# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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 as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_skycoin')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_skycoin')
    _skycoin = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_skycoin', [dirname(__file__)])
        except ImportError:
            import _skycoin
            return _skycoin
        try:
            _mod = imp.load_module('_skycoin', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _skycoin = swig_import_helper()
    del swig_import_helper
else:
    import _skycoin
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0


def equalSlices(slice1, slice2, elem_size):
    return _skycoin.equalSlices(slice1, slice2, elem_size)
equalSlices = _skycoin.equalSlices

def equalTransactions(t1, t2):
    return _skycoin.equalTransactions(t1, t2)
equalTransactions = _skycoin.equalTransactions

def equalTransactionsArrays(pTxs1, pTxs2):
    return _skycoin.equalTransactionsArrays(pTxs1, pTxs2)
equalTransactionsArrays = _skycoin.equalTransactionsArrays

def equalBlockHeaders(bh1, bh2):
    return _skycoin.equalBlockHeaders(bh1, bh2)
equalBlockHeaders = _skycoin.equalBlockHeaders

def destroy_cipher_SecKeys(p):
    return _skycoin.destroy_cipher_SecKeys(p)
destroy_cipher_SecKeys = _skycoin.destroy_cipher_SecKeys

def destroy_cipher_PubKeys(p):
    return _skycoin.destroy_cipher_PubKeys(p)
destroy_cipher_PubKeys = _skycoin.destroy_cipher_PubKeys

def wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed(seed, n):
    return _skycoin.wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed(seed, n)
wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed = _skycoin.wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed

def SKY_params_GetDistributionAddresses():
    return _skycoin.SKY_params_GetDistributionAddresses()
SKY_params_GetDistributionAddresses = _skycoin.SKY_params_GetDistributionAddresses

def SKY_params_GetUnlockedDistributionAddresses():
    return _skycoin.SKY_params_GetUnlockedDistributionAddresses()
SKY_params_GetUnlockedDistributionAddresses = _skycoin.SKY_params_GetUnlockedDistributionAddresses

def SKY_params_GetLockedDistributionAddresses():
    return _skycoin.SKY_params_GetLockedDistributionAddresses()
SKY_params_GetLockedDistributionAddresses = _skycoin.SKY_params_GetLockedDistributionAddresses
class cipher_PubKey(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, cipher_PubKey, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, cipher_PubKey, name)
    __repr__ = _swig_repr

    def __eq__(self, a):
        return _skycoin.cipher_PubKey___eq__(self, a)

    def compareToString(self, str):
        return _skycoin.cipher_PubKey_compareToString(self, str)

    def toStr(self):
        return _skycoin.cipher_PubKey_toStr(self)

    def assignFrom(self, data):
        return _skycoin.cipher_PubKey_assignFrom(self, data)

    def assignTo(self, data):
        return _skycoin.cipher_PubKey_assignTo(self, data)
    __swig_setmethods__["data"] = _skycoin.cipher_PubKey_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_PubKey_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_PubKey_data_get, _skycoin.cipher_PubKey_data_set)

    def __init__(self):
        this = _skycoin.new_cipher_PubKey()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_PubKey
    __del__ = lambda self: None
cipher_PubKey_swigregister = _skycoin.cipher_PubKey_swigregister
cipher_PubKey_swigregister(cipher_PubKey)

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

    def __eq__(self, a):
        return _skycoin.cipher_SecKey___eq__(self, a)

    def compareToString(self, str):
        return _skycoin.cipher_SecKey_compareToString(self, str)

    def toStr(self):
        return _skycoin.cipher_SecKey_toStr(self)

    def assignFrom(self, data):
        return _skycoin.cipher_SecKey_assignFrom(self, data)

    def assignTo(self, data):
        return _skycoin.cipher_SecKey_assignTo(self, data)
    __swig_setmethods__["data"] = _skycoin.cipher_SecKey_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_SecKey_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_SecKey_data_get, _skycoin.cipher_SecKey_data_set)

    def __init__(self):
        this = _skycoin.new_cipher_SecKey()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_SecKey
    __del__ = lambda self: None
cipher_SecKey_swigregister = _skycoin.cipher_SecKey_swigregister
cipher_SecKey_swigregister(cipher_SecKey)

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

    def __eq__(self, a):
        return _skycoin.cipher_Ripemd160___eq__(self, a)

    def compareToString(self, str):
        return _skycoin.cipher_Ripemd160_compareToString(self, str)

    def toStr(self):
        return _skycoin.cipher_Ripemd160_toStr(self)

    def assignFrom(self, data):
        return _skycoin.cipher_Ripemd160_assignFrom(self, data)

    def assignTo(self, data):
        return _skycoin.cipher_Ripemd160_assignTo(self, data)
    __swig_setmethods__["data"] = _skycoin.cipher_Ripemd160_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_Ripemd160_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_Ripemd160_data_get, _skycoin.cipher_Ripemd160_data_set)

    def __init__(self):
        this = _skycoin.new_cipher_Ripemd160()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_Ripemd160
    __del__ = lambda self: None
cipher_Ripemd160_swigregister = _skycoin.cipher_Ripemd160_swigregister
cipher_Ripemd160_swigregister(cipher_Ripemd160)

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

    def __eq__(self, a):
        return _skycoin.cipher_Sig___eq__(self, a)

    def compareToString(self, str):
        return _skycoin.cipher_Sig_compareToString(self, str)

    def toStr(self):
        return _skycoin.cipher_Sig_toStr(self)

    def assignFrom(self, data):
        return _skycoin.cipher_Sig_assignFrom(self, data)

    def assignTo(self, data):
        return _skycoin.cipher_Sig_assignTo(self, data)
    __swig_setmethods__["data"] = _skycoin.cipher_Sig_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_Sig_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_Sig_data_get, _skycoin.cipher_Sig_data_set)

    def __init__(self):
        this = _skycoin.new_cipher_Sig()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_Sig
    __del__ = lambda self: None
cipher_Sig_swigregister = _skycoin.cipher_Sig_swigregister
cipher_Sig_swigregister(cipher_Sig)

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

    def __eq__(self, a):
        return _skycoin.cipher_SHA256___eq__(self, a)

    def compareToString(self, str):
        return _skycoin.cipher_SHA256_compareToString(self, str)

    def toStr(self):
        return _skycoin.cipher_SHA256_toStr(self)

    def assignFrom(self, data):
        return _skycoin.cipher_SHA256_assignFrom(self, data)

    def assignTo(self, data):
        return _skycoin.cipher_SHA256_assignTo(self, data)
    __swig_setmethods__["data"] = _skycoin.cipher_SHA256_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_SHA256_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_SHA256_data_get, _skycoin.cipher_SHA256_data_set)

    def __init__(self):
        this = _skycoin.new_cipher_SHA256()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_SHA256
    __del__ = lambda self: None
cipher_SHA256_swigregister = _skycoin.cipher_SHA256_swigregister
cipher_SHA256_swigregister(cipher_SHA256)

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

    def __eq__(self, a):
        return _skycoin.cipher_Checksum___eq__(self, a)

    def compareToString(self, str):
        return _skycoin.cipher_Checksum_compareToString(self, str)

    def toStr(self):
        return _skycoin.cipher_Checksum_toStr(self)

    def assignFrom(self, data):
        return _skycoin.cipher_Checksum_assignFrom(self, data)

    def assignTo(self, data):
        return _skycoin.cipher_Checksum_assignTo(self, data)
    __swig_setmethods__["data"] = _skycoin.cipher_Checksum_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_Checksum_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_Checksum_data_get, _skycoin.cipher_Checksum_data_set)

    def __init__(self):
        this = _skycoin.new_cipher_Checksum()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_Checksum
    __del__ = lambda self: None
cipher_Checksum_swigregister = _skycoin.cipher_Checksum_swigregister
cipher_Checksum_swigregister(cipher_Checksum)

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

    def getAt(self, i):
        return _skycoin.cipher_SecKeys_getAt(self, i)

    def setAt(self, i, seckey):
        return _skycoin.cipher_SecKeys_setAt(self, i, seckey)

    def __eq__(self, a):
        return _skycoin.cipher_SecKeys___eq__(self, a)

    def allocate(self, n):
        return _skycoin.cipher_SecKeys_allocate(self, n)

    def release(self):
        return _skycoin.cipher_SecKeys_release(self)
    __swig_setmethods__["data"] = _skycoin.cipher_SecKeys_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_SecKeys_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_SecKeys_data_get, _skycoin.cipher_SecKeys_data_set)
    __swig_setmethods__["count"] = _skycoin.cipher_SecKeys_count_set
    __swig_getmethods__["count"] = _skycoin.cipher_SecKeys_count_get
    if _newclass:
        count = _swig_property(_skycoin.cipher_SecKeys_count_get, _skycoin.cipher_SecKeys_count_set)

    def __init__(self):
        this = _skycoin.new_cipher_SecKeys()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_SecKeys
    __del__ = lambda self: None
cipher_SecKeys_swigregister = _skycoin.cipher_SecKeys_swigregister
cipher_SecKeys_swigregister(cipher_SecKeys)

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

    def getAt(self, i):
        return _skycoin.cipher_PubKeys_getAt(self, i)

    def setAt(self, i, pubkey):
        return _skycoin.cipher_PubKeys_setAt(self, i, pubkey)

    def __eq__(self, a):
        return _skycoin.cipher_PubKeys___eq__(self, a)

    def allocate(self, n):
        return _skycoin.cipher_PubKeys_allocate(self, n)

    def release(self):
        return _skycoin.cipher_PubKeys_release(self)
    __swig_setmethods__["data"] = _skycoin.cipher_PubKeys_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_PubKeys_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_PubKeys_data_get, _skycoin.cipher_PubKeys_data_set)
    __swig_setmethods__["count"] = _skycoin.cipher_PubKeys_count_set
    __swig_getmethods__["count"] = _skycoin.cipher_PubKeys_count_get
    if _newclass:
        count = _swig_property(_skycoin.cipher_PubKeys_count_get, _skycoin.cipher_PubKeys_count_set)

    def __init__(self):
        this = _skycoin.new_cipher_PubKeys()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_PubKeys
    __del__ = lambda self: None
cipher_PubKeys_swigregister = _skycoin.cipher_PubKeys_swigregister
cipher_PubKeys_swigregister(cipher_PubKeys)

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

    def getAt(self, i):
        return _skycoin.cipher_SHA256s_getAt(self, i)

    def setAt(self, i, hash):
        return _skycoin.cipher_SHA256s_setAt(self, i, hash)

    def __eq__(self, a):
        return _skycoin.cipher_SHA256s___eq__(self, a)

    def allocate(self, n):
        return _skycoin.cipher_SHA256s_allocate(self, n)

    def release(self):
        return _skycoin.cipher_SHA256s_release(self)
    __swig_setmethods__["data"] = _skycoin.cipher_SHA256s_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_SHA256s_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_SHA256s_data_get, _skycoin.cipher_SHA256s_data_set)
    __swig_setmethods__["count"] = _skycoin.cipher_SHA256s_count_set
    __swig_getmethods__["count"] = _skycoin.cipher_SHA256s_count_get
    if _newclass:
        count = _swig_property(_skycoin.cipher_SHA256s_count_get, _skycoin.cipher_SHA256s_count_set)

    def __init__(self):
        this = _skycoin.new_cipher_SHA256s()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_SHA256s
    __del__ = lambda self: None
cipher_SHA256s_swigregister = _skycoin.cipher_SHA256s_swigregister
cipher_SHA256s_swigregister(cipher_SHA256s)

class coin_UxOutArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, coin_UxOutArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, coin_UxOutArray, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _skycoin.coin_UxOutArray_data_set
    __swig_getmethods__["data"] = _skycoin.coin_UxOutArray_data_get
    if _newclass:
        data = _swig_property(_skycoin.coin_UxOutArray_data_get, _skycoin.coin_UxOutArray_data_set)
    __swig_setmethods__["count"] = _skycoin.coin_UxOutArray_count_set
    __swig_getmethods__["count"] = _skycoin.coin_UxOutArray_count_get
    if _newclass:
        count = _swig_property(_skycoin.coin_UxOutArray_count_get, _skycoin.coin_UxOutArray_count_set)

    def __init__(self):
        this = _skycoin.new_coin_UxOutArray()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin_UxOutArray
    __del__ = lambda self: None
coin_UxOutArray_swigregister = _skycoin.coin_UxOutArray_swigregister
coin_UxOutArray_swigregister(coin_UxOutArray)

class cipher_Addresses(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, cipher_Addresses, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, cipher_Addresses, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _skycoin.cipher_Addresses_data_set
    __swig_getmethods__["data"] = _skycoin.cipher_Addresses_data_get
    if _newclass:
        data = _swig_property(_skycoin.cipher_Addresses_data_get, _skycoin.cipher_Addresses_data_set)
    __swig_setmethods__["count"] = _skycoin.cipher_Addresses_count_set
    __swig_getmethods__["count"] = _skycoin.cipher_Addresses_count_get
    if _newclass:
        count = _swig_property(_skycoin.cipher_Addresses_count_get, _skycoin.cipher_Addresses_count_set)

    def __init__(self):
        this = _skycoin.new_cipher_Addresses()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher_Addresses
    __del__ = lambda self: None
cipher_Addresses_swigregister = _skycoin.cipher_Addresses_swigregister
cipher_Addresses_swigregister(cipher_Addresses)

class Fee_Calculator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Fee_Calculator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Fee_Calculator, name)
    __repr__ = _swig_repr
    __swig_setmethods__["callback"] = _skycoin.Fee_Calculator_callback_set
    __swig_getmethods__["callback"] = _skycoin.Fee_Calculator_callback_get
    if _newclass:
        callback = _swig_property(_skycoin.Fee_Calculator_callback_get, _skycoin.Fee_Calculator_callback_set)
    __swig_setmethods__["context"] = _skycoin.Fee_Calculator_context_set
    __swig_getmethods__["context"] = _skycoin.Fee_Calculator_context_get
    if _newclass:
        context = _swig_property(_skycoin.Fee_Calculator_context_get, _skycoin.Fee_Calculator_context_set)

    def __init__(self):
        this = _skycoin.new_Fee_Calculator()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_Fee_Calculator
    __del__ = lambda self: None
Fee_Calculator_swigregister = _skycoin.Fee_Calculator_swigregister
Fee_Calculator_swigregister(Fee_Calculator)

class _GoString_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _GoString_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _GoString_, name)
    __repr__ = _swig_repr
    __swig_setmethods__["p"] = _skycoin._GoString__p_set
    __swig_getmethods__["p"] = _skycoin._GoString__p_get
    if _newclass:
        p = _swig_property(_skycoin._GoString__p_get, _skycoin._GoString__p_set)
    __swig_setmethods__["n"] = _skycoin._GoString__n_set
    __swig_getmethods__["n"] = _skycoin._GoString__n_get
    if _newclass:
        n = _swig_property(_skycoin._GoString__n_get, _skycoin._GoString__n_set)

    def __init__(self):
        this = _skycoin.new__GoString_()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete__GoString_
    __del__ = lambda self: None
_GoString__swigregister = _skycoin._GoString__swigregister
_GoString__swigregister(_GoString_)

class GoInterface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GoInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GoInterface, name)
    __repr__ = _swig_repr
    __swig_setmethods__["t"] = _skycoin.GoInterface_t_set
    __swig_getmethods__["t"] = _skycoin.GoInterface_t_get
    if _newclass:
        t = _swig_property(_skycoin.GoInterface_t_get, _skycoin.GoInterface_t_set)
    __swig_setmethods__["v"] = _skycoin.GoInterface_v_set
    __swig_getmethods__["v"] = _skycoin.GoInterface_v_get
    if _newclass:
        v = _swig_property(_skycoin.GoInterface_v_get, _skycoin.GoInterface_v_set)

    def __init__(self):
        this = _skycoin.new_GoInterface()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_GoInterface
    __del__ = lambda self: None
GoInterface_swigregister = _skycoin.GoInterface_swigregister
GoInterface_swigregister(GoInterface)

class GoSlice(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GoSlice, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GoSlice, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _skycoin.GoSlice_data_set
    __swig_getmethods__["data"] = _skycoin.GoSlice_data_get
    if _newclass:
        data = _swig_property(_skycoin.GoSlice_data_get, _skycoin.GoSlice_data_set)
    __swig_setmethods__["len"] = _skycoin.GoSlice_len_set
    __swig_getmethods__["len"] = _skycoin.GoSlice_len_get
    if _newclass:
        len = _swig_property(_skycoin.GoSlice_len_get, _skycoin.GoSlice_len_set)
    __swig_setmethods__["cap"] = _skycoin.GoSlice_cap_set
    __swig_getmethods__["cap"] = _skycoin.GoSlice_cap_get
    if _newclass:
        cap = _swig_property(_skycoin.GoSlice_cap_get, _skycoin.GoSlice_cap_set)

    def __init__(self):
        this = _skycoin.new_GoSlice()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_GoSlice
    __del__ = lambda self: None
GoSlice_swigregister = _skycoin.GoSlice_swigregister
GoSlice_swigregister(GoSlice)


def SKY_api_NewClient(p0):
    return _skycoin.SKY_api_NewClient(p0)
SKY_api_NewClient = _skycoin.SKY_api_NewClient

def SKY_api_Client_CSRF(p0):
    return _skycoin.SKY_api_Client_CSRF(p0)
SKY_api_Client_CSRF = _skycoin.SKY_api_Client_CSRF

def SKY_api_Client_Version(p0):
    return _skycoin.SKY_api_Client_Version(p0)
SKY_api_Client_Version = _skycoin.SKY_api_Client_Version

def SKY_api_Client_Outputs(p0):
    return _skycoin.SKY_api_Client_Outputs(p0)
SKY_api_Client_Outputs = _skycoin.SKY_api_Client_Outputs

def SKY_api_Client_OutputsForAddresses(p0, p1):
    return _skycoin.SKY_api_Client_OutputsForAddresses(p0, p1)
SKY_api_Client_OutputsForAddresses = _skycoin.SKY_api_Client_OutputsForAddresses

def SKY_api_Client_OutputsForHashes(p0, p1):
    return _skycoin.SKY_api_Client_OutputsForHashes(p0, p1)
SKY_api_Client_OutputsForHashes = _skycoin.SKY_api_Client_OutputsForHashes

def SKY_api_Client_CoinSupply(p0):
    return _skycoin.SKY_api_Client_CoinSupply(p0)
SKY_api_Client_CoinSupply = _skycoin.SKY_api_Client_CoinSupply

def SKY_api_Client_BlockByHash(p0, p1):
    return _skycoin.SKY_api_Client_BlockByHash(p0, p1)
SKY_api_Client_BlockByHash = _skycoin.SKY_api_Client_BlockByHash

def SKY_api_Client_BlockBySeq(p0, p1):
    return _skycoin.SKY_api_Client_BlockBySeq(p0, p1)
SKY_api_Client_BlockBySeq = _skycoin.SKY_api_Client_BlockBySeq

def SKY_api_Client_Blocks(p0, p1):
    return _skycoin.SKY_api_Client_Blocks(p0, p1)
SKY_api_Client_Blocks = _skycoin.SKY_api_Client_Blocks

def SKY_api_Client_LastBlocks(p0, p1):
    return _skycoin.SKY_api_Client_LastBlocks(p0, p1)
SKY_api_Client_LastBlocks = _skycoin.SKY_api_Client_LastBlocks

def SKY_api_Client_BlockchainMetadata(p0):
    return _skycoin.SKY_api_Client_BlockchainMetadata(p0)
SKY_api_Client_BlockchainMetadata = _skycoin.SKY_api_Client_BlockchainMetadata

def SKY_api_Client_BlockchainProgress(p0):
    return _skycoin.SKY_api_Client_BlockchainProgress(p0)
SKY_api_Client_BlockchainProgress = _skycoin.SKY_api_Client_BlockchainProgress

def SKY_api_Client_Balance(p0, p1, p2):
    return _skycoin.SKY_api_Client_Balance(p0, p1, p2)
SKY_api_Client_Balance = _skycoin.SKY_api_Client_Balance

def SKY_api_Client_UxOut(p0, p1):
    return _skycoin.SKY_api_Client_UxOut(p0, p1)
SKY_api_Client_UxOut = _skycoin.SKY_api_Client_UxOut

def SKY_api_Client_AddressUxOuts(p0, p1):
    return _skycoin.SKY_api_Client_AddressUxOuts(p0, p1)
SKY_api_Client_AddressUxOuts = _skycoin.SKY_api_Client_AddressUxOuts

def SKY_api_Client_Wallet(p0, p1):
    return _skycoin.SKY_api_Client_Wallet(p0, p1)
SKY_api_Client_Wallet = _skycoin.SKY_api_Client_Wallet

def SKY_api_Client_Wallets(p0):
    return _skycoin.SKY_api_Client_Wallets(p0)
SKY_api_Client_Wallets = _skycoin.SKY_api_Client_Wallets

def SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3):
    return _skycoin.SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3)
