# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# 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('_libkombilo', [dirname(__file__)])
        except ImportError:
            import _libkombilo
            return _libkombilo
        if fp is not None:
            try:
                _mod = imp.load_module('_libkombilo', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _libkombilo = swig_import_helper()
    del swig_import_helper
else:
    import _libkombilo
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 Exception:
        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__ = _libkombilo.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def iterator(self):
        return _libkombilo.vectorc_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libkombilo.vectorc___nonzero__(self)

    def __bool__(self):
        return _libkombilo.vectorc___bool__(self)

    def __len__(self):
        return _libkombilo.vectorc___len__(self)

    def __getslice__(self, i, j):
        return _libkombilo.vectorc___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libkombilo.vectorc___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libkombilo.vectorc___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libkombilo.vectorc___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libkombilo.vectorc___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libkombilo.vectorc___setitem__(self, *args)

    def pop(self):
        return _libkombilo.vectorc_pop(self)

    def append(self, x):
        return _libkombilo.vectorc_append(self, x)

    def empty(self):
        return _libkombilo.vectorc_empty(self)

    def size(self):
        return _libkombilo.vectorc_size(self)

    def swap(self, v):
        return _libkombilo.vectorc_swap(self, v)

    def begin(self):
        return _libkombilo.vectorc_begin(self)

    def end(self):
        return _libkombilo.vectorc_end(self)

    def rbegin(self):
        return _libkombilo.vectorc_rbegin(self)

    def rend(self):
        return _libkombilo.vectorc_rend(self)

    def clear(self):
        return _libkombilo.vectorc_clear(self)

    def get_allocator(self):
        return _libkombilo.vectorc_get_allocator(self)

    def pop_back(self):
        return _libkombilo.vectorc_pop_back(self)

    def erase(self, *args):
        return _libkombilo.vectorc_erase(self, *args)

    def __init__(self, *args):
        this = _libkombilo.new_vectorc(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _libkombilo.vectorc_push_back(self, x)

    def front(self):
        return _libkombilo.vectorc_front(self)

    def back(self):
        return _libkombilo.vectorc_back(self)

    def assign(self, n, x):
        return _libkombilo.vectorc_assign(self, n, x)

    def resize(self, *args):
        return _libkombilo.vectorc_resize(self, *args)

    def insert(self, *args):
        return _libkombilo.vectorc_insert(self, *args)

    def reserve(self, n):
        return _libkombilo.vectorc_reserve(self, n)

    def capacity(self):
        return _libkombilo.vectorc_capacity(self)
    __swig_destroy__ = _libkombilo.delete_vectorc
    __del__ = lambda self: None
vectorc_swigregister = _libkombilo.vectorc_swigregister
vectorc_swigregister(vectorc)

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

    def iterator(self):
        return _libkombilo.vectors_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libkombilo.vectors___nonzero__(self)

    def __bool__(self):
        return _libkombilo.vectors___bool__(self)

    def __len__(self):
        return _libkombilo.vectors___len__(self)

    def __getslice__(self, i, j):
        return _libkombilo.vectors___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libkombilo.vectors___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libkombilo.vectors___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libkombilo.vectors___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libkombilo.vectors___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libkombilo.vectors___setitem__(self, *args)

    def pop(self):
        return _libkombilo.vectors_pop(self)

    def append(self, x):
        return _libkombilo.vectors_append(self, x)

    def empty(self):
        return _libkombilo.vectors_empty(self)

    def size(self):
        return _libkombilo.vectors_size(self)

    def swap(self, v):
        return _libkombilo.vectors_swap(self, v)

    def begin(self):
        return _libkombilo.vectors_begin(self)

    def end(self):
        return _libkombilo.vectors_end(self)

    def rbegin(self):
        return _libkombilo.vectors_rbegin(self)

    def rend(self):
        return _libkombilo.vectors_rend(self)

    def clear(self):
        return _libkombilo.vectors_clear(self)

    def get_allocator(self):
        return _libkombilo.vectors_get_allocator(self)

    def pop_back(self):
        return _libkombilo.vectors_pop_back(self)

    def erase(self, *args):
        return _libkombilo.vectors_erase(self, *args)

    def __init__(self, *args):
        this = _libkombilo.new_vectors(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _libkombilo.vectors_push_back(self, x)

    def front(self):
        return _libkombilo.vectors_front(self)

    def back(self):
        return _libkombilo.vectors_back(self)

    def assign(self, n, x):
        return _libkombilo.vectors_assign(self, n, x)

    def resize(self, *args):
        return _libkombilo.vectors_resize(self, *args)

    def insert(self, *args):
        return _libkombilo.vectors_insert(self, *args)

    def reserve(self, n):
        return _libkombilo.vectors_reserve(self, n)

    def capacity(self):
        return _libkombilo.vectors_capacity(self)
    __swig_destroy__ = _libkombilo.delete_vectors
    __del__ = lambda self: None
vectors_swigregister = _libkombilo.vectors_swigregister
vectors_swigregister(vectors)

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

    def iterator(self):
        return _libkombilo.vectori_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libkombilo.vectori___nonzero__(self)

    def __bool__(self):
        return _libkombilo.vectori___bool__(self)

    def __len__(self):
        return _libkombilo.vectori___len__(self)

    def __getslice__(self, i, j):
        return _libkombilo.vectori___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libkombilo.vectori___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libkombilo.vectori___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libkombilo.vectori___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libkombilo.vectori___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libkombilo.vectori___setitem__(self, *args)

    def pop(self):
        return _libkombilo.vectori_pop(self)

    def append(self, x):
        return _libkombilo.vectori_append(self, x)

    def empty(self):
        return _libkombilo.vectori_empty(self)

    def size(self):
        return _libkombilo.vectori_size(self)

    def swap(self, v):
        return _libkombilo.vectori_swap(self, v)

    def begin(self):
        return _libkombilo.vectori_begin(self)

    def end(self):
        return _libkombilo.vectori_end(self)

    def rbegin(self):
        return _libkombilo.vectori_rbegin(self)

    def rend(self):
        return _libkombilo.vectori_rend(self)

    def clear(self):
        return _libkombilo.vectori_clear(self)

    def get_allocator(self):
        return _libkombilo.vectori_get_allocator(self)

    def pop_back(self):
        return _libkombilo.vectori_pop_back(self)

    def erase(self, *args):
        return _libkombilo.vectori_erase(self, *args)

    def __init__(self, *args):
        this = _libkombilo.new_vectori(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _libkombilo.vectori_push_back(self, x)

    def front(self):
        return _libkombilo.vectori_front(self)

    def back(self):
        return _libkombilo.vectori_back(self)

    def assign(self, n, x):
        return _libkombilo.vectori_assign(self, n, x)

    def resize(self, *args):
        return _libkombilo.vectori_resize(self, *args)

    def insert(self, *args):
        return _libkombilo.vectori_insert(self, *args)

    def reserve(self, n):
        return _libkombilo.vectori_reserve(self, n)

    def capacity(self):
        return _libkombilo.vectori_capacity(self)
    __swig_destroy__ = _libkombilo.delete_vectori
    __del__ = lambda self: None
vectori_swigregister = _libkombilo.vectori_swigregister
vectori_swigregister(vectori)

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

    def __init__(self, *args):
        this = _libkombilo.new_pairii(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_setmethods__["first"] = _libkombilo.pairii_first_set
    __swig_getmethods__["first"] = _libkombilo.pairii_first_get
    if _newclass:
        first = _swig_property(_libkombilo.pairii_first_get, _libkombilo.pairii_first_set)
    __swig_setmethods__["second"] = _libkombilo.pairii_second_set
    __swig_getmethods__["second"] = _libkombilo.pairii_second_get
    if _newclass:
        second = _swig_property(_libkombilo.pairii_second_get, _libkombilo.pairii_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _libkombilo.delete_pairii
    __del__ = lambda self: None
pairii_swigregister = _libkombilo.pairii_swigregister
pairii_swigregister(pairii)

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

    def iterator(self):
        return _libkombilo.vectorii_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libkombilo.vectorii___nonzero__(self)

    def __bool__(self):
        return _libkombilo.vectorii___bool__(self)

    def __len__(self):
        return _libkombilo.vectorii___len__(self)

    def __getslice__(self, i, j):
        return _libkombilo.vectorii___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libkombilo.vectorii___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libkombilo.vectorii___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libkombilo.vectorii___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libkombilo.vectorii___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libkombilo.vectorii___setitem__(self, *args)

    def pop(self):
        return _libkombilo.vectorii_pop(self)

    def append(self, x):
        return _libkombilo.vectorii_append(self, x)

    def empty(self):
        return _libkombilo.vectorii_empty(self)

    def size(self):
        return _libkombilo.vectorii_size(self)

    def swap(self, v):
        return _libkombilo.vectorii_swap(self, v)

    def begin(self):
        return _libkombilo.vectorii_begin(self)

    def end(self):
        return _libkombilo.vectorii_end(self)

    def rbegin(self):
        return _libkombilo.vectorii_rbegin(self)

    def rend(self):
        return _libkombilo.vectorii_rend(self)

    def clear(self):
        return _libkombilo.vectorii_clear(self)

    def get_allocator(self):
        return _libkombilo.vectorii_get_allocator(self)

    def pop_back(self):
        return _libkombilo.vectorii_pop_back(self)

    def erase(self, *args):
        return _libkombilo.vectorii_erase(self, *args)

    def __init__(self, *args):
        this = _libkombilo.new_vectorii(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _libkombilo.vectorii_push_back(self, x)

    def front(self):
        return _libkombilo.vectorii_front(self)

    def back(self):
        return _libkombilo.vectorii_back(self)

    def assign(self, n, x):
        return _libkombilo.vectorii_assign(self, n, x)

    def resize(self, *args):
        return _libkombilo.vectorii_resize(self, *args)

    def insert(self, *args):
        return _libkombilo.vectorii_insert(self, *args)

    def reserve(self, n):
        return _libkombilo.vectorii_reserve(self, n)

    def capacity(self):
        return _libkombilo.vectorii_capacity(self)
    __swig_destroy__ = _libkombilo.delete_vectorii
    __del__ = lambda self: None
vectorii_swigregister = _libkombilo.vectorii_swigregister
vectorii_swigregister(vectorii)

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

    def iterator(self):
        return _libkombilo.mapsvi_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libkombilo.mapsvi___nonzero__(self)

    def __bool__(self):
        return _libkombilo.mapsvi___bool__(self)

    def __len__(self):
        return _libkombilo.mapsvi___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, key):
        return _libkombilo.mapsvi___getitem__(self, key)

    def __delitem__(self, key):
        return _libkombilo.mapsvi___delitem__(self, key)

    def has_key(self, key):
        return _libkombilo.mapsvi_has_key(self, key)

    def keys(self):
        return _libkombilo.mapsvi_keys(self)

    def values(self):
        return _libkombilo.mapsvi_values(self)

    def items(self):
        return _libkombilo.mapsvi_items(self)

    def __contains__(self, key):
        return _libkombilo.mapsvi___contains__(self, key)

    def key_iterator(self):
        return _libkombilo.mapsvi_key_iterator(self)

    def value_iterator(self):
        return _libkombilo.mapsvi_value_iterator(self)

    def __setitem__(self, *args):
        return _libkombilo.mapsvi___setitem__(self, *args)

    def asdict(self):
        return _libkombilo.mapsvi_asdict(self)

    def __init__(self, *args):
        this = _libkombilo.new_mapsvi(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        return _libkombilo.mapsvi_empty(self)

    def size(self):
        return _libkombilo.mapsvi_size(self)

    def swap(self, v):
        return _libkombilo.mapsvi_swap(self, v)

    def begin(self):
        return _libkombilo.mapsvi_begin(self)

    def end(self):
        return _libkombilo.mapsvi_end(self)

    def rbegin(self):
        return _libkombilo.mapsvi_rbegin(self)

    def rend(self):
        return _libkombilo.mapsvi_rend(self)

    def clear(self):
        return _libkombilo.mapsvi_clear(self)

    def get_allocator(self):
        return _libkombilo.mapsvi_get_allocator(self)

    def count(self, x):
        return _libkombilo.mapsvi_count(self, x)

    def erase(self, *args):
        return _libkombilo.mapsvi_erase(self, *args)

    def find(self, x):
        return _libkombilo.mapsvi_find(self, x)

    def lower_bound(self, x):
        return _libkombilo.mapsvi_lower_bound(self, x)

    def upper_bound(self, x):
        return _libkombilo.mapsvi_upper_bound(self, x)
    __swig_destroy__ = _libkombilo.delete_mapsvi
    __del__ = lambda self: None
mapsvi_swigregister = _libkombilo.mapsvi_swigregister
mapsvi_swigregister(mapsvi)

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

    def __init__(self):
        this = _libkombilo.new_SGFError()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_SGFError
    __del__ = lambda self: None
SGFError_swigregister = _libkombilo.SGFError_swigregister
SGFError_swigregister(SGFError)

class ExtendedMoveNumber(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExtendedMoveNumber, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExtendedMoveNumber, name)
    __repr__ = _swig_repr
    __swig_setmethods__["length"] = _libkombilo.ExtendedMoveNumber_length_set
    __swig_getmethods__["length"] = _libkombilo.ExtendedMoveNumber_length_get
    if _newclass:
        length = _swig_property(_libkombilo.ExtendedMoveNumber_length_get, _libkombilo.ExtendedMoveNumber_length_set)
    __swig_setmethods__["data"] = _libkombilo.ExtendedMoveNumber_data_set
    __swig_getmethods__["data"] = _libkombilo.ExtendedMoveNumber_data_get
    if _newclass:
        data = _swig_property(_libkombilo.ExtendedMoveNumber_data_get, _libkombilo.ExtendedMoveNumber_data_set)

    def __init__(self, *args):
        this = _libkombilo.new_ExtendedMoveNumber(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_ExtendedMoveNumber
    __del__ = lambda self: None

    def next(self):
        return _libkombilo.ExtendedMoveNumber_next(self)

    def down(self):
        return _libkombilo.ExtendedMoveNumber_down(self)

    def total_move_num(self):
        return _libkombilo.ExtendedMoveNumber_total_move_num(self)
ExtendedMoveNumber_swigregister = _libkombilo.ExtendedMoveNumber_swigregister
ExtendedMoveNumber_swigregister(ExtendedMoveNumber)


def SGFescape(s):
    return _libkombilo.SGFescape(s)
SGFescape = _libkombilo.SGFescape
class PropValue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PropValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PropValue, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _libkombilo.new_PropValue(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_PropValue
    __del__ = lambda self: None
    __swig_setmethods__["IDcomplete"] = _libkombilo.PropValue_IDcomplete_set
    __swig_getmethods__["IDcomplete"] = _libkombilo.PropValue_IDcomplete_get
    if _newclass:
        IDcomplete = _swig_property(_libkombilo.PropValue_IDcomplete_get, _libkombilo.PropValue_IDcomplete_set)
    __swig_setmethods__["pv"] = _libkombilo.PropValue_pv_set
    __swig_getmethods__["pv"] = _libkombilo.PropValue_pv_get
    if _newclass:
        pv = _swig_property(_libkombilo.PropValue_pv_get, _libkombilo.PropValue_pv_set)
PropValue_swigregister = _libkombilo.PropValue_swigregister
PropValue_swigregister(PropValue)

class Node(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Node, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Node, name)
    __repr__ = _swig_repr
    __swig_setmethods__["previous"] = _libkombilo.Node_previous_set
    __swig_getmethods__["previous"] = _libkombilo.Node_previous_get
    if _newclass:
        previous = _swig_property(_libkombilo.Node_previous_get, _libkombilo.Node_previous_set)
    __swig_setmethods__["next"] = _libkombilo.Node_next_set
    __swig_getmethods__["next"] = _libkombilo.Node_next_get
    if _newclass:
        next = _swig_property(_libkombilo.Node_next_get, _libkombilo.Node_next_set)
    __swig_setmethods__["up"] = _libkombilo.Node_up_set
    __swig_getmethods__["up"] = _libkombilo.Node_up_get
    if _newclass:
        up = _swig_property(_libkombilo.Node_up_get, _libkombilo.Node_up_set)
    __swig_setmethods__["down"] = _libkombilo.Node_down_set
    __swig_getmethods__["down"] = _libkombilo.Node_down_get
    if _newclass:
        down = _swig_property(_libkombilo.Node_down_get, _libkombilo.Node_down_set)
    __swig_setmethods__["numChildren"] = _libkombilo.Node_numChildren_set
    __swig_getmethods__["numChildren"] = _libkombilo.Node_numChildren_get
    if _newclass:
        numChildren = _swig_property(_libkombilo.Node_numChildren_get, _libkombilo.Node_numChildren_set)
    __swig_setmethods__["SGFstring"] = _libkombilo.Node_SGFstring_set
    __swig_getmethods__["SGFstring"] = _libkombilo.Node_SGFstring_get
    if _newclass:
        SGFstring = _swig_property(_libkombilo.Node_SGFstring_get, _libkombilo.Node_SGFstring_set)
    __swig_setmethods__["parsed"] = _libkombilo.Node_parsed_set
    __swig_getmethods__["parsed"] = _libkombilo.Node_parsed_get
    if _newclass:
        parsed = _swig_property(_libkombilo.Node_parsed_get, _libkombilo.Node_parsed_set)

    def gpv(self, prop):
        return _libkombilo.Node_gpv(self, prop)

    def get_property_value(self, prop):
        return _libkombilo.Node_get_property_value(self, prop)

    def set_property_value(self, IDcomplete, propValue):
        return _libkombilo.Node_set_property_value(self, IDcomplete, propValue)

    def add_property_value(self, IDcomplete, propValue):
        return _libkombilo.Node_add_property_value(self, IDcomplete, propValue)

    def del_property_value(self, IDcomplete):
        return _libkombilo.Node_del_property_value(self, IDcomplete)

    def keys(self):
        return _libkombilo.Node_keys(self)
    __swig_setmethods__["posyD"] = _libkombilo.Node_posyD_set
    __swig_getmethods__["posyD"] = _libkombilo.Node_posyD_get
    if _newclass:
        posyD = _swig_property(_libkombilo.Node_posyD_get, _libkombilo.Node_posyD_set)

    def __init__(self, prev, SGFst):
        this = _libkombilo.new_Node(prev, SGFst)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_Node
    __del__ = lambda self: None

    def get_move_number(self):
        return _libkombilo.Node_get_move_number(self)

    def parseNode(self):
        return _libkombilo.Node_parseNode(self)
    __swig_setmethods__["sloppy"] = _libkombilo.Node_sloppy_set
    __swig_getmethods__["sloppy"] = _libkombilo.Node_sloppy_get
    if _newclass:
        sloppy = _swig_property(_libkombilo.Node_sloppy_get, _libkombilo.Node_sloppy_set)
    __swig_setmethods__["level"] = _libkombilo.Node_level_set
    __swig_getmethods__["level"] = _libkombilo.Node_level_get
    if _newclass:
        level = _swig_property(_libkombilo.Node_level_get, _libkombilo.Node_level_set)
Node_swigregister = _libkombilo.Node_swigregister
Node_swigregister(Node)
cvar = _libkombilo.cvar


def parseRootNode(n, tags):
    return _libkombilo.parseRootNode(n, tags)
parseRootNode = _libkombilo.parseRootNode
class Cursor(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cursor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Cursor, name)
    __repr__ = _swig_repr

    def __init__(self, sgf, sloppy):
        this = _libkombilo.new_Cursor(sgf, sloppy)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_Cursor
    __del__ = lambda self: None
    __swig_setmethods__["atStart"] = _libkombilo.Cursor_atStart_set
    __swig_getmethods__["atStart"] = _libkombilo.Cursor_atStart_get
    if _newclass:
        atStart = _swig_property(_libkombilo.Cursor_atStart_get, _libkombilo.Cursor_atStart_set)
    __swig_setmethods__["atEnd"] = _libkombilo.Cursor_atEnd_set
    __swig_getmethods__["atEnd"] = _libkombilo.Cursor_atEnd_get
    if _newclass:
        atEnd = _swig_property(_libkombilo.Cursor_atEnd_get, _libkombilo.Cursor_atEnd_set)
    __swig_setmethods__["height"] = _libkombilo.Cursor_height_set
    __swig_getmethods__["height"] = _libkombilo.Cursor_height_get
    if _newclass:
        height = _swig_property(_libkombilo.Cursor_height_get, _libkombilo.Cursor_height_set)
    __swig_setmethods__["width"] = _libkombilo.Cursor_width_set
    __swig_getmethods__["width"] = _libkombilo.Cursor_width_get
    if _newclass:
        width = _swig_property(_libkombilo.Cursor_width_get, _libkombilo.Cursor_width_set)
    __swig_setmethods__["root"] = _libkombilo.Cursor_root_set
    __swig_getmethods__["root"] = _libkombilo.Cursor_root_get
    if _newclass:
        root = _swig_property(_libkombilo.Cursor_root_get, _libkombilo.Cursor_root_set)
    __swig_setmethods__["currentN"] = _libkombilo.Cursor_currentN_set
    __swig_getmethods__["currentN"] = _libkombilo.Cursor_currentN_get
    if _newclass:
        currentN = _swig_property(_libkombilo.Cursor_currentN_get, _libkombilo.Cursor_currentN_set)
    __swig_setmethods__["posx"] = _libkombilo.Cursor_posx_set
    __swig_getmethods__["posx"] = _libkombilo.Cursor_posx_get
    if _newclass:
        posx = _swig_property(_libkombilo.Cursor_posx_get, _libkombilo.Cursor_posx_set)
    __swig_setmethods__["posy"] = _libkombilo.Cursor_posy_set
    __swig_getmethods__["posy"] = _libkombilo.Cursor_posy_get
    if _newclass:
        posy = _swig_property(_libkombilo.Cursor_posy_get, _libkombilo.Cursor_posy_set)

    def parse(self, s):
        return _libkombilo.Cursor_parse(self, s)

    def game(self, n):
        return _libkombilo.Cursor_game(self, n)

    def next(self, n=0):
        return _libkombilo.Cursor_next(self, n)

    def previous(self):
        return _libkombilo.Cursor_previous(self)

    def getRootNode(self, n):
        return _libkombilo.Cursor_getRootNode(self, n)

    def outputVar(self, node):
        return _libkombilo.Cursor_outputVar(self, node)

    def output(self):
        return _libkombilo.Cursor_output(self)

    def add(self, st):
        return _libkombilo.Cursor_add(self, st)

    def delVariation(self, node):
        return _libkombilo.Cursor_delVariation(self, node)

    def setFlags(self):
        return _libkombilo.Cursor_setFlags(self)
Cursor_swigregister = _libkombilo.Cursor_swigregister
Cursor_swigregister(Cursor)


def nodeToString(data):
    return _libkombilo.nodeToString(data)
nodeToString = _libkombilo.nodeToString
class BoardError(Exception):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoardError, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BoardError, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _libkombilo.new_BoardError()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_BoardError
    __del__ = lambda self: None
BoardError_swigregister = _libkombilo.BoardError_swigregister
BoardError_swigregister(BoardError)

class MoveNC(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MoveNC, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MoveNC, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _libkombilo.MoveNC_x_set
    __swig_getmethods__["x"] = _libkombilo.MoveNC_x_get
    if _newclass:
        x = _swig_property(_libkombilo.MoveNC_x_get, _libkombilo.MoveNC_x_set)
    __swig_setmethods__["y"] = _libkombilo.MoveNC_y_set
    __swig_getmethods__["y"] = _libkombilo.MoveNC_y_get
    if _newclass:
        y = _swig_property(_libkombilo.MoveNC_y_get, _libkombilo.MoveNC_y_set)
    __swig_setmethods__["color"] = _libkombilo.MoveNC_color_set
    __swig_getmethods__["color"] = _libkombilo.MoveNC_color_get
    if _newclass:
        color = _swig_property(_libkombilo.MoveNC_color_get, _libkombilo.MoveNC_color_set)

    def __init__(self, *args):
        this = _libkombilo.new_MoveNC(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __eq__(self, mnc):
        return _libkombilo.MoveNC___eq__(self, mnc)
    __swig_destroy__ = _libkombilo.delete_MoveNC
    __del__ = lambda self: None
MoveNC_swigregister = _libkombilo.MoveNC_swigregister
MoveNC_swigregister(MoveNC)
AB = cvar.AB
AW = cvar.AW
AEB = cvar.AEB
AEW = cvar.AEW

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

    def __init__(self, *args):
        this = _libkombilo.new_Move(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_Move
    __del__ = lambda self: None
    __swig_setmethods__["captures"] = _libkombilo.Move_captures_set
    __swig_getmethods__["captures"] = _libkombilo.Move_captures_get
    if _newclass:
        captures = _swig_property(_libkombilo.Move_captures_get, _libkombilo.Move_captures_set)
Move_swigregister = _libkombilo.Move_swigregister
Move_swigregister(Move)

class abstractBoard(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, abstractBoard, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, abstractBoard, name)
    __repr__ = _swig_repr
    __swig_setmethods__["boardsize"] = _libkombilo.abstractBoard_boardsize_set
    __swig_getmethods__["boardsize"] = _libkombilo.abstractBoard_boardsize_get
    if _newclass:
        boardsize = _swig_property(_libkombilo.abstractBoard_boardsize_get, _libkombilo.abstractBoard_boardsize_set)
    __swig_setmethods__["undostack"] = _libkombilo.abstractBoard_undostack_set
    __swig_getmethods__["undostack"] = _libkombilo.abstractBoard_undostack_get
    if _newclass:
        undostack = _swig_property(_libkombilo.abstractBoard_undostack_get, _libkombilo.abstractBoard_undostack_set)

    def __init__(self, *args):
        this = _libkombilo.new_abstractBoard(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_abstractBoard
    __del__ = lambda self: None

    def clear(self):
        return _libkombilo.abstractBoard_clear(self)

    def play(self, x, y, color):
        return _libkombilo.abstractBoard_play(self, x, y, color)

    def undo(self, n=1):
        return _libkombilo.abstractBoard_undo(self, n)

    def remove(self, x, y, removeFromUndostack):
        return _libkombilo.abstractBoard_remove(self, x, y, removeFromUndostack)

    def getStatus(self, x, y):
        return _libkombilo.abstractBoard_getStatus(self, x, y)

    def setStatus(self, x, y, val):
        return _libkombilo.abstractBoard_setStatus(self, x, y, val)

    def len_cap_last(self):
        return _libkombilo.abstractBoard_len_cap_last(self)

    def undostack_append_pass(self):
        return _libkombilo.abstractBoard_undostack_append_pass(self)

    def undostack_top_pos(self):
        return _libkombilo.abstractBoard_undostack_top_pos(self)

    def undostack_top_color(self):
        return _libkombilo.abstractBoard_undostack_top_color(self)

    def undostack_top_captures(self):
        return _libkombilo.abstractBoard_undostack_top_captures(self)

    def undostack_push(self, m):
        return _libkombilo.abstractBoard_undostack_push(self, m)

    def undostack_pop(self):
        return _libkombilo.abstractBoard_undostack_pop(self)
abstractBoard_swigregister = _libkombilo.abstractBoard_swigregister
abstractBoard_swigregister(abstractBoard)


def flipped_sig(f, sig, boardsize):
    return _libkombilo.flipped_sig(f, sig, boardsize)
flipped_sig = _libkombilo.flipped_sig

def symmetrize(sig, boardsize):
    return _libkombilo.symmetrize(sig, boardsize)
symmetrize = _libkombilo.symmetrize
class PatternError(Exception):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PatternError, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PatternError, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _libkombilo.new_PatternError()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_PatternError
    __del__ = lambda self: None
PatternError_swigregister = _libkombilo.PatternError_swigregister
PatternError_swigregister(PatternError)
NOT_HASHABLE = cvar.NOT_HASHABLE
NO_CONT = cvar.NO_CONT
CORNER_NW_PATTERN = cvar.CORNER_NW_PATTERN
CORNER_NE_PATTERN = cvar.CORNER_NE_PATTERN
CORNER_SW_PATTERN = cvar.CORNER_SW_PATTERN
CORNER_SE_PATTERN = cvar.CORNER_SE_PATTERN
SIDE_N_PATTERN = cvar.SIDE_N_PATTERN
SIDE_W_PATTERN = cvar.SIDE_W_PATTERN
SIDE_E_PATTERN = cvar.SIDE_E_PATTERN
SIDE_S_PATTERN = cvar.SIDE_S_PATTERN
CENTER_PATTERN = cvar.CENTER_PATTERN
FULLBOARD_PATTERN = cvar.FULLBOARD_PATTERN
ALGO_FINALPOS = cvar.ALGO_FINALPOS
ALGO_MOVELIST = cvar.ALGO_MOVELIST
ALGO_HASH_FULL = cvar.ALGO_HASH_FULL
ALGO_HASH_CORNER = cvar.ALGO_HASH_CORNER
ALGO_HASH_CENTER = cvar.ALGO_HASH_CENTER
ALGO_HASH_SIDE = cvar.ALGO_HASH_SIDE
algo_finalpos = cvar.algo_finalpos
algo_movelist = cvar.algo_movelist
algo_hash_full = cvar.algo_hash_full
algo_hash_corner = cvar.algo_hash_corner
algo_intervals = cvar.algo_intervals
algo_hash_center = cvar.algo_hash_center
algo_hash_side = cvar.algo_hash_side
DATE_PROFILE_START = cvar.DATE_PROFILE_START
DATE_PROFILE_END = cvar.DATE_PROFILE_END

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

    def __init__(self):
        this = _libkombilo.new_DBError()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_DBError
    __del__ = lambda self: None
DBError_swigregister = _libkombilo.DBError_swigregister
DBError_swigregister(DBError)

class Symmetries(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Symmetries, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Symmetries, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dataX"] = _libkombilo.Symmetries_dataX_set
    __swig_getmethods__["dataX"] = _libkombilo.Symmetries_dataX_get
    if _newclass:
        dataX = _swig_property(_libkombilo.Symmetries_dataX_get, _libkombilo.Symmetries_dataX_set)
    __swig_setmethods__["dataY"] = _libkombilo.Symmetries_dataY_set
    __swig_getmethods__["dataY"] = _libkombilo.Symmetries_dataY_get
    if _newclass:
        dataY = _swig_property(_libkombilo.Symmetries_dataY_get, _libkombilo.Symmetries_dataY_set)
    __swig_setmethods__["dataCS"] = _libkombilo.Symmetries_dataCS_set
    __swig_getmethods__["dataCS"] = _libkombilo.Symmetries_dataCS_get
    if _newclass:
        dataCS = _swig_property(_libkombilo.Symmetries_dataCS_get, _libkombilo.Symmetries_dataCS_set)
    __swig_setmethods__["sizeX"] = _libkombilo.Symmetries_sizeX_set
    __swig_getmethods__["sizeX"] = _libkombilo.Symmetries_sizeX_get
    if _newclass:
        sizeX = _swig_property(_libkombilo.Symmetries_sizeX_get, _libkombilo.Symmetries_sizeX_set)
    __swig_setmethods__["sizeY"] = _libkombilo.Symmetries_sizeY_set
    __swig_getmethods__["sizeY"] = _libkombilo.Symmetries_sizeY_get
    if _newclass:
        sizeY = _swig_property(_libkombilo.Symmetries_sizeY_get, _libkombilo.Symmetries_sizeY_set)
    __swig_destroy__ = _libkombilo.delete_Symmetries
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _libkombilo.new_Symmetries(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set(self, i, j, k, l, cs):
        return _libkombilo.Symmetries_set(self, i, j, k, l, cs)

    def getX(self, i, j):
        return _libkombilo.Symmetries_getX(self, i, j)

    def getY(self, i, j):
        return _libkombilo.Symmetries_getY(self, i, j)

    def getCS(self, i, j):
        return _libkombilo.Symmetries_getCS(self, i, j)

    def has_key(self, i, j):
        return _libkombilo.Symmetries_has_key(self, i, j)
Symmetries_swigregister = _libkombilo.Symmetries_swigregister
Symmetries_swigregister(Symmetries)

class Pattern(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pattern, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Pattern, name)
    __repr__ = _swig_repr
    __swig_setmethods__["left"] = _libkombilo.Pattern_left_set
    __swig_getmethods__["left"] = _libkombilo.Pattern_left_get
    if _newclass:
        left = _swig_property(_libkombilo.Pattern_left_get, _libkombilo.Pattern_left_set)
    __swig_setmethods__["right"] = _libkombilo.Pattern_right_set
    __swig_getmethods__["right"] = _libkombilo.Pattern_right_get
    if _newclass:
        right = _swig_property(_libkombilo.Pattern_right_get, _libkombilo.Pattern_right_set)
    __swig_setmethods__["bottom"] = _libkombilo.Pattern_bottom_set
    __swig_getmethods__["bottom"] = _libkombilo.Pattern_bottom_get
    if _newclass:
        bottom = _swig_property(_libkombilo.Pattern_bottom_get, _libkombilo.Pattern_bottom_set)
    __swig_setmethods__["top"] = _libkombilo.Pattern_top_set
    __swig_getmethods__["top"] = _libkombilo.Pattern_top_get
    if _newclass:
        top = _swig_property(_libkombilo.Pattern_top_get, _libkombilo.Pattern_top_set)
    __swig_setmethods__["boardsize"] = _libkombilo.Pattern_boardsize_set
    __swig_getmethods__["boardsize"] = _libkombilo.Pattern_boardsize_get
    if _newclass:
        boardsize = _swig_property(_libkombilo.Pattern_boardsize_get, _libkombilo.Pattern_boardsize_set)
    __swig_setmethods__["sizeX"] = _libkombilo.Pattern_sizeX_set
    __swig_getmethods__["sizeX"] = _libkombilo.Pattern_sizeX_get
    if _newclass:
        sizeX = _swig_property(_libkombilo.Pattern_sizeX_get, _libkombilo.Pattern_sizeX_set)
    __swig_setmethods__["sizeY"] = _libkombilo.Pattern_sizeY_set
    __swig_getmethods__["sizeY"] = _libkombilo.Pattern_sizeY_get
    if _newclass:
        sizeY = _swig_property(_libkombilo.Pattern_sizeY_get, _libkombilo.Pattern_sizeY_set)
    __swig_setmethods__["flip"] = _libkombilo.Pattern_flip_set
    __swig_getmethods__["flip"] = _libkombilo.Pattern_flip_get
    if _newclass:
        flip = _swig_property(_libkombilo.Pattern_flip_get, _libkombilo.Pattern_flip_set)
    __swig_setmethods__["colorSwitch"] = _libkombilo.Pattern_colorSwitch_set
    __swig_getmethods__["colorSwitch"] = _libkombilo.Pattern_colorSwitch_get
    if _newclass:
        colorSwitch = _swig_property(_libkombilo.Pattern_colorSwitch_get, _libkombilo.Pattern_colorSwitch_set)
    __swig_setmethods__["initialPos"] = _libkombilo.Pattern_initialPos_set
    __swig_getmethods__["initialPos"] = _libkombilo.Pattern_initialPos_get
    if _newclass:
        initialPos = _swig_property(_libkombilo.Pattern_initialPos_get, _libkombilo.Pattern_initialPos_set)
    __swig_setmethods__["finalPos"] = _libkombilo.Pattern_finalPos_set
    __swig_getmethods__["finalPos"] = _libkombilo.Pattern_finalPos_get
    if _newclass:
        finalPos = _swig_property(_libkombilo.Pattern_finalPos_get, _libkombilo.Pattern_finalPos_set)
    __swig_setmethods__["contLabels"] = _libkombilo.Pattern_contLabels_set
    __swig_getmethods__["contLabels"] = _libkombilo.Pattern_contLabels_get
    if _newclass:
        contLabels = _swig_property(_libkombilo.Pattern_contLabels_get, _libkombilo.Pattern_contLabels_set)
    __swig_setmethods__["contList"] = _libkombilo.Pattern_contList_set
    __swig_getmethods__["contList"] = _libkombilo.Pattern_contList_get
    if _newclass:
        contList = _swig_property(_libkombilo.Pattern_contList_get, _libkombilo.Pattern_contList_set)

    def __init__(self, *args):
        this = _libkombilo.new_Pattern(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_Pattern
    __del__ = lambda self: None

    def copy(self, p):
        return _libkombilo.Pattern_copy(self, p)

    def getInitial(self, i, j):
        return _libkombilo.Pattern_getInitial(self, i, j)

    def getFinal(self, i, j):
        return _libkombilo.Pattern_getFinal(self, i, j)

    def BW2XO(self, c):
        return _libkombilo.Pattern_BW2XO(self, c)

    def __eq__(self, p):
        return _libkombilo.Pattern___eq__(self, p)

    def printPattern(self):
        return _libkombilo.Pattern_printPattern(self)

    def to_snv(self, snv):
        return _libkombilo.Pattern_to_snv(self, snv)
    __swig_getmethods__["flipsX"] = lambda x: _libkombilo.Pattern_flipsX
    if _newclass:
        flipsX = staticmethod(_libkombilo.Pattern_flipsX)
    __swig_getmethods__["flipsY"] = lambda x: _libkombilo.Pattern_flipsY
    if _newclass:
        flipsY = staticmethod(_libkombilo.Pattern_flipsY)
    __swig_getmethods__["PatternInvFlip"] = lambda x: _libkombilo.Pattern_PatternInvFlip
    if _newclass:
        PatternInvFlip = staticmethod(_libkombilo.Pattern_PatternInvFlip)
    __swig_getmethods__["compose_flips"] = lambda x: _libkombilo.Pattern_compose_flips
    if _newclass:
        compose_flips = staticmethod(_libkombilo.Pattern_compose_flips)
Pattern_swigregister = _libkombilo.Pattern_swigregister
Pattern_swigregister(Pattern)

def Pattern_flipsX(i, x, y, XX, YY):
    return _libkombilo.Pattern_flipsX(i, x, y, XX, YY)
Pattern_flipsX = _libkombilo.Pattern_flipsX

def Pattern_flipsY(i, x, y, XX, YY):
    return _libkombilo.Pattern_flipsY(i, x, y, XX, YY)
Pattern_flipsY = _libkombilo.Pattern_flipsY

def Pattern_PatternInvFlip(i):
    return _libkombilo.Pattern_PatternInvFlip(i)
Pattern_PatternInvFlip = _libkombilo.Pattern_PatternInvFlip

def Pattern_compose_flips(i, j):
    return _libkombilo.Pattern_compose_flips(i, j)
Pattern_compose_flips = _libkombilo.Pattern_compose_flips

class Continuation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Continuation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Continuation, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _libkombilo.Continuation_x_set
    __swig_getmethods__["x"] = _libkombilo.Continuation_x_get
    if _newclass:
        x = _swig_property(_libkombilo.Continuation_x_get, _libkombilo.Continuation_x_set)
    __swig_setmethods__["y"] = _libkombilo.Continuation_y_set
    __swig_getmethods__["y"] = _libkombilo.Continuation_y_get
    if _newclass:
        y = _swig_property(_libkombilo.Continuation_y_get, _libkombilo.Continuation_y_set)
    __swig_setmethods__["B"] = _libkombilo.Continuation_B_set
    __swig_getmethods__["B"] = _libkombilo.Continuation_B_get
    if _newclass:
        B = _swig_property(_libkombilo.Continuation_B_get, _libkombilo.Continuation_B_set)
    __swig_setmethods__["W"] = _libkombilo.Continuation_W_set
    __swig_getmethods__["W"] = _libkombilo.Continuation_W_get
    if _newclass:
        W = _swig_property(_libkombilo.Continuation_W_get, _libkombilo.Continuation_W_set)
    __swig_setmethods__["tB"] = _libkombilo.Continuation_tB_set
    __swig_getmethods__["tB"] = _libkombilo.Continuation_tB_get
    if _newclass:
        tB = _swig_property(_libkombilo.Continuation_tB_get, _libkombilo.Continuation_tB_set)
    __swig_setmethods__["tW"] = _libkombilo.Continuation_tW_set
    __swig_getmethods__["tW"] = _libkombilo.Continuation_tW_get
    if _newclass:
        tW = _swig_property(_libkombilo.Continuation_tW_get, _libkombilo.Continuation_tW_set)
    __swig_setmethods__["wB"] = _libkombilo.Continuation_wB_set
    __swig_getmethods__["wB"] = _libkombilo.Continuation_wB_get
    if _newclass:
        wB = _swig_property(_libkombilo.Continuation_wB_get, _libkombilo.Continuation_wB_set)
    __swig_setmethods__["lB"] = _libkombilo.Continuation_lB_set
    __swig_getmethods__["lB"] = _libkombilo.Continuation_lB_get
    if _newclass:
        lB = _swig_property(_libkombilo.Continuation_lB_get, _libkombilo.Continuation_lB_set)
    __swig_setmethods__["wW"] = _libkombilo.Continuation_wW_set
    __swig_getmethods__["wW"] = _libkombilo.Continuation_wW_get
    if _newclass:
        wW = _swig_property(_libkombilo.Continuation_wW_get, _libkombilo.Continuation_wW_set)
    __swig_setmethods__["lW"] = _libkombilo.Continuation_lW_set
    __swig_getmethods__["lW"] = _libkombilo.Continuation_lW_get
    if _newclass:
        lW = _swig_property(_libkombilo.Continuation_lW_get, _libkombilo.Continuation_lW_set)
    __swig_setmethods__["dates_B"] = _libkombilo.Continuation_dates_B_set
    __swig_getmethods__["dates_B"] = _libkombilo.Continuation_dates_B_get
    if _newclass:
        dates_B = _swig_property(_libkombilo.Continuation_dates_B_get, _libkombilo.Continuation_dates_B_set)
    __swig_setmethods__["dates_W"] = _libkombilo.Continuation_dates_W_set
    __swig_getmethods__["dates_W"] = _libkombilo.Continuation_dates_W_get
    if _newclass:
        dates_W = _swig_property(_libkombilo.Continuation_dates_W_get, _libkombilo.Continuation_dates_W_set)
    __swig_setmethods__["label"] = _libkombilo.Continuation_label_set
    __swig_getmethods__["label"] = _libkombilo.Continuation_label_get
    if _newclass:
        label = _swig_property(_libkombilo.Continuation_label_get, _libkombilo.Continuation_label_set)
    __swig_setmethods__["gamelist"] = _libkombilo.Continuation_gamelist_set
    __swig_getmethods__["gamelist"] = _libkombilo.Continuation_gamelist_get
    if _newclass:
        gamelist = _swig_property(_libkombilo.Continuation_gamelist_get, _libkombilo.Continuation_gamelist_set)

    def __init__(self, *args):
        this = _libkombilo.new_Continuation(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def add(self, c):
        return _libkombilo.Continuation_add(self, c)

    def earliest(self):
        return _libkombilo.Continuation_earliest(self)

    def earliest_B(self):
        return _libkombilo.Continuation_earliest_B(self)

    def earliest_W(self):
        return _libkombilo.Continuation_earliest_W(self)

    def latest(self):
        return _libkombilo.Continuation_latest(self)

    def latest_B(self):
        return _libkombilo.Continuation_latest_B(self)

    def latest_W(self):
        return _libkombilo.Continuation_latest_W(self)

    def average_date(self):
        return _libkombilo.Continuation_average_date(self)

    def average_date_B(self):
        return _libkombilo.Continuation_average_date_B(self)

    def average_date_W(self):
        return _libkombilo.Continuation_average_date_W(self)

    def became_popular(self):
        return _libkombilo.Continuation_became_popular(self)

    def became_popular_B(self):
        return _libkombilo.Continuation_became_popular_B(self)

    def became_popular_W(self):
        return _libkombilo.Continuation_became_popular_W(self)

    def became_unpopular(self):
        return _libkombilo.Continuation_became_unpopular(self)

    def became_unpopular_B(self):
        return _libkombilo.Continuation_became_unpopular_B(self)

    def became_unpopular_W(self):
        return _libkombilo.Continuation_became_unpopular_W(self)

    def total(self):
        return _libkombilo.Continuation_total(self)
    __swig_destroy__ = _libkombilo.delete_Continuation
    __del__ = lambda self: None
Continuation_swigregister = _libkombilo.Continuation_swigregister
Continuation_swigregister(Continuation)

class PatternList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PatternList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PatternList, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pattern"] = _libkombilo.PatternList_pattern_set
    __swig_getmethods__["pattern"] = _libkombilo.PatternList_pattern_get
    if _newclass:
        pattern = _swig_property(_libkombilo.PatternList_pattern_get, _libkombilo.PatternList_pattern_set)
    __swig_setmethods__["fixedColor"] = _libkombilo.PatternList_fixedColor_set
    __swig_getmethods__["fixedColor"] = _libkombilo.PatternList_fixedColor_get
    if _newclass:
        fixedColor = _swig_property(_libkombilo.PatternList_fixedColor_get, _libkombilo.PatternList_fixedColor_set)
    __swig_setmethods__["nextMove"] = _libkombilo.PatternList_nextMove_set
    __swig_getmethods__["nextMove"] = _libkombilo.PatternList_nextMove_get
    if _newclass:
        nextMove = _swig_property(_libkombilo.PatternList_nextMove_get, _libkombilo.PatternList_nextMove_set)
    __swig_setmethods__["data"] = _libkombilo.PatternList_data_set
    __swig_getmethods__["data"] = _libkombilo.PatternList_data_get
    if _newclass:
        data = _swig_property(_libkombilo.PatternList_data_get, _libkombilo.PatternList_data_set)
    __swig_setmethods__["symmetries"] = _libkombilo.PatternList_symmetries_set
    __swig_getmethods__["symmetries"] = _libkombilo.PatternList_symmetries_get
    if _newclass:
        symmetries = _swig_property(_libkombilo.PatternList_symmetries_get, _libkombilo.PatternList_symmetries_set)
    __swig_setmethods__["continuations"] = _libkombilo.PatternList_continuations_set
    __swig_getmethods__["continuations"] = _libkombilo.PatternList_continuations_get
    if _newclass:
        continuations = _swig_property(_libkombilo.PatternList_continuations_get, _libkombilo.PatternList_continuations_set)
    __swig_setmethods__["flipTable"] = _libkombilo.PatternList_flipTable_set
    __swig_getmethods__["flipTable"] = _libkombilo.PatternList_flipTable_get
    if _newclass:
        flipTable = _swig_property(_libkombilo.PatternList_flipTable_get, _libkombilo.PatternList_flipTable_set)
    __swig_setmethods__["special"] = _libkombilo.PatternList_special_set
    __swig_getmethods__["special"] = _libkombilo.PatternList_special_get
    if _newclass:
        special = _swig_property(_libkombilo.PatternList_special_get, _libkombilo.PatternList_special_set)

    def __init__(self, p, fColor, nMove, gl):
        this = _libkombilo.new_PatternList(p, fColor, nMove, gl)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_PatternList
    __del__ = lambda self: None

    def patternList(self):
        return _libkombilo.PatternList_patternList(self)

    def get(self, i):
        return _libkombilo.PatternList_get(self, i)

    def size(self):
        return _libkombilo.PatternList_size(self)
PatternList_swigregister = _libkombilo.PatternList_swigregister
PatternList_swigregister(PatternList)

class ProcessOptions(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProcessOptions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProcessOptions, name)
    __repr__ = _swig_repr
    __swig_setmethods__["processVariations"] = _libkombilo.ProcessOptions_processVariations_set
    __swig_getmethods__["processVariations"] = _libkombilo.ProcessOptions_processVariations_get
    if _newclass:
        processVariations = _swig_property(_libkombilo.ProcessOptions_processVariations_get, _libkombilo.ProcessOptions_processVariations_set)
    __swig_setmethods__["sgfInDB"] = _libkombilo.ProcessOptions_sgfInDB_set
    __swig_getmethods__["sgfInDB"] = _libkombilo.ProcessOptions_sgfInDB_get
    if _newclass:
        sgfInDB = _swig_property(_libkombilo.ProcessOptions_sgfInDB_get, _libkombilo.ProcessOptions_sgfInDB_set)
    __swig_setmethods__["rootNodeTags"] = _libkombilo.ProcessOptions_rootNodeTags_set
    __swig_getmethods__["rootNodeTags"] = _libkombilo.ProcessOptions_rootNodeTags_get
    if _newclass:
        rootNodeTags = _swig_property(_libkombilo.ProcessOptions_rootNodeTags_get, _libkombilo.ProcessOptions_rootNodeTags_set)
    __swig_setmethods__["algos"] = _libkombilo.ProcessOptions_algos_set
    __swig_getmethods__["algos"] = _libkombilo.ProcessOptions_algos_get
    if _newclass:
        algos = _swig_property(_libkombilo.ProcessOptions_algos_get, _libkombilo.ProcessOptions_algos_set)
    __swig_setmethods__["algo_hash_full_maxNumStones"] = _libkombilo.ProcessOptions_algo_hash_full_maxNumStones_set
    __swig_getmethods__["algo_hash_full_maxNumStones"] = _libkombilo.ProcessOptions_algo_hash_full_maxNumStones_get
    if _newclass:
        algo_hash_full_maxNumStones = _swig_property(_libkombilo.ProcessOptions_algo_hash_full_maxNumStones_get, _libkombilo.ProcessOptions_algo_hash_full_maxNumStones_set)
    __swig_setmethods__["algo_hash_corner_maxNumStones"] = _libkombilo.ProcessOptions_algo_hash_corner_maxNumStones_set
    __swig_getmethods__["algo_hash_corner_maxNumStones"] = _libkombilo.ProcessOptions_algo_hash_corner_maxNumStones_get
    if _newclass:
        algo_hash_corner_maxNumStones = _swig_property(_libkombilo.ProcessOptions_algo_hash_corner_maxNumStones_get, _libkombilo.ProcessOptions_algo_hash_corner_maxNumStones_set)
    __swig_setmethods__["professional_tag"] = _libkombilo.ProcessOptions_professional_tag_set
    __swig_getmethods__["professional_tag"] = _libkombilo.ProcessOptions_professional_tag_get
    if _newclass:
        professional_tag = _swig_property(_libkombilo.ProcessOptions_professional_tag_get, _libkombilo.ProcessOptions_professional_tag_set)

    def asString(self):
        return _libkombilo.ProcessOptions_asString(self)

    def validate(self):
        return _libkombilo.ProcessOptions_validate(self)

    def SGFTagsAsStrings(self):
        return _libkombilo.ProcessOptions_SGFTagsAsStrings(self)

    def __init__(self, *args):
        this = _libkombilo.new_ProcessOptions(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_ProcessOptions
    __del__ = lambda self: None
ProcessOptions_swigregister = _libkombilo.ProcessOptions_swigregister
ProcessOptions_swigregister(ProcessOptions)

class SearchOptions(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SearchOptions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SearchOptions, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fixedColor"] = _libkombilo.SearchOptions_fixedColor_set
    __swig_getmethods__["fixedColor"] = _libkombilo.SearchOptions_fixedColor_get
    if _newclass:
        fixedColor = _swig_property(_libkombilo.SearchOptions_fixedColor_get, _libkombilo.SearchOptions_fixedColor_set)
    __swig_setmethods__["nextMove"] = _libkombilo.SearchOptions_nextMove_set
    __swig_getmethods__["nextMove"] = _libkombilo.SearchOptions_nextMove_get
    if _newclass:
        nextMove = _swig_property(_libkombilo.SearchOptions_nextMove_get, _libkombilo.SearchOptions_nextMove_set)
    __swig_setmethods__["moveLimit"] = _libkombilo.SearchOptions_moveLimit_set
    __swig_getmethods__["moveLimit"] = _libkombilo.SearchOptions_moveLimit_get
    if _newclass:
        moveLimit = _swig_property(_libkombilo.SearchOptions_moveLimit_get, _libkombilo.SearchOptions_moveLimit_set)
    __swig_setmethods__["trustHashFull"] = _libkombilo.SearchOptions_trustHashFull_set
    __swig_getmethods__["trustHashFull"] = _libkombilo.SearchOptions_trustHashFull_get
    if _newclass:
        trustHashFull = _swig_property(_libkombilo.SearchOptions_trustHashFull_get, _libkombilo.SearchOptions_trustHashFull_set)
    __swig_setmethods__["searchInVariations"] = _libkombilo.SearchOptions_searchInVariations_set
    __swig_getmethods__["searchInVariations"] = _libkombilo.SearchOptions_searchInVariations_get
    if _newclass:
        searchInVariations = _swig_property(_libkombilo.SearchOptions_searchInVariations_get, _libkombilo.SearchOptions_searchInVariations_set)
    __swig_setmethods__["algos"] = _libkombilo.SearchOptions_algos_set
    __swig_getmethods__["algos"] = _libkombilo.SearchOptions_algos_get
    if _newclass:
        algos = _swig_property(_libkombilo.SearchOptions_algos_get, _libkombilo.SearchOptions_algos_set)

    def __init__(self, *args):
        this = _libkombilo.new_SearchOptions(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def to_snv(self, snv):
        return _libkombilo.SearchOptions_to_snv(self, snv)
    __swig_destroy__ = _libkombilo.delete_SearchOptions
    __del__ = lambda self: None
SearchOptions_swigregister = _libkombilo.SearchOptions_swigregister
SearchOptions_swigregister(SearchOptions)

class VarInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VarInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VarInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["n"] = _libkombilo.VarInfo_n_set
    __swig_getmethods__["n"] = _libkombilo.VarInfo_n_get
    if _newclass:
        n = _swig_property(_libkombilo.VarInfo_n_get, _libkombilo.VarInfo_n_set)
    __swig_setmethods__["b"] = _libkombilo.VarInfo_b_set
    __swig_getmethods__["b"] = _libkombilo.VarInfo_b_get
    if _newclass:
        b = _swig_property(_libkombilo.VarInfo_b_get, _libkombilo.VarInfo_b_set)
    __swig_setmethods__["i"] = _libkombilo.VarInfo_i_set
    __swig_getmethods__["i"] = _libkombilo.VarInfo_i_get
    if _newclass:
        i = _swig_property(_libkombilo.VarInfo_i_get, _libkombilo.VarInfo_i_set)

    def __init__(self, *args):
        this = _libkombilo.new_VarInfo(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_VarInfo
    __del__ = lambda self: None
VarInfo_swigregister = _libkombilo.VarInfo_swigregister
VarInfo_swigregister(VarInfo)

class GameList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GameList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GameList, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dbname"] = _libkombilo.GameList_dbname_set
    __swig_getmethods__["dbname"] = _libkombilo.GameList_dbname_get
    if _newclass:
        dbname = _swig_property(_libkombilo.GameList_dbname_get, _libkombilo.GameList_dbname_set)
    __swig_setmethods__["orderby"] = _libkombilo.GameList_orderby_set
    __swig_getmethods__["orderby"] = _libkombilo.GameList_orderby_get
    if _newclass:
        orderby = _swig_property(_libkombilo.GameList_orderby_get, _libkombilo.GameList_orderby_set)
    __swig_setmethods__["format1"] = _libkombilo.GameList_format1_set
    __swig_getmethods__["format1"] = _libkombilo.GameList_format1_get
    if _newclass:
        format1 = _swig_property(_libkombilo.GameList_format1_get, _libkombilo.GameList_format1_set)
    __swig_setmethods__["format2"] = _libkombilo.GameList_format2_set
    __swig_getmethods__["format2"] = _libkombilo.GameList_format2_get
    if _newclass:
        format2 = _swig_property(_libkombilo.GameList_format2_get, _libkombilo.GameList_format2_set)
    __swig_setmethods__["numColumns"] = _libkombilo.GameList_numColumns_set
    __swig_getmethods__["numColumns"] = _libkombilo.GameList_numColumns_get
    if _newclass:
        numColumns = _swig_property(_libkombilo.GameList_numColumns_get, _libkombilo.GameList_numColumns_set)
    __swig_setmethods__["processVariations"] = _libkombilo.GameList_processVariations_set
    __swig_getmethods__["processVariations"] = _libkombilo.GameList_processVariations_get
    if _newclass:
        processVariations = _swig_property(_libkombilo.GameList_processVariations_get, _libkombilo.GameList_processVariations_set)
    __swig_setmethods__["boardsize"] = _libkombilo.GameList_boardsize_set
    __swig_getmethods__["boardsize"] = _libkombilo.GameList_boardsize_get
    if _newclass:
        boardsize = _swig_property(_libkombilo.GameList_boardsize_get, _libkombilo.GameList_boardsize_set)
    __swig_setmethods__["algo_ps"] = _libkombilo.GameList_algo_ps_set
    __swig_getmethods__["algo_ps"] = _libkombilo.GameList_algo_ps_get
    if _newclass:
        algo_ps = _swig_property(_libkombilo.GameList_algo_ps_get, _libkombilo.GameList_algo_ps_set)
    __swig_setmethods__["current"] = _libkombilo.GameList_current_set
    __swig_getmethods__["current"] = _libkombilo.GameList_current_get
    if _newclass:
        current = _swig_property(_libkombilo.GameList_current_get, _libkombilo.GameList_current_set)
    __swig_setmethods__["db"] = _libkombilo.GameList_db_set
    __swig_getmethods__["db"] = _libkombilo.GameList_db_get
    if _newclass:
        db = _swig_property(_libkombilo.GameList_db_get, _libkombilo.GameList_db_set)
    __swig_setmethods__["labels"] = _libkombilo.GameList_labels_set
    __swig_getmethods__["labels"] = _libkombilo.GameList_labels_get
    if _newclass:
        labels = _swig_property(_libkombilo.GameList_labels_get, _libkombilo.GameList_labels_set)
    __swig_setmethods__["continuations"] = _libkombilo.GameList_continuations_set
    __swig_getmethods__["continuations"] = _libkombilo.GameList_continuations_get
    if _newclass:
        continuations = _swig_property(_libkombilo.GameList_continuations_get, _libkombilo.GameList_continuations_set)
    __swig_setmethods__["num_hits"] = _libkombilo.GameList_num_hits_set
    __swig_getmethods__["num_hits"] = _libkombilo.GameList_num_hits_get
    if _newclass:
        num_hits = _swig_property(_libkombilo.GameList_num_hits_get, _libkombilo.GameList_num_hits_set)
    __swig_setmethods__["num_switched"] = _libkombilo.GameList_num_switched_set
    __swig_getmethods__["num_switched"] = _libkombilo.GameList_num_switched_get
    if _newclass:
        num_switched = _swig_property(_libkombilo.GameList_num_switched_get, _libkombilo.GameList_num_switched_set)
    __swig_setmethods__["Bwins"] = _libkombilo.GameList_Bwins_set
    __swig_getmethods__["Bwins"] = _libkombilo.GameList_Bwins_get
    if _newclass:
        Bwins = _swig_property(_libkombilo.GameList_Bwins_get, _libkombilo.GameList_Bwins_set)
    __swig_setmethods__["BwinsAll"] = _libkombilo.GameList_BwinsAll_set
    __swig_getmethods__["BwinsAll"] = _libkombilo.GameList_BwinsAll_get
    if _newclass:
        BwinsAll = _swig_property(_libkombilo.GameList_BwinsAll_get, _libkombilo.GameList_BwinsAll_set)
    __swig_setmethods__["Wwins"] = _libkombilo.GameList_Wwins_set
    __swig_getmethods__["Wwins"] = _libkombilo.GameList_Wwins_get
    if _newclass:
        Wwins = _swig_property(_libkombilo.GameList_Wwins_get, _libkombilo.GameList_Wwins_set)
    __swig_setmethods__["WwinsAll"] = _libkombilo.GameList_WwinsAll_set
    __swig_getmethods__["WwinsAll"] = _libkombilo.GameList_WwinsAll_get
    if _newclass:
        WwinsAll = _swig_property(_libkombilo.GameList_WwinsAll_get, _libkombilo.GameList_WwinsAll_set)
    __swig_setmethods__["mrs_pattern"] = _libkombilo.GameList_mrs_pattern_set
    __swig_getmethods__["mrs_pattern"] = _libkombilo.GameList_mrs_pattern_get
    if _newclass:
        mrs_pattern = _swig_property(_libkombilo.GameList_mrs_pattern_get, _libkombilo.GameList_mrs_pattern_set)
    __swig_setmethods__["searchOptions"] = _libkombilo.GameList_searchOptions_set
    __swig_getmethods__["searchOptions"] = _libkombilo.GameList_searchOptions_get
    if _newclass:
        searchOptions = _swig_property(_libkombilo.GameList_searchOptions_get, _libkombilo.GameList_searchOptions_set)
    __swig_setmethods__["dates_all"] = _libkombilo.GameList_dates_all_set
    __swig_getmethods__["dates_all"] = _libkombilo.GameList_dates_all_get
    if _newclass:
        dates_all = _swig_property(_libkombilo.GameList_dates_all_get, _libkombilo.GameList_dates_all_set)
    __swig_setmethods__["dates_all_per_year"] = _libkombilo.GameList_dates_all_per_year_set
    __swig_getmethods__["dates_all_per_year"] = _libkombilo.GameList_dates_all_per_year_get
    if _newclass:
        dates_all_per_year = _swig_property(_libkombilo.GameList_dates_all_per_year_get, _libkombilo.GameList_dates_all_per_year_set)
    __swig_setmethods__["dates_current"] = _libkombilo.GameList_dates_current_set
    __swig_getmethods__["dates_current"] = _libkombilo.GameList_dates_current_get
    if _newclass:
        dates_current = _swig_property(_libkombilo.GameList_dates_current_get, _libkombilo.GameList_dates_current_set)

    def __init__(self, *args):
        this = _libkombilo.new_GameList(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _libkombilo.delete_GameList
    __del__ = lambda self: None

    def process(self, sgf, path, fn, glists, DBTREE=None, flags=0):
        return _libkombilo.GameList_process(self, sgf, path, fn, glists, DBTREE, flags)

    def process_results(self, i=0):
        return _libkombilo.GameList_process_results(self, i)

    def start_processing(self, PROCESSVARIATIONS=-1):
        return _libkombilo.GameList_start_processing(self, PROCESSVARIATIONS)

    def finalize_processing(self):
        return _libkombilo.GameList_finalize_processing(self)

    def search(self, pattern, options=None):
        return _libkombilo.GameList_search(self, pattern, options)

    def lookupLabel(self, x, y):
        return _libkombilo.GameList_lookupLabel(self, x, y)

    def setLabel(self, x, y, label):
        return _libkombilo.GameList_setLabel(self, x, y, label)

    def lookupContinuation(self, x, y):
        return _libkombilo.GameList_lookupContinuation(self, x, y)

    def numHits(self):
        return _libkombilo.GameList_numHits(self)

    def sigsearch(self, sig):
        return _libkombilo.GameList_sigsearch(self, sig)

    def sigsearchNC(self, sig):
        return _libkombilo.GameList_sigsearchNC(self, sig)

    def getSignature(self, i):
        return _libkombilo.GameList_getSignature(self, i)

    def gisearch(self, sql, complete=0):
        return _libkombilo.GameList_gisearch(self, sql, complete)

    def gisearchNC(self, sql, complete=0):
        return _libkombilo.GameList_gisearchNC(self, sql, complete)

    def tagsearch(self, tag):
        return _libkombilo.GameList_tagsearch(self, tag)

    def tagsearchSQL(self, query):
        return _libkombilo.GameList_tagsearchSQL(self, query)

    def setTag(self, tag, start=0, end=0):
        return _libkombilo.GameList_setTag(self, tag, start, end)

    def setTagID(self, tag, i):
        return _libkombilo.GameList_setTagID(self, tag, i)

    def getTagsID(self, i, tag=0):
        return _libkombilo.GameList_getTagsID(self, i, tag)

    def deleteTag(self, tag, i=-1):
        return _libkombilo.GameList_deleteTag(self, tag, i)

    def getTags(self, i, tag=0):
        return _libkombilo.GameList_getTags(self, i, tag)

    def export_tags(self, tag_db_name, which_tags):
        return _libkombilo.GameList_export_tags(self, tag_db_name, which_tags)

    def import_tags(self, tag_db_name):
        return _libkombilo.GameList_import_tags(self, tag_db_name)

    def snapshot(self):
        return _libkombilo.GameList_snapshot(self)

    def restore(self, handle, arg3=False):
        return _libkombilo.GameList_restore(self, handle, arg3)

    def delete_snapshot(self, handle):
        return _libkombilo.GameList_delete_snapshot(self, handle)

    def delete_all_snapshots(self):
        return _libkombilo.GameList_delete_all_snapshots(self)

    def reset(self):
        return _libkombilo.GameList_reset(self)

    def resetFormat(self, *args):
        return _libkombilo.GameList_resetFormat(self, *args)

    def size(self):
        return _libkombilo.GameList_size(self)

    def size_all(self):
        return _libkombilo.GameList_size_all(self)

    def get_resultsStr(self, i):
        return _libkombilo.GameList_get_resultsStr(self, i)

    def resultsStr(self, gle):
        return _libkombilo.GameList_resultsStr(self, gle)

    def find_by_ID(self, ID):
        return _libkombilo.GameList_find_by_ID(self, ID)

    def get_gameInfoStr(self, i):
        return _libkombilo.GameList_get_gameInfoStr(self, i)

    def get_currentList_entry(self, i):
        return _libkombilo.GameList_get_currentList_entry(self, i)

    def currentEntryAsString(self, i):
        return _libkombilo.GameList_currentEntryAsString(self, i)

    def currentEntriesAsStrings(self, start=0, end=0):
        return _libkombilo.GameList_currentEntriesAsStrings(self, start, end)

    def getSGF(self, i):
        return _libkombilo.GameList_getSGF(self, i)

    def getCurrentProperty(self, i, tag):
        return _libkombilo.GameList_getCurrentProperty(self, i, tag)

    def plSize(self):
        return _libkombilo.GameList_plSize(self)

    def plEntry(self, i):
        return _libkombilo.GameList_plEntry(self, i)
GameList_swigregister = _libkombilo.GameList_swigregister
GameList_swigregister(GameList)
CHECK_FOR_DUPLICATES = cvar.CHECK_FOR_DUPLICATES
CHECK_FOR_DUPLICATES_STRICT = cvar.CHECK_FOR_DUPLICATES_STRICT
OMIT_DUPLICATES = cvar.OMIT_DUPLICATES
OMIT_GAMES_WITH_SGF_ERRORS = cvar.OMIT_GAMES_WITH_SGF_ERRORS
UNACCEPTABLE_BOARDSIZE = cvar.UNACCEPTABLE_BOARDSIZE
SGF_ERROR = cvar.SGF_ERROR
IS_DUPLICATE = cvar.IS_DUPLICATE
NOT_INSERTED_INTO_DB = cvar.NOT_INSERTED_INTO_DB
INDEX_OUT_OF_RANGE = cvar.INDEX_OUT_OF_RANGE


def find_duplicates(glists, strict=False, dupl_within_db=False):
    return _libkombilo.find_duplicates(glists, strict, dupl_within_db)
find_duplicates = _libkombilo.find_duplicates
class vectorMNC(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorMNC, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorMNC, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _libkombilo.vectorMNC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libkombilo.vectorMNC___nonzero__(self)

    def __bool__(self):
        return _libkombilo.vectorMNC___bool__(self)

    def __len__(self):
        return _libkombilo.vectorMNC___len__(self)

    def __getslice__(self, i, j):
        return _libkombilo.vectorMNC___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libkombilo.vectorMNC___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libkombilo.vectorMNC___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libkombilo.vectorMNC___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libkombilo.vectorMNC___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libkombilo.vectorMNC___setitem__(self, *args)

    def pop(self):
        return _libkombilo.vectorMNC_pop(self)

    def append(self, x):
        return _libkombilo.vectorMNC_append(self, x)

    def empty(self):
        return _libkombilo.vectorMNC_empty(self)

    def size(self):
        return _libkombilo.vectorMNC_size(self)

    def swap(self, v):
        return _libkombilo.vectorMNC_swap(self, v)

    def begin(self):
        return _libkombilo.vectorMNC_begin(self)

    def end(self):
        return _libkombilo.vectorMNC_end(self)

    def rbegin(self):
        return _libkombilo.vectorMNC_rbegin(self)

    def rend(self):
        return _libkombilo.vectorMNC_rend(self)

    def clear(self):
        return _libkombilo.vectorMNC_clear(self)

    def get_allocator(self):
        return _libkombilo.vectorMNC_get_allocator(self)

    def pop_back(self):
        return _libkombilo.vectorMNC_pop_back(self)

    def erase(self, *args):
        return _libkombilo.vectorMNC_erase(self, *args)

    def __init__(self, *args):
        this = _libkombilo.new_vectorMNC(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _libkombilo.vectorMNC_push_back(self, x)

    def front(self):
        return _libkombilo.vectorMNC_front(self)

    def back(self):
        return _libkombilo.vectorMNC_back(self)

    def assign(self, n, x):
        return _libkombilo.vectorMNC_assign(self, n, x)

    def resize(self, *args):
        return _libkombilo.vectorMNC_resize(self, *args)

    def insert(self, *args):
        return _libkombilo.vectorMNC_insert(self, *args)

    def reserve(self, n):
        return _libkombilo.vectorMNC_reserve(self, n)

    def capacity(self):
        return _libkombilo.vectorMNC_capacity(self)
    __swig_destroy__ = _libkombilo.delete_vectorMNC
    __del__ = lambda self: None
vectorMNC_swigregister = _libkombilo.vectorMNC_swigregister
vectorMNC_swigregister(vectorMNC)
HANDI_TAG = cvar.HANDI_TAG
PROFESSIONAL_TAG = cvar.PROFESSIONAL_TAG

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

    def iterator(self):
        return _libkombilo.vectorM_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libkombilo.vectorM___nonzero__(self)

    def __bool__(self):
        return _libkombilo.vectorM___bool__(self)

    def __len__(self):
        return _libkombilo.vectorM___len__(self)

    def __getslice__(self, i, j):
        return _libkombilo.vectorM___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libkombilo.vectorM___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libkombilo.vectorM___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libkombilo.vectorM___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libkombilo.vectorM___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libkombilo.vectorM___setitem__(self, *args)

    def pop(self):
        return _libkombilo.vectorM_pop(self)

    def append(self, x):
        return _libkombilo.vectorM_append(self, x)

    def empty(self):
        return _libkombilo.vectorM_empty(self)

    def size(self):
        return _libkombilo.vectorM_size(self)

    def swap(self, v):
        return _libkombilo.vectorM_swap(self, v)

    def begin(self):
        return _libkombilo.vectorM_begin(self)

    def end(self):
        return _libkombilo.vectorM_end(self)

    def rbegin(self):
        return _libkombilo.vectorM_rbegin(self)

    def rend(self):
        return _libkombilo.vectorM_rend(self)

    def clear(self):
        return _libkombilo.vectorM_clear(self)

    def get_allocator(self):
        return _libkombilo.vectorM_get_allocator(self)

    def pop_back(self):
        return _libkombilo.vectorM_pop_back(self)

    def erase(self, *args):
        return _libkombilo.vectorM_erase(self, *args)

    def __init__(self, *args):
        this = _libkombilo.new_vectorM(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _libkombilo.vectorM_push_back(self, x)

    def front(self):
        return _libkombilo.vectorM_front(self)

    def back(self):
        return _libkombilo.vectorM_back(self)

    def assign(self, n, x):
        return _libkombilo.vectorM_assign(self, n, x)

    def resize(self, *args):
        return _libkombilo.vectorM_resize(self, *args)

    def insert(self, *args):
        return _libkombilo.vectorM_insert(self, *args)

    def reserve(self, n):
        return _libkombilo.vectorM_reserve(self, n)

    def capacity(self):
        return _libkombilo.vectorM_capacity(self)
    __swig_destroy__ = _libkombilo.delete_vectorM
    __del__ = lambda self: None
vectorM_swigregister = _libkombilo.vectorM_swigregister
vectorM_swigregister(vectorM)

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

    def iterator(self):
        return _libkombilo.vectorGL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _libkombilo.vectorGL___nonzero__(self)

    def __bool__(self):
        return _libkombilo.vectorGL___bool__(self)

    def __len__(self):
        return _libkombilo.vectorGL___len__(self)

    def __getslice__(self, i, j):
        return _libkombilo.vectorGL___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _libkombilo.vectorGL___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _libkombilo.vectorGL___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _libkombilo.vectorGL___delitem__(self, *args)

    def __getitem__(self, *args):
        return _libkombilo.vectorGL___getitem__(self, *args)

    def __setitem__(self, *args):
        return _libkombilo.vectorGL___setitem__(self, *args)

    def pop(self):
        return _libkombilo.vectorGL_pop(self)

    def append(self, x):
        return _libkombilo.vectorGL_append(self, x)

    def empty(self):
        return _libkombilo.vectorGL_empty(self)

    def size(self):
        return _libkombilo.vectorGL_size(self)

    def swap(self, v):
        return _libkombilo.vectorGL_swap(self, v)

    def begin(self):
        return _libkombilo.vectorGL_begin(self)

    def end(self):
        return _libkombilo.vectorGL_end(self)

    def rbegin(self):
        return _libkombilo.vectorGL_rbegin(self)

    def rend(self):
        return _libkombilo.vectorGL_rend(self)

    def clear(self):
        return _libkombilo.vectorGL_clear(self)

    def get_allocator(self):
        return _libkombilo.vectorGL_get_allocator(self)

    def pop_back(self):
        return _libkombilo.vectorGL_pop_back(self)

    def erase(self, *args):
        return _libkombilo.vectorGL_erase(self, *args)

    def __init__(self, *args):
        this = _libkombilo.new_vectorGL(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _libkombilo.vectorGL_push_back(self, x)

    def front(self):
        return _libkombilo.vectorGL_front(self)

    def back(self):
        return _libkombilo.vectorGL_back(self)

    def assign(self, n, x):
        return _libkombilo.vectorGL_assign(self, n, x)

    def resize(self, *args):
        return _libkombilo.vectorGL_resize(self, *args)

    def insert(self, *args):
        return _libkombilo.vectorGL_insert(self, *args)

    def reserve(self, n):
        return _libkombilo.vectorGL_reserve(self, n)

    def capacity(self):
        return _libkombilo.vectorGL_capacity(self)
    __swig_destroy__ = _libkombilo.delete_vectorGL
    __del__ = lambda self: None
vectorGL_swigregister = _libkombilo.vectorGL_swigregister
vectorGL_swigregister(vectorGL)

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