SKY_api_Client_CreateUnencryptedWallet = _skycoin.SKY_api_Client_CreateUnencryptedWallet

def SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4):
    return _skycoin.SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4)
SKY_api_Client_CreateEncryptedWallet = _skycoin.SKY_api_Client_CreateEncryptedWallet

def SKY_api_Client_NewWalletAddress(p0, p1, p2, p3):
    return _skycoin.SKY_api_Client_NewWalletAddress(p0, p1, p2, p3)
SKY_api_Client_NewWalletAddress = _skycoin.SKY_api_Client_NewWalletAddress

def SKY_api_Client_WalletBalance(p0, p1, p2):
    return _skycoin.SKY_api_Client_WalletBalance(p0, p1, p2)
SKY_api_Client_WalletBalance = _skycoin.SKY_api_Client_WalletBalance

def SKY_api_Client_CreateTransaction(p0):
    return _skycoin.SKY_api_Client_CreateTransaction(p0)
SKY_api_Client_CreateTransaction = _skycoin.SKY_api_Client_CreateTransaction

def SKY_api_Client_UpdateWallet(p0, p1, p2):
    return _skycoin.SKY_api_Client_UpdateWallet(p0, p1, p2)
SKY_api_Client_UpdateWallet = _skycoin.SKY_api_Client_UpdateWallet

def SKY_api_Client_WalletFolderName(p0):
    return _skycoin.SKY_api_Client_WalletFolderName(p0)
SKY_api_Client_WalletFolderName = _skycoin.SKY_api_Client_WalletFolderName

def SKY_api_Client_NewSeed(p0, p1):
    return _skycoin.SKY_api_Client_NewSeed(p0, p1)
SKY_api_Client_NewSeed = _skycoin.SKY_api_Client_NewSeed

def SKY_api_Client_WalletSeed(p0, p1, p2):
    return _skycoin.SKY_api_Client_WalletSeed(p0, p1, p2)
SKY_api_Client_WalletSeed = _skycoin.SKY_api_Client_WalletSeed

def SKY_api_Client_NetworkConnection(p0, p1):
    return _skycoin.SKY_api_Client_NetworkConnection(p0, p1)
SKY_api_Client_NetworkConnection = _skycoin.SKY_api_Client_NetworkConnection

def SKY_api_Client_NetworkConnections(p0, p1):
    return _skycoin.SKY_api_Client_NetworkConnections(p0, p1)
SKY_api_Client_NetworkConnections = _skycoin.SKY_api_Client_NetworkConnections

def SKY_api_Client_NetworkDefaultPeers(p0):
    return _skycoin.SKY_api_Client_NetworkDefaultPeers(p0)
SKY_api_Client_NetworkDefaultPeers = _skycoin.SKY_api_Client_NetworkDefaultPeers

def SKY_api_Client_NetworkTrustedPeers(p0):
    return _skycoin.SKY_api_Client_NetworkTrustedPeers(p0)
SKY_api_Client_NetworkTrustedPeers = _skycoin.SKY_api_Client_NetworkTrustedPeers

def SKY_api_Client_NetworkExchangedPeers(p0):
    return _skycoin.SKY_api_Client_NetworkExchangedPeers(p0)
SKY_api_Client_NetworkExchangedPeers = _skycoin.SKY_api_Client_NetworkExchangedPeers

def SKY_api_Client_PendingTransactions(p0):
    return _skycoin.SKY_api_Client_PendingTransactions(p0)
SKY_api_Client_PendingTransactions = _skycoin.SKY_api_Client_PendingTransactions

def SKY_api_Client_Transaction(p0, p1):
    return _skycoin.SKY_api_Client_Transaction(p0, p1)
SKY_api_Client_Transaction = _skycoin.SKY_api_Client_Transaction

def SKY_api_Client_Transactions(p0, p1):
    return _skycoin.SKY_api_Client_Transactions(p0, p1)
SKY_api_Client_Transactions = _skycoin.SKY_api_Client_Transactions

def SKY_api_Client_ConfirmedTransactions(p0, p1):
    return _skycoin.SKY_api_Client_ConfirmedTransactions(p0, p1)
SKY_api_Client_ConfirmedTransactions = _skycoin.SKY_api_Client_ConfirmedTransactions

def SKY_api_Client_UnconfirmedTransactions(p0, p1):
    return _skycoin.SKY_api_Client_UnconfirmedTransactions(p0, p1)
SKY_api_Client_UnconfirmedTransactions = _skycoin.SKY_api_Client_UnconfirmedTransactions

def SKY_api_Client_InjectTransaction(p0, p1):
    return _skycoin.SKY_api_Client_InjectTransaction(p0, p1)
SKY_api_Client_InjectTransaction = _skycoin.SKY_api_Client_InjectTransaction

def SKY_api_Client_ResendUnconfirmedTransactions(p0):
    return _skycoin.SKY_api_Client_ResendUnconfirmedTransactions(p0)
SKY_api_Client_ResendUnconfirmedTransactions = _skycoin.SKY_api_Client_ResendUnconfirmedTransactions

def SKY_api_Client_RawTransaction(p0, p1):
    return _skycoin.SKY_api_Client_RawTransaction(p0, p1)
SKY_api_Client_RawTransaction = _skycoin.SKY_api_Client_RawTransaction

def SKY_api_Client_Richlist(p0, p1):
    return _skycoin.SKY_api_Client_Richlist(p0, p1)
SKY_api_Client_Richlist = _skycoin.SKY_api_Client_Richlist

def SKY_api_Client_AddressCount(p0):
    return _skycoin.SKY_api_Client_AddressCount(p0)
SKY_api_Client_AddressCount = _skycoin.SKY_api_Client_AddressCount

def SKY_api_Client_UnloadWallet(p0, p1):
    return _skycoin.SKY_api_Client_UnloadWallet(p0, p1)
SKY_api_Client_UnloadWallet = _skycoin.SKY_api_Client_UnloadWallet

def SKY_api_Client_Health(p0):
    return _skycoin.SKY_api_Client_Health(p0)
SKY_api_Client_Health = _skycoin.SKY_api_Client_Health

def SKY_api_Client_EncryptWallet(p0, p1, p2):
    return _skycoin.SKY_api_Client_EncryptWallet(p0, p1, p2)
SKY_api_Client_EncryptWallet = _skycoin.SKY_api_Client_EncryptWallet

def SKY_api_Client_DecryptWallet(p0, p1, p2):
    return _skycoin.SKY_api_Client_DecryptWallet(p0, p1, p2)
SKY_api_Client_DecryptWallet = _skycoin.SKY_api_Client_DecryptWallet

def SKY_api_NewCreateTransactionResponse(p0, p1):
    return _skycoin.SKY_api_NewCreateTransactionResponse(p0, p1)
SKY_api_NewCreateTransactionResponse = _skycoin.SKY_api_NewCreateTransactionResponse

def SKY_api_NewCreatedTransaction(p0, p1):
    return _skycoin.SKY_api_NewCreatedTransaction(p0, p1)
SKY_api_NewCreatedTransaction = _skycoin.SKY_api_NewCreatedTransaction

def SKY_api_CreatedTransaction_ToTransaction(p0):
    return _skycoin.SKY_api_CreatedTransaction_ToTransaction(p0)
SKY_api_CreatedTransaction_ToTransaction = _skycoin.SKY_api_CreatedTransaction_ToTransaction

def SKY_api_NewCreatedTransactionOutput(p0, p1):
    return _skycoin.SKY_api_NewCreatedTransactionOutput(p0, p1)
SKY_api_NewCreatedTransactionOutput = _skycoin.SKY_api_NewCreatedTransactionOutput

def SKY_api_NewCreatedTransactionInput(p0):
    return _skycoin.SKY_api_NewCreatedTransactionInput(p0)
SKY_api_NewCreatedTransactionInput = _skycoin.SKY_api_NewCreatedTransactionInput

def SKY_api_NewWalletResponse(p0):
    return _skycoin.SKY_api_NewWalletResponse(p0)
SKY_api_NewWalletResponse = _skycoin.SKY_api_NewWalletResponse

def SKY_cipher_DecodeBase58Address(p0, p1):
    return _skycoin.SKY_cipher_DecodeBase58Address(p0, p1)
SKY_cipher_DecodeBase58Address = _skycoin.SKY_cipher_DecodeBase58Address

def SKY_cipher_AddressFromBytes(p0, p1):
    return _skycoin.SKY_cipher_AddressFromBytes(p0, p1)
SKY_cipher_AddressFromBytes = _skycoin.SKY_cipher_AddressFromBytes

def SKY_cipher_AddressFromPubKey(p0, p1):
    return _skycoin.SKY_cipher_AddressFromPubKey(p0, p1)
SKY_cipher_AddressFromPubKey = _skycoin.SKY_cipher_AddressFromPubKey

def SKY_cipher_AddressFromSecKey(p0, p1):
    return _skycoin.SKY_cipher_AddressFromSecKey(p0, p1)
SKY_cipher_AddressFromSecKey = _skycoin.SKY_cipher_AddressFromSecKey

def SKY_cipher_Address_Null(p0):
    return _skycoin.SKY_cipher_Address_Null(p0)
SKY_cipher_Address_Null = _skycoin.SKY_cipher_Address_Null

def SKY_cipher_Address_Bytes(p0):
    return _skycoin.SKY_cipher_Address_Bytes(p0)
SKY_cipher_Address_Bytes = _skycoin.SKY_cipher_Address_Bytes

def SKY_cipher_Address_Verify(p0, p1):
    return _skycoin.SKY_cipher_Address_Verify(p0, p1)
SKY_cipher_Address_Verify = _skycoin.SKY_cipher_Address_Verify

def SKY_cipher_Address_String(p0):
    return _skycoin.SKY_cipher_Address_String(p0)
SKY_cipher_Address_String = _skycoin.SKY_cipher_Address_String

def SKY_cipher_Address_Checksum(p0, p1):
    return _skycoin.SKY_cipher_Address_Checksum(p0, p1)
SKY_cipher_Address_Checksum = _skycoin.SKY_cipher_Address_Checksum

def SKY_base58_Hex2Base58(p0):
    return _skycoin.SKY_base58_Hex2Base58(p0)
SKY_base58_Hex2Base58 = _skycoin.SKY_base58_Hex2Base58

def SKY_base58_Encode(p0):
    return _skycoin.SKY_base58_Encode(p0)
SKY_base58_Encode = _skycoin.SKY_base58_Encode

def SKY_base58_Decode(p0):
    return _skycoin.SKY_base58_Decode(p0)
SKY_base58_Decode = _skycoin.SKY_base58_Decode

def SKY_base58_String2Hex(p0):
    return _skycoin.SKY_base58_String2Hex(p0)
SKY_base58_String2Hex = _skycoin.SKY_base58_String2Hex

def SKY_cipher_DecodeBase58BitcoinAddress(p0, p1):
    return _skycoin.SKY_cipher_DecodeBase58BitcoinAddress(p0, p1)
SKY_cipher_DecodeBase58BitcoinAddress = _skycoin.SKY_cipher_DecodeBase58BitcoinAddress

def SKY_cipher_BitcoinAddressFromPubKey(p0, p1):
    return _skycoin.SKY_cipher_BitcoinAddressFromPubKey(p0, p1)
SKY_cipher_BitcoinAddressFromPubKey = _skycoin.SKY_cipher_BitcoinAddressFromPubKey

def SKY_cipher_BitcoinAddressFromSecKey(p0, p1):
    return _skycoin.SKY_cipher_BitcoinAddressFromSecKey(p0, p1)
SKY_cipher_BitcoinAddressFromSecKey = _skycoin.SKY_cipher_BitcoinAddressFromSecKey

def SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0):
    return _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0)
SKY_cipher_BitcoinWalletImportFormatFromSeckey = _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey

def SKY_cipher_BitcoinAddressFromBytes(p0, p1):
    return _skycoin.SKY_cipher_BitcoinAddressFromBytes(p0, p1)
SKY_cipher_BitcoinAddressFromBytes = _skycoin.SKY_cipher_BitcoinAddressFromBytes

def SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1):
    return _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1)
SKY_cipher_SecKeyFromBitcoinWalletImportFormat = _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat

def SKY_cipher_BitcoinAddress_Null(p0):
    return _skycoin.SKY_cipher_BitcoinAddress_Null(p0)
SKY_cipher_BitcoinAddress_Null = _skycoin.SKY_cipher_BitcoinAddress_Null

def SKY_cipher_BitcoinAddress_Bytes(p0):
    return _skycoin.SKY_cipher_BitcoinAddress_Bytes(p0)
SKY_cipher_BitcoinAddress_Bytes = _skycoin.SKY_cipher_BitcoinAddress_Bytes

def SKY_cipher_BitcoinAddress_Verify(p0, p1):
    return _skycoin.SKY_cipher_BitcoinAddress_Verify(p0, p1)
SKY_cipher_BitcoinAddress_Verify = _skycoin.SKY_cipher_BitcoinAddress_Verify

def SKY_cipher_BitcoinAddress_String(p0):
    return _skycoin.SKY_cipher_BitcoinAddress_String(p0)
SKY_cipher_BitcoinAddress_String = _skycoin.SKY_cipher_BitcoinAddress_String

def SKY_cipher_BitcoinAddress_Checksum(p0, p1):
    return _skycoin.SKY_cipher_BitcoinAddress_Checksum(p0, p1)
SKY_cipher_BitcoinAddress_Checksum = _skycoin.SKY_cipher_BitcoinAddress_Checksum

def SKY_cipher_RandByte(p0):
    return _skycoin.SKY_cipher_RandByte(p0)
SKY_cipher_RandByte = _skycoin.SKY_cipher_RandByte

def SKY_cipher_NewPubKey(p0, p1):
    return _skycoin.SKY_cipher_NewPubKey(p0, p1)
SKY_cipher_NewPubKey = _skycoin.SKY_cipher_NewPubKey

def SKY_cipher_PubKeyFromHex(p0, p1):
    return _skycoin.SKY_cipher_PubKeyFromHex(p0, p1)
SKY_cipher_PubKeyFromHex = _skycoin.SKY_cipher_PubKeyFromHex

def SKY_cipher_PubKeyFromSecKey(p0, p1):
    return _skycoin.SKY_cipher_PubKeyFromSecKey(p0, p1)
SKY_cipher_PubKeyFromSecKey = _skycoin.SKY_cipher_PubKeyFromSecKey

def SKY_cipher_PubKeyFromSig(p0, p1, p2):
    return _skycoin.SKY_cipher_PubKeyFromSig(p0, p1, p2)
SKY_cipher_PubKeyFromSig = _skycoin.SKY_cipher_PubKeyFromSig

def SKY_cipher_PubKey_Verify(p0):
    return _skycoin.SKY_cipher_PubKey_Verify(p0)
SKY_cipher_PubKey_Verify = _skycoin.SKY_cipher_PubKey_Verify

def SKY_cipher_PubKey_Hex(p0):
    return _skycoin.SKY_cipher_PubKey_Hex(p0)
SKY_cipher_PubKey_Hex = _skycoin.SKY_cipher_PubKey_Hex

def SKY_cipher_PubKeyRipemd160(p0, p1):
    return _skycoin.SKY_cipher_PubKeyRipemd160(p0, p1)
SKY_cipher_PubKeyRipemd160 = _skycoin.SKY_cipher_PubKeyRipemd160

def SKY_cipher_NewSecKey(p0, p1):
    return _skycoin.SKY_cipher_NewSecKey(p0, p1)
SKY_cipher_NewSecKey = _skycoin.SKY_cipher_NewSecKey

def SKY_cipher_SecKeyFromHex(p0, p1):
    return _skycoin.SKY_cipher_SecKeyFromHex(p0, p1)
SKY_cipher_SecKeyFromHex = _skycoin.SKY_cipher_SecKeyFromHex

def SKY_cipher_SecKey_Verify(p0):
    return _skycoin.SKY_cipher_SecKey_Verify(p0)
SKY_cipher_SecKey_Verify = _skycoin.SKY_cipher_SecKey_Verify

def SKY_cipher_SecKey_Hex(p0):
    return _skycoin.SKY_cipher_SecKey_Hex(p0)
SKY_cipher_SecKey_Hex = _skycoin.SKY_cipher_SecKey_Hex

def SKY_cipher_ECDH(p0, p1):
    return _skycoin.SKY_cipher_ECDH(p0, p1)
SKY_cipher_ECDH = _skycoin.SKY_cipher_ECDH

def SKY_cipher_NewSig(p0, p1):
    return _skycoin.SKY_cipher_NewSig(p0, p1)
SKY_cipher_NewSig = _skycoin.SKY_cipher_NewSig

def SKY_cipher_SigFromHex(p0, p1):
    return _skycoin.SKY_cipher_SigFromHex(p0, p1)
SKY_cipher_SigFromHex = _skycoin.SKY_cipher_SigFromHex

def SKY_cipher_Sig_Hex(p0):
    return _skycoin.SKY_cipher_Sig_Hex(p0)
SKY_cipher_Sig_Hex = _skycoin.SKY_cipher_Sig_Hex

def SKY_cipher_SignHash(p0, p1, p2):
    return _skycoin.SKY_cipher_SignHash(p0, p1, p2)
SKY_cipher_SignHash = _skycoin.SKY_cipher_SignHash

def SKY_cipher_VerifyAddressSignedHash(p0, p1, p2):
    return _skycoin.SKY_cipher_VerifyAddressSignedHash(p0, p1, p2)
SKY_cipher_VerifyAddressSignedHash = _skycoin.SKY_cipher_VerifyAddressSignedHash

def SKY_cipher_VerifyPubKeySignedHash(p0, p1, p2):
    return _skycoin.SKY_cipher_VerifyPubKeySignedHash(p0, p1, p2)
SKY_cipher_VerifyPubKeySignedHash = _skycoin.SKY_cipher_VerifyPubKeySignedHash

def SKY_cipher_GenerateKeyPair(p0, p1):
    return _skycoin.SKY_cipher_GenerateKeyPair(p0, p1)
SKY_cipher_GenerateKeyPair = _skycoin.SKY_cipher_GenerateKeyPair

def SKY_cipher_GenerateDeterministicKeyPair(p0, p1, p2):
    return _skycoin.SKY_cipher_GenerateDeterministicKeyPair(p0, p1, p2)
SKY_cipher_GenerateDeterministicKeyPair = _skycoin.SKY_cipher_GenerateDeterministicKeyPair

def SKY_cipher_DeterministicKeyPairIterator(p0, p2, p3):
    return _skycoin.SKY_cipher_DeterministicKeyPairIterator(p0, p2, p3)
SKY_cipher_DeterministicKeyPairIterator = _skycoin.SKY_cipher_DeterministicKeyPairIterator

def SKY_cipher_GenerateDeterministicKeyPairs(*args):
    return _skycoin.SKY_cipher_GenerateDeterministicKeyPairs(*args)
SKY_cipher_GenerateDeterministicKeyPairs = _skycoin.SKY_cipher_GenerateDeterministicKeyPairs

def SKY_cipher_GenerateDeterministicKeyPairsSeed(p0, p1):
    return _skycoin.SKY_cipher_GenerateDeterministicKeyPairsSeed(p0, p1)
SKY_cipher_GenerateDeterministicKeyPairsSeed = _skycoin.SKY_cipher_GenerateDeterministicKeyPairsSeed

def SKY_cipher_CheckSecKey(p0):
    return _skycoin.SKY_cipher_CheckSecKey(p0)
SKY_cipher_CheckSecKey = _skycoin.SKY_cipher_CheckSecKey

def SKY_cipher_CheckSecKeyHash(p0, p1):
    return _skycoin.SKY_cipher_CheckSecKeyHash(p0, p1)
SKY_cipher_CheckSecKeyHash = _skycoin.SKY_cipher_CheckSecKeyHash

def SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2):
    return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2)
SKY_encrypt_ScryptChacha20poly1305_Encrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt

def SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2):
    return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2)
SKY_encrypt_ScryptChacha20poly1305_Decrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt

def SKY_bip39_NewDefaultMnemomic():
    return _skycoin.SKY_bip39_NewDefaultMnemomic()
SKY_bip39_NewDefaultMnemomic = _skycoin.SKY_bip39_NewDefaultMnemomic

def SKY_bip39_NewEntropy(p0):
    return _skycoin.SKY_bip39_NewEntropy(p0)
SKY_bip39_NewEntropy = _skycoin.SKY_bip39_NewEntropy

def SKY_bip39_NewMnemonic(p0):
    return _skycoin.SKY_bip39_NewMnemonic(p0)
SKY_bip39_NewMnemonic = _skycoin.SKY_bip39_NewMnemonic

def SKY_bip39_ValidateMnemonic(p0):
    return _skycoin.SKY_bip39_ValidateMnemonic(p0)
SKY_bip39_ValidateMnemonic = _skycoin.SKY_bip39_ValidateMnemonic

def SKY_bip39_NewSeed(p0, p1):
    return _skycoin.SKY_bip39_NewSeed(p0, p1)
SKY_bip39_NewSeed = _skycoin.SKY_bip39_NewSeed

def SKY_cipher_Ripemd160_Set(p0, p1):
    return _skycoin.SKY_cipher_Ripemd160_Set(p0, p1)
SKY_cipher_Ripemd160_Set = _skycoin.SKY_cipher_Ripemd160_Set

def SKY_cipher_HashRipemd160(p0, p1):
    return _skycoin.SKY_cipher_HashRipemd160(p0, p1)
SKY_cipher_HashRipemd160 = _skycoin.SKY_cipher_HashRipemd160

def SKY_cipher_SHA256_Set(p0, p1):
    return _skycoin.SKY_cipher_SHA256_Set(p0, p1)
SKY_cipher_SHA256_Set = _skycoin.SKY_cipher_SHA256_Set

def SKY_cipher_SHA256_Hex(p0):
    return _skycoin.SKY_cipher_SHA256_Hex(p0)
SKY_cipher_SHA256_Hex = _skycoin.SKY_cipher_SHA256_Hex

def SKY_cipher_SHA256_Xor(p0, p1, p2):
    return _skycoin.SKY_cipher_SHA256_Xor(p0, p1, p2)
SKY_cipher_SHA256_Xor = _skycoin.SKY_cipher_SHA256_Xor

def SKY_cipher_SumSHA256(p0, p1):
    return _skycoin.SKY_cipher_SumSHA256(p0, p1)
SKY_cipher_SumSHA256 = _skycoin.SKY_cipher_SumSHA256

def SKY_cipher_SHA256FromHex(p0, p1):
    return _skycoin.SKY_cipher_SHA256FromHex(p0, p1)
SKY_cipher_SHA256FromHex = _skycoin.SKY_cipher_SHA256FromHex

def SKY_cipher_DoubleSHA256(p0, p1):
    return _skycoin.SKY_cipher_DoubleSHA256(p0, p1)
SKY_cipher_DoubleSHA256 = _skycoin.SKY_cipher_DoubleSHA256

def SKY_cipher_AddSHA256(p0, p1, p2):
    return _skycoin.SKY_cipher_AddSHA256(p0, p1, p2)
SKY_cipher_AddSHA256 = _skycoin.SKY_cipher_AddSHA256

def SKY_cipher_Merkle(p0, p1):
    return _skycoin.SKY_cipher_Merkle(p0, p1)
SKY_cipher_Merkle = _skycoin.SKY_cipher_Merkle

def SKY_cipher_SHA256_Null(p0):
    return _skycoin.SKY_cipher_SHA256_Null(p0)
SKY_cipher_SHA256_Null = _skycoin.SKY_cipher_SHA256_Null

def SKY_secp256k1_PubkeyFromSeckey(p0):
    return _skycoin.SKY_secp256k1_PubkeyFromSeckey(p0)
SKY_secp256k1_PubkeyFromSeckey = _skycoin.SKY_secp256k1_PubkeyFromSeckey

def SKY_secp256k1_VerifyPubkey(p0):
    return _skycoin.SKY_secp256k1_VerifyPubkey(p0)
SKY_secp256k1_VerifyPubkey = _skycoin.SKY_secp256k1_VerifyPubkey

def SKY_secp256k1_VerifySecKey(p0):
    return _skycoin.SKY_secp256k1_VerifySecKey(p0)
SKY_secp256k1_VerifySecKey = _skycoin.SKY_secp256k1_VerifySecKey

def SKY_secp256k1_ECDH(p0, p1):
    return _skycoin.SKY_secp256k1_ECDH(p0, p1)
SKY_secp256k1_ECDH = _skycoin.SKY_secp256k1_ECDH

def SKY_cli_AddPrivateKey(p0, p1):
    return _skycoin.SKY_cli_AddPrivateKey(p0, p1)
SKY_cli_AddPrivateKey = _skycoin.SKY_cli_AddPrivateKey

def SKY_cli_AddPrivateKeyToFile(p0, p1, p2):
    return _skycoin.SKY_cli_AddPrivateKeyToFile(p0, p1, p2)
SKY_cli_AddPrivateKeyToFile = _skycoin.SKY_cli_AddPrivateKeyToFile

def SKY_cli_LoadConfig():
    return _skycoin.SKY_cli_LoadConfig()
SKY_cli_LoadConfig = _skycoin.SKY_cli_LoadConfig

def SKY_cli_Config_FullWalletPath(p0):
    return _skycoin.SKY_cli_Config_FullWalletPath(p0)
SKY_cli_Config_FullWalletPath = _skycoin.SKY_cli_Config_FullWalletPath

def SKY_cli_Config_FullDBPath(p0):
    return _skycoin.SKY_cli_Config_FullDBPath(p0)
SKY_cli_Config_FullDBPath = _skycoin.SKY_cli_Config_FullDBPath

def SKY_cli_NewCLI(p0):
    return _skycoin.SKY_cli_NewCLI(p0)
SKY_cli_NewCLI = _skycoin.SKY_cli_NewCLI

def SKY_cli_NewPasswordReader(p0):
    return _skycoin.SKY_cli_NewPasswordReader(p0)
SKY_cli_NewPasswordReader = _skycoin.SKY_cli_NewPasswordReader

def SKY_cli_PasswordFromBytes_Password():
    return _skycoin.SKY_cli_PasswordFromBytes_Password()
SKY_cli_PasswordFromBytes_Password = _skycoin.SKY_cli_PasswordFromBytes_Password

def SKY_cli_PasswordFromTerm_Password():
    return _skycoin.SKY_cli_PasswordFromTerm_Password()
SKY_cli_PasswordFromTerm_Password = _skycoin.SKY_cli_PasswordFromTerm_Password

def SKY_cli_NewTransaction(p0, p1, p2):
    return _skycoin.SKY_cli_NewTransaction(p0, p1, p2)
SKY_cli_NewTransaction = _skycoin.SKY_cli_NewTransaction

def SKY_cli_GenerateAddressesInFile(p0, p1, p2):
    return _skycoin.SKY_cli_GenerateAddressesInFile(p0, p1, p2)
SKY_cli_GenerateAddressesInFile = _skycoin.SKY_cli_GenerateAddressesInFile

def SKY_cli_FormatAddressesAsJSON(p0):
    return _skycoin.SKY_cli_FormatAddressesAsJSON(p0)
SKY_cli_FormatAddressesAsJSON = _skycoin.SKY_cli_FormatAddressesAsJSON

def SKY_cli_FormatAddressesAsJoinedArray(p0):
    return _skycoin.SKY_cli_FormatAddressesAsJoinedArray(p0)
SKY_cli_FormatAddressesAsJoinedArray = _skycoin.SKY_cli_FormatAddressesAsJoinedArray

def SKY_cli_AddressesToStrings(p0):
    return _skycoin.SKY_cli_AddressesToStrings(p0)
SKY_cli_AddressesToStrings = _skycoin.SKY_cli_AddressesToStrings

def SKY_cli_GenerateWallet(p0, p2):
    return _skycoin.SKY_cli_GenerateWallet(p0, p2)
SKY_cli_GenerateWallet = _skycoin.SKY_cli_GenerateWallet

def SKY_cli_MakeAlphanumericSeed():
    return _skycoin.SKY_cli_MakeAlphanumericSeed()
SKY_cli_MakeAlphanumericSeed = _skycoin.SKY_cli_MakeAlphanumericSeed

def SKY_cli_CLI_Run(p0):
    return _skycoin.SKY_cli_CLI_Run(p0)
SKY_cli_CLI_Run = _skycoin.SKY_cli_CLI_Run

def SKY_cli_Config_GetCoin(p0):
    return _skycoin.SKY_cli_Config_GetCoin(p0)
SKY_cli_Config_GetCoin = _skycoin.SKY_cli_Config_GetCoin

def SKY_cli_Config_GetRPCAddress(p0):
    return _skycoin.SKY_cli_Config_GetRPCAddress(p0)
SKY_cli_Config_GetRPCAddress = _skycoin.SKY_cli_Config_GetRPCAddress

def SKY_cli_Getenv(p0):
    return _skycoin.SKY_cli_Getenv(p0)
SKY_cli_Getenv = _skycoin.SKY_cli_Getenv

def SKY_cli_Setenv(p0, p1):
    return _skycoin.SKY_cli_Setenv(p0, p1)
SKY_cli_Setenv = _skycoin.SKY_cli_Setenv

def SKY_coin_NewBlock(p0, p1, p2, p3, p4):
    return _skycoin.SKY_coin_NewBlock(p0, p1, p2, p3, p4)
SKY_coin_NewBlock = _skycoin.SKY_coin_NewBlock

def SKY_coin_SignedBlock_VerifySignature(p0, p1):
    return _skycoin.SKY_coin_SignedBlock_VerifySignature(p0, p1)
SKY_coin_SignedBlock_VerifySignature = _skycoin.SKY_coin_SignedBlock_VerifySignature

def SKY_coin_NewGenesisBlock(p0, p1, p2):
    return _skycoin.SKY_coin_NewGenesisBlock(p0, p1, p2)
SKY_coin_NewGenesisBlock = _skycoin.SKY_coin_NewGenesisBlock

def SKY_coin_Block_HashHeader(p0, p1):
    return _skycoin.SKY_coin_Block_HashHeader(p0, p1)
SKY_coin_Block_HashHeader = _skycoin.SKY_coin_Block_HashHeader

def SKY_coin_Block_Time(p0):
    return _skycoin.SKY_coin_Block_Time(p0)
SKY_coin_Block_Time = _skycoin.SKY_coin_Block_Time

def SKY_coin_Block_Seq(p0):
    return _skycoin.SKY_coin_Block_Seq(p0)
SKY_coin_Block_Seq = _skycoin.SKY_coin_Block_Seq

def SKY_coin_Block_HashBody(p0, p1):
    return _skycoin.SKY_coin_Block_HashBody(p0, p1)
SKY_coin_Block_HashBody = _skycoin.SKY_coin_Block_HashBody

def SKY_coin_Block_Size(p0):
    return _skycoin.SKY_coin_Block_Size(p0)
SKY_coin_Block_Size = _skycoin.SKY_coin_Block_Size

def SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5):
    return _skycoin.SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5)
SKY_coin_NewBlockHeader = _skycoin.SKY_coin_NewBlockHeader

def SKY_coin_BlockHeader_Hash(p0, p1):
    return _skycoin.SKY_coin_BlockHeader_Hash(p0, p1)
SKY_coin_BlockHeader_Hash = _skycoin.SKY_coin_BlockHeader_Hash

def SKY_coin_BlockHeader_Bytes(p0):
    return _skycoin.SKY_coin_BlockHeader_Bytes(p0)
SKY_coin_BlockHeader_Bytes = _skycoin.SKY_coin_BlockHeader_Bytes

def SKY_coin_BlockBody_Hash(p0, p1):
    return _skycoin.SKY_coin_BlockBody_Hash(p0, p1)
SKY_coin_BlockBody_Hash = _skycoin.SKY_coin_BlockBody_Hash

def SKY_coin_BlockBody_Size():
    return _skycoin.SKY_coin_BlockBody_Size()
SKY_coin_BlockBody_Size = _skycoin.SKY_coin_BlockBody_Size

def SKY_coin_BlockBody_Bytes(p0):
    return _skycoin.SKY_coin_BlockBody_Bytes(p0)
SKY_coin_BlockBody_Bytes = _skycoin.SKY_coin_BlockBody_Bytes

def SKY_coin_CreateUnspents(*args):
    return _skycoin.SKY_coin_CreateUnspents(*args)
SKY_coin_CreateUnspents = _skycoin.SKY_coin_CreateUnspents

def SKY_coin_CreateUnspent(p0, p1, p2, p3):
    return _skycoin.SKY_coin_CreateUnspent(p0, p1, p2, p3)
SKY_coin_CreateUnspent = _skycoin.SKY_coin_CreateUnspent

def SKY_coin_GetBlockObject(p0):
    return _skycoin.SKY_coin_GetBlockObject(p0)
SKY_coin_GetBlockObject = _skycoin.SKY_coin_GetBlockObject

def SKY_coin_GetBlockBody(p0):
    return _skycoin.SKY_coin_GetBlockBody(p0)
SKY_coin_GetBlockBody = _skycoin.SKY_coin_GetBlockBody

def SKY_coin_NewEmptyBlock(p0):
    return _skycoin.SKY_coin_NewEmptyBlock(p0)
SKY_coin_NewEmptyBlock = _skycoin.SKY_coin_NewEmptyBlock

def SKY_coin_Block_GetBlockHeader(p0):
    return _skycoin.SKY_coin_Block_GetBlockHeader(p0)
SKY_coin_Block_GetBlockHeader = _skycoin.SKY_coin_Block_GetBlockHeader

def SKY_coin_GetBlockHeaderObject(p0, p1):
    return _skycoin.SKY_coin_GetBlockHeaderObject(p0, p1)
SKY_coin_GetBlockHeaderObject = _skycoin.SKY_coin_GetBlockHeaderObject

def SKY_coin_BlockHeader_Time(p0):
    return _skycoin.SKY_coin_BlockHeader_Time(p0)
SKY_coin_BlockHeader_Time = _skycoin.SKY_coin_BlockHeader_Time

def SKY_coin_BlockHeader_BkSeq(p0):
    return _skycoin.SKY_coin_BlockHeader_BkSeq(p0)
SKY_coin_BlockHeader_BkSeq = _skycoin.SKY_coin_BlockHeader_BkSeq

def SKY_coin_BlockHeader_UxHash(p0, p1):
    return _skycoin.SKY_coin_BlockHeader_UxHash(p0, p1)
SKY_coin_BlockHeader_UxHash = _skycoin.SKY_coin_BlockHeader_UxHash

def SKY_coin_BlockHeader_Fee(p0):
    return _skycoin.SKY_coin_BlockHeader_Fee(p0)
SKY_coin_BlockHeader_Fee = _skycoin.SKY_coin_BlockHeader_Fee

def SKY_coin_BlockBody_Transactions(p0):
    return _skycoin.SKY_coin_BlockBody_Transactions(p0)
SKY_coin_BlockBody_Transactions = _skycoin.SKY_coin_BlockBody_Transactions

def SKY_coin_BlockHeader_SetTime(p0, p1):
    return _skycoin.SKY_coin_BlockHeader_SetTime(p0, p1)
SKY_coin_BlockHeader_SetTime = _skycoin.SKY_coin_BlockHeader_SetTime

def SKY_coin_BlockHeader_SetBkSeq(p0, p1):
    return _skycoin.SKY_coin_BlockHeader_SetBkSeq(p0, p1)
SKY_coin_BlockHeader_SetBkSeq = _skycoin.SKY_coin_BlockHeader_SetBkSeq

def SKY_coin_BlockHeader_SetFee(p0, p1):
    return _skycoin.SKY_coin_BlockHeader_SetFee(p0, p1)
SKY_coin_BlockHeader_SetFee = _skycoin.SKY_coin_BlockHeader_SetFee

def SKY_coin_BlockHeader_SetVersion(p0, p1):
    return _skycoin.SKY_coin_BlockHeader_SetVersion(p0, p1)
SKY_coin_BlockHeader_SetVersion = _skycoin.SKY_coin_BlockHeader_SetVersion

def SKY_coin_BlockHeader_Version(p0):
    return _skycoin.SKY_coin_BlockHeader_Version(p0)
SKY_coin_BlockHeader_Version = _skycoin.SKY_coin_BlockHeader_Version

def SKY_coin_BlockHeader_PrevHash(p0, p1):
    return _skycoin.SKY_coin_BlockHeader_PrevHash(p0, p1)
SKY_coin_BlockHeader_PrevHash = _skycoin.SKY_coin_BlockHeader_PrevHash

def SKY_coin_UxOut_Hash(p0, p1):
    return _skycoin.SKY_coin_UxOut_Hash(p0, p1)
SKY_coin_UxOut_Hash = _skycoin.SKY_coin_UxOut_Hash

def SKY_coin_UxOut_SnapshotHash(p0, p1):
    return _skycoin.SKY_coin_UxOut_SnapshotHash(p0, p1)
SKY_coin_UxOut_SnapshotHash = _skycoin.SKY_coin_UxOut_SnapshotHash

def SKY_coin_UxBody_Hash(p0, p1):
    return _skycoin.SKY_coin_UxBody_Hash(p0, p1)
SKY_coin_UxBody_Hash = _skycoin.SKY_coin_UxBody_Hash

def SKY_coin_UxOut_CoinHours(p0, p1):
    return _skycoin.SKY_coin_UxOut_CoinHours(p0, p1)
SKY_coin_UxOut_CoinHours = _skycoin.SKY_coin_UxOut_CoinHours

def SKY_coin_UxArray_Hashes(*args):
    return _skycoin.SKY_coin_UxArray_Hashes(*args)
SKY_coin_UxArray_Hashes = _skycoin.SKY_coin_UxArray_Hashes

def SKY_coin_UxArray_HasDupes(*args):
    return _skycoin.SKY_coin_UxArray_HasDupes(*args)
SKY_coin_UxArray_HasDupes = _skycoin.SKY_coin_UxArray_HasDupes

def SKY_coin_UxArray_Sort():
    return _skycoin.SKY_coin_UxArray_Sort()
SKY_coin_UxArray_Sort = _skycoin.SKY_coin_UxArray_Sort

def SKY_coin_UxArray_Len():
    return _skycoin.SKY_coin_UxArray_Len()
SKY_coin_UxArray_Len = _skycoin.SKY_coin_UxArray_Len

def SKY_coin_UxArray_Less(*args):
    return _skycoin.SKY_coin_UxArray_Less(*args)
SKY_coin_UxArray_Less = _skycoin.SKY_coin_UxArray_Less

def SKY_coin_UxArray_Swap(*args):
    return _skycoin.SKY_coin_UxArray_Swap(*args)
SKY_coin_UxArray_Swap = _skycoin.SKY_coin_UxArray_Swap

def SKY_coin_UxArray_Coins(*args):
    return _skycoin.SKY_coin_UxArray_Coins(*args)
SKY_coin_UxArray_Coins = _skycoin.SKY_coin_UxArray_Coins

def SKY_coin_UxArray_CoinHours(*args):
    return _skycoin.SKY_coin_UxArray_CoinHours(*args)
SKY_coin_UxArray_CoinHours = _skycoin.SKY_coin_UxArray_CoinHours

def SKY_coin_UxArray_Sub(*args):
    return _skycoin.SKY_coin_UxArray_Sub(*args)
SKY_coin_UxArray_Sub = _skycoin.SKY_coin_UxArray_Sub

def SKY_coin_UxArray_Add(*args):
    return _skycoin.SKY_coin_UxArray_Add(*args)
SKY_coin_UxArray_Add = _skycoin.SKY_coin_UxArray_Add

def SKY_coin_NewAddressUxOuts(*args):
    return _skycoin.SKY_coin_NewAddressUxOuts(*args)
SKY_coin_NewAddressUxOuts = _skycoin.SKY_coin_NewAddressUxOuts

def SKY_coin_AddressUxOuts_Keys(*args):
    return _skycoin.SKY_coin_AddressUxOuts_Keys(*args)
SKY_coin_AddressUxOuts_Keys = _skycoin.SKY_coin_AddressUxOuts_Keys

def SKY_coin_AddressUxOuts_Flatten(*args):
    return _skycoin.SKY_coin_AddressUxOuts_Flatten(*args)
SKY_coin_AddressUxOuts_Flatten = _skycoin.SKY_coin_AddressUxOuts_Flatten

def SKY_coin_AddressUxOuts_Sub(p0, p1):
    return _skycoin.SKY_coin_AddressUxOuts_Sub(p0, p1)
SKY_coin_AddressUxOuts_Sub = _skycoin.SKY_coin_AddressUxOuts_Sub

def SKY_coin_AddressUxOuts_Add(p0, p1):
    return _skycoin.SKY_coin_AddressUxOuts_Add(p0, p1)
SKY_coin_AddressUxOuts_Add = _skycoin.SKY_coin_AddressUxOuts_Add

def SKY_coin_AddressUxOuts_Get(*args):
    return _skycoin.SKY_coin_AddressUxOuts_Get(*args)
SKY_coin_AddressUxOuts_Get = _skycoin.SKY_coin_AddressUxOuts_Get

def SKY_coin_AddressUxOuts_HasKey(p0, p1):
    return _skycoin.SKY_coin_AddressUxOuts_HasKey(p0, p1)
SKY_coin_AddressUxOuts_HasKey = _skycoin.SKY_coin_AddressUxOuts_HasKey

def SKY_coin_AddressUxOuts_GetOutputLength(p0, p1):
    return _skycoin.SKY_coin_AddressUxOuts_GetOutputLength(p0, p1)
SKY_coin_AddressUxOuts_GetOutputLength = _skycoin.SKY_coin_AddressUxOuts_GetOutputLength

def SKY_coin_AddressUxOuts_Length(p0):
    return _skycoin.SKY_coin_AddressUxOuts_Length(p0)
SKY_coin_AddressUxOuts_Length = _skycoin.SKY_coin_AddressUxOuts_Length

def SKY_coin_AddressUxOuts_Set(*args):
    return _skycoin.SKY_coin_AddressUxOuts_Set(*args)
SKY_coin_AddressUxOuts_Set = _skycoin.SKY_coin_AddressUxOuts_Set

def SKY_coin_Create_Transaction():
    return _skycoin.SKY_coin_Create_Transaction()
SKY_coin_Create_Transaction = _skycoin.SKY_coin_Create_Transaction

def SKY_coin_Transaction_Copy(p0):
    return _skycoin.SKY_coin_Transaction_Copy(p0)
SKY_coin_Transaction_Copy = _skycoin.SKY_coin_Transaction_Copy

def SKY_coin_GetTransactionObject(p0):
    return _skycoin.SKY_coin_GetTransactionObject(p0)
SKY_coin_GetTransactionObject = _skycoin.SKY_coin_GetTransactionObject

def SKY_coin_Transaction_ResetInputs(p0, p1):
    return _skycoin.SKY_coin_Transaction_ResetInputs(p0, p1)
SKY_coin_Transaction_ResetInputs = _skycoin.SKY_coin_Transaction_ResetInputs

def SKY_coin_Transaction_GetInputsCount(p0):
    return _skycoin.SKY_coin_Transaction_GetInputsCount(p0)
SKY_coin_Transaction_GetInputsCount = _skycoin.SKY_coin_Transaction_GetInputsCount

def SKY_coin_Transaction_GetInputAt(p0, p1, p2):
    return _skycoin.SKY_coin_Transaction_GetInputAt(p0, p1, p2)
SKY_coin_Transaction_GetInputAt = _skycoin.SKY_coin_Transaction_GetInputAt

def SKY_coin_Transaction_SetInputAt(p0, p1, p2):
    return _skycoin.SKY_coin_Transaction_SetInputAt(p0, p1, p2)
SKY_coin_Transaction_SetInputAt = _skycoin.SKY_coin_Transaction_SetInputAt

def SKY_coin_Transaction_GetOutputsCount(p0):
    return _skycoin.SKY_coin_Transaction_GetOutputsCount(p0)
SKY_coin_Transaction_GetOutputsCount = _skycoin.SKY_coin_Transaction_GetOutputsCount

def SKY_coin_Transaction_GetOutputAt(p0, p1, p2):
    return _skycoin.SKY_coin_Transaction_GetOutputAt(p0, p1, p2)
SKY_coin_Transaction_GetOutputAt = _skycoin.SKY_coin_Transaction_GetOutputAt

def SKY_coin_Transaction_SetOutputAt(p0, p1, p2):
    return _skycoin.SKY_coin_Transaction_SetOutputAt(p0, p1, p2)
SKY_coin_Transaction_SetOutputAt = _skycoin.SKY_coin_Transaction_SetOutputAt

def SKY_coin_Transaction_GetSignaturesCount(p0):
    return _skycoin.SKY_coin_Transaction_GetSignaturesCount(p0)
SKY_coin_Transaction_GetSignaturesCount = _skycoin.SKY_coin_Transaction_GetSignaturesCount

def SKY_coin_Transaction_GetSignatureAt(p0, p1, p2):
    return _skycoin.SKY_coin_Transaction_GetSignatureAt(p0, p1, p2)
SKY_coin_Transaction_GetSignatureAt = _skycoin.SKY_coin_Transaction_GetSignatureAt

def SKY_coin_Transaction_SetSignatureAt(p0, p1, p2):
    return _skycoin.SKY_coin_Transaction_SetSignatureAt(p0, p1, p2)
SKY_coin_Transaction_SetSignatureAt = _skycoin.SKY_coin_Transaction_SetSignatureAt

def SKY_coin_Transaction_PushSignature(p0, p1):
    return _skycoin.SKY_coin_Transaction_PushSignature(p0, p1)
SKY_coin_Transaction_PushSignature = _skycoin.SKY_coin_Transaction_PushSignature

def SKY_coin_Transaction_ResetOutputs(p0, p1):
    return _skycoin.SKY_coin_Transaction_ResetOutputs(p0, p1)
SKY_coin_Transaction_ResetOutputs = _skycoin.SKY_coin_Transaction_ResetOutputs

def SKY_coin_Transaction_ResetSignatures(p0, p1):
    return _skycoin.SKY_coin_Transaction_ResetSignatures(p0, p1)
SKY_coin_Transaction_ResetSignatures = _skycoin.SKY_coin_Transaction_ResetSignatures

def SKY_coin_Transaction_Verify(p0):
    return _skycoin.SKY_coin_Transaction_Verify(p0)
SKY_coin_Transaction_Verify = _skycoin.SKY_coin_Transaction_Verify

def SKY_coin_Transaction_PushInput(p0, p1):
    return _skycoin.SKY_coin_Transaction_PushInput(p0, p1)
SKY_coin_Transaction_PushInput = _skycoin.SKY_coin_Transaction_PushInput

def SKY_coin_TransactionOutput_UxID(p0, p1, p2):
    return _skycoin.SKY_coin_TransactionOutput_UxID(p0, p1, p2)
SKY_coin_TransactionOutput_UxID = _skycoin.SKY_coin_TransactionOutput_UxID

def SKY_coin_Transaction_PushOutput(p0, p1, p2, p3):
    return _skycoin.SKY_coin_Transaction_PushOutput(p0, p1, p2, p3)
SKY_coin_Transaction_PushOutput = _skycoin.SKY_coin_Transaction_PushOutput

def SKY_coin_Transaction_SignInputs(*args):
    return _skycoin.SKY_coin_Transaction_SignInputs(*args)
SKY_coin_Transaction_SignInputs = _skycoin.SKY_coin_Transaction_SignInputs

def SKY_coin_Transaction_Size(p0):
    return _skycoin.SKY_coin_Transaction_Size(p0)
SKY_coin_Transaction_Size = _skycoin.SKY_coin_Transaction_Size

def SKY_coin_Transaction_Hash(p0, p1):
    return _skycoin.SKY_coin_Transaction_Hash(p0, p1)
SKY_coin_Transaction_Hash = _skycoin.SKY_coin_Transaction_Hash

def SKY_coin_Transaction_SizeHash(p0, p2):
    return _skycoin.SKY_coin_Transaction_SizeHash(p0, p2)
SKY_coin_Transaction_SizeHash = _skycoin.SKY_coin_Transaction_SizeHash

def SKY_coin_Transaction_UpdateHeader(p0):
    return _skycoin.SKY_coin_Transaction_UpdateHeader(p0)
SKY_coin_Transaction_UpdateHeader = _skycoin.SKY_coin_Transaction_UpdateHeader

def SKY_coin_Transaction_HashInner(p0, p1):
    return _skycoin.SKY_coin_Transaction_HashInner(p0, p1)
SKY_coin_Transaction_HashInner = _skycoin.SKY_coin_Transaction_HashInner

def SKY_coin_Transaction_Serialize(p0):
    return _skycoin.SKY_coin_Transaction_Serialize(p0)
SKY_coin_Transaction_Serialize = _skycoin.SKY_coin_Transaction_Serialize

def SKY_coin_TransactionDeserialize(p0):
    return _skycoin.SKY_coin_TransactionDeserialize(p0)
SKY_coin_TransactionDeserialize = _skycoin.SKY_coin_TransactionDeserialize

def SKY_coin_Transaction_OutputHours(p0):
    return _skycoin.SKY_coin_Transaction_OutputHours(p0)
SKY_coin_Transaction_OutputHours = _skycoin.SKY_coin_Transaction_OutputHours

def SKY_coin_Create_Transactions():
    return _skycoin.SKY_coin_Create_Transactions()
SKY_coin_Create_Transactions = _skycoin.SKY_coin_Create_Transactions

def SKY_coin_GetTransactionsObject(p0, p1):
    return _skycoin.SKY_coin_GetTransactionsObject(p0, p1)
SKY_coin_GetTransactionsObject = _skycoin.SKY_coin_GetTransactionsObject

def SKY_coin_Transactions_Length(p0):
    return _skycoin.SKY_coin_Transactions_Length(p0)
SKY_coin_Transactions_Length = _skycoin.SKY_coin_Transactions_Length

def SKY_coin_Transactions_Add(p0, p1):
    return _skycoin.SKY_coin_Transactions_Add(p0, p1)
SKY_coin_Transactions_Add = _skycoin.SKY_coin_Transactions_Add

def SKY_coin_Transactions_Fees(p0, p1):
    return _skycoin.SKY_coin_Transactions_Fees(p0, p1)
SKY_coin_Transactions_Fees = _skycoin.SKY_coin_Transactions_Fees

def SKY_coin_Transactions_GetAt(p0, p1):
    return _skycoin.SKY_coin_Transactions_GetAt(p0, p1)
SKY_coin_Transactions_GetAt = _skycoin.SKY_coin_Transactions_GetAt

def SKY_coin_Transactions_Hashes(*args):
    return _skycoin.SKY_coin_Transactions_Hashes(*args)
SKY_coin_Transactions_Hashes = _skycoin.SKY_coin_Transactions_Hashes

def SKY_coin_Transactions_Size(p0):
    return _skycoin.SKY_coin_Transactions_Size(p0)
SKY_coin_Transactions_Size = _skycoin.SKY_coin_Transactions_Size

def SKY_coin_Transactions_TruncateBytesTo(p0, p1):
    return _skycoin.SKY_coin_Transactions_TruncateBytesTo(p0, p1)
SKY_coin_Transactions_TruncateBytesTo = _skycoin.SKY_coin_Transactions_TruncateBytesTo

def SKY_coin_SortTransactions(p0, p1):
    return _skycoin.SKY_coin_SortTransactions(p0, p1)
SKY_coin_SortTransactions = _skycoin.SKY_coin_SortTransactions

def SKY_coin_NewSortableTransactions(p0, p1):
    return _skycoin.SKY_coin_NewSortableTransactions(p0, p1)
SKY_coin_NewSortableTransactions = _skycoin.SKY_coin_NewSortableTransactions

def SKY_coin_SortableTransactions_Sort(p0):
    return _skycoin.SKY_coin_SortableTransactions_Sort(p0)
SKY_coin_SortableTransactions_Sort = _skycoin.SKY_coin_SortableTransactions_Sort

def SKY_coin_SortableTransactions_Len(p0):
    return _skycoin.SKY_coin_SortableTransactions_Len(p0)
SKY_coin_SortableTransactions_Len = _skycoin.SKY_coin_SortableTransactions_Len

def SKY_coin_SortableTransactions_Less(p0, p1, p2):
    return _skycoin.SKY_coin_SortableTransactions_Less(p0, p1, p2)
SKY_coin_SortableTransactions_Less = _skycoin.SKY_coin_SortableTransactions_Less

def SKY_coin_SortableTransactions_Swap(p0, p1, p2):
    return _skycoin.SKY_coin_SortableTransactions_Swap(p0, p1, p2)
SKY_coin_SortableTransactions_Swap = _skycoin.SKY_coin_SortableTransactions_Swap

def SKY_coin_VerifyTransactionCoinsSpending(*args):
    return _skycoin.SKY_coin_VerifyTransactionCoinsSpending(*args)
SKY_coin_VerifyTransactionCoinsSpending = _skycoin.SKY_coin_VerifyTransactionCoinsSpending

def SKY_coin_VerifyTransactionHoursSpending(*args):
    return _skycoin.SKY_coin_VerifyTransactionHoursSpending(*args)
SKY_coin_VerifyTransactionHoursSpending = _skycoin.SKY_coin_VerifyTransactionHoursSpending

def SKY_coin_VerifyInputSignatures(*args):
    return _skycoin.SKY_coin_VerifyInputSignatures(*args)
SKY_coin_VerifyInputSignatures = _skycoin.SKY_coin_VerifyInputSignatures

def SKY_handle_close(p0):
    return _skycoin.SKY_handle_close(p0)
SKY_handle_close = _skycoin.SKY_handle_close

def SKY_handle_copy(p0):
    return _skycoin.SKY_handle_copy(p0)
SKY_handle_copy = _skycoin.SKY_handle_copy

def SKY_JsonEncode_Handle(p0):
    return _skycoin.SKY_JsonEncode_Handle(p0)
SKY_JsonEncode_Handle = _skycoin.SKY_JsonEncode_Handle

def SKY_Handle_Progress_GetCurrent(p0):
    return _skycoin.SKY_Handle_Progress_GetCurrent(p0)
SKY_Handle_Progress_GetCurrent = _skycoin.SKY_Handle_Progress_GetCurrent

def SKY_Handle_Block_GetHeadSeq(p0):
    return _skycoin.SKY_Handle_Block_GetHeadSeq(p0)
SKY_Handle_Block_GetHeadSeq = _skycoin.SKY_Handle_Block_GetHeadSeq

def SKY_Handle_Block_GetHeadHash(p0):
    return _skycoin.SKY_Handle_Block_GetHeadHash(p0)
SKY_Handle_Block_GetHeadHash = _skycoin.SKY_Handle_Block_GetHeadHash

def SKY_Handle_Block_GetPreviousBlockHash(p0):
    return _skycoin.SKY_Handle_Block_GetPreviousBlockHash(p0)
SKY_Handle_Block_GetPreviousBlockHash = _skycoin.SKY_Handle_Block_GetPreviousBlockHash

def SKY_Handle_Blocks_GetAt(p0, p1):
    return _skycoin.SKY_Handle_Blocks_GetAt(p0, p1)
SKY_Handle_Blocks_GetAt = _skycoin.SKY_Handle_Blocks_GetAt

def SKY_Handle_Blocks_GetCount(p0):
    return _skycoin.SKY_Handle_Blocks_GetCount(p0)
SKY_Handle_Blocks_GetCount = _skycoin.SKY_Handle_Blocks_GetCount

def SKY_Handle_Connections_GetCount(p0):
    return _skycoin.SKY_Handle_Connections_GetCount(p0)
SKY_Handle_Connections_GetCount = _skycoin.SKY_Handle_Connections_GetCount

def SKY_Handle_Strings_GetCount(p0):
    return _skycoin.SKY_Handle_Strings_GetCount(p0)
SKY_Handle_Strings_GetCount = _skycoin.SKY_Handle_Strings_GetCount

def SKY_Handle_Strings_Sort(p0):
    return _skycoin.SKY_Handle_Strings_Sort(p0)
SKY_Handle_Strings_Sort = _skycoin.SKY_Handle_Strings_Sort

def SKY_Handle_Strings_GetAt(p0, p1):
    return _skycoin.SKY_Handle_Strings_GetAt(p0, p1)
SKY_Handle_Strings_GetAt = _skycoin.SKY_Handle_Strings_GetAt

def SKY_api_Handle_Client_GetWalletDir(p0):
    return _skycoin.SKY_api_Handle_Client_GetWalletDir(p0)
SKY_api_Handle_Client_GetWalletDir = _skycoin.SKY_api_Handle_Client_GetWalletDir

def SKY_api_Handle_Client_GetWalletFileName(p0):
    return _skycoin.SKY_api_Handle_Client_GetWalletFileName(p0)
SKY_api_Handle_Client_GetWalletFileName = _skycoin.SKY_api_Handle_Client_GetWalletFileName

def SKY_api_Handle_Client_GetWalletLabel(p0):
    return _skycoin.SKY_api_Handle_Client_GetWalletLabel(p0)
SKY_api_Handle_Client_GetWalletLabel = _skycoin.SKY_api_Handle_Client_GetWalletLabel

def SKY_api_Handle_Client_GetWalletFullPath(p0, p1):
    return _skycoin.SKY_api_Handle_Client_GetWalletFullPath(p0, p1)
SKY_api_Handle_Client_GetWalletFullPath = _skycoin.SKY_api_Handle_Client_GetWalletFullPath

def SKY_api_Handle_GetWalletMeta(p0):
    return _skycoin.SKY_api_Handle_GetWalletMeta(p0)
SKY_api_Handle_GetWalletMeta = _skycoin.SKY_api_Handle_GetWalletMeta

def SKY_api_Handle_GetWalletEntriesCount(p0):
    return _skycoin.SKY_api_Handle_GetWalletEntriesCount(p0)
SKY_api_Handle_GetWalletEntriesCount = _skycoin.SKY_api_Handle_GetWalletEntriesCount

def SKY_api_Handle_Client_GetWalletResponseEntriesCount(p0):
    return _skycoin.SKY_api_Handle_Client_GetWalletResponseEntriesCount(p0)
SKY_api_Handle_Client_GetWalletResponseEntriesCount = _skycoin.SKY_api_Handle_Client_GetWalletResponseEntriesCount

def SKY_api_Handle_WalletGetEntry(p0, p1, p2, p3):
    return _skycoin.SKY_api_Handle_WalletGetEntry(p0, p1, p2, p3)
SKY_api_Handle_WalletGetEntry = _skycoin.SKY_api_Handle_WalletGetEntry

def SKY_api_Handle_WalletResponseGetEntry(p0, p1):
    return _skycoin.SKY_api_Handle_WalletResponseGetEntry(p0, p1)
SKY_api_Handle_WalletResponseGetEntry = _skycoin.SKY_api_Handle_WalletResponseGetEntry

def SKY_api_Handle_WalletResponseIsEncrypted(p0):
    return _skycoin.SKY_api_Handle_WalletResponseIsEncrypted(p0)
SKY_api_Handle_WalletResponseIsEncrypted = _skycoin.SKY_api_Handle_WalletResponseIsEncrypted

def SKY_api_Handle_WalletResponseGetCryptoType(p0):
    return _skycoin.SKY_api_Handle_WalletResponseGetCryptoType(p0)
SKY_api_Handle_WalletResponseGetCryptoType = _skycoin.SKY_api_Handle_WalletResponseGetCryptoType

def SKY_api_Handle_WalletsResponseGetCount(p0):
    return _skycoin.SKY_api_Handle_WalletsResponseGetCount(p0)
SKY_api_Handle_WalletsResponseGetCount = _skycoin.SKY_api_Handle_WalletsResponseGetCount

def SKY_api_Handle_WalletsResponseGetAt(p0, p1):
    return _skycoin.SKY_api_Handle_WalletsResponseGetAt(p0, p1)
SKY_api_Handle_WalletsResponseGetAt = _skycoin.SKY_api_Handle_WalletsResponseGetAt

def SKY_api_Handle_GetWalletFolderAddress(p0):
    return _skycoin.SKY_api_Handle_GetWalletFolderAddress(p0)
SKY_api_Handle_GetWalletFolderAddress = _skycoin.SKY_api_Handle_GetWalletFolderAddress

def SKY_api_Handle_GetWalletSeed(p0):
    return _skycoin.SKY_api_Handle_GetWalletSeed(p0)
SKY_api_Handle_GetWalletSeed = _skycoin.SKY_api_Handle_GetWalletSeed

def SKY_api_Handle_GetWalletLastSeed(p0):
    return _skycoin.SKY_api_Handle_GetWalletLastSeed(p0)
SKY_api_Handle_GetWalletLastSeed = _skycoin.SKY_api_Handle_GetWalletLastSeed

def SKY_api_Handle_GetBuildInfoData(p0):
    return _skycoin.SKY_api_Handle_GetBuildInfoData(p0)
SKY_api_Handle_GetBuildInfoData = _skycoin.SKY_api_Handle_GetBuildInfoData

def SKY_map_Get(p1):
    return _skycoin.SKY_map_Get(p1)
SKY_map_Get = _skycoin.SKY_map_Get

def SKY_map_HasKey(p1):
    return _skycoin.SKY_map_HasKey(p1)
SKY_map_HasKey = _skycoin.SKY_map_HasKey

def SKY_map_Close():
    return _skycoin.SKY_map_Close()
SKY_map_Close = _skycoin.SKY_map_Close

def SKY_params_DropletPrecisionToDivisor(p0):
    return _skycoin.SKY_params_DropletPrecisionToDivisor(p0)
SKY_params_DropletPrecisionToDivisor = _skycoin.SKY_params_DropletPrecisionToDivisor

def SKY_params_DropletPrecisionCheck(p0, p1):
    return _skycoin.SKY_params_DropletPrecisionCheck(p0, p1)
SKY_params_DropletPrecisionCheck = _skycoin.SKY_params_DropletPrecisionCheck

def SKY_testutil_MakeAddress(p0):
    return _skycoin.SKY_testutil_MakeAddress(p0)
SKY_testutil_MakeAddress = _skycoin.SKY_testutil_MakeAddress

def SKY_transaction_ChooseSpendsMaximizeUxOuts(p0, p1, p2):
    return _skycoin.SKY_transaction_ChooseSpendsMaximizeUxOuts(p0, p1, p2)
SKY_transaction_ChooseSpendsMaximizeUxOuts = _skycoin.SKY_transaction_ChooseSpendsMaximizeUxOuts

def SKY_transaction_ChooseSpendsMinimizeUxOuts(p0, p1, p2):
    return _skycoin.SKY_transaction_ChooseSpendsMinimizeUxOuts(p0, p1, p2)
SKY_transaction_ChooseSpendsMinimizeUxOuts = _skycoin.SKY_transaction_ChooseSpendsMinimizeUxOuts

def SKY_transaction_NewUxBalance(p0, p1, p2):
    return _skycoin.SKY_transaction_NewUxBalance(p0, p1, p2)
SKY_transaction_NewUxBalance = _skycoin.SKY_transaction_NewUxBalance

def SKY_transaction_NewUxBalances(p0):
    return _skycoin.SKY_transaction_NewUxBalances(p0)
SKY_transaction_NewUxBalances = _skycoin.SKY_transaction_NewUxBalances

def SKY_transaction_DistributeCoinHoursProportional(p0, p1):
    return _skycoin.SKY_transaction_DistributeCoinHoursProportional(p0, p1)
SKY_transaction_DistributeCoinHoursProportional = _skycoin.SKY_transaction_DistributeCoinHoursProportional

def SKY_transaction_DistributeSpendHours(p0, p1, p2):
    return _skycoin.SKY_transaction_DistributeSpendHours(p0, p1, p2)
SKY_transaction_DistributeSpendHours = _skycoin.SKY_transaction_DistributeSpendHours

def SKY_apputil_CatchInterruptPanic():
    return _skycoin.SKY_apputil_CatchInterruptPanic()
SKY_apputil_CatchInterruptPanic = _skycoin.SKY_apputil_CatchInterruptPanic

def SKY_apputil_CatchDebug():
    return _skycoin.SKY_apputil_CatchDebug()
SKY_apputil_CatchDebug = _skycoin.SKY_apputil_CatchDebug

def SKY_apputil_PrintProgramStatus():
    return _skycoin.SKY_apputil_PrintProgramStatus()
SKY_apputil_PrintProgramStatus = _skycoin.SKY_apputil_PrintProgramStatus

def SKY_certutil_NewTLSCertPair(p0, p1, p2):
    return _skycoin.SKY_certutil_NewTLSCertPair(p0, p1, p2)
SKY_certutil_NewTLSCertPair = _skycoin.SKY_certutil_NewTLSCertPair

def SKY_droplet_FromString(p0):
    return _skycoin.SKY_droplet_FromString(p0)
SKY_droplet_FromString = _skycoin.SKY_droplet_FromString

def SKY_droplet_ToString(p0):
    return _skycoin.SKY_droplet_ToString(p0)
SKY_droplet_ToString = _skycoin.SKY_droplet_ToString

def SKY_fee_VerifyTransactionFee(p0, p1, p2):
    return _skycoin.SKY_fee_VerifyTransactionFee(p0, p1, p2)
SKY_fee_VerifyTransactionFee = _skycoin.SKY_fee_VerifyTransactionFee

def SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2):
    return _skycoin.SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2)
SKY_fee_VerifyTransactionFeeForHours = _skycoin.SKY_fee_VerifyTransactionFeeForHours

def SKY_fee_RequiredFee(p0, p1):
    return _skycoin.SKY_fee_RequiredFee(p0, p1)
SKY_fee_RequiredFee = _skycoin.SKY_fee_RequiredFee

def SKY_fee_RemainingHours(p0, p1):
    return _skycoin.SKY_fee_RemainingHours(p0, p1)
SKY_fee_RemainingHours = _skycoin.SKY_fee_RemainingHours

def SKY_fee_TransactionFee(*args):
    return _skycoin.SKY_fee_TransactionFee(*args)
SKY_fee_TransactionFee = _skycoin.SKY_fee_TransactionFee

def SKY_file_InitDataDir(p0):
    return _skycoin.SKY_file_InitDataDir(p0)
SKY_file_InitDataDir = _skycoin.SKY_file_InitDataDir

def SKY_file_UserHome():
    return _skycoin.SKY_file_UserHome()
SKY_file_UserHome = _skycoin.SKY_file_UserHome

def SKY_file_ResolveResourceDirectory(p0):
    return _skycoin.SKY_file_ResolveResourceDirectory(p0)
SKY_file_ResolveResourceDirectory = _skycoin.SKY_file_ResolveResourceDirectory

def SKY_file_DetermineResourcePath(p0, p1, p2):
    return _skycoin.SKY_file_DetermineResourcePath(p0, p1, p2)
SKY_file_DetermineResourcePath = _skycoin.SKY_file_DetermineResourcePath

def SKY_httphelper_Address_UnmarshalJSON(p0, p1):
    return _skycoin.SKY_httphelper_Address_UnmarshalJSON(p0, p1)
SKY_httphelper_Address_UnmarshalJSON = _skycoin.SKY_httphelper_Address_UnmarshalJSON

def SKY_httphelper_Address_MarshalJSON(p0):
    return _skycoin.SKY_httphelper_Address_MarshalJSON(p0)
SKY_httphelper_Address_MarshalJSON = _skycoin.SKY_httphelper_Address_MarshalJSON

def SKY_httphelper_Coins_UnmarshalJSON(p1):
    return _skycoin.SKY_httphelper_Coins_UnmarshalJSON(p1)
SKY_httphelper_Coins_UnmarshalJSON = _skycoin.SKY_httphelper_Coins_UnmarshalJSON

def SKY_httphelper_Coins_MarshalJSON():
    return _skycoin.SKY_httphelper_Coins_MarshalJSON()
SKY_httphelper_Coins_MarshalJSON = _skycoin.SKY_httphelper_Coins_MarshalJSON

def SKY_httphelper_Coins_Value():
    return _skycoin.SKY_httphelper_Coins_Value()
SKY_httphelper_Coins_Value = _skycoin.SKY_httphelper_Coins_Value

def SKY_httphelper_Hours_UnmarshalJSON(p1):
    return _skycoin.SKY_httphelper_Hours_UnmarshalJSON(p1)
SKY_httphelper_Hours_UnmarshalJSON = _skycoin.SKY_httphelper_Hours_UnmarshalJSON

def SKY_httphelper_Hours_MarshalJSON():
    return _skycoin.SKY_httphelper_Hours_MarshalJSON()
SKY_httphelper_Hours_MarshalJSON = _skycoin.SKY_httphelper_Hours_MarshalJSON

def SKY_httphelper_Hours_Value():
    return _skycoin.SKY_httphelper_Hours_Value()
SKY_httphelper_Hours_Value = _skycoin.SKY_httphelper_Hours_Value

def SKY_iputil_LocalhostIP():
    return _skycoin.SKY_iputil_LocalhostIP()
SKY_iputil_LocalhostIP = _skycoin.SKY_iputil_LocalhostIP

def SKY_iputil_IsLocalhost(p0):
    return _skycoin.SKY_iputil_IsLocalhost(p0)
SKY_iputil_IsLocalhost = _skycoin.SKY_iputil_IsLocalhost

def SKY_iputil_SplitAddr(p0):
    return _skycoin.SKY_iputil_SplitAddr(p0)
SKY_iputil_SplitAddr = _skycoin.SKY_iputil_SplitAddr

def SKY_logging_EnableColors():
    return _skycoin.SKY_logging_EnableColors()
SKY_logging_EnableColors = _skycoin.SKY_logging_EnableColors

def SKY_logging_DisableColors():
    return _skycoin.SKY_logging_DisableColors()
SKY_logging_DisableColors = _skycoin.SKY_logging_DisableColors

def SKY_logging_Disable():
    return _skycoin.SKY_logging_Disable()
SKY_logging_Disable = _skycoin.SKY_logging_Disable

def SKY_util_AddUint64(p0, p1):
    return _skycoin.SKY_util_AddUint64(p0, p1)
SKY_util_AddUint64 = _skycoin.SKY_util_AddUint64

def SKY_util_Uint64ToInt64(p0):
    return _skycoin.SKY_util_Uint64ToInt64(p0)
SKY_util_Uint64ToInt64 = _skycoin.SKY_util_Uint64ToInt64

def SKY_util_Int64ToUint64(p0):
    return _skycoin.SKY_util_Int64ToUint64(p0)
SKY_util_Int64ToUint64 = _skycoin.SKY_util_Int64ToUint64

def SKY_util_IntToUint32(p0):
    return _skycoin.SKY_util_IntToUint32(p0)
SKY_util_IntToUint32 = _skycoin.SKY_util_IntToUint32

def SKY_wallet_NewBalance(p0, p1, p2):
    return _skycoin.SKY_wallet_NewBalance(p0, p1, p2)
SKY_wallet_NewBalance = _skycoin.SKY_wallet_NewBalance

def SKY_wallet_NewBalanceFromUxOut(p0, p1, p2):
    return _skycoin.SKY_wallet_NewBalanceFromUxOut(p0, p1, p2)
SKY_wallet_NewBalanceFromUxOut = _skycoin.SKY_wallet_NewBalanceFromUxOut

def SKY_wallet_Balance_Add(p0, p1, p2):
    return _skycoin.SKY_wallet_Balance_Add(p0, p1, p2)
SKY_wallet_Balance_Add = _skycoin.SKY_wallet_Balance_Add

def SKY_wallet_Balance_Sub(p0, p1, p2):
    return _skycoin.SKY_wallet_Balance_Sub(p0, p1, p2)
SKY_wallet_Balance_Sub = _skycoin.SKY_wallet_Balance_Sub

def SKY_wallet_Balance_Equals(p0, p1):
    return _skycoin.SKY_wallet_Balance_Equals(p0, p1)
SKY_wallet_Balance_Equals = _skycoin.SKY_wallet_Balance_Equals

def SKY_wallet_Balance_IsZero(p0):
    return _skycoin.SKY_wallet_Balance_IsZero(p0)
SKY_wallet_Balance_IsZero = _skycoin.SKY_wallet_Balance_IsZero

def SKY_wallet_CryptoTypeFromString(p0):
    return _skycoin.SKY_wallet_CryptoTypeFromString(p0)
SKY_wallet_CryptoTypeFromString = _skycoin.SKY_wallet_CryptoTypeFromString

def SKY_wallet_Entry_Verify(p0):
    return _skycoin.SKY_wallet_Entry_Verify(p0)
SKY_wallet_Entry_Verify = _skycoin.SKY_wallet_Entry_Verify

def SKY_wallet_Entry_VerifyPublic(p0):
    return _skycoin.SKY_wallet_Entry_VerifyPublic(p0)
SKY_wallet_Entry_VerifyPublic = _skycoin.SKY_wallet_Entry_VerifyPublic

def SKY_wallet_NewReadableEntry(p0, p1):
    return _skycoin.SKY_wallet_NewReadableEntry(p0, p1)
SKY_wallet_NewReadableEntry = _skycoin.SKY_wallet_NewReadableEntry

def SKY_wallet_LoadReadableWallet(p0):
    return _skycoin.SKY_wallet_LoadReadableWallet(p0)
SKY_wallet_LoadReadableWallet = _skycoin.SKY_wallet_LoadReadableWallet

def SKY_wallet_ReadableWallet_Save(p0, p1):
    return _skycoin.SKY_wallet_ReadableWallet_Save(p0, p1)
SKY_wallet_ReadableWallet_Save = _skycoin.SKY_wallet_ReadableWallet_Save

def SKY_wallet_ReadableWallet_Load(p0, p1):
    return _skycoin.SKY_wallet_ReadableWallet_Load(p0, p1)
SKY_wallet_ReadableWallet_Load = _skycoin.SKY_wallet_ReadableWallet_Load

def SKY_wallet_ReadableWallet_Erase(p0):
    return _skycoin.SKY_wallet_ReadableWallet_Erase(p0)
SKY_wallet_ReadableWallet_Erase = _skycoin.SKY_wallet_ReadableWallet_Erase

def SKY_wallet_NewError(p0):
    return _skycoin.SKY_wallet_NewError(p0)
SKY_wallet_NewError = _skycoin.SKY_wallet_NewError

def SKY_wallet_NewWallet(p0, p1):
    return _skycoin.SKY_wallet_NewWallet(p0, p1)
SKY_wallet_NewWallet = _skycoin.SKY_wallet_NewWallet

def SKY_wallet_Wallet_Lock(p0, p1, p2):
    return _skycoin.SKY_wallet_Wallet_Lock(p0, p1, p2)
SKY_wallet_Wallet_Lock = _skycoin.SKY_wallet_Wallet_Lock

def SKY_wallet_Wallet_Unlock(p0, p1):
    return _skycoin.SKY_wallet_Wallet_Unlock(p0, p1)
SKY_wallet_Wallet_Unlock = _skycoin.SKY_wallet_Wallet_Unlock

def SKY_wallet_Load(p0):
    return _skycoin.SKY_wallet_Load(p0)
SKY_wallet_Load = _skycoin.SKY_wallet_Load

def SKY_wallet_Wallet_Save(p0, p1):
    return _skycoin.SKY_wallet_Wallet_Save(p0, p1)
SKY_wallet_Wallet_Save = _skycoin.SKY_wallet_Wallet_Save

def SKY_wallet_Wallet_Validate(p0):
    return _skycoin.SKY_wallet_Wallet_Validate(p0)
SKY_wallet_Wallet_Validate = _skycoin.SKY_wallet_Wallet_Validate

def SKY_wallet_Wallet_Type(p0):
    return _skycoin.SKY_wallet_Wallet_Type(p0)
SKY_wallet_Wallet_Type = _skycoin.SKY_wallet_Wallet_Type

def SKY_wallet_Wallet_Version(p0):
    return _skycoin.SKY_wallet_Wallet_Version(p0)
SKY_wallet_Wallet_Version = _skycoin.SKY_wallet_Wallet_Version

def SKY_wallet_Wallet_Filename(p0):
    return _skycoin.SKY_wallet_Wallet_Filename(p0)
SKY_wallet_Wallet_Filename = _skycoin.SKY_wallet_Wallet_Filename

def SKY_wallet_Wallet_Label(p0):
    return _skycoin.SKY_wallet_Wallet_Label(p0)
SKY_wallet_Wallet_Label = _skycoin.SKY_wallet_Wallet_Label

def SKY_wallet_Wallet_IsEncrypted(p0):
    return _skycoin.SKY_wallet_Wallet_IsEncrypted(p0)
SKY_wallet_Wallet_IsEncrypted = _skycoin.SKY_wallet_Wallet_IsEncrypted

def SKY_wallet_Wallet_GenerateAddresses(p0, p1):
    return _skycoin.SKY_wallet_Wallet_GenerateAddresses(p0, p1)
SKY_wallet_Wallet_GenerateAddresses = _skycoin.SKY_wallet_Wallet_GenerateAddresses

def SKY_wallet_Wallet_GetAddresses(p0):
    return _skycoin.SKY_wallet_Wallet_GetAddresses(p0)
SKY_wallet_Wallet_GetAddresses = _skycoin.SKY_wallet_Wallet_GetAddresses

def SKY_wallet_Wallet_GetEntry(p0, p1, p2):
    return _skycoin.SKY_wallet_Wallet_GetEntry(p0, p1, p2)
SKY_wallet_Wallet_GetEntry = _skycoin.SKY_wallet_Wallet_GetEntry

def SKY_wallet_Wallet_AddEntry(p0, p1):
    return _skycoin.SKY_wallet_Wallet_AddEntry(p0, p1)
SKY_wallet_Wallet_AddEntry = _skycoin.SKY_wallet_Wallet_AddEntry

def SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6):
    return _skycoin.SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6)
SKY_wallet_CreateOptionsHandle = _skycoin.SKY_wallet_CreateOptionsHandle
class api__RichlistParams(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, api__RichlistParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, api__RichlistParams, name)
    __repr__ = _swig_repr
    __swig_setmethods__["N"] = _skycoin.api__RichlistParams_N_set
    __swig_getmethods__["N"] = _skycoin.api__RichlistParams_N_get
    if _newclass:
        N = _swig_property(_skycoin.api__RichlistParams_N_get, _skycoin.api__RichlistParams_N_set)
    __swig_setmethods__["IncludeDistribution"] = _skycoin.api__RichlistParams_IncludeDistribution_set
    __swig_getmethods__["IncludeDistribution"] = _skycoin.api__RichlistParams_IncludeDistribution_get
    if _newclass:
        IncludeDistribution = _swig_property(_skycoin.api__RichlistParams_IncludeDistribution_get, _skycoin.api__RichlistParams_IncludeDistribution_set)

    def __init__(self):
        this = _skycoin.new_api__RichlistParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_api__RichlistParams
    __del__ = lambda self: None
api__RichlistParams_swigregister = _skycoin.api__RichlistParams_swigregister
api__RichlistParams_swigregister(api__RichlistParams)

class api__NetworkConnectionsFilter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, api__NetworkConnectionsFilter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, api__NetworkConnectionsFilter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["States"] = _skycoin.api__NetworkConnectionsFilter_States_set
    __swig_getmethods__["States"] = _skycoin.api__NetworkConnectionsFilter_States_get
    if _newclass:
        States = _swig_property(_skycoin.api__NetworkConnectionsFilter_States_get, _skycoin.api__NetworkConnectionsFilter_States_set)
    __swig_setmethods__["Direction"] = _skycoin.api__NetworkConnectionsFilter_Direction_set
    __swig_getmethods__["Direction"] = _skycoin.api__NetworkConnectionsFilter_Direction_get
    if _newclass:
        Direction = _swig_property(_skycoin.api__NetworkConnectionsFilter_Direction_get, _skycoin.api__NetworkConnectionsFilter_Direction_set)

    def __init__(self):
        this = _skycoin.new_api__NetworkConnectionsFilter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_api__NetworkConnectionsFilter
    __del__ = lambda self: None
api__NetworkConnectionsFilter_swigregister = _skycoin.api__NetworkConnectionsFilter_swigregister
api__NetworkConnectionsFilter_swigregister(api__NetworkConnectionsFilter)

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

    def __eq__(self, a):
        return _skycoin.cipher__Address___eq__(self, a)

    def toStr(self):
        return _skycoin.cipher__Address_toStr(self)
    __swig_setmethods__["Version"] = _skycoin.cipher__Address_Version_set
    __swig_getmethods__["Version"] = _skycoin.cipher__Address_Version_get
    if _newclass:
        Version = _swig_property(_skycoin.cipher__Address_Version_get, _skycoin.cipher__Address_Version_set)
    __swig_setmethods__["Key"] = _skycoin.cipher__Address_Key_set
    __swig_getmethods__["Key"] = _skycoin.cipher__Address_Key_get
    if _newclass:
        Key = _swig_property(_skycoin.cipher__Address_Key_get, _skycoin.cipher__Address_Key_set)

    def __init__(self):
        this = _skycoin.new_cipher__Address()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher__Address
    __del__ = lambda self: None
cipher__Address_swigregister = _skycoin.cipher__Address_swigregister
cipher__Address_swigregister(cipher__Address)

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

    def __eq__(self, a):
        return _skycoin.cipher__BitcoinAddress___eq__(self, a)

    def toStr(self):
        return _skycoin.cipher__BitcoinAddress_toStr(self)
    __swig_setmethods__["Version"] = _skycoin.cipher__BitcoinAddress_Version_set
    __swig_getmethods__["Version"] = _skycoin.cipher__BitcoinAddress_Version_get
    if _newclass:
        Version = _swig_property(_skycoin.cipher__BitcoinAddress_Version_get, _skycoin.cipher__BitcoinAddress_Version_set)
    __swig_setmethods__["Key"] = _skycoin.cipher__BitcoinAddress_Key_set
    __swig_getmethods__["Key"] = _skycoin.cipher__BitcoinAddress_Key_get
    if _newclass:
        Key = _swig_property(_skycoin.cipher__BitcoinAddress_Key_get, _skycoin.cipher__BitcoinAddress_Key_set)

    def __init__(self):
        this = _skycoin.new_cipher__BitcoinAddress()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cipher__BitcoinAddress
    __del__ = lambda self: None
cipher__BitcoinAddress_swigregister = _skycoin.cipher__BitcoinAddress_swigregister
cipher__BitcoinAddress_swigregister(cipher__BitcoinAddress)

class encrypt__ScryptChacha20poly1305(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, encrypt__ScryptChacha20poly1305, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, encrypt__ScryptChacha20poly1305, name)
    __repr__ = _swig_repr
    __swig_setmethods__["N"] = _skycoin.encrypt__ScryptChacha20poly1305_N_set
    __swig_getmethods__["N"] = _skycoin.encrypt__ScryptChacha20poly1305_N_get
    if _newclass:
        N = _swig_property(_skycoin.encrypt__ScryptChacha20poly1305_N_get, _skycoin.encrypt__ScryptChacha20poly1305_N_set)
    __swig_setmethods__["R"] = _skycoin.encrypt__ScryptChacha20poly1305_R_set
    __swig_getmethods__["R"] = _skycoin.encrypt__ScryptChacha20poly1305_R_get
    if _newclass:
        R = _swig_property(_skycoin.encrypt__ScryptChacha20poly1305_R_get, _skycoin.encrypt__ScryptChacha20poly1305_R_set)
    __swig_setmethods__["P"] = _skycoin.encrypt__ScryptChacha20poly1305_P_set
    __swig_getmethods__["P"] = _skycoin.encrypt__ScryptChacha20poly1305_P_get
    if _newclass:
        P = _swig_property(_skycoin.encrypt__ScryptChacha20poly1305_P_get, _skycoin.encrypt__ScryptChacha20poly1305_P_set)
    __swig_setmethods__["KeyLen"] = _skycoin.encrypt__ScryptChacha20poly1305_KeyLen_set
    __swig_getmethods__["KeyLen"] = _skycoin.encrypt__ScryptChacha20poly1305_KeyLen_get
    if _newclass:
        KeyLen = _swig_property(_skycoin.encrypt__ScryptChacha20poly1305_KeyLen_get, _skycoin.encrypt__ScryptChacha20poly1305_KeyLen_set)

    def __init__(self):
        this = _skycoin.new_encrypt__ScryptChacha20poly1305()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_encrypt__ScryptChacha20poly1305
    __del__ = lambda self: None
encrypt__ScryptChacha20poly1305_swigregister = _skycoin.encrypt__ScryptChacha20poly1305_swigregister
encrypt__ScryptChacha20poly1305_swigregister(encrypt__ScryptChacha20poly1305)

class secp256k1go__Field(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, secp256k1go__Field, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, secp256k1go__Field, name)
    __repr__ = _swig_repr
    __swig_setmethods__["n"] = _skycoin.secp256k1go__Field_n_set
    __swig_getmethods__["n"] = _skycoin.secp256k1go__Field_n_get
    if _newclass:
        n = _swig_property(_skycoin.secp256k1go__Field_n_get, _skycoin.secp256k1go__Field_n_set)

    def __init__(self):
        this = _skycoin.new_secp256k1go__Field()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_secp256k1go__Field
    __del__ = lambda self: None
secp256k1go__Field_swigregister = _skycoin.secp256k1go__Field_swigregister
secp256k1go__Field_swigregister(secp256k1go__Field)

class secp256k1go__XY(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, secp256k1go__XY, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, secp256k1go__XY, name)
    __repr__ = _swig_repr
    __swig_setmethods__["X"] = _skycoin.secp256k1go__XY_X_set
    __swig_getmethods__["X"] = _skycoin.secp256k1go__XY_X_get
    if _newclass:
        X = _swig_property(_skycoin.secp256k1go__XY_X_get, _skycoin.secp256k1go__XY_X_set)
    __swig_setmethods__["Y"] = _skycoin.secp256k1go__XY_Y_set
    __swig_getmethods__["Y"] = _skycoin.secp256k1go__XY_Y_get
    if _newclass:
        Y = _swig_property(_skycoin.secp256k1go__XY_Y_get, _skycoin.secp256k1go__XY_Y_set)
    __swig_setmethods__["Infinity"] = _skycoin.secp256k1go__XY_Infinity_set
    __swig_getmethods__["Infinity"] = _skycoin.secp256k1go__XY_Infinity_get
    if _newclass:
        Infinity = _swig_property(_skycoin.secp256k1go__XY_Infinity_get, _skycoin.secp256k1go__XY_Infinity_set)

    def __init__(self):
        this = _skycoin.new_secp256k1go__XY()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_secp256k1go__XY
    __del__ = lambda self: None
secp256k1go__XY_swigregister = _skycoin.secp256k1go__XY_swigregister
secp256k1go__XY_swigregister(secp256k1go__XY)

class secp256k1go__XYZ(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, secp256k1go__XYZ, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, secp256k1go__XYZ, name)
    __repr__ = _swig_repr
    __swig_setmethods__["X"] = _skycoin.secp256k1go__XYZ_X_set
    __swig_getmethods__["X"] = _skycoin.secp256k1go__XYZ_X_get
    if _newclass:
        X = _swig_property(_skycoin.secp256k1go__XYZ_X_get, _skycoin.secp256k1go__XYZ_X_set)
    __swig_setmethods__["Y"] = _skycoin.secp256k1go__XYZ_Y_set
    __swig_getmethods__["Y"] = _skycoin.secp256k1go__XYZ_Y_get
    if _newclass:
        Y = _swig_property(_skycoin.secp256k1go__XYZ_Y_get, _skycoin.secp256k1go__XYZ_Y_set)
    __swig_setmethods__["Z"] = _skycoin.secp256k1go__XYZ_Z_set
    __swig_getmethods__["Z"] = _skycoin.secp256k1go__XYZ_Z_get
    if _newclass:
        Z = _swig_property(_skycoin.secp256k1go__XYZ_Z_get, _skycoin.secp256k1go__XYZ_Z_set)
    __swig_setmethods__["Infinity"] = _skycoin.secp256k1go__XYZ_Infinity_set
    __swig_getmethods__["Infinity"] = _skycoin.secp256k1go__XYZ_Infinity_get
    if _newclass:
        Infinity = _swig_property(_skycoin.secp256k1go__XYZ_Infinity_get, _skycoin.secp256k1go__XYZ_Infinity_set)

    def __init__(self):
        this = _skycoin.new_secp256k1go__XYZ()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_secp256k1go__XYZ
    __del__ = lambda self: None
secp256k1go__XYZ_swigregister = _skycoin.secp256k1go__XYZ_swigregister
secp256k1go__XYZ_swigregister(secp256k1go__XYZ)

class cli__SendAmount(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, cli__SendAmount, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, cli__SendAmount, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Addr"] = _skycoin.cli__SendAmount_Addr_set
    __swig_getmethods__["Addr"] = _skycoin.cli__SendAmount_Addr_get
    if _newclass:
        Addr = _swig_property(_skycoin.cli__SendAmount_Addr_get, _skycoin.cli__SendAmount_Addr_set)
    __swig_setmethods__["Coins"] = _skycoin.cli__SendAmount_Coins_set
    __swig_getmethods__["Coins"] = _skycoin.cli__SendAmount_Coins_get
    if _newclass:
        Coins = _swig_property(_skycoin.cli__SendAmount_Coins_get, _skycoin.cli__SendAmount_Coins_set)

    def __init__(self):
        this = _skycoin.new_cli__SendAmount()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_cli__SendAmount
    __del__ = lambda self: None
cli__SendAmount_swigregister = _skycoin.cli__SendAmount_swigregister
cli__SendAmount_swigregister(cli__SendAmount)

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

    def __eq__(self, t):
        return _skycoin.coin__Transaction___eq__(self, t)
    __swig_setmethods__["Length"] = _skycoin.coin__Transaction_Length_set
    __swig_getmethods__["Length"] = _skycoin.coin__Transaction_Length_get
    if _newclass:
        Length = _swig_property(_skycoin.coin__Transaction_Length_get, _skycoin.coin__Transaction_Length_set)
    __swig_setmethods__["Type"] = _skycoin.coin__Transaction_Type_set
    __swig_getmethods__["Type"] = _skycoin.coin__Transaction_Type_get
    if _newclass:
        Type = _swig_property(_skycoin.coin__Transaction_Type_get, _skycoin.coin__Transaction_Type_set)
    __swig_setmethods__["InnerHash"] = _skycoin.coin__Transaction_InnerHash_set
    __swig_getmethods__["InnerHash"] = _skycoin.coin__Transaction_InnerHash_get
    if _newclass:
        InnerHash = _swig_property(_skycoin.coin__Transaction_InnerHash_get, _skycoin.coin__Transaction_InnerHash_set)
    __swig_setmethods__["Sigs"] = _skycoin.coin__Transaction_Sigs_set
    __swig_getmethods__["Sigs"] = _skycoin.coin__Transaction_Sigs_get
    if _newclass:
        Sigs = _swig_property(_skycoin.coin__Transaction_Sigs_get, _skycoin.coin__Transaction_Sigs_set)
    __swig_setmethods__["In"] = _skycoin.coin__Transaction_In_set
    __swig_getmethods__["In"] = _skycoin.coin__Transaction_In_get
    if _newclass:
        In = _swig_property(_skycoin.coin__Transaction_In_get, _skycoin.coin__Transaction_In_set)
    __swig_setmethods__["Out"] = _skycoin.coin__Transaction_Out_set
    __swig_getmethods__["Out"] = _skycoin.coin__Transaction_Out_get
    if _newclass:
        Out = _swig_property(_skycoin.coin__Transaction_Out_get, _skycoin.coin__Transaction_Out_set)

    def __init__(self):
        this = _skycoin.new_coin__Transaction()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin__Transaction
    __del__ = lambda self: None
coin__Transaction_swigregister = _skycoin.coin__Transaction_swigregister
coin__Transaction_swigregister(coin__Transaction)

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

    def __eq__(self, t):
        return _skycoin.coin__TransactionOutput___eq__(self, t)
    __swig_setmethods__["Address"] = _skycoin.coin__TransactionOutput_Address_set
    __swig_getmethods__["Address"] = _skycoin.coin__TransactionOutput_Address_get
    if _newclass:
        Address = _swig_property(_skycoin.coin__TransactionOutput_Address_get, _skycoin.coin__TransactionOutput_Address_set)
    __swig_setmethods__["Coins"] = _skycoin.coin__TransactionOutput_Coins_set
    __swig_getmethods__["Coins"] = _skycoin.coin__TransactionOutput_Coins_get
    if _newclass:
        Coins = _swig_property(_skycoin.coin__TransactionOutput_Coins_get, _skycoin.coin__TransactionOutput_Coins_set)
    __swig_setmethods__["Hours"] = _skycoin.coin__TransactionOutput_Hours_set
    __swig_getmethods__["Hours"] = _skycoin.coin__TransactionOutput_Hours_get
    if _newclass:
        Hours = _swig_property(_skycoin.coin__TransactionOutput_Hours_get, _skycoin.coin__TransactionOutput_Hours_set)

    def __init__(self):
        this = _skycoin.new_coin__TransactionOutput()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin__TransactionOutput
    __del__ = lambda self: None
coin__TransactionOutput_swigregister = _skycoin.coin__TransactionOutput_swigregister
coin__TransactionOutput_swigregister(coin__TransactionOutput)

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

    def __eq__(self, bh):
        return _skycoin.coin__BlockHeader___eq__(self, bh)
    __swig_setmethods__["Version"] = _skycoin.coin__BlockHeader_Version_set
    __swig_getmethods__["Version"] = _skycoin.coin__BlockHeader_Version_get
    if _newclass:
        Version = _swig_property(_skycoin.coin__BlockHeader_Version_get, _skycoin.coin__BlockHeader_Version_set)
    __swig_setmethods__["Time"] = _skycoin.coin__BlockHeader_Time_set
    __swig_getmethods__["Time"] = _skycoin.coin__BlockHeader_Time_get
    if _newclass:
        Time = _swig_property(_skycoin.coin__BlockHeader_Time_get, _skycoin.coin__BlockHeader_Time_set)
    __swig_setmethods__["BkSeq"] = _skycoin.coin__BlockHeader_BkSeq_set
    __swig_getmethods__["BkSeq"] = _skycoin.coin__BlockHeader_BkSeq_get
    if _newclass:
        BkSeq = _swig_property(_skycoin.coin__BlockHeader_BkSeq_get, _skycoin.coin__BlockHeader_BkSeq_set)
    __swig_setmethods__["Fee"] = _skycoin.coin__BlockHeader_Fee_set
    __swig_getmethods__["Fee"] = _skycoin.coin__BlockHeader_Fee_get
    if _newclass:
        Fee = _swig_property(_skycoin.coin__BlockHeader_Fee_get, _skycoin.coin__BlockHeader_Fee_set)
    __swig_setmethods__["PrevHash"] = _skycoin.coin__BlockHeader_PrevHash_set
    __swig_getmethods__["PrevHash"] = _skycoin.coin__BlockHeader_PrevHash_get
    if _newclass:
        PrevHash = _swig_property(_skycoin.coin__BlockHeader_PrevHash_get, _skycoin.coin__BlockHeader_PrevHash_set)
    __swig_setmethods__["BodyHash"] = _skycoin.coin__BlockHeader_BodyHash_set
    __swig_getmethods__["BodyHash"] = _skycoin.coin__BlockHeader_BodyHash_get
    if _newclass:
        BodyHash = _swig_property(_skycoin.coin__BlockHeader_BodyHash_get, _skycoin.coin__BlockHeader_BodyHash_set)
    __swig_setmethods__["UxHash"] = _skycoin.coin__BlockHeader_UxHash_set
    __swig_getmethods__["UxHash"] = _skycoin.coin__BlockHeader_UxHash_get
    if _newclass:
        UxHash = _swig_property(_skycoin.coin__BlockHeader_UxHash_get, _skycoin.coin__BlockHeader_UxHash_set)

    def __init__(self):
        this = _skycoin.new_coin__BlockHeader()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin__BlockHeader
    __del__ = lambda self: None
coin__BlockHeader_swigregister = _skycoin.coin__BlockHeader_swigregister
coin__BlockHeader_swigregister(coin__BlockHeader)

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

    def __eq__(self, b):
        return _skycoin.coin__BlockBody___eq__(self, b)
    __swig_setmethods__["Transactions"] = _skycoin.coin__BlockBody_Transactions_set
    __swig_getmethods__["Transactions"] = _skycoin.coin__BlockBody_Transactions_get
    if _newclass:
        Transactions = _swig_property(_skycoin.coin__BlockBody_Transactions_get, _skycoin.coin__BlockBody_Transactions_set)

    def __init__(self):
        this = _skycoin.new_coin__BlockBody()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin__BlockBody
    __del__ = lambda self: None
coin__BlockBody_swigregister = _skycoin.coin__BlockBody_swigregister
coin__BlockBody_swigregister(coin__BlockBody)

class coin__Block(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, coin__Block, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, coin__Block, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Head"] = _skycoin.coin__Block_Head_set
    __swig_getmethods__["Head"] = _skycoin.coin__Block_Head_get
    if _newclass:
        Head = _swig_property(_skycoin.coin__Block_Head_get, _skycoin.coin__Block_Head_set)
    __swig_setmethods__["Body"] = _skycoin.coin__Block_Body_set
    __swig_getmethods__["Body"] = _skycoin.coin__Block_Body_get
    if _newclass:
        Body = _swig_property(_skycoin.coin__Block_Body_get, _skycoin.coin__Block_Body_set)

    def __init__(self):
        this = _skycoin.new_coin__Block()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin__Block
    __del__ = lambda self: None
coin__Block_swigregister = _skycoin.coin__Block_swigregister
coin__Block_swigregister(coin__Block)

class coin__SignedBlock(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, coin__SignedBlock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, coin__SignedBlock, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_unnamed"] = _skycoin.coin__SignedBlock__unnamed_set
    __swig_getmethods__["_unnamed"] = _skycoin.coin__SignedBlock__unnamed_get
    if _newclass:
        _unnamed = _swig_property(_skycoin.coin__SignedBlock__unnamed_get, _skycoin.coin__SignedBlock__unnamed_set)
    __swig_setmethods__["Sig"] = _skycoin.coin__SignedBlock_Sig_set
    __swig_getmethods__["Sig"] = _skycoin.coin__SignedBlock_Sig_get
    if _newclass:
        Sig = _swig_property(_skycoin.coin__SignedBlock_Sig_get, _skycoin.coin__SignedBlock_Sig_set)

    def __init__(self):
        this = _skycoin.new_coin__SignedBlock()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin__SignedBlock
    __del__ = lambda self: None
coin__SignedBlock_swigregister = _skycoin.coin__SignedBlock_swigregister
coin__SignedBlock_swigregister(coin__SignedBlock)

class coin__UxHead(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, coin__UxHead, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, coin__UxHead, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Time"] = _skycoin.coin__UxHead_Time_set
    __swig_getmethods__["Time"] = _skycoin.coin__UxHead_Time_get
    if _newclass:
        Time = _swig_property(_skycoin.coin__UxHead_Time_get, _skycoin.coin__UxHead_Time_set)
    __swig_setmethods__["BkSeq"] = _skycoin.coin__UxHead_BkSeq_set
    __swig_getmethods__["BkSeq"] = _skycoin.coin__UxHead_BkSeq_get
    if _newclass:
        BkSeq = _swig_property(_skycoin.coin__UxHead_BkSeq_get, _skycoin.coin__UxHead_BkSeq_set)

    def __init__(self):
        this = _skycoin.new_coin__UxHead()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin__UxHead
    __del__ = lambda self: None
coin__UxHead_swigregister = _skycoin.coin__UxHead_swigregister
coin__UxHead_swigregister(coin__UxHead)

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

    def GetSrcTransaction(self):
        return _skycoin.coin__UxBody_GetSrcTransaction(self)

    def SetSrcTransaction(self, o):
        return _skycoin.coin__UxBody_SetSrcTransaction(self, o)
    __swig_setmethods__["SrcTransaction"] = _skycoin.coin__UxBody_SrcTransaction_set
    __swig_getmethods__["SrcTransaction"] = _skycoin.coin__UxBody_SrcTransaction_get
    if _newclass:
        SrcTransaction = _swig_property(_skycoin.coin__UxBody_SrcTransaction_get, _skycoin.coin__UxBody_SrcTransaction_set)
    __swig_setmethods__["Address"] = _skycoin.coin__UxBody_Address_set
    __swig_getmethods__["Address"] = _skycoin.coin__UxBody_Address_get
    if _newclass:
        Address = _swig_property(_skycoin.coin__UxBody_Address_get, _skycoin.coin__UxBody_Address_set)
    __swig_setmethods__["Coins"] = _skycoin.coin__UxBody_Coins_set
    __swig_getmethods__["Coins"] = _skycoin.coin__UxBody_Coins_get
    if _newclass:
        Coins = _swig_property(_skycoin.coin__UxBody_Coins_get, _skycoin.coin__UxBody_Coins_set)
    __swig_setmethods__["Hours"] = _skycoin.coin__UxBody_Hours_set
    __swig_getmethods__["Hours"] = _skycoin.coin__UxBody_Hours_get
    if _newclass:
        Hours = _swig_property(_skycoin.coin__UxBody_Hours_get, _skycoin.coin__UxBody_Hours_set)

    def __init__(self):
        this = _skycoin.new_coin__UxBody()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin__UxBody
    __del__ = lambda self: None
coin__UxBody_swigregister = _skycoin.coin__UxBody_swigregister
coin__UxBody_swigregister(coin__UxBody)

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

    def __eq__(self, u):
        return _skycoin.coin__UxOut___eq__(self, u)
    __swig_setmethods__["Head"] = _skycoin.coin__UxOut_Head_set
    __swig_getmethods__["Head"] = _skycoin.coin__UxOut_Head_get
    if _newclass:
        Head = _swig_property(_skycoin.coin__UxOut_Head_get, _skycoin.coin__UxOut_Head_set)
    __swig_setmethods__["Body"] = _skycoin.coin__UxOut_Body_set
    __swig_getmethods__["Body"] = _skycoin.coin__UxOut_Body_get
    if _newclass:
        Body = _swig_property(_skycoin.coin__UxOut_Body_get, _skycoin.coin__UxOut_Body_set)

    def __init__(self):
        this = _skycoin.new_coin__UxOut()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_coin__UxOut
    __del__ = lambda self: None
coin__UxOut_swigregister = _skycoin.coin__UxOut_swigregister
coin__UxOut_swigregister(coin__UxOut)

class httphelper__Address(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, httphelper__Address, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, httphelper__Address, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_unnamed"] = _skycoin.httphelper__Address__unnamed_set
    __swig_getmethods__["_unnamed"] = _skycoin.httphelper__Address__unnamed_get
    if _newclass:
        _unnamed = _swig_property(_skycoin.httphelper__Address__unnamed_get, _skycoin.httphelper__Address__unnamed_set)

    def __init__(self):
        this = _skycoin.new_httphelper__Address()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_httphelper__Address
    __del__ = lambda self: None
httphelper__Address_swigregister = _skycoin.httphelper__Address_swigregister
httphelper__Address_swigregister(httphelper__Address)

class httphelper__SHA256(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, httphelper__SHA256, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, httphelper__SHA256, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_unnamed"] = _skycoin.httphelper__SHA256__unnamed_set
    __swig_getmethods__["_unnamed"] = _skycoin.httphelper__SHA256__unnamed_get
    if _newclass:
        _unnamed = _swig_property(_skycoin.httphelper__SHA256__unnamed_get, _skycoin.httphelper__SHA256__unnamed_set)

    def __init__(self):
        this = _skycoin.new_httphelper__SHA256()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_httphelper__SHA256
    __del__ = lambda self: None
httphelper__SHA256_swigregister = _skycoin.httphelper__SHA256_swigregister
httphelper__SHA256_swigregister(httphelper__SHA256)

class wallet__Balance(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wallet__Balance, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wallet__Balance, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Coins"] = _skycoin.wallet__Balance_Coins_set
    __swig_getmethods__["Coins"] = _skycoin.wallet__Balance_Coins_get
    if _newclass:
        Coins = _swig_property(_skycoin.wallet__Balance_Coins_get, _skycoin.wallet__Balance_Coins_set)
    __swig_setmethods__["Hours"] = _skycoin.wallet__Balance_Hours_set
    __swig_getmethods__["Hours"] = _skycoin.wallet__Balance_Hours_get
    if _newclass:
        Hours = _swig_property(_skycoin.wallet__Balance_Hours_get, _skycoin.wallet__Balance_Hours_set)

    def __init__(self):
        this = _skycoin.new_wallet__Balance()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_wallet__Balance
    __del__ = lambda self: None
wallet__Balance_swigregister = _skycoin.wallet__Balance_swigregister
wallet__Balance_swigregister(wallet__Balance)

class wallet__BalancePair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wallet__BalancePair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wallet__BalancePair, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Confirmed"] = _skycoin.wallet__BalancePair_Confirmed_set
    __swig_getmethods__["Confirmed"] = _skycoin.wallet__BalancePair_Confirmed_get
    if _newclass:
        Confirmed = _swig_property(_skycoin.wallet__BalancePair_Confirmed_get, _skycoin.wallet__BalancePair_Confirmed_set)
    __swig_setmethods__["Predicted"] = _skycoin.wallet__BalancePair_Predicted_set
    __swig_getmethods__["Predicted"] = _skycoin.wallet__BalancePair_Predicted_get
    if _newclass:
        Predicted = _swig_property(_skycoin.wallet__BalancePair_Predicted_get, _skycoin.wallet__BalancePair_Predicted_set)

    def __init__(self):
        this = _skycoin.new_wallet__BalancePair()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_wallet__BalancePair
    __del__ = lambda self: None
wallet__BalancePair_swigregister = _skycoin.wallet__BalancePair_swigregister
wallet__BalancePair_swigregister(wallet__BalancePair)

class wallet__Entry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wallet__Entry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wallet__Entry, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Address"] = _skycoin.wallet__Entry_Address_set
    __swig_getmethods__["Address"] = _skycoin.wallet__Entry_Address_get
    if _newclass:
        Address = _swig_property(_skycoin.wallet__Entry_Address_get, _skycoin.wallet__Entry_Address_set)
    __swig_setmethods__["Public"] = _skycoin.wallet__Entry_Public_set
    __swig_getmethods__["Public"] = _skycoin.wallet__Entry_Public_get
    if _newclass:
        Public = _swig_property(_skycoin.wallet__Entry_Public_get, _skycoin.wallet__Entry_Public_set)
    __swig_setmethods__["Secret"] = _skycoin.wallet__Entry_Secret_set
    __swig_getmethods__["Secret"] = _skycoin.wallet__Entry_Secret_get
    if _newclass:
        Secret = _swig_property(_skycoin.wallet__Entry_Secret_get, _skycoin.wallet__Entry_Secret_set)

    def __init__(self):
        this = _skycoin.new_wallet__Entry()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_wallet__Entry
    __del__ = lambda self: None
wallet__Entry_swigregister = _skycoin.wallet__Entry_swigregister
wallet__Entry_swigregister(wallet__Entry)

class wallet__Note(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wallet__Note, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wallet__Note, name)
    __repr__ = _swig_repr
    __swig_setmethods__["TxID"] = _skycoin.wallet__Note_TxID_set
    __swig_getmethods__["TxID"] = _skycoin.wallet__Note_TxID_get
    if _newclass:
        TxID = _swig_property(_skycoin.wallet__Note_TxID_get, _skycoin.wallet__Note_TxID_set)
    __swig_setmethods__["Value"] = _skycoin.wallet__Note_Value_set
    __swig_getmethods__["Value"] = _skycoin.wallet__Note_Value_get
    if _newclass:
        Value = _swig_property(_skycoin.wallet__Note_Value_get, _skycoin.wallet__Note_Value_set)

    def __init__(self):
        this = _skycoin.new_wallet__Note()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_wallet__Note
    __del__ = lambda self: None
wallet__Note_swigregister = _skycoin.wallet__Note_swigregister
wallet__Note_swigregister(wallet__Note)

class wallet__ReadableNote(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, wallet__ReadableNote, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, wallet__ReadableNote, name)
    __repr__ = _swig_repr
    __swig_setmethods__["TransactionID"] = _skycoin.wallet__ReadableNote_TransactionID_set
    __swig_getmethods__["TransactionID"] = _skycoin.wallet__ReadableNote_TransactionID_get
    if _newclass:
        TransactionID = _swig_property(_skycoin.wallet__ReadableNote_TransactionID_get, _skycoin.wallet__ReadableNote_TransactionID_set)
    __swig_setmethods__["ActualNote"] = _skycoin.wallet__ReadableNote_ActualNote_set
    __swig_getmethods__["ActualNote"] = _skycoin.wallet__ReadableNote_ActualNote_get
    if _newclass:
        ActualNote = _swig_property(_skycoin.wallet__ReadableNote_ActualNote_get, _skycoin.wallet__ReadableNote_ActualNote_set)

    def __init__(self):
        this = _skycoin.new_wallet__ReadableNote()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_wallet__ReadableNote
    __del__ = lambda self: None
wallet__ReadableNote_swigregister = _skycoin.wallet__ReadableNote_swigregister
wallet__ReadableNote_swigregister(wallet__ReadableNote)

class transaction__UxBalance(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, transaction__UxBalance, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, transaction__UxBalance, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Hash"] = _skycoin.transaction__UxBalance_Hash_set
    __swig_getmethods__["Hash"] = _skycoin.transaction__UxBalance_Hash_get
    if _newclass:
        Hash = _swig_property(_skycoin.transaction__UxBalance_Hash_get, _skycoin.transaction__UxBalance_Hash_set)
    __swig_setmethods__["BkSeq"] = _skycoin.transaction__UxBalance_BkSeq_set
    __swig_getmethods__["BkSeq"] = _skycoin.transaction__UxBalance_BkSeq_get
    if _newclass:
        BkSeq = _swig_property(_skycoin.transaction__UxBalance_BkSeq_get, _skycoin.transaction__UxBalance_BkSeq_set)
    __swig_setmethods__["Address"] = _skycoin.transaction__UxBalance_Address_set
    __swig_getmethods__["Address"] = _skycoin.transaction__UxBalance_Address_get
    if _newclass:
        Address = _swig_property(_skycoin.transaction__UxBalance_Address_get, _skycoin.transaction__UxBalance_Address_set)
    __swig_setmethods__["Coins"] = _skycoin.transaction__UxBalance_Coins_set
    __swig_getmethods__["Coins"] = _skycoin.transaction__UxBalance_Coins_get
    if _newclass:
        Coins = _swig_property(_skycoin.transaction__UxBalance_Coins_get, _skycoin.transaction__UxBalance_Coins_set)
    __swig_setmethods__["Hours"] = _skycoin.transaction__UxBalance_Hours_set
    __swig_getmethods__["Hours"] = _skycoin.transaction__UxBalance_Hours_get
    if _newclass:
        Hours = _swig_property(_skycoin.transaction__UxBalance_Hours_get, _skycoin.transaction__UxBalance_Hours_set)
    __swig_setmethods__["InitialHours"] = _skycoin.transaction__UxBalance_InitialHours_set
    __swig_getmethods__["InitialHours"] = _skycoin.transaction__UxBalance_InitialHours_get
    if _newclass:
        InitialHours = _swig_property(_skycoin.transaction__UxBalance_InitialHours_get, _skycoin.transaction__UxBalance_InitialHours_set)
    __swig_setmethods__["SrcTransaction"] = _skycoin.transaction__UxBalance_SrcTransaction_set
    __swig_getmethods__["SrcTransaction"] = _skycoin.transaction__UxBalance_SrcTransaction_get
    if _newclass:
        SrcTransaction = _swig_property(_skycoin.transaction__UxBalance_SrcTransaction_get, _skycoin.transaction__UxBalance_SrcTransaction_set)

    def __init__(self):
        this = _skycoin.new_transaction__UxBalance()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_transaction__UxBalance
    __del__ = lambda self: None
transaction__UxBalance_swigregister = _skycoin.transaction__UxBalance_swigregister
transaction__UxBalance_swigregister(transaction__UxBalance)

class api__TransactionInput(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, api__TransactionInput, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, api__TransactionInput, name)
    __repr__ = _swig_repr
    __swig_setmethods__["UxOut"] = _skycoin.api__TransactionInput_UxOut_set
    __swig_getmethods__["UxOut"] = _skycoin.api__TransactionInput_UxOut_get
    if _newclass:
        UxOut = _swig_property(_skycoin.api__TransactionInput_UxOut_get, _skycoin.api__TransactionInput_UxOut_set)
    __swig_setmethods__["CalculatedHours"] = _skycoin.api__TransactionInput_CalculatedHours_set
    __swig_getmethods__["CalculatedHours"] = _skycoin.api__TransactionInput_CalculatedHours_get
    if _newclass:
        CalculatedHours = _swig_property(_skycoin.api__TransactionInput_CalculatedHours_get, _skycoin.api__TransactionInput_CalculatedHours_set)

    def __init__(self):
        this = _skycoin.new_api__TransactionInput()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_api__TransactionInput
    __del__ = lambda self: None
api__TransactionInput_swigregister = _skycoin.api__TransactionInput_swigregister
api__TransactionInput_swigregister(api__TransactionInput)

SKY_OK = _skycoin.SKY_OK
SKY_ERROR = _skycoin.SKY_ERROR
SKY_BAD_HANDLE = _skycoin.SKY_BAD_HANDLE
SKY_INVALID_TIMESTRING = _skycoin.SKY_INVALID_TIMESTRING
SKY_PKG_API = _skycoin.SKY_PKG_API
SKY_PKG_CIPHER = _skycoin.SKY_PKG_CIPHER
SKY_PKG_CLI = _skycoin.SKY_PKG_CLI
SKY_PKG_COIN = _skycoin.SKY_PKG_COIN
SKY_PKG_CONSENSUS = _skycoin.SKY_PKG_CONSENSUS
SKY_PKG_DAEMON = _skycoin.SKY_PKG_DAEMON
SKY_PKG_GUI = _skycoin.SKY_PKG_GUI
SKY_PKG_SKYCOIN = _skycoin.SKY_PKG_SKYCOIN
SKY_PKG_UTIL = _skycoin.SKY_PKG_UTIL
SKY_PKG_VISOR = _skycoin.SKY_PKG_VISOR
SKY_PKG_WALLET = _skycoin.SKY_PKG_WALLET
SKY_PKG_PARAMS = _skycoin.SKY_PKG_PARAMS
SKY_PKG_LIBCGO = _skycoin.SKY_PKG_LIBCGO
SKY_ErrAddressInvalidLength = _skycoin.SKY_ErrAddressInvalidLength
SKY_ErrAddressInvalidChecksum = _skycoin.SKY_ErrAddressInvalidChecksum
SKY_ErrAddressInvalidVersion = _skycoin.SKY_ErrAddressInvalidVersion
SKY_ErrAddressInvalidPubKey = _skycoin.SKY_ErrAddressInvalidPubKey
SKY_ErrAddressInvalidFirstByte = _skycoin.SKY_ErrAddressInvalidFirstByte
SKY_ErrAddressInvalidLastByte = _skycoin.SKY_ErrAddressInvalidLastByte
SKY_ErrBufferUnderflow = _skycoin.SKY_ErrBufferUnderflow
SKY_ErrInvalidOmitEmpty = _skycoin.SKY_ErrInvalidOmitEmpty
SKY_ErrInvalidLengthPubKey = _skycoin.SKY_ErrInvalidLengthPubKey
SKY_ErrPubKeyFromNullSecKey = _skycoin.SKY_ErrPubKeyFromNullSecKey
SKY_ErrPubKeyFromBadSecKey = _skycoin.SKY_ErrPubKeyFromBadSecKey
SKY_ErrInvalidLengthSecKey = _skycoin.SKY_ErrInvalidLengthSecKey
SKY_ErrECHDInvalidPubKey = _skycoin.SKY_ErrECHDInvalidPubKey
SKY_ErrECHDInvalidSecKey = _skycoin.SKY_ErrECHDInvalidSecKey
SKY_ErrInvalidLengthSig = _skycoin.SKY_ErrInvalidLengthSig
SKY_ErrInvalidLengthRipemd160 = _skycoin.SKY_ErrInvalidLengthRipemd160
SKY_ErrInvalidLengthSHA256 = _skycoin.SKY_ErrInvalidLengthSHA256
SKY_ErrInvalidBase58Char = _skycoin.SKY_ErrInvalidBase58Char
SKY_ErrInvalidBase58String = _skycoin.SKY_ErrInvalidBase58String
SKY_ErrInvalidBase58Length = _skycoin.SKY_ErrInvalidBase58Length
SKY_ErrInvalidHexLength = _skycoin.SKY_ErrInvalidHexLength
SKY_ErrInvalidBytesLength = _skycoin.SKY_ErrInvalidBytesLength
SKY_ErrInvalidPubKey = _skycoin.SKY_ErrInvalidPubKey
SKY_ErrInvalidSecKey = _skycoin.SKY_ErrInvalidSecKey
SKY_ErrInvalidSigPubKeyRecovery = _skycoin.SKY_ErrInvalidSigPubKeyRecovery
SKY_ErrInvalidSecKeyHex = _skycoin.SKY_ErrInvalidSecKeyHex
SKY_ErrInvalidAddressForSig = _skycoin.SKY_ErrInvalidAddressForSig
SKY_ErrInvalidHashForSig = _skycoin.SKY_ErrInvalidHashForSig
SKY_ErrPubKeyRecoverMismatch = _skycoin.SKY_ErrPubKeyRecoverMismatch
SKY_ErrInvalidSigInvalidPubKey = _skycoin.SKY_ErrInvalidSigInvalidPubKey
SKY_ErrInvalidSigValidity = _skycoin.SKY_ErrInvalidSigValidity
SKY_ErrInvalidSigForMessage = _skycoin.SKY_ErrInvalidSigForMessage
SKY_ErrInvalidSecKyVerification = _skycoin.SKY_ErrInvalidSecKyVerification
SKY_ErrNullPubKeyFromSecKey = _skycoin.SKY_ErrNullPubKeyFromSecKey
SKY_ErrInvalidDerivedPubKeyFromSecKey = _skycoin.SKY_ErrInvalidDerivedPubKeyFromSecKey
SKY_ErrInvalidPubKeyFromHash = _skycoin.SKY_ErrInvalidPubKeyFromHash
SKY_ErrPubKeyFromSecKeyMismatch = _skycoin.SKY_ErrPubKeyFromSecKeyMismatch
SKY_ErrInvalidLength = _skycoin.SKY_ErrInvalidLength
SKY_ErrBitcoinWIFInvalidFirstByte = _skycoin.SKY_ErrBitcoinWIFInvalidFirstByte
SKY_ErrBitcoinWIFInvalidSuffix = _skycoin.SKY_ErrBitcoinWIFInvalidSuffix
SKY_ErrBitcoinWIFInvalidChecksum = _skycoin.SKY_ErrBitcoinWIFInvalidChecksum
SKY_ErrEmptySeed = _skycoin.SKY_ErrEmptySeed
SKY_ErrInvalidSig = _skycoin.SKY_ErrInvalidSig
SKY_ErrMissingPassword = _skycoin.SKY_ErrMissingPassword
SKY_ErrDataTooLarge = _skycoin.SKY_ErrDataTooLarge
SKY_ErrInvalidChecksumLength = _skycoin.SKY_ErrInvalidChecksumLength
SKY_ErrInvalidChecksum = _skycoin.SKY_ErrInvalidChecksum
SKY_ErrInvalidNonceLength = _skycoin.SKY_ErrInvalidNonceLength
SKY_ErrInvalidBlockSize = _skycoin.SKY_ErrInvalidBlockSize
SKY_ErrReadDataHashFailed = _skycoin.SKY_ErrReadDataHashFailed
SKY_ErrInvalidPassword = _skycoin.SKY_ErrInvalidPassword
SKY_ErrReadDataLengthFailed = _skycoin.SKY_ErrReadDataLengthFailed
SKY_ErrInvalidDataLength = _skycoin.SKY_ErrInvalidDataLength
SKY_ErrTemporaryInsufficientBalance = _skycoin.SKY_ErrTemporaryInsufficientBalance
SKY_ErrAddress = _skycoin.SKY_ErrAddress
SKY_ErrWalletName = _skycoin.SKY_ErrWalletName
SKY_ErrJSONMarshal = _skycoin.SKY_ErrJSONMarshal
SKY_WalletLoadError = _skycoin.SKY_WalletLoadError
SKY_WalletSaveError = _skycoin.SKY_WalletSaveError
SKY_ErrAddEarnedCoinHoursAdditionOverflow = _skycoin.SKY_ErrAddEarnedCoinHoursAdditionOverflow
SKY_ErrUint64MultOverflow = _skycoin.SKY_ErrUint64MultOverflow
SKY_ErrUint64AddOverflow = _skycoin.SKY_ErrUint64AddOverflow
SKY_ErrUint32AddOverflow = _skycoin.SKY_ErrUint32AddOverflow
SKY_ErrUint64OverflowsInt64 = _skycoin.SKY_ErrUint64OverflowsInt64
SKY_ErrInt64UnderflowsUint64 = _skycoin.SKY_ErrInt64UnderflowsUint64
SKY_ErrIntUnderflowsUint32 = _skycoin.SKY_ErrIntUnderflowsUint32
SKY_ErrIntOverflowsUint32 = _skycoin.SKY_ErrIntOverflowsUint32
SKY_ErrPeerlistFull = _skycoin.SKY_ErrPeerlistFull
SKY_ErrInvalidAddress = _skycoin.SKY_ErrInvalidAddress
SKY_ErrNoLocalhost = _skycoin.SKY_ErrNoLocalhost
SKY_ErrNotExternalIP = _skycoin.SKY_ErrNotExternalIP
SKY_ErrPortTooLow = _skycoin.SKY_ErrPortTooLow
SKY_ErrBlacklistedAddress = _skycoin.SKY_ErrBlacklistedAddress
SKY_ErrDisconnectWriteFailed = _skycoin.SKY_ErrDisconnectWriteFailed
SKY_ErrDisconnectSetReadDeadlineFailed = _skycoin.SKY_ErrDisconnectSetReadDeadlineFailed
SKY_ErrDisconnectInvalidMessageLength = _skycoin.SKY_ErrDisconnectInvalidMessageLength
SKY_ErrDisconnectMalformedMessage = _skycoin.SKY_ErrDisconnectMalformedMessage
SKY_ErrDisconnectUnknownMessage = _skycoin.SKY_ErrDisconnectUnknownMessage
SKY_ErrConnectionPoolClosed = _skycoin.SKY_ErrConnectionPoolClosed
SKY_ErrWriteQueueFull = _skycoin.SKY_ErrWriteQueueFull
SKY_ErrNoReachableConnections = _skycoin.SKY_ErrNoReachableConnections
SKY_ErrMaxDefaultConnectionsReached = _skycoin.SKY_ErrMaxDefaultConnectionsReached
SKY_ErrDisconnectVersionNotSupported = _skycoin.SKY_ErrDisconnectVersionNotSupported
SKY_ErrDisconnectIntroductionTimeout = _skycoin.SKY_ErrDisconnectIntroductionTimeout
SKY_ErrDisconnectIsBlacklisted = _skycoin.SKY_ErrDisconnectIsBlacklisted
SKY_ErrDisconnectSelf = _skycoin.SKY_ErrDisconnectSelf
SKY_ErrDisconnectConnectedTwice = _skycoin.SKY_ErrDisconnectConnectedTwice
SKY_ErrDisconnectIdle = _skycoin.SKY_ErrDisconnectIdle
SKY_ErrDisconnectNoIntroduction = _skycoin.SKY_ErrDisconnectNoIntroduction
SKY_ErrDisconnectIPLimitReached = _skycoin.SKY_ErrDisconnectIPLimitReached
SKY_ErrDisconnectMaxDefaultConnectionReached = _skycoin.SKY_ErrDisconnectMaxDefaultConnectionReached
SKY_ErrDisconnectMaxOutgoingConnectionsReached = _skycoin.SKY_ErrDisconnectMaxOutgoingConnectionsReached
SKY_ConnectionError = _skycoin.SKY_ConnectionError
SKY_ErrTxnNoFee = _skycoin.SKY_ErrTxnNoFee
SKY_ErrTxnInsufficientFee = _skycoin.SKY_ErrTxnInsufficientFee
SKY_ErrTxnInsufficientCoinHours = _skycoin.SKY_ErrTxnInsufficientCoinHours
SKY_ErrNegativeValue = _skycoin.SKY_ErrNegativeValue
SKY_ErrTooManyDecimals = _skycoin.SKY_ErrTooManyDecimals
SKY_ErrTooLarge = _skycoin.SKY_ErrTooLarge
SKY_ErrEmptyDirectoryName = _skycoin.SKY_ErrEmptyDirectoryName
SKY_ErrDotDirectoryName = _skycoin.SKY_ErrDotDirectoryName
SKY_ErrHistoryDBCorrupted = _skycoin.SKY_ErrHistoryDBCorrupted
SKY_ErrUxOutNotExist = _skycoin.SKY_ErrUxOutNotExist
SKY_ErrNoHeadBlock = _skycoin.SKY_ErrNoHeadBlock
SKY_ErrMissingSignature = _skycoin.SKY_ErrMissingSignature
SKY_ErrUnspentNotExist = _skycoin.SKY_ErrUnspentNotExist
SKY_ErrVerifyStopped = _skycoin.SKY_ErrVerifyStopped
SKY_ErrCreateBucketFailed = _skycoin.SKY_ErrCreateBucketFailed
SKY_ErrBucketNotExist = _skycoin.SKY_ErrBucketNotExist
SKY_ErrTxnViolatesHardConstraint = _skycoin.SKY_ErrTxnViolatesHardConstraint
SKY_ErrTxnViolatesSoftConstraint = _skycoin.SKY_ErrTxnViolatesSoftConstraint
SKY_ErrTxnViolatesUserConstraint = _skycoin.SKY_ErrTxnViolatesUserConstraint
SKY_ErrInsufficientBalance = _skycoin.SKY_ErrInsufficientBalance
SKY_ErrInsufficientHours = _skycoin.SKY_ErrInsufficientHours
SKY_ErrZeroSpend = _skycoin.SKY_ErrZeroSpend
SKY_ErrSpendingUnconfirmed = _skycoin.SKY_ErrSpendingUnconfirmed
SKY_ErrInvalidEncryptedField = _skycoin.SKY_ErrInvalidEncryptedField
SKY_ErrWalletEncrypted = _skycoin.SKY_ErrWalletEncrypted
SKY_ErrWalletNotEncrypted = _skycoin.SKY_ErrWalletNotEncrypted
SKY_ErrWalletMissingPassword = _skycoin.SKY_ErrWalletMissingPassword
SKY_ErrMissingEncrypt = _skycoin.SKY_ErrMissingEncrypt
SKY_ErrWalletInvalidPassword = _skycoin.SKY_ErrWalletInvalidPassword
SKY_ErrMissingSeed = _skycoin.SKY_ErrMissingSeed
SKY_ErrMissingAuthenticated = _skycoin.SKY_ErrMissingAuthenticated
SKY_ErrWrongCryptoType = _skycoin.SKY_ErrWrongCryptoType
SKY_ErrWalletNotExist = _skycoin.SKY_ErrWalletNotExist
SKY_ErrSeedUsed = _skycoin.SKY_ErrSeedUsed
SKY_ErrWalletAPIDisabled = _skycoin.SKY_ErrWalletAPIDisabled
SKY_ErrSeedAPIDisabled = _skycoin.SKY_ErrSeedAPIDisabled
SKY_ErrWalletNameConflict = _skycoin.SKY_ErrWalletNameConflict
SKY_ErrInvalidHoursSelectionMode = _skycoin.SKY_ErrInvalidHoursSelectionMode
SKY_ErrInvalidHoursSelectionType = _skycoin.SKY_ErrInvalidHoursSelectionType
SKY_ErrUnknownAddress = _skycoin.SKY_ErrUnknownAddress
SKY_ErrUnknownUxOut = _skycoin.SKY_ErrUnknownUxOut
SKY_ErrNoUnspents = _skycoin.SKY_ErrNoUnspents
SKY_ErrNullChangeAddress = _skycoin.SKY_ErrNullChangeAddress
SKY_ErrMissingTo = _skycoin.SKY_ErrMissingTo
SKY_ErrZeroCoinsTo = _skycoin.SKY_ErrZeroCoinsTo
SKY_ErrNullAddressTo = _skycoin.SKY_ErrNullAddressTo
SKY_ErrDuplicateTo = _skycoin.SKY_ErrDuplicateTo
SKY_ErrMissingWalletID = _skycoin.SKY_ErrMissingWalletID
SKY_ErrIncludesNullAddress = _skycoin.SKY_ErrIncludesNullAddress
SKY_ErrDuplicateAddresses = _skycoin.SKY_ErrDuplicateAddresses
SKY_ErrZeroToHoursAuto = _skycoin.SKY_ErrZeroToHoursAuto
SKY_ErrMissingModeAuto = _skycoin.SKY_ErrMissingModeAuto
SKY_ErrInvalidHoursSelMode = _skycoin.SKY_ErrInvalidHoursSelMode
SKY_ErrInvalidModeManual = _skycoin.SKY_ErrInvalidModeManual
SKY_ErrInvalidHoursSelType = _skycoin.SKY_ErrInvalidHoursSelType
SKY_ErrMissingShareFactor = _skycoin.SKY_ErrMissingShareFactor
SKY_ErrInvalidShareFactor = _skycoin.SKY_ErrInvalidShareFactor
SKY_ErrShareFactorOutOfRange = _skycoin.SKY_ErrShareFactorOutOfRange
SKY_ErrWalletConstraint = _skycoin.SKY_ErrWalletConstraint
SKY_ErrDuplicateUxOuts = _skycoin.SKY_ErrDuplicateUxOuts
SKY_ErrUnknownWalletID = _skycoin.SKY_ErrUnknownWalletID
SKY_ErrVerifySignatureInvalidInputsNils = _skycoin.SKY_ErrVerifySignatureInvalidInputsNils
SKY_ErrVerifySignatureInvalidSigLength = _skycoin.SKY_ErrVerifySignatureInvalidSigLength
SKY_ErrVerifySignatureInvalidPubkeysLength = _skycoin.SKY_ErrVerifySignatureInvalidPubkeysLength
SKY_ErrInvalidDecimals = _skycoin.SKY_ErrInvalidDecimals
class GoComplex64_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GoComplex64_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GoComplex64_, name)
    __repr__ = _swig_repr
    __swig_setmethods__["real"] = _skycoin.GoComplex64__real_set
    __swig_getmethods__["real"] = _skycoin.GoComplex64__real_get
    if _newclass:
        real = _swig_property(_skycoin.GoComplex64__real_get, _skycoin.GoComplex64__real_set)
    __swig_setmethods__["imaginary"] = _skycoin.GoComplex64__imaginary_set
    __swig_getmethods__["imaginary"] = _skycoin.GoComplex64__imaginary_get
    if _newclass:
        imaginary = _swig_property(_skycoin.GoComplex64__imaginary_get, _skycoin.GoComplex64__imaginary_set)

    def __init__(self):
        this = _skycoin.new_GoComplex64_()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_GoComplex64_
    __del__ = lambda self: None
GoComplex64__swigregister = _skycoin.GoComplex64__swigregister
GoComplex64__swigregister(GoComplex64_)

class GoComplex128_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GoComplex128_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GoComplex128_, name)
    __repr__ = _swig_repr
    __swig_setmethods__["real"] = _skycoin.GoComplex128__real_set
    __swig_getmethods__["real"] = _skycoin.GoComplex128__real_get
    if _newclass:
        real = _swig_property(_skycoin.GoComplex128__real_get, _skycoin.GoComplex128__real_set)
    __swig_setmethods__["imaginary"] = _skycoin.GoComplex128__imaginary_set
    __swig_getmethods__["imaginary"] = _skycoin.GoComplex128__imaginary_get
    if _newclass:
        imaginary = _swig_property(_skycoin.GoComplex128__imaginary_get, _skycoin.GoComplex128__imaginary_set)

    def __init__(self):
        this = _skycoin.new_GoComplex128_()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_GoComplex128_
    __del__ = lambda self: None
GoComplex128__swigregister = _skycoin.GoComplex128__swigregister
GoComplex128__swigregister(GoComplex128_)

class GoString_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GoString_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GoString_, name)
    __repr__ = _swig_repr
    __swig_setmethods__["p"] = _skycoin.GoString__p_set
    __swig_getmethods__["p"] = _skycoin.GoString__p_get
    if _newclass:
        p = _swig_property(_skycoin.GoString__p_get, _skycoin.GoString__p_set)
    __swig_setmethods__["n"] = _skycoin.GoString__n_set
    __swig_getmethods__["n"] = _skycoin.GoString__n_get
    if _newclass:
        n = _swig_property(_skycoin.GoString__n_get, _skycoin.GoString__n_set)

    def __init__(self):
        this = _skycoin.new_GoString_()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_GoString_
    __del__ = lambda self: None
GoString__swigregister = _skycoin.GoString__swigregister
GoString__swigregister(GoString_)

class GoInterface_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GoInterface_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GoInterface_, name)
    __repr__ = _swig_repr
    __swig_setmethods__["t"] = _skycoin.GoInterface__t_set
    __swig_getmethods__["t"] = _skycoin.GoInterface__t_get
    if _newclass:
        t = _swig_property(_skycoin.GoInterface__t_get, _skycoin.GoInterface__t_set)
    __swig_setmethods__["v"] = _skycoin.GoInterface__v_set
    __swig_getmethods__["v"] = _skycoin.GoInterface__v_get
    if _newclass:
        v = _swig_property(_skycoin.GoInterface__v_get, _skycoin.GoInterface__v_set)

    def __init__(self):
        this = _skycoin.new_GoInterface_()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_GoInterface_
    __del__ = lambda self: None
GoInterface__swigregister = _skycoin.GoInterface__swigregister
GoInterface__swigregister(GoInterface_)

class GoSlice_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GoSlice_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GoSlice_, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _skycoin.GoSlice__data_set
    __swig_getmethods__["data"] = _skycoin.GoSlice__data_get
    if _newclass:
        data = _swig_property(_skycoin.GoSlice__data_get, _skycoin.GoSlice__data_set)
    __swig_setmethods__["len"] = _skycoin.GoSlice__len_set
    __swig_getmethods__["len"] = _skycoin.GoSlice__len_get
    if _newclass:
        len = _swig_property(_skycoin.GoSlice__len_get, _skycoin.GoSlice__len_set)
    __swig_setmethods__["cap"] = _skycoin.GoSlice__cap_set
    __swig_getmethods__["cap"] = _skycoin.GoSlice__cap_get
    if _newclass:
        cap = _swig_property(_skycoin.GoSlice__cap_get, _skycoin.GoSlice__cap_set)

    def __init__(self):
        this = _skycoin.new_GoSlice_()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_GoSlice_
    __del__ = lambda self: None
GoSlice__swigregister = _skycoin.GoSlice__swigregister
GoSlice__swigregister(GoSlice_)

class Number(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Number, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Number, name)
    __repr__ = _swig_repr
    __swig_setmethods__["neg"] = _skycoin.Number_neg_set
    __swig_getmethods__["neg"] = _skycoin.Number_neg_get
    if _newclass:
        neg = _swig_property(_skycoin.Number_neg_get, _skycoin.Number_neg_set)
    __swig_setmethods__["nat"] = _skycoin.Number_nat_set
    __swig_getmethods__["nat"] = _skycoin.Number_nat_get
    if _newclass:
        nat = _swig_property(_skycoin.Number_nat_get, _skycoin.Number_nat_set)

    def __init__(self):
        this = _skycoin.new_Number()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_Number
    __del__ = lambda self: None
Number_swigregister = _skycoin.Number_swigregister
Number_swigregister(Number)

class Signature(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Signature, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Signature, name)
    __repr__ = _swig_repr
    __swig_setmethods__["R"] = _skycoin.Signature_R_set
    __swig_getmethods__["R"] = _skycoin.Signature_R_get
    if _newclass:
        R = _swig_property(_skycoin.Signature_R_get, _skycoin.Signature_R_set)
    __swig_setmethods__["S"] = _skycoin.Signature_S_set
    __swig_getmethods__["S"] = _skycoin.Signature_S_get
    if _newclass:
        S = _swig_property(_skycoin.Signature_S_get, _skycoin.Signature_S_set)

    def __init__(self):
        this = _skycoin.new_Signature()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_Signature
    __del__ = lambda self: None
Signature_swigregister = _skycoin.Signature_swigregister
Signature_swigregister(Signature)

class Wallet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Wallet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Wallet, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Meta"] = _skycoin.Wallet_Meta_set
    __swig_getmethods__["Meta"] = _skycoin.Wallet_Meta_get
    if _newclass:
        Meta = _swig_property(_skycoin.Wallet_Meta_get, _skycoin.Wallet_Meta_set)
    __swig_setmethods__["Entries"] = _skycoin.Wallet_Entries_set
    __swig_getmethods__["Entries"] = _skycoin.Wallet_Entries_get
    if _newclass:
        Entries = _swig_property(_skycoin.Wallet_Entries_get, _skycoin.Wallet_Entries_set)

    def __init__(self):
        this = _skycoin.new_Wallet()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_Wallet
    __del__ = lambda self: None
Wallet_swigregister = _skycoin.Wallet_swigregister
Wallet_swigregister(Wallet)

class FeeCalculator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FeeCalculator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FeeCalculator, name)
    __repr__ = _swig_repr
    __swig_setmethods__["callback"] = _skycoin.FeeCalculator_callback_set
    __swig_getmethods__["callback"] = _skycoin.FeeCalculator_callback_get
    if _newclass:
        callback = _swig_property(_skycoin.FeeCalculator_callback_get, _skycoin.FeeCalculator_callback_set)
    __swig_setmethods__["context"] = _skycoin.FeeCalculator_context_set
    __swig_getmethods__["context"] = _skycoin.FeeCalculator_context_get
    if _newclass:
        context = _swig_property(_skycoin.FeeCalculator_context_get, _skycoin.FeeCalculator_context_set)

    def __init__(self):
        this = _skycoin.new_FeeCalculator()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skycoin.delete_FeeCalculator
    __del__ = lambda self: None
FeeCalculator_swigregister = _skycoin.FeeCalculator_swigregister
FeeCalculator_swigregister(FeeCalculator)

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


