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



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

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

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

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

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


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr



def CalcEffDiam(*args):
  """
    CalcEffDiam(TIntFltKdV const & DistNbrsCdfV, double const & Percentile=0.9) -> double

    Parameters:
        DistNbrsCdfV: TIntFltKdV const &
        Percentile: double const &

    CalcEffDiam(TIntFltKdV const & DistNbrsCdfV) -> double

    Parameters:
        DistNbrsCdfV: TIntFltKdV const &

    CalcEffDiam(TFltPrV const & DistNbrsCdfV, double const & Percentile=0.9) -> double

    Parameters:
        DistNbrsCdfV: TFltPrV const &
        Percentile: double const &

    CalcEffDiam(TFltPrV const & DistNbrsCdfV) -> double

    Parameters:
        DistNbrsCdfV: TFltPrV const &

    """
  return _snap.CalcEffDiam(*args)

def CalcEffDiamPdf(*args):
  """
    CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV, double const & Percentile=0.9) -> double

    Parameters:
        DistNbrsPdfV: TIntFltKdV const &
        Percentile: double const &

    CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double

    Parameters:
        DistNbrsPdfV: TIntFltKdV const &

    CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV, double const & Percentile=0.9) -> double

    Parameters:
        DistNbrsPdfV: TFltPrV const &
        Percentile: double const &

    CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV) -> double

    Parameters:
        DistNbrsPdfV: TFltPrV const &

    """
  return _snap.CalcEffDiamPdf(*args)

def CalcAvgDiamPdf(*args):
  """
    CalcAvgDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double

    Parameters:
        DistNbrsPdfV: TIntFltKdV const &

    CalcAvgDiamPdf(TFltPrV const & DistNbrsPdfV) -> double

    Parameters:
        DistNbrsPdfV: TFltPrV const &

    """
  return _snap.CalcAvgDiamPdf(*args)
lUndef = _snap.lUndef
lUs = _snap.lUs
lSi = _snap.lSi

def WrNotify(*args):
  """
    WrNotify(char const * CaptionCStr, char const * NotifyCStr)

    Parameters:
        CaptionCStr: char const *
        NotifyCStr: char const *

    """
  return _snap.WrNotify(*args)

def SaveToErrLog(*args):
  """
    SaveToErrLog(char const * MsgCStr)

    Parameters:
        MsgCStr: char const *

    """
  return _snap.SaveToErrLog(*args)

def InfoNotify(*args):
  """
    InfoNotify(char const * NotifyCStr)

    Parameters:
        NotifyCStr: char const *

    """
  return _snap.InfoNotify(*args)

def WarnNotify(*args):
  """
    WarnNotify(char const * NotifyCStr)

    Parameters:
        NotifyCStr: char const *

    """
  return _snap.WarnNotify(*args)

def ErrNotify(*args):
  """
    ErrNotify(char const * NotifyCStr)

    Parameters:
        NotifyCStr: char const *

    """
  return _snap.ErrNotify(*args)

def StatNotify(*args):
  """
    StatNotify(char const * NotifyCStr)

    Parameters:
        NotifyCStr: char const *

    """
  return _snap.StatNotify(*args)

def ExeStop(*args):
  """
    ExeStop(char const * MsgStr, char const * ReasonStr, char const * CondStr, char const * FNm, 
        int const & LnN)

    Parameters:
        MsgStr: char const *
        ReasonStr: char const *
        CondStr: char const *
        FNm: char const *
        LnN: int const &

    """
  return _snap.ExeStop(*args)
loUndef = _snap.loUndef
loNot = _snap.loNot
loAnd = _snap.loAnd
loOr = _snap.loOr
roUndef = _snap.roUndef
roLs = _snap.roLs
roLEq = _snap.roLEq
roEq = _snap.roEq
roNEq = _snap.roNEq
roGEq = _snap.roGEq
roGt = _snap.roGt
class TCRef(object):
    """Proxy of C++ TCRef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(TCRef self) -> TCRef"""
        _snap.TCRef_swiginit(self,_snap.new_TCRef())
    __swig_destroy__ = _snap.delete_TCRef
    def MkRef(self):
        """
        MkRef(TCRef self)

        Parameters:
            self: TCRef *

        """
        return _snap.TCRef_MkRef(self)

    def UnRef(self):
        """
        UnRef(TCRef self)

        Parameters:
            self: TCRef *

        """
        return _snap.TCRef_UnRef(self)

    def NoRef(self):
        """
        NoRef(TCRef self) -> bool

        Parameters:
            self: TCRef const *

        """
        return _snap.TCRef_NoRef(self)

    def GetRefs(self):
        """
        GetRefs(TCRef self) -> int

        Parameters:
            self: TCRef const *

        """
        return _snap.TCRef_GetRefs(self)

TCRef.MkRef = new_instancemethod(_snap.TCRef_MkRef,None,TCRef)
TCRef.UnRef = new_instancemethod(_snap.TCRef_UnRef,None,TCRef)
TCRef.NoRef = new_instancemethod(_snap.TCRef_NoRef,None,TCRef)
TCRef.GetRefs = new_instancemethod(_snap.TCRef_GetRefs,None,TCRef)
TCRef_swigregister = _snap.TCRef_swigregister
TCRef_swigregister(TCRef)

class TSStr(object):
    """Proxy of C++ TSStr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TSStr self) -> TSStr
        __init__(TSStr self, TSStr SStr) -> TSStr

        Parameters:
            SStr: TSStr const &

        __init__(TSStr self, char const * _Bf) -> TSStr

        Parameters:
            _Bf: char const *

        """
        _snap.TSStr_swiginit(self,_snap.new_TSStr(*args))
    __swig_destroy__ = _snap.delete_TSStr
    def CStr(self, *args):
        """
        CStr(TSStr self) -> char
        CStr(TSStr self) -> char const *

        Parameters:
            self: TSStr const *

        """
        return _snap.TSStr_CStr(self, *args)

    def Empty(self):
        """
        Empty(TSStr self) -> bool

        Parameters:
            self: TSStr const *

        """
        return _snap.TSStr_Empty(self)

    def Len(self):
        """
        Len(TSStr self) -> int

        Parameters:
            self: TSStr const *

        """
        return _snap.TSStr_Len(self)

TSStr.CStr = new_instancemethod(_snap.TSStr_CStr,None,TSStr)
TSStr.Empty = new_instancemethod(_snap.TSStr_Empty,None,TSStr)
TSStr.Len = new_instancemethod(_snap.TSStr_Len,None,TSStr)
TSStr_swigregister = _snap.TSStr_swigregister
TSStr_swigregister(TSStr)

class TConv_Pt64Ints32(object):
    """Proxy of C++ TConv_Pt64Ints32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TConv_Pt64Ints32 self) -> TConv_Pt64Ints32
        __init__(TConv_Pt64Ints32 self, void * Pt) -> TConv_Pt64Ints32

        Parameters:
            Pt: void *

        __init__(TConv_Pt64Ints32 self, uint const & Ms, uint const & Ls) -> TConv_Pt64Ints32

        Parameters:
            Ms: uint const &
            Ls: uint const &

        """
        _snap.TConv_Pt64Ints32_swiginit(self,_snap.new_TConv_Pt64Ints32(*args))
    def PutPt(self, *args):
        """
        PutPt(TConv_Pt64Ints32 self, void * Pt)

        Parameters:
            Pt: void *

        """
        return _snap.TConv_Pt64Ints32_PutPt(self, *args)

    def GetPt(self):
        """
        GetPt(TConv_Pt64Ints32 self) -> void *

        Parameters:
            self: TConv_Pt64Ints32 const *

        """
        return _snap.TConv_Pt64Ints32_GetPt(self)

    def PutUInt64(self, *args):
        """
        PutUInt64(TConv_Pt64Ints32 self, uint64 const & _UInt64)

        Parameters:
            _UInt64: uint64 const &

        """
        return _snap.TConv_Pt64Ints32_PutUInt64(self, *args)

    def GetUInt64(self):
        """
        GetUInt64(TConv_Pt64Ints32 self) -> uint64

        Parameters:
            self: TConv_Pt64Ints32 const *

        """
        return _snap.TConv_Pt64Ints32_GetUInt64(self)

    def PutMsUInt32(self, *args):
        """
        PutMsUInt32(TConv_Pt64Ints32 self, uint const & Ms)

        Parameters:
            Ms: uint const &

        """
        return _snap.TConv_Pt64Ints32_PutMsUInt32(self, *args)

    def GetMsUInt32(self):
        """
        GetMsUInt32(TConv_Pt64Ints32 self) -> uint

        Parameters:
            self: TConv_Pt64Ints32 const *

        """
        return _snap.TConv_Pt64Ints32_GetMsUInt32(self)

    def PutLsUInt32(self, *args):
        """
        PutLsUInt32(TConv_Pt64Ints32 self, uint const & Ls)

        Parameters:
            Ls: uint const &

        """
        return _snap.TConv_Pt64Ints32_PutLsUInt32(self, *args)

    def GetLsUInt32(self):
        """
        GetLsUInt32(TConv_Pt64Ints32 self) -> uint

        Parameters:
            self: TConv_Pt64Ints32 const *

        """
        return _snap.TConv_Pt64Ints32_GetLsUInt32(self)

    __swig_destroy__ = _snap.delete_TConv_Pt64Ints32
TConv_Pt64Ints32.PutPt = new_instancemethod(_snap.TConv_Pt64Ints32_PutPt,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.GetPt = new_instancemethod(_snap.TConv_Pt64Ints32_GetPt,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.PutUInt64 = new_instancemethod(_snap.TConv_Pt64Ints32_PutUInt64,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.GetUInt64 = new_instancemethod(_snap.TConv_Pt64Ints32_GetUInt64,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.PutMsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_PutMsUInt32,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.GetMsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_GetMsUInt32,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.PutLsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_PutLsUInt32,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.GetLsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_GetLsUInt32,None,TConv_Pt64Ints32)
TConv_Pt64Ints32_swigregister = _snap.TConv_Pt64Ints32_swigregister
TConv_Pt64Ints32_swigregister(TConv_Pt64Ints32)

class TPairHashImpl1(object):
    """Proxy of C++ TPairHashImpl1 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetHashCd(*args):
        """
        GetHashCd(int const hc1, int const hc2) -> int

        Parameters:
            hc1: int const
            hc2: int const

        """
        return _snap.TPairHashImpl1_GetHashCd(*args)

    GetHashCd = staticmethod(GetHashCd)
    def __init__(self): 
        """__init__(TPairHashImpl1 self) -> TPairHashImpl1"""
        _snap.TPairHashImpl1_swiginit(self,_snap.new_TPairHashImpl1())
    __swig_destroy__ = _snap.delete_TPairHashImpl1
TPairHashImpl1_swigregister = _snap.TPairHashImpl1_swigregister
TPairHashImpl1_swigregister(TPairHashImpl1)

def TPairHashImpl1_GetHashCd(*args):
  """
    TPairHashImpl1_GetHashCd(int const hc1, int const hc2) -> int

    Parameters:
        hc1: int const
        hc2: int const

    """
  return _snap.TPairHashImpl1_GetHashCd(*args)

class TPairHashImpl2(object):
    """Proxy of C++ TPairHashImpl2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetHashCd(*args):
        """
        GetHashCd(int const hc1, int const hc2) -> int

        Parameters:
            hc1: int const
            hc2: int const

        """
        return _snap.TPairHashImpl2_GetHashCd(*args)

    GetHashCd = staticmethod(GetHashCd)
    def __init__(self): 
        """__init__(TPairHashImpl2 self) -> TPairHashImpl2"""
        _snap.TPairHashImpl2_swiginit(self,_snap.new_TPairHashImpl2())
    __swig_destroy__ = _snap.delete_TPairHashImpl2
TPairHashImpl2_swigregister = _snap.TPairHashImpl2_swigregister
TPairHashImpl2_swigregister(TPairHashImpl2)

def TPairHashImpl2_GetHashCd(*args):
  """
    TPairHashImpl2_GetHashCd(int const hc1, int const hc2) -> int

    Parameters:
        hc1: int const
        hc2: int const

    """
  return _snap.TPairHashImpl2_GetHashCd(*args)


def GetDegreeCentr(*args):
  """
    GetDegreeCentr(PUNGraph const & Graph, int const & NId) -> double

    Parameters:
        Graph: PUNGraph const &
        NId: int const &

    """
  return _snap.GetDegreeCentr(*args)

def GetFarnessCentr(*args):
  """
    GetFarnessCentr(PUNGraph const & Graph, int const & NId) -> double

    Parameters:
        Graph: PUNGraph const &
        NId: int const &

    """
  return _snap.GetFarnessCentr(*args)

def GetClosenessCentr(*args):
  """
    GetClosenessCentr(PUNGraph const & Graph, int const & NId) -> double

    Parameters:
        Graph: PUNGraph const &
        NId: int const &

    """
  return _snap.GetClosenessCentr(*args)

def GetBetweennessCentr(*args):
  """
    GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, double const & NodeFrac=1.0)

    Parameters:
        Graph: PUNGraph const &
        NIdBtwH: TIntFltH &
        NodeFrac: double const &

    GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH)

    Parameters:
        Graph: PUNGraph const &
        NIdBtwH: TIntFltH &

    GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0)

    Parameters:
        Graph: PUNGraph const &
        EdgeBtwH: TIntPrFltH &
        NodeFrac: double const &

    GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH)

    Parameters:
        Graph: PUNGraph const &
        EdgeBtwH: TIntPrFltH &

    GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0)

    Parameters:
        Graph: PUNGraph const &
        NIdBtwH: TIntFltH &
        EdgeBtwH: TIntPrFltH &
        NodeFrac: double const &

    GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH)

    Parameters:
        Graph: PUNGraph const &
        NIdBtwH: TIntFltH &
        EdgeBtwH: TIntPrFltH &

    GetBetweennessCentr(PUNGraph const & Graph, TIntV BtwNIdV, TIntFltH & NodeBtwH, bool const & DoNodeCent, 
        TIntPrFltH & EdgeBtwH, bool const & DoEdgeCent)

    Parameters:
        Graph: PUNGraph const &
        BtwNIdV: TIntV const &
        NodeBtwH: TIntFltH &
        DoNodeCent: bool const &
        EdgeBtwH: TIntPrFltH &
        DoEdgeCent: bool const &

    """
  return _snap.GetBetweennessCentr(*args)

def GetEigenVectorCentr(*args):
  """
    GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4, int const & MaxIter=100)

    Parameters:
        Graph: PUNGraph const &
        NIdEigenH: TIntFltH &
        Eps: double const &
        MaxIter: int const &

    GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4)

    Parameters:
        Graph: PUNGraph const &
        NIdEigenH: TIntFltH &
        Eps: double const &

    GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH)

    Parameters:
        Graph: PUNGraph const &
        NIdEigenH: TIntFltH &

    """
  return _snap.GetEigenVectorCentr(*args)

def CommunityGirvanNewman(*args):
  """
    CommunityGirvanNewman(PUNGraph & Graph, TCnComV & CmtyV) -> double

    Parameters:
        Graph: PUNGraph &
        CmtyV: TCnComV &

    """
  return _snap.CommunityGirvanNewman(*args)

def CommunityCNM(*args):
  """
    CommunityCNM(PUNGraph const & Graph, TCnComV & CmtyV) -> double

    Parameters:
        Graph: PUNGraph const &
        CmtyV: TCnComV &

    """
  return _snap.CommunityCNM(*args)

def CmtyGirvanNewmanStep(*args):
  """
    CmtyGirvanNewmanStep(PUNGraph & Graph, TIntV Cmty1, TIntV Cmty2)

    Parameters:
        Graph: PUNGraph &
        Cmty1: TIntV &
        Cmty2: TIntV &

    """
  return _snap.CmtyGirvanNewmanStep(*args)

def GetBiConSzCnt(*args):
  """
    GetBiConSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV)

    Parameters:
        Graph: PUNGraph const &
        SzCntV: TIntPrV &

    """
  return _snap.GetBiConSzCnt(*args)

def GetBiCon(*args):
  """
    GetBiCon(PUNGraph const & Graph, TCnComV & BiCnComV)

    Parameters:
        Graph: PUNGraph const &
        BiCnComV: TCnComV &

    """
  return _snap.GetBiCon(*args)

def GetArtPoints(*args):
  """
    GetArtPoints(PUNGraph const & Graph, TIntV ArtNIdV)

    Parameters:
        Graph: PUNGraph const &
        ArtNIdV: TIntV &

    """
  return _snap.GetArtPoints(*args)

def GetEdgeBridges(*args):
  """
    GetEdgeBridges(PUNGraph const & Graph, TIntPrV & EdgeV)

    Parameters:
        Graph: PUNGraph const &
        EdgeV: TIntPrV &

    """
  return _snap.GetEdgeBridges(*args)

def Get1CnComSzCnt(*args):
  """
    Get1CnComSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV)

    Parameters:
        Graph: PUNGraph const &
        SzCntV: TIntPrV &

    """
  return _snap.Get1CnComSzCnt(*args)

def Get1CnCom(*args):
  """
    Get1CnCom(PUNGraph const & Graph, TCnComV & Cn1ComV)

    Parameters:
        Graph: PUNGraph const &
        Cn1ComV: TCnComV &

    """
  return _snap.Get1CnCom(*args)
class TCnCom(object):
    """Proxy of C++ TCnCom class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NIdV = _swig_property(_snap.TCnCom_NIdV_get, _snap.TCnCom_NIdV_set)
    def __init__(self, *args): 
        """
        __init__(TCnCom self) -> TCnCom
        __init__(TCnCom self, TIntV NodeIdV) -> TCnCom

        Parameters:
            NodeIdV: TIntV const &

        __init__(TCnCom self, TCnCom CC) -> TCnCom

        Parameters:
            CC: TCnCom const &

        __init__(TCnCom self, TSIn SIn) -> TCnCom

        Parameters:
            SIn: TSIn &

        """
        _snap.TCnCom_swiginit(self,_snap.new_TCnCom(*args))
    def Save(self, *args):
        """
        Save(TCnCom self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TCnCom_Save(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TCnCom self, TCnCom CC) -> bool

        Parameters:
            CC: TCnCom const &

        """
        return _snap.TCnCom___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TCnCom self, TCnCom CC) -> bool

        Parameters:
            CC: TCnCom const &

        """
        return _snap.TCnCom___lt__(self, *args)

    def Len(self):
        """
        Len(TCnCom self) -> int

        Parameters:
            self: TCnCom const *

        """
        return _snap.TCnCom_Len(self)

    def Empty(self):
        """
        Empty(TCnCom self) -> bool

        Parameters:
            self: TCnCom const *

        """
        return _snap.TCnCom_Empty(self)

    def Clr(self):
        """
        Clr(TCnCom self)

        Parameters:
            self: TCnCom *

        """
        return _snap.TCnCom_Clr(self)

    def Add(self, *args):
        """
        Add(TCnCom self, int const & NodeId)

        Parameters:
            NodeId: int const &

        """
        return _snap.TCnCom_Add(self, *args)

    def __call__(self, *args):
        """
        __call__(TCnCom self) -> TIntV
        __call__(TCnCom self) -> TIntV

        Parameters:
            self: TCnCom *

        """
        return _snap.TCnCom___call__(self, *args)

    def Sort(self, Asc=True):
        """
        Sort(TCnCom self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        Sort(TCnCom self)

        Parameters:
            self: TCnCom *

        """
        return _snap.TCnCom_Sort(self, Asc)

    def IsNIdIn(self, *args):
        """
        IsNIdIn(TCnCom self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TCnCom_IsNIdIn(self, *args)

    def GetRndNId(self):
        """
        GetRndNId(TCnCom self) -> TInt

        Parameters:
            self: TCnCom const *

        """
        return _snap.TCnCom_GetRndNId(self)

    def Dump(*args):
        """
        Dump(TCnComV const & CnComV, TStr Desc=TStr())

        Parameters:
            CnComV: TCnComV const &
            Desc: TStr const &

        Dump(TCnComV const & CnComV)

        Parameters:
            CnComV: TCnComV const &

        """
        return _snap.TCnCom_Dump(*args)

    Dump = staticmethod(Dump)
    def SaveTxt(*args):
        """
        SaveTxt(TCnComV const & CnComV, TStr FNm, TStr Desc=TStr())

        Parameters:
            CnComV: TCnComV const &
            FNm: TStr const &
            Desc: TStr const &

        SaveTxt(TCnComV const & CnComV, TStr FNm)

        Parameters:
            CnComV: TCnComV const &
            FNm: TStr const &

        """
        return _snap.TCnCom_SaveTxt(*args)

    SaveTxt = staticmethod(SaveTxt)
    __swig_destroy__ = _snap.delete_TCnCom
TCnCom.Save = new_instancemethod(_snap.TCnCom_Save,None,TCnCom)
TCnCom.__eq__ = new_instancemethod(_snap.TCnCom___eq__,None,TCnCom)
TCnCom.__lt__ = new_instancemethod(_snap.TCnCom___lt__,None,TCnCom)
TCnCom.Len = new_instancemethod(_snap.TCnCom_Len,None,TCnCom)
TCnCom.Empty = new_instancemethod(_snap.TCnCom_Empty,None,TCnCom)
TCnCom.Clr = new_instancemethod(_snap.TCnCom_Clr,None,TCnCom)
TCnCom.Add = new_instancemethod(_snap.TCnCom_Add,None,TCnCom)
TCnCom.__call__ = new_instancemethod(_snap.TCnCom___call__,None,TCnCom)
TCnCom.Sort = new_instancemethod(_snap.TCnCom_Sort,None,TCnCom)
TCnCom.IsNIdIn = new_instancemethod(_snap.TCnCom_IsNIdIn,None,TCnCom)
TCnCom.GetRndNId = new_instancemethod(_snap.TCnCom_GetRndNId,None,TCnCom)
TCnCom_swigregister = _snap.TCnCom_swigregister
TCnCom_swigregister(TCnCom)

def TCnCom_Dump(*args):
  """
    Dump(TCnComV const & CnComV, TStr Desc=TStr())

    Parameters:
        CnComV: TCnComV const &
        Desc: TStr const &

    TCnCom_Dump(TCnComV const & CnComV)

    Parameters:
        CnComV: TCnComV const &

    """
  return _snap.TCnCom_Dump(*args)

def TCnCom_SaveTxt(*args):
  """
    SaveTxt(TCnComV const & CnComV, TStr FNm, TStr Desc=TStr())

    Parameters:
        CnComV: TCnComV const &
        FNm: TStr const &
        Desc: TStr const &

    TCnCom_SaveTxt(TCnComV const & CnComV, TStr FNm)

    Parameters:
        CnComV: TCnComV const &
        FNm: TStr const &

    """
  return _snap.TCnCom_SaveTxt(*args)

class TArtPointVisitor(object):
    """Proxy of C++ TArtPointVisitor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    VnLowH = _swig_property(_snap.TArtPointVisitor_VnLowH_get, _snap.TArtPointVisitor_VnLowH_set)
    ParentH = _swig_property(_snap.TArtPointVisitor_ParentH_get, _snap.TArtPointVisitor_ParentH_set)
    ArtSet = _swig_property(_snap.TArtPointVisitor_ArtSet_get, _snap.TArtPointVisitor_ArtSet_set)
    Time = _swig_property(_snap.TArtPointVisitor_Time_get, _snap.TArtPointVisitor_Time_set)
    def __init__(self, *args): 
        """
        __init__(TArtPointVisitor self) -> TArtPointVisitor
        __init__(TArtPointVisitor self, int const & Nodes) -> TArtPointVisitor

        Parameters:
            Nodes: int const &

        """
        _snap.TArtPointVisitor_swiginit(self,_snap.new_TArtPointVisitor(*args))
    def DiscoverNode(self, *args):
        """
        DiscoverNode(TArtPointVisitor self, int NId)

        Parameters:
            NId: int

        """
        return _snap.TArtPointVisitor_DiscoverNode(self, *args)

    def FinishNode(self, *args):
        """
        FinishNode(TArtPointVisitor self, int const & NId)

        Parameters:
            NId: int const &

        """
        return _snap.TArtPointVisitor_FinishNode(self, *args)

    def ExamineEdge(self, *args):
        """
        ExamineEdge(TArtPointVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TArtPointVisitor_ExamineEdge(self, *args)

    def TreeEdge(self, *args):
        """
        TreeEdge(TArtPointVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TArtPointVisitor_TreeEdge(self, *args)

    def BackEdge(self, *args):
        """
        BackEdge(TArtPointVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TArtPointVisitor_BackEdge(self, *args)

    def FwdEdge(self, *args):
        """
        FwdEdge(TArtPointVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TArtPointVisitor_FwdEdge(self, *args)

    __swig_destroy__ = _snap.delete_TArtPointVisitor
TArtPointVisitor.DiscoverNode = new_instancemethod(_snap.TArtPointVisitor_DiscoverNode,None,TArtPointVisitor)
TArtPointVisitor.FinishNode = new_instancemethod(_snap.TArtPointVisitor_FinishNode,None,TArtPointVisitor)
TArtPointVisitor.ExamineEdge = new_instancemethod(_snap.TArtPointVisitor_ExamineEdge,None,TArtPointVisitor)
TArtPointVisitor.TreeEdge = new_instancemethod(_snap.TArtPointVisitor_TreeEdge,None,TArtPointVisitor)
TArtPointVisitor.BackEdge = new_instancemethod(_snap.TArtPointVisitor_BackEdge,None,TArtPointVisitor)
TArtPointVisitor.FwdEdge = new_instancemethod(_snap.TArtPointVisitor_FwdEdge,None,TArtPointVisitor)
TArtPointVisitor_swigregister = _snap.TArtPointVisitor_swigregister
TArtPointVisitor_swigregister(TArtPointVisitor)

class TBiConVisitor(object):
    """Proxy of C++ TBiConVisitor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    VnLowH = _swig_property(_snap.TBiConVisitor_VnLowH_get, _snap.TBiConVisitor_VnLowH_set)
    ParentH = _swig_property(_snap.TBiConVisitor_ParentH_get, _snap.TBiConVisitor_ParentH_set)
    Stack = _swig_property(_snap.TBiConVisitor_Stack_get, _snap.TBiConVisitor_Stack_set)
    CnComV = _swig_property(_snap.TBiConVisitor_CnComV_get, _snap.TBiConVisitor_CnComV_set)
    NSet = _swig_property(_snap.TBiConVisitor_NSet_get, _snap.TBiConVisitor_NSet_set)
    Time = _swig_property(_snap.TBiConVisitor_Time_get, _snap.TBiConVisitor_Time_set)
    def __init__(self, *args): 
        """
        __init__(TBiConVisitor self) -> TBiConVisitor
        __init__(TBiConVisitor self, int const & Nodes) -> TBiConVisitor

        Parameters:
            Nodes: int const &

        """
        _snap.TBiConVisitor_swiginit(self,_snap.new_TBiConVisitor(*args))
    def DiscoverNode(self, *args):
        """
        DiscoverNode(TBiConVisitor self, int NId)

        Parameters:
            NId: int

        """
        return _snap.TBiConVisitor_DiscoverNode(self, *args)

    def FinishNode(self, *args):
        """
        FinishNode(TBiConVisitor self, int const & NId)

        Parameters:
            NId: int const &

        """
        return _snap.TBiConVisitor_FinishNode(self, *args)

    def ExamineEdge(self, *args):
        """
        ExamineEdge(TBiConVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TBiConVisitor_ExamineEdge(self, *args)

    def TreeEdge(self, *args):
        """
        TreeEdge(TBiConVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TBiConVisitor_TreeEdge(self, *args)

    def BackEdge(self, *args):
        """
        BackEdge(TBiConVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TBiConVisitor_BackEdge(self, *args)

    def FwdEdge(self, *args):
        """
        FwdEdge(TBiConVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TBiConVisitor_FwdEdge(self, *args)

    __swig_destroy__ = _snap.delete_TBiConVisitor
TBiConVisitor.DiscoverNode = new_instancemethod(_snap.TBiConVisitor_DiscoverNode,None,TBiConVisitor)
TBiConVisitor.FinishNode = new_instancemethod(_snap.TBiConVisitor_FinishNode,None,TBiConVisitor)
TBiConVisitor.ExamineEdge = new_instancemethod(_snap.TBiConVisitor_ExamineEdge,None,TBiConVisitor)
TBiConVisitor.TreeEdge = new_instancemethod(_snap.TBiConVisitor_TreeEdge,None,TBiConVisitor)
TBiConVisitor.BackEdge = new_instancemethod(_snap.TBiConVisitor_BackEdge,None,TBiConVisitor)
TBiConVisitor.FwdEdge = new_instancemethod(_snap.TBiConVisitor_FwdEdge,None,TBiConVisitor)
TBiConVisitor_swigregister = _snap.TBiConVisitor_swigregister
TBiConVisitor_swigregister(TBiConVisitor)

class TForestFire(object):
    """Proxy of C++ TForestFire class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TForestFire self) -> TForestFire
        __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb, 
            double const & DecayProb=1.0, int const & RndSeed=1) -> TForestFire

        Parameters:
            GraphPt: PNGraph const &
            ForwBurnProb: double const &
            BackBurnProb: double const &
            DecayProb: double const &
            RndSeed: int const &

        __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb, 
            double const & DecayProb=1.0) -> TForestFire

        Parameters:
            GraphPt: PNGraph const &
            ForwBurnProb: double const &
            BackBurnProb: double const &
            DecayProb: double const &

        __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb) -> TForestFire

        Parameters:
            GraphPt: PNGraph const &
            ForwBurnProb: double const &
            BackBurnProb: double const &

        """
        _snap.TForestFire_swiginit(self,_snap.new_TForestFire(*args))
    def SetGraph(self, *args):
        """
        SetGraph(TForestFire self, PNGraph const & GraphPt)

        Parameters:
            GraphPt: PNGraph const &

        """
        return _snap.TForestFire_SetGraph(self, *args)

    def GetGraph(self):
        """
        GetGraph(TForestFire self) -> PNGraph

        Parameters:
            self: TForestFire const *

        """
        return _snap.TForestFire_GetGraph(self)

    def SetBurnProb(self, *args):
        """
        SetBurnProb(TForestFire self, double const & ForwBurnProb, double const & BackBurnProb)

        Parameters:
            ForwBurnProb: double const &
            BackBurnProb: double const &

        """
        return _snap.TForestFire_SetBurnProb(self, *args)

    def SetProbDecay(self, *args):
        """
        SetProbDecay(TForestFire self, double const & DecayProb)

        Parameters:
            DecayProb: double const &

        """
        return _snap.TForestFire_SetProbDecay(self, *args)

    def Infect(self, *args):
        """
        Infect(TForestFire self, int const & NodeId)

        Parameters:
            NodeId: int const &

        Infect(TForestFire self, TIntV InfectedNIdV)

        Parameters:
            InfectedNIdV: TIntV const &

        """
        return _snap.TForestFire_Infect(self, *args)

    def InfectAll(self):
        """
        InfectAll(TForestFire self)

        Parameters:
            self: TForestFire *

        """
        return _snap.TForestFire_InfectAll(self)

    def InfectRnd(self, *args):
        """
        InfectRnd(TForestFire self, int const & NInfect)

        Parameters:
            NInfect: int const &

        """
        return _snap.TForestFire_InfectRnd(self, *args)

    def BurnExpFire(self):
        """
        BurnExpFire(TForestFire self)

        Parameters:
            self: TForestFire *

        """
        return _snap.TForestFire_BurnExpFire(self)

    def BurnGeoFire(self):
        """
        BurnGeoFire(TForestFire self)

        Parameters:
            self: TForestFire *

        """
        return _snap.TForestFire_BurnGeoFire(self)

    def GetFireTm(self):
        """
        GetFireTm(TForestFire self) -> int

        Parameters:
            self: TForestFire const *

        """
        return _snap.TForestFire_GetFireTm(self)

    def GetBurned(self):
        """
        GetBurned(TForestFire self) -> int

        Parameters:
            self: TForestFire const *

        """
        return _snap.TForestFire_GetBurned(self)

    def GetBurnedNId(self, *args):
        """
        GetBurnedNId(TForestFire self, int const & NIdN) -> int

        Parameters:
            NIdN: int const &

        """
        return _snap.TForestFire_GetBurnedNId(self, *args)

    def GetBurnedNIdV(self, *args):
        """
        GetBurnedNIdV(TForestFire self) -> TIntV
        GetBurnedNIdV(TForestFire self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TForestFire_GetBurnedNIdV(self, *args)

    def PlotFire(self, *args):
        """
        PlotFire(TForestFire self, TStr FNmPref, TStr Desc, bool const & PlotAllBurned=False)

        Parameters:
            FNmPref: TStr const &
            Desc: TStr const &
            PlotAllBurned: bool const &

        PlotFire(TForestFire self, TStr FNmPref, TStr Desc)

        Parameters:
            FNmPref: TStr const &
            Desc: TStr const &

        """
        return _snap.TForestFire_PlotFire(self, *args)

    def GenGraph(*args):
        """
        GenGraph(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph

        Parameters:
            Nodes: int const &
            FwdProb: double const &
            BckProb: double const &

        """
        return _snap.TForestFire_GenGraph(*args)

    GenGraph = staticmethod(GenGraph)
    __swig_destroy__ = _snap.delete_TForestFire
TForestFire.SetGraph = new_instancemethod(_snap.TForestFire_SetGraph,None,TForestFire)
TForestFire.GetGraph = new_instancemethod(_snap.TForestFire_GetGraph,None,TForestFire)
TForestFire.SetBurnProb = new_instancemethod(_snap.TForestFire_SetBurnProb,None,TForestFire)
TForestFire.SetProbDecay = new_instancemethod(_snap.TForestFire_SetProbDecay,None,TForestFire)
TForestFire.Infect = new_instancemethod(_snap.TForestFire_Infect,None,TForestFire)
TForestFire.InfectAll = new_instancemethod(_snap.TForestFire_InfectAll,None,TForestFire)
TForestFire.InfectRnd = new_instancemethod(_snap.TForestFire_InfectRnd,None,TForestFire)
TForestFire.BurnExpFire = new_instancemethod(_snap.TForestFire_BurnExpFire,None,TForestFire)
TForestFire.BurnGeoFire = new_instancemethod(_snap.TForestFire_BurnGeoFire,None,TForestFire)
TForestFire.GetFireTm = new_instancemethod(_snap.TForestFire_GetFireTm,None,TForestFire)
TForestFire.GetBurned = new_instancemethod(_snap.TForestFire_GetBurned,None,TForestFire)
TForestFire.GetBurnedNId = new_instancemethod(_snap.TForestFire_GetBurnedNId,None,TForestFire)
TForestFire.GetBurnedNIdV = new_instancemethod(_snap.TForestFire_GetBurnedNIdV,None,TForestFire)
TForestFire.PlotFire = new_instancemethod(_snap.TForestFire_PlotFire,None,TForestFire)
TForestFire_swigregister = _snap.TForestFire_swigregister
TForestFire_swigregister(TForestFire)

def TForestFire_GenGraph(*args):
  """
    TForestFire_GenGraph(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph

    Parameters:
        Nodes: int const &
        FwdProb: double const &
        BckProb: double const &

    """
  return _snap.TForestFire_GenGraph(*args)

class TFfGGen(object):
    """Proxy of C++ TFfGGen class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    srUndef = _snap.TFfGGen_srUndef
    srOk = _snap.TFfGGen_srOk
    srFlood = _snap.TFfGGen_srFlood
    srTimeLimit = _snap.TFfGGen_srTimeLimit
    TimeLimitSec = _swig_property(_snap.TFfGGen_TimeLimitSec_get, _snap.TFfGGen_TimeLimitSec_set)
    def __init__(self, *args): 
        """
        __init__(TFfGGen self, bool const & BurnExpFireP, int const & StartNNodes, double const & ForwBurnProb, 
            double const & BackBurnProb, double const & DecayProb, double const & Take2AmbasPrb, 
            double const & OrphanPrb) -> TFfGGen

        Parameters:
            BurnExpFireP: bool const &
            StartNNodes: int const &
            ForwBurnProb: double const &
            BackBurnProb: double const &
            DecayProb: double const &
            Take2AmbasPrb: double const &
            OrphanPrb: double const &

        """
        _snap.TFfGGen_swiginit(self,_snap.new_TFfGGen(*args))
    def GetGraph(self):
        """
        GetGraph(TFfGGen self) -> PNGraph

        Parameters:
            self: TFfGGen const *

        """
        return _snap.TFfGGen_GetGraph(self)

    def SetGraph(self, *args):
        """
        SetGraph(TFfGGen self, PNGraph const & NGraph)

        Parameters:
            NGraph: PNGraph const &

        """
        return _snap.TFfGGen_SetGraph(self, *args)

    def Clr(self):
        """
        Clr(TFfGGen self)

        Parameters:
            self: TFfGGen *

        """
        return _snap.TFfGGen_Clr(self)

    def GetParamStr(self):
        """
        GetParamStr(TFfGGen self) -> TStr

        Parameters:
            self: TFfGGen const *

        """
        return _snap.TFfGGen_GetParamStr(self)

    def AddNodes(self, *args):
        """
        AddNodes(TFfGGen self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            FloodStop: bool const &

        AddNodes(TFfGGen self, int const & GraphNodes) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &

        """
        return _snap.TFfGGen_AddNodes(self, *args)

    def GenGraph(self, *args):
        """
        GenGraph(TFfGGen self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            FloodStop: bool const &

        GenGraph(TFfGGen self, int const & GraphNodes) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &

        GenGraph(TFfGGen self, int const & GraphNodes, PGStatVec & EvolStat, bool const & FloodStop=True) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            EvolStat: PGStatVec &
            FloodStop: bool const &

        GenGraph(TFfGGen self, int const & GraphNodes, PGStatVec & EvolStat) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            EvolStat: PGStatVec &

        """
        return _snap.TFfGGen_GenGraph(self, *args)

    def PlotFireSize(self, *args):
        """
        PlotFireSize(TFfGGen self, TStr FNmPref, TStr DescStr)

        Parameters:
            FNmPref: TStr const &
            DescStr: TStr const &

        """
        return _snap.TFfGGen_PlotFireSize(self, *args)

    def GenFFGraphs(*args):
        """
        GenFFGraphs(double const & FProb, double const & BProb, TStr FNm)

        Parameters:
            FProb: double const &
            BProb: double const &
            FNm: TStr const &

        """
        return _snap.TFfGGen_GenFFGraphs(*args)

    GenFFGraphs = staticmethod(GenFFGraphs)
    __swig_destroy__ = _snap.delete_TFfGGen
TFfGGen.GetGraph = new_instancemethod(_snap.TFfGGen_GetGraph,None,TFfGGen)
TFfGGen.SetGraph = new_instancemethod(_snap.TFfGGen_SetGraph,None,TFfGGen)
TFfGGen.Clr = new_instancemethod(_snap.TFfGGen_Clr,None,TFfGGen)
TFfGGen.GetParamStr = new_instancemethod(_snap.TFfGGen_GetParamStr,None,TFfGGen)
TFfGGen.AddNodes = new_instancemethod(_snap.TFfGGen_AddNodes,None,TFfGGen)
TFfGGen.GenGraph = new_instancemethod(_snap.TFfGGen_GenGraph,None,TFfGGen)
TFfGGen.PlotFireSize = new_instancemethod(_snap.TFfGGen_PlotFireSize,None,TFfGGen)
TFfGGen_swigregister = _snap.TFfGGen_swigregister
TFfGGen_swigregister(TFfGGen)
cvar = _snap.cvar

def TFfGGen_GenFFGraphs(*args):
  """
    TFfGGen_GenFFGraphs(double const & FProb, double const & BProb, TStr FNm)

    Parameters:
        FProb: double const &
        BProb: double const &
        FNm: TStr const &

    """
  return _snap.TFfGGen_GenFFGraphs(*args)

class TUndirFFire(object):
    """Proxy of C++ TUndirFFire class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, _BurnProb=0.3): 
        """
        __init__(TUndirFFire self, double const & _BurnProb=0.3) -> TUndirFFire

        Parameters:
            _BurnProb: double const &

        __init__(TUndirFFire self) -> TUndirFFire
        """
        _snap.TUndirFFire_swiginit(self,_snap.new_TUndirFFire(_BurnProb))
    def SetGraph(self, *args):
        """
        SetGraph(TUndirFFire self, PUNGraph const & GraphPt)

        Parameters:
            GraphPt: PUNGraph const &

        """
        return _snap.TUndirFFire_SetGraph(self, *args)

    def GetGraph(self):
        """
        GetGraph(TUndirFFire self) -> PUNGraph

        Parameters:
            self: TUndirFFire const *

        """
        return _snap.TUndirFFire_GetGraph(self)

    def GetNBurned(self):
        """
        GetNBurned(TUndirFFire self) -> int

        Parameters:
            self: TUndirFFire const *

        """
        return _snap.TUndirFFire_GetNBurned(self)

    def GetBurnedNId(self, *args):
        """
        GetBurnedNId(TUndirFFire self, int const & n) -> int

        Parameters:
            n: int const &

        """
        return _snap.TUndirFFire_GetBurnedNId(self, *args)

    def BurnGeoFire(self, *args):
        """
        BurnGeoFire(TUndirFFire self, int const & StartNId) -> int

        Parameters:
            StartNId: int const &

        """
        return _snap.TUndirFFire_BurnGeoFire(self, *args)

    def AddNodes(self, *args):
        """
        AddNodes(TUndirFFire self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            FloodStop: bool const &

        AddNodes(TUndirFFire self, int const & GraphNodes) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &

        """
        return _snap.TUndirFFire_AddNodes(self, *args)

    __swig_destroy__ = _snap.delete_TUndirFFire
TUndirFFire.SetGraph = new_instancemethod(_snap.TUndirFFire_SetGraph,None,TUndirFFire)
TUndirFFire.GetGraph = new_instancemethod(_snap.TUndirFFire_GetGraph,None,TUndirFFire)
TUndirFFire.GetNBurned = new_instancemethod(_snap.TUndirFFire_GetNBurned,None,TUndirFFire)
TUndirFFire.GetBurnedNId = new_instancemethod(_snap.TUndirFFire_GetBurnedNId,None,TUndirFFire)
TUndirFFire.BurnGeoFire = new_instancemethod(_snap.TUndirFFire_BurnGeoFire,None,TUndirFFire)
TUndirFFire.AddNodes = new_instancemethod(_snap.TUndirFFire_AddNodes,None,TUndirFFire)
TUndirFFire_swigregister = _snap.TUndirFFire_swigregister
TUndirFFire_swigregister(TUndirFFire)

class TCs(object):
    """Proxy of C++ TCs class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TCs self) -> TCs
        __init__(TCs self, TCs Cs) -> TCs

        Parameters:
            Cs: TCs const &

        __init__(TCs self, int const & Int) -> TCs

        Parameters:
            Int: int const &

        """
        _snap.TCs_swiginit(self,_snap.new_TCs(*args))
    def __eq__(self, *args):
        """
        __eq__(TCs self, TCs Cs) -> bool

        Parameters:
            Cs: TCs const &

        """
        return _snap.TCs___eq__(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(TCs self, TCs Cs) -> TCs

        Parameters:
            Cs: TCs const &

        __iadd__(TCs self, char const & Ch) -> TCs

        Parameters:
            Ch: char const &

        __iadd__(TCs self, int const & Int) -> TCs

        Parameters:
            Int: int const &

        """
        return _snap.TCs___iadd__(self, *args)

    def Get(self):
        """
        Get(TCs self) -> int

        Parameters:
            self: TCs const *

        """
        return _snap.TCs_Get(self)

    def GetCsFromBf(*args):
        """
        GetCsFromBf(char * Bf, int const & BfL) -> TCs

        Parameters:
            Bf: char *
            BfL: int const &

        """
        return _snap.TCs_GetCsFromBf(*args)

    GetCsFromBf = staticmethod(GetCsFromBf)
    __swig_destroy__ = _snap.delete_TCs
TCs.__eq__ = new_instancemethod(_snap.TCs___eq__,None,TCs)
TCs.__iadd__ = new_instancemethod(_snap.TCs___iadd__,None,TCs)
TCs.Get = new_instancemethod(_snap.TCs_Get,None,TCs)
TCs_swigregister = _snap.TCs_swigregister
TCs_swigregister(TCs)

def TCs_GetCsFromBf(*args):
  """
    TCs_GetCsFromBf(char * Bf, int const & BfL) -> TCs

    Parameters:
        Bf: char *
        BfL: int const &

    """
  return _snap.TCs_GetCsFromBf(*args)

class TSOutMnp(object):
    """Proxy of C++ TSOutMnp class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def __call__(self, *args):
        """
        __call__(TSOutMnp self, TSOut SOut) -> TSOut

        Parameters:
            SOut: TSOut &

        """
        return _snap.TSOutMnp___call__(self, *args)

    __swig_destroy__ = _snap.delete_TSOutMnp
TSOutMnp.__call__ = new_instancemethod(_snap.TSOutMnp___call__,None,TSOutMnp)
TSOutMnp_swigregister = _snap.TSOutMnp_swigregister
TSOutMnp_swigregister(TSOutMnp)

class TSBase(object):
    """Proxy of C++ TSBase class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TSBase self, TSStr Nm) -> TSBase

        Parameters:
            Nm: TSStr const &

        """
        _snap.TSBase_swiginit(self,_snap.new_TSBase(*args))
    __swig_destroy__ = _snap.delete_TSBase
    def GetSNm(self):
        """
        GetSNm(TSBase self) -> TStr

        Parameters:
            self: TSBase const *

        """
        return _snap.TSBase_GetSNm(self)

TSBase.GetSNm = new_instancemethod(_snap.TSBase_GetSNm,None,TSBase)
TSBase_swigregister = _snap.TSBase_swigregister
TSBase_swigregister(TSBase)

class TSIn(TSBase):
    """Proxy of C++ TSIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TSIn
    def Eof(self):
        """
        Eof(TSIn self) -> bool

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_Eof(self)

    def Len(self):
        """
        Len(TSIn self) -> int

        Parameters:
            self: TSIn const *

        """
        return _snap.TSIn_Len(self)

    def GetCh(self):
        """
        GetCh(TSIn self) -> char

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_GetCh(self)

    def PeekCh(self):
        """
        PeekCh(TSIn self) -> char

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_PeekCh(self)

    def GetBf(self, *args):
        """
        GetBf(TSIn self, void const * Bf, TSize const & BfL) -> int

        Parameters:
            Bf: void const *
            BfL: TSize const &

        """
        return _snap.TSIn_GetBf(self, *args)

    def GetNextLnBf(self, *args):
        """
        GetNextLnBf(TSIn self, TChA LnChA) -> bool

        Parameters:
            LnChA: TChA &

        """
        return _snap.TSIn_GetNextLnBf(self, *args)

    def Reset(self):
        """
        Reset(TSIn self)

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_Reset(self)

    def IsFastMode(self):
        """
        IsFastMode(TSIn self) -> bool

        Parameters:
            self: TSIn const *

        """
        return _snap.TSIn_IsFastMode(self)

    def SetFastMode(self, *args):
        """
        SetFastMode(TSIn self, bool const & _FastMode)

        Parameters:
            _FastMode: bool const &

        """
        return _snap.TSIn_SetFastMode(self, *args)

    def LoadCs(self):
        """
        LoadCs(TSIn self)

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_LoadCs(self)

    def LoadBf(self, *args):
        """
        LoadBf(TSIn self, void const * Bf, TSize const & BfL)

        Parameters:
            Bf: void const *
            BfL: TSize const &

        """
        return _snap.TSIn_LoadBf(self, *args)

    def LoadNewBf(self, *args):
        """
        LoadNewBf(TSIn self, int const & BfL) -> void *

        Parameters:
            BfL: int const &

        """
        return _snap.TSIn_LoadNewBf(self, *args)

    def Load(self, *args):
        """
        Load(TSIn self, bool & Bool)

        Parameters:
            Bool: bool &

        Load(TSIn self, uchar & UCh)

        Parameters:
            UCh: uchar &

        Load(TSIn self, char & Ch)

        Parameters:
            Ch: char &

        Load(TSIn self, short & Short)

        Parameters:
            Short: short &

        Load(TSIn self, ushort & UShort)

        Parameters:
            UShort: ushort &

        Load(TSIn self, int & Int)

        Parameters:
            Int: int &

        Load(TSIn self, uint & UInt)

        Parameters:
            UInt: uint &

        Load(TSIn self, int64 & Int)

        Parameters:
            Int: int64 &

        Load(TSIn self, uint64 & UInt)

        Parameters:
            UInt: uint64 &

        Load(TSIn self, double & Flt)

        Parameters:
            Flt: double &

        Load(TSIn self, sdouble & SFlt)

        Parameters:
            SFlt: sdouble &

        Load(TSIn self, ldouble & LFlt)

        Parameters:
            LFlt: ldouble &

        Load(TSIn self, char *& CStr, int const & MxCStrLen, int const & CStrLen)

        Parameters:
            CStr: char *&
            MxCStrLen: int const &
            CStrLen: int const &

        Load(TSIn self, char *& CStr)

        Parameters:
            CStr: char *&

        """
        return _snap.TSIn_Load(self, *args)

    def __rshift__(self, *args):
        """
        __rshift__(TSIn self, bool & Bool) -> TSIn

        Parameters:
            Bool: bool &

        __rshift__(TSIn self, uchar & UCh) -> TSIn

        Parameters:
            UCh: uchar &

        __rshift__(TSIn self, char & Ch) -> TSIn

        Parameters:
            Ch: char &

        __rshift__(TSIn self, short & Sh) -> TSIn

        Parameters:
            Sh: short &

        __rshift__(TSIn self, ushort & USh) -> TSIn

        Parameters:
            USh: ushort &

        __rshift__(TSIn self, int & Int) -> TSIn

        Parameters:
            Int: int &

        __rshift__(TSIn self, uint & UInt) -> TSIn

        Parameters:
            UInt: uint &

        __rshift__(TSIn self, int64 & Int) -> TSIn

        Parameters:
            Int: int64 &

        __rshift__(TSIn self, uint64 & UInt) -> TSIn

        Parameters:
            UInt: uint64 &

        __rshift__(TSIn self, float & Flt) -> TSIn

        Parameters:
            Flt: float &

        __rshift__(TSIn self, double & Double) -> TSIn

        Parameters:
            Double: double &

        __rshift__(TSIn self, long double & LDouble) -> TSIn

        Parameters:
            LDouble: long double &

        """
        return _snap.TSIn___rshift__(self, *args)

    def GetNextLn(self, *args):
        """
        GetNextLn(TSIn self, TStr LnStr) -> bool

        Parameters:
            LnStr: TStr &

        GetNextLn(TSIn self, TChA LnChA) -> bool

        Parameters:
            LnChA: TChA &

        """
        return _snap.TSIn_GetNextLn(self, *args)

TSIn.Eof = new_instancemethod(_snap.TSIn_Eof,None,TSIn)
TSIn.Len = new_instancemethod(_snap.TSIn_Len,None,TSIn)
TSIn.GetCh = new_instancemethod(_snap.TSIn_GetCh,None,TSIn)
TSIn.PeekCh = new_instancemethod(_snap.TSIn_PeekCh,None,TSIn)
TSIn.GetBf = new_instancemethod(_snap.TSIn_GetBf,None,TSIn)
TSIn.GetNextLnBf = new_instancemethod(_snap.TSIn_GetNextLnBf,None,TSIn)
TSIn.Reset = new_instancemethod(_snap.TSIn_Reset,None,TSIn)
TSIn.IsFastMode = new_instancemethod(_snap.TSIn_IsFastMode,None,TSIn)
TSIn.SetFastMode = new_instancemethod(_snap.TSIn_SetFastMode,None,TSIn)
TSIn.LoadCs = new_instancemethod(_snap.TSIn_LoadCs,None,TSIn)
TSIn.LoadBf = new_instancemethod(_snap.TSIn_LoadBf,None,TSIn)
TSIn.LoadNewBf = new_instancemethod(_snap.TSIn_LoadNewBf,None,TSIn)
TSIn.Load = new_instancemethod(_snap.TSIn_Load,None,TSIn)
TSIn.__rshift__ = new_instancemethod(_snap.TSIn___rshift__,None,TSIn)
TSIn.GetNextLn = new_instancemethod(_snap.TSIn_GetNextLn,None,TSIn)
TSIn_swigregister = _snap.TSIn_swigregister
TSIn_swigregister(TSIn)
TSIn.StdIn = _snap.cvar.TSIn_StdIn

class TSOut(TSBase):
    """Proxy of C++ TSOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TSOut
    def EnableLnTrunc(self, *args):
        """
        EnableLnTrunc(TSOut self, int const & _MxLnLen)

        Parameters:
            _MxLnLen: int const &

        """
        return _snap.TSOut_EnableLnTrunc(self, *args)

    def DisableLnTrunc(self):
        """
        DisableLnTrunc(TSOut self)

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_DisableLnTrunc(self)

    def PutBf(self, *args):
        """
        PutBf(TSOut self, void const * LBf, TSize const & LBfL) -> int

        Parameters:
            LBf: void const *
            LBfL: TSize const &

        """
        return _snap.TSOut_PutBf(self, *args)

    def Flush(self):
        """
        Flush(TSOut self)

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_Flush(self)

    def GetFileId(self):
        """
        GetFileId(TSOut self) -> TFileId

        Parameters:
            self: TSOut const *

        """
        return _snap.TSOut_GetFileId(self)

    def PutMem(self, *args):
        """
        PutMem(TSOut self, TMem Mem) -> int

        Parameters:
            Mem: TMem const &

        """
        return _snap.TSOut_PutMem(self, *args)

    def PutCh(self, *args):
        """
        PutCh(TSOut self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        PutCh(TSOut self, char const & Ch, int const & Chs) -> int

        Parameters:
            Ch: char const &
            Chs: int const &

        """
        return _snap.TSOut_PutCh(self, *args)

    def PutBool(self, *args):
        """
        PutBool(TSOut self, bool const & Bool) -> int

        Parameters:
            Bool: bool const &

        """
        return _snap.TSOut_PutBool(self, *args)

    def PutInt(self, *args):
        """
        PutInt(TSOut self, int const & Int) -> int

        Parameters:
            Int: int const &

        PutInt(TSOut self, int const & Int, char const * FmtStr) -> int

        Parameters:
            Int: int const &
            FmtStr: char const *

        """
        return _snap.TSOut_PutInt(self, *args)

    def PutUInt(self, *args):
        """
        PutUInt(TSOut self, uint const & Int) -> int

        Parameters:
            Int: uint const &

        PutUInt(TSOut self, uint const & Int, char const * FmtStr) -> int

        Parameters:
            Int: uint const &
            FmtStr: char const *

        """
        return _snap.TSOut_PutUInt(self, *args)

    def PutFlt(self, *args):
        """
        PutFlt(TSOut self, double const & Flt) -> int

        Parameters:
            Flt: double const &

        PutFlt(TSOut self, double const & Flt, char const * FmtStr) -> int

        Parameters:
            Flt: double const &
            FmtStr: char const *

        """
        return _snap.TSOut_PutFlt(self, *args)

    def PutStr(self, *args):
        """
        PutStr(TSOut self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        PutStr(TSOut self, TChA ChA) -> int

        Parameters:
            ChA: TChA const &

        PutStr(TSOut self, TStr Str, char const * FmtStr) -> int

        Parameters:
            Str: TStr const &
            FmtStr: char const *

        PutStr(TSOut self, TStr Str, bool const & ForceInLn=False) -> int

        Parameters:
            Str: TStr const &
            ForceInLn: bool const &

        PutStr(TSOut self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TSOut_PutStr(self, *args)

    def PutStrLn(self, *args):
        """
        PutStrLn(TSOut self, TStr Str, bool const & ForceInLn=False) -> int

        Parameters:
            Str: TStr const &
            ForceInLn: bool const &

        PutStrLn(TSOut self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TSOut_PutStrLn(self, *args)

    def PutStrFmt(self, *args):
        """
        PutStrFmt(TSOut self, char const * FmtStr) -> int

        Parameters:
            FmtStr: char const *

        """
        return _snap.TSOut_PutStrFmt(self, *args)

    def PutStrFmtLn(self, *args):
        """
        PutStrFmtLn(TSOut self, char const * FmtStr) -> int

        Parameters:
            FmtStr: char const *

        """
        return _snap.TSOut_PutStrFmtLn(self, *args)

    def PutIndent(self, IndentLev=1):
        """
        PutIndent(TSOut self, int const & IndentLev=1) -> int

        Parameters:
            IndentLev: int const &

        PutIndent(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutIndent(self, IndentLev)

    def PutLn(self, Lns=1):
        """
        PutLn(TSOut self, int const & Lns=1) -> int

        Parameters:
            Lns: int const &

        PutLn(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutLn(self, Lns)

    def PutDosLn(self, Lns=1):
        """
        PutDosLn(TSOut self, int const & Lns=1) -> int

        Parameters:
            Lns: int const &

        PutDosLn(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutDosLn(self, Lns)

    def PutSep(self, NextStrLen=0):
        """
        PutSep(TSOut self, int const & NextStrLen=0) -> int

        Parameters:
            NextStrLen: int const &

        PutSep(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutSep(self, NextStrLen)

    def PutSepLn(self, Lns=0):
        """
        PutSepLn(TSOut self, int const & Lns=0) -> int

        Parameters:
            Lns: int const &

        PutSepLn(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutSepLn(self, Lns)

    def SaveCs(self):
        """
        SaveCs(TSOut self)

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_SaveCs(self)

    def SaveBf(self, *args):
        """
        SaveBf(TSOut self, void const * Bf, TSize const & BfL)

        Parameters:
            Bf: void const *
            BfL: TSize const &

        """
        return _snap.TSOut_SaveBf(self, *args)

    def Save(self, *args):
        """
        Save(TSOut self, bool const & Bool)

        Parameters:
            Bool: bool const &

        Save(TSOut self, char const & Ch)

        Parameters:
            Ch: char const &

        Save(TSOut self, uchar const & UCh)

        Parameters:
            UCh: uchar const &

        Save(TSOut self, short const & Short)

        Parameters:
            Short: short const &

        Save(TSOut self, ushort const & UShort)

        Parameters:
            UShort: ushort const &

        Save(TSOut self, int const & Int)

        Parameters:
            Int: int const &

        Save(TSOut self, uint const & UInt)

        Parameters:
            UInt: uint const &

        Save(TSOut self, int64 const & Int)

        Parameters:
            Int: int64 const &

        Save(TSOut self, uint64 const & UInt)

        Parameters:
            UInt: uint64 const &

        Save(TSOut self, double const & Flt)

        Parameters:
            Flt: double const &

        Save(TSOut self, sdouble const & SFlt)

        Parameters:
            SFlt: sdouble const &

        Save(TSOut self, ldouble const & LFlt)

        Parameters:
            LFlt: ldouble const &

        Save(TSOut self, char const * CStr, TSize const & CStrLen)

        Parameters:
            CStr: char const *
            CStrLen: TSize const &

        Save(TSOut self, char const * CStr)

        Parameters:
            CStr: char const *

        Save(TSOut self, TSIn SIn, TSize const & BfL=-1)

        Parameters:
            SIn: TSIn &
            BfL: TSize const &

        Save(TSOut self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        Save(TSOut self, PSIn const & SIn, TSize const & BfL=-1)

        Parameters:
            SIn: PSIn const &
            BfL: TSize const &

        Save(TSOut self, PSIn const & SIn)

        Parameters:
            SIn: PSIn const &

        Save(TSOut self, void const * Bf, TSize const & BfL)

        Parameters:
            Bf: void const *
            BfL: TSize const &

        """
        return _snap.TSOut_Save(self, *args)

    def __lshift__(self, *args):
        """
        __lshift__(TSOut self, bool const & Bool) -> TSOut

        Parameters:
            Bool: bool const &

        __lshift__(TSOut self, uchar const & UCh) -> TSOut

        Parameters:
            UCh: uchar const &

        __lshift__(TSOut self, char const & Ch) -> TSOut

        Parameters:
            Ch: char const &

        __lshift__(TSOut self, short const & Sh) -> TSOut

        Parameters:
            Sh: short const &

        __lshift__(TSOut self, ushort const & USh) -> TSOut

        Parameters:
            USh: ushort const &

        __lshift__(TSOut self, int const & Int) -> TSOut

        Parameters:
            Int: int const &

        __lshift__(TSOut self, uint const & Int) -> TSOut

        Parameters:
            Int: uint const &

        __lshift__(TSOut self, int64 const & Int) -> TSOut

        Parameters:
            Int: int64 const &

        __lshift__(TSOut self, uint64 const & UInt) -> TSOut

        Parameters:
            UInt: uint64 const &

        __lshift__(TSOut self, float const & Flt) -> TSOut

        Parameters:
            Flt: float const &

        __lshift__(TSOut self, double const & Double) -> TSOut

        Parameters:
            Double: double const &

        __lshift__(TSOut self, long double const & LDouble) -> TSOut

        Parameters:
            LDouble: long double const &

        __lshift__(TSOut self, TSOutMnp Mnp) -> TSOut

        Parameters:
            Mnp: TSOutMnp const &

        __lshift__(TSOut self, TSOut &(*)(TSOut &) FuncPt) -> TSOut

        Parameters:
            FuncPt: TSOut &(*)(TSOut &)

        __lshift__(TSOut self, TSIn SIn) -> TSOut

        Parameters:
            SIn: TSIn &

        __lshift__(TSOut self, PSIn & SIn) -> TSOut

        Parameters:
            SIn: PSIn &

        """
        return _snap.TSOut___lshift__(self, *args)

TSOut.EnableLnTrunc = new_instancemethod(_snap.TSOut_EnableLnTrunc,None,TSOut)
TSOut.DisableLnTrunc = new_instancemethod(_snap.TSOut_DisableLnTrunc,None,TSOut)
TSOut.PutBf = new_instancemethod(_snap.TSOut_PutBf,None,TSOut)
TSOut.Flush = new_instancemethod(_snap.TSOut_Flush,None,TSOut)
TSOut.GetFileId = new_instancemethod(_snap.TSOut_GetFileId,None,TSOut)
TSOut.PutMem = new_instancemethod(_snap.TSOut_PutMem,None,TSOut)
TSOut.PutCh = new_instancemethod(_snap.TSOut_PutCh,None,TSOut)
TSOut.PutBool = new_instancemethod(_snap.TSOut_PutBool,None,TSOut)
TSOut.PutInt = new_instancemethod(_snap.TSOut_PutInt,None,TSOut)
TSOut.PutUInt = new_instancemethod(_snap.TSOut_PutUInt,None,TSOut)
TSOut.PutFlt = new_instancemethod(_snap.TSOut_PutFlt,None,TSOut)
TSOut.PutStr = new_instancemethod(_snap.TSOut_PutStr,None,TSOut)
TSOut.PutStrLn = new_instancemethod(_snap.TSOut_PutStrLn,None,TSOut)
TSOut.PutStrFmt = new_instancemethod(_snap.TSOut_PutStrFmt,None,TSOut)
TSOut.PutStrFmtLn = new_instancemethod(_snap.TSOut_PutStrFmtLn,None,TSOut)
TSOut.PutIndent = new_instancemethod(_snap.TSOut_PutIndent,None,TSOut)
TSOut.PutLn = new_instancemethod(_snap.TSOut_PutLn,None,TSOut)
TSOut.PutDosLn = new_instancemethod(_snap.TSOut_PutDosLn,None,TSOut)
TSOut.PutSep = new_instancemethod(_snap.TSOut_PutSep,None,TSOut)
TSOut.PutSepLn = new_instancemethod(_snap.TSOut_PutSepLn,None,TSOut)
TSOut.SaveCs = new_instancemethod(_snap.TSOut_SaveCs,None,TSOut)
TSOut.SaveBf = new_instancemethod(_snap.TSOut_SaveBf,None,TSOut)
TSOut.Save = new_instancemethod(_snap.TSOut_Save,None,TSOut)
TSOut.__lshift__ = new_instancemethod(_snap.TSOut___lshift__,None,TSOut)
TSOut_swigregister = _snap.TSOut_swigregister
TSOut_swigregister(TSOut)
TSOut.StdOut = _snap.cvar.TSOut_StdOut

class TSInOut(TSIn,TSOut):
    """Proxy of C++ TSInOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TSInOut
    def SetPos(self, *args):
        """
        SetPos(TSInOut self, int const & Pos)

        Parameters:
            Pos: int const &

        """
        return _snap.TSInOut_SetPos(self, *args)

    def MovePos(self, *args):
        """
        MovePos(TSInOut self, int const & DPos)

        Parameters:
            DPos: int const &

        """
        return _snap.TSInOut_MovePos(self, *args)

    def GetPos(self):
        """
        GetPos(TSInOut self) -> int

        Parameters:
            self: TSInOut const *

        """
        return _snap.TSInOut_GetPos(self)

    def GetSize(self):
        """
        GetSize(TSInOut self) -> int

        Parameters:
            self: TSInOut const *

        """
        return _snap.TSInOut_GetSize(self)

    def Clr(self):
        """
        Clr(TSInOut self)

        Parameters:
            self: TSInOut *

        """
        return _snap.TSInOut_Clr(self)

TSInOut.SetPos = new_instancemethod(_snap.TSInOut_SetPos,None,TSInOut)
TSInOut.MovePos = new_instancemethod(_snap.TSInOut_MovePos,None,TSInOut)
TSInOut.GetPos = new_instancemethod(_snap.TSInOut_GetPos,None,TSInOut)
TSInOut.GetSize = new_instancemethod(_snap.TSInOut_GetSize,None,TSInOut)
TSInOut.Clr = new_instancemethod(_snap.TSInOut_Clr,None,TSInOut)
TSInOut_swigregister = _snap.TSInOut_swigregister
TSInOut_swigregister(TSInOut)

class TStdIn(TSIn):
    """Proxy of C++ TStdIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(TStdIn self) -> TStdIn"""
        _snap.TStdIn_swiginit(self,_snap.new_TStdIn())
    def New():
        """New() -> TPt< TSIn >"""
        return _snap.TStdIn_New()

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TStdIn
TStdIn_swigregister = _snap.TStdIn_swigregister
TStdIn_swigregister(TStdIn)

def TStdIn_New():
  """TStdIn_New() -> TPt< TSIn >"""
  return _snap.TStdIn_New()

class TStdOut(TSOut):
    """Proxy of C++ TStdOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(TStdOut self) -> TStdOut"""
        _snap.TStdOut_swiginit(self,_snap.new_TStdOut())
    def New():
        """New() -> TPt< TSOut >"""
        return _snap.TStdOut_New()

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TStdOut
TStdOut_swigregister = _snap.TStdOut_swigregister
TStdOut_swigregister(TStdOut)

def TStdOut_New():
  """TStdOut_New() -> TPt< TSOut >"""
  return _snap.TStdOut_New()

class TFIn(TSIn):
    """Proxy of C++ TFIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TFIn self, TStr FNm) -> TFIn

        Parameters:
            FNm: TStr const &

        __init__(TFIn self, TStr FNm, bool & OpenedP) -> TFIn

        Parameters:
            FNm: TStr const &
            OpenedP: bool &

        """
        _snap.TFIn_swiginit(self,_snap.new_TFIn(*args))
    def New(*args):
        """
        New(TStr FNm) -> PSIn

        Parameters:
            FNm: TStr const &

        New(TStr FNm, bool & OpenedP) -> PSIn

        Parameters:
            FNm: TStr const &
            OpenedP: bool &

        """
        return _snap.TFIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TFIn
TFIn_swigregister = _snap.TFIn_swigregister
TFIn_swigregister(TFIn)

def TFIn_New(*args):
  """
    New(TStr FNm) -> PSIn

    Parameters:
        FNm: TStr const &

    TFIn_New(TStr FNm, bool & OpenedP) -> PSIn

    Parameters:
        FNm: TStr const &
        OpenedP: bool &

    """
  return _snap.TFIn_New(*args)

class TFOut(TSOut):
    """Proxy of C++ TFOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TFOut self, TStr _FNm, bool const & Append=False) -> TFOut

        Parameters:
            _FNm: TStr const &
            Append: bool const &

        __init__(TFOut self, TStr _FNm) -> TFOut

        Parameters:
            _FNm: TStr const &

        __init__(TFOut self, TStr _FNm, bool const & Append, bool & OpenedP) -> TFOut

        Parameters:
            _FNm: TStr const &
            Append: bool const &
            OpenedP: bool &

        """
        _snap.TFOut_swiginit(self,_snap.new_TFOut(*args))
    def New(*args):
        """
        New(TStr FNm, bool const & Append=False) -> PSOut

        Parameters:
            FNm: TStr const &
            Append: bool const &

        New(TStr FNm) -> PSOut

        Parameters:
            FNm: TStr const &

        New(TStr FNm, bool const & Append, bool & OpenedP) -> PSOut

        Parameters:
            FNm: TStr const &
            Append: bool const &
            OpenedP: bool &

        """
        return _snap.TFOut_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TFOut
TFOut_swigregister = _snap.TFOut_swigregister
TFOut_swigregister(TFOut)

def TFOut_New(*args):
  """
    New(TStr FNm, bool const & Append=False) -> PSOut

    Parameters:
        FNm: TStr const &
        Append: bool const &

    New(TStr FNm) -> PSOut

    Parameters:
        FNm: TStr const &

    TFOut_New(TStr FNm, bool const & Append, bool & OpenedP) -> PSOut

    Parameters:
        FNm: TStr const &
        Append: bool const &
        OpenedP: bool &

    """
  return _snap.TFOut_New(*args)

faUndef = _snap.faUndef
faCreate = _snap.faCreate
faUpdate = _snap.faUpdate
faAppend = _snap.faAppend
faRdOnly = _snap.faRdOnly
faRestore = _snap.faRestore
class TMIn(TSIn):
    """Proxy of C++ TMIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TMIn self, void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> TMIn

        Parameters:
            _Bf: void const *
            _BfL: int const &
            TakeBf: bool const &

        __init__(TMIn self, void const * _Bf, int const & _BfL) -> TMIn

        Parameters:
            _Bf: void const *
            _BfL: int const &

        __init__(TMIn self, TSIn SIn) -> TMIn

        Parameters:
            SIn: TSIn &

        __init__(TMIn self, char const * CStr) -> TMIn

        Parameters:
            CStr: char const *

        __init__(TMIn self, TStr Str) -> TMIn

        Parameters:
            Str: TStr const &

        __init__(TMIn self, TChA ChA) -> TMIn

        Parameters:
            ChA: TChA const &

        """
        _snap.TMIn_swiginit(self,_snap.new_TMIn(*args))
    def New(*args):
        """
        New(void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> PSIn

        Parameters:
            _Bf: void const *
            _BfL: int const &
            TakeBf: bool const &

        New(void const * _Bf, int const & _BfL) -> PSIn

        Parameters:
            _Bf: void const *
            _BfL: int const &

        New(char const * CStr) -> PSIn

        Parameters:
            CStr: char const *

        New(TStr Str) -> PSIn

        Parameters:
            Str: TStr const &

        New(TChA ChA) -> PSIn

        Parameters:
            ChA: TChA const &

        """
        return _snap.TMIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TMIn
    def GetBfAddr(self):
        """
        GetBfAddr(TMIn self) -> char *

        Parameters:
            self: TMIn *

        """
        return _snap.TMIn_GetBfAddr(self)

TMIn.GetBfAddr = new_instancemethod(_snap.TMIn_GetBfAddr,None,TMIn)
TMIn_swigregister = _snap.TMIn_swigregister
TMIn_swigregister(TMIn)

def TMIn_New(*args):
  """
    New(void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> PSIn

    Parameters:
        _Bf: void const *
        _BfL: int const &
        TakeBf: bool const &

    New(void const * _Bf, int const & _BfL) -> PSIn

    Parameters:
        _Bf: void const *
        _BfL: int const &

    New(char const * CStr) -> PSIn

    Parameters:
        CStr: char const *

    New(TStr Str) -> PSIn

    Parameters:
        Str: TStr const &

    TMIn_New(TChA ChA) -> PSIn

    Parameters:
        ChA: TChA const &

    """
  return _snap.TMIn_New(*args)

class TMOut(TSOut):
    """Proxy of C++ TMOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def New(MxBfL=1024):
        """
        New(int const & MxBfL=1024) -> PSOut

        Parameters:
            MxBfL: int const &

        New() -> PSOut
        """
        return _snap.TMOut_New(MxBfL)

    New = staticmethod(New)
    def __init__(self, *args): 
        """
        __init__(TMOut self, int const & _MxBfL=1024) -> TMOut

        Parameters:
            _MxBfL: int const &

        __init__(TMOut self) -> TMOut
        __init__(TMOut self, char * _Bf, int const & _MxBfL) -> TMOut

        Parameters:
            _Bf: char *
            _MxBfL: int const &

        """
        _snap.TMOut_swiginit(self,_snap.new_TMOut(*args))
    __swig_destroy__ = _snap.delete_TMOut
    def AppendBf(self, *args):
        """
        AppendBf(TMOut self, void const * LBf, TSize const & LBfL)

        Parameters:
            LBf: void const *
            LBfL: TSize const &

        """
        return _snap.TMOut_AppendBf(self, *args)

    def Len(self):
        """
        Len(TMOut self) -> int

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_Len(self)

    def Clr(self):
        """
        Clr(TMOut self)

        Parameters:
            self: TMOut *

        """
        return _snap.TMOut_Clr(self)

    def GetCh(self, *args):
        """
        GetCh(TMOut self, int const & ChN) -> char

        Parameters:
            ChN: int const &

        """
        return _snap.TMOut_GetCh(self, *args)

    def GetAsStr(self):
        """
        GetAsStr(TMOut self) -> TStr

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_GetAsStr(self)

    def CutBf(self, *args):
        """
        CutBf(TMOut self, int const & CutBfL)

        Parameters:
            CutBfL: int const &

        """
        return _snap.TMOut_CutBf(self, *args)

    def GetSIn(self, *args):
        """
        GetSIn(TMOut self, bool const & IsCut=True, int const & CutBfL=-1) -> PSIn

        Parameters:
            IsCut: bool const &
            CutBfL: int const &

        GetSIn(TMOut self, bool const & IsCut=True) -> PSIn

        Parameters:
            IsCut: bool const &

        GetSIn(TMOut self) -> PSIn

        Parameters:
            self: TMOut *

        """
        return _snap.TMOut_GetSIn(self, *args)

    def GetBfAddr(self):
        """
        GetBfAddr(TMOut self) -> char *

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_GetBfAddr(self)

    def IsCrLfLn(self):
        """
        IsCrLfLn(TMOut self) -> bool

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_IsCrLfLn(self)

    def GetCrLfLn(self):
        """
        GetCrLfLn(TMOut self) -> TStr

        Parameters:
            self: TMOut *

        """
        return _snap.TMOut_GetCrLfLn(self)

    def IsEolnLn(self):
        """
        IsEolnLn(TMOut self) -> bool

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_IsEolnLn(self)

    def GetEolnLn(self, *args):
        """
        GetEolnLn(TMOut self, bool const & DoAddEoln, bool const & DoCutBf) -> TStr

        Parameters:
            DoAddEoln: bool const &
            DoCutBf: bool const &

        """
        return _snap.TMOut_GetEolnLn(self, *args)

    def MkEolnLn(self):
        """
        MkEolnLn(TMOut self)

        Parameters:
            self: TMOut *

        """
        return _snap.TMOut_MkEolnLn(self)

TMOut.AppendBf = new_instancemethod(_snap.TMOut_AppendBf,None,TMOut)
TMOut.Len = new_instancemethod(_snap.TMOut_Len,None,TMOut)
TMOut.Clr = new_instancemethod(_snap.TMOut_Clr,None,TMOut)
TMOut.GetCh = new_instancemethod(_snap.TMOut_GetCh,None,TMOut)
TMOut.GetAsStr = new_instancemethod(_snap.TMOut_GetAsStr,None,TMOut)
TMOut.CutBf = new_instancemethod(_snap.TMOut_CutBf,None,TMOut)
TMOut.GetSIn = new_instancemethod(_snap.TMOut_GetSIn,None,TMOut)
TMOut.GetBfAddr = new_instancemethod(_snap.TMOut_GetBfAddr,None,TMOut)
TMOut.IsCrLfLn = new_instancemethod(_snap.TMOut_IsCrLfLn,None,TMOut)
TMOut.GetCrLfLn = new_instancemethod(_snap.TMOut_GetCrLfLn,None,TMOut)
TMOut.IsEolnLn = new_instancemethod(_snap.TMOut_IsEolnLn,None,TMOut)
TMOut.GetEolnLn = new_instancemethod(_snap.TMOut_GetEolnLn,None,TMOut)
TMOut.MkEolnLn = new_instancemethod(_snap.TMOut_MkEolnLn,None,TMOut)
TMOut_swigregister = _snap.TMOut_swigregister
TMOut_swigregister(TMOut)

def TMOut_New(MxBfL=1024):
  """
    New(int const & MxBfL=1024) -> PSOut

    Parameters:
        MxBfL: int const &

    TMOut_New() -> PSOut
    """
  return _snap.TMOut_New(MxBfL)

class TChRet(object):
    """Proxy of C++ TChRet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TChRet self, PSIn const & _SIn, char const & _EofCh=0) -> TChRet

        Parameters:
            _SIn: PSIn const &
            _EofCh: char const &

        __init__(TChRet self, PSIn const & _SIn) -> TChRet

        Parameters:
            _SIn: PSIn const &

        """
        _snap.TChRet_swiginit(self,_snap.new_TChRet(*args))
    def Eof(self):
        """
        Eof(TChRet self) -> bool

        Parameters:
            self: TChRet const *

        """
        return _snap.TChRet_Eof(self)

    def GetCh(self):
        """
        GetCh(TChRet self) -> char

        Parameters:
            self: TChRet *

        """
        return _snap.TChRet_GetCh(self)

    def __call__(self):
        """
        __call__(TChRet self) -> char

        Parameters:
            self: TChRet *

        """
        return _snap.TChRet___call__(self)

    __swig_destroy__ = _snap.delete_TChRet
TChRet.Eof = new_instancemethod(_snap.TChRet_Eof,None,TChRet)
TChRet.GetCh = new_instancemethod(_snap.TChRet_GetCh,None,TChRet)
TChRet.__call__ = new_instancemethod(_snap.TChRet___call__,None,TChRet)
TChRet_swigregister = _snap.TChRet_swigregister
TChRet_swigregister(TChRet)

class TLnRet(object):
    """Proxy of C++ TLnRet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TLnRet self, PSIn const & _SIn) -> TLnRet

        Parameters:
            _SIn: PSIn const &

        """
        _snap.TLnRet_swiginit(self,_snap.new_TLnRet(*args))
    def NextLn(self, *args):
        """
        NextLn(TLnRet self, TStr LnStr) -> bool

        Parameters:
            LnStr: TStr &

        """
        return _snap.TLnRet_NextLn(self, *args)

    __swig_destroy__ = _snap.delete_TLnRet
TLnRet.NextLn = new_instancemethod(_snap.TLnRet_NextLn,None,TLnRet)
TLnRet_swigregister = _snap.TLnRet_swigregister
TLnRet_swigregister(TLnRet)

class TFile(object):
    """Proxy of C++ TFile class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def Exists(*args):
        """
        Exists(TStr FNm) -> bool

        Parameters:
            FNm: TStr const &

        """
        return _snap.TFile_Exists(*args)

    Exists = staticmethod(Exists)
    def Del(*args):
        """
        Del(TStr FNm, bool const & ThrowExceptP=True)

        Parameters:
            FNm: TStr const &
            ThrowExceptP: bool const &

        Del(TStr FNm)

        Parameters:
            FNm: TStr const &

        """
        return _snap.TFile_Del(*args)

    Del = staticmethod(Del)
    def DelWc(*args):
        """
        DelWc(TStr WcStr, bool const & RecurseDirP=False)

        Parameters:
            WcStr: TStr const &
            RecurseDirP: bool const &

        DelWc(TStr WcStr)

        Parameters:
            WcStr: TStr const &

        """
        return _snap.TFile_DelWc(*args)

    DelWc = staticmethod(DelWc)
    def Rename(*args):
        """
        Rename(TStr SrcFNm, TStr DstFNm)

        Parameters:
            SrcFNm: TStr const &
            DstFNm: TStr const &

        """
        return _snap.TFile_Rename(*args)

    Rename = staticmethod(Rename)
    def GetUniqueFNm(*args):
        """
        GetUniqueFNm(TStr FNm) -> TStr

        Parameters:
            FNm: TStr const &

        """
        return _snap.TFile_GetUniqueFNm(*args)

    GetUniqueFNm = staticmethod(GetUniqueFNm)
    def __init__(self): 
        """__init__(TFile self) -> TFile"""
        _snap.TFile_swiginit(self,_snap.new_TFile())
    __swig_destroy__ = _snap.delete_TFile
TFile_swigregister = _snap.TFile_swigregister
TFile_swigregister(TFile)
TFile.TxtFExt = _snap.cvar.TFile_TxtFExt
TFile.HtmlFExt = _snap.cvar.TFile_HtmlFExt
TFile.HtmFExt = _snap.cvar.TFile_HtmFExt
TFile.GifFExt = _snap.cvar.TFile_GifFExt
TFile.JarFExt = _snap.cvar.TFile_JarFExt

def TFile_Exists(*args):
  """
    TFile_Exists(TStr FNm) -> bool

    Parameters:
        FNm: TStr const &

    """
  return _snap.TFile_Exists(*args)

def TFile_Del(*args):
  """
    Del(TStr FNm, bool const & ThrowExceptP=True)

    Parameters:
        FNm: TStr const &
        ThrowExceptP: bool const &

    TFile_Del(TStr FNm)

    Parameters:
        FNm: TStr const &

    """
  return _snap.TFile_Del(*args)

def TFile_DelWc(*args):
  """
    DelWc(TStr WcStr, bool const & RecurseDirP=False)

    Parameters:
        WcStr: TStr const &
        RecurseDirP: bool const &

    TFile_DelWc(TStr WcStr)

    Parameters:
        WcStr: TStr const &

    """
  return _snap.TFile_DelWc(*args)

def TFile_Rename(*args):
  """
    TFile_Rename(TStr SrcFNm, TStr DstFNm)

    Parameters:
        SrcFNm: TStr const &
        DstFNm: TStr const &

    """
  return _snap.TFile_Rename(*args)

def TFile_GetUniqueFNm(*args):
  """
    TFile_GetUniqueFNm(TStr FNm) -> TStr

    Parameters:
        FNm: TStr const &

    """
  return _snap.TFile_GetUniqueFNm(*args)

class TUNGraph(object):
    """Proxy of C++ TUNGraph class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TUNGraph self) -> TUNGraph
        __init__(TUNGraph self, int const & Nodes, int const & Edges) -> TUNGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TUNGraph self, TUNGraph Graph) -> TUNGraph

        Parameters:
            Graph: TUNGraph const &

        __init__(TUNGraph self, TSIn SIn) -> TUNGraph

        Parameters:
            SIn: TSIn &

        """
        _snap.TUNGraph_swiginit(self,_snap.new_TUNGraph(*args))
    def Save(self, *args):
        """
        Save(TUNGraph self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TUNGraph_Save(self, *args)

    def New(*args):
        """
        New() -> PUNGraph
        New(int const & Nodes, int const & Edges) -> PUNGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TUNGraph_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PUNGraph

        Parameters:
            SIn: TSIn &

        """
        return _snap.TUNGraph_Load(*args)

    Load = staticmethod(Load)
    def HasFlag(self, *args):
        """
        HasFlag(TUNGraph self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.TUNGraph_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(TUNGraph self) -> int

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TUNGraph self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TUNGraph self) -> int
        AddNode(TUNGraph self, TUNGraph::TNodeI const & NodeI) -> int

        Parameters:
            NodeI: TUNGraph::TNodeI const &

        AddNode(TUNGraph self, int const & NId, TIntV NbrNIdV) -> int

        Parameters:
            NId: int const &
            NbrNIdV: TIntV const &

        AddNode(TUNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & NIdVId) -> int

        Parameters:
            NId: int const &
            Pool: TVecPool< TInt > const &
            NIdVId: int const &

        """
        return _snap.TUNGraph_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TUNGraph self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TUNGraph self, TUNGraph::TNode const & NodeI)

        Parameters:
            NodeI: TUNGraph::TNode const &

        """
        return _snap.TUNGraph_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TUNGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraph_IsNode(self, *args)

    def BegNI(self):
        """
        BegNI(TUNGraph self) -> TUNGraph::TNodeI

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_BegNI(self)

    def EndNI(self):
        """
        EndNI(TUNGraph self) -> TUNGraph::TNodeI

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_EndNI(self)

    def GetNI(self, *args):
        """
        GetNI(TUNGraph self, int const & NId) -> TUNGraph::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraph_GetNI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TUNGraph self) -> int

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(TUNGraph self) -> int

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TUNGraph self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(TUNGraph self, TUNGraph::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TUNGraph::TEdgeI const &

        """
        return _snap.TUNGraph_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TUNGraph self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TUNGraph_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TUNGraph self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TUNGraph_IsEdge(self, *args)

    def BegEI(self):
        """
        BegEI(TUNGraph self) -> TUNGraph::TEdgeI

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_BegEI(self)

    def EndEI(self):
        """
        EndEI(TUNGraph self) -> TUNGraph::TEdgeI

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_EndEI(self)

    def GetEI(self, *args):
        """
        GetEI(TUNGraph self, int const & SrcNId, int const & DstNId) -> TUNGraph::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TUNGraph_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TUNGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TUNGraph self) -> int

        Parameters:
            self: TUNGraph *

        """
        return _snap.TUNGraph_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TUNGraph self, TRnd Rnd=Rnd) -> TUNGraph::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TUNGraph self) -> TUNGraph::TNodeI

        Parameters:
            self: TUNGraph *

        """
        return _snap.TUNGraph_GetRndNI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TUNGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TUNGraph_GetNIdV(self, *args)

    def Empty(self):
        """
        Empty(TUNGraph self) -> bool

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_Empty(self)

    def Clr(self):
        """
        Clr(TUNGraph self)

        Parameters:
            self: TUNGraph *

        """
        return _snap.TUNGraph_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TUNGraph self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TUNGraph_Reserve(self, *args)

    def ReserveNIdDeg(self, *args):
        """
        ReserveNIdDeg(TUNGraph self, int const & NId, int const & Deg)

        Parameters:
            NId: int const &
            Deg: int const &

        """
        return _snap.TUNGraph_ReserveNIdDeg(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TUNGraph self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TUNGraph self)

        Parameters:
            self: TUNGraph *

        """
        return _snap.TUNGraph_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TUNGraph self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TUNGraph self) -> bool

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TUNGraph self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TUNGraph self)

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_Dump(self, *args)

    def GetSmallGraph():
        """GetSmallGraph() -> PUNGraph"""
        return _snap.TUNGraph_GetSmallGraph()

    GetSmallGraph = staticmethod(GetSmallGraph)
    __swig_destroy__ = _snap.delete_TUNGraph
TUNGraph.Save = new_instancemethod(_snap.TUNGraph_Save,None,TUNGraph)
TUNGraph.HasFlag = new_instancemethod(_snap.TUNGraph_HasFlag,None,TUNGraph)
TUNGraph.GetNodes = new_instancemethod(_snap.TUNGraph_GetNodes,None,TUNGraph)
TUNGraph.AddNode = new_instancemethod(_snap.TUNGraph_AddNode,None,TUNGraph)
TUNGraph.DelNode = new_instancemethod(_snap.TUNGraph_DelNode,None,TUNGraph)
TUNGraph.IsNode = new_instancemethod(_snap.TUNGraph_IsNode,None,TUNGraph)
TUNGraph.BegNI = new_instancemethod(_snap.TUNGraph_BegNI,None,TUNGraph)
TUNGraph.EndNI = new_instancemethod(_snap.TUNGraph_EndNI,None,TUNGraph)
TUNGraph.GetNI = new_instancemethod(_snap.TUNGraph_GetNI,None,TUNGraph)
TUNGraph.GetMxNId = new_instancemethod(_snap.TUNGraph_GetMxNId,None,TUNGraph)
TUNGraph.GetEdges = new_instancemethod(_snap.TUNGraph_GetEdges,None,TUNGraph)
TUNGraph.AddEdge = new_instancemethod(_snap.TUNGraph_AddEdge,None,TUNGraph)
TUNGraph.DelEdge = new_instancemethod(_snap.TUNGraph_DelEdge,None,TUNGraph)
TUNGraph.IsEdge = new_instancemethod(_snap.TUNGraph_IsEdge,None,TUNGraph)
TUNGraph.BegEI = new_instancemethod(_snap.TUNGraph_BegEI,None,TUNGraph)
TUNGraph.EndEI = new_instancemethod(_snap.TUNGraph_EndEI,None,TUNGraph)
TUNGraph.GetEI = new_instancemethod(_snap.TUNGraph_GetEI,None,TUNGraph)
TUNGraph.GetRndNId = new_instancemethod(_snap.TUNGraph_GetRndNId,None,TUNGraph)
TUNGraph.GetRndNI = new_instancemethod(_snap.TUNGraph_GetRndNI,None,TUNGraph)
TUNGraph.GetNIdV = new_instancemethod(_snap.TUNGraph_GetNIdV,None,TUNGraph)
TUNGraph.Empty = new_instancemethod(_snap.TUNGraph_Empty,None,TUNGraph)
TUNGraph.Clr = new_instancemethod(_snap.TUNGraph_Clr,None,TUNGraph)
TUNGraph.Reserve = new_instancemethod(_snap.TUNGraph_Reserve,None,TUNGraph)
TUNGraph.ReserveNIdDeg = new_instancemethod(_snap.TUNGraph_ReserveNIdDeg,None,TUNGraph)
TUNGraph.Defrag = new_instancemethod(_snap.TUNGraph_Defrag,None,TUNGraph)
TUNGraph.IsOk = new_instancemethod(_snap.TUNGraph_IsOk,None,TUNGraph)
TUNGraph.Dump = new_instancemethod(_snap.TUNGraph_Dump,None,TUNGraph)
TUNGraph_swigregister = _snap.TUNGraph_swigregister
TUNGraph_swigregister(TUNGraph)

def TUNGraph_New(*args):
  """
    New() -> PUNGraph
    TUNGraph_New(int const & Nodes, int const & Edges) -> PUNGraph

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TUNGraph_New(*args)

def TUNGraph_Load(*args):
  """
    TUNGraph_Load(TSIn SIn) -> PUNGraph

    Parameters:
        SIn: TSIn &

    """
  return _snap.TUNGraph_Load(*args)

def TUNGraph_GetSmallGraph():
  """TUNGraph_GetSmallGraph() -> PUNGraph"""
  return _snap.TUNGraph_GetSmallGraph()

class TNGraph(object):
    """Proxy of C++ TNGraph class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNGraph self) -> TNGraph
        __init__(TNGraph self, int const & Nodes, int const & Edges) -> TNGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TNGraph self, TNGraph Graph) -> TNGraph

        Parameters:
            Graph: TNGraph const &

        __init__(TNGraph self, TSIn SIn) -> TNGraph

        Parameters:
            SIn: TSIn &

        """
        _snap.TNGraph_swiginit(self,_snap.new_TNGraph(*args))
    def Save(self, *args):
        """
        Save(TNGraph self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TNGraph_Save(self, *args)

    def New(*args):
        """
        New() -> PNGraph
        New(int const & Nodes, int const & Edges) -> PNGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNGraph_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PNGraph

        Parameters:
            SIn: TSIn &

        """
        return _snap.TNGraph_Load(*args)

    Load = staticmethod(Load)
    def HasFlag(self, *args):
        """
        HasFlag(TNGraph self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.TNGraph_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(TNGraph self) -> int

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TNGraph self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TNGraph self) -> int
        AddNode(TNGraph self, TNGraph::TNodeI const & NodeId) -> int

        Parameters:
            NodeId: TNGraph::TNodeI const &

        AddNode(TNGraph self, int const & NId, TIntV InNIdV, TIntV OutNIdV) -> int

        Parameters:
            NId: int const &
            InNIdV: TIntV const &
            OutNIdV: TIntV const &

        AddNode(TNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & SrcVId, int const & DstVId) -> int

        Parameters:
            NId: int const &
            Pool: TVecPool< TInt > const &
            SrcVId: int const &
            DstVId: int const &

        """
        return _snap.TNGraph_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TNGraph self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TNGraph self, TNGraph::TNode const & NodeI)

        Parameters:
            NodeI: TNGraph::TNode const &

        """
        return _snap.TNGraph_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TNGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNGraph_IsNode(self, *args)

    def BegNI(self):
        """
        BegNI(TNGraph self) -> TNGraph::TNodeI

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_BegNI(self)

    def EndNI(self):
        """
        EndNI(TNGraph self) -> TNGraph::TNodeI

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_EndNI(self)

    def GetNI(self, *args):
        """
        GetNI(TNGraph self, int const & NId) -> TNGraph::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TNGraph_GetNI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TNGraph self) -> int

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(TNGraph self) -> int

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TNGraph self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(TNGraph self, TNGraph::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TNGraph::TEdgeI const &

        """
        return _snap.TNGraph_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TNGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        DelEdge(TNGraph self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNGraph_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TNGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        IsEdge(TNGraph self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNGraph_IsEdge(self, *args)

    def BegEI(self):
        """
        BegEI(TNGraph self) -> TNGraph::TEdgeI

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_BegEI(self)

    def EndEI(self):
        """
        EndEI(TNGraph self) -> TNGraph::TEdgeI

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_EndEI(self)

    def GetEI(self, *args):
        """
        GetEI(TNGraph self, int const & SrcNId, int const & DstNId) -> TNGraph::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNGraph_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TNGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TNGraph self) -> int

        Parameters:
            self: TNGraph *

        """
        return _snap.TNGraph_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TNGraph self, TRnd Rnd=Rnd) -> TNGraph::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TNGraph self) -> TNGraph::TNodeI

        Parameters:
            self: TNGraph *

        """
        return _snap.TNGraph_GetRndNI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TNGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TNGraph_GetNIdV(self, *args)

    def Empty(self):
        """
        Empty(TNGraph self) -> bool

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_Empty(self)

    def Clr(self):
        """
        Clr(TNGraph self)

        Parameters:
            self: TNGraph *

        """
        return _snap.TNGraph_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TNGraph self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNGraph_Reserve(self, *args)

    def ReserveNIdInDeg(self, *args):
        """
        ReserveNIdInDeg(TNGraph self, int const & NId, int const & InDeg)

        Parameters:
            NId: int const &
            InDeg: int const &

        """
        return _snap.TNGraph_ReserveNIdInDeg(self, *args)

    def ReserveNIdOutDeg(self, *args):
        """
        ReserveNIdOutDeg(TNGraph self, int const & NId, int const & OutDeg)

        Parameters:
            NId: int const &
            OutDeg: int const &

        """
        return _snap.TNGraph_ReserveNIdOutDeg(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TNGraph self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TNGraph self)

        Parameters:
            self: TNGraph *

        """
        return _snap.TNGraph_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TNGraph self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TNGraph self) -> bool

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TNGraph self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TNGraph self)

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_Dump(self, *args)

    def GetSmallGraph():
        """GetSmallGraph() -> PNGraph"""
        return _snap.TNGraph_GetSmallGraph()

    GetSmallGraph = staticmethod(GetSmallGraph)
    __swig_destroy__ = _snap.delete_TNGraph
TNGraph.Save = new_instancemethod(_snap.TNGraph_Save,None,TNGraph)
TNGraph.HasFlag = new_instancemethod(_snap.TNGraph_HasFlag,None,TNGraph)
TNGraph.GetNodes = new_instancemethod(_snap.TNGraph_GetNodes,None,TNGraph)
TNGraph.AddNode = new_instancemethod(_snap.TNGraph_AddNode,None,TNGraph)
TNGraph.DelNode = new_instancemethod(_snap.TNGraph_DelNode,None,TNGraph)
TNGraph.IsNode = new_instancemethod(_snap.TNGraph_IsNode,None,TNGraph)
TNGraph.BegNI = new_instancemethod(_snap.TNGraph_BegNI,None,TNGraph)
TNGraph.EndNI = new_instancemethod(_snap.TNGraph_EndNI,None,TNGraph)
TNGraph.GetNI = new_instancemethod(_snap.TNGraph_GetNI,None,TNGraph)
TNGraph.GetMxNId = new_instancemethod(_snap.TNGraph_GetMxNId,None,TNGraph)
TNGraph.GetEdges = new_instancemethod(_snap.TNGraph_GetEdges,None,TNGraph)
TNGraph.AddEdge = new_instancemethod(_snap.TNGraph_AddEdge,None,TNGraph)
TNGraph.DelEdge = new_instancemethod(_snap.TNGraph_DelEdge,None,TNGraph)
TNGraph.IsEdge = new_instancemethod(_snap.TNGraph_IsEdge,None,TNGraph)
TNGraph.BegEI = new_instancemethod(_snap.TNGraph_BegEI,None,TNGraph)
TNGraph.EndEI = new_instancemethod(_snap.TNGraph_EndEI,None,TNGraph)
TNGraph.GetEI = new_instancemethod(_snap.TNGraph_GetEI,None,TNGraph)
TNGraph.GetRndNId = new_instancemethod(_snap.TNGraph_GetRndNId,None,TNGraph)
TNGraph.GetRndNI = new_instancemethod(_snap.TNGraph_GetRndNI,None,TNGraph)
TNGraph.GetNIdV = new_instancemethod(_snap.TNGraph_GetNIdV,None,TNGraph)
TNGraph.Empty = new_instancemethod(_snap.TNGraph_Empty,None,TNGraph)
TNGraph.Clr = new_instancemethod(_snap.TNGraph_Clr,None,TNGraph)
TNGraph.Reserve = new_instancemethod(_snap.TNGraph_Reserve,None,TNGraph)
TNGraph.ReserveNIdInDeg = new_instancemethod(_snap.TNGraph_ReserveNIdInDeg,None,TNGraph)
TNGraph.ReserveNIdOutDeg = new_instancemethod(_snap.TNGraph_ReserveNIdOutDeg,None,TNGraph)
TNGraph.Defrag = new_instancemethod(_snap.TNGraph_Defrag,None,TNGraph)
TNGraph.IsOk = new_instancemethod(_snap.TNGraph_IsOk,None,TNGraph)
TNGraph.Dump = new_instancemethod(_snap.TNGraph_Dump,None,TNGraph)
TNGraph_swigregister = _snap.TNGraph_swigregister
TNGraph_swigregister(TNGraph)

def TNGraph_New(*args):
  """
    New() -> PNGraph
    TNGraph_New(int const & Nodes, int const & Edges) -> PNGraph

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TNGraph_New(*args)

def TNGraph_Load(*args):
  """
    TNGraph_Load(TSIn SIn) -> PNGraph

    Parameters:
        SIn: TSIn &

    """
  return _snap.TNGraph_Load(*args)

def TNGraph_GetSmallGraph():
  """TNGraph_GetSmallGraph() -> PNGraph"""
  return _snap.TNGraph_GetSmallGraph()

class TNEGraph(object):
    """Proxy of C++ TNEGraph class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEGraph self) -> TNEGraph
        __init__(TNEGraph self, int const & Nodes, int const & Edges) -> TNEGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TNEGraph self, TNEGraph Graph) -> TNEGraph

        Parameters:
            Graph: TNEGraph const &

        __init__(TNEGraph self, TSIn SIn) -> TNEGraph

        Parameters:
            SIn: TSIn &

        """
        _snap.TNEGraph_swiginit(self,_snap.new_TNEGraph(*args))
    def Save(self, *args):
        """
        Save(TNEGraph self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TNEGraph_Save(self, *args)

    def New(*args):
        """
        New() -> PNEGraph
        New(int const & Nodes, int const & Edges) -> PNEGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNEGraph_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PNEGraph

        Parameters:
            SIn: TSIn &

        """
        return _snap.TNEGraph_Load(*args)

    Load = staticmethod(Load)
    def HasFlag(self, *args):
        """
        HasFlag(TNEGraph self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.TNEGraph_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(TNEGraph self) -> int

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TNEGraph self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TNEGraph self) -> int
        AddNode(TNEGraph self, TNEGraph::TNodeI const & NodeId) -> int

        Parameters:
            NodeId: TNEGraph::TNodeI const &

        """
        return _snap.TNEGraph_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TNEGraph self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TNEGraph self, TNEGraph::TNode const & NodeI)

        Parameters:
            NodeI: TNEGraph::TNode const &

        """
        return _snap.TNEGraph_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TNEGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEGraph_IsNode(self, *args)

    def BegNI(self):
        """
        BegNI(TNEGraph self) -> TNEGraph::TNodeI

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_BegNI(self)

    def EndNI(self):
        """
        EndNI(TNEGraph self) -> TNEGraph::TNodeI

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_EndNI(self)

    def GetNI(self, *args):
        """
        GetNI(TNEGraph self, int const & NId) -> TNEGraph::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TNEGraph_GetNI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TNEGraph self) -> int

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(TNEGraph self) -> int

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int EId=-1) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int

        AddEdge(TNEGraph self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(TNEGraph self, TNEGraph::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TNEGraph::TEdgeI const &

        """
        return _snap.TNEGraph_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TNEGraph self, int const & EId)

        Parameters:
            EId: int const &

        DelEdge(TNEGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        DelEdge(TNEGraph self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEGraph_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TNEGraph self, int const & EId) -> bool

        Parameters:
            EId: int const &

        IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &
            IsDir: bool const &

        IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int & EId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &

        """
        return _snap.TNEGraph_IsEdge(self, *args)

    def GetEId(self, *args):
        """
        GetEId(TNEGraph self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEGraph_GetEId(self, *args)

    def BegEI(self):
        """
        BegEI(TNEGraph self) -> TNEGraph::TEdgeI

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_BegEI(self)

    def EndEI(self):
        """
        EndEI(TNEGraph self) -> TNEGraph::TEdgeI

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_EndEI(self)

    def GetEI(self, *args):
        """
        GetEI(TNEGraph self, int const & EId) -> TNEGraph::TEdgeI

        Parameters:
            EId: int const &

        GetEI(TNEGraph self, int const & SrcNId, int const & DstNId) -> TNEGraph::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEGraph_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TNEGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TNEGraph self) -> int

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TNEGraph self, TRnd Rnd=Rnd) -> TNEGraph::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TNEGraph self) -> TNEGraph::TNodeI

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_GetRndNI(self, *args)

    def GetRndEId(self, *args):
        """
        GetRndEId(TNEGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndEId(TNEGraph self) -> int

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_GetRndEId(self, *args)

    def GetRndEI(self, *args):
        """
        GetRndEI(TNEGraph self, TRnd Rnd=Rnd) -> TNEGraph::TEdgeI

        Parameters:
            Rnd: TRnd &

        GetRndEI(TNEGraph self) -> TNEGraph::TEdgeI

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_GetRndEI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TNEGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TNEGraph_GetNIdV(self, *args)

    def GetEIdV(self, *args):
        """
        GetEIdV(TNEGraph self, TIntV EIdV)

        Parameters:
            EIdV: TIntV &

        """
        return _snap.TNEGraph_GetEIdV(self, *args)

    def Empty(self):
        """
        Empty(TNEGraph self) -> bool

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_Empty(self)

    def Clr(self):
        """
        Clr(TNEGraph self)

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TNEGraph self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNEGraph_Reserve(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TNEGraph self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TNEGraph self)

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TNEGraph self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TNEGraph self) -> bool

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TNEGraph self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TNEGraph self)

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_Dump(self, *args)

    __swig_destroy__ = _snap.delete_TNEGraph
TNEGraph.Save = new_instancemethod(_snap.TNEGraph_Save,None,TNEGraph)
TNEGraph.HasFlag = new_instancemethod(_snap.TNEGraph_HasFlag,None,TNEGraph)
TNEGraph.GetNodes = new_instancemethod(_snap.TNEGraph_GetNodes,None,TNEGraph)
TNEGraph.AddNode = new_instancemethod(_snap.TNEGraph_AddNode,None,TNEGraph)
TNEGraph.DelNode = new_instancemethod(_snap.TNEGraph_DelNode,None,TNEGraph)
TNEGraph.IsNode = new_instancemethod(_snap.TNEGraph_IsNode,None,TNEGraph)
TNEGraph.BegNI = new_instancemethod(_snap.TNEGraph_BegNI,None,TNEGraph)
TNEGraph.EndNI = new_instancemethod(_snap.TNEGraph_EndNI,None,TNEGraph)
TNEGraph.GetNI = new_instancemethod(_snap.TNEGraph_GetNI,None,TNEGraph)
TNEGraph.GetMxNId = new_instancemethod(_snap.TNEGraph_GetMxNId,None,TNEGraph)
TNEGraph.GetEdges = new_instancemethod(_snap.TNEGraph_GetEdges,None,TNEGraph)
TNEGraph.AddEdge = new_instancemethod(_snap.TNEGraph_AddEdge,None,TNEGraph)
TNEGraph.DelEdge = new_instancemethod(_snap.TNEGraph_DelEdge,None,TNEGraph)
TNEGraph.IsEdge = new_instancemethod(_snap.TNEGraph_IsEdge,None,TNEGraph)
TNEGraph.GetEId = new_instancemethod(_snap.TNEGraph_GetEId,None,TNEGraph)
TNEGraph.BegEI = new_instancemethod(_snap.TNEGraph_BegEI,None,TNEGraph)
TNEGraph.EndEI = new_instancemethod(_snap.TNEGraph_EndEI,None,TNEGraph)
TNEGraph.GetEI = new_instancemethod(_snap.TNEGraph_GetEI,None,TNEGraph)
TNEGraph.GetRndNId = new_instancemethod(_snap.TNEGraph_GetRndNId,None,TNEGraph)
TNEGraph.GetRndNI = new_instancemethod(_snap.TNEGraph_GetRndNI,None,TNEGraph)
TNEGraph.GetRndEId = new_instancemethod(_snap.TNEGraph_GetRndEId,None,TNEGraph)
TNEGraph.GetRndEI = new_instancemethod(_snap.TNEGraph_GetRndEI,None,TNEGraph)
TNEGraph.GetNIdV = new_instancemethod(_snap.TNEGraph_GetNIdV,None,TNEGraph)
TNEGraph.GetEIdV = new_instancemethod(_snap.TNEGraph_GetEIdV,None,TNEGraph)
TNEGraph.Empty = new_instancemethod(_snap.TNEGraph_Empty,None,TNEGraph)
TNEGraph.Clr = new_instancemethod(_snap.TNEGraph_Clr,None,TNEGraph)
TNEGraph.Reserve = new_instancemethod(_snap.TNEGraph_Reserve,None,TNEGraph)
TNEGraph.Defrag = new_instancemethod(_snap.TNEGraph_Defrag,None,TNEGraph)
TNEGraph.IsOk = new_instancemethod(_snap.TNEGraph_IsOk,None,TNEGraph)
TNEGraph.Dump = new_instancemethod(_snap.TNEGraph_Dump,None,TNEGraph)
TNEGraph_swigregister = _snap.TNEGraph_swigregister
TNEGraph_swigregister(TNEGraph)

def TNEGraph_New(*args):
  """
    New() -> PNEGraph
    TNEGraph_New(int const & Nodes, int const & Edges) -> PNEGraph

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TNEGraph_New(*args)

def TNEGraph_Load(*args):
  """
    TNEGraph_Load(TSIn SIn) -> PNEGraph

    Parameters:
        SIn: TSIn &

    """
  return _snap.TNEGraph_Load(*args)

class TBPGraph(object):
    """Proxy of C++ TBPGraph class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    bgsUndef = _snap.TBPGraph_bgsUndef
    bgsLeft = _snap.TBPGraph_bgsLeft
    bgsRight = _snap.TBPGraph_bgsRight
    bgsBoth = _snap.TBPGraph_bgsBoth
    def __init__(self, *args): 
        """
        __init__(TBPGraph self) -> TBPGraph
        __init__(TBPGraph self, int const & Nodes, int const & Edges) -> TBPGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TBPGraph self, TBPGraph BPGraph) -> TBPGraph

        Parameters:
            BPGraph: TBPGraph const &

        __init__(TBPGraph self, TSIn SIn) -> TBPGraph

        Parameters:
            SIn: TSIn &

        """
        _snap.TBPGraph_swiginit(self,_snap.new_TBPGraph(*args))
    def Save(self, *args):
        """
        Save(TBPGraph self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TBPGraph_Save(self, *args)

    def New(*args):
        """
        New() -> PBPGraph
        New(int const & Nodes, int const & Edges) -> PBPGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TBPGraph_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PBPGraph

        Parameters:
            SIn: TSIn &

        """
        return _snap.TBPGraph_Load(*args)

    Load = staticmethod(Load)
    def GetNodes(self):
        """
        GetNodes(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetNodes(self)

    def GetLNodes(self):
        """
        GetLNodes(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetLNodes(self)

    def GetRNodes(self):
        """
        GetRNodes(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetRNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TBPGraph self, int NId=-1, bool const & LeftNode=True) -> int

        Parameters:
            NId: int
            LeftNode: bool const &

        AddNode(TBPGraph self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TBPGraph self) -> int
        AddNode(TBPGraph self, TBPGraph::TNodeI const & NodeI) -> int

        Parameters:
            NodeI: TBPGraph::TNodeI const &

        """
        return _snap.TBPGraph_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TBPGraph self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TBPGraph self, TBPGraph::TNode const & NodeI)

        Parameters:
            NodeI: TBPGraph::TNode const &

        """
        return _snap.TBPGraph_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TBPGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TBPGraph_IsNode(self, *args)

    def IsLNode(self, *args):
        """
        IsLNode(TBPGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TBPGraph_IsLNode(self, *args)

    def IsRNode(self, *args):
        """
        IsRNode(TBPGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TBPGraph_IsRNode(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetMxNId(self)

    def BegNI(self):
        """
        BegNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_BegNI(self)

    def EndNI(self):
        """
        EndNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_EndNI(self)

    def GetNI(self, *args):
        """
        GetNI(TBPGraph self, int const & NId) -> TBPGraph::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TBPGraph_GetNI(self, *args)

    def BegLNI(self):
        """
        BegLNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_BegLNI(self)

    def EndLNI(self):
        """
        EndLNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_EndLNI(self)

    def BegRNI(self):
        """
        BegRNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_BegRNI(self)

    def EndRNI(self):
        """
        EndRNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_EndRNI(self)

    def GetEdges(self):
        """
        GetEdges(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TBPGraph self, int const & LeftNId, int const & RightNId) -> int

        Parameters:
            LeftNId: int const &
            RightNId: int const &

        AddEdge(TBPGraph self, TBPGraph::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TBPGraph::TEdgeI const &

        """
        return _snap.TBPGraph_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TBPGraph self, int const & LeftNId, int const & RightNId)

        Parameters:
            LeftNId: int const &
            RightNId: int const &

        """
        return _snap.TBPGraph_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TBPGraph self, int const & LeftNId, int const & RightNId) -> bool

        Parameters:
            LeftNId: int const &
            RightNId: int const &

        """
        return _snap.TBPGraph_IsEdge(self, *args)

    def BegEI(self):
        """
        BegEI(TBPGraph self) -> TBPGraph::TEdgeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_BegEI(self)

    def EndEI(self):
        """
        EndEI(TBPGraph self) -> TBPGraph::TEdgeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_EndEI(self)

    def GetEI(self, *args):
        """
        GetEI(TBPGraph self, int const & LeftNId, int const & RightNId) -> TBPGraph::TEdgeI

        Parameters:
            LeftNId: int const &
            RightNId: int const &

        """
        return _snap.TBPGraph_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TBPGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TBPGraph self) -> int

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_GetRndNId(self, *args)

    def GetRndLNId(self, *args):
        """
        GetRndLNId(TBPGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndLNId(TBPGraph self) -> int

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_GetRndLNId(self, *args)

    def GetRndRNId(self, *args):
        """
        GetRndRNId(TBPGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndRNId(TBPGraph self) -> int

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_GetRndRNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TBPGraph self, TRnd Rnd=Rnd) -> TBPGraph::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_GetRndNI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TBPGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TBPGraph_GetNIdV(self, *args)

    def GetLNIdV(self, *args):
        """
        GetLNIdV(TBPGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TBPGraph_GetLNIdV(self, *args)

    def GetRNIdV(self, *args):
        """
        GetRNIdV(TBPGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TBPGraph_GetRNIdV(self, *args)

    def Empty(self):
        """
        Empty(TBPGraph self) -> bool

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_Empty(self)

    def Clr(self):
        """
        Clr(TBPGraph self)

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TBPGraph self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TBPGraph_Reserve(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TBPGraph self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TBPGraph self)

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TBPGraph self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TBPGraph self) -> bool

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TBPGraph self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TBPGraph self)

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_Dump(self, *args)

    def GetSmallGraph():
        """GetSmallGraph() -> PBPGraph"""
        return _snap.TBPGraph_GetSmallGraph()

    GetSmallGraph = staticmethod(GetSmallGraph)
    __swig_destroy__ = _snap.delete_TBPGraph
TBPGraph.Save = new_instancemethod(_snap.TBPGraph_Save,None,TBPGraph)
TBPGraph.GetNodes = new_instancemethod(_snap.TBPGraph_GetNodes,None,TBPGraph)
TBPGraph.GetLNodes = new_instancemethod(_snap.TBPGraph_GetLNodes,None,TBPGraph)
TBPGraph.GetRNodes = new_instancemethod(_snap.TBPGraph_GetRNodes,None,TBPGraph)
TBPGraph.AddNode = new_instancemethod(_snap.TBPGraph_AddNode,None,TBPGraph)
TBPGraph.DelNode = new_instancemethod(_snap.TBPGraph_DelNode,None,TBPGraph)
TBPGraph.IsNode = new_instancemethod(_snap.TBPGraph_IsNode,None,TBPGraph)
TBPGraph.IsLNode = new_instancemethod(_snap.TBPGraph_IsLNode,None,TBPGraph)
TBPGraph.IsRNode = new_instancemethod(_snap.TBPGraph_IsRNode,None,TBPGraph)
TBPGraph.GetMxNId = new_instancemethod(_snap.TBPGraph_GetMxNId,None,TBPGraph)
TBPGraph.BegNI = new_instancemethod(_snap.TBPGraph_BegNI,None,TBPGraph)
TBPGraph.EndNI = new_instancemethod(_snap.TBPGraph_EndNI,None,TBPGraph)
TBPGraph.GetNI = new_instancemethod(_snap.TBPGraph_GetNI,None,TBPGraph)
TBPGraph.BegLNI = new_instancemethod(_snap.TBPGraph_BegLNI,None,TBPGraph)
TBPGraph.EndLNI = new_instancemethod(_snap.TBPGraph_EndLNI,None,TBPGraph)
TBPGraph.BegRNI = new_instancemethod(_snap.TBPGraph_BegRNI,None,TBPGraph)
TBPGraph.EndRNI = new_instancemethod(_snap.TBPGraph_EndRNI,None,TBPGraph)
TBPGraph.GetEdges = new_instancemethod(_snap.TBPGraph_GetEdges,None,TBPGraph)
TBPGraph.AddEdge = new_instancemethod(_snap.TBPGraph_AddEdge,None,TBPGraph)
TBPGraph.DelEdge = new_instancemethod(_snap.TBPGraph_DelEdge,None,TBPGraph)
TBPGraph.IsEdge = new_instancemethod(_snap.TBPGraph_IsEdge,None,TBPGraph)
TBPGraph.BegEI = new_instancemethod(_snap.TBPGraph_BegEI,None,TBPGraph)
TBPGraph.EndEI = new_instancemethod(_snap.TBPGraph_EndEI,None,TBPGraph)
TBPGraph.GetEI = new_instancemethod(_snap.TBPGraph_GetEI,None,TBPGraph)
TBPGraph.GetRndNId = new_instancemethod(_snap.TBPGraph_GetRndNId,None,TBPGraph)
TBPGraph.GetRndLNId = new_instancemethod(_snap.TBPGraph_GetRndLNId,None,TBPGraph)
TBPGraph.GetRndRNId = new_instancemethod(_snap.TBPGraph_GetRndRNId,None,TBPGraph)
TBPGraph.GetRndNI = new_instancemethod(_snap.TBPGraph_GetRndNI,None,TBPGraph)
TBPGraph.GetNIdV = new_instancemethod(_snap.TBPGraph_GetNIdV,None,TBPGraph)
TBPGraph.GetLNIdV = new_instancemethod(_snap.TBPGraph_GetLNIdV,None,TBPGraph)
TBPGraph.GetRNIdV = new_instancemethod(_snap.TBPGraph_GetRNIdV,None,TBPGraph)
TBPGraph.Empty = new_instancemethod(_snap.TBPGraph_Empty,None,TBPGraph)
TBPGraph.Clr = new_instancemethod(_snap.TBPGraph_Clr,None,TBPGraph)
TBPGraph.Reserve = new_instancemethod(_snap.TBPGraph_Reserve,None,TBPGraph)
TBPGraph.Defrag = new_instancemethod(_snap.TBPGraph_Defrag,None,TBPGraph)
TBPGraph.IsOk = new_instancemethod(_snap.TBPGraph_IsOk,None,TBPGraph)
TBPGraph.Dump = new_instancemethod(_snap.TBPGraph_Dump,None,TBPGraph)
TBPGraph_swigregister = _snap.TBPGraph_swigregister
TBPGraph_swigregister(TBPGraph)

def TBPGraph_New(*args):
  """
    New() -> PBPGraph
    TBPGraph_New(int const & Nodes, int const & Edges) -> PBPGraph

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TBPGraph_New(*args)

def TBPGraph_Load(*args):
  """
    TBPGraph_Load(TSIn SIn) -> PBPGraph

    Parameters:
        SIn: TSIn &

    """
  return _snap.TBPGraph_Load(*args)

def TBPGraph_GetSmallGraph():
  """TBPGraph_GetSmallGraph() -> PBPGraph"""
  return _snap.TBPGraph_GetSmallGraph()

class TNGraphMtx(object):
    """Proxy of C++ TNGraphMtx class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNGraphMtx self, PNGraph const & GraphPt) -> TNGraphMtx

        Parameters:
            GraphPt: PNGraph const &

        __init__(TNGraphMtx self, TNGraphMtx GraphMtx) -> TNGraphMtx

        Parameters:
            GraphMtx: TNGraphMtx const &

        """
        _snap.TNGraphMtx_swiginit(self,_snap.new_TNGraphMtx(*args))
    def PGetRows(self):
        """
        PGetRows(TNGraphMtx self) -> int

        Parameters:
            self: TNGraphMtx const *

        """
        return _snap.TNGraphMtx_PGetRows(self)

    def PGetCols(self):
        """
        PGetCols(TNGraphMtx self) -> int

        Parameters:
            self: TNGraphMtx const *

        """
        return _snap.TNGraphMtx_PGetCols(self)

    def PMultiply(self, *args):
        """
        PMultiply(TNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)

        Parameters:
            B: TFltVV const &
            ColId: int
            Result: TFltV &

        PMultiply(TNGraphMtx self, TFltV const & Vec, TFltV & Result)

        Parameters:
            Vec: TFltV const &
            Result: TFltV &

        """
        return _snap.TNGraphMtx_PMultiply(self, *args)

    def PMultiplyT(self, *args):
        """
        PMultiplyT(TNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)

        Parameters:
            B: TFltVV const &
            ColId: int
            Result: TFltV &

        PMultiplyT(TNGraphMtx self, TFltV const & Vec, TFltV & Result)

        Parameters:
            Vec: TFltV const &
            Result: TFltV &

        """
        return _snap.TNGraphMtx_PMultiplyT(self, *args)

    __swig_destroy__ = _snap.delete_TNGraphMtx
TNGraphMtx.PGetRows = new_instancemethod(_snap.TNGraphMtx_PGetRows,None,TNGraphMtx)
TNGraphMtx.PGetCols = new_instancemethod(_snap.TNGraphMtx_PGetCols,None,TNGraphMtx)
TNGraphMtx.PMultiply = new_instancemethod(_snap.TNGraphMtx_PMultiply,None,TNGraphMtx)
TNGraphMtx.PMultiplyT = new_instancemethod(_snap.TNGraphMtx_PMultiplyT,None,TNGraphMtx)
TNGraphMtx_swigregister = _snap.TNGraphMtx_swigregister
TNGraphMtx_swigregister(TNGraphMtx)

class TUNGraphMtx(object):
    """Proxy of C++ TUNGraphMtx class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TUNGraphMtx self, PUNGraph const & GraphPt) -> TUNGraphMtx

        Parameters:
            GraphPt: PUNGraph const &

        __init__(TUNGraphMtx self, TUNGraphMtx GraphMtx) -> TUNGraphMtx

        Parameters:
            GraphMtx: TUNGraphMtx const &

        """
        _snap.TUNGraphMtx_swiginit(self,_snap.new_TUNGraphMtx(*args))
    def PGetRows(self):
        """
        PGetRows(TUNGraphMtx self) -> int

        Parameters:
            self: TUNGraphMtx const *

        """
        return _snap.TUNGraphMtx_PGetRows(self)

    def PGetCols(self):
        """
        PGetCols(TUNGraphMtx self) -> int

        Parameters:
            self: TUNGraphMtx const *

        """
        return _snap.TUNGraphMtx_PGetCols(self)

    def PMultiply(self, *args):
        """
        PMultiply(TUNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)

        Parameters:
            B: TFltVV const &
            ColId: int
            Result: TFltV &

        PMultiply(TUNGraphMtx self, TFltV const & Vec, TFltV & Result)

        Parameters:
            Vec: TFltV const &
            Result: TFltV &

        """
        return _snap.TUNGraphMtx_PMultiply(self, *args)

    def PMultiplyT(self, *args):
        """
        PMultiplyT(TUNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)

        Parameters:
            B: TFltVV const &
            ColId: int
            Result: TFltV &

        PMultiplyT(TUNGraphMtx self, TFltV const & Vec, TFltV & Result)

        Parameters:
            Vec: TFltV const &
            Result: TFltV &

        """
        return _snap.TUNGraphMtx_PMultiplyT(self, *args)

    __swig_destroy__ = _snap.delete_TUNGraphMtx
TUNGraphMtx.PGetRows = new_instancemethod(_snap.TUNGraphMtx_PGetRows,None,TUNGraphMtx)
TUNGraphMtx.PGetCols = new_instancemethod(_snap.TUNGraphMtx_PGetCols,None,TUNGraphMtx)
TUNGraphMtx.PMultiply = new_instancemethod(_snap.TUNGraphMtx_PMultiply,None,TUNGraphMtx)
TUNGraphMtx.PMultiplyT = new_instancemethod(_snap.TUNGraphMtx_PMultiplyT,None,TUNGraphMtx)
TUNGraphMtx_swigregister = _snap.TUNGraphMtx_swigregister
TUNGraphMtx_swigregister(TUNGraphMtx)


def GetSngVals(*args):
  """
    GetSngVals(PNGraph const & Graph, int const & SngVals, TFltV & SngValV)

    Parameters:
        Graph: PNGraph const &
        SngVals: int const &
        SngValV: TFltV &

    """
  return _snap.GetSngVals(*args)

def GetSngVec(*args):
  """
    GetSngVec(PNGraph const & Graph, TFltV & LeftSV, TFltV & RightSV)

    Parameters:
        Graph: PNGraph const &
        LeftSV: TFltV &
        RightSV: TFltV &

    GetSngVec(PNGraph const & Graph, int const & SngVecs, TFltV & SngValV, TVec< TFltV > & LeftSV, 
        TVec< TFltV > & RightSV)

    Parameters:
        Graph: PNGraph const &
        SngVecs: int const &
        SngValV: TFltV &
        LeftSV: TVec< TFltV > &
        RightSV: TVec< TFltV > &

    """
  return _snap.GetSngVec(*args)

def GetEigVals(*args):
  """
    GetEigVals(PUNGraph const & Graph, int const & EigVals, TFltV & EigValV)

    Parameters:
        Graph: PUNGraph const &
        EigVals: int const &
        EigValV: TFltV &

    """
  return _snap.GetEigVals(*args)

def GetEigVec(*args):
  """
    GetEigVec(PUNGraph const & Graph, TFltV & EigVecV)

    Parameters:
        Graph: PUNGraph const &
        EigVecV: TFltV &

    GetEigVec(PUNGraph const & Graph, int const & EigVecs, TFltV & EigValV, TVec< TFltV > & EigVecV)

    Parameters:
        Graph: PUNGraph const &
        EigVecs: int const &
        EigValV: TFltV &
        EigVecV: TVec< TFltV > &

    """
  return _snap.GetEigVec(*args)

def GetInvParticipRat(*args):
  """
    GetInvParticipRat(PUNGraph const & Graph, int MaxEigVecs, int TimeLimit, TFltPrV & EigValIprV)

    Parameters:
        Graph: PUNGraph const &
        MaxEigVecs: int
        TimeLimit: int
        EigValIprV: TFltPrV &

    """
  return _snap.GetInvParticipRat(*args)

def GetInvParticipRatEig(*args):
  """
    GetInvParticipRatEig(TFltV const & EigVec) -> double

    Parameters:
        EigVec: TFltV const &

    """
  return _snap.GetInvParticipRatEig(*args)

def LoadDyNet(*args):
  """
    LoadDyNet(TStr FNm) -> PNGraph

    Parameters:
        FNm: TStr const &

    """
  return _snap.LoadDyNet(*args)

def LoadDyNetGraphV(*args):
  """
    LoadDyNetGraphV(TStr FNm) -> TVec< PNGraph >

    Parameters:
        FNm: TStr const &

    """
  return _snap.LoadDyNetGraphV(*args)
gvlDot = _snap.gvlDot
gvlNeato = _snap.gvlNeato
gvlTwopi = _snap.gvlTwopi
gvlCirco = _snap.gvlCirco

def GVizDoLayout(*args):
  """
    GVizDoLayout(TStr GraphInFNm, TStr OutFNm, TGVizLayout const & Layout)

    Parameters:
        GraphInFNm: TStr const &
        OutFNm: TStr
        Layout: TGVizLayout const &

    """
  return _snap.GVizDoLayout(*args)

def GVizGetLayoutStr(*args):
  """
    GVizGetLayoutStr(TGVizLayout const & Layout) -> TStr

    Parameters:
        Layout: TGVizLayout const &

    """
  return _snap.GVizGetLayoutStr(*args)
class TBigStrPool(object):
    """Proxy of C++ TBigStrPool class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TBigStrPool self, TSize MxBfLen=0, uint _GrowBy=16*1024*1024) -> TBigStrPool

        Parameters:
            MxBfLen: TSize
            _GrowBy: uint

        __init__(TBigStrPool self, TSize MxBfLen=0) -> TBigStrPool

        Parameters:
            MxBfLen: TSize

        __init__(TBigStrPool self) -> TBigStrPool
        __init__(TBigStrPool self, TSIn SIn, bool LoadCompact=True) -> TBigStrPool

        Parameters:
            SIn: TSIn &
            LoadCompact: bool

        __init__(TBigStrPool self, TSIn SIn) -> TBigStrPool

        Parameters:
            SIn: TSIn &

        __init__(TBigStrPool self, TBigStrPool Pool) -> TBigStrPool

        Parameters:
            Pool: TBigStrPool const &

        """
        _snap.TBigStrPool_swiginit(self,_snap.new_TBigStrPool(*args))
    __swig_destroy__ = _snap.delete_TBigStrPool
    def New(*args):
        """
        New(TSize _MxBfLen=0, uint _GrowBy=16*1024*1024) -> PBigStrPool

        Parameters:
            _MxBfLen: TSize
            _GrowBy: uint

        New(TSize _MxBfLen=0) -> PBigStrPool

        Parameters:
            _MxBfLen: TSize

        New() -> PBigStrPool
        New(TSIn SIn) -> PBigStrPool

        Parameters:
            SIn: TSIn &

        New(TStr fileName) -> PBigStrPool

        Parameters:
            fileName: TStr const &

        """
        return _snap.TBigStrPool_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn, bool LoadCompacted=True) -> PBigStrPool

        Parameters:
            SIn: TSIn &
            LoadCompacted: bool

        Load(TSIn SIn) -> PBigStrPool

        Parameters:
            SIn: TSIn &

        """
        return _snap.TBigStrPool_Load(*args)

    Load = staticmethod(Load)
    def Save(self, *args):
        """
        Save(TBigStrPool self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        Save(TBigStrPool self, TStr fileName)

        Parameters:
            fileName: TStr const &

        """
        return _snap.TBigStrPool_Save(self, *args)

    def GetStrs(self):
        """
        GetStrs(TBigStrPool self) -> int

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool_GetStrs(self)

    def Len(self):
        """
        Len(TBigStrPool self) -> TSize

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool_Len(self)

    def Size(self):
        """
        Size(TBigStrPool self) -> TSize

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool_Size(self)

    def Empty(self):
        """
        Empty(TBigStrPool self) -> bool

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool_Empty(self)

    def __call__(self):
        """
        __call__(TBigStrPool self) -> char *

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool___call__(self)

    def AddStr(self, *args):
        """
        AddStr(TBigStrPool self, char const * Str, uint Len) -> int

        Parameters:
            Str: char const *
            Len: uint

        AddStr(TBigStrPool self, char const * Str) -> int

        Parameters:
            Str: char const *

        AddStr(TBigStrPool self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TBigStrPool_AddStr(self, *args)

    def GetCStr(self, *args):
        """
        GetCStr(TBigStrPool self, int const & StrId) -> char const *

        Parameters:
            StrId: int const &

        """
        return _snap.TBigStrPool_GetCStr(self, *args)

    def GetStrFromOffset(self, *args):
        """
        GetStrFromOffset(TBigStrPool self, TSize const & Offset) -> TStr

        Parameters:
            Offset: TSize const &

        """
        return _snap.TBigStrPool_GetStrFromOffset(self, *args)

    def GetCStrFromOffset(self, *args):
        """
        GetCStrFromOffset(TBigStrPool self, TSize const & Offset) -> char const *

        Parameters:
            Offset: TSize const &

        """
        return _snap.TBigStrPool_GetCStrFromOffset(self, *args)

    def Clr(self, DoDel=False):
        """
        Clr(TBigStrPool self, bool DoDel=False)

        Parameters:
            DoDel: bool

        Clr(TBigStrPool self)

        Parameters:
            self: TBigStrPool *

        """
        return _snap.TBigStrPool_Clr(self, DoDel)

    def Cmp(self, *args):
        """
        Cmp(TBigStrPool self, int const & StrId, char const * Str) -> int

        Parameters:
            StrId: int const &
            Str: char const *

        """
        return _snap.TBigStrPool_Cmp(self, *args)

    def GetPrimHashCd(self, *args):
        """
        GetPrimHashCd(TBigStrPool self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        GetPrimHashCd(TBigStrPool self, int const & StrId) -> int

        Parameters:
            StrId: int const &

        """
        return _snap.TBigStrPool_GetPrimHashCd(self, *args)

    def GetSecHashCd(self, *args):
        """
        GetSecHashCd(TBigStrPool self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        GetSecHashCd(TBigStrPool self, int const & StrId) -> int

        Parameters:
            StrId: int const &

        """
        return _snap.TBigStrPool_GetSecHashCd(self, *args)

TBigStrPool.Save = new_instancemethod(_snap.TBigStrPool_Save,None,TBigStrPool)
TBigStrPool.GetStrs = new_instancemethod(_snap.TBigStrPool_GetStrs,None,TBigStrPool)
TBigStrPool.Len = new_instancemethod(_snap.TBigStrPool_Len,None,TBigStrPool)
TBigStrPool.Size = new_instancemethod(_snap.TBigStrPool_Size,None,TBigStrPool)
TBigStrPool.Empty = new_instancemethod(_snap.TBigStrPool_Empty,None,TBigStrPool)
TBigStrPool.__call__ = new_instancemethod(_snap.TBigStrPool___call__,None,TBigStrPool)
TBigStrPool.AddStr = new_instancemethod(_snap.TBigStrPool_AddStr,None,TBigStrPool)
TBigStrPool.GetCStr = new_instancemethod(_snap.TBigStrPool_GetCStr,None,TBigStrPool)
TBigStrPool.GetStrFromOffset = new_instancemethod(_snap.TBigStrPool_GetStrFromOffset,None,TBigStrPool)
TBigStrPool.GetCStrFromOffset = new_instancemethod(_snap.TBigStrPool_GetCStrFromOffset,None,TBigStrPool)
TBigStrPool.Clr = new_instancemethod(_snap.TBigStrPool_Clr,None,TBigStrPool)
TBigStrPool.Cmp = new_instancemethod(_snap.TBigStrPool_Cmp,None,TBigStrPool)
TBigStrPool.GetPrimHashCd = new_instancemethod(_snap.TBigStrPool_GetPrimHashCd,None,TBigStrPool)
TBigStrPool.GetSecHashCd = new_instancemethod(_snap.TBigStrPool_GetSecHashCd,None,TBigStrPool)
TBigStrPool_swigregister = _snap.TBigStrPool_swigregister
TBigStrPool_swigregister(TBigStrPool)

def TBigStrPool_New(*args):
  """
    New(TSize _MxBfLen=0, uint _GrowBy=16*1024*1024) -> PBigStrPool

    Parameters:
        _MxBfLen: TSize
        _GrowBy: uint

    New(TSize _MxBfLen=0) -> PBigStrPool

    Parameters:
        _MxBfLen: TSize

    New() -> PBigStrPool
    New(TSIn SIn) -> PBigStrPool

    Parameters:
        SIn: TSIn &

    TBigStrPool_New(TStr fileName) -> PBigStrPool

    Parameters:
        fileName: TStr const &

    """
  return _snap.TBigStrPool_New(*args)

def TBigStrPool_Load(*args):
  """
    Load(TSIn SIn, bool LoadCompacted=True) -> PBigStrPool

    Parameters:
        SIn: TSIn &
        LoadCompacted: bool

    TBigStrPool_Load(TSIn SIn) -> PBigStrPool

    Parameters:
        SIn: TSIn &

    """
  return _snap.TBigStrPool_Load(*args)

class TStrHashF_OldGLib(object):
    """Proxy of C++ TStrHashF_OldGLib class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetPrimHashCd(*args):
        """
        GetPrimHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetPrimHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_OldGLib_GetPrimHashCd(*args)

    GetPrimHashCd = staticmethod(GetPrimHashCd)
    def GetSecHashCd(*args):
        """
        GetSecHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetSecHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_OldGLib_GetSecHashCd(*args)

    GetSecHashCd = staticmethod(GetSecHashCd)
    def __init__(self): 
        """__init__(TStrHashF_OldGLib self) -> TStrHashF_OldGLib"""
        _snap.TStrHashF_OldGLib_swiginit(self,_snap.new_TStrHashF_OldGLib())
    __swig_destroy__ = _snap.delete_TStrHashF_OldGLib
TStrHashF_OldGLib_swigregister = _snap.TStrHashF_OldGLib_swigregister
TStrHashF_OldGLib_swigregister(TStrHashF_OldGLib)

def TStrHashF_OldGLib_GetPrimHashCd(*args):
  """
    GetPrimHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_OldGLib_GetPrimHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_OldGLib_GetPrimHashCd(*args)

def TStrHashF_OldGLib_GetSecHashCd(*args):
  """
    GetSecHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_OldGLib_GetSecHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_OldGLib_GetSecHashCd(*args)

class TStrHashF_Md5(object):
    """Proxy of C++ TStrHashF_Md5 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetPrimHashCd(*args):
        """
        GetPrimHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetPrimHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_Md5_GetPrimHashCd(*args)

    GetPrimHashCd = staticmethod(GetPrimHashCd)
    def GetSecHashCd(*args):
        """
        GetSecHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetSecHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_Md5_GetSecHashCd(*args)

    GetSecHashCd = staticmethod(GetSecHashCd)
    def __init__(self): 
        """__init__(TStrHashF_Md5 self) -> TStrHashF_Md5"""
        _snap.TStrHashF_Md5_swiginit(self,_snap.new_TStrHashF_Md5())
    __swig_destroy__ = _snap.delete_TStrHashF_Md5
TStrHashF_Md5_swigregister = _snap.TStrHashF_Md5_swigregister
TStrHashF_Md5_swigregister(TStrHashF_Md5)

def TStrHashF_Md5_GetPrimHashCd(*args):
  """
    GetPrimHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_Md5_GetPrimHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_Md5_GetPrimHashCd(*args)

def TStrHashF_Md5_GetSecHashCd(*args):
  """
    GetSecHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_Md5_GetSecHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_Md5_GetSecHashCd(*args)

class TStrHashF_DJB(object):
    """Proxy of C++ TStrHashF_DJB class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetPrimHashCd(*args):
        """
        GetPrimHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetPrimHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_DJB_GetPrimHashCd(*args)

    GetPrimHashCd = staticmethod(GetPrimHashCd)
    def GetSecHashCd(*args):
        """
        GetSecHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetSecHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_DJB_GetSecHashCd(*args)

    GetSecHashCd = staticmethod(GetSecHashCd)
    def __init__(self): 
        """__init__(TStrHashF_DJB self) -> TStrHashF_DJB"""
        _snap.TStrHashF_DJB_swiginit(self,_snap.new_TStrHashF_DJB())
    __swig_destroy__ = _snap.delete_TStrHashF_DJB
TStrHashF_DJB_swigregister = _snap.TStrHashF_DJB_swigregister
TStrHashF_DJB_swigregister(TStrHashF_DJB)

def TStrHashF_DJB_GetPrimHashCd(*args):
  """
    GetPrimHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_DJB_GetPrimHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_DJB_GetPrimHashCd(*args)

def TStrHashF_DJB_GetSecHashCd(*args):
  """
    GetSecHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_DJB_GetSecHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_DJB_GetSecHashCd(*args)


def GenRndBipart(*args):
  """
    GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges, TRnd Rnd=Rnd) -> PBPGraph

    Parameters:
        LeftNodes: int const &
        RightNodes: int const &
        Edges: int const &
        Rnd: TRnd &

    GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges) -> PBPGraph

    Parameters:
        LeftNodes: int const &
        RightNodes: int const &
        Edges: int const &

    """
  return _snap.GenRndBipart(*args)

def GenRndDegK(*args):
  """
    GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeDeg: int const &
        NSwitch: int const &
        Rnd: TRnd &

    GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeDeg: int const &
        NSwitch: int const &

    GenRndDegK(int const & Nodes, int const & NodeDeg) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeDeg: int const &

    """
  return _snap.GenRndDegK(*args)

def GenRndPowerLaw(*args):
  """
    GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        PowerExp: double const &
        ConfModel: bool const &
        Rnd: TRnd &

    GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True) -> PUNGraph

    Parameters:
        Nodes: int const &
        PowerExp: double const &
        ConfModel: bool const &

    GenRndPowerLaw(int const & Nodes, double const & PowerExp) -> PUNGraph

    Parameters:
        Nodes: int const &
        PowerExp: double const &

    """
  return _snap.GenRndPowerLaw(*args)

def GenDegSeq(*args):
  """
    GenDegSeq(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        DegSeqV: TIntV const &
        Rnd: TRnd &

    GenDegSeq(TIntV DegSeqV) -> PUNGraph

    Parameters:
        DegSeqV: TIntV const &

    """
  return _snap.GenDegSeq(*args)

def GenPrefAttach(*args):
  """
    GenPrefAttach(int const & Nodes, int const & NodeOutDeg, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeOutDeg: int const &
        Rnd: TRnd &

    GenPrefAttach(int const & Nodes, int const & NodeOutDeg) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeOutDeg: int const &

    """
  return _snap.GenPrefAttach(*args)

def GenGeoPrefAttach(*args):
  """
    GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        OutDeg: int const &
        Beta: double const &
        Rnd: TRnd &

    GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta) -> PUNGraph

    Parameters:
        Nodes: int const &
        OutDeg: int const &
        Beta: double const &

    """
  return _snap.GenGeoPrefAttach(*args)

def GenSmallWorld(*args):
  """
    GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeOutDeg: int const &
        RewireProb: double const &
        Rnd: TRnd &

    GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeOutDeg: int const &
        RewireProb: double const &

    """
  return _snap.GenSmallWorld(*args)

def GenForestFire(*args):
  """
    GenForestFire(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph

    Parameters:
        Nodes: int const &
        FwdProb: double const &
        BckProb: double const &

    """
  return _snap.GenForestFire(*args)

def GenCopyModel(*args):
  """
    GenCopyModel(int const & Nodes, double const & Beta, TRnd Rnd=Rnd) -> PNGraph

    Parameters:
        Nodes: int const &
        Beta: double const &
        Rnd: TRnd &

    GenCopyModel(int const & Nodes, double const & Beta) -> PNGraph

    Parameters:
        Nodes: int const &
        Beta: double const &

    """
  return _snap.GenCopyModel(*args)

def GenRMat(*args):
  """
    GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C, 
        TRnd Rnd=Rnd) -> PNGraph

    Parameters:
        Nodes: int const &
        Edges: int const &
        A: double const &
        B: double const &
        C: double const &
        Rnd: TRnd &

    GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C) -> PNGraph

    Parameters:
        Nodes: int const &
        Edges: int const &
        A: double const &
        B: double const &
        C: double const &

    """
  return _snap.GenRMat(*args)

def GenRMatEpinions():
  """GenRMatEpinions() -> PNGraph"""
  return _snap.GenRMatEpinions()

def GenRewire(*args):
  """
    GenRewire(PUNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        NSwitch: int const &
        Rnd: TRnd &

    GenRewire(PUNGraph const & Graph, int const & NSwitch=100) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        NSwitch: int const &

    GenRewire(PUNGraph const & Graph) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &

    GenRewire(PNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PNGraph

    Parameters:
        Graph: PNGraph const &
        NSwitch: int const &
        Rnd: TRnd &

    GenRewire(PNGraph const & Graph, int const & NSwitch=100) -> PNGraph

    Parameters:
        Graph: PNGraph const &
        NSwitch: int const &

    GenRewire(PNGraph const & Graph) -> PNGraph

    Parameters:
        Graph: PNGraph const &

    GenRewire(PBPGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PBPGraph

    Parameters:
        Graph: PBPGraph const &
        NSwitch: int const &
        Rnd: TRnd &

    GenRewire(PBPGraph const & Graph, int const & NSwitch=100) -> PBPGraph

    Parameters:
        Graph: PBPGraph const &
        NSwitch: int const &

    GenRewire(PBPGraph const & Graph) -> PBPGraph

    Parameters:
        Graph: PBPGraph const &

    """
  return _snap.GenRewire(*args)

def GenConfModel(*args):
  """
    GenConfModel(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        DegSeqV: TIntV const &
        Rnd: TRnd &

    GenConfModel(TIntV DegSeqV) -> PUNGraph

    Parameters:
        DegSeqV: TIntV const &

    GenConfModel(PUNGraph const & G) -> PUNGraph

    Parameters:
        G: PUNGraph const &

    """
  return _snap.GenConfModel(*args)

def GetSubGraph(*args):
  """
    GetSubGraph(PUNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        NIdV: TIntV const &
        RenumberNodes: bool const &

    GetSubGraph(PUNGraph const & Graph, TIntV NIdV) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        NIdV: TIntV const &

    GetSubGraph(PNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PNGraph

    Parameters:
        Graph: PNGraph const &
        NIdV: TIntV const &
        RenumberNodes: bool const &

    GetSubGraph(PNGraph const & Graph, TIntV NIdV) -> PNGraph

    Parameters:
        Graph: PNGraph const &
        NIdV: TIntV const &

    """
  return _snap.GetSubGraph(*args)
class TGUtil(object):
    """Proxy of C++ TGUtil class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetCdf(*args):
        """
        GetCdf(TIntPrV const & PdfV, TIntPrV & CdfV)

        Parameters:
            PdfV: TIntPrV const &
            CdfV: TIntPrV &

        GetCdf(TFltPrV const & PdfV, TFltPrV & CdfV)

        Parameters:
            PdfV: TFltPrV const &
            CdfV: TFltPrV &

        GetCdf(TIntFltKdV const & PdfV, TIntFltKdV & CdfV)

        Parameters:
            PdfV: TIntFltKdV const &
            CdfV: TIntFltKdV &

        GetCdf(TIntPrV const & PdfV) -> TIntPrV

        Parameters:
            PdfV: TIntPrV const &

        GetCdf(TFltPrV const & PdfV) -> TFltPrV

        Parameters:
            PdfV: TFltPrV const &

        """
        return _snap.TGUtil_GetCdf(*args)

    GetCdf = staticmethod(GetCdf)
    def GetCCdf(*args):
        """
        GetCCdf(TIntPrV const & PdfV, TIntPrV & CCdfV)

        Parameters:
            PdfV: TIntPrV const &
            CCdfV: TIntPrV &

        GetCCdf(TFltPrV const & PdfV, TFltPrV & CCdfV)

        Parameters:
            PdfV: TFltPrV const &
            CCdfV: TFltPrV &

        GetCCdf(TIntFltKdV const & PdfV, TIntFltKdV & CCdfV)

        Parameters:
            PdfV: TIntFltKdV const &
            CCdfV: TIntFltKdV &

        GetCCdf(TIntPrV const & PdfV) -> TIntPrV

        Parameters:
            PdfV: TIntPrV const &

        GetCCdf(TFltPrV const & PdfV) -> TFltPrV

        Parameters:
            PdfV: TFltPrV const &

        """
        return _snap.TGUtil_GetCCdf(*args)

    GetCCdf = staticmethod(GetCCdf)
    def GetPdf(*args):
        """
        GetPdf(TIntPrV const & CdfV, TIntPrV & PdfV)

        Parameters:
            CdfV: TIntPrV const &
            PdfV: TIntPrV &

        GetPdf(TFltPrV const & CdfV, TFltPrV & PdfV)

        Parameters:
            CdfV: TFltPrV const &
            PdfV: TFltPrV &

        GetPdf(TIntFltKdV const & CdfV, TIntFltKdV & PdfV)

        Parameters:
            CdfV: TIntFltKdV const &
            PdfV: TIntFltKdV &

        """
        return _snap.TGUtil_GetPdf(*args)

    GetPdf = staticmethod(GetPdf)
    def Normalize(*args):
        """
        Normalize(TFltPrV & PdfV)

        Parameters:
            PdfV: TFltPrV &

        Normalize(TIntFltKdV & PdfV)

        Parameters:
            PdfV: TIntFltKdV &

        """
        return _snap.TGUtil_Normalize(*args)

    Normalize = staticmethod(Normalize)
    def MakeExpBins(*args):
        """
        MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)

        Parameters:
            XYValV: TFltPrV const &
            ExpXYValV: TFltPrV &
            BinFactor: double const &
            MinYVal: double const &

        MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2)

        Parameters:
            XYValV: TFltPrV const &
            ExpXYValV: TFltPrV &
            BinFactor: double const &

        MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV)

        Parameters:
            XYValV: TFltPrV const &
            ExpXYValV: TFltPrV &

        MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)

        Parameters:
            XYValV: TFltKdV const &
            ExpXYValV: TFltKdV &
            BinFactor: double const &
            MinYVal: double const &

        MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2)

        Parameters:
            XYValV: TFltKdV const &
            ExpXYValV: TFltKdV &
            BinFactor: double const &

        MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV)

        Parameters:
            XYValV: TFltKdV const &
            ExpXYValV: TFltKdV &

        MakeExpBins(TFltV const & YValV, TFltV & ExpYValV, double const & BinFactor=1.01)

        Parameters:
            YValV: TFltV const &
            ExpYValV: TFltV &
            BinFactor: double const &

        MakeExpBins(TFltV const & YValV, TFltV & ExpYValV)

        Parameters:
            YValV: TFltV const &
            ExpYValV: TFltV &

        MakeExpBins(TIntV YValV, TIntV ExpYValV, double const & BinFactor=1.01)

        Parameters:
            YValV: TIntV const &
            ExpYValV: TIntV &
            BinFactor: double const &

        MakeExpBins(TIntV YValV, TIntV ExpYValV)

        Parameters:
            YValV: TIntV const &
            ExpYValV: TIntV &

        """
        return _snap.TGUtil_MakeExpBins(*args)

    MakeExpBins = staticmethod(MakeExpBins)
    def __init__(self): 
        """__init__(TGUtil self) -> TGUtil"""
        _snap.TGUtil_swiginit(self,_snap.new_TGUtil())
    __swig_destroy__ = _snap.delete_TGUtil
TGUtil_swigregister = _snap.TGUtil_swigregister
TGUtil_swigregister(TGUtil)

def TGUtil_GetCdf(*args):
  """
    GetCdf(TIntPrV const & PdfV, TIntPrV & CdfV)

    Parameters:
        PdfV: TIntPrV const &
        CdfV: TIntPrV &

    GetCdf(TFltPrV const & PdfV, TFltPrV & CdfV)

    Parameters:
        PdfV: TFltPrV const &
        CdfV: TFltPrV &

    GetCdf(TIntFltKdV const & PdfV, TIntFltKdV & CdfV)

    Parameters:
        PdfV: TIntFltKdV const &
        CdfV: TIntFltKdV &

    GetCdf(TIntPrV const & PdfV) -> TIntPrV

    Parameters:
        PdfV: TIntPrV const &

    TGUtil_GetCdf(TFltPrV const & PdfV) -> TFltPrV

    Parameters:
        PdfV: TFltPrV const &

    """
  return _snap.TGUtil_GetCdf(*args)

def TGUtil_GetCCdf(*args):
  """
    GetCCdf(TIntPrV const & PdfV, TIntPrV & CCdfV)

    Parameters:
        PdfV: TIntPrV const &
        CCdfV: TIntPrV &

    GetCCdf(TFltPrV const & PdfV, TFltPrV & CCdfV)

    Parameters:
        PdfV: TFltPrV const &
        CCdfV: TFltPrV &

    GetCCdf(TIntFltKdV const & PdfV, TIntFltKdV & CCdfV)

    Parameters:
        PdfV: TIntFltKdV const &
        CCdfV: TIntFltKdV &

    GetCCdf(TIntPrV const & PdfV) -> TIntPrV

    Parameters:
        PdfV: TIntPrV const &

    TGUtil_GetCCdf(TFltPrV const & PdfV) -> TFltPrV

    Parameters:
        PdfV: TFltPrV const &

    """
  return _snap.TGUtil_GetCCdf(*args)

def TGUtil_GetPdf(*args):
  """
    GetPdf(TIntPrV const & CdfV, TIntPrV & PdfV)

    Parameters:
        CdfV: TIntPrV const &
        PdfV: TIntPrV &

    GetPdf(TFltPrV const & CdfV, TFltPrV & PdfV)

    Parameters:
        CdfV: TFltPrV const &
        PdfV: TFltPrV &

    TGUtil_GetPdf(TIntFltKdV const & CdfV, TIntFltKdV & PdfV)

    Parameters:
        CdfV: TIntFltKdV const &
        PdfV: TIntFltKdV &

    """
  return _snap.TGUtil_GetPdf(*args)

def TGUtil_Normalize(*args):
  """
    Normalize(TFltPrV & PdfV)

    Parameters:
        PdfV: TFltPrV &

    TGUtil_Normalize(TIntFltKdV & PdfV)

    Parameters:
        PdfV: TIntFltKdV &

    """
  return _snap.TGUtil_Normalize(*args)

def TGUtil_MakeExpBins(*args):
  """
    MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)

    Parameters:
        XYValV: TFltPrV const &
        ExpXYValV: TFltPrV &
        BinFactor: double const &
        MinYVal: double const &

    MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2)

    Parameters:
        XYValV: TFltPrV const &
        ExpXYValV: TFltPrV &
        BinFactor: double const &

    MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV)

    Parameters:
        XYValV: TFltPrV const &
        ExpXYValV: TFltPrV &

    MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)

    Parameters:
        XYValV: TFltKdV const &
        ExpXYValV: TFltKdV &
        BinFactor: double const &
        MinYVal: double const &

    MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2)

    Parameters:
        XYValV: TFltKdV const &
        ExpXYValV: TFltKdV &
        BinFactor: double const &

    MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV)

    Parameters:
        XYValV: TFltKdV const &
        ExpXYValV: TFltKdV &

    MakeExpBins(TFltV const & YValV, TFltV & ExpYValV, double const & BinFactor=1.01)

    Parameters:
        YValV: TFltV const &
        ExpYValV: TFltV &
        BinFactor: double const &

    MakeExpBins(TFltV const & YValV, TFltV & ExpYValV)

    Parameters:
        YValV: TFltV const &
        ExpYValV: TFltV &

    MakeExpBins(TIntV YValV, TIntV ExpYValV, double const & BinFactor=1.01)

    Parameters:
        YValV: TIntV const &
        ExpYValV: TIntV &
        BinFactor: double const &

    TGUtil_MakeExpBins(TIntV YValV, TIntV ExpYValV)

    Parameters:
        YValV: TIntV const &
        ExpYValV: TIntV &

    """
  return _snap.TGUtil_MakeExpBins(*args)

class TStrUtil(object):
    """Proxy of C++ TStrUtil class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetXmlTagVal(*args):
        """
        GetXmlTagVal(TXmlLx & XmlLx, TChA TagNm) -> TChA

        Parameters:
            XmlLx: TXmlLx &
            TagNm: TChA const &

        """
        return _snap.TStrUtil_GetXmlTagVal(*args)

    GetXmlTagVal = staticmethod(GetXmlTagVal)
    def GetXmlTagNmVal(*args):
        """
        GetXmlTagNmVal(TXmlLx & XmlLx, TChA TagNm, TChA TagVal)

        Parameters:
            XmlLx: TXmlLx &
            TagNm: TChA &
            TagVal: TChA &

        """
        return _snap.TStrUtil_GetXmlTagNmVal(*args)

    GetXmlTagNmVal = staticmethod(GetXmlTagNmVal)
    def GetXmlTagNmVal2(*args):
        """
        GetXmlTagNmVal2(TXmlLx & XmlLx, TChA TagNm, TChA TagVal, bool const & TakeTagNms) -> bool

        Parameters:
            XmlLx: TXmlLx &
            TagNm: TChA &
            TagVal: TChA &
            TakeTagNms: bool const &

        """
        return _snap.TStrUtil_GetXmlTagNmVal2(*args)

    GetXmlTagNmVal2 = staticmethod(GetXmlTagNmVal2)
    def GetDomNm(*args):
        """
        GetDomNm(TChA UrlChA) -> TChA

        Parameters:
            UrlChA: TChA const &

        """
        return _snap.TStrUtil_GetDomNm(*args)

    GetDomNm = staticmethod(GetDomNm)
    def GetDomNm2(*args):
        """
        GetDomNm2(TChA UrlChA) -> TChA

        Parameters:
            UrlChA: TChA const &

        """
        return _snap.TStrUtil_GetDomNm2(*args)

    GetDomNm2 = staticmethod(GetDomNm2)
    def GetWebsiteNm(*args):
        """
        GetWebsiteNm(TChA UrlChA) -> TChA

        Parameters:
            UrlChA: TChA const &

        """
        return _snap.TStrUtil_GetWebsiteNm(*args)

    GetWebsiteNm = staticmethod(GetWebsiteNm)
    def GetNormalizedUrl(*args):
        """
        GetNormalizedUrl(TChA UrlIn, TChA BaseUrl, TChA UrlOut) -> bool

        Parameters:
            UrlIn: TChA const &
            BaseUrl: TChA const &
            UrlOut: TChA &

        """
        return _snap.TStrUtil_GetNormalizedUrl(*args)

    GetNormalizedUrl = staticmethod(GetNormalizedUrl)
    def StripEnd(*args):
        """
        StripEnd(TChA Str, TChA SearchStr, TChA NewStr) -> bool

        Parameters:
            Str: TChA const &
            SearchStr: TChA const &
            NewStr: TChA &

        """
        return _snap.TStrUtil_StripEnd(*args)

    StripEnd = staticmethod(StripEnd)
    def GetShorStr(*args):
        """
        GetShorStr(TChA LongStr, int const MaxLen=50) -> TChA

        Parameters:
            LongStr: TChA const &
            MaxLen: int const

        GetShorStr(TChA LongStr) -> TChA

        Parameters:
            LongStr: TChA const &

        """
        return _snap.TStrUtil_GetShorStr(*args)

    GetShorStr = staticmethod(GetShorStr)
    def GetCleanStr(*args):
        """
        GetCleanStr(TChA ChA) -> TChA

        Parameters:
            ChA: TChA const &

        """
        return _snap.TStrUtil_GetCleanStr(*args)

    GetCleanStr = staticmethod(GetCleanStr)
    def GetCleanWrdStr(*args):
        """
        GetCleanWrdStr(TChA ChA) -> TChA

        Parameters:
            ChA: TChA const &

        """
        return _snap.TStrUtil_GetCleanWrdStr(*args)

    GetCleanWrdStr = staticmethod(GetCleanWrdStr)
    def CountWords(*args):
        """
        CountWords(char const * CStr) -> int

        Parameters:
            CStr: char const *

        CountWords(TChA ChA) -> int

        Parameters:
            ChA: TChA const &

        CountWords(TChA ChA, TStrHash< TInt > const & StopWordH) -> int

        Parameters:
            ChA: TChA const &
            StopWordH: TStrHash< TInt > const &

        """
        return _snap.TStrUtil_CountWords(*args)

    CountWords = staticmethod(CountWords)
    def SplitWords(*args):
        """
        SplitWords(TChA ChA, TVec< char * > & WrdV, bool const & SplitOnWs=True) -> int

        Parameters:
            ChA: TChA &
            WrdV: TVec< char * > &
            SplitOnWs: bool const &

        SplitWords(TChA ChA, TVec< char * > & WrdV) -> int

        Parameters:
            ChA: TChA &
            WrdV: TVec< char * > &

        """
        return _snap.TStrUtil_SplitWords(*args)

    SplitWords = staticmethod(SplitWords)
    def SplitOnCh(*args):
        """
        SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch, bool const & SkipEmpty=False) -> int

        Parameters:
            ChA: TChA &
            WrdV: TVec< char * > &
            Ch: char const &
            SkipEmpty: bool const &

        SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch) -> int

        Parameters:
            ChA: TChA &
            WrdV: TVec< char * > &
            Ch: char const &

        """
        return _snap.TStrUtil_SplitOnCh(*args)

    SplitOnCh = staticmethod(SplitOnCh)
    def SplitLines(*args):
        """
        SplitLines(TChA ChA, TVec< char * > & LineV, bool const & SkipEmpty=False) -> int

        Parameters:
            ChA: TChA &
            LineV: TVec< char * > &
            SkipEmpty: bool const &

        SplitLines(TChA ChA, TVec< char * > & LineV) -> int

        Parameters:
            ChA: TChA &
            LineV: TVec< char * > &

        """
        return _snap.TStrUtil_SplitLines(*args)

    SplitLines = staticmethod(SplitLines)
    def SplitSentences(*args):
        """
        SplitSentences(TChA ChA, TVec< char * > & SentenceV) -> int

        Parameters:
            ChA: TChA &
            SentenceV: TVec< char * > &

        """
        return _snap.TStrUtil_SplitSentences(*args)

    SplitSentences = staticmethod(SplitSentences)
    def RemoveHtmlTags(*args):
        """
        RemoveHtmlTags(TChA HtmlStr, TChA TextStr)

        Parameters:
            HtmlStr: TChA const &
            TextStr: TChA &

        """
        return _snap.TStrUtil_RemoveHtmlTags(*args)

    RemoveHtmlTags = staticmethod(RemoveHtmlTags)
    def IsLatinStr(*args):
        """
        IsLatinStr(TChA Str, double const & MinAlFrac) -> bool

        Parameters:
            Str: TChA const &
            MinAlFrac: double const &

        """
        return _snap.TStrUtil_IsLatinStr(*args)

    IsLatinStr = staticmethod(IsLatinStr)
    def GetWIdV(*args):
        """
        GetWIdV(TStrHash< TInt > const & StrH, char const * CStr, TIntV WIdV)

        Parameters:
            StrH: TStrHash< TInt > const &
            CStr: char const *
            WIdV: TIntV &

        """
        return _snap.TStrUtil_GetWIdV(*args)

    GetWIdV = staticmethod(GetWIdV)
    def GetAddWIdV(*args):
        """
        GetAddWIdV(TStrHash< TInt > & StrH, char const * CStr, TIntV WIdV)

        Parameters:
            StrH: TStrHash< TInt > &
            CStr: char const *
            WIdV: TIntV &

        """
        return _snap.TStrUtil_GetAddWIdV(*args)

    GetAddWIdV = staticmethod(GetAddWIdV)
    def GetTmFromStr(*args):
        """
        GetTmFromStr(char const * TmStr, TSecTm & Tm) -> bool

        Parameters:
            TmStr: char const *
            Tm: TSecTm &

        """
        return _snap.TStrUtil_GetTmFromStr(*args)

    GetTmFromStr = staticmethod(GetTmFromStr)
    def GetStdName(*args):
        """
        GetStdName(TStr AuthorName) -> TStr

        Parameters:
            AuthorName: TStr

        """
        return _snap.TStrUtil_GetStdName(*args)

    GetStdName = staticmethod(GetStdName)
    def GetStdNameV(*args):
        """
        GetStdNameV(TStr AuthorNames, TStrV StdNameV)

        Parameters:
            AuthorNames: TStr
            StdNameV: TStrV &

        """
        return _snap.TStrUtil_GetStdNameV(*args)

    GetStdNameV = staticmethod(GetStdNameV)
    def __init__(self): 
        """__init__(TStrUtil self) -> TStrUtil"""
        _snap.TStrUtil_swiginit(self,_snap.new_TStrUtil())
    __swig_destroy__ = _snap.delete_TStrUtil
TStrUtil_swigregister = _snap.TStrUtil_swigregister
TStrUtil_swigregister(TStrUtil)

def TStrUtil_GetXmlTagVal(*args):
  """
    TStrUtil_GetXmlTagVal(TXmlLx & XmlLx, TChA TagNm) -> TChA

    Parameters:
        XmlLx: TXmlLx &
        TagNm: TChA const &

    """
  return _snap.TStrUtil_GetXmlTagVal(*args)

def TStrUtil_GetXmlTagNmVal(*args):
  """
    TStrUtil_GetXmlTagNmVal(TXmlLx & XmlLx, TChA TagNm, TChA TagVal)

    Parameters:
        XmlLx: TXmlLx &
        TagNm: TChA &
        TagVal: TChA &

    """
  return _snap.TStrUtil_GetXmlTagNmVal(*args)

def TStrUtil_GetXmlTagNmVal2(*args):
  """
    TStrUtil_GetXmlTagNmVal2(TXmlLx & XmlLx, TChA TagNm, TChA TagVal, bool const & TakeTagNms) -> bool

    Parameters:
        XmlLx: TXmlLx &
        TagNm: TChA &
        TagVal: TChA &
        TakeTagNms: bool const &

    """
  return _snap.TStrUtil_GetXmlTagNmVal2(*args)

def TStrUtil_GetDomNm(*args):
  """
    TStrUtil_GetDomNm(TChA UrlChA) -> TChA

    Parameters:
        UrlChA: TChA const &

    """
  return _snap.TStrUtil_GetDomNm(*args)

def TStrUtil_GetDomNm2(*args):
  """
    TStrUtil_GetDomNm2(TChA UrlChA) -> TChA

    Parameters:
        UrlChA: TChA const &

    """
  return _snap.TStrUtil_GetDomNm2(*args)

def TStrUtil_GetWebsiteNm(*args):
  """
    TStrUtil_GetWebsiteNm(TChA UrlChA) -> TChA

    Parameters:
        UrlChA: TChA const &

    """
  return _snap.TStrUtil_GetWebsiteNm(*args)

def TStrUtil_GetNormalizedUrl(*args):
  """
    TStrUtil_GetNormalizedUrl(TChA UrlIn, TChA BaseUrl, TChA UrlOut) -> bool

    Parameters:
        UrlIn: TChA const &
        BaseUrl: TChA const &
        UrlOut: TChA &

    """
  return _snap.TStrUtil_GetNormalizedUrl(*args)

def TStrUtil_StripEnd(*args):
  """
    TStrUtil_StripEnd(TChA Str, TChA SearchStr, TChA NewStr) -> bool

    Parameters:
        Str: TChA const &
        SearchStr: TChA const &
        NewStr: TChA &

    """
  return _snap.TStrUtil_StripEnd(*args)

def TStrUtil_GetShorStr(*args):
  """
    GetShorStr(TChA LongStr, int const MaxLen=50) -> TChA

    Parameters:
        LongStr: TChA const &
        MaxLen: int const

    TStrUtil_GetShorStr(TChA LongStr) -> TChA

    Parameters:
        LongStr: TChA const &

    """
  return _snap.TStrUtil_GetShorStr(*args)

def TStrUtil_GetCleanStr(*args):
  """
    TStrUtil_GetCleanStr(TChA ChA) -> TChA

    Parameters:
        ChA: TChA const &

    """
  return _snap.TStrUtil_GetCleanStr(*args)

def TStrUtil_GetCleanWrdStr(*args):
  """
    TStrUtil_GetCleanWrdStr(TChA ChA) -> TChA

    Parameters:
        ChA: TChA const &

    """
  return _snap.TStrUtil_GetCleanWrdStr(*args)

def TStrUtil_CountWords(*args):
  """
    CountWords(char const * CStr) -> int

    Parameters:
        CStr: char const *

    CountWords(TChA ChA) -> int

    Parameters:
        ChA: TChA const &

    TStrUtil_CountWords(TChA ChA, TStrHash< TInt > const & StopWordH) -> int

    Parameters:
        ChA: TChA const &
        StopWordH: TStrHash< TInt > const &

    """
  return _snap.TStrUtil_CountWords(*args)

def TStrUtil_SplitWords(*args):
  """
    SplitWords(TChA ChA, TVec< char * > & WrdV, bool const & SplitOnWs=True) -> int

    Parameters:
        ChA: TChA &
        WrdV: TVec< char * > &
        SplitOnWs: bool const &

    TStrUtil_SplitWords(TChA ChA, TVec< char * > & WrdV) -> int

    Parameters:
        ChA: TChA &
        WrdV: TVec< char * > &

    """
  return _snap.TStrUtil_SplitWords(*args)

def TStrUtil_SplitOnCh(*args):
  """
    SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch, bool const & SkipEmpty=False) -> int

    Parameters:
        ChA: TChA &
        WrdV: TVec< char * > &
        Ch: char const &
        SkipEmpty: bool const &

    TStrUtil_SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch) -> int

    Parameters:
        ChA: TChA &
        WrdV: TVec< char * > &
        Ch: char const &

    """
  return _snap.TStrUtil_SplitOnCh(*args)

def TStrUtil_SplitLines(*args):
  """
    SplitLines(TChA ChA, TVec< char * > & LineV, bool const & SkipEmpty=False) -> int

    Parameters:
        ChA: TChA &
        LineV: TVec< char * > &
        SkipEmpty: bool const &

    TStrUtil_SplitLines(TChA ChA, TVec< char * > & LineV) -> int

    Parameters:
        ChA: TChA &
        LineV: TVec< char * > &

    """
  return _snap.TStrUtil_SplitLines(*args)

def TStrUtil_SplitSentences(*args):
  """
    TStrUtil_SplitSentences(TChA ChA, TVec< char * > & SentenceV) -> int

    Parameters:
        ChA: TChA &
        SentenceV: TVec< char * > &

    """
  return _snap.TStrUtil_SplitSentences(*args)

def TStrUtil_RemoveHtmlTags(*args):
  """
    TStrUtil_RemoveHtmlTags(TChA HtmlStr, TChA TextStr)

    Parameters:
        HtmlStr: TChA const &
        TextStr: TChA &

    """
  return _snap.TStrUtil_RemoveHtmlTags(*args)

def TStrUtil_IsLatinStr(*args):
  """
    TStrUtil_IsLatinStr(TChA Str, double const & MinAlFrac) -> bool

    Parameters:
        Str: TChA const &
        MinAlFrac: double const &

    """
  return _snap.TStrUtil_IsLatinStr(*args)

def TStrUtil_GetWIdV(*args):
  """
    TStrUtil_GetWIdV(TStrHash< TInt > const & StrH, char const * CStr, TIntV WIdV)

    Parameters:
        StrH: TStrHash< TInt > const &
        CStr: char const *
        WIdV: TIntV &

    """
  return _snap.TStrUtil_GetWIdV(*args)

def TStrUtil_GetAddWIdV(*args):
  """
    TStrUtil_GetAddWIdV(TStrHash< TInt > & StrH, char const * CStr, TIntV WIdV)

    Parameters:
        StrH: TStrHash< TInt > &
        CStr: char const *
        WIdV: TIntV &

    """
  return _snap.TStrUtil_GetAddWIdV(*args)

def TStrUtil_GetTmFromStr(*args):
  """
    TStrUtil_GetTmFromStr(char const * TmStr, TSecTm & Tm) -> bool

    Parameters:
        TmStr: char const *
        Tm: TSecTm &

    """
  return _snap.TStrUtil_GetTmFromStr(*args)

def TStrUtil_GetStdName(*args):
  """
    TStrUtil_GetStdName(TStr AuthorName) -> TStr

    Parameters:
        AuthorName: TStr

    """
  return _snap.TStrUtil_GetStdName(*args)

def TStrUtil_GetStdNameV(*args):
  """
    TStrUtil_GetStdNameV(TStr AuthorNames, TStrV StdNameV)

    Parameters:
        AuthorNames: TStr
        StdNameV: TStrV &

    """
  return _snap.TStrUtil_GetStdNameV(*args)

class TRnd(object):
    """Proxy of C++ TRnd class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TRnd self, int const & _Seed=1, int const & Steps=0) -> TRnd

        Parameters:
            _Seed: int const &
            Steps: int const &

        __init__(TRnd self, int const & _Seed=1) -> TRnd

        Parameters:
            _Seed: int const &

        __init__(TRnd self) -> TRnd
        __init__(TRnd self, TSIn SIn) -> TRnd

        Parameters:
            SIn: TSIn &

        """
        _snap.TRnd_swiginit(self,_snap.new_TRnd(*args))
    def Save(self, *args):
        """
        Save(TRnd self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TRnd_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TRnd self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TRnd_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TRnd self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TRnd_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TRnd self, TRnd arg2) -> bool

        Parameters:
            arg2: TRnd const &

        """
        return _snap.TRnd___eq__(self, *args)

    def GetUniDev(self):
        """
        GetUniDev(TRnd self) -> double

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_GetUniDev(self)

    def GetUniDevInt(self, *args):
        """
        GetUniDevInt(TRnd self, int const & Range=0) -> int

        Parameters:
            Range: int const &

        GetUniDevInt(TRnd self) -> int
        GetUniDevInt(TRnd self, int const & MnVal, int const & MxVal) -> int

        Parameters:
            MnVal: int const &
            MxVal: int const &

        """
        return _snap.TRnd_GetUniDevInt(self, *args)

    def GetUniDevUInt(self, Range=0):
        """
        GetUniDevUInt(TRnd self, uint const & Range=0) -> uint

        Parameters:
            Range: uint const &

        GetUniDevUInt(TRnd self) -> uint

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_GetUniDevUInt(self, Range)

    def GetUniDevInt64(self, Range=0):
        """
        GetUniDevInt64(TRnd self, int64 const & Range=0) -> int64

        Parameters:
            Range: int64 const &

        GetUniDevInt64(TRnd self) -> int64

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_GetUniDevInt64(self, Range)

    def GetUniDevUInt64(self, Range=0):
        """
        GetUniDevUInt64(TRnd self, uint64 const & Range=0) -> uint64

        Parameters:
            Range: uint64 const &

        GetUniDevUInt64(TRnd self) -> uint64

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_GetUniDevUInt64(self, Range)

    def GetNrmDev(self, *args):
        """
        GetNrmDev(TRnd self) -> double
        GetNrmDev(TRnd self, double const & Mean, double const & SDev, double const & Mn, double const & Mx) -> double

        Parameters:
            Mean: double const &
            SDev: double const &
            Mn: double const &
            Mx: double const &

        """
        return _snap.TRnd_GetNrmDev(self, *args)

    def GetExpDev(self, *args):
        """
        GetExpDev(TRnd self) -> double
        GetExpDev(TRnd self, double const & Lambda) -> double

        Parameters:
            Lambda: double const &

        """
        return _snap.TRnd_GetExpDev(self, *args)

    def GetGammaDev(self, *args):
        """
        GetGammaDev(TRnd self, int const & Order) -> double

        Parameters:
            Order: int const &

        """
        return _snap.TRnd_GetGammaDev(self, *args)

    def GetPoissonDev(self, *args):
        """
        GetPoissonDev(TRnd self, double const & Mean) -> double

        Parameters:
            Mean: double const &

        """
        return _snap.TRnd_GetPoissonDev(self, *args)

    def GetBinomialDev(self, *args):
        """
        GetBinomialDev(TRnd self, double const & Prb, int const & Trials) -> double

        Parameters:
            Prb: double const &
            Trials: int const &

        """
        return _snap.TRnd_GetBinomialDev(self, *args)

    def GetGeoDev(self, *args):
        """
        GetGeoDev(TRnd self, double const & Prb) -> int

        Parameters:
            Prb: double const &

        """
        return _snap.TRnd_GetGeoDev(self, *args)

    def GetPowerDev(self, *args):
        """
        GetPowerDev(TRnd self, double const & AlphaSlope) -> double

        Parameters:
            AlphaSlope: double const &

        """
        return _snap.TRnd_GetPowerDev(self, *args)

    def GetRayleigh(self, *args):
        """
        GetRayleigh(TRnd self, double const & Sigma) -> double

        Parameters:
            Sigma: double const &

        """
        return _snap.TRnd_GetRayleigh(self, *args)

    def GetWeibull(self, *args):
        """
        GetWeibull(TRnd self, double const & K, double const & Lambda) -> double

        Parameters:
            K: double const &
            Lambda: double const &

        """
        return _snap.TRnd_GetWeibull(self, *args)

    def PutSeed(self, *args):
        """
        PutSeed(TRnd self, int const & _Seed)

        Parameters:
            _Seed: int const &

        """
        return _snap.TRnd_PutSeed(self, *args)

    def GetSeed(self):
        """
        GetSeed(TRnd self) -> int

        Parameters:
            self: TRnd const *

        """
        return _snap.TRnd_GetSeed(self)

    def Randomize(self):
        """
        Randomize(TRnd self)

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_Randomize(self)

    def Move(self, *args):
        """
        Move(TRnd self, int const & Steps)

        Parameters:
            Steps: int const &

        """
        return _snap.TRnd_Move(self, *args)

    def Check(self):
        """
        Check(TRnd self) -> bool

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_Check(self)

    def GetUniDevStep(*args):
        """
        GetUniDevStep(int const & Seed, int const & Steps) -> double

        Parameters:
            Seed: int const &
            Steps: int const &

        """
        return _snap.TRnd_GetUniDevStep(*args)

    GetUniDevStep = staticmethod(GetUniDevStep)
    def GetNrmDevStep(*args):
        """
        GetNrmDevStep(int const & Seed, int const & Steps) -> double

        Parameters:
            Seed: int const &
            Steps: int const &

        """
        return _snap.TRnd_GetNrmDevStep(*args)

    GetNrmDevStep = staticmethod(GetNrmDevStep)
    def GetExpDevStep(*args):
        """
        GetExpDevStep(int const & Seed, int const & Steps) -> double

        Parameters:
            Seed: int const &
            Steps: int const &

        """
        return _snap.TRnd_GetExpDevStep(*args)

    GetExpDevStep = staticmethod(GetExpDevStep)
    def LoadTxt(*args):
        """
        LoadTxt(TILx & Lx) -> TRnd

        Parameters:
            Lx: TILx &

        """
        return _snap.TRnd_LoadTxt(*args)

    LoadTxt = staticmethod(LoadTxt)
    def SaveTxt(self, *args):
        """
        SaveTxt(TRnd self, TOLx & Lx)

        Parameters:
            Lx: TOLx &

        """
        return _snap.TRnd_SaveTxt(self, *args)

    __swig_destroy__ = _snap.delete_TRnd
TRnd.Save = new_instancemethod(_snap.TRnd_Save,None,TRnd)
TRnd.LoadXml = new_instancemethod(_snap.TRnd_LoadXml,None,TRnd)
TRnd.SaveXml = new_instancemethod(_snap.TRnd_SaveXml,None,TRnd)
TRnd.__eq__ = new_instancemethod(_snap.TRnd___eq__,None,TRnd)
TRnd.GetUniDev = new_instancemethod(_snap.TRnd_GetUniDev,None,TRnd)
TRnd.GetUniDevInt = new_instancemethod(_snap.TRnd_GetUniDevInt,None,TRnd)
TRnd.GetUniDevUInt = new_instancemethod(_snap.TRnd_GetUniDevUInt,None,TRnd)
TRnd.GetUniDevInt64 = new_instancemethod(_snap.TRnd_GetUniDevInt64,None,TRnd)
TRnd.GetUniDevUInt64 = new_instancemethod(_snap.TRnd_GetUniDevUInt64,None,TRnd)
TRnd.GetNrmDev = new_instancemethod(_snap.TRnd_GetNrmDev,None,TRnd)
TRnd.GetExpDev = new_instancemethod(_snap.TRnd_GetExpDev,None,TRnd)
TRnd.GetGammaDev = new_instancemethod(_snap.TRnd_GetGammaDev,None,TRnd)
TRnd.GetPoissonDev = new_instancemethod(_snap.TRnd_GetPoissonDev,None,TRnd)
TRnd.GetBinomialDev = new_instancemethod(_snap.TRnd_GetBinomialDev,None,TRnd)
TRnd.GetGeoDev = new_instancemethod(_snap.TRnd_GetGeoDev,None,TRnd)
TRnd.GetPowerDev = new_instancemethod(_snap.TRnd_GetPowerDev,None,TRnd)
TRnd.GetRayleigh = new_instancemethod(_snap.TRnd_GetRayleigh,None,TRnd)
TRnd.GetWeibull = new_instancemethod(_snap.TRnd_GetWeibull,None,TRnd)
TRnd.PutSeed = new_instancemethod(_snap.TRnd_PutSeed,None,TRnd)
TRnd.GetSeed = new_instancemethod(_snap.TRnd_GetSeed,None,TRnd)
TRnd.Randomize = new_instancemethod(_snap.TRnd_Randomize,None,TRnd)
TRnd.Move = new_instancemethod(_snap.TRnd_Move,None,TRnd)
TRnd.Check = new_instancemethod(_snap.TRnd_Check,None,TRnd)
TRnd.SaveTxt = new_instancemethod(_snap.TRnd_SaveTxt,None,TRnd)
TRnd_swigregister = _snap.TRnd_swigregister
TRnd_swigregister(TRnd)
TRnd.RndSeed = _snap.cvar.TRnd_RndSeed

def TRnd_GetUniDevStep(*args):
  """
    TRnd_GetUniDevStep(int const & Seed, int const & Steps) -> double

    Parameters:
        Seed: int const &
        Steps: int const &

    """
  return _snap.TRnd_GetUniDevStep(*args)

def TRnd_GetNrmDevStep(*args):
  """
    TRnd_GetNrmDevStep(int const & Seed, int const & Steps) -> double

    Parameters:
        Seed: int const &
        Steps: int const &

    """
  return _snap.TRnd_GetNrmDevStep(*args)

def TRnd_GetExpDevStep(*args):
  """
    TRnd_GetExpDevStep(int const & Seed, int const & Steps) -> double

    Parameters:
        Seed: int const &
        Steps: int const &

    """
  return _snap.TRnd_GetExpDevStep(*args)

def TRnd_LoadTxt(*args):
  """
    TRnd_LoadTxt(TILx & Lx) -> TRnd

    Parameters:
        Lx: TILx &

    """
  return _snap.TRnd_LoadTxt(*args)

class TMem(object):
    """Proxy of C++ TMem class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def New(*args):
        """
        New(int const & MxBfL=0) -> PMem

        Parameters:
            MxBfL: int const &

        New() -> PMem
        New(void const * Bf, int const & BfL) -> PMem

        Parameters:
            Bf: void const *
            BfL: int const &

        New(TMem Mem) -> PMem

        Parameters:
            Mem: TMem const &

        New(PMem const & Mem) -> PMem

        Parameters:
            Mem: PMem const &

        New(TStr Str) -> PMem

        Parameters:
            Str: TStr const &

        """
        return _snap.TMem_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TMem
    def __init__(self, *args): 
        """
        __init__(TMem self, int const & _MxBfL=0) -> TMem

        Parameters:
            _MxBfL: int const &

        __init__(TMem self) -> TMem
        __init__(TMem self, void const * _Bf, int const & _BfL) -> TMem

        Parameters:
            _Bf: void const *
            _BfL: int const &

        __init__(TMem self, TMem Mem) -> TMem

        Parameters:
            Mem: TMem const &

        __init__(TMem self, TStr Str) -> TMem

        Parameters:
            Str: TStr const &

        __init__(TMem self, TSIn SIn) -> TMem

        Parameters:
            SIn: TSIn &

        """
        _snap.TMem_swiginit(self,_snap.new_TMem(*args))
    def Save(self, *args):
        """
        Save(TMem self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TMem_Save(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TMem self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TMem_SaveXml(self, *args)

    def __call__(self):
        """
        __call__(TMem self) -> char *

        Parameters:
            self: TMem const *

        """
        return _snap.TMem___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TMem self, char const & Ch) -> TMem

        Parameters:
            Ch: char const &

        __iadd__(TMem self, TMem Mem) -> TMem

        Parameters:
            Mem: TMem const &

        __iadd__(TMem self, TStr Str) -> TMem

        Parameters:
            Str: TStr const &

        __iadd__(TMem self, PSIn const & SIn) -> TMem

        Parameters:
            SIn: PSIn const &

        """
        return _snap.TMem___iadd__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TMem self) -> int

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_GetMemUsed(self)

    def Gen(self, *args):
        """
        Gen(TMem self, int const & _BfL)

        Parameters:
            _BfL: int const &

        """
        return _snap.TMem_Gen(self, *args)

    def GenZeros(self, *args):
        """
        GenZeros(TMem self, int const & _BfL)

        Parameters:
            _BfL: int const &

        """
        return _snap.TMem_GenZeros(self, *args)

    def Reserve(self, *args):
        """
        Reserve(TMem self, int const & _MxBfL, bool const & DoClr=True)

        Parameters:
            _MxBfL: int const &
            DoClr: bool const &

        Reserve(TMem self, int const & _MxBfL)

        Parameters:
            _MxBfL: int const &

        """
        return _snap.TMem_Reserve(self, *args)

    def Del(self, *args):
        """
        Del(TMem self, int const & BChN, int const & EChN)

        Parameters:
            BChN: int const &
            EChN: int const &

        """
        return _snap.TMem_Del(self, *args)

    def Clr(self, DoDel=True):
        """
        Clr(TMem self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TMem self)

        Parameters:
            self: TMem *

        """
        return _snap.TMem_Clr(self, DoDel)

    def Len(self):
        """
        Len(TMem self) -> int

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_Len(self)

    def Empty(self):
        """
        Empty(TMem self) -> bool

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_Empty(self)

    def Trunc(self, *args):
        """
        Trunc(TMem self, int const & _BfL)

        Parameters:
            _BfL: int const &

        """
        return _snap.TMem_Trunc(self, *args)

    def Push(self, *args):
        """
        Push(TMem self, char const & Ch)

        Parameters:
            Ch: char const &

        """
        return _snap.TMem_Push(self, *args)

    def Pop(self):
        """
        Pop(TMem self) -> char

        Parameters:
            self: TMem *

        """
        return _snap.TMem_Pop(self)

    def DoFitStr(self, *args):
        """
        DoFitStr(TMem self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TMem_DoFitStr(self, *args)

    def AddBf(self, *args):
        """
        AddBf(TMem self, void const * Bf, int const & BfL)

        Parameters:
            Bf: void const *
            BfL: int const &

        """
        return _snap.TMem_AddBf(self, *args)

    def GetBf(self):
        """
        GetBf(TMem self) -> char *

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_GetBf(self)

    def GetAsStr(self, NewNullCh='\0'):
        """
        GetAsStr(TMem self, char const & NewNullCh='\0') -> TStr

        Parameters:
            NewNullCh: char const &

        GetAsStr(TMem self) -> TStr

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_GetAsStr(self, NewNullCh)

    def GetSIn(self):
        """
        GetSIn(TMem self) -> PSIn

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_GetSIn(self)

    def LoadMem(*args):
        """
        LoadMem(PSIn const & SIn, TMem Mem)

        Parameters:
            SIn: PSIn const &
            Mem: TMem &

        LoadMem(PSIn const & SIn, PMem const & Mem)

        Parameters:
            SIn: PSIn const &
            Mem: PMem const &

        """
        return _snap.TMem_LoadMem(*args)

    LoadMem = staticmethod(LoadMem)
    def SaveMem(self, *args):
        """
        SaveMem(TMem self, PSOut const & SOut)

        Parameters:
            SOut: PSOut const &

        """
        return _snap.TMem_SaveMem(self, *args)

TMem.Save = new_instancemethod(_snap.TMem_Save,None,TMem)
TMem.SaveXml = new_instancemethod(_snap.TMem_SaveXml,None,TMem)
TMem.__call__ = new_instancemethod(_snap.TMem___call__,None,TMem)
TMem.__iadd__ = new_instancemethod(_snap.TMem___iadd__,None,TMem)
TMem.GetMemUsed = new_instancemethod(_snap.TMem_GetMemUsed,None,TMem)
TMem.Gen = new_instancemethod(_snap.TMem_Gen,None,TMem)
TMem.GenZeros = new_instancemethod(_snap.TMem_GenZeros,None,TMem)
TMem.Reserve = new_instancemethod(_snap.TMem_Reserve,None,TMem)
TMem.Del = new_instancemethod(_snap.TMem_Del,None,TMem)
TMem.Clr = new_instancemethod(_snap.TMem_Clr,None,TMem)
TMem.Len = new_instancemethod(_snap.TMem_Len,None,TMem)
TMem.Empty = new_instancemethod(_snap.TMem_Empty,None,TMem)
TMem.Trunc = new_instancemethod(_snap.TMem_Trunc,None,TMem)
TMem.Push = new_instancemethod(_snap.TMem_Push,None,TMem)
TMem.Pop = new_instancemethod(_snap.TMem_Pop,None,TMem)
TMem.DoFitStr = new_instancemethod(_snap.TMem_DoFitStr,None,TMem)
TMem.AddBf = new_instancemethod(_snap.TMem_AddBf,None,TMem)
TMem.GetBf = new_instancemethod(_snap.TMem_GetBf,None,TMem)
TMem.GetAsStr = new_instancemethod(_snap.TMem_GetAsStr,None,TMem)
TMem.GetSIn = new_instancemethod(_snap.TMem_GetSIn,None,TMem)
TMem.SaveMem = new_instancemethod(_snap.TMem_SaveMem,None,TMem)
TMem_swigregister = _snap.TMem_swigregister
TMem_swigregister(TMem)

def TMem_New(*args):
  """
    New(int const & MxBfL=0) -> PMem

    Parameters:
        MxBfL: int const &

    New() -> PMem
    New(void const * Bf, int const & BfL) -> PMem

    Parameters:
        Bf: void const *
        BfL: int const &

    New(TMem Mem) -> PMem

    Parameters:
        Mem: TMem const &

    New(PMem const & Mem) -> PMem

    Parameters:
        Mem: PMem const &

    TMem_New(TStr Str) -> PMem

    Parameters:
        Str: TStr const &

    """
  return _snap.TMem_New(*args)

def TMem_LoadMem(*args):
  """
    LoadMem(PSIn const & SIn, TMem Mem)

    Parameters:
        SIn: PSIn const &
        Mem: TMem &

    TMem_LoadMem(PSIn const & SIn, PMem const & Mem)

    Parameters:
        SIn: PSIn const &
        Mem: PMem const &

    """
  return _snap.TMem_LoadMem(*args)

class TMemIn(TSIn):
    """Proxy of C++ TMemIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TMemIn self, TMem _Mem, int const & _BfC=0) -> TMemIn

        Parameters:
            _Mem: TMem const &
            _BfC: int const &

        __init__(TMemIn self, TMem _Mem) -> TMemIn

        Parameters:
            _Mem: TMem const &

        """
        _snap.TMemIn_swiginit(self,_snap.new_TMemIn(*args))
    def New(*args):
        """
        New(TMem Mem) -> PSIn

        Parameters:
            Mem: TMem const &

        New(PMem const & Mem) -> PSIn

        Parameters:
            Mem: PMem const &

        """
        return _snap.TMemIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TMemIn
TMemIn_swigregister = _snap.TMemIn_swigregister
TMemIn_swigregister(TMemIn)

def TMemIn_New(*args):
  """
    New(TMem Mem) -> PSIn

    Parameters:
        Mem: TMem const &

    TMemIn_New(PMem const & Mem) -> PSIn

    Parameters:
        Mem: PMem const &

    """
  return _snap.TMemIn_New(*args)

class TMemOut(TSOut):
    """Proxy of C++ TMemOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TMemOut self, PMem const & _Mem) -> TMemOut

        Parameters:
            _Mem: PMem const &

        """
        _snap.TMemOut_swiginit(self,_snap.new_TMemOut(*args))
    def New(*args):
        """
        New(PMem const & Mem) -> PSOut

        Parameters:
            Mem: PMem const &

        """
        return _snap.TMemOut_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TMemOut
TMemOut_swigregister = _snap.TMemOut_swigregister
TMemOut_swigregister(TMemOut)

def TMemOut_New(*args):
  """
    TMemOut_New(PMem const & Mem) -> PSOut

    Parameters:
        Mem: PMem const &

    """
  return _snap.TMemOut_New(*args)

class TChA(object):
    """Proxy of C++ TChA class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TChA
    def __init__(self, *args): 
        """
        __init__(TChA self, int const & _MxBfL=256) -> TChA

        Parameters:
            _MxBfL: int const &

        __init__(TChA self) -> TChA
        __init__(TChA self, char const * CStr) -> TChA

        Parameters:
            CStr: char const *

        __init__(TChA self, char const * CStr, int const & StrLen) -> TChA

        Parameters:
            CStr: char const *
            StrLen: int const &

        __init__(TChA self, TChA ChA) -> TChA

        Parameters:
            ChA: TChA const &

        __init__(TChA self, TStr Str) -> TChA

        Parameters:
            Str: TStr const &

        __init__(TChA self, TMem Mem) -> TChA

        Parameters:
            Mem: TMem const &

        __init__(TChA self, TSIn SIn) -> TChA

        Parameters:
            SIn: TSIn &

        """
        _snap.TChA_swiginit(self,_snap.new_TChA(*args))
    def Load(self, *args):
        """
        Load(TChA self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TChA_Load(self, *args)

    def Save(self, *args):
        """
        Save(TChA self, TSOut SOut, bool const & SaveCompact=True)

        Parameters:
            SOut: TSOut &
            SaveCompact: bool const &

        Save(TChA self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TChA_Save(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TChA self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TChA_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TChA self, TChA ChA) -> bool

        Parameters:
            ChA: TChA const &

        __eq__(TChA self, char const * _CStr) -> bool

        Parameters:
            _CStr: char const *

        __eq__(TChA self, char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TChA___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TChA self, TChA ChA) -> bool

        Parameters:
            ChA: TChA const &

        __ne__(TChA self, char const * _CStr) -> bool

        Parameters:
            _CStr: char const *

        __ne__(TChA self, char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TChA___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TChA self, TChA ChA) -> bool

        Parameters:
            ChA: TChA const &

        """
        return _snap.TChA___lt__(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(TChA self, TMem Mem) -> TChA

        Parameters:
            Mem: TMem const &

        __iadd__(TChA self, TChA ChA) -> TChA

        Parameters:
            ChA: TChA const &

        __iadd__(TChA self, TStr Str) -> TChA

        Parameters:
            Str: TStr const &

        __iadd__(TChA self, char const * CStr) -> TChA

        Parameters:
            CStr: char const *

        __iadd__(TChA self, char const & Ch) -> TChA

        Parameters:
            Ch: char const &

        """
        return _snap.TChA___iadd__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TChA self) -> int

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_GetMemUsed(self)

    def __call__(self, *args):
        """
        __call__(TChA self) -> char
        __call__(TChA self) -> char const *

        Parameters:
            self: TChA const *

        """
        return _snap.TChA___call__(self, *args)

    def CStr(self, *args):
        """
        CStr(TChA self) -> char
        CStr(TChA self) -> char const *

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_CStr(self, *args)

    def Clr(self):
        """
        Clr(TChA self)

        Parameters:
            self: TChA *

        """
        return _snap.TChA_Clr(self)

    def Len(self):
        """
        Len(TChA self) -> int

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_Len(self)

    def Empty(self):
        """
        Empty(TChA self) -> bool

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_Empty(self)

    def Ins(self, *args):
        """
        Ins(TChA self, int const & BChN, char const * CStr)

        Parameters:
            BChN: int const &
            CStr: char const *

        """
        return _snap.TChA_Ins(self, *args)

    def Del(self, *args):
        """
        Del(TChA self, int const & ChN)

        Parameters:
            ChN: int const &

        """
        return _snap.TChA_Del(self, *args)

    def DelLastCh(self):
        """
        DelLastCh(TChA self)

        Parameters:
            self: TChA *

        """
        return _snap.TChA_DelLastCh(self)

    def Push(self, *args):
        """
        Push(TChA self, char const & Ch)

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_Push(self, *args)

    def Pop(self):
        """
        Pop(TChA self) -> char

        Parameters:
            self: TChA *

        """
        return _snap.TChA_Pop(self)

    def Trunc(self, *args):
        """
        Trunc(TChA self)
        Trunc(TChA self, int const & _BfL)

        Parameters:
            _BfL: int const &

        """
        return _snap.TChA_Trunc(self, *args)

    def Reverse(self):
        """
        Reverse(TChA self)

        Parameters:
            self: TChA *

        """
        return _snap.TChA_Reverse(self)

    def AddCh(self, *args):
        """
        AddCh(TChA self, char const & Ch, int const & MxLen=-1)

        Parameters:
            Ch: char const &
            MxLen: int const &

        AddCh(TChA self, char const & Ch)

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_AddCh(self, *args)

    def AddChTo(self, *args):
        """
        AddChTo(TChA self, char const & Ch, int const & ToChN)

        Parameters:
            Ch: char const &
            ToChN: int const &

        """
        return _snap.TChA_AddChTo(self, *args)

    def AddBf(self, *args):
        """
        AddBf(TChA self, char * NewBf, int const & BfS)

        Parameters:
            NewBf: char *
            BfS: int const &

        """
        return _snap.TChA_AddBf(self, *args)

    def PutCh(self, *args):
        """
        PutCh(TChA self, int const & ChN, char const & Ch)

        Parameters:
            ChN: int const &
            Ch: char const &

        """
        return _snap.TChA_PutCh(self, *args)

    def GetCh(self, *args):
        """
        GetCh(TChA self, int const & ChN) -> char

        Parameters:
            ChN: int const &

        """
        return _snap.TChA_GetCh(self, *args)

    def LastCh(self):
        """
        LastCh(TChA self) -> char

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_LastCh(self)

    def LastLastCh(self):
        """
        LastLastCh(TChA self) -> char

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_LastLastCh(self)

    def GetSubStr(self, *args):
        """
        GetSubStr(TChA self, int const & BChN, int const & EChN) -> TChA

        Parameters:
            BChN: int const &
            EChN: int const &

        """
        return _snap.TChA_GetSubStr(self, *args)

    def CountCh(self, *args):
        """
        CountCh(TChA self, char const & Ch, int const & BChN=0) -> int

        Parameters:
            Ch: char const &
            BChN: int const &

        CountCh(TChA self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_CountCh(self, *args)

    def SearchCh(self, *args):
        """
        SearchCh(TChA self, char const & Ch, int const & BChN=0) -> int

        Parameters:
            Ch: char const &
            BChN: int const &

        SearchCh(TChA self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_SearchCh(self, *args)

    def SearchChBack(self, *args):
        """
        SearchChBack(TChA self, char const & Ch, int BChN=-1) -> int

        Parameters:
            Ch: char const &
            BChN: int

        SearchChBack(TChA self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_SearchChBack(self, *args)

    def SearchStr(self, *args):
        """
        SearchStr(TChA self, TChA Str, int const & BChN=0) -> int

        Parameters:
            Str: TChA const &
            BChN: int const &

        SearchStr(TChA self, TChA Str) -> int

        Parameters:
            Str: TChA const &

        SearchStr(TChA self, TStr Str, int const & BChN=0) -> int

        Parameters:
            Str: TStr const &
            BChN: int const &

        SearchStr(TChA self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        SearchStr(TChA self, char const * CStr, int const & BChN=0) -> int

        Parameters:
            CStr: char const *
            BChN: int const &

        SearchStr(TChA self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        """
        return _snap.TChA_SearchStr(self, *args)

    def IsStrIn(self, *args):
        """
        IsStrIn(TChA self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TChA_IsStrIn(self, *args)

    def IsPrefix(self, *args):
        """
        IsPrefix(TChA self, char const * CStr, int const & BChN=0) -> bool

        Parameters:
            CStr: char const *
            BChN: int const &

        IsPrefix(TChA self, char const * CStr) -> bool

        Parameters:
            CStr: char const *

        IsPrefix(TChA self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        IsPrefix(TChA self, TChA Str) -> bool

        Parameters:
            Str: TChA const &

        """
        return _snap.TChA_IsPrefix(self, *args)

    def IsSuffix(self, *args):
        """
        IsSuffix(TChA self, char const * CStr) -> bool

        Parameters:
            CStr: char const *

        IsSuffix(TChA self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        IsSuffix(TChA self, TChA Str) -> bool

        Parameters:
            Str: TChA const &

        """
        return _snap.TChA_IsSuffix(self, *args)

    def IsChIn(self, *args):
        """
        IsChIn(TChA self, char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_IsChIn(self, *args)

    def ChangeCh(self, *args):
        """
        ChangeCh(TChA self, char const & SrcCh, char const & DstCh)

        Parameters:
            SrcCh: char const &
            DstCh: char const &

        """
        return _snap.TChA_ChangeCh(self, *args)

    def ToUc(self):
        """
        ToUc(TChA self) -> TChA

        Parameters:
            self: TChA *

        """
        return _snap.TChA_ToUc(self)

    def ToLc(self):
        """
        ToLc(TChA self) -> TChA

        Parameters:
            self: TChA *

        """
        return _snap.TChA_ToLc(self)

    def ToTrunc(self):
        """
        ToTrunc(TChA self) -> TChA

        Parameters:
            self: TChA *

        """
        return _snap.TChA_ToTrunc(self)

    def CompressWs(self):
        """
        CompressWs(TChA self)

        Parameters:
            self: TChA *

        """
        return _snap.TChA_CompressWs(self)

    def Swap(self, *args):
        """
        Swap(TChA self, int const & ChN1, int const & ChN2)

        Parameters:
            ChN1: int const &
            ChN2: int const &

        Swap(TChA self, TChA ChA)

        Parameters:
            ChA: TChA &

        """
        return _snap.TChA_Swap(self, *args)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TChA self) -> int

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TChA self) -> int

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_GetSecHashCd(self)

    def LoadTxt(*args):
        """
        LoadTxt(PSIn const & SIn, TChA ChA)

        Parameters:
            SIn: PSIn const &
            ChA: TChA &

        """
        return _snap.TChA_LoadTxt(*args)

    LoadTxt = staticmethod(LoadTxt)
    def SaveTxt(self, *args):
        """
        SaveTxt(TChA self, PSOut const & SOut)

        Parameters:
            SOut: PSOut const &

        """
        return _snap.TChA_SaveTxt(self, *args)

TChA.Load = new_instancemethod(_snap.TChA_Load,None,TChA)
TChA.Save = new_instancemethod(_snap.TChA_Save,None,TChA)
TChA.SaveXml = new_instancemethod(_snap.TChA_SaveXml,None,TChA)
TChA.__eq__ = new_instancemethod(_snap.TChA___eq__,None,TChA)
TChA.__ne__ = new_instancemethod(_snap.TChA___ne__,None,TChA)
TChA.__lt__ = new_instancemethod(_snap.TChA___lt__,None,TChA)
TChA.__iadd__ = new_instancemethod(_snap.TChA___iadd__,None,TChA)
TChA.GetMemUsed = new_instancemethod(_snap.TChA_GetMemUsed,None,TChA)
TChA.__call__ = new_instancemethod(_snap.TChA___call__,None,TChA)
TChA.CStr = new_instancemethod(_snap.TChA_CStr,None,TChA)
TChA.Clr = new_instancemethod(_snap.TChA_Clr,None,TChA)
TChA.Len = new_instancemethod(_snap.TChA_Len,None,TChA)
TChA.Empty = new_instancemethod(_snap.TChA_Empty,None,TChA)
TChA.Ins = new_instancemethod(_snap.TChA_Ins,None,TChA)
TChA.Del = new_instancemethod(_snap.TChA_Del,None,TChA)
TChA.DelLastCh = new_instancemethod(_snap.TChA_DelLastCh,None,TChA)
TChA.Push = new_instancemethod(_snap.TChA_Push,None,TChA)
TChA.Pop = new_instancemethod(_snap.TChA_Pop,None,TChA)
TChA.Trunc = new_instancemethod(_snap.TChA_Trunc,None,TChA)
TChA.Reverse = new_instancemethod(_snap.TChA_Reverse,None,TChA)
TChA.AddCh = new_instancemethod(_snap.TChA_AddCh,None,TChA)
TChA.AddChTo = new_instancemethod(_snap.TChA_AddChTo,None,TChA)
TChA.AddBf = new_instancemethod(_snap.TChA_AddBf,None,TChA)
TChA.PutCh = new_instancemethod(_snap.TChA_PutCh,None,TChA)
TChA.GetCh = new_instancemethod(_snap.TChA_GetCh,None,TChA)
TChA.LastCh = new_instancemethod(_snap.TChA_LastCh,None,TChA)
TChA.LastLastCh = new_instancemethod(_snap.TChA_LastLastCh,None,TChA)
TChA.GetSubStr = new_instancemethod(_snap.TChA_GetSubStr,None,TChA)
TChA.CountCh = new_instancemethod(_snap.TChA_CountCh,None,TChA)
TChA.SearchCh = new_instancemethod(_snap.TChA_SearchCh,None,TChA)
TChA.SearchChBack = new_instancemethod(_snap.TChA_SearchChBack,None,TChA)
TChA.SearchStr = new_instancemethod(_snap.TChA_SearchStr,None,TChA)
TChA.IsStrIn = new_instancemethod(_snap.TChA_IsStrIn,None,TChA)
TChA.IsPrefix = new_instancemethod(_snap.TChA_IsPrefix,None,TChA)
TChA.IsSuffix = new_instancemethod(_snap.TChA_IsSuffix,None,TChA)
TChA.IsChIn = new_instancemethod(_snap.TChA_IsChIn,None,TChA)
TChA.ChangeCh = new_instancemethod(_snap.TChA_ChangeCh,None,TChA)
TChA.ToUc = new_instancemethod(_snap.TChA_ToUc,None,TChA)
TChA.ToLc = new_instancemethod(_snap.TChA_ToLc,None,TChA)
TChA.ToTrunc = new_instancemethod(_snap.TChA_ToTrunc,None,TChA)
TChA.CompressWs = new_instancemethod(_snap.TChA_CompressWs,None,TChA)
TChA.Swap = new_instancemethod(_snap.TChA_Swap,None,TChA)
TChA.GetPrimHashCd = new_instancemethod(_snap.TChA_GetPrimHashCd,None,TChA)
TChA.GetSecHashCd = new_instancemethod(_snap.TChA_GetSecHashCd,None,TChA)
TChA.SaveTxt = new_instancemethod(_snap.TChA_SaveTxt,None,TChA)
TChA_swigregister = _snap.TChA_swigregister
TChA_swigregister(TChA)

def TChA_LoadTxt(*args):
  """
    TChA_LoadTxt(PSIn const & SIn, TChA ChA)

    Parameters:
        SIn: PSIn const &
        ChA: TChA &

    """
  return _snap.TChA_LoadTxt(*args)

class TChAIn(TSIn):
    """Proxy of C++ TChAIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TChAIn self, TChA ChA, int const & _BfC=0) -> TChAIn

        Parameters:
            ChA: TChA const &
            _BfC: int const &

        __init__(TChAIn self, TChA ChA) -> TChAIn

        Parameters:
            ChA: TChA const &

        """
        _snap.TChAIn_swiginit(self,_snap.new_TChAIn(*args))
    def New(*args):
        """
        New(TChA ChA) -> PSIn

        Parameters:
            ChA: TChA const &

        """
        return _snap.TChAIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TChAIn
TChAIn_swigregister = _snap.TChAIn_swigregister
TChAIn_swigregister(TChAIn)

def TChAIn_New(*args):
  """
    TChAIn_New(TChA ChA) -> PSIn

    Parameters:
        ChA: TChA const &

    """
  return _snap.TChAIn_New(*args)

class TRStr(object):
    """Proxy of C++ TRStr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Bf = _swig_property(_snap.TRStr_Bf_get, _snap.TRStr_Bf_set)
    Refs = _swig_property(_snap.TRStr_Refs_get, _snap.TRStr_Refs_set)
    __swig_destroy__ = _snap.delete_TRStr
    def __init__(self, *args): 
        """
        __init__(TRStr self) -> TRStr
        __init__(TRStr self, int const & Len) -> TRStr

        Parameters:
            Len: int const &

        __init__(TRStr self, char const * CStr) -> TRStr

        Parameters:
            CStr: char const *

        __init__(TRStr self, char const * CStr, int const & MxLen) -> TRStr

        Parameters:
            CStr: char const *
            MxLen: int const &

        __init__(TRStr self, char const * CStr1, char const * CStr2) -> TRStr

        Parameters:
            CStr1: char const *
            CStr2: char const *

        __init__(TRStr self, char const & Ch) -> TRStr

        Parameters:
            Ch: char const &

        __init__(TRStr self, char const & Ch1, char const & Ch2) -> TRStr

        Parameters:
            Ch1: char const &
            Ch2: char const &

        __init__(TRStr self, TSIn SIn, bool const & IsSmall) -> TRStr

        Parameters:
            SIn: TSIn &
            IsSmall: bool const &

        """
        _snap.TRStr_swiginit(self,_snap.new_TRStr(*args))
    def Save(self, *args):
        """
        Save(TRStr self, TSOut SOut, bool const & IsSmall)

        Parameters:
            SOut: TSOut &
            IsSmall: bool const &

        """
        return _snap.TRStr_Save(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TRStr self) -> int

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_GetMemUsed(self)

    def MkRef(self):
        """
        MkRef(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_MkRef(self)

    def UnRef(self):
        """
        UnRef(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_UnRef(self)

    def CStr(self, *args):
        """
        CStr(TRStr self) -> char const
        CStr(TRStr self) -> char *

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_CStr(self, *args)

    def Empty(self):
        """
        Empty(TRStr self) -> bool

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_Empty(self)

    def Len(self):
        """
        Len(TRStr self) -> int

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_Len(self)

    def PutCh(self, *args):
        """
        PutCh(TRStr self, int const & ChN, char const & Ch)

        Parameters:
            ChN: int const &
            Ch: char const &

        """
        return _snap.TRStr_PutCh(self, *args)

    def GetCh(self, *args):
        """
        GetCh(TRStr self, int const & ChN) -> char

        Parameters:
            ChN: int const &

        """
        return _snap.TRStr_GetCh(self, *args)

    def IsUc(self):
        """
        IsUc(TRStr self) -> bool

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_IsUc(self)

    def ToUc(self):
        """
        ToUc(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_ToUc(self)

    def IsLc(self):
        """
        IsLc(TRStr self) -> bool

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_IsLc(self)

    def ToLc(self):
        """
        ToLc(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_ToLc(self)

    def ToCap(self):
        """
        ToCap(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_ToCap(self)

    def ConvUsFromYuAscii(self):
        """
        ConvUsFromYuAscii(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_ConvUsFromYuAscii(self)

    def CmpI(*args):
        """
        CmpI(char const * CStr1, char const * CStr2) -> int

        Parameters:
            CStr1: char const *
            CStr2: char const *

        """
        return _snap.TRStr_CmpI(*args)

    CmpI = staticmethod(CmpI)
    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TRStr self) -> int

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TRStr self) -> int

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_GetSecHashCd(self)

    def GetNullRStr():
        """GetNullRStr() -> TRStr"""
        return _snap.TRStr_GetNullRStr()

    GetNullRStr = staticmethod(GetNullRStr)
TRStr.Save = new_instancemethod(_snap.TRStr_Save,None,TRStr)
TRStr.GetMemUsed = new_instancemethod(_snap.TRStr_GetMemUsed,None,TRStr)
TRStr.MkRef = new_instancemethod(_snap.TRStr_MkRef,None,TRStr)
TRStr.UnRef = new_instancemethod(_snap.TRStr_UnRef,None,TRStr)
TRStr.CStr = new_instancemethod(_snap.TRStr_CStr,None,TRStr)
TRStr.Empty = new_instancemethod(_snap.TRStr_Empty,None,TRStr)
TRStr.Len = new_instancemethod(_snap.TRStr_Len,None,TRStr)
TRStr.PutCh = new_instancemethod(_snap.TRStr_PutCh,None,TRStr)
TRStr.GetCh = new_instancemethod(_snap.TRStr_GetCh,None,TRStr)
TRStr.IsUc = new_instancemethod(_snap.TRStr_IsUc,None,TRStr)
TRStr.ToUc = new_instancemethod(_snap.TRStr_ToUc,None,TRStr)
TRStr.IsLc = new_instancemethod(_snap.TRStr_IsLc,None,TRStr)
TRStr.ToLc = new_instancemethod(_snap.TRStr_ToLc,None,TRStr)
TRStr.ToCap = new_instancemethod(_snap.TRStr_ToCap,None,TRStr)
TRStr.ConvUsFromYuAscii = new_instancemethod(_snap.TRStr_ConvUsFromYuAscii,None,TRStr)
TRStr.GetPrimHashCd = new_instancemethod(_snap.TRStr_GetPrimHashCd,None,TRStr)
TRStr.GetSecHashCd = new_instancemethod(_snap.TRStr_GetSecHashCd,None,TRStr)
TRStr_swigregister = _snap.TRStr_swigregister
TRStr_swigregister(TRStr)

def TRStr_CmpI(*args):
  """
    TRStr_CmpI(char const * CStr1, char const * CStr2) -> int

    Parameters:
        CStr1: char const *
        CStr2: char const *

    """
  return _snap.TRStr_CmpI(*args)

def TRStr_GetNullRStr():
  """TRStr_GetNullRStr() -> TRStr"""
  return _snap.TRStr_GetNullRStr()

class TStr(object):
    """Proxy of C++ TStr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TStr
    def __init__(self, *args): 
        """
        __init__(TStr self) -> TStr
        __init__(TStr self, TStr Str) -> TStr

        Parameters:
            Str: TStr const &

        __init__(TStr self, TChA ChA) -> TStr

        Parameters:
            ChA: TChA const &

        __init__(TStr self, TSStr SStr) -> TStr

        Parameters:
            SStr: TSStr const &

        __init__(TStr self, char const * CStr) -> TStr

        Parameters:
            CStr: char const *

        __init__(TStr self, char const & Ch) -> TStr

        Parameters:
            Ch: char const &

        __init__(TStr self, TMem Mem) -> TStr

        Parameters:
            Mem: TMem const &

        __init__(TStr self, PSIn const & SIn) -> TStr

        Parameters:
            SIn: PSIn const &

        __init__(TStr self, TSIn SIn, bool const & IsSmall=False) -> TStr

        Parameters:
            SIn: TSIn &
            IsSmall: bool const &

        __init__(TStr self, TSIn SIn) -> TStr

        Parameters:
            SIn: TSIn &

        """
        _snap.TStr_swiginit(self,_snap.new_TStr(*args))
    def Load(self, *args):
        """
        Load(TStr self, TSIn SIn, bool const & IsSmall=False)

        Parameters:
            SIn: TSIn &
            IsSmall: bool const &

        Load(TStr self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TStr_Load(self, *args)

    def Save(self, *args):
        """
        Save(TStr self, TSOut SOut, bool const & IsSmall=False)

        Parameters:
            SOut: TSOut &
            IsSmall: bool const &

        Save(TStr self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TStr_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TStr self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TStr_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TStr self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TStr_SaveXml(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(TStr self, TStr Str) -> TStr

        Parameters:
            Str: TStr const &

        __iadd__(TStr self, char const * CStr) -> TStr

        Parameters:
            CStr: char const *

        """
        return _snap.TStr___iadd__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        __eq__(TStr self, char const * CStr) -> bool

        Parameters:
            CStr: char const *

        """
        return _snap.TStr___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TStr self, char const * CStr) -> bool

        Parameters:
            CStr: char const *

        """
        return _snap.TStr___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TStr self) -> int

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetMemUsed(self)

    def CStr(self, *args):
        """
        CStr(TStr self) -> char
        CStr(TStr self) -> char const *

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_CStr(self, *args)

    def PutCh(self, *args):
        """
        PutCh(TStr self, int const & ChN, char const & Ch)

        Parameters:
            ChN: int const &
            Ch: char const &

        """
        return _snap.TStr_PutCh(self, *args)

    def GetCh(self, *args):
        """
        GetCh(TStr self, int const & ChN) -> char

        Parameters:
            ChN: int const &

        """
        return _snap.TStr_GetCh(self, *args)

    def LastCh(self):
        """
        LastCh(TStr self) -> char

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_LastCh(self)

    def Clr(self):
        """
        Clr(TStr self)

        Parameters:
            self: TStr *

        """
        return _snap.TStr_Clr(self)

    def Len(self):
        """
        Len(TStr self) -> int

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_Len(self)

    def Empty(self):
        """
        Empty(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_Empty(self)

    def IsUc(self):
        """
        IsUc(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsUc(self)

    def ToUc(self):
        """
        ToUc(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToUc(self)

    def GetUc(self):
        """
        GetUc(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetUc(self)

    def CmpI(self, *args):
        """
        CmpI(TStr self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_CmpI(self, *args)

    def EqI(self, *args):
        """
        EqI(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_EqI(self, *args)

    def IsLc(self):
        """
        IsLc(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsLc(self)

    def ToLc(self):
        """
        ToLc(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToLc(self)

    def GetLc(self):
        """
        GetLc(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetLc(self)

    def ToCap(self):
        """
        ToCap(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToCap(self)

    def GetCap(self):
        """
        GetCap(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetCap(self)

    def ToTrunc(self):
        """
        ToTrunc(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToTrunc(self)

    def GetTrunc(self):
        """
        GetTrunc(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetTrunc(self)

    def ConvUsFromYuAscii(self):
        """
        ConvUsFromYuAscii(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ConvUsFromYuAscii(self)

    def GetUsFromYuAscii(self):
        """
        GetUsFromYuAscii(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetUsFromYuAscii(self)

    def ToHex(self):
        """
        ToHex(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToHex(self)

    def GetHex(self):
        """
        GetHex(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetHex(self)

    def FromHex(self):
        """
        FromHex(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_FromHex(self)

    def GetFromHex(self):
        """
        GetFromHex(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFromHex(self)

    def GetSubStr(self, *args):
        """
        GetSubStr(TStr self, int const & BChN, int const & EChN) -> TStr

        Parameters:
            BChN: int const &
            EChN: int const &

        GetSubStr(TStr self, int const & BChN) -> TStr

        Parameters:
            BChN: int const &

        """
        return _snap.TStr_GetSubStr(self, *args)

    def InsStr(self, *args):
        """
        InsStr(TStr self, int const & BChN, TStr Str)

        Parameters:
            BChN: int const &
            Str: TStr const &

        """
        return _snap.TStr_InsStr(self, *args)

    def DelChAll(self, *args):
        """
        DelChAll(TStr self, char const & Ch)

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_DelChAll(self, *args)

    def DelSubStr(self, *args):
        """
        DelSubStr(TStr self, int const & BChN, int const & EChN)

        Parameters:
            BChN: int const &
            EChN: int const &

        """
        return _snap.TStr_DelSubStr(self, *args)

    def DelStr(self, *args):
        """
        DelStr(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_DelStr(self, *args)

    def LeftOf(self, *args):
        """
        LeftOf(TStr self, char const & SplitCh) -> TStr

        Parameters:
            SplitCh: char const &

        """
        return _snap.TStr_LeftOf(self, *args)

    def LeftOfLast(self, *args):
        """
        LeftOfLast(TStr self, char const & SplitCh) -> TStr

        Parameters:
            SplitCh: char const &

        """
        return _snap.TStr_LeftOfLast(self, *args)

    def RightOf(self, *args):
        """
        RightOf(TStr self, char const & SplitCh) -> TStr

        Parameters:
            SplitCh: char const &

        """
        return _snap.TStr_RightOf(self, *args)

    def RightOfLast(self, *args):
        """
        RightOfLast(TStr self, char const & SplitCh) -> TStr

        Parameters:
            SplitCh: char const &

        """
        return _snap.TStr_RightOfLast(self, *args)

    def SplitOnCh(self, *args):
        """
        SplitOnCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr)

        Parameters:
            LStr: TStr &
            SplitCh: char const &
            RStr: TStr &

        """
        return _snap.TStr_SplitOnCh(self, *args)

    def SplitOnLastCh(self, *args):
        """
        SplitOnLastCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr)

        Parameters:
            LStr: TStr &
            SplitCh: char const &
            RStr: TStr &

        """
        return _snap.TStr_SplitOnLastCh(self, *args)

    def SplitOnAllCh(self, *args):
        """
        SplitOnAllCh(TStr self, char const & SplitCh, TStrV StrV, bool const & SkipEmpty=True)

        Parameters:
            SplitCh: char const &
            StrV: TStrV &
            SkipEmpty: bool const &

        SplitOnAllCh(TStr self, char const & SplitCh, TStrV StrV)

        Parameters:
            SplitCh: char const &
            StrV: TStrV &

        """
        return _snap.TStr_SplitOnAllCh(self, *args)

    def SplitOnAllAnyCh(self, *args):
        """
        SplitOnAllAnyCh(TStr self, TStr SplitChStr, TStrV StrV, bool const & SkipEmpty=True)

        Parameters:
            SplitChStr: TStr const &
            StrV: TStrV &
            SkipEmpty: bool const &

        SplitOnAllAnyCh(TStr self, TStr SplitChStr, TStrV StrV)

        Parameters:
            SplitChStr: TStr const &
            StrV: TStrV &

        """
        return _snap.TStr_SplitOnAllAnyCh(self, *args)

    def SplitOnWs(self, *args):
        """
        SplitOnWs(TStr self, TStrV StrV)

        Parameters:
            StrV: TStrV &

        """
        return _snap.TStr_SplitOnWs(self, *args)

    def SplitOnNonAlNum(self, *args):
        """
        SplitOnNonAlNum(TStr self, TStrV StrV)

        Parameters:
            StrV: TStrV &

        """
        return _snap.TStr_SplitOnNonAlNum(self, *args)

    def SplitOnStr(self, *args):
        """
        SplitOnStr(TStr self, TStr SplitStr, TStrV StrV)

        Parameters:
            SplitStr: TStr const &
            StrV: TStrV &

        SplitOnStr(TStr self, TStr LeftStr, TStr MidStr, TStr RightStr)

        Parameters:
            LeftStr: TStr &
            MidStr: TStr const &
            RightStr: TStr &

        """
        return _snap.TStr_SplitOnStr(self, *args)

    def Mid(self, *args):
        """
        Mid(TStr self, int const & BChN, int const & Chs) -> TStr

        Parameters:
            BChN: int const &
            Chs: int const &

        Mid(TStr self, int const & BChN) -> TStr

        Parameters:
            BChN: int const &

        """
        return _snap.TStr_Mid(self, *args)

    def Left(self, *args):
        """
        Left(TStr self, int const & EChN) -> TStr

        Parameters:
            EChN: int const &

        """
        return _snap.TStr_Left(self, *args)

    def Right(self, *args):
        """
        Right(TStr self, int const & BChN) -> TStr

        Parameters:
            BChN: int const &

        """
        return _snap.TStr_Right(self, *args)

    def Slice(self, *args):
        """
        Slice(TStr self, int BChN, int EChNP1) -> TStr

        Parameters:
            BChN: int
            EChNP1: int

        """
        return _snap.TStr_Slice(self, *args)

    def __call__(self, *args):
        """
        __call__(TStr self) -> char
        __call__(TStr self) -> char const
        __call__(TStr self, int const & BChN, int const & EChNP1) -> TStr

        Parameters:
            BChN: int const &
            EChNP1: int const &

        """
        return _snap.TStr___call__(self, *args)

    def CountCh(self, *args):
        """
        CountCh(TStr self, char const & Ch, int const & BChN=0) -> int

        Parameters:
            Ch: char const &
            BChN: int const &

        CountCh(TStr self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_CountCh(self, *args)

    def SearchCh(self, *args):
        """
        SearchCh(TStr self, char const & Ch, int const & BChN=0) -> int

        Parameters:
            Ch: char const &
            BChN: int const &

        SearchCh(TStr self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_SearchCh(self, *args)

    def SearchChBack(self, *args):
        """
        SearchChBack(TStr self, char const & Ch, int BChN=-1) -> int

        Parameters:
            Ch: char const &
            BChN: int

        SearchChBack(TStr self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_SearchChBack(self, *args)

    def SearchStr(self, *args):
        """
        SearchStr(TStr self, TStr Str, int const & BChN=0) -> int

        Parameters:
            Str: TStr const &
            BChN: int const &

        SearchStr(TStr self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_SearchStr(self, *args)

    def IsChIn(self, *args):
        """
        IsChIn(TStr self, char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_IsChIn(self, *args)

    def IsStrIn(self, *args):
        """
        IsStrIn(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_IsStrIn(self, *args)

    def IsPrefix(self, *args):
        """
        IsPrefix(TStr self, char const * Str) -> bool

        Parameters:
            Str: char const *

        IsPrefix(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_IsPrefix(self, *args)

    def IsSuffix(self, *args):
        """
        IsSuffix(TStr self, char const * Str) -> bool

        Parameters:
            Str: char const *

        IsSuffix(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_IsSuffix(self, *args)

    def ChangeCh(self, *args):
        """
        ChangeCh(TStr self, char const & SrcCh, char const & DstCh, int const & BChN=0) -> int

        Parameters:
            SrcCh: char const &
            DstCh: char const &
            BChN: int const &

        ChangeCh(TStr self, char const & SrcCh, char const & DstCh) -> int

        Parameters:
            SrcCh: char const &
            DstCh: char const &

        """
        return _snap.TStr_ChangeCh(self, *args)

    def ChangeChAll(self, *args):
        """
        ChangeChAll(TStr self, char const & SrcCh, char const & DstCh) -> int

        Parameters:
            SrcCh: char const &
            DstCh: char const &

        """
        return _snap.TStr_ChangeChAll(self, *args)

    def ChangeStr(self, *args):
        """
        ChangeStr(TStr self, TStr SrcStr, TStr DstStr, int const & BChN=0) -> int

        Parameters:
            SrcStr: TStr const &
            DstStr: TStr const &
            BChN: int const &

        ChangeStr(TStr self, TStr SrcStr, TStr DstStr) -> int

        Parameters:
            SrcStr: TStr const &
            DstStr: TStr const &

        """
        return _snap.TStr_ChangeStr(self, *args)

    def ChangeStrAll(self, *args):
        """
        ChangeStrAll(TStr self, TStr SrcStr, TStr DstStr, bool const & FromStartP=False) -> int

        Parameters:
            SrcStr: TStr const &
            DstStr: TStr const &
            FromStartP: bool const &

        ChangeStrAll(TStr self, TStr SrcStr, TStr DstStr) -> int

        Parameters:
            SrcStr: TStr const &
            DstStr: TStr const &

        """
        return _snap.TStr_ChangeStrAll(self, *args)

    def Reverse(self):
        """
        Reverse(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_Reverse(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TStr self) -> int

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TStr self) -> int

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetSecHashCd(self)

    def IsBool(self, *args):
        """
        IsBool(TStr self, bool & Val) -> bool

        Parameters:
            Val: bool &

        """
        return _snap.TStr_IsBool(self, *args)

    def IsInt(self, *args):
        """
        IsInt(TStr self, bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: int const &
            MxVal: int const &
            Val: int &

        IsInt(TStr self, int & Val) -> bool

        Parameters:
            Val: int &

        IsInt(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsInt(self, *args)

    def GetInt(self, *args):
        """
        GetInt(TStr self) -> int
        GetInt(TStr self, int const & DfVal) -> int

        Parameters:
            DfVal: int const &

        """
        return _snap.TStr_GetInt(self, *args)

    def IsUInt(self, *args):
        """
        IsUInt(TStr self, bool const & Check, uint const & MnVal, uint const & MxVal, uint & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: uint const &
            MxVal: uint const &
            Val: uint &

        IsUInt(TStr self, uint & Val) -> bool

        Parameters:
            Val: uint &

        IsUInt(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsUInt(self, *args)

    def GetUInt(self, *args):
        """
        GetUInt(TStr self) -> uint
        GetUInt(TStr self, uint const & DfVal) -> uint

        Parameters:
            DfVal: uint const &

        """
        return _snap.TStr_GetUInt(self, *args)

    def IsInt64(self, *args):
        """
        IsInt64(TStr self, bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: int64 const &
            MxVal: int64 const &
            Val: int64 &

        IsInt64(TStr self, int64 & Val) -> bool

        Parameters:
            Val: int64 &

        IsInt64(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsInt64(self, *args)

    def GetInt64(self, *args):
        """
        GetInt64(TStr self) -> int64
        GetInt64(TStr self, int64 const & DfVal) -> int64

        Parameters:
            DfVal: int64 const &

        """
        return _snap.TStr_GetInt64(self, *args)

    def IsUInt64(self, *args):
        """
        IsUInt64(TStr self, bool const & Check, uint64 const & MnVal, uint64 const & MxVal, uint64 & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: uint64 const &
            MxVal: uint64 const &
            Val: uint64 &

        IsUInt64(TStr self, uint64 & Val) -> bool

        Parameters:
            Val: uint64 &

        IsUInt64(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsUInt64(self, *args)

    def GetUInt64(self, *args):
        """
        GetUInt64(TStr self) -> uint64
        GetUInt64(TStr self, uint64 const & DfVal) -> uint64

        Parameters:
            DfVal: uint64 const &

        """
        return _snap.TStr_GetUInt64(self, *args)

    def IsHexInt(self, *args):
        """
        IsHexInt(TStr self, bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: int const &
            MxVal: int const &
            Val: int &

        IsHexInt(TStr self, int & Val) -> bool

        Parameters:
            Val: int &

        IsHexInt(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsHexInt(self, *args)

    def GetHexInt(self, *args):
        """
        GetHexInt(TStr self) -> int
        GetHexInt(TStr self, int const & DfVal) -> int

        Parameters:
            DfVal: int const &

        """
        return _snap.TStr_GetHexInt(self, *args)

    def IsHexInt64(self, *args):
        """
        IsHexInt64(TStr self, bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: int64 const &
            MxVal: int64 const &
            Val: int64 &

        IsHexInt64(TStr self, int64 & Val) -> bool

        Parameters:
            Val: int64 &

        IsHexInt64(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsHexInt64(self, *args)

    def GetHexInt64(self, *args):
        """
        GetHexInt64(TStr self) -> int64
        GetHexInt64(TStr self, int64 const & DfVal) -> int64

        Parameters:
            DfVal: int64 const &

        """
        return _snap.TStr_GetHexInt64(self, *args)

    def IsFlt(self, *args):
        """
        IsFlt(TStr self, bool const & Check, double const & MnVal, double const & MxVal, double & Val, char const & DecDelimCh='.') -> bool

        Parameters:
            Check: bool const &
            MnVal: double const &
            MxVal: double const &
            Val: double &
            DecDelimCh: char const &

        IsFlt(TStr self, bool const & Check, double const & MnVal, double const & MxVal, double & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: double const &
            MxVal: double const &
            Val: double &

        IsFlt(TStr self, double & Val) -> bool

        Parameters:
            Val: double &

        IsFlt(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsFlt(self, *args)

    def GetFlt(self, *args):
        """
        GetFlt(TStr self) -> double
        GetFlt(TStr self, double const & DfVal) -> double

        Parameters:
            DfVal: double const &

        """
        return _snap.TStr_GetFlt(self, *args)

    def IsWord(self, WsPrefixP=True, FirstUcAllowedP=True):
        """
        IsWord(TStr self, bool const & WsPrefixP=True, bool const & FirstUcAllowedP=True) -> bool

        Parameters:
            WsPrefixP: bool const &
            FirstUcAllowedP: bool const &

        IsWord(TStr self, bool const & WsPrefixP=True) -> bool

        Parameters:
            WsPrefixP: bool const &

        IsWord(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsWord(self, WsPrefixP, FirstUcAllowedP)

    def IsWs(self):
        """
        IsWs(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsWs(self)

    def IsWcMatch(self, *args):
        """
        IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*', 
            char const & QuestCh='?') -> bool

        Parameters:
            StrBChN: int const &
            WcStr: TStr const &
            WcStrBChN: int const &
            StarStrV: TStrV &
            StarCh: char const &
            QuestCh: char const &

        IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*') -> bool

        Parameters:
            StrBChN: int const &
            WcStr: TStr const &
            WcStrBChN: int const &
            StarStrV: TStrV &
            StarCh: char const &

        IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV) -> bool

        Parameters:
            StrBChN: int const &
            WcStr: TStr const &
            WcStrBChN: int const &
            StarStrV: TStrV &

        IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV, char const & StarCh='*', char const & QuestCh='?') -> bool

        Parameters:
            WcStr: TStr const &
            StarStrV: TStrV &
            StarCh: char const &
            QuestCh: char const &

        IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV, char const & StarCh='*') -> bool

        Parameters:
            WcStr: TStr const &
            StarStrV: TStrV &
            StarCh: char const &

        IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV) -> bool

        Parameters:
            WcStr: TStr const &
            StarStrV: TStrV &

        IsWcMatch(TStr self, TStr WcStr, char const & StarCh, char const & QuestCh) -> bool

        Parameters:
            WcStr: TStr const &
            StarCh: char const &
            QuestCh: char const &

        IsWcMatch(TStr self, TStr WcStr, int const & StarStrN, TStr StarStr) -> bool

        Parameters:
            WcStr: TStr const &
            StarStrN: int const &
            StarStr: TStr &

        IsWcMatch(TStr self, TStr WcStr) -> bool

        Parameters:
            WcStr: TStr const &

        """
        return _snap.TStr_IsWcMatch(self, *args)

    def GetWcMatch(self, *args):
        """
        GetWcMatch(TStr self, TStr WcStr, int const & StarStrN=0) -> TStr

        Parameters:
            WcStr: TStr const &
            StarStrN: int const &

        GetWcMatch(TStr self, TStr WcStr) -> TStr

        Parameters:
            WcStr: TStr const &

        """
        return _snap.TStr_GetWcMatch(self, *args)

    def GetFPath(self):
        """
        GetFPath(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFPath(self)

    def GetFBase(self):
        """
        GetFBase(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFBase(self)

    def GetFMid(self):
        """
        GetFMid(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFMid(self)

    def GetFExt(self):
        """
        GetFExt(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFExt(self)

    def GetNrFPath(*args):
        """
        GetNrFPath(TStr FPath) -> TStr

        Parameters:
            FPath: TStr const &

        """
        return _snap.TStr_GetNrFPath(*args)

    GetNrFPath = staticmethod(GetNrFPath)
    def GetNrFMid(*args):
        """
        GetNrFMid(TStr FMid) -> TStr

        Parameters:
            FMid: TStr const &

        """
        return _snap.TStr_GetNrFMid(*args)

    GetNrFMid = staticmethod(GetNrFMid)
    def GetNrFExt(*args):
        """
        GetNrFExt(TStr FExt) -> TStr

        Parameters:
            FExt: TStr const &

        """
        return _snap.TStr_GetNrFExt(*args)

    GetNrFExt = staticmethod(GetNrFExt)
    def GetNrNumFExt(*args):
        """
        GetNrNumFExt(int const & FExtN) -> TStr

        Parameters:
            FExtN: int const &

        """
        return _snap.TStr_GetNrNumFExt(*args)

    GetNrNumFExt = staticmethod(GetNrNumFExt)
    def GetNrFNm(*args):
        """
        GetNrFNm(TStr FNm) -> TStr

        Parameters:
            FNm: TStr const &

        """
        return _snap.TStr_GetNrFNm(*args)

    GetNrFNm = staticmethod(GetNrFNm)
    def GetNrAbsFPath(*args):
        """
        GetNrAbsFPath(TStr FPath, TStr BaseFPath=TStr()) -> TStr

        Parameters:
            FPath: TStr const &
            BaseFPath: TStr const &

        GetNrAbsFPath(TStr FPath) -> TStr

        Parameters:
            FPath: TStr const &

        """
        return _snap.TStr_GetNrAbsFPath(*args)

    GetNrAbsFPath = staticmethod(GetNrAbsFPath)
    def IsAbsFPath(*args):
        """
        IsAbsFPath(TStr FPath) -> bool

        Parameters:
            FPath: TStr const &

        """
        return _snap.TStr_IsAbsFPath(*args)

    IsAbsFPath = staticmethod(IsAbsFPath)
    def PutFExt(*args):
        """
        PutFExt(TStr FNm, TStr FExt) -> TStr

        Parameters:
            FNm: TStr const &
            FExt: TStr const &

        """
        return _snap.TStr_PutFExt(*args)

    PutFExt = staticmethod(PutFExt)
    def PutFExtIfEmpty(*args):
        """
        PutFExtIfEmpty(TStr FNm, TStr FExt) -> TStr

        Parameters:
            FNm: TStr const &
            FExt: TStr const &

        """
        return _snap.TStr_PutFExtIfEmpty(*args)

    PutFExtIfEmpty = staticmethod(PutFExtIfEmpty)
    def PutFBase(*args):
        """
        PutFBase(TStr FNm, TStr FBase) -> TStr

        Parameters:
            FNm: TStr const &
            FBase: TStr const &

        """
        return _snap.TStr_PutFBase(*args)

    PutFBase = staticmethod(PutFBase)
    def PutFBaseIfEmpty(*args):
        """
        PutFBaseIfEmpty(TStr FNm, TStr FBase) -> TStr

        Parameters:
            FNm: TStr const &
            FBase: TStr const &

        """
        return _snap.TStr_PutFBaseIfEmpty(*args)

    PutFBaseIfEmpty = staticmethod(PutFBaseIfEmpty)
    def AddToFMid(*args):
        """
        AddToFMid(TStr FNm, TStr ExtFMid) -> TStr

        Parameters:
            FNm: TStr const &
            ExtFMid: TStr const &

        """
        return _snap.TStr_AddToFMid(*args)

    AddToFMid = staticmethod(AddToFMid)
    def GetNumFNm(*args):
        """
        GetNumFNm(TStr FNm, int const & Num) -> TStr

        Parameters:
            FNm: TStr const &
            Num: int const &

        """
        return _snap.TStr_GetNumFNm(*args)

    GetNumFNm = staticmethod(GetNumFNm)
    def GetFNmStr(*args):
        """
        GetFNmStr(TStr Str, bool const & AlNumOnlyP=True) -> TStr

        Parameters:
            Str: TStr const &
            AlNumOnlyP: bool const &

        GetFNmStr(TStr Str) -> TStr

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_GetFNmStr(*args)

    GetFNmStr = staticmethod(GetFNmStr)
    def LoadTxt(*args):
        """
        LoadTxt(PSIn const & SIn) -> TStr

        Parameters:
            SIn: PSIn const &

        LoadTxt(TStr FNm) -> TStr

        Parameters:
            FNm: TStr const &

        """
        return _snap.TStr_LoadTxt(*args)

    LoadTxt = staticmethod(LoadTxt)
    def SaveTxt(self, *args):
        """
        SaveTxt(TStr self, PSOut const & SOut)

        Parameters:
            SOut: PSOut const &

        SaveTxt(TStr self, TStr FNm)

        Parameters:
            FNm: TStr const &

        """
        return _snap.TStr_SaveTxt(self, *args)

    def GetChStr(*args):
        """
        GetChStr(char const & Ch) -> TStr

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_GetChStr(*args)

    GetChStr = staticmethod(GetChStr)
    def GetDChStr(*args):
        """
        GetDChStr(char const & Ch1, char const & Ch2) -> TStr

        Parameters:
            Ch1: char const &
            Ch2: char const &

        """
        return _snap.TStr_GetDChStr(*args)

    GetDChStr = staticmethod(GetDChStr)
    def Fmt(*args):
        """
        Fmt(char const * FmtStr) -> TStr

        Parameters:
            FmtStr: char const *

        """
        return _snap.TStr_Fmt(*args)

    Fmt = staticmethod(Fmt)
    def GetSpaceStr(*args):
        """
        GetSpaceStr(int const & Spaces) -> TStr

        Parameters:
            Spaces: int const &

        """
        return _snap.TStr_GetSpaceStr(*args)

    GetSpaceStr = staticmethod(GetSpaceStr)
    def GetCStr(self):
        """
        GetCStr(TStr self) -> char *

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetCStr(self)

    def MkClone(*args):
        """
        MkClone(TStr Str) -> TStr

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_MkClone(*args)

    MkClone = staticmethod(MkClone)
    def GetNullStr():
        """GetNullStr() -> TStr"""
        return _snap.TStr_GetNullStr()

    GetNullStr = staticmethod(GetNullStr)
TStr.Load = new_instancemethod(_snap.TStr_Load,None,TStr)
TStr.Save = new_instancemethod(_snap.TStr_Save,None,TStr)
TStr.LoadXml = new_instancemethod(_snap.TStr_LoadXml,None,TStr)
TStr.SaveXml = new_instancemethod(_snap.TStr_SaveXml,None,TStr)
TStr.__iadd__ = new_instancemethod(_snap.TStr___iadd__,None,TStr)
TStr.__eq__ = new_instancemethod(_snap.TStr___eq__,None,TStr)
TStr.__ne__ = new_instancemethod(_snap.TStr___ne__,None,TStr)
TStr.__lt__ = new_instancemethod(_snap.TStr___lt__,None,TStr)
TStr.GetMemUsed = new_instancemethod(_snap.TStr_GetMemUsed,None,TStr)
TStr.CStr = new_instancemethod(_snap.TStr_CStr,None,TStr)
TStr.PutCh = new_instancemethod(_snap.TStr_PutCh,None,TStr)
TStr.GetCh = new_instancemethod(_snap.TStr_GetCh,None,TStr)
TStr.LastCh = new_instancemethod(_snap.TStr_LastCh,None,TStr)
TStr.Clr = new_instancemethod(_snap.TStr_Clr,None,TStr)
TStr.Len = new_instancemethod(_snap.TStr_Len,None,TStr)
TStr.Empty = new_instancemethod(_snap.TStr_Empty,None,TStr)
TStr.IsUc = new_instancemethod(_snap.TStr_IsUc,None,TStr)
TStr.ToUc = new_instancemethod(_snap.TStr_ToUc,None,TStr)
TStr.GetUc = new_instancemethod(_snap.TStr_GetUc,None,TStr)
TStr.CmpI = new_instancemethod(_snap.TStr_CmpI,None,TStr)
TStr.EqI = new_instancemethod(_snap.TStr_EqI,None,TStr)
TStr.IsLc = new_instancemethod(_snap.TStr_IsLc,None,TStr)
TStr.ToLc = new_instancemethod(_snap.TStr_ToLc,None,TStr)
TStr.GetLc = new_instancemethod(_snap.TStr_GetLc,None,TStr)
TStr.ToCap = new_instancemethod(_snap.TStr_ToCap,None,TStr)
TStr.GetCap = new_instancemethod(_snap.TStr_GetCap,None,TStr)
TStr.ToTrunc = new_instancemethod(_snap.TStr_ToTrunc,None,TStr)
TStr.GetTrunc = new_instancemethod(_snap.TStr_GetTrunc,None,TStr)
TStr.ConvUsFromYuAscii = new_instancemethod(_snap.TStr_ConvUsFromYuAscii,None,TStr)
TStr.GetUsFromYuAscii = new_instancemethod(_snap.TStr_GetUsFromYuAscii,None,TStr)
TStr.ToHex = new_instancemethod(_snap.TStr_ToHex,None,TStr)
TStr.GetHex = new_instancemethod(_snap.TStr_GetHex,None,TStr)
TStr.FromHex = new_instancemethod(_snap.TStr_FromHex,None,TStr)
TStr.GetFromHex = new_instancemethod(_snap.TStr_GetFromHex,None,TStr)
TStr.GetSubStr = new_instancemethod(_snap.TStr_GetSubStr,None,TStr)
TStr.InsStr = new_instancemethod(_snap.TStr_InsStr,None,TStr)
TStr.DelChAll = new_instancemethod(_snap.TStr_DelChAll,None,TStr)
TStr.DelSubStr = new_instancemethod(_snap.TStr_DelSubStr,None,TStr)
TStr.DelStr = new_instancemethod(_snap.TStr_DelStr,None,TStr)
TStr.LeftOf = new_instancemethod(_snap.TStr_LeftOf,None,TStr)
TStr.LeftOfLast = new_instancemethod(_snap.TStr_LeftOfLast,None,TStr)
TStr.RightOf = new_instancemethod(_snap.TStr_RightOf,None,TStr)
TStr.RightOfLast = new_instancemethod(_snap.TStr_RightOfLast,None,TStr)
TStr.SplitOnCh = new_instancemethod(_snap.TStr_SplitOnCh,None,TStr)
TStr.SplitOnLastCh = new_instancemethod(_snap.TStr_SplitOnLastCh,None,TStr)
TStr.SplitOnAllCh = new_instancemethod(_snap.TStr_SplitOnAllCh,None,TStr)
TStr.SplitOnAllAnyCh = new_instancemethod(_snap.TStr_SplitOnAllAnyCh,None,TStr)
TStr.SplitOnWs = new_instancemethod(_snap.TStr_SplitOnWs,None,TStr)
TStr.SplitOnNonAlNum = new_instancemethod(_snap.TStr_SplitOnNonAlNum,None,TStr)
TStr.SplitOnStr = new_instancemethod(_snap.TStr_SplitOnStr,None,TStr)
TStr.Mid = new_instancemethod(_snap.TStr_Mid,None,TStr)
TStr.Left = new_instancemethod(_snap.TStr_Left,None,TStr)
TStr.Right = new_instancemethod(_snap.TStr_Right,None,TStr)
TStr.Slice = new_instancemethod(_snap.TStr_Slice,None,TStr)
TStr.__call__ = new_instancemethod(_snap.TStr___call__,None,TStr)
TStr.CountCh = new_instancemethod(_snap.TStr_CountCh,None,TStr)
TStr.SearchCh = new_instancemethod(_snap.TStr_SearchCh,None,TStr)
TStr.SearchChBack = new_instancemethod(_snap.TStr_SearchChBack,None,TStr)
TStr.SearchStr = new_instancemethod(_snap.TStr_SearchStr,None,TStr)
TStr.IsChIn = new_instancemethod(_snap.TStr_IsChIn,None,TStr)
TStr.IsStrIn = new_instancemethod(_snap.TStr_IsStrIn,None,TStr)
TStr.IsPrefix = new_instancemethod(_snap.TStr_IsPrefix,None,TStr)
TStr.IsSuffix = new_instancemethod(_snap.TStr_IsSuffix,None,TStr)
TStr.ChangeCh = new_instancemethod(_snap.TStr_ChangeCh,None,TStr)
TStr.ChangeChAll = new_instancemethod(_snap.TStr_ChangeChAll,None,TStr)
TStr.ChangeStr = new_instancemethod(_snap.TStr_ChangeStr,None,TStr)
TStr.ChangeStrAll = new_instancemethod(_snap.TStr_ChangeStrAll,None,TStr)
TStr.Reverse = new_instancemethod(_snap.TStr_Reverse,None,TStr)
TStr.GetPrimHashCd = new_instancemethod(_snap.TStr_GetPrimHashCd,None,TStr)
TStr.GetSecHashCd = new_instancemethod(_snap.TStr_GetSecHashCd,None,TStr)
TStr.IsBool = new_instancemethod(_snap.TStr_IsBool,None,TStr)
TStr.IsInt = new_instancemethod(_snap.TStr_IsInt,None,TStr)
TStr.GetInt = new_instancemethod(_snap.TStr_GetInt,None,TStr)
TStr.IsUInt = new_instancemethod(_snap.TStr_IsUInt,None,TStr)
TStr.GetUInt = new_instancemethod(_snap.TStr_GetUInt,None,TStr)
TStr.IsInt64 = new_instancemethod(_snap.TStr_IsInt64,None,TStr)
TStr.GetInt64 = new_instancemethod(_snap.TStr_GetInt64,None,TStr)
TStr.IsUInt64 = new_instancemethod(_snap.TStr_IsUInt64,None,TStr)
TStr.GetUInt64 = new_instancemethod(_snap.TStr_GetUInt64,None,TStr)
TStr.IsHexInt = new_instancemethod(_snap.TStr_IsHexInt,None,TStr)
TStr.GetHexInt = new_instancemethod(_snap.TStr_GetHexInt,None,TStr)
TStr.IsHexInt64 = new_instancemethod(_snap.TStr_IsHexInt64,None,TStr)
TStr.GetHexInt64 = new_instancemethod(_snap.TStr_GetHexInt64,None,TStr)
TStr.IsFlt = new_instancemethod(_snap.TStr_IsFlt,None,TStr)
TStr.GetFlt = new_instancemethod(_snap.TStr_GetFlt,None,TStr)
TStr.IsWord = new_instancemethod(_snap.TStr_IsWord,None,TStr)
TStr.IsWs = new_instancemethod(_snap.TStr_IsWs,None,TStr)
TStr.IsWcMatch = new_instancemethod(_snap.TStr_IsWcMatch,None,TStr)
TStr.GetWcMatch = new_instancemethod(_snap.TStr_GetWcMatch,None,TStr)
TStr.GetFPath = new_instancemethod(_snap.TStr_GetFPath,None,TStr)
TStr.GetFBase = new_instancemethod(_snap.TStr_GetFBase,None,TStr)
TStr.GetFMid = new_instancemethod(_snap.TStr_GetFMid,None,TStr)
TStr.GetFExt = new_instancemethod(_snap.TStr_GetFExt,None,TStr)
TStr.SaveTxt = new_instancemethod(_snap.TStr_SaveTxt,None,TStr)
TStr.GetCStr = new_instancemethod(_snap.TStr_GetCStr,None,TStr)
TStr_swigregister = _snap.TStr_swigregister
TStr_swigregister(TStr)

def TStr_GetNrFPath(*args):
  """
    TStr_GetNrFPath(TStr FPath) -> TStr

    Parameters:
        FPath: TStr const &

    """
  return _snap.TStr_GetNrFPath(*args)

def TStr_GetNrFMid(*args):
  """
    TStr_GetNrFMid(TStr FMid) -> TStr

    Parameters:
        FMid: TStr const &

    """
  return _snap.TStr_GetNrFMid(*args)

def TStr_GetNrFExt(*args):
  """
    TStr_GetNrFExt(TStr FExt) -> TStr

    Parameters:
        FExt: TStr const &

    """
  return _snap.TStr_GetNrFExt(*args)

def TStr_GetNrNumFExt(*args):
  """
    TStr_GetNrNumFExt(int const & FExtN) -> TStr

    Parameters:
        FExtN: int const &

    """
  return _snap.TStr_GetNrNumFExt(*args)

def TStr_GetNrFNm(*args):
  """
    TStr_GetNrFNm(TStr FNm) -> TStr

    Parameters:
        FNm: TStr const &

    """
  return _snap.TStr_GetNrFNm(*args)

def TStr_GetNrAbsFPath(*args):
  """
    GetNrAbsFPath(TStr FPath, TStr BaseFPath=TStr()) -> TStr

    Parameters:
        FPath: TStr const &
        BaseFPath: TStr const &

    TStr_GetNrAbsFPath(TStr FPath) -> TStr

    Parameters:
        FPath: TStr const &

    """
  return _snap.TStr_GetNrAbsFPath(*args)

def TStr_IsAbsFPath(*args):
  """
    TStr_IsAbsFPath(TStr FPath) -> bool

    Parameters:
        FPath: TStr const &

    """
  return _snap.TStr_IsAbsFPath(*args)

def TStr_PutFExt(*args):
  """
    TStr_PutFExt(TStr FNm, TStr FExt) -> TStr

    Parameters:
        FNm: TStr const &
        FExt: TStr const &

    """
  return _snap.TStr_PutFExt(*args)

def TStr_PutFExtIfEmpty(*args):
  """
    TStr_PutFExtIfEmpty(TStr FNm, TStr FExt) -> TStr

    Parameters:
        FNm: TStr const &
        FExt: TStr const &

    """
  return _snap.TStr_PutFExtIfEmpty(*args)

def TStr_PutFBase(*args):
  """
    TStr_PutFBase(TStr FNm, TStr FBase) -> TStr

    Parameters:
        FNm: TStr const &
        FBase: TStr const &

    """
  return _snap.TStr_PutFBase(*args)

def TStr_PutFBaseIfEmpty(*args):
  """
    TStr_PutFBaseIfEmpty(TStr FNm, TStr FBase) -> TStr

    Parameters:
        FNm: TStr const &
        FBase: TStr const &

    """
  return _snap.TStr_PutFBaseIfEmpty(*args)

def TStr_AddToFMid(*args):
  """
    TStr_AddToFMid(TStr FNm, TStr ExtFMid) -> TStr

    Parameters:
        FNm: TStr const &
        ExtFMid: TStr const &

    """
  return _snap.TStr_AddToFMid(*args)

def TStr_GetNumFNm(*args):
  """
    TStr_GetNumFNm(TStr FNm, int const & Num) -> TStr

    Parameters:
        FNm: TStr const &
        Num: int const &

    """
  return _snap.TStr_GetNumFNm(*args)

def TStr_GetFNmStr(*args):
  """
    GetFNmStr(TStr Str, bool const & AlNumOnlyP=True) -> TStr

    Parameters:
        Str: TStr const &
        AlNumOnlyP: bool const &

    TStr_GetFNmStr(TStr Str) -> TStr

    Parameters:
        Str: TStr const &

    """
  return _snap.TStr_GetFNmStr(*args)

def TStr_LoadTxt(*args):
  """
    LoadTxt(PSIn const & SIn) -> TStr

    Parameters:
        SIn: PSIn const &

    TStr_LoadTxt(TStr FNm) -> TStr

    Parameters:
        FNm: TStr const &

    """
  return _snap.TStr_LoadTxt(*args)

def TStr_GetChStr(*args):
  """
    TStr_GetChStr(char const & Ch) -> TStr

    Parameters:
        Ch: char const &

    """
  return _snap.TStr_GetChStr(*args)

def TStr_GetDChStr(*args):
  """
    TStr_GetDChStr(char const & Ch1, char const & Ch2) -> TStr

    Parameters:
        Ch1: char const &
        Ch2: char const &

    """
  return _snap.TStr_GetDChStr(*args)

def TStr_Fmt(*args):
  """
    TStr_Fmt(char const * FmtStr) -> TStr

    Parameters:
        FmtStr: char const *

    """
  return _snap.TStr_Fmt(*args)

def TStr_GetSpaceStr(*args):
  """
    TStr_GetSpaceStr(int const & Spaces) -> TStr

    Parameters:
        Spaces: int const &

    """
  return _snap.TStr_GetSpaceStr(*args)

def TStr_MkClone(*args):
  """
    TStr_MkClone(TStr Str) -> TStr

    Parameters:
        Str: TStr const &

    """
  return _snap.TStr_MkClone(*args)

def TStr_GetNullStr():
  """TStr_GetNullStr() -> TStr"""
  return _snap.TStr_GetNullStr()

class TStrIn(TSIn):
    """Proxy of C++ TStrIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TStrIn self, TStr _Str) -> TStrIn

        Parameters:
            _Str: TStr const &

        """
        _snap.TStrIn_swiginit(self,_snap.new_TStrIn(*args))
    def New(*args):
        """
        New(TStr Str) -> PSIn

        Parameters:
            Str: TStr const &

        """
        return _snap.TStrIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TStrIn
TStrIn_swigregister = _snap.TStrIn_swigregister
TStrIn_swigregister(TStrIn)

def TStrIn_New(*args):
  """
    TStrIn_New(TStr Str) -> PSIn

    Parameters:
        Str: TStr const &

    """
  return _snap.TStrIn_New(*args)

class TDbStr(object):
    """Proxy of C++ TDbStr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Str1 = _swig_property(_snap.TDbStr_Str1_get, _snap.TDbStr_Str1_set)
    Str2 = _swig_property(_snap.TDbStr_Str2_get, _snap.TDbStr_Str2_set)
    def __init__(self, *args): 
        """
        __init__(TDbStr self) -> TDbStr
        __init__(TDbStr self, TDbStr DbStr) -> TDbStr

        Parameters:
            DbStr: TDbStr const &

        __init__(TDbStr self, TStr _Str1) -> TDbStr

        Parameters:
            _Str1: TStr const &

        __init__(TDbStr self, TStr _Str1, TStr _Str2) -> TDbStr

        Parameters:
            _Str1: TStr const &
            _Str2: TStr const &

        __init__(TDbStr self, TSIn SIn) -> TDbStr

        Parameters:
            SIn: TSIn &

        """
        _snap.TDbStr_swiginit(self,_snap.new_TDbStr(*args))
    def Save(self, *args):
        """
        Save(TDbStr self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TDbStr_Save(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TDbStr self, TDbStr DbStr) -> bool

        Parameters:
            DbStr: TDbStr const &

        """
        return _snap.TDbStr___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TDbStr self, TDbStr DbStr) -> bool

        Parameters:
            DbStr: TDbStr const &

        """
        return _snap.TDbStr___lt__(self, *args)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TDbStr self) -> int

        Parameters:
            self: TDbStr const *

        """
        return _snap.TDbStr_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TDbStr self) -> int

        Parameters:
            self: TDbStr const *

        """
        return _snap.TDbStr_GetSecHashCd(self)

    def Empty(self):
        """
        Empty(TDbStr self) -> bool

        Parameters:
            self: TDbStr const *

        """
        return _snap.TDbStr_Empty(self)

    def Filled(self):
        """
        Filled(TDbStr self) -> bool

        Parameters:
            self: TDbStr const *

        """
        return _snap.TDbStr_Filled(self)

    __swig_destroy__ = _snap.delete_TDbStr
TDbStr.Save = new_instancemethod(_snap.TDbStr_Save,None,TDbStr)
TDbStr.__eq__ = new_instancemethod(_snap.TDbStr___eq__,None,TDbStr)
TDbStr.__lt__ = new_instancemethod(_snap.TDbStr___lt__,None,TDbStr)
TDbStr.GetPrimHashCd = new_instancemethod(_snap.TDbStr_GetPrimHashCd,None,TDbStr)
TDbStr.GetSecHashCd = new_instancemethod(_snap.TDbStr_GetSecHashCd,None,TDbStr)
TDbStr.Empty = new_instancemethod(_snap.TDbStr_Empty,None,TDbStr)
TDbStr.Filled = new_instancemethod(_snap.TDbStr_Filled,None,TDbStr)
TDbStr_swigregister = _snap.TDbStr_swigregister
TDbStr_swigregister(TDbStr)

class TStrPool(object):
    """Proxy of C++ TStrPool class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TStrPool self, uint const & MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> TStrPool

        Parameters:
            MxBfLen: uint const &
            _GrowBy: uint const &

        __init__(TStrPool self, uint const & MxBfLen=0) -> TStrPool

        Parameters:
            MxBfLen: uint const &

        __init__(TStrPool self) -> TStrPool
        __init__(TStrPool self, TSIn SIn, bool LoadCompact=True) -> TStrPool

        Parameters:
            SIn: TSIn &
            LoadCompact: bool

        __init__(TStrPool self, TSIn SIn) -> TStrPool

        Parameters:
            SIn: TSIn &

        __init__(TStrPool self, TStrPool Pool) -> TStrPool

        Parameters:
            Pool: TStrPool const &

        """
        _snap.TStrPool_swiginit(self,_snap.new_TStrPool(*args))
    __swig_destroy__ = _snap.delete_TStrPool
    def New(*args):
        """
        New(uint const & _MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> PStrPool

        Parameters:
            _MxBfLen: uint const &
            _GrowBy: uint const &

        New(uint const & _MxBfLen=0) -> PStrPool

        Parameters:
            _MxBfLen: uint const &

        New() -> PStrPool
        New(TSIn SIn) -> PStrPool

        Parameters:
            SIn: TSIn &

        New(TStr fileName) -> PStrPool

        Parameters:
            fileName: TStr const &

        """
        return _snap.TStrPool_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn, bool LoadCompacted=True) -> PStrPool

        Parameters:
            SIn: TSIn &
            LoadCompacted: bool

        Load(TSIn SIn) -> PStrPool

        Parameters:
            SIn: TSIn &

        """
        return _snap.TStrPool_Load(*args)

    Load = staticmethod(Load)
    def Save(self, *args):
        """
        Save(TStrPool self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        Save(TStrPool self, TStr FNm)

        Parameters:
            FNm: TStr const &

        """
        return _snap.TStrPool_Save(self, *args)

    def Len(self):
        """
        Len(TStrPool self) -> uint

        Parameters:
            self: TStrPool const *

        """
        return _snap.TStrPool_Len(self)

    def Size(self):
        """
        Size(TStrPool self) -> uint

        Parameters:
            self: TStrPool const *

        """
        return _snap.TStrPool_Size(self)

    def Empty(self):
        """
        Empty(TStrPool self) -> bool

        Parameters:
            self: TStrPool const *

        """
        return _snap.TStrPool_Empty(self)

    def __call__(self):
        """
        __call__(TStrPool self) -> char *

        Parameters:
            self: TStrPool const *

        """
        return _snap.TStrPool___call__(self)

    def AddStr(self, *args):
        """
        AddStr(TStrPool self, char const * Str, uint const & Len) -> uint

        Parameters:
            Str: char const *
            Len: uint const &

        AddStr(TStrPool self, char const * Str) -> uint

        Parameters:
            Str: char const *

        AddStr(TStrPool self, TStr Str) -> uint

        Parameters:
            Str: TStr const &

        """
        return _snap.TStrPool_AddStr(self, *args)

    def GetCStr(self, *args):
        """
        GetCStr(TStrPool self, uint const & Offset) -> char const *

        Parameters:
            Offset: uint const &

        """
        return _snap.TStrPool_GetCStr(self, *args)

    def Clr(self, DoDel=False):
        """
        Clr(TStrPool self, bool DoDel=False)

        Parameters:
            DoDel: bool

        Clr(TStrPool self)

        Parameters:
            self: TStrPool *

        """
        return _snap.TStrPool_Clr(self, DoDel)

    def Cmp(self, *args):
        """
        Cmp(TStrPool self, uint const & Offset, char const * Str) -> int

        Parameters:
            Offset: uint const &
            Str: char const *

        """
        return _snap.TStrPool_Cmp(self, *args)

    def GetPrimHashCd(self, *args):
        """
        GetPrimHashCd(TStrPool self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        GetPrimHashCd(TStrPool self, uint const & Offset) -> int

        Parameters:
            Offset: uint const &

        """
        return _snap.TStrPool_GetPrimHashCd(self, *args)

    def GetSecHashCd(self, *args):
        """
        GetSecHashCd(TStrPool self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        GetSecHashCd(TStrPool self, uint const & Offset) -> int

        Parameters:
            Offset: uint const &

        """
        return _snap.TStrPool_GetSecHashCd(self, *args)

TStrPool.Save = new_instancemethod(_snap.TStrPool_Save,None,TStrPool)
TStrPool.Len = new_instancemethod(_snap.TStrPool_Len,None,TStrPool)
TStrPool.Size = new_instancemethod(_snap.TStrPool_Size,None,TStrPool)
TStrPool.Empty = new_instancemethod(_snap.TStrPool_Empty,None,TStrPool)
TStrPool.__call__ = new_instancemethod(_snap.TStrPool___call__,None,TStrPool)
TStrPool.AddStr = new_instancemethod(_snap.TStrPool_AddStr,None,TStrPool)
TStrPool.GetCStr = new_instancemethod(_snap.TStrPool_GetCStr,None,TStrPool)
TStrPool.Clr = new_instancemethod(_snap.TStrPool_Clr,None,TStrPool)
TStrPool.Cmp = new_instancemethod(_snap.TStrPool_Cmp,None,TStrPool)
TStrPool.GetPrimHashCd = new_instancemethod(_snap.TStrPool_GetPrimHashCd,None,TStrPool)
TStrPool.GetSecHashCd = new_instancemethod(_snap.TStrPool_GetSecHashCd,None,TStrPool)
TStrPool_swigregister = _snap.TStrPool_swigregister
TStrPool_swigregister(TStrPool)

def TStrPool_New(*args):
  """
    New(uint const & _MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> PStrPool

    Parameters:
        _MxBfLen: uint const &
        _GrowBy: uint const &

    New(uint const & _MxBfLen=0) -> PStrPool

    Parameters:
        _MxBfLen: uint const &

    New() -> PStrPool
    New(TSIn SIn) -> PStrPool

    Parameters:
        SIn: TSIn &

    TStrPool_New(TStr fileName) -> PStrPool

    Parameters:
        fileName: TStr const &

    """
  return _snap.TStrPool_New(*args)

def TStrPool_Load(*args):
  """
    Load(TSIn SIn, bool LoadCompacted=True) -> PStrPool

    Parameters:
        SIn: TSIn &
        LoadCompacted: bool

    TStrPool_Load(TSIn SIn) -> PStrPool

    Parameters:
        SIn: TSIn &

    """
  return _snap.TStrPool_Load(*args)

class TStrPool64(object):
    """Proxy of C++ TStrPool64 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TStrPool64 self, ::TSize _MxBfL=0, ::TSize _GrowBy=16*1024*1024) -> TStrPool64

        Parameters:
            _MxBfL: ::TSize
            _GrowBy: ::TSize

        __init__(TStrPool64 self, ::TSize _MxBfL=0) -> TStrPool64

        Parameters:
            _MxBfL: ::TSize

        __init__(TStrPool64 self) -> TStrPool64
        __init__(TStrPool64 self, TStrPool64 StrPool) -> TStrPool64

        Parameters:
            StrPool: TStrPool64 const &

        __init__(TStrPool64 self, TSIn SIn, bool LoadCompact=True) -> TStrPool64

        Parameters:
            SIn: TSIn &
            LoadCompact: bool

        __init__(TStrPool64 self, TSIn SIn) -> TStrPool64

        Parameters:
            SIn: TSIn &

        """
        _snap.TStrPool64_swiginit(self,_snap.new_TStrPool64(*args))
    __swig_destroy__ = _snap.delete_TStrPool64
    def Save(self, *args):
        """
        Save(TStrPool64 self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TStrPool64_Save(self, *args)

    def New(MxBfL=0, GrowBy=16*1024*1024):
        """
        New(::TSize MxBfL=0, ::TSize GrowBy=16*1024*1024) -> PStrPool64

        Parameters:
            MxBfL: ::TSize
            GrowBy: ::TSize

        New(::TSize MxBfL=0) -> PStrPool64

        Parameters:
            MxBfL: ::TSize

        New() -> PStrPool64
        """
        return _snap.TStrPool64_New(MxBfL, GrowBy)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn, bool LoadCompact=True) -> PStrPool64

        Parameters:
            SIn: TSIn &
            LoadCompact: bool

        Load(TSIn SIn) -> PStrPool64

        Parameters:
            SIn: TSIn &

        """
        return _snap.TStrPool64_Load(*args)

    Load = staticmethod(Load)
    def GetMemUsed(self):
        """
        GetMemUsed(TStrPool64 self) -> uint64

        Parameters:
            self: TStrPool64 const *

        """
        return _snap.TStrPool64_GetMemUsed(self)

    def Empty(self):
        """
        Empty(TStrPool64 self) -> bool

        Parameters:
            self: TStrPool64 const *

        """
        return _snap.TStrPool64_Empty(self)

    def Len(self):
        """
        Len(TStrPool64 self) -> uint64

        Parameters:
            self: TStrPool64 const *

        """
        return _snap.TStrPool64_Len(self)

    def Reserved(self):
        """
        Reserved(TStrPool64 self) -> uint64

        Parameters:
            self: TStrPool64 const *

        """
        return _snap.TStrPool64_Reserved(self)

    def Clr(self, DoDel=False):
        """
        Clr(TStrPool64 self, bool DoDel=False)

        Parameters:
            DoDel: bool

        Clr(TStrPool64 self)

        Parameters:
            self: TStrPool64 *

        """
        return _snap.TStrPool64_Clr(self, DoDel)

    def Cmp(self, *args):
        """
        Cmp(TStrPool64 self, uint64 Offset, char const * Str) -> int

        Parameters:
            Offset: uint64
            Str: char const *

        """
        return _snap.TStrPool64_Cmp(self, *args)

    def AddStr(self, *args):
        """
        AddStr(TStrPool64 self, TStr Str) -> uint64

        Parameters:
            Str: TStr const &

        """
        return _snap.TStrPool64_AddStr(self, *args)

TStrPool64.Save = new_instancemethod(_snap.TStrPool64_Save,None,TStrPool64)
TStrPool64.GetMemUsed = new_instancemethod(_snap.TStrPool64_GetMemUsed,None,TStrPool64)
TStrPool64.Empty = new_instancemethod(_snap.TStrPool64_Empty,None,TStrPool64)
TStrPool64.Len = new_instancemethod(_snap.TStrPool64_Len,None,TStrPool64)
TStrPool64.Reserved = new_instancemethod(_snap.TStrPool64_Reserved,None,TStrPool64)
TStrPool64.Clr = new_instancemethod(_snap.TStrPool64_Clr,None,TStrPool64)
TStrPool64.Cmp = new_instancemethod(_snap.TStrPool64_Cmp,None,TStrPool64)
TStrPool64.AddStr = new_instancemethod(_snap.TStrPool64_AddStr,None,TStrPool64)
TStrPool64_swigregister = _snap.TStrPool64_swigregister
TStrPool64_swigregister(TStrPool64)

def TStrPool64_New(MxBfL=0, GrowBy=16*1024*1024):
  """
    New(::TSize MxBfL=0, ::TSize GrowBy=16*1024*1024) -> PStrPool64

    Parameters:
        MxBfL: ::TSize
        GrowBy: ::TSize

    New(::TSize MxBfL=0) -> PStrPool64

    Parameters:
        MxBfL: ::TSize

    TStrPool64_New() -> PStrPool64
    """
  return _snap.TStrPool64_New(MxBfL, GrowBy)

def TStrPool64_Load(*args):
  """
    Load(TSIn SIn, bool LoadCompact=True) -> PStrPool64

    Parameters:
        SIn: TSIn &
        LoadCompact: bool

    TStrPool64_Load(TSIn SIn) -> PStrPool64

    Parameters:
        SIn: TSIn &

    """
  return _snap.TStrPool64_Load(*args)

class TVoid(object):
    """Proxy of C++ TVoid class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TVoid self) -> TVoid
        __init__(TVoid self, TSIn arg2) -> TVoid

        Parameters:
            arg2: TSIn &

        """
        _snap.TVoid_swiginit(self,_snap.new_TVoid(*args))
    def Save(self, *args):
        """
        Save(TVoid self, TSOut arg2)

        Parameters:
            arg2: TSOut &

        """
        return _snap.TVoid_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TVoid self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TVoid_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TVoid self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TVoid_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TVoid self, TVoid arg2) -> bool

        Parameters:
            arg2: TVoid const &

        """
        return _snap.TVoid___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TVoid self, TVoid arg2) -> bool

        Parameters:
            arg2: TVoid const &

        """
        return _snap.TVoid___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TVoid self) -> int

        Parameters:
            self: TVoid const *

        """
        return _snap.TVoid_GetMemUsed(self)

    __swig_destroy__ = _snap.delete_TVoid
TVoid.Save = new_instancemethod(_snap.TVoid_Save,None,TVoid)
TVoid.LoadXml = new_instancemethod(_snap.TVoid_LoadXml,None,TVoid)
TVoid.SaveXml = new_instancemethod(_snap.TVoid_SaveXml,None,TVoid)
TVoid.__eq__ = new_instancemethod(_snap.TVoid___eq__,None,TVoid)
TVoid.__lt__ = new_instancemethod(_snap.TVoid___lt__,None,TVoid)
TVoid.GetMemUsed = new_instancemethod(_snap.TVoid_GetMemUsed,None,TVoid)
TVoid_swigregister = _snap.TVoid_swigregister
TVoid_swigregister(TVoid)

class TBool(object):
    """Proxy of C++ TBool class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TBool_Val_get, _snap.TBool_Val_set)
    Rnd = _swig_property(_snap.TBool_Rnd_get, _snap.TBool_Rnd_set)
    def __nonzero__(self):
        return _snap.TBool___nonzero__(self)
    __bool__ = __nonzero__


    def __init__(self, *args): 
        """
        __init__(TBool self) -> TBool
        __init__(TBool self, bool const & _Val) -> TBool

        Parameters:
            _Val: bool const &

        __init__(TBool self, TSIn SIn) -> TBool

        Parameters:
            SIn: TSIn &

        """
        _snap.TBool_swiginit(self,_snap.new_TBool(*args))
    def Load(self, *args):
        """
        Load(TBool self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TBool_Load(self, *args)

    def Save(self, *args):
        """
        Save(TBool self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TBool_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TBool self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TBool_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TBool self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TBool_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TBool self, TBool Bool) -> bool

        Parameters:
            Bool: TBool const &

        """
        return _snap.TBool___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TBool self, TBool Bool) -> bool

        Parameters:
            Bool: TBool const &

        """
        return _snap.TBool___lt__(self, *args)

    def __call__(self):
        """
        __call__(TBool self) -> bool

        Parameters:
            self: TBool const *

        """
        return _snap.TBool___call__(self)

    def GetMemUsed(self):
        """
        GetMemUsed(TBool self) -> int

        Parameters:
            self: TBool const *

        """
        return _snap.TBool_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TBool self) -> int

        Parameters:
            self: TBool const *

        """
        return _snap.TBool_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TBool self) -> int

        Parameters:
            self: TBool const *

        """
        return _snap.TBool_GetSecHashCd(self)

    def GetRnd():
        """GetRnd() -> bool"""
        return _snap.TBool_GetRnd()

    GetRnd = staticmethod(GetRnd)
    def GetYNStr(*args):
        """
        GetYNStr(bool const & Val) -> TStr

        Parameters:
            Val: bool const &

        """
        return _snap.TBool_GetYNStr(*args)

    GetYNStr = staticmethod(GetYNStr)
    def GetYesNoStr(*args):
        """
        GetYesNoStr(bool const & Val) -> TStr

        Parameters:
            Val: bool const &

        """
        return _snap.TBool_GetYesNoStr(*args)

    GetYesNoStr = staticmethod(GetYesNoStr)
    def Get01Str(*args):
        """
        Get01Str(bool const & Val) -> TStr

        Parameters:
            Val: bool const &

        """
        return _snap.TBool_Get01Str(*args)

    Get01Str = staticmethod(Get01Str)
    def IsValStr(*args):
        """
        IsValStr(TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TBool_IsValStr(*args)

    IsValStr = staticmethod(IsValStr)
    def GetValFromStr(*args):
        """
        GetValFromStr(TStr Str) -> bool

        Parameters:
            Str: TStr const &

        GetValFromStr(TStr Str, bool const & DfVal) -> bool

        Parameters:
            Str: TStr const &
            DfVal: bool const &

        """
        return _snap.TBool_GetValFromStr(*args)

    GetValFromStr = staticmethod(GetValFromStr)
    __swig_destroy__ = _snap.delete_TBool
TBool.Load = new_instancemethod(_snap.TBool_Load,None,TBool)
TBool.Save = new_instancemethod(_snap.TBool_Save,None,TBool)
TBool.LoadXml = new_instancemethod(_snap.TBool_LoadXml,None,TBool)
TBool.SaveXml = new_instancemethod(_snap.TBool_SaveXml,None,TBool)
TBool.__eq__ = new_instancemethod(_snap.TBool___eq__,None,TBool)
TBool.__lt__ = new_instancemethod(_snap.TBool___lt__,None,TBool)
TBool.__call__ = new_instancemethod(_snap.TBool___call__,None,TBool)
TBool.GetMemUsed = new_instancemethod(_snap.TBool_GetMemUsed,None,TBool)
TBool.GetPrimHashCd = new_instancemethod(_snap.TBool_GetPrimHashCd,None,TBool)
TBool.GetSecHashCd = new_instancemethod(_snap.TBool_GetSecHashCd,None,TBool)
TBool_swigregister = _snap.TBool_swigregister
TBool_swigregister(TBool)
TBool.Mn = _snap.cvar.TBool_Mn
TBool.Mx = _snap.cvar.TBool_Mx
TBool.Vals = _snap.cvar.TBool_Vals
TBool.FalseStr = _snap.cvar.TBool_FalseStr
TBool.TrueStr = _snap.cvar.TBool_TrueStr
TBool.NStr = _snap.cvar.TBool_NStr
TBool.YStr = _snap.cvar.TBool_YStr
TBool.NoStr = _snap.cvar.TBool_NoStr
TBool.YesStr = _snap.cvar.TBool_YesStr

def TBool_GetRnd():
  """TBool_GetRnd() -> bool"""
  return _snap.TBool_GetRnd()

def TBool_GetYNStr(*args):
  """
    TBool_GetYNStr(bool const & Val) -> TStr

    Parameters:
        Val: bool const &

    """
  return _snap.TBool_GetYNStr(*args)

def TBool_GetYesNoStr(*args):
  """
    TBool_GetYesNoStr(bool const & Val) -> TStr

    Parameters:
        Val: bool const &

    """
  return _snap.TBool_GetYesNoStr(*args)

def TBool_Get01Str(*args):
  """
    TBool_Get01Str(bool const & Val) -> TStr

    Parameters:
        Val: bool const &

    """
  return _snap.TBool_Get01Str(*args)

def TBool_IsValStr(*args):
  """
    TBool_IsValStr(TStr Str) -> bool

    Parameters:
        Str: TStr const &

    """
  return _snap.TBool_IsValStr(*args)

def TBool_GetValFromStr(*args):
  """
    GetValFromStr(TStr Str) -> bool

    Parameters:
        Str: TStr const &

    TBool_GetValFromStr(TStr Str, bool const & DfVal) -> bool

    Parameters:
        Str: TStr const &
        DfVal: bool const &

    """
  return _snap.TBool_GetValFromStr(*args)

class TCh(object):
    """Proxy of C++ TCh class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TCh_Val_get, _snap.TCh_Val_set)
    def __init__(self, *args): 
        """
        __init__(TCh self) -> TCh
        __init__(TCh self, char const & _Val) -> TCh

        Parameters:
            _Val: char const &

        __init__(TCh self, TSIn SIn) -> TCh

        Parameters:
            SIn: TSIn &

        """
        _snap.TCh_swiginit(self,_snap.new_TCh(*args))
    def Save(self, *args):
        """
        Save(TCh self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TCh_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TCh self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TCh_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TCh self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TCh_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TCh self, TCh Ch) -> bool

        Parameters:
            Ch: TCh const &

        """
        return _snap.TCh___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TCh self, TCh Ch) -> bool

        Parameters:
            Ch: TCh const &

        """
        return _snap.TCh___lt__(self, *args)

    def __call__(self):
        """
        __call__(TCh self) -> char

        Parameters:
            self: TCh const *

        """
        return _snap.TCh___call__(self)

    def GetMemUsed(self):
        """
        GetMemUsed(TCh self) -> int

        Parameters:
            self: TCh const *

        """
        return _snap.TCh_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TCh self) -> int

        Parameters:
            self: TCh const *

        """
        return _snap.TCh_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TCh self) -> int

        Parameters:
            self: TCh const *

        """
        return _snap.TCh_GetSecHashCd(self)

    def IsWs(*args):
        """
        IsWs(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsWs(*args)

    IsWs = staticmethod(IsWs)
    def IsAlpha(*args):
        """
        IsAlpha(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsAlpha(*args)

    IsAlpha = staticmethod(IsAlpha)
    def IsNum(*args):
        """
        IsNum(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsNum(*args)

    IsNum = staticmethod(IsNum)
    def IsAlNum(*args):
        """
        IsAlNum(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsAlNum(*args)

    IsAlNum = staticmethod(IsAlNum)
    def GetNum(*args):
        """
        GetNum(char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_GetNum(*args)

    GetNum = staticmethod(GetNum)
    def IsHex(*args):
        """
        IsHex(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsHex(*args)

    IsHex = staticmethod(IsHex)
    def GetHex(*args):
        """
        GetHex(char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_GetHex(*args)

    GetHex = staticmethod(GetHex)
    def GetHexCh(*args):
        """
        GetHexCh(int const & Val) -> char

        Parameters:
            Val: int const &

        """
        return _snap.TCh_GetHexCh(*args)

    GetHexCh = staticmethod(GetHexCh)
    def IsUc(*args):
        """
        IsUc(char const & Ch) -> char

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsUc(*args)

    IsUc = staticmethod(IsUc)
    def GetUc(*args):
        """
        GetUc(char const & Ch) -> char

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_GetUc(*args)

    GetUc = staticmethod(GetUc)
    def GetUsFromYuAscii(*args):
        """
        GetUsFromYuAscii(char const & Ch) -> char

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_GetUsFromYuAscii(*args)

    GetUsFromYuAscii = staticmethod(GetUsFromYuAscii)
    __swig_destroy__ = _snap.delete_TCh
TCh.Save = new_instancemethod(_snap.TCh_Save,None,TCh)
TCh.LoadXml = new_instancemethod(_snap.TCh_LoadXml,None,TCh)
TCh.SaveXml = new_instancemethod(_snap.TCh_SaveXml,None,TCh)
TCh.__eq__ = new_instancemethod(_snap.TCh___eq__,None,TCh)
TCh.__lt__ = new_instancemethod(_snap.TCh___lt__,None,TCh)
TCh.__call__ = new_instancemethod(_snap.TCh___call__,None,TCh)
TCh.GetMemUsed = new_instancemethod(_snap.TCh_GetMemUsed,None,TCh)
TCh.GetPrimHashCd = new_instancemethod(_snap.TCh_GetPrimHashCd,None,TCh)
TCh.GetSecHashCd = new_instancemethod(_snap.TCh_GetSecHashCd,None,TCh)
TCh_swigregister = _snap.TCh_swigregister
TCh_swigregister(TCh)
TCh.Mn = _snap.cvar.TCh_Mn
TCh.Mx = _snap.cvar.TCh_Mx
TCh.Vals = _snap.cvar.TCh_Vals
TCh.NullCh = _snap.cvar.TCh_NullCh
TCh.TabCh = _snap.cvar.TCh_TabCh
TCh.LfCh = _snap.cvar.TCh_LfCh
TCh.CrCh = _snap.cvar.TCh_CrCh
TCh.EofCh = _snap.cvar.TCh_EofCh
TCh.HashCh = _snap.cvar.TCh_HashCh

def TCh_IsWs(*args):
  """
    TCh_IsWs(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsWs(*args)

def TCh_IsAlpha(*args):
  """
    TCh_IsAlpha(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsAlpha(*args)

def TCh_IsNum(*args):
  """
    TCh_IsNum(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsNum(*args)

def TCh_IsAlNum(*args):
  """
    TCh_IsAlNum(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsAlNum(*args)

def TCh_GetNum(*args):
  """
    TCh_GetNum(char const & Ch) -> int

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_GetNum(*args)

def TCh_IsHex(*args):
  """
    TCh_IsHex(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsHex(*args)

def TCh_GetHex(*args):
  """
    TCh_GetHex(char const & Ch) -> int

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_GetHex(*args)

def TCh_GetHexCh(*args):
  """
    TCh_GetHexCh(int const & Val) -> char

    Parameters:
        Val: int const &

    """
  return _snap.TCh_GetHexCh(*args)

def TCh_IsUc(*args):
  """
    TCh_IsUc(char const & Ch) -> char

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsUc(*args)

def TCh_GetUc(*args):
  """
    TCh_GetUc(char const & Ch) -> char

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_GetUc(*args)

def TCh_GetUsFromYuAscii(*args):
  """
    TCh_GetUsFromYuAscii(char const & Ch) -> char

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_GetUsFromYuAscii(*args)

class TUCh(object):
    """Proxy of C++ TUCh class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TUCh_Val_get, _snap.TUCh_Val_set)
    def __init__(self, *args): 
        """
        __init__(TUCh self) -> TUCh
        __init__(TUCh self, uchar const & _Val) -> TUCh

        Parameters:
            _Val: uchar const &

        __init__(TUCh self, TSIn SIn) -> TUCh

        Parameters:
            SIn: TSIn &

        """
        _snap.TUCh_swiginit(self,_snap.new_TUCh(*args))
    def Save(self, *args):
        """
        Save(TUCh self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TUCh_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TUCh self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TUCh_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TUCh self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TUCh_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TUCh self, TUCh UCh) -> bool

        Parameters:
            UCh: TUCh const &

        """
        return _snap.TUCh___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TUCh self, TUCh UCh) -> bool

        Parameters:
            UCh: TUCh const &

        """
        return _snap.TUCh___lt__(self, *args)

    def __call__(self):
        """
        __call__(TUCh self) -> uchar

        Parameters:
            self: TUCh const *

        """
        return _snap.TUCh___call__(self)

    def GetMemUsed(self):
        """
        GetMemUsed(TUCh self) -> int

        Parameters:
            self: TUCh const *

        """
        return _snap.TUCh_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TUCh self) -> int

        Parameters:
            self: TUCh const *

        """
        return _snap.TUCh_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TUCh self) -> int

        Parameters:
            self: TUCh const *

        """
        return _snap.TUCh_GetSecHashCd(self)

    __swig_destroy__ = _snap.delete_TUCh
TUCh.Save = new_instancemethod(_snap.TUCh_Save,None,TUCh)
TUCh.LoadXml = new_instancemethod(_snap.TUCh_LoadXml,None,TUCh)
TUCh.SaveXml = new_instancemethod(_snap.TUCh_SaveXml,None,TUCh)
TUCh.__eq__ = new_instancemethod(_snap.TUCh___eq__,None,TUCh)
TUCh.__lt__ = new_instancemethod(_snap.TUCh___lt__,None,TUCh)
TUCh.__call__ = new_instancemethod(_snap.TUCh___call__,None,TUCh)
TUCh.GetMemUsed = new_instancemethod(_snap.TUCh_GetMemUsed,None,TUCh)
TUCh.GetPrimHashCd = new_instancemethod(_snap.TUCh_GetPrimHashCd,None,TUCh)
TUCh.GetSecHashCd = new_instancemethod(_snap.TUCh_GetSecHashCd,None,TUCh)
TUCh_swigregister = _snap.TUCh_swigregister
TUCh_swigregister(TUCh)
TUCh.Mn = _snap.cvar.TUCh_Mn
TUCh.Mx = _snap.cvar.TUCh_Mx
TUCh.Vals = _snap.cvar.TUCh_Vals

class TSInt(object):
    """Proxy of C++ TSInt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TSInt_Val_get, _snap.TSInt_Val_set)
    def __init__(self, *args): 
        """
        __init__(TSInt self) -> TSInt
        __init__(TSInt self, int16 const & _Val) -> TSInt

        Parameters:
            _Val: int16 const &

        __init__(TSInt self, TSIn SIn) -> TSInt

        Parameters:
            SIn: TSIn &

        """
        _snap.TSInt_swiginit(self,_snap.new_TSInt(*args))
    def Load(self, *args):
        """
        Load(TSInt self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TSInt_Load(self, *args)

    def Save(self, *args):
        """
        Save(TSInt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TSInt_Save(self, *args)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TSInt self) -> int

        Parameters:
            self: TSInt const *

        """
        return _snap.TSInt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TSInt self) -> int

        Parameters:
            self: TSInt const *

        """
        return _snap.TSInt_GetSecHashCd(self)

    __swig_destroy__ = _snap.delete_TSInt
TSInt.Load = new_instancemethod(_snap.TSInt_Load,None,TSInt)
TSInt.Save = new_instancemethod(_snap.TSInt_Save,None,TSInt)
TSInt.GetPrimHashCd = new_instancemethod(_snap.TSInt_GetPrimHashCd,None,TSInt)
TSInt.GetSecHashCd = new_instancemethod(_snap.TSInt_GetSecHashCd,None,TSInt)
TSInt_swigregister = _snap.TSInt_swigregister
TSInt_swigregister(TSInt)

class TInt(object):
    """Proxy of C++ TInt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TInt_Val_get, _snap.TInt_Val_set)
    Rnd = _swig_property(_snap.TInt_Rnd_get, _snap.TInt_Rnd_set)
    def __init__(self, *args): 
        """
        __init__(TInt self) -> TInt
        __init__(TInt self, int const & _Val) -> TInt

        Parameters:
            _Val: int const &

        __init__(TInt self, TSIn SIn) -> TInt

        Parameters:
            SIn: TSIn &

        """
        _snap.TInt_swiginit(self,_snap.new_TInt(*args))
    def Load(self, *args):
        """
        Load(TInt self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TInt_Load(self, *args)

    def Save(self, *args):
        """
        Save(TInt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TInt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TInt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TInt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TInt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TInt_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TInt self, TInt Int) -> bool

        Parameters:
            Int: TInt const &

        __eq__(TInt self, int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TInt self, int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TInt self, TInt Int) -> bool

        Parameters:
            Int: TInt const &

        __lt__(TInt self, int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt___lt__(self, *args)

    def __call__(self):
        """
        __call__(TInt self) -> int

        Parameters:
            self: TInt const *

        """
        return _snap.TInt___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TInt self, int const & Int) -> TInt

        Parameters:
            Int: int const &

        """
        return _snap.TInt___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TInt self, int const & Int) -> TInt

        Parameters:
            Int: int const &

        """
        return _snap.TInt___isub__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TInt self) -> int

        Parameters:
            self: TInt const *

        """
        return _snap.TInt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TInt self) -> int

        Parameters:
            self: TInt const *

        """
        return _snap.TInt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TInt self) -> int

        Parameters:
            self: TInt const *

        """
        return _snap.TInt_GetSecHashCd(self)

    def Abs(*args):
        """
        Abs(int const & Int) -> int

        Parameters:
            Int: int const &

        """
        return _snap.TInt_Abs(*args)

    Abs = staticmethod(Abs)
    def Sign(*args):
        """
        Sign(int const & Int) -> int

        Parameters:
            Int: int const &

        """
        return _snap.TInt_Sign(*args)

    Sign = staticmethod(Sign)
    def Swap(*args):
        """
        Swap(int & Int1, int & Int2)

        Parameters:
            Int1: int &
            Int2: int &

        """
        return _snap.TInt_Swap(*args)

    Swap = staticmethod(Swap)
    def GetRnd(Range=0):
        """
        GetRnd(int const & Range=0) -> int

        Parameters:
            Range: int const &

        GetRnd() -> int
        """
        return _snap.TInt_GetRnd(Range)

    GetRnd = staticmethod(GetRnd)
    def IsOdd(*args):
        """
        IsOdd(int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt_IsOdd(*args)

    IsOdd = staticmethod(IsOdd)
    def IsEven(*args):
        """
        IsEven(int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt_IsEven(*args)

    IsEven = staticmethod(IsEven)
    def GetMn(*args):
        """
        GetMn(int const & Int1, int const & Int2) -> int

        Parameters:
            Int1: int const &
            Int2: int const &

        GetMn(int const & Int1, int const & Int2, int const & Int3) -> int

        Parameters:
            Int1: int const &
            Int2: int const &
            Int3: int const &

        GetMn(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int

        Parameters:
            Int1: int const &
            Int2: int const &
            Int3: int const &
            Int4: int const &

        """
        return _snap.TInt_GetMn(*args)

    GetMn = staticmethod(GetMn)
    def GetMx(*args):
        """
        GetMx(int const & Int1, int const & Int2) -> int

        Parameters:
            Int1: int const &
            Int2: int const &

        GetMx(int const & Int1, int const & Int2, int const & Int3) -> int

        Parameters:
            Int1: int const &
            Int2: int const &
            Int3: int const &

        GetMx(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int

        Parameters:
            Int1: int const &
            Int2: int const &
            Int3: int const &
            Int4: int const &

        """
        return _snap.TInt_GetMx(*args)

    GetMx = staticmethod(GetMx)
    def GetInRng(*args):
        """
        GetInRng(int const & Val, int const & Mn, int const & Mx) -> int

        Parameters:
            Val: int const &
            Mn: int const &
            Mx: int const &

        """
        return _snap.TInt_GetInRng(*args)

    GetInRng = staticmethod(GetInRng)
    def GetHexStr(*args):
        """
        GetHexStr(int const & Val) -> TStr

        Parameters:
            Val: int const &

        GetHexStr(TInt Int) -> TStr

        Parameters:
            Int: TInt const &

        """
        return _snap.TInt_GetHexStr(*args)

    GetHexStr = staticmethod(GetHexStr)
    def GetKiloStr(*args):
        """
        GetKiloStr(int const & Val) -> TStr

        Parameters:
            Val: int const &

        """
        return _snap.TInt_GetKiloStr(*args)

    GetKiloStr = staticmethod(GetKiloStr)
    def GetMegaStr(*args):
        """
        GetMegaStr(int const & Val) -> TStr

        Parameters:
            Val: int const &

        """
        return _snap.TInt_GetMegaStr(*args)

    GetMegaStr = staticmethod(GetMegaStr)
    def SaveFrugalInt(*args):
        """
        SaveFrugalInt(char * pDest, int i) -> char *

        Parameters:
            pDest: char *
            i: int

        """
        return _snap.TInt_SaveFrugalInt(*args)

    SaveFrugalInt = staticmethod(SaveFrugalInt)
    def LoadFrugalInt(*args):
        """
        LoadFrugalInt(char * pSrc, int & i) -> char *

        Parameters:
            pSrc: char *
            i: int &

        """
        return _snap.TInt_LoadFrugalInt(*args)

    LoadFrugalInt = staticmethod(LoadFrugalInt)
    def TestFrugalInt():
        """TestFrugalInt()"""
        return _snap.TInt_TestFrugalInt()

    TestFrugalInt = staticmethod(TestFrugalInt)
    def SaveFrugalIntV(*args):
        """
        SaveFrugalIntV(TSOut SOut, TIntV IntV)

        Parameters:
            SOut: TSOut &
            IntV: TVec< TInt,int > const &

        """
        return _snap.TInt_SaveFrugalIntV(*args)

    SaveFrugalIntV = staticmethod(SaveFrugalIntV)
    def LoadFrugalIntV(*args):
        """
        LoadFrugalIntV(TSIn SIn, TIntV IntV, bool ClrP=True)

        Parameters:
            SIn: TSIn &
            IntV: TVec< TInt,int > &
            ClrP: bool

        LoadFrugalIntV(TSIn SIn, TIntV IntV)

        Parameters:
            SIn: TSIn &
            IntV: TVec< TInt,int > &

        """
        return _snap.TInt_LoadFrugalIntV(*args)

    LoadFrugalIntV = staticmethod(LoadFrugalIntV)
    __swig_destroy__ = _snap.delete_TInt
TInt.Load = new_instancemethod(_snap.TInt_Load,None,TInt)
TInt.Save = new_instancemethod(_snap.TInt_Save,None,TInt)
TInt.LoadXml = new_instancemethod(_snap.TInt_LoadXml,None,TInt)
TInt.SaveXml = new_instancemethod(_snap.TInt_SaveXml,None,TInt)
TInt.__eq__ = new_instancemethod(_snap.TInt___eq__,None,TInt)
TInt.__ne__ = new_instancemethod(_snap.TInt___ne__,None,TInt)
TInt.__lt__ = new_instancemethod(_snap.TInt___lt__,None,TInt)
TInt.__call__ = new_instancemethod(_snap.TInt___call__,None,TInt)
TInt.__iadd__ = new_instancemethod(_snap.TInt___iadd__,None,TInt)
TInt.__isub__ = new_instancemethod(_snap.TInt___isub__,None,TInt)
TInt.GetMemUsed = new_instancemethod(_snap.TInt_GetMemUsed,None,TInt)
TInt.GetPrimHashCd = new_instancemethod(_snap.TInt_GetPrimHashCd,None,TInt)
TInt.GetSecHashCd = new_instancemethod(_snap.TInt_GetSecHashCd,None,TInt)
TInt_swigregister = _snap.TInt_swigregister
TInt_swigregister(TInt)
TInt.Mn = _snap.cvar.TInt_Mn
TInt.Mx = _snap.cvar.TInt_Mx
TInt.Kilo = _snap.cvar.TInt_Kilo
TInt.Mega = _snap.cvar.TInt_Mega
TInt.Giga = _snap.cvar.TInt_Giga

def TInt_Abs(*args):
  """
    TInt_Abs(int const & Int) -> int

    Parameters:
        Int: int const &

    """
  return _snap.TInt_Abs(*args)

def TInt_Sign(*args):
  """
    TInt_Sign(int const & Int) -> int

    Parameters:
        Int: int const &

    """
  return _snap.TInt_Sign(*args)

def TInt_Swap(*args):
  """
    TInt_Swap(int & Int1, int & Int2)

    Parameters:
        Int1: int &
        Int2: int &

    """
  return _snap.TInt_Swap(*args)

def TInt_GetRnd(Range=0):
  """
    GetRnd(int const & Range=0) -> int

    Parameters:
        Range: int const &

    TInt_GetRnd() -> int
    """
  return _snap.TInt_GetRnd(Range)

def TInt_IsOdd(*args):
  """
    TInt_IsOdd(int const & Int) -> bool

    Parameters:
        Int: int const &

    """
  return _snap.TInt_IsOdd(*args)

def TInt_IsEven(*args):
  """
    TInt_IsEven(int const & Int) -> bool

    Parameters:
        Int: int const &

    """
  return _snap.TInt_IsEven(*args)

def TInt_GetMn(*args):
  """
    GetMn(int const & Int1, int const & Int2) -> int

    Parameters:
        Int1: int const &
        Int2: int const &

    GetMn(int const & Int1, int const & Int2, int const & Int3) -> int

    Parameters:
        Int1: int const &
        Int2: int const &
        Int3: int const &

    TInt_GetMn(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int

    Parameters:
        Int1: int const &
        Int2: int const &
        Int3: int const &
        Int4: int const &

    """
  return _snap.TInt_GetMn(*args)

def TInt_GetMx(*args):
  """
    GetMx(int const & Int1, int const & Int2) -> int

    Parameters:
        Int1: int const &
        Int2: int const &

    GetMx(int const & Int1, int const & Int2, int const & Int3) -> int

    Parameters:
        Int1: int const &
        Int2: int const &
        Int3: int const &

    TInt_GetMx(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int

    Parameters:
        Int1: int const &
        Int2: int const &
        Int3: int const &
        Int4: int const &

    """
  return _snap.TInt_GetMx(*args)

def TInt_GetInRng(*args):
  """
    TInt_GetInRng(int const & Val, int const & Mn, int const & Mx) -> int

    Parameters:
        Val: int const &
        Mn: int const &
        Mx: int const &

    """
  return _snap.TInt_GetInRng(*args)

def TInt_GetHexStr(*args):
  """
    GetHexStr(int const & Val) -> TStr

    Parameters:
        Val: int const &

    TInt_GetHexStr(TInt Int) -> TStr

    Parameters:
        Int: TInt const &

    """
  return _snap.TInt_GetHexStr(*args)

def TInt_GetKiloStr(*args):
  """
    TInt_GetKiloStr(int const & Val) -> TStr

    Parameters:
        Val: int const &

    """
  return _snap.TInt_GetKiloStr(*args)

def TInt_GetMegaStr(*args):
  """
    TInt_GetMegaStr(int const & Val) -> TStr

    Parameters:
        Val: int const &

    """
  return _snap.TInt_GetMegaStr(*args)

def TInt_SaveFrugalInt(*args):
  """
    TInt_SaveFrugalInt(char * pDest, int i) -> char *

    Parameters:
        pDest: char *
        i: int

    """
  return _snap.TInt_SaveFrugalInt(*args)

def TInt_LoadFrugalInt(*args):
  """
    TInt_LoadFrugalInt(char * pSrc, int & i) -> char *

    Parameters:
        pSrc: char *
        i: int &

    """
  return _snap.TInt_LoadFrugalInt(*args)

def TInt_TestFrugalInt():
  """TInt_TestFrugalInt()"""
  return _snap.TInt_TestFrugalInt()

def TInt_SaveFrugalIntV(*args):
  """
    TInt_SaveFrugalIntV(TSOut SOut, TIntV IntV)

    Parameters:
        SOut: TSOut &
        IntV: TVec< TInt,int > const &

    """
  return _snap.TInt_SaveFrugalIntV(*args)

def TInt_LoadFrugalIntV(*args):
  """
    LoadFrugalIntV(TSIn SIn, TIntV IntV, bool ClrP=True)

    Parameters:
        SIn: TSIn &
        IntV: TVec< TInt,int > &
        ClrP: bool

    TInt_LoadFrugalIntV(TSIn SIn, TIntV IntV)

    Parameters:
        SIn: TSIn &
        IntV: TVec< TInt,int > &

    """
  return _snap.TInt_LoadFrugalIntV(*args)

class TUInt(object):
    """Proxy of C++ TUInt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TUInt_Val_get, _snap.TUInt_Val_set)
    Rnd = _swig_property(_snap.TUInt_Rnd_get, _snap.TUInt_Rnd_set)
    def __init__(self, *args): 
        """
        __init__(TUInt self) -> TUInt
        __init__(TUInt self, uint const & _Val) -> TUInt

        Parameters:
            _Val: uint const &

        __init__(TUInt self, TSIn SIn) -> TUInt

        Parameters:
            SIn: TSIn &

        """
        _snap.TUInt_swiginit(self,_snap.new_TUInt(*args))
    def Load(self, *args):
        """
        Load(TUInt self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TUInt_Load(self, *args)

    def Save(self, *args):
        """
        Save(TUInt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TUInt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TUInt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TUInt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TUInt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TUInt_SaveXml(self, *args)

    def __call__(self, *args):
        """
        __call__(TUInt self) -> uint
        __call__(TUInt self) -> uint &

        Parameters:
            self: TUInt *

        """
        return _snap.TUInt___call__(self, *args)

    def __invert__(self):
        """
        __invert__(TUInt self) -> TUInt

        Parameters:
            self: TUInt *

        """
        return _snap.TUInt___invert__(self)

    def __iand__(self, *args):
        """
        __iand__(TUInt self, TUInt UInt) -> TUInt

        Parameters:
            UInt: TUInt const &

        """
        return _snap.TUInt___iand__(self, *args)

    def __ior__(self, *args):
        """
        __ior__(TUInt self, TUInt UInt) -> TUInt

        Parameters:
            UInt: TUInt const &

        """
        return _snap.TUInt___ior__(self, *args)

    def __ixor__(self, *args):
        """
        __ixor__(TUInt self, TUInt UInt) -> TUInt

        Parameters:
            UInt: TUInt const &

        """
        return _snap.TUInt___ixor__(self, *args)

    def __irshift__(self, *args):
        """
        __irshift__(TUInt self, int const & ShiftBits) -> TUInt

        Parameters:
            ShiftBits: int const &

        """
        return _snap.TUInt___irshift__(self, *args)

    def __ilshift__(self, *args):
        """
        __ilshift__(TUInt self, int const & ShiftBits) -> TUInt

        Parameters:
            ShiftBits: int const &

        """
        return _snap.TUInt___ilshift__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TUInt self) -> int

        Parameters:
            self: TUInt const *

        """
        return _snap.TUInt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TUInt self) -> int

        Parameters:
            self: TUInt const *

        """
        return _snap.TUInt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TUInt self) -> int

        Parameters:
            self: TUInt const *

        """
        return _snap.TUInt_GetSecHashCd(self)

    def GetRnd(Range=0):
        """
        GetRnd(uint const & Range=0) -> uint

        Parameters:
            Range: uint const &

        GetRnd() -> uint
        """
        return _snap.TUInt_GetRnd(Range)

    GetRnd = staticmethod(GetRnd)
    def GetKiloStr(*args):
        """
        GetKiloStr(uint const & Val) -> TStr

        Parameters:
            Val: uint const &

        """
        return _snap.TUInt_GetKiloStr(*args)

    GetKiloStr = staticmethod(GetKiloStr)
    def GetMegaStr(*args):
        """
        GetMegaStr(uint const & Val) -> TStr

        Parameters:
            Val: uint const &

        """
        return _snap.TUInt_GetMegaStr(*args)

    GetMegaStr = staticmethod(GetMegaStr)
    def JavaUIntToCppUInt(*args):
        """
        JavaUIntToCppUInt(uint const & JavaUInt) -> uint

        Parameters:
            JavaUInt: uint const &

        """
        return _snap.TUInt_JavaUIntToCppUInt(*args)

    JavaUIntToCppUInt = staticmethod(JavaUIntToCppUInt)
    def IsIpStr(*args):
        """
        IsIpStr(TStr IpStr, uint & Ip, char const & SplitCh='.') -> bool

        Parameters:
            IpStr: TStr const &
            Ip: uint &
            SplitCh: char const &

        IsIpStr(TStr IpStr, uint & Ip) -> bool

        Parameters:
            IpStr: TStr const &
            Ip: uint &

        IsIpStr(TStr IpStr, char const & SplitCh='.') -> bool

        Parameters:
            IpStr: TStr const &
            SplitCh: char const &

        IsIpStr(TStr IpStr) -> bool

        Parameters:
            IpStr: TStr const &

        """
        return _snap.TUInt_IsIpStr(*args)

    IsIpStr = staticmethod(IsIpStr)
    def GetUIntFromIpStr(*args):
        """
        GetUIntFromIpStr(TStr IpStr, char const & SplitCh='.') -> uint

        Parameters:
            IpStr: TStr const &
            SplitCh: char const &

        GetUIntFromIpStr(TStr IpStr) -> uint

        Parameters:
            IpStr: TStr const &

        """
        return _snap.TUInt_GetUIntFromIpStr(*args)

    GetUIntFromIpStr = staticmethod(GetUIntFromIpStr)
    def GetStrFromIpUInt(*args):
        """
        GetStrFromIpUInt(uint const & Ip) -> TStr

        Parameters:
            Ip: uint const &

        """
        return _snap.TUInt_GetStrFromIpUInt(*args)

    GetStrFromIpUInt = staticmethod(GetStrFromIpUInt)
    def IsIpv6Str(*args):
        """
        IsIpv6Str(TStr IpStr, char const & SplitCh=':') -> bool

        Parameters:
            IpStr: TStr const &
            SplitCh: char const &

        IsIpv6Str(TStr IpStr) -> bool

        Parameters:
            IpStr: TStr const &

        """
        return _snap.TUInt_IsIpv6Str(*args)

    IsIpv6Str = staticmethod(IsIpv6Str)
    __swig_destroy__ = _snap.delete_TUInt
TUInt.Load = new_instancemethod(_snap.TUInt_Load,None,TUInt)
TUInt.Save = new_instancemethod(_snap.TUInt_Save,None,TUInt)
TUInt.LoadXml = new_instancemethod(_snap.TUInt_LoadXml,None,TUInt)
TUInt.SaveXml = new_instancemethod(_snap.TUInt_SaveXml,None,TUInt)
TUInt.__call__ = new_instancemethod(_snap.TUInt___call__,None,TUInt)
TUInt.__invert__ = new_instancemethod(_snap.TUInt___invert__,None,TUInt)
TUInt.__iand__ = new_instancemethod(_snap.TUInt___iand__,None,TUInt)
TUInt.__ior__ = new_instancemethod(_snap.TUInt___ior__,None,TUInt)
TUInt.__ixor__ = new_instancemethod(_snap.TUInt___ixor__,None,TUInt)
TUInt.__irshift__ = new_instancemethod(_snap.TUInt___irshift__,None,TUInt)
TUInt.__ilshift__ = new_instancemethod(_snap.TUInt___ilshift__,None,TUInt)
TUInt.GetMemUsed = new_instancemethod(_snap.TUInt_GetMemUsed,None,TUInt)
TUInt.GetPrimHashCd = new_instancemethod(_snap.TUInt_GetPrimHashCd,None,TUInt)
TUInt.GetSecHashCd = new_instancemethod(_snap.TUInt_GetSecHashCd,None,TUInt)
TUInt_swigregister = _snap.TUInt_swigregister
TUInt_swigregister(TUInt)
TUInt.Mn = _snap.cvar.TUInt_Mn
TUInt.Mx = _snap.cvar.TUInt_Mx

def TUInt_GetRnd(Range=0):
  """
    GetRnd(uint const & Range=0) -> uint

    Parameters:
        Range: uint const &

    TUInt_GetRnd() -> uint
    """
  return _snap.TUInt_GetRnd(Range)

def TUInt_GetKiloStr(*args):
  """
    TUInt_GetKiloStr(uint const & Val) -> TStr

    Parameters:
        Val: uint const &

    """
  return _snap.TUInt_GetKiloStr(*args)

def TUInt_GetMegaStr(*args):
  """
    TUInt_GetMegaStr(uint const & Val) -> TStr

    Parameters:
        Val: uint const &

    """
  return _snap.TUInt_GetMegaStr(*args)

def TUInt_JavaUIntToCppUInt(*args):
  """
    TUInt_JavaUIntToCppUInt(uint const & JavaUInt) -> uint

    Parameters:
        JavaUInt: uint const &

    """
  return _snap.TUInt_JavaUIntToCppUInt(*args)

def TUInt_IsIpStr(*args):
  """
    IsIpStr(TStr IpStr, uint & Ip, char const & SplitCh='.') -> bool

    Parameters:
        IpStr: TStr const &
        Ip: uint &
        SplitCh: char const &

    IsIpStr(TStr IpStr, uint & Ip) -> bool

    Parameters:
        IpStr: TStr const &
        Ip: uint &

    IsIpStr(TStr IpStr, char const & SplitCh='.') -> bool

    Parameters:
        IpStr: TStr const &
        SplitCh: char const &

    TUInt_IsIpStr(TStr IpStr) -> bool

    Parameters:
        IpStr: TStr const &

    """
  return _snap.TUInt_IsIpStr(*args)

def TUInt_GetUIntFromIpStr(*args):
  """
    GetUIntFromIpStr(TStr IpStr, char const & SplitCh='.') -> uint

    Parameters:
        IpStr: TStr const &
        SplitCh: char const &

    TUInt_GetUIntFromIpStr(TStr IpStr) -> uint

    Parameters:
        IpStr: TStr const &

    """
  return _snap.TUInt_GetUIntFromIpStr(*args)

def TUInt_GetStrFromIpUInt(*args):
  """
    TUInt_GetStrFromIpUInt(uint const & Ip) -> TStr

    Parameters:
        Ip: uint const &

    """
  return _snap.TUInt_GetStrFromIpUInt(*args)

def TUInt_IsIpv6Str(*args):
  """
    IsIpv6Str(TStr IpStr, char const & SplitCh=':') -> bool

    Parameters:
        IpStr: TStr const &
        SplitCh: char const &

    TUInt_IsIpv6Str(TStr IpStr) -> bool

    Parameters:
        IpStr: TStr const &

    """
  return _snap.TUInt_IsIpv6Str(*args)

class TUInt64(object):
    """Proxy of C++ TUInt64 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TUInt64_Val_get, _snap.TUInt64_Val_set)
    def __init__(self, *args): 
        """
        __init__(TUInt64 self) -> TUInt64
        __init__(TUInt64 self, TUInt64 Int) -> TUInt64

        Parameters:
            Int: TUInt64 const &

        __init__(TUInt64 self, uint64 const & Int) -> TUInt64

        Parameters:
            Int: uint64 const &

        __init__(TUInt64 self, uint const & MsVal, uint const & LsVal) -> TUInt64

        Parameters:
            MsVal: uint const &
            LsVal: uint const &

        __init__(TUInt64 self, void * Pt) -> TUInt64

        Parameters:
            Pt: void *

        __init__(TUInt64 self, TSIn SIn) -> TUInt64

        Parameters:
            SIn: TSIn &

        """
        _snap.TUInt64_swiginit(self,_snap.new_TUInt64(*args))
    def Load(self, *args):
        """
        Load(TUInt64 self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TUInt64_Load(self, *args)

    def Save(self, *args):
        """
        Save(TUInt64 self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TUInt64_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TUInt64 self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TUInt64_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TUInt64 self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TUInt64_SaveXml(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(TUInt64 self, TUInt64 Int) -> TUInt64

        Parameters:
            Int: TUInt64 const &

        """
        return _snap.TUInt64___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TUInt64 self, TUInt64 Int) -> TUInt64

        Parameters:
            Int: TUInt64 const &

        """
        return _snap.TUInt64___isub__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TUInt64 self) -> int

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TUInt64 self) -> int

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TUInt64 self) -> int

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetSecHashCd(self)

    def GetMsVal(self):
        """
        GetMsVal(TUInt64 self) -> uint

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetMsVal(self)

    def GetLsVal(self):
        """
        GetLsVal(TUInt64 self) -> uint

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetLsVal(self)

    def GetHexStr(*args):
        """
        GetHexStr(TUInt64 Int) -> TStr

        Parameters:
            Int: TUInt64 const &

        """
        return _snap.TUInt64_GetHexStr(*args)

    GetHexStr = staticmethod(GetHexStr)
    def GetKiloStr(*args):
        """
        GetKiloStr(uint64 const & Val) -> TStr

        Parameters:
            Val: uint64 const &

        """
        return _snap.TUInt64_GetKiloStr(*args)

    GetKiloStr = staticmethod(GetKiloStr)
    def GetMegaStr(*args):
        """
        GetMegaStr(uint64 const & Val) -> TStr

        Parameters:
            Val: uint64 const &

        """
        return _snap.TUInt64_GetMegaStr(*args)

    GetMegaStr = staticmethod(GetMegaStr)
    __swig_destroy__ = _snap.delete_TUInt64
TUInt64.Load = new_instancemethod(_snap.TUInt64_Load,None,TUInt64)
TUInt64.Save = new_instancemethod(_snap.TUInt64_Save,None,TUInt64)
TUInt64.LoadXml = new_instancemethod(_snap.TUInt64_LoadXml,None,TUInt64)
TUInt64.SaveXml = new_instancemethod(_snap.TUInt64_SaveXml,None,TUInt64)
TUInt64.__iadd__ = new_instancemethod(_snap.TUInt64___iadd__,None,TUInt64)
TUInt64.__isub__ = new_instancemethod(_snap.TUInt64___isub__,None,TUInt64)
TUInt64.GetMemUsed = new_instancemethod(_snap.TUInt64_GetMemUsed,None,TUInt64)
TUInt64.GetPrimHashCd = new_instancemethod(_snap.TUInt64_GetPrimHashCd,None,TUInt64)
TUInt64.GetSecHashCd = new_instancemethod(_snap.TUInt64_GetSecHashCd,None,TUInt64)
TUInt64.GetMsVal = new_instancemethod(_snap.TUInt64_GetMsVal,None,TUInt64)
TUInt64.GetLsVal = new_instancemethod(_snap.TUInt64_GetLsVal,None,TUInt64)
TUInt64_swigregister = _snap.TUInt64_swigregister
TUInt64_swigregister(TUInt64)
TUInt64.Mn = _snap.cvar.TUInt64_Mn
TUInt64.Mx = _snap.cvar.TUInt64_Mx

def TUInt64_GetHexStr(*args):
  """
    TUInt64_GetHexStr(TUInt64 Int) -> TStr

    Parameters:
        Int: TUInt64 const &

    """
  return _snap.TUInt64_GetHexStr(*args)

def TUInt64_GetKiloStr(*args):
  """
    TUInt64_GetKiloStr(uint64 const & Val) -> TStr

    Parameters:
        Val: uint64 const &

    """
  return _snap.TUInt64_GetKiloStr(*args)

def TUInt64_GetMegaStr(*args):
  """
    TUInt64_GetMegaStr(uint64 const & Val) -> TStr

    Parameters:
        Val: uint64 const &

    """
  return _snap.TUInt64_GetMegaStr(*args)

class TFlt(object):
    """Proxy of C++ TFlt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TFlt_Val_get, _snap.TFlt_Val_set)
    Rnd = _swig_property(_snap.TFlt_Rnd_get, _snap.TFlt_Rnd_set)
    def __init__(self, *args): 
        """
        __init__(TFlt self) -> TFlt
        __init__(TFlt self, double const & _Val) -> TFlt

        Parameters:
            _Val: double const &

        __init__(TFlt self, TSIn SIn) -> TFlt

        Parameters:
            SIn: TSIn &

        __init__(TFlt self, TSIn SIn, bool const & IsTxt) -> TFlt

        Parameters:
            SIn: TSIn &
            IsTxt: bool const &

        """
        _snap.TFlt_swiginit(self,_snap.new_TFlt(*args))
    def Load(self, *args):
        """
        Load(TFlt self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TFlt_Load(self, *args)

    def Save(self, *args):
        """
        Save(TFlt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        Save(TFlt self, TSOut SOut, bool const & IsTxt)

        Parameters:
            SOut: TSOut &
            IsTxt: bool const &

        """
        return _snap.TFlt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TFlt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TFlt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TFlt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TFlt_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TFlt self, TFlt Flt) -> bool

        Parameters:
            Flt: TFlt const &

        __eq__(TFlt self, double const & Flt) -> bool

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TFlt self, double const & Flt) -> bool

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___ne__(self, *args)

    def __call__(self):
        """
        __call__(TFlt self) -> double

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TFlt self, double const & Flt) -> TFlt

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TFlt self, double const & Flt) -> TFlt

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___isub__(self, *args)

    def __imul__(self, *args):
        """
        __imul__(TFlt self, double const & Flt) -> TFlt

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(TFlt self, double const & Flt) -> TFlt

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___idiv__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TFlt self) -> int

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TFlt self) -> int

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TFlt self) -> int

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_GetSecHashCd(self)

    def Abs(*args):
        """
        Abs(double const & Flt) -> double

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt_Abs(*args)

    Abs = staticmethod(Abs)
    def Sign(*args):
        """
        Sign(double const & Flt) -> int

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt_Sign(*args)

    Sign = staticmethod(Sign)
    def Round(*args):
        """
        Round(double const & Flt) -> int

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt_Round(*args)

    Round = staticmethod(Round)
    def GetRnd():
        """GetRnd() -> double"""
        return _snap.TFlt_GetRnd()

    GetRnd = staticmethod(GetRnd)
    def Eq6(*args):
        """
        Eq6(double const & LFlt, double const & RFlt) -> bool

        Parameters:
            LFlt: double const &
            RFlt: double const &

        """
        return _snap.TFlt_Eq6(*args)

    Eq6 = staticmethod(Eq6)
    def GetMn(*args):
        """
        GetMn(double const & Flt1, double const & Flt2) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &

        GetMn(double const & Flt1, double const & Flt2, double const & Flt3) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &
            Flt3: double const &

        GetMn(double const & Flt1, double const & Flt2, double const & Flt3, double const & Flt4) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &
            Flt3: double const &
            Flt4: double const &

        """
        return _snap.TFlt_GetMn(*args)

    GetMn = staticmethod(GetMn)
    def GetMx(*args):
        """
        GetMx(double const & Flt1, double const & Flt2) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &

        GetMx(double const & Flt1, double const & Flt2, double const Flt3) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &
            Flt3: double const

        GetMx(double const & Flt1, double const & Flt2, double const Flt3, double const & Flt4) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &
            Flt3: double const
            Flt4: double const &

        """
        return _snap.TFlt_GetMx(*args)

    GetMx = staticmethod(GetMx)
    def GetInRng(*args):
        """
        GetInRng(double const & Val, double const & Mn, double const & Mx) -> double

        Parameters:
            Val: double const &
            Mn: double const &
            Mx: double const &

        """
        return _snap.TFlt_GetInRng(*args)

    GetInRng = staticmethod(GetInRng)
    def IsNum(self, *args):
        """
        IsNum(TFlt self, double const & Val) -> bool

        Parameters:
            Val: double const &

        IsNum(TFlt self) -> bool

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_IsNum(self, *args)

    def IsNan(self, *args):
        """
        IsNan(TFlt self, double const & Val) -> bool

        Parameters:
            Val: double const &

        IsNan(TFlt self) -> bool

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_IsNan(self, *args)

    def GetPrcStr(*args):
        """
        GetPrcStr(double const & RelVal, double const & FullVal) -> TStr

        Parameters:
            RelVal: double const &
            FullVal: double const &

        """
        return _snap.TFlt_GetPrcStr(*args)

    GetPrcStr = staticmethod(GetPrcStr)
    def GetKiloStr(*args):
        """
        GetKiloStr(double const & Val) -> TStr

        Parameters:
            Val: double const &

        """
        return _snap.TFlt_GetKiloStr(*args)

    GetKiloStr = staticmethod(GetKiloStr)
    def GetMegaStr(*args):
        """
        GetMegaStr(double const & Val) -> TStr

        Parameters:
            Val: double const &

        """
        return _snap.TFlt_GetMegaStr(*args)

    GetMegaStr = staticmethod(GetMegaStr)
    def GetGigaStr(*args):
        """
        GetGigaStr(double const & Val) -> TStr

        Parameters:
            Val: double const &

        """
        return _snap.TFlt_GetGigaStr(*args)

    GetGigaStr = staticmethod(GetGigaStr)
    __swig_destroy__ = _snap.delete_TFlt
TFlt.Load = new_instancemethod(_snap.TFlt_Load,None,TFlt)
TFlt.Save = new_instancemethod(_snap.TFlt_Save,None,TFlt)
TFlt.LoadXml = new_instancemethod(_snap.TFlt_LoadXml,None,TFlt)
TFlt.SaveXml = new_instancemethod(_snap.TFlt_SaveXml,None,TFlt)
TFlt.__eq__ = new_instancemethod(_snap.TFlt___eq__,None,TFlt)
TFlt.__ne__ = new_instancemethod(_snap.TFlt___ne__,None,TFlt)
TFlt.__call__ = new_instancemethod(_snap.TFlt___call__,None,TFlt)
TFlt.__iadd__ = new_instancemethod(_snap.TFlt___iadd__,None,TFlt)
TFlt.__isub__ = new_instancemethod(_snap.TFlt___isub__,None,TFlt)
TFlt.__imul__ = new_instancemethod(_snap.TFlt___imul__,None,TFlt)
TFlt.__idiv__ = new_instancemethod(_snap.TFlt___idiv__,None,TFlt)
TFlt.GetMemUsed = new_instancemethod(_snap.TFlt_GetMemUsed,None,TFlt)
TFlt.GetPrimHashCd = new_instancemethod(_snap.TFlt_GetPrimHashCd,None,TFlt)
TFlt.GetSecHashCd = new_instancemethod(_snap.TFlt_GetSecHashCd,None,TFlt)
TFlt.IsNum = new_instancemethod(_snap.TFlt_IsNum,None,TFlt)
TFlt.IsNan = new_instancemethod(_snap.TFlt_IsNan,None,TFlt)
TFlt_swigregister = _snap.TFlt_swigregister
TFlt_swigregister(TFlt)
TFlt.Mn = _snap.cvar.TFlt_Mn
TFlt.Mx = _snap.cvar.TFlt_Mx
TFlt.NInf = _snap.cvar.TFlt_NInf
TFlt.PInf = _snap.cvar.TFlt_PInf
TFlt.Eps = _snap.cvar.TFlt_Eps
TFlt.EpsHalf = _snap.cvar.TFlt_EpsHalf

def TFlt_Abs(*args):
  """
    TFlt_Abs(double const & Flt) -> double

    Parameters:
        Flt: double const &

    """
  return _snap.TFlt_Abs(*args)

def TFlt_Sign(*args):
  """
    TFlt_Sign(double const & Flt) -> int

    Parameters:
        Flt: double const &

    """
  return _snap.TFlt_Sign(*args)

def TFlt_Round(*args):
  """
    TFlt_Round(double const & Flt) -> int

    Parameters:
        Flt: double const &

    """
  return _snap.TFlt_Round(*args)

def TFlt_GetRnd():
  """TFlt_GetRnd() -> double"""
  return _snap.TFlt_GetRnd()

def TFlt_Eq6(*args):
  """
    TFlt_Eq6(double const & LFlt, double const & RFlt) -> bool

    Parameters:
        LFlt: double const &
        RFlt: double const &

    """
  return _snap.TFlt_Eq6(*args)

def TFlt_GetMn(*args):
  """
    GetMn(double const & Flt1, double const & Flt2) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &

    GetMn(double const & Flt1, double const & Flt2, double const & Flt3) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &
        Flt3: double const &

    TFlt_GetMn(double const & Flt1, double const & Flt2, double const & Flt3, double const & Flt4) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &
        Flt3: double const &
        Flt4: double const &

    """
  return _snap.TFlt_GetMn(*args)

def TFlt_GetMx(*args):
  """
    GetMx(double const & Flt1, double const & Flt2) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &

    GetMx(double const & Flt1, double const & Flt2, double const Flt3) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &
        Flt3: double const

    TFlt_GetMx(double const & Flt1, double const & Flt2, double const Flt3, double const & Flt4) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &
        Flt3: double const
        Flt4: double const &

    """
  return _snap.TFlt_GetMx(*args)

def TFlt_GetInRng(*args):
  """
    TFlt_GetInRng(double const & Val, double const & Mn, double const & Mx) -> double

    Parameters:
        Val: double const &
        Mn: double const &
        Mx: double const &

    """
  return _snap.TFlt_GetInRng(*args)

def TFlt_GetPrcStr(*args):
  """
    TFlt_GetPrcStr(double const & RelVal, double const & FullVal) -> TStr

    Parameters:
        RelVal: double const &
        FullVal: double const &

    """
  return _snap.TFlt_GetPrcStr(*args)

def TFlt_GetKiloStr(*args):
  """
    TFlt_GetKiloStr(double const & Val) -> TStr

    Parameters:
        Val: double const &

    """
  return _snap.TFlt_GetKiloStr(*args)

def TFlt_GetMegaStr(*args):
  """
    TFlt_GetMegaStr(double const & Val) -> TStr

    Parameters:
        Val: double const &

    """
  return _snap.TFlt_GetMegaStr(*args)

def TFlt_GetGigaStr(*args):
  """
    TFlt_GetGigaStr(double const & Val) -> TStr

    Parameters:
        Val: double const &

    """
  return _snap.TFlt_GetGigaStr(*args)

class TAscFlt(TFlt):
    """Proxy of C++ TAscFlt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TAscFlt self) -> TAscFlt
        __init__(TAscFlt self, double const & Val) -> TAscFlt

        Parameters:
            Val: double const &

        __init__(TAscFlt self, TSIn SIn) -> TAscFlt

        Parameters:
            SIn: TSIn &

        """
        _snap.TAscFlt_swiginit(self,_snap.new_TAscFlt(*args))
    def Save(self, *args):
        """
        Save(TAscFlt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TAscFlt_Save(self, *args)

    __swig_destroy__ = _snap.delete_TAscFlt
TAscFlt.Save = new_instancemethod(_snap.TAscFlt_Save,None,TAscFlt)
TAscFlt_swigregister = _snap.TAscFlt_swigregister
TAscFlt_swigregister(TAscFlt)

class TSFlt(object):
    """Proxy of C++ TSFlt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TSFlt_Val_get, _snap.TSFlt_Val_set)
    def __init__(self, *args): 
        """
        __init__(TSFlt self) -> TSFlt
        __init__(TSFlt self, sdouble const & _Val) -> TSFlt

        Parameters:
            _Val: sdouble const &

        __init__(TSFlt self, TSIn SIn) -> TSFlt

        Parameters:
            SIn: TSIn &

        """
        _snap.TSFlt_swiginit(self,_snap.new_TSFlt(*args))
    def Save(self, *args):
        """
        Save(TSFlt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TSFlt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TSFlt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TSFlt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TSFlt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TSFlt_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TSFlt self, TSFlt SFlt) -> bool

        Parameters:
            SFlt: TSFlt const &

        __eq__(TSFlt self, double const & Flt) -> bool

        Parameters:
            Flt: double const &

        """
        return _snap.TSFlt___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TSFlt self, double const & Flt) -> bool

        Parameters:
            Flt: double const &

        """
        return _snap.TSFlt___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TSFlt self, TSFlt SFlt) -> bool

        Parameters:
            SFlt: TSFlt const &

        """
        return _snap.TSFlt___lt__(self, *args)

    def __call__(self):
        """
        __call__(TSFlt self) -> sdouble

        Parameters:
            self: TSFlt const *

        """
        return _snap.TSFlt___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TSFlt self, double const & SFlt) -> TSFlt

        Parameters:
            SFlt: double const &

        """
        return _snap.TSFlt___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TSFlt self, double const & SFlt) -> TSFlt

        Parameters:
            SFlt: double const &

        """
        return _snap.TSFlt___isub__(self, *args)

    def __imul__(self, *args):
        """
        __imul__(TSFlt self, double const & SFlt) -> TSFlt

        Parameters:
            SFlt: double const &

        """
        return _snap.TSFlt___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(TSFlt self, double const & SFlt) -> TSFlt

        Parameters:
            SFlt: double const &

        """
        return _snap.TSFlt___idiv__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TSFlt self) -> int

        Parameters:
            self: TSFlt const *

        """
        return _snap.TSFlt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TSFlt self) -> int

        Parameters:
            self: TSFlt const *

        """
        return _snap.TSFlt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TSFlt self) -> int

        Parameters:
            self: TSFlt const *

        """
        return _snap.TSFlt_GetSecHashCd(self)

    __swig_destroy__ = _snap.delete_TSFlt
TSFlt.Save = new_instancemethod(_snap.TSFlt_Save,None,TSFlt)
TSFlt.LoadXml = new_instancemethod(_snap.TSFlt_LoadXml,None,TSFlt)
TSFlt.SaveXml = new_instancemethod(_snap.TSFlt_SaveXml,None,TSFlt)
TSFlt.__eq__ = new_instancemethod(_snap.TSFlt___eq__,None,TSFlt)
TSFlt.__ne__ = new_instancemethod(_snap.TSFlt___ne__,None,TSFlt)
TSFlt.__lt__ = new_instancemethod(_snap.TSFlt___lt__,None,TSFlt)
TSFlt.__call__ = new_instancemethod(_snap.TSFlt___call__,None,TSFlt)
TSFlt.__iadd__ = new_instancemethod(_snap.TSFlt___iadd__,None,TSFlt)
TSFlt.__isub__ = new_instancemethod(_snap.TSFlt___isub__,None,TSFlt)
TSFlt.__imul__ = new_instancemethod(_snap.TSFlt___imul__,None,TSFlt)
TSFlt.__idiv__ = new_instancemethod(_snap.TSFlt___idiv__,None,TSFlt)
TSFlt.GetMemUsed = new_instancemethod(_snap.TSFlt_GetMemUsed,None,TSFlt)
TSFlt.GetPrimHashCd = new_instancemethod(_snap.TSFlt_GetPrimHashCd,None,TSFlt)
TSFlt.GetSecHashCd = new_instancemethod(_snap.TSFlt_GetSecHashCd,None,TSFlt)
TSFlt_swigregister = _snap.TSFlt_swigregister
TSFlt_swigregister(TSFlt)
TSFlt.Mn = _snap.cvar.TSFlt_Mn
TSFlt.Mx = _snap.cvar.TSFlt_Mx

class TLFlt(object):
    """Proxy of C++ TLFlt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TLFlt_Val_get, _snap.TLFlt_Val_set)
    def __init__(self, *args): 
        """
        __init__(TLFlt self) -> TLFlt
        __init__(TLFlt self, ldouble const & _Val) -> TLFlt

        Parameters:
            _Val: ldouble const &

        __init__(TLFlt self, TSIn SIn) -> TLFlt

        Parameters:
            SIn: TSIn &

        """
        _snap.TLFlt_swiginit(self,_snap.new_TLFlt(*args))
    def Save(self, *args):
        """
        Save(TLFlt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TLFlt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TLFlt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TLFlt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TLFlt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TLFlt_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TLFlt self, TLFlt LFlt) -> bool

        Parameters:
            LFlt: TLFlt const &

        __eq__(TLFlt self, ldouble const & LFlt) -> bool

        Parameters:
            LFlt: ldouble const &

        """
        return _snap.TLFlt___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TLFlt self, ldouble const & LFlt) -> bool

        Parameters:
            LFlt: ldouble const &

        """
        return _snap.TLFlt___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TLFlt self, TLFlt LFlt) -> bool

        Parameters:
            LFlt: TLFlt const &

        """
        return _snap.TLFlt___lt__(self, *args)

    def __call__(self):
        """
        __call__(TLFlt self) -> ldouble

        Parameters:
            self: TLFlt const *

        """
        return _snap.TLFlt___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TLFlt self, ldouble const & LFlt) -> TLFlt

        Parameters:
            LFlt: ldouble const &

        """
        return _snap.TLFlt___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TLFlt self, ldouble const & LFlt) -> TLFlt

        Parameters:
            LFlt: ldouble const &

        """
        return _snap.TLFlt___isub__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TLFlt self) -> int

        Parameters:
            self: TLFlt const *

        """
        return _snap.TLFlt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TLFlt self) -> int

        Parameters:
            self: TLFlt const *

        """
        return _snap.TLFlt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TLFlt self) -> int

        Parameters:
            self: TLFlt const *

        """
        return _snap.TLFlt_GetSecHashCd(self)

    __swig_destroy__ = _snap.delete_TLFlt
TLFlt.Save = new_instancemethod(_snap.TLFlt_Save,None,TLFlt)
TLFlt.LoadXml = new_instancemethod(_snap.TLFlt_LoadXml,None,TLFlt)
TLFlt.SaveXml = new_instancemethod(_snap.TLFlt_SaveXml,None,TLFlt)
TLFlt.__eq__ = new_instancemethod(_snap.TLFlt___eq__,None,TLFlt)
TLFlt.__ne__ = new_instancemethod(_snap.TLFlt___ne__,None,TLFlt)
TLFlt.__lt__ = new_instancemethod(_snap.TLFlt___lt__,None,TLFlt)
TLFlt.__call__ = new_instancemethod(_snap.TLFlt___call__,None,TLFlt)
TLFlt.__iadd__ = new_instancemethod(_snap.TLFlt___iadd__,None,TLFlt)
TLFlt.__isub__ = new_instancemethod(_snap.TLFlt___isub__,None,TLFlt)
TLFlt.GetMemUsed = new_instancemethod(_snap.TLFlt_GetMemUsed,None,TLFlt)
TLFlt.GetPrimHashCd = new_instancemethod(_snap.TLFlt_GetPrimHashCd,None,TLFlt)
TLFlt.GetSecHashCd = new_instancemethod(_snap.TLFlt_GetSecHashCd,None,TLFlt)
TLFlt_swigregister = _snap.TLFlt_swigregister
TLFlt_swigregister(TLFlt)
TLFlt.Mn = _snap.cvar.TLFlt_Mn
TLFlt.Mx = _snap.cvar.TLFlt_Mx

class TFltRect(object):
    """Proxy of C++ TFltRect class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    MnX = _swig_property(_snap.TFltRect_MnX_get, _snap.TFltRect_MnX_set)
    MnY = _swig_property(_snap.TFltRect_MnY_get, _snap.TFltRect_MnY_set)
    MxX = _swig_property(_snap.TFltRect_MxX_get, _snap.TFltRect_MxX_set)
    MxY = _swig_property(_snap.TFltRect_MxY_get, _snap.TFltRect_MxY_set)
    def __init__(self, *args): 
        """
        __init__(TFltRect self) -> TFltRect
        __init__(TFltRect self, TFltRect FltRect) -> TFltRect

        Parameters:
            FltRect: TFltRect const &

        __init__(TFltRect self, double const & _MnX, double const & _MnY, double const & _MxX, double const & _MxY) -> TFltRect

        Parameters:
            _MnX: double const &
            _MnY: double const &
            _MxX: double const &
            _MxY: double const &

        __init__(TFltRect self, TSIn SIn) -> TFltRect

        Parameters:
            SIn: TSIn &

        """
        _snap.TFltRect_swiginit(self,_snap.new_TFltRect(*args))
    def Save(self, *args):
        """
        Save(TFltRect self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TFltRect_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TFltRect self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TFltRect_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TFltRect self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TFltRect_SaveXml(self, *args)

    def GetMnX(self):
        """
        GetMnX(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetMnX(self)

    def GetMnY(self):
        """
        GetMnY(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetMnY(self)

    def GetMxX(self):
        """
        GetMxX(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetMxX(self)

    def GetMxY(self):
        """
        GetMxY(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetMxY(self)

    def GetXLen(self):
        """
        GetXLen(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetXLen(self)

    def GetYLen(self):
        """
        GetYLen(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetYLen(self)

    def GetXCenter(self):
        """
        GetXCenter(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetXCenter(self)

    def GetYCenter(self):
        """
        GetYCenter(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetYCenter(self)

    def IsXYIn(self, *args):
        """
        IsXYIn(TFltRect self, double const & X, double const & Y) -> bool

        Parameters:
            X: double const &
            Y: double const &

        """
        return _snap.TFltRect_IsXYIn(self, *args)

    def Intersection(*args):
        """
        Intersection(TFltRect Rect1, TFltRect Rect2) -> bool

        Parameters:
            Rect1: TFltRect const &
            Rect2: TFltRect const &

        """
        return _snap.TFltRect_Intersection(*args)

    Intersection = staticmethod(Intersection)
    __swig_destroy__ = _snap.delete_TFltRect
TFltRect.Save = new_instancemethod(_snap.TFltRect_Save,None,TFltRect)
TFltRect.LoadXml = new_instancemethod(_snap.TFltRect_LoadXml,None,TFltRect)
TFltRect.SaveXml = new_instancemethod(_snap.TFltRect_SaveXml,None,TFltRect)
TFltRect.GetMnX = new_instancemethod(_snap.TFltRect_GetMnX,None,TFltRect)
TFltRect.GetMnY = new_instancemethod(_snap.TFltRect_GetMnY,None,TFltRect)
TFltRect.GetMxX = new_instancemethod(_snap.TFltRect_GetMxX,None,TFltRect)
TFltRect.GetMxY = new_instancemethod(_snap.TFltRect_GetMxY,None,TFltRect)
TFltRect.GetXLen = new_instancemethod(_snap.TFltRect_GetXLen,None,TFltRect)
TFltRect.GetYLen = new_instancemethod(_snap.TFltRect_GetYLen,None,TFltRect)
TFltRect.GetXCenter = new_instancemethod(_snap.TFltRect_GetXCenter,None,TFltRect)
TFltRect.GetYCenter = new_instancemethod(_snap.TFltRect_GetYCenter,None,TFltRect)
TFltRect.IsXYIn = new_instancemethod(_snap.TFltRect_IsXYIn,None,TFltRect)
TFltRect_swigregister = _snap.TFltRect_swigregister
TFltRect_swigregister(TFltRect)

def TFltRect_Intersection(*args):
  """
    TFltRect_Intersection(TFltRect Rect1, TFltRect Rect2) -> bool

    Parameters:
        Rect1: TFltRect const &
        Rect2: TFltRect const &

    """
  return _snap.TFltRect_Intersection(*args)

class TIntV(object):
    """Proxy of C++ TVec<(TInt,int)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TIntV
    def __init__(self, *args): 
        """
        __init__(TVec<(TInt,int)> self) -> TIntV
        __init__(TVec<(TInt,int)> self, TIntV Vec) -> TIntV

        Parameters:
            Vec: TVec< TInt,int > const &

        __init__(TVec<(TInt,int)> self, int const & _Vals) -> TIntV

        Parameters:
            _Vals: int const &

        __init__(TVec<(TInt,int)> self, int const & _MxVals, int const & _Vals) -> TIntV

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        __init__(TVec<(TInt,int)> self, TInt _ValT, int const & _Vals) -> TIntV

        Parameters:
            _ValT: TInt *
            _Vals: int const &

        __init__(TVec<(TInt,int)> self, TSIn SIn) -> TIntV

        Parameters:
            SIn: TSIn &

        """
        _snap.TIntV_swiginit(self,_snap.new_TIntV(*args))
    def Load(self, *args):
        """
        Load(TIntV self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TIntV_Load(self, *args)

    def Save(self, *args):
        """
        Save(TIntV self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TIntV_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TIntV self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TIntV self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TIntV_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TIntV self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TIntV_SaveXml(self, *args)

    def __add__(self, *args):
        """
        __add__(TIntV self, TInt Val) -> TIntV

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV___add__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TIntV self, TIntV Vec) -> bool

        Parameters:
            Vec: TVec< TInt,int > const &

        """
        return _snap.TIntV___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntV self, TIntV Vec) -> bool

        Parameters:
            Vec: TVec< TInt,int > const &

        """
        return _snap.TIntV___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetMemUsed(self)

    def GetMemSize(self):
        """
        GetMemSize(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetMemSize(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetSecHashCd(self)

    def Gen(self, *args):
        """
        Gen(TIntV self, int const & _Vals)

        Parameters:
            _Vals: int const &

        Gen(TIntV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TIntV_Gen(self, *args)

    def GenExt(self, *args):
        """
        GenExt(TIntV self, TInt _ValT, int const & _Vals)

        Parameters:
            _ValT: TInt *
            _Vals: int const &

        """
        return _snap.TIntV_GenExt(self, *args)

    def IsExt(self):
        """
        IsExt(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_IsExt(self)

    def Reserve(self, *args):
        """
        Reserve(TIntV self, int const & _MxVals)

        Parameters:
            _MxVals: int const &

        Reserve(TIntV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TIntV_Reserve(self, *args)

    def Clr(self, *args):
        """
        Clr(TIntV self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TIntV self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Clr(self, *args)

    def Trunc(self, *args):
        """
        Trunc(TIntV self, int const & _Vals=-1)

        Parameters:
            _Vals: int const &

        Trunc(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Trunc(self, *args)

    def Pack(self):
        """
        Pack(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Pack(self)

    def MoveFrom(self, *args):
        """
        MoveFrom(TIntV self, TIntV Vec)

        Parameters:
            Vec: TVec< TInt,int > &

        """
        return _snap.TIntV_MoveFrom(self, *args)

    def Empty(self):
        """
        Empty(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_Empty(self)

    def Len(self):
        """
        Len(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_Len(self)

    def Reserved(self):
        """
        Reserved(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_Reserved(self)

    def Last(self, *args):
        """
        Last(TIntV self) -> TInt
        Last(TIntV self) -> TInt

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Last(self, *args)

    def LastValN(self):
        """
        LastValN(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_LastValN(self)

    def LastLast(self, *args):
        """
        LastLast(TIntV self) -> TInt
        LastLast(TIntV self) -> TInt

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_LastLast(self, *args)

    def BegI(self):
        """
        BegI(TIntV self) -> TInt

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_BegI(self)

    def EndI(self):
        """
        EndI(TIntV self) -> TInt

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_EndI(self)

    def GetI(self, *args):
        """
        GetI(TIntV self, int const & ValN) -> TInt

        Parameters:
            ValN: int const &

        """
        return _snap.TIntV_GetI(self, *args)

    def AddV(self, *args):
        """
        AddV(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_AddV(self, *args)

    def AddSorted(self, *args):
        """
        AddSorted(TIntV self, TInt Val, bool const & Asc=True, int const & _MxVals=-1) -> int

        Parameters:
            Val: TInt const &
            Asc: bool const &
            _MxVals: int const &

        AddSorted(TIntV self, TInt Val, bool const & Asc=True) -> int

        Parameters:
            Val: TInt const &
            Asc: bool const &

        AddSorted(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_AddSorted(self, *args)

    def AddBackSorted(self, *args):
        """
        AddBackSorted(TIntV self, TInt Val, bool const & Asc) -> int

        Parameters:
            Val: TInt const &
            Asc: bool const &

        """
        return _snap.TIntV_AddBackSorted(self, *args)

    def AddVMerged(self, *args):
        """
        AddVMerged(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_AddVMerged(self, *args)

    def AddUnique(self, *args):
        """
        AddUnique(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_AddUnique(self, *args)

    def GetVal(self, *args):
        """
        GetVal(TIntV self, int const & ValN) -> TInt

        Parameters:
            ValN: int const &

        GetVal(TIntV self, int const & ValN) -> TInt

        Parameters:
            ValN: int const &

        """
        return _snap.TIntV_GetVal(self, *args)

    def GetSubValV(self, *args):
        """
        GetSubValV(TIntV self, int const & BValN, int const & EValN, TIntV ValV)

        Parameters:
            BValN: int const &
            EValN: int const &
            ValV: TVec< TInt,int > &

        """
        return _snap.TIntV_GetSubValV(self, *args)

    def Ins(self, *args):
        """
        Ins(TIntV self, int const & ValN, TInt Val)

        Parameters:
            ValN: int const &
            Val: TInt const &

        """
        return _snap.TIntV_Ins(self, *args)

    def Del(self, *args):
        """
        Del(TIntV self, int const & ValN)

        Parameters:
            ValN: int const &

        Del(TIntV self, int const & MnValN, int const & MxValN)

        Parameters:
            MnValN: int const &
            MxValN: int const &

        """
        return _snap.TIntV_Del(self, *args)

    def DelLast(self):
        """
        DelLast(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_DelLast(self)

    def DelIfIn(self, *args):
        """
        DelIfIn(TIntV self, TInt Val) -> bool

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_DelIfIn(self, *args)

    def DelAll(self, *args):
        """
        DelAll(TIntV self, TInt Val)

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_DelAll(self, *args)

    def PutAll(self, *args):
        """
        PutAll(TIntV self, TInt Val)

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_PutAll(self, *args)

    def Swap(self, *args):
        """
        Swap(TIntV self, TIntV Vec)

        Parameters:
            Vec: TVec< TInt,int > &

        Swap(TIntV self, int const & ValN1, int const & ValN2)

        Parameters:
            ValN1: int const &
            ValN2: int const &

        """
        return _snap.TIntV_Swap(self, *args)

    def SwapI(*args):
        """
        SwapI(TInt LVal, TInt RVal)

        Parameters:
            LVal: TVec< TInt,int >::TIter
            RVal: TVec< TInt,int >::TIter

        """
        return _snap.TIntV_SwapI(*args)

    SwapI = staticmethod(SwapI)
    def NextPerm(self):
        """
        NextPerm(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_NextPerm(self)

    def PrevPerm(self):
        """
        PrevPerm(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_PrevPerm(self)

    def GetPivotValN(self, *args):
        """
        GetPivotValN(TIntV self, int const & LValN, int const & RValN) -> int

        Parameters:
            LValN: int const &
            RValN: int const &

        """
        return _snap.TIntV_GetPivotValN(self, *args)

    def BSort(self, *args):
        """
        BSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntV_BSort(self, *args)

    def ISort(self, *args):
        """
        ISort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntV_ISort(self, *args)

    def Partition(self, *args):
        """
        Partition(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntV_Partition(self, *args)

    def QSort(self, *args):
        """
        QSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntV_QSort(self, *args)

    def Sort(self, Asc=True):
        """
        Sort(TIntV self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        Sort(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Sort(self, Asc)

    def IsSorted(self, Asc=True):
        """
        IsSorted(TIntV self, bool const & Asc=True) -> bool

        Parameters:
            Asc: bool const &

        IsSorted(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_IsSorted(self, Asc)

    def Shuffle(self, *args):
        """
        Shuffle(TIntV self, TRnd Rnd)

        Parameters:
            Rnd: TRnd &

        """
        return _snap.TIntV_Shuffle(self, *args)

    def Reverse(self, *args):
        """
        Reverse(TIntV self)
        Reverse(TIntV self, int LValN, int RValN)

        Parameters:
            LValN: int
            RValN: int

        """
        return _snap.TIntV_Reverse(self, *args)

    def Merge(self):
        """
        Merge(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Merge(self)

    def Intrs(self, *args):
        """
        Intrs(TIntV self, TIntV ValV)

        Parameters:
            ValV: TVec< TInt,int > const &

        Intrs(TIntV self, TIntV ValV, TIntV DstValV)

        Parameters:
            ValV: TVec< TInt,int > const &
            DstValV: TVec< TInt,int > &

        """
        return _snap.TIntV_Intrs(self, *args)

    def Union(self, *args):
        """
        Union(TIntV self, TIntV ValV)

        Parameters:
            ValV: TVec< TInt,int > const &

        Union(TIntV self, TIntV ValV, TIntV DstValV)

        Parameters:
            ValV: TVec< TInt,int > const &
            DstValV: TVec< TInt,int > &

        """
        return _snap.TIntV_Union(self, *args)

    def Diff(self, *args):
        """
        Diff(TIntV self, TIntV ValV)

        Parameters:
            ValV: TVec< TInt,int > const &

        Diff(TIntV self, TIntV ValV, TIntV DstValV)

        Parameters:
            ValV: TVec< TInt,int > const &
            DstValV: TVec< TInt,int > &

        """
        return _snap.TIntV_Diff(self, *args)

    def IntrsLen(self, *args):
        """
        IntrsLen(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_IntrsLen(self, *args)

    def UnionLen(self, *args):
        """
        UnionLen(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_UnionLen(self, *args)

    def Count(self, *args):
        """
        Count(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_Count(self, *args)

    def SearchBin(self, *args):
        """
        SearchBin(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        SearchBin(TIntV self, TInt Val, int & InsValN) -> int

        Parameters:
            Val: TInt const &
            InsValN: int &

        """
        return _snap.TIntV_SearchBin(self, *args)

    def SearchForw(self, *args):
        """
        SearchForw(TIntV self, TInt Val, int const & BValN=0) -> int

        Parameters:
            Val: TInt const &
            BValN: int const &

        SearchForw(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_SearchForw(self, *args)

    def SearchBack(self, *args):
        """
        SearchBack(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_SearchBack(self, *args)

    def SearchVForw(self, *args):
        """
        SearchVForw(TIntV self, TIntV ValV, int const & BValN=0) -> int

        Parameters:
            ValV: TVec< TInt,int > const &
            BValN: int const &

        SearchVForw(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_SearchVForw(self, *args)

    def IsIn(self, *args):
        """
        IsIn(TIntV self, TInt Val) -> bool

        Parameters:
            Val: TInt const &

        IsIn(TIntV self, TInt Val, int & ValN) -> bool

        Parameters:
            Val: TInt const &
            ValN: int &

        """
        return _snap.TIntV_IsIn(self, *args)

    def IsInBin(self, *args):
        """
        IsInBin(TIntV self, TInt Val) -> bool

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_IsInBin(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TIntV self, TInt Val) -> TInt

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_GetDat(self, *args)

    def GetAddDat(self, *args):
        """
        GetAddDat(TIntV self, TInt Val) -> TInt

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_GetAddDat(self, *args)

    def GetMxValN(self):
        """
        GetMxValN(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetMxValN(self)

    def GetV(*args):
        """
        GetV(TInt Val1) -> TIntV

        Parameters:
            Val1: TInt const &

        GetV(TInt Val1, TInt Val2) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &
            Val6: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &
            Val6: TInt const &
            Val7: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &
            Val6: TInt const &
            Val7: TInt const &
            Val8: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8, 
            TInt Val9) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &
            Val6: TInt const &
            Val7: TInt const &
            Val8: TInt const &
            Val9: TInt const &

        """
        return _snap.TIntV_GetV(*args)

    GetV = staticmethod(GetV)
    def Add(self, *args):
        """
        Add(TIntV self) -> int
        Add(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        Add(TIntV self, TInt Val, int const & ResizeLen) -> int

        Parameters:
            Val: TInt const &
            ResizeLen: int const &

        Add(TIntV self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntV_Add(self, *args)

    def AddMerged(self, *args):
        """
        AddMerged(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        AddMerged(TIntV self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntV_AddMerged(self, *args)

TIntV.Load = new_instancemethod(_snap.TIntV_Load,None,TIntV)
TIntV.Save = new_instancemethod(_snap.TIntV_Save,None,TIntV)
TIntV.LoadXml = new_instancemethod(_snap.TIntV_LoadXml,None,TIntV)
TIntV.SaveXml = new_instancemethod(_snap.TIntV_SaveXml,None,TIntV)
TIntV.__add__ = new_instancemethod(_snap.TIntV___add__,None,TIntV)
TIntV.__eq__ = new_instancemethod(_snap.TIntV___eq__,None,TIntV)
TIntV.__lt__ = new_instancemethod(_snap.TIntV___lt__,None,TIntV)
TIntV.GetMemUsed = new_instancemethod(_snap.TIntV_GetMemUsed,None,TIntV)
TIntV.GetMemSize = new_instancemethod(_snap.TIntV_GetMemSize,None,TIntV)
TIntV.GetPrimHashCd = new_instancemethod(_snap.TIntV_GetPrimHashCd,None,TIntV)
TIntV.GetSecHashCd = new_instancemethod(_snap.TIntV_GetSecHashCd,None,TIntV)
TIntV.Gen = new_instancemethod(_snap.TIntV_Gen,None,TIntV)
TIntV.GenExt = new_instancemethod(_snap.TIntV_GenExt,None,TIntV)
TIntV.IsExt = new_instancemethod(_snap.TIntV_IsExt,None,TIntV)
TIntV.Reserve = new_instancemethod(_snap.TIntV_Reserve,None,TIntV)
TIntV.Clr = new_instancemethod(_snap.TIntV_Clr,None,TIntV)
TIntV.Trunc = new_instancemethod(_snap.TIntV_Trunc,None,TIntV)
TIntV.Pack = new_instancemethod(_snap.TIntV_Pack,None,TIntV)
TIntV.MoveFrom = new_instancemethod(_snap.TIntV_MoveFrom,None,TIntV)
TIntV.Empty = new_instancemethod(_snap.TIntV_Empty,None,TIntV)
TIntV.Len = new_instancemethod(_snap.TIntV_Len,None,TIntV)
TIntV.Reserved = new_instancemethod(_snap.TIntV_Reserved,None,TIntV)
TIntV.Last = new_instancemethod(_snap.TIntV_Last,None,TIntV)
TIntV.LastValN = new_instancemethod(_snap.TIntV_LastValN,None,TIntV)
TIntV.LastLast = new_instancemethod(_snap.TIntV_LastLast,None,TIntV)
TIntV.BegI = new_instancemethod(_snap.TIntV_BegI,None,TIntV)
TIntV.EndI = new_instancemethod(_snap.TIntV_EndI,None,TIntV)
TIntV.GetI = new_instancemethod(_snap.TIntV_GetI,None,TIntV)
TIntV.AddV = new_instancemethod(_snap.TIntV_AddV,None,TIntV)
TIntV.AddSorted = new_instancemethod(_snap.TIntV_AddSorted,None,TIntV)
TIntV.AddBackSorted = new_instancemethod(_snap.TIntV_AddBackSorted,None,TIntV)
TIntV.AddVMerged = new_instancemethod(_snap.TIntV_AddVMerged,None,TIntV)
TIntV.AddUnique = new_instancemethod(_snap.TIntV_AddUnique,None,TIntV)
TIntV.GetVal = new_instancemethod(_snap.TIntV_GetVal,None,TIntV)
TIntV.GetSubValV = new_instancemethod(_snap.TIntV_GetSubValV,None,TIntV)
TIntV.Ins = new_instancemethod(_snap.TIntV_Ins,None,TIntV)
TIntV.Del = new_instancemethod(_snap.TIntV_Del,None,TIntV)
TIntV.DelLast = new_instancemethod(_snap.TIntV_DelLast,None,TIntV)
TIntV.DelIfIn = new_instancemethod(_snap.TIntV_DelIfIn,None,TIntV)
TIntV.DelAll = new_instancemethod(_snap.TIntV_DelAll,None,TIntV)
TIntV.PutAll = new_instancemethod(_snap.TIntV_PutAll,None,TIntV)
TIntV.Swap = new_instancemethod(_snap.TIntV_Swap,None,TIntV)
TIntV.NextPerm = new_instancemethod(_snap.TIntV_NextPerm,None,TIntV)
TIntV.PrevPerm = new_instancemethod(_snap.TIntV_PrevPerm,None,TIntV)
TIntV.GetPivotValN = new_instancemethod(_snap.TIntV_GetPivotValN,None,TIntV)
TIntV.BSort = new_instancemethod(_snap.TIntV_BSort,None,TIntV)
TIntV.ISort = new_instancemethod(_snap.TIntV_ISort,None,TIntV)
TIntV.Partition = new_instancemethod(_snap.TIntV_Partition,None,TIntV)
TIntV.QSort = new_instancemethod(_snap.TIntV_QSort,None,TIntV)
TIntV.Sort = new_instancemethod(_snap.TIntV_Sort,None,TIntV)
TIntV.IsSorted = new_instancemethod(_snap.TIntV_IsSorted,None,TIntV)
TIntV.Shuffle = new_instancemethod(_snap.TIntV_Shuffle,None,TIntV)
TIntV.Reverse = new_instancemethod(_snap.TIntV_Reverse,None,TIntV)
TIntV.Merge = new_instancemethod(_snap.TIntV_Merge,None,TIntV)
TIntV.Intrs = new_instancemethod(_snap.TIntV_Intrs,None,TIntV)
TIntV.Union = new_instancemethod(_snap.TIntV_Union,None,TIntV)
TIntV.Diff = new_instancemethod(_snap.TIntV_Diff,None,TIntV)
TIntV.IntrsLen = new_instancemethod(_snap.TIntV_IntrsLen,None,TIntV)
TIntV.UnionLen = new_instancemethod(_snap.TIntV_UnionLen,None,TIntV)
TIntV.Count = new_instancemethod(_snap.TIntV_Count,None,TIntV)
TIntV.SearchBin = new_instancemethod(_snap.TIntV_SearchBin,None,TIntV)
TIntV.SearchForw = new_instancemethod(_snap.TIntV_SearchForw,None,TIntV)
TIntV.SearchBack = new_instancemethod(_snap.TIntV_SearchBack,None,TIntV)
TIntV.SearchVForw = new_instancemethod(_snap.TIntV_SearchVForw,None,TIntV)
TIntV.IsIn = new_instancemethod(_snap.TIntV_IsIn,None,TIntV)
TIntV.IsInBin = new_instancemethod(_snap.TIntV_IsInBin,None,TIntV)
TIntV.GetDat = new_instancemethod(_snap.TIntV_GetDat,None,TIntV)
TIntV.GetAddDat = new_instancemethod(_snap.TIntV_GetAddDat,None,TIntV)
TIntV.GetMxValN = new_instancemethod(_snap.TIntV_GetMxValN,None,TIntV)
TIntV.Add = new_instancemethod(_snap.TIntV_Add,None,TIntV)
TIntV.AddMerged = new_instancemethod(_snap.TIntV_AddMerged,None,TIntV)
TIntV_swigregister = _snap.TIntV_swigregister
TIntV_swigregister(TIntV)

def TIntV_SwapI(*args):
  """
    TIntV_SwapI(TInt LVal, TInt RVal)

    Parameters:
        LVal: TVec< TInt,int >::TIter
        RVal: TVec< TInt,int >::TIter

    """
  return _snap.TIntV_SwapI(*args)

def TIntV_GetV(*args):
  """
    GetV(TInt Val1) -> TIntV

    Parameters:
        Val1: TInt const &

    GetV(TInt Val1, TInt Val2) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &
        Val6: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &
        Val6: TInt const &
        Val7: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &
        Val6: TInt const &
        Val7: TInt const &
        Val8: TInt const &

    TIntV_GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8, 
        TInt Val9) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &
        Val6: TInt const &
        Val7: TInt const &
        Val8: TInt const &
        Val9: TInt const &

    """
  return _snap.TIntV_GetV(*args)

class TIntIntVV(object):
    """Proxy of C++ TVec<(TVec<(TInt,int)>,int)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TIntIntVV
    def __init__(self, *args): 
        """
        __init__(TVec<(TVec<(TInt,int)>,int)> self) -> TIntIntVV
        __init__(TVec<(TVec<(TInt,int)>,int)> self, TIntIntVV Vec) -> TIntIntVV

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > const &

        __init__(TVec<(TVec<(TInt,int)>,int)> self, int const & _Vals) -> TIntIntVV

        Parameters:
            _Vals: int const &

        __init__(TVec<(TVec<(TInt,int)>,int)> self, int const & _MxVals, int const & _Vals) -> TIntIntVV

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        __init__(TVec<(TVec<(TInt,int)>,int)> self, TIntV _ValT, int const & _Vals) -> TIntIntVV

        Parameters:
            _ValT: TVec< TInt,int > *
            _Vals: int const &

        __init__(TVec<(TVec<(TInt,int)>,int)> self, TSIn SIn) -> TIntIntVV

        Parameters:
            SIn: TSIn &

        """
        _snap.TIntIntVV_swiginit(self,_snap.new_TIntIntVV(*args))
    def Load(self, *args):
        """
        Load(TIntIntVV self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TIntIntVV_Load(self, *args)

    def Save(self, *args):
        """
        Save(TIntIntVV self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TIntIntVV_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TIntIntVV self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TIntIntVV self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TIntIntVV_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TIntIntVV self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TIntIntVV_SaveXml(self, *args)

    def __add__(self, *args):
        """
        __add__(TIntIntVV self, TIntV Val) -> TIntIntVV

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV___add__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TIntIntVV self, TIntIntVV Vec) -> bool

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntIntVV self, TIntIntVV Vec) -> bool

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetMemUsed(self)

    def GetMemSize(self):
        """
        GetMemSize(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetMemSize(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetSecHashCd(self)

    def Gen(self, *args):
        """
        Gen(TIntIntVV self, int const & _Vals)

        Parameters:
            _Vals: int const &

        Gen(TIntIntVV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TIntIntVV_Gen(self, *args)

    def GenExt(self, *args):
        """
        GenExt(TIntIntVV self, TIntV _ValT, int const & _Vals)

        Parameters:
            _ValT: TVec< TInt,int > *
            _Vals: int const &

        """
        return _snap.TIntIntVV_GenExt(self, *args)

    def IsExt(self):
        """
        IsExt(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_IsExt(self)

    def Reserve(self, *args):
        """
        Reserve(TIntIntVV self, int const & _MxVals)

        Parameters:
            _MxVals: int const &

        Reserve(TIntIntVV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TIntIntVV_Reserve(self, *args)

    def Clr(self, *args):
        """
        Clr(TIntIntVV self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TIntIntVV self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Clr(self, *args)

    def Trunc(self, *args):
        """
        Trunc(TIntIntVV self, int const & _Vals=-1)

        Parameters:
            _Vals: int const &

        Trunc(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Trunc(self, *args)

    def Pack(self):
        """
        Pack(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Pack(self)

    def MoveFrom(self, *args):
        """
        MoveFrom(TIntIntVV self, TIntIntVV Vec)

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_MoveFrom(self, *args)

    def Empty(self):
        """
        Empty(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_Empty(self)

    def Len(self):
        """
        Len(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_Len(self)

    def Reserved(self):
        """
        Reserved(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_Reserved(self)

    def Last(self, *args):
        """
        Last(TIntIntVV self) -> TIntV
        Last(TIntIntVV self) -> TIntV

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Last(self, *args)

    def LastValN(self):
        """
        LastValN(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_LastValN(self)

    def LastLast(self, *args):
        """
        LastLast(TIntIntVV self) -> TIntV
        LastLast(TIntIntVV self) -> TIntV

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_LastLast(self, *args)

    def BegI(self):
        """
        BegI(TIntIntVV self) -> TIntV

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_BegI(self)

    def EndI(self):
        """
        EndI(TIntIntVV self) -> TIntV

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_EndI(self)

    def GetI(self, *args):
        """
        GetI(TIntIntVV self, int const & ValN) -> TIntV

        Parameters:
            ValN: int const &

        """
        return _snap.TIntIntVV_GetI(self, *args)

    def AddV(self, *args):
        """
        AddV(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_AddV(self, *args)

    def AddSorted(self, *args):
        """
        AddSorted(TIntIntVV self, TIntV Val, bool const & Asc=True, int const & _MxVals=-1) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            Asc: bool const &
            _MxVals: int const &

        AddSorted(TIntIntVV self, TIntV Val, bool const & Asc=True) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            Asc: bool const &

        AddSorted(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_AddSorted(self, *args)

    def AddBackSorted(self, *args):
        """
        AddBackSorted(TIntIntVV self, TIntV Val, bool const & Asc) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_AddBackSorted(self, *args)

    def AddVMerged(self, *args):
        """
        AddVMerged(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_AddVMerged(self, *args)

    def AddUnique(self, *args):
        """
        AddUnique(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_AddUnique(self, *args)

    def GetVal(self, *args):
        """
        GetVal(TIntIntVV self, int const & ValN) -> TIntV

        Parameters:
            ValN: int const &

        GetVal(TIntIntVV self, int const & ValN) -> TIntV

        Parameters:
            ValN: int const &

        """
        return _snap.TIntIntVV_GetVal(self, *args)

    def GetSubValV(self, *args):
        """
        GetSubValV(TIntIntVV self, int const & BValN, int const & EValN, TIntIntVV ValV)

        Parameters:
            BValN: int const &
            EValN: int const &
            ValV: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_GetSubValV(self, *args)

    def Ins(self, *args):
        """
        Ins(TIntIntVV self, int const & ValN, TIntV Val)

        Parameters:
            ValN: int const &
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_Ins(self, *args)

    def Del(self, *args):
        """
        Del(TIntIntVV self, int const & ValN)

        Parameters:
            ValN: int const &

        Del(TIntIntVV self, int const & MnValN, int const & MxValN)

        Parameters:
            MnValN: int const &
            MxValN: int const &

        """
        return _snap.TIntIntVV_Del(self, *args)

    def DelLast(self):
        """
        DelLast(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_DelLast(self)

    def DelIfIn(self, *args):
        """
        DelIfIn(TIntIntVV self, TIntV Val) -> bool

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_DelIfIn(self, *args)

    def DelAll(self, *args):
        """
        DelAll(TIntIntVV self, TIntV Val)

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_DelAll(self, *args)

    def PutAll(self, *args):
        """
        PutAll(TIntIntVV self, TIntV Val)

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_PutAll(self, *args)

    def Swap(self, *args):
        """
        Swap(TIntIntVV self, TIntIntVV Vec)

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > &

        Swap(TIntIntVV self, int const & ValN1, int const & ValN2)

        Parameters:
            ValN1: int const &
            ValN2: int const &

        """
        return _snap.TIntIntVV_Swap(self, *args)

    def SwapI(*args):
        """
        SwapI(TIntV LVal, TIntV RVal)

        Parameters:
            LVal: TVec< TVec< TInt,int >,int >::TIter
            RVal: TVec< TVec< TInt,int >,int >::TIter

        """
        return _snap.TIntIntVV_SwapI(*args)

    SwapI = staticmethod(SwapI)
    def NextPerm(self):
        """
        NextPerm(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_NextPerm(self)

    def PrevPerm(self):
        """
        PrevPerm(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_PrevPerm(self)

    def GetPivotValN(self, *args):
        """
        GetPivotValN(TIntIntVV self, int const & LValN, int const & RValN) -> int

        Parameters:
            LValN: int const &
            RValN: int const &

        """
        return _snap.TIntIntVV_GetPivotValN(self, *args)

    def BSort(self, *args):
        """
        BSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_BSort(self, *args)

    def ISort(self, *args):
        """
        ISort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_ISort(self, *args)

    def Partition(self, *args):
        """
        Partition(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_Partition(self, *args)

    def QSort(self, *args):
        """
        QSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_QSort(self, *args)

    def Sort(self, Asc=True):
        """
        Sort(TIntIntVV self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        Sort(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Sort(self, Asc)

    def IsSorted(self, Asc=True):
        """
        IsSorted(TIntIntVV self, bool const & Asc=True) -> bool

        Parameters:
            Asc: bool const &

        IsSorted(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_IsSorted(self, Asc)

    def Shuffle(self, *args):
        """
        Shuffle(TIntIntVV self, TRnd Rnd)

        Parameters:
            Rnd: TRnd &

        """
        return _snap.TIntIntVV_Shuffle(self, *args)

    def Reverse(self, *args):
        """
        Reverse(TIntIntVV self)
        Reverse(TIntIntVV self, int LValN, int RValN)

        Parameters:
            LValN: int
            RValN: int

        """
        return _snap.TIntIntVV_Reverse(self, *args)

    def Merge(self):
        """
        Merge(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Merge(self)

    def Intrs(self, *args):
        """
        Intrs(TIntIntVV self, TIntIntVV ValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        Intrs(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &
            DstValV: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_Intrs(self, *args)

    def Union(self, *args):
        """
        Union(TIntIntVV self, TIntIntVV ValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        Union(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &
            DstValV: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_Union(self, *args)

    def Diff(self, *args):
        """
        Diff(TIntIntVV self, TIntIntVV ValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        Diff(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &
            DstValV: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_Diff(self, *args)

    def IntrsLen(self, *args):
        """
        IntrsLen(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_IntrsLen(self, *args)

    def UnionLen(self, *args):
        """
        UnionLen(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_UnionLen(self, *args)

    def Count(self, *args):
        """
        Count(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_Count(self, *args)

    def SearchBin(self, *args):
        """
        SearchBin(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        SearchBin(TIntIntVV self, TIntV Val, int & InsValN) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            InsValN: int &

        """
        return _snap.TIntIntVV_SearchBin(self, *args)

    def SearchForw(self, *args):
        """
        SearchForw(TIntIntVV self, TIntV Val, int const & BValN=0) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            BValN: int const &

        SearchForw(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_SearchForw(self, *args)

    def SearchBack(self, *args):
        """
        SearchBack(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_SearchBack(self, *args)

    def SearchVForw(self, *args):
        """
        SearchVForw(TIntIntVV self, TIntIntVV ValV, int const & BValN=0) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &
            BValN: int const &

        SearchVForw(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_SearchVForw(self, *args)

    def IsIn(self, *args):
        """
        IsIn(TIntIntVV self, TIntV Val) -> bool

        Parameters:
            Val: TVec< TInt,int > const &

        IsIn(TIntIntVV self, TIntV Val, int & ValN) -> bool

        Parameters:
            Val: TVec< TInt,int > const &
            ValN: int &

        """
        return _snap.TIntIntVV_IsIn(self, *args)

    def IsInBin(self, *args):
        """
        IsInBin(TIntIntVV self, TIntV Val) -> bool

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_IsInBin(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TIntIntVV self, TIntV Val) -> TIntV

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_GetDat(self, *args)

    def GetAddDat(self, *args):
        """
        GetAddDat(TIntIntVV self, TIntV Val) -> TIntV

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_GetAddDat(self, *args)

    def GetMxValN(self):
        """
        GetMxValN(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetMxValN(self)

    def GetV(*args):
        """
        GetV(TIntV Val1) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &
            Val6: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &
            Val6: TVec< TInt,int > const &
            Val7: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, 
            TIntV Val8) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &
            Val6: TVec< TInt,int > const &
            Val7: TVec< TInt,int > const &
            Val8: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, 
            TIntV Val8, TIntV Val9) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &
            Val6: TVec< TInt,int > const &
            Val7: TVec< TInt,int > const &
            Val8: TVec< TInt,int > const &
            Val9: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_GetV(*args)

    GetV = staticmethod(GetV)
TIntIntVV.Load = new_instancemethod(_snap.TIntIntVV_Load,None,TIntIntVV)
TIntIntVV.Save = new_instancemethod(_snap.TIntIntVV_Save,None,TIntIntVV)
TIntIntVV.LoadXml = new_instancemethod(_snap.TIntIntVV_LoadXml,None,TIntIntVV)
TIntIntVV.SaveXml = new_instancemethod(_snap.TIntIntVV_SaveXml,None,TIntIntVV)
TIntIntVV.__add__ = new_instancemethod(_snap.TIntIntVV___add__,None,TIntIntVV)
TIntIntVV.__eq__ = new_instancemethod(_snap.TIntIntVV___eq__,None,TIntIntVV)
TIntIntVV.__lt__ = new_instancemethod(_snap.TIntIntVV___lt__,None,TIntIntVV)
TIntIntVV.GetMemUsed = new_instancemethod(_snap.TIntIntVV_GetMemUsed,None,TIntIntVV)
TIntIntVV.GetMemSize = new_instancemethod(_snap.TIntIntVV_GetMemSize,None,TIntIntVV)
TIntIntVV.GetPrimHashCd = new_instancemethod(_snap.TIntIntVV_GetPrimHashCd,None,TIntIntVV)
TIntIntVV.GetSecHashCd = new_instancemethod(_snap.TIntIntVV_GetSecHashCd,None,TIntIntVV)
TIntIntVV.Gen = new_instancemethod(_snap.TIntIntVV_Gen,None,TIntIntVV)
TIntIntVV.GenExt = new_instancemethod(_snap.TIntIntVV_GenExt,None,TIntIntVV)
TIntIntVV.IsExt = new_instancemethod(_snap.TIntIntVV_IsExt,None,TIntIntVV)
TIntIntVV.Reserve = new_instancemethod(_snap.TIntIntVV_Reserve,None,TIntIntVV)
TIntIntVV.Clr = new_instancemethod(_snap.TIntIntVV_Clr,None,TIntIntVV)
TIntIntVV.Trunc = new_instancemethod(_snap.TIntIntVV_Trunc,None,TIntIntVV)
TIntIntVV.Pack = new_instancemethod(_snap.TIntIntVV_Pack,None,TIntIntVV)
TIntIntVV.MoveFrom = new_instancemethod(_snap.TIntIntVV_MoveFrom,None,TIntIntVV)
TIntIntVV.Empty = new_instancemethod(_snap.TIntIntVV_Empty,None,TIntIntVV)
TIntIntVV.Len = new_instancemethod(_snap.TIntIntVV_Len,None,TIntIntVV)
TIntIntVV.Reserved = new_instancemethod(_snap.TIntIntVV_Reserved,None,TIntIntVV)
TIntIntVV.Last = new_instancemethod(_snap.TIntIntVV_Last,None,TIntIntVV)
TIntIntVV.LastValN = new_instancemethod(_snap.TIntIntVV_LastValN,None,TIntIntVV)
TIntIntVV.LastLast = new_instancemethod(_snap.TIntIntVV_LastLast,None,TIntIntVV)
TIntIntVV.BegI = new_instancemethod(_snap.TIntIntVV_BegI,None,TIntIntVV)
TIntIntVV.EndI = new_instancemethod(_snap.TIntIntVV_EndI,None,TIntIntVV)
TIntIntVV.GetI = new_instancemethod(_snap.TIntIntVV_GetI,None,TIntIntVV)
TIntIntVV.AddV = new_instancemethod(_snap.TIntIntVV_AddV,None,TIntIntVV)
TIntIntVV.AddSorted = new_instancemethod(_snap.TIntIntVV_AddSorted,None,TIntIntVV)
TIntIntVV.AddBackSorted = new_instancemethod(_snap.TIntIntVV_AddBackSorted,None,TIntIntVV)
TIntIntVV.AddVMerged = new_instancemethod(_snap.TIntIntVV_AddVMerged,None,TIntIntVV)
TIntIntVV.AddUnique = new_instancemethod(_snap.TIntIntVV_AddUnique,None,TIntIntVV)
TIntIntVV.GetVal = new_instancemethod(_snap.TIntIntVV_GetVal,None,TIntIntVV)
TIntIntVV.GetSubValV = new_instancemethod(_snap.TIntIntVV_GetSubValV,None,TIntIntVV)
TIntIntVV.Ins = new_instancemethod(_snap.TIntIntVV_Ins,None,TIntIntVV)
TIntIntVV.Del = new_instancemethod(_snap.TIntIntVV_Del,None,TIntIntVV)
TIntIntVV.DelLast = new_instancemethod(_snap.TIntIntVV_DelLast,None,TIntIntVV)
TIntIntVV.DelIfIn = new_instancemethod(_snap.TIntIntVV_DelIfIn,None,TIntIntVV)
TIntIntVV.DelAll = new_instancemethod(_snap.TIntIntVV_DelAll,None,TIntIntVV)
TIntIntVV.PutAll = new_instancemethod(_snap.TIntIntVV_PutAll,None,TIntIntVV)
TIntIntVV.Swap = new_instancemethod(_snap.TIntIntVV_Swap,None,TIntIntVV)
TIntIntVV.NextPerm = new_instancemethod(_snap.TIntIntVV_NextPerm,None,TIntIntVV)
TIntIntVV.PrevPerm = new_instancemethod(_snap.TIntIntVV_PrevPerm,None,TIntIntVV)
TIntIntVV.GetPivotValN = new_instancemethod(_snap.TIntIntVV_GetPivotValN,None,TIntIntVV)
TIntIntVV.BSort = new_instancemethod(_snap.TIntIntVV_BSort,None,TIntIntVV)
TIntIntVV.ISort = new_instancemethod(_snap.TIntIntVV_ISort,None,TIntIntVV)
TIntIntVV.Partition = new_instancemethod(_snap.TIntIntVV_Partition,None,TIntIntVV)
TIntIntVV.QSort = new_instancemethod(_snap.TIntIntVV_QSort,None,TIntIntVV)
TIntIntVV.Sort = new_instancemethod(_snap.TIntIntVV_Sort,None,TIntIntVV)
TIntIntVV.IsSorted = new_instancemethod(_snap.TIntIntVV_IsSorted,None,TIntIntVV)
TIntIntVV.Shuffle = new_instancemethod(_snap.TIntIntVV_Shuffle,None,TIntIntVV)
TIntIntVV.Reverse = new_instancemethod(_snap.TIntIntVV_Reverse,None,TIntIntVV)
TIntIntVV.Merge = new_instancemethod(_snap.TIntIntVV_Merge,None,TIntIntVV)
TIntIntVV.Intrs = new_instancemethod(_snap.TIntIntVV_Intrs,None,TIntIntVV)
TIntIntVV.Union = new_instancemethod(_snap.TIntIntVV_Union,None,TIntIntVV)
TIntIntVV.Diff = new_instancemethod(_snap.TIntIntVV_Diff,None,TIntIntVV)
TIntIntVV.IntrsLen = new_instancemethod(_snap.TIntIntVV_IntrsLen,None,TIntIntVV)
TIntIntVV.UnionLen = new_instancemethod(_snap.TIntIntVV_UnionLen,None,TIntIntVV)
TIntIntVV.Count = new_instancemethod(_snap.TIntIntVV_Count,None,TIntIntVV)
TIntIntVV.SearchBin = new_instancemethod(_snap.TIntIntVV_SearchBin,None,TIntIntVV)
TIntIntVV.SearchForw = new_instancemethod(_snap.TIntIntVV_SearchForw,None,TIntIntVV)
TIntIntVV.SearchBack = new_instancemethod(_snap.TIntIntVV_SearchBack,None,TIntIntVV)
TIntIntVV.SearchVForw = new_instancemethod(_snap.TIntIntVV_SearchVForw,None,TIntIntVV)
TIntIntVV.IsIn = new_instancemethod(_snap.TIntIntVV_IsIn,None,TIntIntVV)
TIntIntVV.IsInBin = new_instancemethod(_snap.TIntIntVV_IsInBin,None,TIntIntVV)
TIntIntVV.GetDat = new_instancemethod(_snap.TIntIntVV_GetDat,None,TIntIntVV)
TIntIntVV.GetAddDat = new_instancemethod(_snap.TIntIntVV_GetAddDat,None,TIntIntVV)
TIntIntVV.GetMxValN = new_instancemethod(_snap.TIntIntVV_GetMxValN,None,TIntIntVV)
TIntIntVV_swigregister = _snap.TIntIntVV_swigregister
TIntIntVV_swigregister(TIntIntVV)

def TIntIntVV_SwapI(*args):
  """
    TIntIntVV_SwapI(TIntV LVal, TIntV RVal)

    Parameters:
        LVal: TVec< TVec< TInt,int >,int >::TIter
        RVal: TVec< TVec< TInt,int >,int >::TIter

    """
  return _snap.TIntIntVV_SwapI(*args)

def TIntIntVV_GetV(*args):
  """
    GetV(TIntV Val1) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &
        Val6: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &
        Val6: TVec< TInt,int > const &
        Val7: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, 
        TIntV Val8) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &
        Val6: TVec< TInt,int > const &
        Val7: TVec< TInt,int > const &
        Val8: TVec< TInt,int > const &

    TIntIntVV_GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, 
        TIntV Val8, TIntV Val9) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &
        Val6: TVec< TInt,int > const &
        Val7: TVec< TInt,int > const &
        Val8: TVec< TInt,int > const &
        Val9: TVec< TInt,int > const &

    """
  return _snap.TIntIntVV_GetV(*args)

class TIntIntVH(object):
    """Proxy of C++ THash<(TInt,TVec<(TInt,int)>)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    HashPrimes = _snap.TIntIntVH_HashPrimes
    def __init__(self, *args): 
        """
        __init__(THash<(TInt,TVec<(TInt,int)>)> self) -> TIntIntVH
        __init__(THash<(TInt,TVec<(TInt,int)>)> self, TIntIntVH Hash) -> TIntIntVH

        Parameters:
            Hash: THash< TInt,TVec< TInt,int > > const &

        __init__(THash<(TInt,TVec<(TInt,int)>)> self, int const & ExpectVals, bool const & _AutoSizeP=False) -> TIntIntVH

        Parameters:
            ExpectVals: int const &
            _AutoSizeP: bool const &

        __init__(THash<(TInt,TVec<(TInt,int)>)> self, int const & ExpectVals) -> TIntIntVH

        Parameters:
            ExpectVals: int const &

        __init__(THash<(TInt,TVec<(TInt,int)>)> self, TSIn SIn) -> TIntIntVH

        Parameters:
            SIn: TSIn &

        """
        _snap.TIntIntVH_swiginit(self,_snap.new_TIntIntVH(*args))
    def Load(self, *args):
        """
        Load(TIntIntVH self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TIntIntVH_Load(self, *args)

    def Save(self, *args):
        """
        Save(TIntIntVH self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TIntIntVH_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TIntIntVH self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TIntIntVH self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TIntIntVH_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TIntIntVH self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TIntIntVH_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TIntIntVH self, TIntIntVH Hash) -> bool

        Parameters:
            Hash: THash< TInt,TVec< TInt,int > > const &

        """
        return _snap.TIntIntVH___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntIntVH self, TIntIntVH Hash) -> bool

        Parameters:
            Hash: THash< TInt,TVec< TInt,int > > const &

        """
        return _snap.TIntIntVH___lt__(self, *args)

    def __call__(self, *args):
        """
        __call__(TIntIntVH self, TInt Key) -> TIntV

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH___call__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TIntIntVH self) -> ::TSize

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_GetMemUsed(self)

    def BegI(self):
        """
        BegI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_BegI(self)

    def EndI(self):
        """
        EndI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_EndI(self)

    def GetI(self, *args):
        """
        GetI(TIntIntVH self, TInt Key) -> THash< TInt,TVec< TInt,int > >::TIter

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_GetI(self, *args)

    def Gen(self, *args):
        """
        Gen(TIntIntVH self, int const & ExpectVals)

        Parameters:
            ExpectVals: int const &

        """
        return _snap.TIntIntVH_Gen(self, *args)

    def Clr(self, *args):
        """
        Clr(TIntIntVH self, bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &
            ResetDat: bool const &

        Clr(TIntIntVH self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TIntIntVH self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_Clr(self, *args)

    def Empty(self):
        """
        Empty(TIntIntVH self) -> bool

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_Empty(self)

    def Len(self):
        """
        Len(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_Len(self)

    def GetPorts(self):
        """
        GetPorts(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_GetPorts(self)

    def IsAutoSize(self):
        """
        IsAutoSize(TIntIntVH self) -> bool

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_IsAutoSize(self)

    def GetMxKeyIds(self):
        """
        GetMxKeyIds(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_GetMxKeyIds(self)

    def GetReservedKeyIds(self):
        """
        GetReservedKeyIds(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_GetReservedKeyIds(self)

    def IsKeyIdEqKeyN(self):
        """
        IsKeyIdEqKeyN(TIntIntVH self) -> bool

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_IsKeyIdEqKeyN(self)

    def DelKey(self, *args):
        """
        DelKey(TIntIntVH self, TInt Key)

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_DelKey(self, *args)

    def DelIfKey(self, *args):
        """
        DelIfKey(TIntIntVH self, TInt Key) -> bool

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_DelIfKey(self, *args)

    def DelKeyId(self, *args):
        """
        DelKeyId(TIntIntVH self, int const & KeyId)

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntIntVH_DelKeyId(self, *args)

    def DelKeyIdV(self, *args):
        """
        DelKeyIdV(TIntIntVH self, TIntV KeyIdV)

        Parameters:
            KeyIdV: TIntV const &

        """
        return _snap.TIntIntVH_DelKeyIdV(self, *args)

    def MarkDelKey(self, *args):
        """
        MarkDelKey(TIntIntVH self, TInt Key)

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_MarkDelKey(self, *args)

    def MarkDelKeyId(self, *args):
        """
        MarkDelKeyId(TIntIntVH self, int const & KeyId)

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntIntVH_MarkDelKeyId(self, *args)

    def GetKey(self, *args):
        """
        GetKey(TIntIntVH self, int const & KeyId) -> TInt

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntIntVH_GetKey(self, *args)

    def GetKeyId(self, *args):
        """
        GetKeyId(TIntIntVH self, TInt Key) -> int

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_GetKeyId(self, *args)

    def GetRndKeyId(self, *args):
        """
        GetRndKeyId(TIntIntVH self, TRnd Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndKeyId(TIntIntVH self, TRnd Rnd, double const & EmptyFrac) -> int

        Parameters:
            Rnd: TRnd &
            EmptyFrac: double const &

        """
        return _snap.TIntIntVH_GetRndKeyId(self, *args)

    def IsKeyId(self, *args):
        """
        IsKeyId(TIntIntVH self, int const & KeyId) -> bool

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntIntVH_IsKeyId(self, *args)

    def GetKeyDat(self, *args):
        """
        GetKeyDat(TIntIntVH self, int const & KeyId, TInt Key, TIntV Dat)

        Parameters:
            KeyId: int const &
            Key: TInt &
            Dat: TVec< TInt,int > &

        """
        return _snap.TIntIntVH_GetKeyDat(self, *args)

    def IsKeyGetDat(self, *args):
        """
        IsKeyGetDat(TIntIntVH self, TInt Key, TIntV Dat) -> bool

        Parameters:
            Key: TInt const &
            Dat: TVec< TInt,int > &

        """
        return _snap.TIntIntVH_IsKeyGetDat(self, *args)

    def FFirstKeyId(self):
        """
        FFirstKeyId(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_FFirstKeyId(self)

    def FNextKeyId(self, *args):
        """
        FNextKeyId(TIntIntVH self, int & KeyId) -> bool

        Parameters:
            KeyId: int &

        """
        return _snap.TIntIntVH_FNextKeyId(self, *args)

    def GetKeyV(self, *args):
        """
        GetKeyV(TIntIntVH self, TIntV KeyV)

        Parameters:
            KeyV: TVec< TInt > &

        """
        return _snap.TIntIntVH_GetKeyV(self, *args)

    def GetDatV(self, *args):
        """
        GetDatV(TIntIntVH self, TIntIntVV DatV)

        Parameters:
            DatV: TVec< TVec< TInt,int > > &

        """
        return _snap.TIntIntVH_GetDatV(self, *args)

    def GetKeyDatPrV(self, *args):
        """
        GetKeyDatPrV(TIntIntVH self, TVec< TPair< TInt,TVec< TInt,int > > > & KeyDatPrV)

        Parameters:
            KeyDatPrV: TVec< TPair< TInt,TVec< TInt,int > > > &

        """
        return _snap.TIntIntVH_GetKeyDatPrV(self, *args)

    def GetDatKeyPrV(self, *args):
        """
        GetDatKeyPrV(TIntIntVH self, TVec< TPair< TVec< TInt,int >,TInt > > & DatKeyPrV)

        Parameters:
            DatKeyPrV: TVec< TPair< TVec< TInt,int >,TInt > > &

        """
        return _snap.TIntIntVH_GetDatKeyPrV(self, *args)

    def GetKeyDatKdV(self, *args):
        """
        GetKeyDatKdV(TIntIntVH self, TVec< TKeyDat< TInt,TVec< TInt,int > > > & KeyDatKdV)

        Parameters:
            KeyDatKdV: TVec< TKeyDat< TInt,TVec< TInt,int > > > &

        """
        return _snap.TIntIntVH_GetKeyDatKdV(self, *args)

    def GetDatKeyKdV(self, *args):
        """
        GetDatKeyKdV(TIntIntVH self, TVec< TKeyDat< TVec< TInt,int >,TInt > > & DatKeyKdV)

        Parameters:
            DatKeyKdV: TVec< TKeyDat< TVec< TInt,int >,TInt > > &

        """
        return _snap.TIntIntVH_GetDatKeyKdV(self, *args)

    def Swap(self, *args):
        """
        Swap(TIntIntVH self, TIntIntVH Hash)

        Parameters:
            Hash: THash< TInt,TVec< TInt,int > > &

        """
        return _snap.TIntIntVH_Swap(self, *args)

    def Defrag(self):
        """
        Defrag(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_Defrag(self)

    def Pack(self):
        """
        Pack(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_Pack(self)

    def Sort(self, *args):
        """
        Sort(TIntIntVH self, bool const & CmpKey, bool const & Asc)

        Parameters:
            CmpKey: bool const &
            Asc: bool const &

        """
        return _snap.TIntIntVH_Sort(self, *args)

    def SortByKey(self, Asc=True):
        """
        SortByKey(TIntIntVH self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        SortByKey(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_SortByKey(self, Asc)

    def SortByDat(self, Asc=True):
        """
        SortByDat(TIntIntVH self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        SortByDat(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_SortByDat(self, Asc)

    def AddKey(self, *args):
        """
        AddKey(TIntIntVH self, TInt Key) -> int

        Parameters:
            Key: TInt const &

        AddKey(TIntIntVH self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntIntVH_AddKey(self, *args)

    def IsKey(self, *args):
        """
        IsKey(TIntIntVH self, TInt Key) -> bool

        Parameters:
            Key: TInt const &

        IsKey(TIntIntVH self, TInt Key, int & KeyId) -> bool

        Parameters:
            Key: TInt const &
            KeyId: int &

        IsKey(TIntIntVH self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntIntVH_IsKey(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TIntIntVH self, TInt Key) -> TIntV

        Parameters:
            Key: TInt const &

        GetDat(TIntIntVH self, TInt Key) -> TIntV

        Parameters:
            Key: TInt const &

        GetDat(TIntIntVH self, int Val) -> TIntV

        Parameters:
            Val: int

        """
        return _snap.TIntIntVH_GetDat(self, *args)

    __swig_destroy__ = _snap.delete_TIntIntVH
TIntIntVH.Load = new_instancemethod(_snap.TIntIntVH_Load,None,TIntIntVH)
TIntIntVH.Save = new_instancemethod(_snap.TIntIntVH_Save,None,TIntIntVH)
TIntIntVH.LoadXml = new_instancemethod(_snap.TIntIntVH_LoadXml,None,TIntIntVH)
TIntIntVH.SaveXml = new_instancemethod(_snap.TIntIntVH_SaveXml,None,TIntIntVH)
TIntIntVH.__eq__ = new_instancemethod(_snap.TIntIntVH___eq__,None,TIntIntVH)
TIntIntVH.__lt__ = new_instancemethod(_snap.TIntIntVH___lt__,None,TIntIntVH)
TIntIntVH.__call__ = new_instancemethod(_snap.TIntIntVH___call__,None,TIntIntVH)
TIntIntVH.GetMemUsed = new_instancemethod(_snap.TIntIntVH_GetMemUsed,None,TIntIntVH)
TIntIntVH.BegI = new_instancemethod(_snap.TIntIntVH_BegI,None,TIntIntVH)
TIntIntVH.EndI = new_instancemethod(_snap.TIntIntVH_EndI,None,TIntIntVH)
TIntIntVH.GetI = new_instancemethod(_snap.TIntIntVH_GetI,None,TIntIntVH)
TIntIntVH.Gen = new_instancemethod(_snap.TIntIntVH_Gen,None,TIntIntVH)
TIntIntVH.Clr = new_instancemethod(_snap.TIntIntVH_Clr,None,TIntIntVH)
TIntIntVH.Empty = new_instancemethod(_snap.TIntIntVH_Empty,None,TIntIntVH)
TIntIntVH.Len = new_instancemethod(_snap.TIntIntVH_Len,None,TIntIntVH)
TIntIntVH.GetPorts = new_instancemethod(_snap.TIntIntVH_GetPorts,None,TIntIntVH)
TIntIntVH.IsAutoSize = new_instancemethod(_snap.TIntIntVH_IsAutoSize,None,TIntIntVH)
TIntIntVH.GetMxKeyIds = new_instancemethod(_snap.TIntIntVH_GetMxKeyIds,None,TIntIntVH)
TIntIntVH.GetReservedKeyIds = new_instancemethod(_snap.TIntIntVH_GetReservedKeyIds,None,TIntIntVH)
TIntIntVH.IsKeyIdEqKeyN = new_instancemethod(_snap.TIntIntVH_IsKeyIdEqKeyN,None,TIntIntVH)
TIntIntVH.DelKey = new_instancemethod(_snap.TIntIntVH_DelKey,None,TIntIntVH)
TIntIntVH.DelIfKey = new_instancemethod(_snap.TIntIntVH_DelIfKey,None,TIntIntVH)
TIntIntVH.DelKeyId = new_instancemethod(_snap.TIntIntVH_DelKeyId,None,TIntIntVH)
TIntIntVH.DelKeyIdV = new_instancemethod(_snap.TIntIntVH_DelKeyIdV,None,TIntIntVH)
TIntIntVH.MarkDelKey = new_instancemethod(_snap.TIntIntVH_MarkDelKey,None,TIntIntVH)
TIntIntVH.MarkDelKeyId = new_instancemethod(_snap.TIntIntVH_MarkDelKeyId,None,TIntIntVH)
TIntIntVH.GetKey = new_instancemethod(_snap.TIntIntVH_GetKey,None,TIntIntVH)
TIntIntVH.GetKeyId = new_instancemethod(_snap.TIntIntVH_GetKeyId,None,TIntIntVH)
TIntIntVH.GetRndKeyId = new_instancemethod(_snap.TIntIntVH_GetRndKeyId,None,TIntIntVH)
TIntIntVH.IsKeyId = new_instancemethod(_snap.TIntIntVH_IsKeyId,None,TIntIntVH)
TIntIntVH.GetKeyDat = new_instancemethod(_snap.TIntIntVH_GetKeyDat,None,TIntIntVH)
TIntIntVH.IsKeyGetDat = new_instancemethod(_snap.TIntIntVH_IsKeyGetDat,None,TIntIntVH)
TIntIntVH.FFirstKeyId = new_instancemethod(_snap.TIntIntVH_FFirstKeyId,None,TIntIntVH)
TIntIntVH.FNextKeyId = new_instancemethod(_snap.TIntIntVH_FNextKeyId,None,TIntIntVH)
TIntIntVH.GetKeyV = new_instancemethod(_snap.TIntIntVH_GetKeyV,None,TIntIntVH)
TIntIntVH.GetDatV = new_instancemethod(_snap.TIntIntVH_GetDatV,None,TIntIntVH)
TIntIntVH.GetKeyDatPrV = new_instancemethod(_snap.TIntIntVH_GetKeyDatPrV,None,TIntIntVH)
TIntIntVH.GetDatKeyPrV = new_instancemethod(_snap.TIntIntVH_GetDatKeyPrV,None,TIntIntVH)
TIntIntVH.GetKeyDatKdV = new_instancemethod(_snap.TIntIntVH_GetKeyDatKdV,None,TIntIntVH)
TIntIntVH.GetDatKeyKdV = new_instancemethod(_snap.TIntIntVH_GetDatKeyKdV,None,TIntIntVH)
TIntIntVH.Swap = new_instancemethod(_snap.TIntIntVH_Swap,None,TIntIntVH)
TIntIntVH.Defrag = new_instancemethod(_snap.TIntIntVH_Defrag,None,TIntIntVH)
TIntIntVH.Pack = new_instancemethod(_snap.TIntIntVH_Pack,None,TIntIntVH)
TIntIntVH.Sort = new_instancemethod(_snap.TIntIntVH_Sort,None,TIntIntVH)
TIntIntVH.SortByKey = new_instancemethod(_snap.TIntIntVH_SortByKey,None,TIntIntVH)
TIntIntVH.SortByDat = new_instancemethod(_snap.TIntIntVH_SortByDat,None,TIntIntVH)
TIntIntVH.AddKey = new_instancemethod(_snap.TIntIntVH_AddKey,None,TIntIntVH)
TIntIntVH.IsKey = new_instancemethod(_snap.TIntIntVH_IsKey,None,TIntIntVH)
TIntIntVH.GetDat = new_instancemethod(_snap.TIntIntVH_GetDat,None,TIntIntVH)
TIntIntVH_swigregister = _snap.TIntIntVH_swigregister
TIntIntVH_swigregister(TIntIntVH)

class TIntH(object):
    """Proxy of C++ THash<(TInt,TInt)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    HashPrimes = _snap.TIntH_HashPrimes
    def __init__(self, *args): 
        """
        __init__(THash<(TInt,TInt)> self) -> TIntH
        __init__(THash<(TInt,TInt)> self, TIntH Hash) -> TIntH

        Parameters:
            Hash: THash< TInt,TInt > const &

        __init__(THash<(TInt,TInt)> self, int const & ExpectVals, bool const & _AutoSizeP=False) -> TIntH

        Parameters:
            ExpectVals: int const &
            _AutoSizeP: bool const &

        __init__(THash<(TInt,TInt)> self, int const & ExpectVals) -> TIntH

        Parameters:
            ExpectVals: int const &

        __init__(THash<(TInt,TInt)> self, TSIn SIn) -> TIntH

        Parameters:
            SIn: TSIn &

        """
        _snap.TIntH_swiginit(self,_snap.new_TIntH(*args))
    def Load(self, *args):
        """
        Load(TIntH self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TIntH_Load(self, *args)

    def Save(self, *args):
        """
        Save(TIntH self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TIntH_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TIntH self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TIntH self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TIntH_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TIntH self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TIntH_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TIntH self, TIntH Hash) -> bool

        Parameters:
            Hash: THash< TInt,TInt > const &

        """
        return _snap.TIntH___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntH self, TIntH Hash) -> bool

        Parameters:
            Hash: THash< TInt,TInt > const &

        """
        return _snap.TIntH___lt__(self, *args)

    def __call__(self, *args):
        """
        __call__(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH___call__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TIntH self) -> ::TSize

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_GetMemUsed(self)

    def BegI(self):
        """
        BegI(TIntH self) -> TIntHI

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_BegI(self)

    def EndI(self):
        """
        EndI(TIntH self) -> TIntHI

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_EndI(self)

    def GetI(self, *args):
        """
        GetI(TIntH self, TInt Key) -> TIntHI

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_GetI(self, *args)

    def Gen(self, *args):
        """
        Gen(TIntH self, int const & ExpectVals)

        Parameters:
            ExpectVals: int const &

        """
        return _snap.TIntH_Gen(self, *args)

    def Clr(self, *args):
        """
        Clr(TIntH self, bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &
            ResetDat: bool const &

        Clr(TIntH self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TIntH self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_Clr(self, *args)

    def Empty(self):
        """
        Empty(TIntH self) -> bool

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_Empty(self)

    def Len(self):
        """
        Len(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_Len(self)

    def GetPorts(self):
        """
        GetPorts(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_GetPorts(self)

    def IsAutoSize(self):
        """
        IsAutoSize(TIntH self) -> bool

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_IsAutoSize(self)

    def GetMxKeyIds(self):
        """
        GetMxKeyIds(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_GetMxKeyIds(self)

    def GetReservedKeyIds(self):
        """
        GetReservedKeyIds(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_GetReservedKeyIds(self)

    def IsKeyIdEqKeyN(self):
        """
        IsKeyIdEqKeyN(TIntH self) -> bool

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_IsKeyIdEqKeyN(self)

    def AddDatId(self, *args):
        """
        AddDatId(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_AddDatId(self, *args)

    def DelKey(self, *args):
        """
        DelKey(TIntH self, TInt Key)

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_DelKey(self, *args)

    def DelIfKey(self, *args):
        """
        DelIfKey(TIntH self, TInt Key) -> bool

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_DelIfKey(self, *args)

    def DelKeyId(self, *args):
        """
        DelKeyId(TIntH self, int const & KeyId)

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntH_DelKeyId(self, *args)

    def DelKeyIdV(self, *args):
        """
        DelKeyIdV(TIntH self, TIntV KeyIdV)

        Parameters:
            KeyIdV: TIntV const &

        """
        return _snap.TIntH_DelKeyIdV(self, *args)

    def MarkDelKey(self, *args):
        """
        MarkDelKey(TIntH self, TInt Key)

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_MarkDelKey(self, *args)

    def MarkDelKeyId(self, *args):
        """
        MarkDelKeyId(TIntH self, int const & KeyId)

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntH_MarkDelKeyId(self, *args)

    def GetKey(self, *args):
        """
        GetKey(TIntH self, int const & KeyId) -> TInt

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntH_GetKey(self, *args)

    def GetKeyId(self, *args):
        """
        GetKeyId(TIntH self, TInt Key) -> int

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_GetKeyId(self, *args)

    def GetRndKeyId(self, *args):
        """
        GetRndKeyId(TIntH self, TRnd Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndKeyId(TIntH self, TRnd Rnd, double const & EmptyFrac) -> int

        Parameters:
            Rnd: TRnd &
            EmptyFrac: double const &

        """
        return _snap.TIntH_GetRndKeyId(self, *args)

    def IsKeyId(self, *args):
        """
        IsKeyId(TIntH self, int const & KeyId) -> bool

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntH_IsKeyId(self, *args)

    def GetKeyDat(self, *args):
        """
        GetKeyDat(TIntH self, int const & KeyId, TInt Key, TInt Dat)

        Parameters:
            KeyId: int const &
            Key: TInt &
            Dat: TInt &

        """
        return _snap.TIntH_GetKeyDat(self, *args)

    def IsKeyGetDat(self, *args):
        """
        IsKeyGetDat(TIntH self, TInt Key, TInt Dat) -> bool

        Parameters:
            Key: TInt const &
            Dat: TInt &

        """
        return _snap.TIntH_IsKeyGetDat(self, *args)

    def FFirstKeyId(self):
        """
        FFirstKeyId(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_FFirstKeyId(self)

    def FNextKeyId(self, *args):
        """
        FNextKeyId(TIntH self, int & KeyId) -> bool

        Parameters:
            KeyId: int &

        """
        return _snap.TIntH_FNextKeyId(self, *args)

    def GetKeyV(self, *args):
        """
        GetKeyV(TIntH self, TIntV KeyV)

        Parameters:
            KeyV: TVec< TInt > &

        """
        return _snap.TIntH_GetKeyV(self, *args)

    def GetDatV(self, *args):
        """
        GetDatV(TIntH self, TIntV DatV)

        Parameters:
            DatV: TVec< TInt > &

        """
        return _snap.TIntH_GetDatV(self, *args)

    def GetKeyDatPrV(self, *args):
        """
        GetKeyDatPrV(TIntH self, TVec< TPair< TInt,TInt > > & KeyDatPrV)

        Parameters:
            KeyDatPrV: TVec< TPair< TInt,TInt > > &

        """
        return _snap.TIntH_GetKeyDatPrV(self, *args)

    def GetDatKeyPrV(self, *args):
        """
        GetDatKeyPrV(TIntH self, TVec< TPair< TInt,TInt > > & DatKeyPrV)

        Parameters:
            DatKeyPrV: TVec< TPair< TInt,TInt > > &

        """
        return _snap.TIntH_GetDatKeyPrV(self, *args)

    def GetKeyDatKdV(self, *args):
        """
        GetKeyDatKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & KeyDatKdV)

        Parameters:
            KeyDatKdV: TVec< TKeyDat< TInt,TInt > > &

        """
        return _snap.TIntH_GetKeyDatKdV(self, *args)

    def GetDatKeyKdV(self, *args):
        """
        GetDatKeyKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & DatKeyKdV)

        Parameters:
            DatKeyKdV: TVec< TKeyDat< TInt,TInt > > &

        """
        return _snap.TIntH_GetDatKeyKdV(self, *args)

    def Swap(self, *args):
        """
        Swap(TIntH self, TIntH Hash)

        Parameters:
            Hash: THash< TInt,TInt > &

        """
        return _snap.TIntH_Swap(self, *args)

    def Defrag(self):
        """
        Defrag(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_Defrag(self)

    def Pack(self):
        """
        Pack(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_Pack(self)

    def Sort(self, *args):
        """
        Sort(TIntH self, bool const & CmpKey, bool const & Asc)

        Parameters:
            CmpKey: bool const &
            Asc: bool const &

        """
        return _snap.TIntH_Sort(self, *args)

    def SortByKey(self, Asc=True):
        """
        SortByKey(TIntH self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        SortByKey(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_SortByKey(self, Asc)

    def SortByDat(self, Asc=True):
        """
        SortByDat(TIntH self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        SortByDat(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_SortByDat(self, Asc)

    def AddKey(self, *args):
        """
        AddKey(TIntH self, TInt Key) -> int

        Parameters:
            Key: TInt const &

        AddKey(TIntH self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntH_AddKey(self, *args)

    def IsKey(self, *args):
        """
        IsKey(TIntH self, TInt Key) -> bool

        Parameters:
            Key: TInt const &

        IsKey(TIntH self, TInt Key, int & KeyId) -> bool

        Parameters:
            Key: TInt const &
            KeyId: int &

        IsKey(TIntH self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntH_IsKey(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        GetDat(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        GetDat(TIntH self, int Val) -> TInt

        Parameters:
            Val: int

        """
        return _snap.TIntH_GetDat(self, *args)

    def AddDat(self, *args):
        """
        AddDat(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        AddDat(TIntH self, TInt Key, TInt Dat) -> TInt

        Parameters:
            Key: TInt const &
            Dat: TInt const &

        AddDat(TIntH self, int Key, int Val) -> TInt

        Parameters:
            Key: int
            Val: int

        """
        return _snap.TIntH_AddDat(self, *args)

    __swig_destroy__ = _snap.delete_TIntH
TIntH.Load = new_instancemethod(_snap.TIntH_Load,None,TIntH)
TIntH.Save = new_instancemethod(_snap.TIntH_Save,None,TIntH)
TIntH.LoadXml = new_instancemethod(_snap.TIntH_LoadXml,None,TIntH)
TIntH.SaveXml = new_instancemethod(_snap.TIntH_SaveXml,None,TIntH)
TIntH.__eq__ = new_instancemethod(_snap.TIntH___eq__,None,TIntH)
TIntH.__lt__ = new_instancemethod(_snap.TIntH___lt__,None,TIntH)
TIntH.__call__ = new_instancemethod(_snap.TIntH___call__,None,TIntH)
TIntH.GetMemUsed = new_instancemethod(_snap.TIntH_GetMemUsed,None,TIntH)
TIntH.BegI = new_instancemethod(_snap.TIntH_BegI,None,TIntH)
TIntH.EndI = new_instancemethod(_snap.TIntH_EndI,None,TIntH)
TIntH.GetI = new_instancemethod(_snap.TIntH_GetI,None,TIntH)
TIntH.Gen = new_instancemethod(_snap.TIntH_Gen,None,TIntH)
TIntH.Clr = new_instancemethod(_snap.TIntH_Clr,None,TIntH)
TIntH.Empty = new_instancemethod(_snap.TIntH_Empty,None,TIntH)
TIntH.Len = new_instancemethod(_snap.TIntH_Len,None,TIntH)
TIntH.GetPorts = new_instancemethod(_snap.TIntH_GetPorts,None,TIntH)
TIntH.IsAutoSize = new_instancemethod(_snap.TIntH_IsAutoSize,None,TIntH)
TIntH.GetMxKeyIds = new_instancemethod(_snap.TIntH_GetMxKeyIds,None,TIntH)
TIntH.GetReservedKeyIds = new_instancemethod(_snap.TIntH_GetReservedKeyIds,None,TIntH)
TIntH.IsKeyIdEqKeyN = new_instancemethod(_snap.TIntH_IsKeyIdEqKeyN,None,TIntH)
TIntH.AddDatId = new_instancemethod(_snap.TIntH_AddDatId,None,TIntH)
TIntH.DelKey = new_instancemethod(_snap.TIntH_DelKey,None,TIntH)
TIntH.DelIfKey = new_instancemethod(_snap.TIntH_DelIfKey,None,TIntH)
TIntH.DelKeyId = new_instancemethod(_snap.TIntH_DelKeyId,None,TIntH)
TIntH.DelKeyIdV = new_instancemethod(_snap.TIntH_DelKeyIdV,None,TIntH)
TIntH.MarkDelKey = new_instancemethod(_snap.TIntH_MarkDelKey,None,TIntH)
TIntH.MarkDelKeyId = new_instancemethod(_snap.TIntH_MarkDelKeyId,None,TIntH)
TIntH.GetKey = new_instancemethod(_snap.TIntH_GetKey,None,TIntH)
TIntH.GetKeyId = new_instancemethod(_snap.TIntH_GetKeyId,None,TIntH)
TIntH.GetRndKeyId = new_instancemethod(_snap.TIntH_GetRndKeyId,None,TIntH)
TIntH.IsKeyId = new_instancemethod(_snap.TIntH_IsKeyId,None,TIntH)
TIntH.GetKeyDat = new_instancemethod(_snap.TIntH_GetKeyDat,None,TIntH)
TIntH.IsKeyGetDat = new_instancemethod(_snap.TIntH_IsKeyGetDat,None,TIntH)
TIntH.FFirstKeyId = new_instancemethod(_snap.TIntH_FFirstKeyId,None,TIntH)
TIntH.FNextKeyId = new_instancemethod(_snap.TIntH_FNextKeyId,None,TIntH)
TIntH.GetKeyV = new_instancemethod(_snap.TIntH_GetKeyV,None,TIntH)
TIntH.GetDatV = new_instancemethod(_snap.TIntH_GetDatV,None,TIntH)
TIntH.GetKeyDatPrV = new_instancemethod(_snap.TIntH_GetKeyDatPrV,None,TIntH)
TIntH.GetDatKeyPrV = new_instancemethod(_snap.TIntH_GetDatKeyPrV,None,TIntH)
TIntH.GetKeyDatKdV = new_instancemethod(_snap.TIntH_GetKeyDatKdV,None,TIntH)
TIntH.GetDatKeyKdV = new_instancemethod(_snap.TIntH_GetDatKeyKdV,None,TIntH)
TIntH.Swap = new_instancemethod(_snap.TIntH_Swap,None,TIntH)
TIntH.Defrag = new_instancemethod(_snap.TIntH_Defrag,None,TIntH)
TIntH.Pack = new_instancemethod(_snap.TIntH_Pack,None,TIntH)
TIntH.Sort = new_instancemethod(_snap.TIntH_Sort,None,TIntH)
TIntH.SortByKey = new_instancemethod(_snap.TIntH_SortByKey,None,TIntH)
TIntH.SortByDat = new_instancemethod(_snap.TIntH_SortByDat,None,TIntH)
TIntH.AddKey = new_instancemethod(_snap.TIntH_AddKey,None,TIntH)
TIntH.IsKey = new_instancemethod(_snap.TIntH_IsKey,None,TIntH)
TIntH.GetDat = new_instancemethod(_snap.TIntH_GetDat,None,TIntH)
TIntH.AddDat = new_instancemethod(_snap.TIntH_AddDat,None,TIntH)
TIntH_swigregister = _snap.TIntH_swigregister
TIntH_swigregister(TIntH)

class TIntHI(object):
    """Proxy of C++ THashKeyDatI<(TInt,TInt)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(THashKeyDatI<(TInt,TInt)> self) -> TIntHI
        __init__(THashKeyDatI<(TInt,TInt)> self, TIntHI _HashKeyDatI) -> TIntHI

        Parameters:
            _HashKeyDatI: THashKeyDatI< TInt,TInt > const &

        __init__(THashKeyDatI<(TInt,TInt)> self, THashKeyDatI< TInt,TInt >::THKeyDat const * _KeyDatI, THashKeyDatI< TInt,TInt >::THKeyDat const * _EndI) -> TIntHI

        Parameters:
            _KeyDatI: THashKeyDatI< TInt,TInt >::THKeyDat const *
            _EndI: THashKeyDatI< TInt,TInt >::THKeyDat const *

        """
        _snap.TIntHI_swiginit(self,_snap.new_TIntHI(*args))
    def __eq__(self, *args):
        """
        __eq__(TIntHI self, TIntHI HashKeyDatI) -> bool

        Parameters:
            HashKeyDatI: THashKeyDatI< TInt,TInt > const &

        """
        return _snap.TIntHI___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntHI self, TIntHI HashKeyDatI) -> bool

        Parameters:
            HashKeyDatI: THashKeyDatI< TInt,TInt > const &

        """
        return _snap.TIntHI___lt__(self, *args)

    def __ref__(self):
        """
        __ref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat &

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI___ref__(self)

    def __call__(self):
        """
        __call__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat &

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI___call__(self)

    def __deref__(self):
        """
        __deref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat *

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI___deref__(self)

    def Next(self):
        """
        Next(TIntHI self) -> TIntHI

        Parameters:
            self: THashKeyDatI< TInt,TInt > *

        """
        return _snap.TIntHI_Next(self)

    def IsEmpty(self):
        """
        IsEmpty(TIntHI self) -> bool

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI_IsEmpty(self)

    def IsEnd(self):
        """
        IsEnd(TIntHI self) -> bool

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI_IsEnd(self)

    def GetKey(self):
        """
        GetKey(TIntHI self) -> TInt

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI_GetKey(self)

    def GetDat(self, *args):
        """
        GetDat(TIntHI self) -> TInt
        GetDat(TIntHI self) -> TInt

        Parameters:
            self: THashKeyDatI< TInt,TInt > *

        """
        return _snap.TIntHI_GetDat(self, *args)

    __swig_destroy__ = _snap.delete_TIntHI
TIntHI.__eq__ = new_instancemethod(_snap.TIntHI___eq__,None,TIntHI)
TIntHI.__lt__ = new_instancemethod(_snap.TIntHI___lt__,None,TIntHI)
TIntHI.__ref__ = new_instancemethod(_snap.TIntHI___ref__,None,TIntHI)
TIntHI.__call__ = new_instancemethod(_snap.TIntHI___call__,None,TIntHI)
TIntHI.__deref__ = new_instancemethod(_snap.TIntHI___deref__,None,TIntHI)
TIntHI.Next = new_instancemethod(_snap.TIntHI_Next,None,TIntHI)
TIntHI.IsEmpty = new_instancemethod(_snap.TIntHI_IsEmpty,None,TIntHI)
TIntHI.IsEnd = new_instancemethod(_snap.TIntHI_IsEnd,None,TIntHI)
TIntHI.GetKey = new_instancemethod(_snap.TIntHI_GetKey,None,TIntHI)
TIntHI.GetDat = new_instancemethod(_snap.TIntHI_GetDat,None,TIntHI)
TIntHI_swigregister = _snap.TIntHI_swigregister
TIntHI_swigregister(TIntHI)

class TStrV(object):
    """Proxy of C++ TVec<(TStr,int)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TStrV
    def __init__(self, *args): 
        """
        __init__(TVec<(TStr,int)> self) -> TStrV
        __init__(TVec<(TStr,int)> self, TStrV Vec) -> TStrV

        Parameters:
            Vec: TVec< TStr,int > const &

        __init__(TVec<(TStr,int)> self, int const & _Vals) -> TStrV

        Parameters:
            _Vals: int const &

        __init__(TVec<(TStr,int)> self, int const & _MxVals, int const & _Vals) -> TStrV

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        __init__(TVec<(TStr,int)> self, TStr _ValT, int const & _Vals) -> TStrV

        Parameters:
            _ValT: TStr *
            _Vals: int const &

        __init__(TVec<(TStr,int)> self, TSIn SIn) -> TStrV

        Parameters:
            SIn: TSIn &

        """
        _snap.TStrV_swiginit(self,_snap.new_TStrV(*args))
    def Load(self, *args):
        """
        Load(TStrV self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TStrV_Load(self, *args)

    def Save(self, *args):
        """
        Save(TStrV self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TStrV_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TStrV self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TStrV self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TStrV_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TStrV self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TStrV_SaveXml(self, *args)

    def __add__(self, *args):
        """
        __add__(TStrV self, TStr Val) -> TStrV

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV___add__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TStrV self, TStrV Vec) -> bool

        Parameters:
            Vec: TVec< TStr,int > const &

        """
        return _snap.TStrV___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TStrV self, TStrV Vec) -> bool

        Parameters:
            Vec: TVec< TStr,int > const &

        """
        return _snap.TStrV___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetMemUsed(self)

    def GetMemSize(self):
        """
        GetMemSize(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetMemSize(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetSecHashCd(self)

    def Gen(self, *args):
        """
        Gen(TStrV self, int const & _Vals)

        Parameters:
            _Vals: int const &

        Gen(TStrV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TStrV_Gen(self, *args)

    def GenExt(self, *args):
        """
        GenExt(TStrV self, TStr _ValT, int const & _Vals)

        Parameters:
            _ValT: TStr *
            _Vals: int const &

        """
        return _snap.TStrV_GenExt(self, *args)

    def IsExt(self):
        """
        IsExt(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_IsExt(self)

    def Reserve(self, *args):
        """
        Reserve(TStrV self, int const & _MxVals)

        Parameters:
            _MxVals: int const &

        Reserve(TStrV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TStrV_Reserve(self, *args)

    def Clr(self, *args):
        """
        Clr(TStrV self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TStrV self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Clr(self, *args)

    def Trunc(self, *args):
        """
        Trunc(TStrV self, int const & _Vals=-1)

        Parameters:
            _Vals: int const &

        Trunc(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Trunc(self, *args)

    def Pack(self):
        """
        Pack(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Pack(self)

    def MoveFrom(self, *args):
        """
        MoveFrom(TStrV self, TStrV Vec)

        Parameters:
            Vec: TVec< TStr,int > &

        """
        return _snap.TStrV_MoveFrom(self, *args)

    def Empty(self):
        """
        Empty(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_Empty(self)

    def Len(self):
        """
        Len(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_Len(self)

    def Reserved(self):
        """
        Reserved(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_Reserved(self)

    def Last(self, *args):
        """
        Last(TStrV self) -> TStr
        Last(TStrV self) -> TStr

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Last(self, *args)

    def LastValN(self):
        """
        LastValN(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_LastValN(self)

    def LastLast(self, *args):
        """
        LastLast(TStrV self) -> TStr
        LastLast(TStrV self) -> TStr

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_LastLast(self, *args)

    def BegI(self):
        """
        BegI(TStrV self) -> TStr

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_BegI(self)

    def EndI(self):
        """
        EndI(TStrV self) -> TStr

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_EndI(self)

    def GetI(self, *args):
        """
        GetI(TStrV self, int const & ValN) -> TStr

        Parameters:
            ValN: int const &

        """
        return _snap.TStrV_GetI(self, *args)

    def AddV(self, *args):
        """
        AddV(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_AddV(self, *args)

    def AddSorted(self, *args):
        """
        AddSorted(TStrV self, TStr Val, bool const & Asc=True, int const & _MxVals=-1) -> int

        Parameters:
            Val: TStr const &
            Asc: bool const &
            _MxVals: int const &

        AddSorted(TStrV self, TStr Val, bool const & Asc=True) -> int

        Parameters:
            Val: TStr const &
            Asc: bool const &

        AddSorted(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_AddSorted(self, *args)

    def AddBackSorted(self, *args):
        """
        AddBackSorted(TStrV self, TStr Val, bool const & Asc) -> int

        Parameters:
            Val: TStr const &
            Asc: bool const &

        """
        return _snap.TStrV_AddBackSorted(self, *args)

    def AddVMerged(self, *args):
        """
        AddVMerged(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_AddVMerged(self, *args)

    def AddUnique(self, *args):
        """
        AddUnique(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_AddUnique(self, *args)

    def GetVal(self, *args):
        """
        GetVal(TStrV self, int const & ValN) -> TStr

        Parameters:
            ValN: int const &

        GetVal(TStrV self, int const & ValN) -> TStr

        Parameters:
            ValN: int const &

        """
        return _snap.TStrV_GetVal(self, *args)

    def GetSubValV(self, *args):
        """
        GetSubValV(TStrV self, int const & BValN, int const & EValN, TStrV ValV)

        Parameters:
            BValN: int const &
            EValN: int const &
            ValV: TVec< TStr,int > &

        """
        return _snap.TStrV_GetSubValV(self, *args)

    def Ins(self, *args):
        """
        Ins(TStrV self, int const & ValN, TStr Val)

        Parameters:
            ValN: int const &
            Val: TStr const &

        """
        return _snap.TStrV_Ins(self, *args)

    def Del(self, *args):
        """
        Del(TStrV self, int const & ValN)

        Parameters:
            ValN: int const &

        Del(TStrV self, int const & MnValN, int const & MxValN)

        Parameters:
            MnValN: int const &
            MxValN: int const &

        """
        return _snap.TStrV_Del(self, *args)

    def DelLast(self):
        """
        DelLast(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_DelLast(self)

    def DelIfIn(self, *args):
        """
        DelIfIn(TStrV self, TStr Val) -> bool

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_DelIfIn(self, *args)

    def DelAll(self, *args):
        """
        DelAll(TStrV self, TStr Val)

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_DelAll(self, *args)

    def PutAll(self, *args):
        """
        PutAll(TStrV self, TStr Val)

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_PutAll(self, *args)

    def Swap(self, *args):
        """
        Swap(TStrV self, TStrV Vec)

        Parameters:
            Vec: TVec< TStr,int > &

        Swap(TStrV self, int const & ValN1, int const & ValN2)

        Parameters:
            ValN1: int const &
            ValN2: int const &

        """
        return _snap.TStrV_Swap(self, *args)

    def SwapI(*args):
        """
        SwapI(TStr LVal, TStr RVal)

        Parameters:
            LVal: TVec< TStr,int >::TIter
            RVal: TVec< TStr,int >::TIter

        """
        return _snap.TStrV_SwapI(*args)

    SwapI = staticmethod(SwapI)
    def NextPerm(self):
        """
        NextPerm(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_NextPerm(self)

    def PrevPerm(self):
        """
        PrevPerm(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_PrevPerm(self)

    def GetPivotValN(self, *args):
        """
        GetPivotValN(TStrV self, int const & LValN, int const & RValN) -> int

        Parameters:
            LValN: int const &
            RValN: int const &

        """
        return _snap.TStrV_GetPivotValN(self, *args)

    def BSort(self, *args):
        """
        BSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TStrV_BSort(self, *args)

    def ISort(self, *args):
        """
        ISort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TStrV_ISort(self, *args)

    def Partition(self, *args):
        """
        Partition(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TStrV_Partition(self, *args)

    def QSort(self, *args):
        """
        QSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TStrV_QSort(self, *args)

    def Sort(self, Asc=True):
        """
        Sort(TStrV self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        Sort(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Sort(self, Asc)

    def IsSorted(self, Asc=True):
        """
        IsSorted(TStrV self, bool const & Asc=True) -> bool

        Parameters:
            Asc: bool const &

        IsSorted(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_IsSorted(self, Asc)

    def Shuffle(self, *args):
        """
        Shuffle(TStrV self, TRnd Rnd)

        Parameters:
            Rnd: TRnd &

        """
        return _snap.TStrV_Shuffle(self, *args)

    def Reverse(self, *args):
        """
        Reverse(TStrV self)
        Reverse(TStrV self, int LValN, int RValN)

        Parameters:
            LValN: int
            RValN: int

        """
        return _snap.TStrV_Reverse(self, *args)

    def Merge(self):
        """
        Merge(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Merge(self)

    def Intrs(self, *args):
        """
        Intrs(TStrV self, TStrV ValV)

        Parameters:
            ValV: TVec< TStr,int > const &

        Intrs(TStrV self, TStrV ValV, TStrV DstValV)

        Parameters:
            ValV: TVec< TStr,int > const &
            DstValV: TVec< TStr,int > &

        """
        return _snap.TStrV_Intrs(self, *args)

    def Union(self, *args):
        """
        Union(TStrV self, TStrV ValV)

        Parameters:
            ValV: TVec< TStr,int > const &

        Union(TStrV self, TStrV ValV, TStrV DstValV)

        Parameters:
            ValV: TVec< TStr,int > const &
            DstValV: TVec< TStr,int > &

        """
        return _snap.TStrV_Union(self, *args)

    def Diff(self, *args):
        """
        Diff(TStrV self, TStrV ValV)

        Parameters:
            ValV: TVec< TStr,int > const &

        Diff(TStrV self, TStrV ValV, TStrV DstValV)

        Parameters:
            ValV: TVec< TStr,int > const &
            DstValV: TVec< TStr,int > &

        """
        return _snap.TStrV_Diff(self, *args)

    def IntrsLen(self, *args):
        """
        IntrsLen(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_IntrsLen(self, *args)

    def UnionLen(self, *args):
        """
        UnionLen(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_UnionLen(self, *args)

    def Count(self, *args):
        """
        Count(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_Count(self, *args)

    def SearchBin(self, *args):
        """
        SearchBin(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        SearchBin(TStrV self, TStr Val, int & InsValN) -> int

        Parameters:
            Val: TStr const &
            InsValN: int &

        """
        return _snap.TStrV_SearchBin(self, *args)

    def SearchForw(self, *args):
        """
        SearchForw(TStrV self, TStr Val, int const & BValN=0) -> int

        Parameters:
            Val: TStr const &
            BValN: int const &

        SearchForw(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_SearchForw(self, *args)

    def SearchBack(self, *args):
        """
        SearchBack(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_SearchBack(self, *args)

    def SearchVForw(self, *args):
        """
        SearchVForw(TStrV self, TStrV ValV, int const & BValN=0) -> int

        Parameters:
            ValV: TVec< TStr,int > const &
            BValN: int const &

        SearchVForw(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_SearchVForw(self, *args)

    def IsIn(self, *args):
        """
        IsIn(TStrV self, TStr Val) -> bool

        Parameters:
            Val: TStr const &

        IsIn(TStrV self, TStr Val, int & ValN) -> bool

        Parameters:
            Val: TStr const &
            ValN: int &

        """
        return _snap.TStrV_IsIn(self, *args)

    def IsInBin(self, *args):
        """
        IsInBin(TStrV self, TStr Val) -> bool

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_IsInBin(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TStrV self, TStr Val) -> TStr

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_GetDat(self, *args)

    def GetAddDat(self, *args):
        """
        GetAddDat(TStrV self, TStr Val) -> TStr

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_GetAddDat(self, *args)

    def GetMxValN(self):
        """
        GetMxValN(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetMxValN(self)

    def GetV(*args):
        """
        GetV(TStr Val1) -> TStrV

        Parameters:
            Val1: TStr const &

        GetV(TStr Val1, TStr Val2) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &
            Val6: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &
            Val6: TStr const &
            Val7: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &
            Val6: TStr const &
            Val7: TStr const &
            Val8: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8, 
            TStr Val9) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &
            Val6: TStr const &
            Val7: TStr const &
            Val8: TStr const &
            Val9: TStr const &

        """
        return _snap.TStrV_GetV(*args)

    GetV = staticmethod(GetV)
TStrV.Load = new_instancemethod(_snap.TStrV_Load,None,TStrV)
TStrV.Save = new_instancemethod(_snap.TStrV_Save,None,TStrV)
TStrV.LoadXml = new_instancemethod(_snap.TStrV_LoadXml,None,TStrV)
TStrV.SaveXml = new_instancemethod(_snap.TStrV_SaveXml,None,TStrV)
TStrV.__add__ = new_instancemethod(_snap.TStrV___add__,None,TStrV)
TStrV.__eq__ = new_instancemethod(_snap.TStrV___eq__,None,TStrV)
TStrV.__lt__ = new_instancemethod(_snap.TStrV___lt__,None,TStrV)
TStrV.GetMemUsed = new_instancemethod(_snap.TStrV_GetMemUsed,None,TStrV)
TStrV.GetMemSize = new_instancemethod(_snap.TStrV_GetMemSize,None,TStrV)
TStrV.GetPrimHashCd = new_instancemethod(_snap.TStrV_GetPrimHashCd,None,TStrV)
TStrV.GetSecHashCd = new_instancemethod(_snap.TStrV_GetSecHashCd,None,TStrV)
TStrV.Gen = new_instancemethod(_snap.TStrV_Gen,None,TStrV)
TStrV.GenExt = new_instancemethod(_snap.TStrV_GenExt,None,TStrV)
TStrV.IsExt = new_instancemethod(_snap.TStrV_IsExt,None,TStrV)
TStrV.Reserve = new_instancemethod(_snap.TStrV_Reserve,None,TStrV)
TStrV.Clr = new_instancemethod(_snap.TStrV_Clr,None,TStrV)
TStrV.Trunc = new_instancemethod(_snap.TStrV_Trunc,None,TStrV)
TStrV.Pack = new_instancemethod(_snap.TStrV_Pack,None,TStrV)
TStrV.MoveFrom = new_instancemethod(_snap.TStrV_MoveFrom,None,TStrV)
TStrV.Empty = new_instancemethod(_snap.TStrV_Empty,None,TStrV)
TStrV.Len = new_instancemethod(_snap.TStrV_Len,None,TStrV)
TStrV.Reserved = new_instancemethod(_snap.TStrV_Reserved,None,TStrV)
TStrV.Last = new_instancemethod(_snap.TStrV_Last,None,TStrV)
TStrV.LastValN = new_instancemethod(_snap.TStrV_LastValN,None,TStrV)
TStrV.LastLast = new_instancemethod(_snap.TStrV_LastLast,None,TStrV)
TStrV.BegI = new_instancemethod(_snap.TStrV_BegI,None,TStrV)
TStrV.EndI = new_instancemethod(_snap.TStrV_EndI,None,TStrV)
TStrV.GetI = new_instancemethod(_snap.TStrV_GetI,None,TStrV)
TStrV.AddV = new_instancemethod(_snap.TStrV_AddV,None,TStrV)
TStrV.AddSorted = new_instancemethod(_snap.TStrV_AddSorted,None,TStrV)
TStrV.AddBackSorted = new_instancemethod(_snap.TStrV_AddBackSorted,None,TStrV)
TStrV.AddVMerged = new_instancemethod(_snap.TStrV_AddVMerged,None,TStrV)
TStrV.AddUnique = new_instancemethod(_snap.TStrV_AddUnique,None,TStrV)
TStrV.GetVal = new_instancemethod(_snap.TStrV_GetVal,None,TStrV)
TStrV.GetSubValV = new_instancemethod(_snap.TStrV_GetSubValV,None,TStrV)
TStrV.Ins = new_instancemethod(_snap.TStrV_Ins,None,TStrV)
TStrV.Del = new_instancemethod(_snap.TStrV_Del,None,TStrV)
TStrV.DelLast = new_instancemethod(_snap.TStrV_DelLast,None,TStrV)
TStrV.DelIfIn = new_instancemethod(_snap.TStrV_DelIfIn,None,TStrV)
TStrV.DelAll = new_instancemethod(_snap.TStrV_DelAll,None,TStrV)
TStrV.PutAll = new_instancemethod(_snap.TStrV_PutAll,None,TStrV)
TStrV.Swap = new_instancemethod(_snap.TStrV_Swap,None,TStrV)
TStrV.NextPerm = new_instancemethod(_snap.TStrV_NextPerm,None,TStrV)
TStrV.PrevPerm = new_instancemethod(_snap.TStrV_PrevPerm,None,TStrV)
TStrV.GetPivotValN = new_instancemethod(_snap.TStrV_GetPivotValN,None,TStrV)
TStrV.BSort = new_instancemethod(_snap.TStrV_BSort,None,TStrV)
TStrV.ISort = new_instancemethod(_snap.TStrV_ISort,None,TStrV)
TStrV.Partition = new_instancemethod(_snap.TStrV_Partition,None,TStrV)
TStrV.QSort = new_instancemethod(_snap.TStrV_QSort,None,TStrV)
TStrV.Sort = new_instancemethod(_snap.TStrV_Sort,None,TStrV)
TStrV.IsSorted = new_instancemethod(_snap.TStrV_IsSorted,None,TStrV)
TStrV.Shuffle = new_instancemethod(_snap.TStrV_Shuffle,None,TStrV)
TStrV.Reverse = new_instancemethod(_snap.TStrV_Reverse,None,TStrV)
TStrV.Merge = new_instancemethod(_snap.TStrV_Merge,None,TStrV)
TStrV.Intrs = new_instancemethod(_snap.TStrV_Intrs,None,TStrV)
TStrV.Union = new_instancemethod(_snap.TStrV_Union,None,TStrV)
TStrV.Diff = new_instancemethod(_snap.TStrV_Diff,None,TStrV)
TStrV.IntrsLen = new_instancemethod(_snap.TStrV_IntrsLen,None,TStrV)
TStrV.UnionLen = new_instancemethod(_snap.TStrV_UnionLen,None,TStrV)
TStrV.Count = new_instancemethod(_snap.TStrV_Count,None,TStrV)
TStrV.SearchBin = new_instancemethod(_snap.TStrV_SearchBin,None,TStrV)
TStrV.SearchForw = new_instancemethod(_snap.TStrV_SearchForw,None,TStrV)
TStrV.SearchBack = new_instancemethod(_snap.TStrV_SearchBack,None,TStrV)
TStrV.SearchVForw = new_instancemethod(_snap.TStrV_SearchVForw,None,TStrV)
TStrV.IsIn = new_instancemethod(_snap.TStrV_IsIn,None,TStrV)
TStrV.IsInBin = new_instancemethod(_snap.TStrV_IsInBin,None,TStrV)
TStrV.GetDat = new_instancemethod(_snap.TStrV_GetDat,None,TStrV)
TStrV.GetAddDat = new_instancemethod(_snap.TStrV_GetAddDat,None,TStrV)
TStrV.GetMxValN = new_instancemethod(_snap.TStrV_GetMxValN,None,TStrV)
TStrV_swigregister = _snap.TStrV_swigregister
TStrV_swigregister(TStrV)

def TStrV_SwapI(*args):
  """
    TStrV_SwapI(TStr LVal, TStr RVal)

    Parameters:
        LVal: TVec< TStr,int >::TIter
        RVal: TVec< TStr,int >::TIter

    """
  return _snap.TStrV_SwapI(*args)

def TStrV_GetV(*args):
  """
    GetV(TStr Val1) -> TStrV

    Parameters:
        Val1: TStr const &

    GetV(TStr Val1, TStr Val2) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &
        Val6: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &
        Val6: TStr const &
        Val7: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &
        Val6: TStr const &
        Val7: TStr const &
        Val8: TStr const &

    TStrV_GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8, 
        TStr Val9) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &
        Val6: TStr const &
        Val7: TStr const &
        Val8: TStr const &
        Val9: TStr const &

    """
  return _snap.TStrV_GetV(*args)

class TNGraphNodeI(object):
    """Proxy of C++ TNGraphNodeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNGraphNodeI self) -> TNGraphNodeI
        __init__(TNGraphNodeI self, TNGraph::TNodeI const & NodeI) -> TNGraphNodeI

        Parameters:
            NodeI: TNGraph::TNodeI const &

        """
        _snap.TNGraphNodeI_swiginit(self,_snap.new_TNGraphNodeI(*args))
    def Next(self):
        """
        Next(TNGraphNodeI self) -> TNGraphNodeI

        Parameters:
            self: TNGraphNodeI *

        """
        return _snap.TNGraphNodeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool

        Parameters:
            NodeI: TNGraphNodeI const &

        """
        return _snap.TNGraphNodeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool

        Parameters:
            NodeI: TNGraphNodeI const &

        """
        return _snap.TNGraphNodeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TNGraphNodeI self) -> int

        Parameters:
            self: TNGraphNodeI const *

        """
        return _snap.TNGraphNodeI_GetId(self)

    def GetDeg(self):
        """
        GetDeg(TNGraphNodeI self) -> int

        Parameters:
            self: TNGraphNodeI const *

        """
        return _snap.TNGraphNodeI_GetDeg(self)

    def GetInDeg(self):
        """
        GetInDeg(TNGraphNodeI self) -> int

        Parameters:
            self: TNGraphNodeI const *

        """
        return _snap.TNGraphNodeI_GetInDeg(self)

    def GetOutDeg(self):
        """
        GetOutDeg(TNGraphNodeI self) -> int

        Parameters:
            self: TNGraphNodeI const *

        """
        return _snap.TNGraphNodeI_GetOutDeg(self)

    def GetInNId(self, *args):
        """
        GetInNId(TNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNGraphNodeI_GetInNId(self, *args)

    def GetOutNId(self, *args):
        """
        GetOutNId(TNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNGraphNodeI_GetOutNId(self, *args)

    def GetNbrNId(self, *args):
        """
        GetNbrNId(TNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNGraphNodeI_GetNbrNId(self, *args)

    def IsInNId(self, *args):
        """
        IsInNId(TNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNGraphNodeI_IsInNId(self, *args)

    def IsOutNId(self, *args):
        """
        IsOutNId(TNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNGraphNodeI_IsOutNId(self, *args)

    def IsNbrNId(self, *args):
        """
        IsNbrNId(TNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNGraphNodeI_IsNbrNId(self, *args)

    __swig_destroy__ = _snap.delete_TNGraphNodeI
TNGraphNodeI.Next = new_instancemethod(_snap.TNGraphNodeI_Next,None,TNGraphNodeI)
TNGraphNodeI.__lt__ = new_instancemethod(_snap.TNGraphNodeI___lt__,None,TNGraphNodeI)
TNGraphNodeI.__eq__ = new_instancemethod(_snap.TNGraphNodeI___eq__,None,TNGraphNodeI)
TNGraphNodeI.GetId = new_instancemethod(_snap.TNGraphNodeI_GetId,None,TNGraphNodeI)
TNGraphNodeI.GetDeg = new_instancemethod(_snap.TNGraphNodeI_GetDeg,None,TNGraphNodeI)
TNGraphNodeI.GetInDeg = new_instancemethod(_snap.TNGraphNodeI_GetInDeg,None,TNGraphNodeI)
TNGraphNodeI.GetOutDeg = new_instancemethod(_snap.TNGraphNodeI_GetOutDeg,None,TNGraphNodeI)
TNGraphNodeI.GetInNId = new_instancemethod(_snap.TNGraphNodeI_GetInNId,None,TNGraphNodeI)
TNGraphNodeI.GetOutNId = new_instancemethod(_snap.TNGraphNodeI_GetOutNId,None,TNGraphNodeI)
TNGraphNodeI.GetNbrNId = new_instancemethod(_snap.TNGraphNodeI_GetNbrNId,None,TNGraphNodeI)
TNGraphNodeI.IsInNId = new_instancemethod(_snap.TNGraphNodeI_IsInNId,None,TNGraphNodeI)
TNGraphNodeI.IsOutNId = new_instancemethod(_snap.TNGraphNodeI_IsOutNId,None,TNGraphNodeI)
TNGraphNodeI.IsNbrNId = new_instancemethod(_snap.TNGraphNodeI_IsNbrNId,None,TNGraphNodeI)
TNGraphNodeI_swigregister = _snap.TNGraphNodeI_swigregister
TNGraphNodeI_swigregister(TNGraphNodeI)

class TNGraphEdgeI(object):
    """Proxy of C++ TNGraphEdgeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNGraphEdgeI self) -> TNGraphEdgeI
        __init__(TNGraphEdgeI self, TNGraph::TEdgeI const & EdgeI) -> TNGraphEdgeI

        Parameters:
            EdgeI: TNGraph::TEdgeI const &

        """
        _snap.TNGraphEdgeI_swiginit(self,_snap.new_TNGraphEdgeI(*args))
    def Next(self):
        """
        Next(TNGraphEdgeI self) -> TNGraphEdgeI

        Parameters:
            self: TNGraphEdgeI *

        """
        return _snap.TNGraphEdgeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TNGraphEdgeI const &

        """
        return _snap.TNGraphEdgeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TNGraphEdgeI const &

        """
        return _snap.TNGraphEdgeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TNGraphEdgeI self) -> int

        Parameters:
            self: TNGraphEdgeI const *

        """
        return _snap.TNGraphEdgeI_GetId(self)

    def GetSrcNId(self):
        """
        GetSrcNId(TNGraphEdgeI self) -> int

        Parameters:
            self: TNGraphEdgeI const *

        """
        return _snap.TNGraphEdgeI_GetSrcNId(self)

    def GetDstNId(self):
        """
        GetDstNId(TNGraphEdgeI self) -> int

        Parameters:
            self: TNGraphEdgeI const *

        """
        return _snap.TNGraphEdgeI_GetDstNId(self)

    __swig_destroy__ = _snap.delete_TNGraphEdgeI
TNGraphEdgeI.Next = new_instancemethod(_snap.TNGraphEdgeI_Next,None,TNGraphEdgeI)
TNGraphEdgeI.__lt__ = new_instancemethod(_snap.TNGraphEdgeI___lt__,None,TNGraphEdgeI)
TNGraphEdgeI.__eq__ = new_instancemethod(_snap.TNGraphEdgeI___eq__,None,TNGraphEdgeI)
TNGraphEdgeI.GetId = new_instancemethod(_snap.TNGraphEdgeI_GetId,None,TNGraphEdgeI)
TNGraphEdgeI.GetSrcNId = new_instancemethod(_snap.TNGraphEdgeI_GetSrcNId,None,TNGraphEdgeI)
TNGraphEdgeI.GetDstNId = new_instancemethod(_snap.TNGraphEdgeI_GetDstNId,None,TNGraphEdgeI)
TNGraphEdgeI_swigregister = _snap.TNGraphEdgeI_swigregister
TNGraphEdgeI_swigregister(TNGraphEdgeI)

class TUNGraphNodeI(object):
    """Proxy of C++ TUNGraphNodeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TUNGraphNodeI self) -> TUNGraphNodeI
        __init__(TUNGraphNodeI self, TUNGraph::TNodeI const & NodeI) -> TUNGraphNodeI

        Parameters:
            NodeI: TUNGraph::TNodeI const &

        """
        _snap.TUNGraphNodeI_swiginit(self,_snap.new_TUNGraphNodeI(*args))
    def Next(self):
        """
        Next(TUNGraphNodeI self) -> TUNGraphNodeI

        Parameters:
            self: TUNGraphNodeI *

        """
        return _snap.TUNGraphNodeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool

        Parameters:
            NodeI: TUNGraphNodeI const &

        """
        return _snap.TUNGraphNodeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool

        Parameters:
            NodeI: TUNGraphNodeI const &

        """
        return _snap.TUNGraphNodeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TUNGraphNodeI self) -> int

        Parameters:
            self: TUNGraphNodeI const *

        """
        return _snap.TUNGraphNodeI_GetId(self)

    def GetDeg(self):
        """
        GetDeg(TUNGraphNodeI self) -> int

        Parameters:
            self: TUNGraphNodeI const *

        """
        return _snap.TUNGraphNodeI_GetDeg(self)

    def GetInDeg(self):
        """
        GetInDeg(TUNGraphNodeI self) -> int

        Parameters:
            self: TUNGraphNodeI const *

        """
        return _snap.TUNGraphNodeI_GetInDeg(self)

    def GetOutDeg(self):
        """
        GetOutDeg(TUNGraphNodeI self) -> int

        Parameters:
            self: TUNGraphNodeI const *

        """
        return _snap.TUNGraphNodeI_GetOutDeg(self)

    def GetInNId(self, *args):
        """
        GetInNId(TUNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TUNGraphNodeI_GetInNId(self, *args)

    def GetOutNId(self, *args):
        """
        GetOutNId(TUNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TUNGraphNodeI_GetOutNId(self, *args)

    def GetNbrNId(self, *args):
        """
        GetNbrNId(TUNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TUNGraphNodeI_GetNbrNId(self, *args)

    def IsInNId(self, *args):
        """
        IsInNId(TUNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraphNodeI_IsInNId(self, *args)

    def IsOutNId(self, *args):
        """
        IsOutNId(TUNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraphNodeI_IsOutNId(self, *args)

    def IsNbrNId(self, *args):
        """
        IsNbrNId(TUNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraphNodeI_IsNbrNId(self, *args)

    __swig_destroy__ = _snap.delete_TUNGraphNodeI
TUNGraphNodeI.Next = new_instancemethod(_snap.TUNGraphNodeI_Next,None,TUNGraphNodeI)
TUNGraphNodeI.__lt__ = new_instancemethod(_snap.TUNGraphNodeI___lt__,None,TUNGraphNodeI)
TUNGraphNodeI.__eq__ = new_instancemethod(_snap.TUNGraphNodeI___eq__,None,TUNGraphNodeI)
TUNGraphNodeI.GetId = new_instancemethod(_snap.TUNGraphNodeI_GetId,None,TUNGraphNodeI)
TUNGraphNodeI.GetDeg = new_instancemethod(_snap.TUNGraphNodeI_GetDeg,None,TUNGraphNodeI)
TUNGraphNodeI.GetInDeg = new_instancemethod(_snap.TUNGraphNodeI_GetInDeg,None,TUNGraphNodeI)
TUNGraphNodeI.GetOutDeg = new_instancemethod(_snap.TUNGraphNodeI_GetOutDeg,None,TUNGraphNodeI)
TUNGraphNodeI.GetInNId = new_instancemethod(_snap.TUNGraphNodeI_GetInNId,None,TUNGraphNodeI)
TUNGraphNodeI.GetOutNId = new_instancemethod(_snap.TUNGraphNodeI_GetOutNId,None,TUNGraphNodeI)
TUNGraphNodeI.GetNbrNId = new_instancemethod(_snap.TUNGraphNodeI_GetNbrNId,None,TUNGraphNodeI)
TUNGraphNodeI.IsInNId = new_instancemethod(_snap.TUNGraphNodeI_IsInNId,None,TUNGraphNodeI)
TUNGraphNodeI.IsOutNId = new_instancemethod(_snap.TUNGraphNodeI_IsOutNId,None,TUNGraphNodeI)
TUNGraphNodeI.IsNbrNId = new_instancemethod(_snap.TUNGraphNodeI_IsNbrNId,None,TUNGraphNodeI)
TUNGraphNodeI_swigregister = _snap.TUNGraphNodeI_swigregister
TUNGraphNodeI_swigregister(TUNGraphNodeI)

class TUNGraphEdgeI(object):
    """Proxy of C++ TUNGraphEdgeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TUNGraphEdgeI self) -> TUNGraphEdgeI
        __init__(TUNGraphEdgeI self, TUNGraph::TEdgeI const & EdgeI) -> TUNGraphEdgeI

        Parameters:
            EdgeI: TUNGraph::TEdgeI const &

        """
        _snap.TUNGraphEdgeI_swiginit(self,_snap.new_TUNGraphEdgeI(*args))
    def Next(self):
        """
        Next(TUNGraphEdgeI self) -> TUNGraphEdgeI

        Parameters:
            self: TUNGraphEdgeI *

        """
        return _snap.TUNGraphEdgeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TUNGraphEdgeI const &

        """
        return _snap.TUNGraphEdgeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TUNGraphEdgeI const &

        """
        return _snap.TUNGraphEdgeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TUNGraphEdgeI self) -> int

        Parameters:
            self: TUNGraphEdgeI const *

        """
        return _snap.TUNGraphEdgeI_GetId(self)

    def GetSrcNId(self):
        """
        GetSrcNId(TUNGraphEdgeI self) -> int

        Parameters:
            self: TUNGraphEdgeI const *

        """
        return _snap.TUNGraphEdgeI_GetSrcNId(self)

    def GetDstNId(self):
        """
        GetDstNId(TUNGraphEdgeI self) -> int

        Parameters:
            self: TUNGraphEdgeI const *

        """
        return _snap.TUNGraphEdgeI_GetDstNId(self)

    __swig_destroy__ = _snap.delete_TUNGraphEdgeI
TUNGraphEdgeI.Next = new_instancemethod(_snap.TUNGraphEdgeI_Next,None,TUNGraphEdgeI)
TUNGraphEdgeI.__lt__ = new_instancemethod(_snap.TUNGraphEdgeI___lt__,None,TUNGraphEdgeI)
TUNGraphEdgeI.__eq__ = new_instancemethod(_snap.TUNGraphEdgeI___eq__,None,TUNGraphEdgeI)
TUNGraphEdgeI.GetId = new_instancemethod(_snap.TUNGraphEdgeI_GetId,None,TUNGraphEdgeI)
TUNGraphEdgeI.GetSrcNId = new_instancemethod(_snap.TUNGraphEdgeI_GetSrcNId,None,TUNGraphEdgeI)
TUNGraphEdgeI.GetDstNId = new_instancemethod(_snap.TUNGraphEdgeI_GetDstNId,None,TUNGraphEdgeI)
TUNGraphEdgeI_swigregister = _snap.TUNGraphEdgeI_swigregister
TUNGraphEdgeI_swigregister(TUNGraphEdgeI)

class TNEANetNodeI(object):
    """Proxy of C++ TNEANetNodeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetNodeI self) -> TNEANetNodeI
        __init__(TNEANetNodeI self, TNEANet::TNodeI const & NodeI) -> TNEANetNodeI

        Parameters:
            NodeI: TNEANet::TNodeI const &

        """
        _snap.TNEANetNodeI_swiginit(self,_snap.new_TNEANetNodeI(*args))
    def Next(self):
        """
        Next(TNEANetNodeI self) -> TNEANetNodeI

        Parameters:
            self: TNEANetNodeI *

        """
        return _snap.TNEANetNodeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool

        Parameters:
            NodeI: TNEANetNodeI const &

        """
        return _snap.TNEANetNodeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool

        Parameters:
            NodeI: TNEANetNodeI const &

        """
        return _snap.TNEANetNodeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TNEANetNodeI self) -> int

        Parameters:
            self: TNEANetNodeI const *

        """
        return _snap.TNEANetNodeI_GetId(self)

    def GetDeg(self):
        """
        GetDeg(TNEANetNodeI self) -> int

        Parameters:
            self: TNEANetNodeI const *

        """
        return _snap.TNEANetNodeI_GetDeg(self)

    def GetInDeg(self):
        """
        GetInDeg(TNEANetNodeI self) -> int

        Parameters:
            self: TNEANetNodeI const *

        """
        return _snap.TNEANetNodeI_GetInDeg(self)

    def GetOutDeg(self):
        """
        GetOutDeg(TNEANetNodeI self) -> int

        Parameters:
            self: TNEANetNodeI const *

        """
        return _snap.TNEANetNodeI_GetOutDeg(self)

    def GetInNId(self, *args):
        """
        GetInNId(TNEANetNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNEANetNodeI_GetInNId(self, *args)

    def GetOutNId(self, *args):
        """
        GetOutNId(TNEANetNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNEANetNodeI_GetOutNId(self, *args)

    def GetNbrNId(self, *args):
        """
        GetNbrNId(TNEANetNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNEANetNodeI_GetNbrNId(self, *args)

    def IsInNId(self, *args):
        """
        IsInNId(TNEANetNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEANetNodeI_IsInNId(self, *args)

    def IsOutNId(self, *args):
        """
        IsOutNId(TNEANetNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEANetNodeI_IsOutNId(self, *args)

    def IsNbrNId(self, *args):
        """
        IsNbrNId(TNEANetNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEANetNodeI_IsNbrNId(self, *args)

    __swig_destroy__ = _snap.delete_TNEANetNodeI
TNEANetNodeI.Next = new_instancemethod(_snap.TNEANetNodeI_Next,None,TNEANetNodeI)
TNEANetNodeI.__lt__ = new_instancemethod(_snap.TNEANetNodeI___lt__,None,TNEANetNodeI)
TNEANetNodeI.__eq__ = new_instancemethod(_snap.TNEANetNodeI___eq__,None,TNEANetNodeI)
TNEANetNodeI.GetId = new_instancemethod(_snap.TNEANetNodeI_GetId,None,TNEANetNodeI)
TNEANetNodeI.GetDeg = new_instancemethod(_snap.TNEANetNodeI_GetDeg,None,TNEANetNodeI)
TNEANetNodeI.GetInDeg = new_instancemethod(_snap.TNEANetNodeI_GetInDeg,None,TNEANetNodeI)
TNEANetNodeI.GetOutDeg = new_instancemethod(_snap.TNEANetNodeI_GetOutDeg,None,TNEANetNodeI)
TNEANetNodeI.GetInNId = new_instancemethod(_snap.TNEANetNodeI_GetInNId,None,TNEANetNodeI)
TNEANetNodeI.GetOutNId = new_instancemethod(_snap.TNEANetNodeI_GetOutNId,None,TNEANetNodeI)
TNEANetNodeI.GetNbrNId = new_instancemethod(_snap.TNEANetNodeI_GetNbrNId,None,TNEANetNodeI)
TNEANetNodeI.IsInNId = new_instancemethod(_snap.TNEANetNodeI_IsInNId,None,TNEANetNodeI)
TNEANetNodeI.IsOutNId = new_instancemethod(_snap.TNEANetNodeI_IsOutNId,None,TNEANetNodeI)
TNEANetNodeI.IsNbrNId = new_instancemethod(_snap.TNEANetNodeI_IsNbrNId,None,TNEANetNodeI)
TNEANetNodeI_swigregister = _snap.TNEANetNodeI_swigregister
TNEANetNodeI_swigregister(TNEANetNodeI)

class TNEANetEdgeI(object):
    """Proxy of C++ TNEANetEdgeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetEdgeI self) -> TNEANetEdgeI
        __init__(TNEANetEdgeI self, TNEANet::TEdgeI const & EdgeI) -> TNEANetEdgeI

        Parameters:
            EdgeI: TNEANet::TEdgeI const &

        """
        _snap.TNEANetEdgeI_swiginit(self,_snap.new_TNEANetEdgeI(*args))
    def Next(self):
        """
        Next(TNEANetEdgeI self) -> TNEANetEdgeI

        Parameters:
            self: TNEANetEdgeI *

        """
        return _snap.TNEANetEdgeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TNEANetEdgeI const &

        """
        return _snap.TNEANetEdgeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TNEANetEdgeI const &

        """
        return _snap.TNEANetEdgeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TNEANetEdgeI self) -> int

        Parameters:
            self: TNEANetEdgeI const *

        """
        return _snap.TNEANetEdgeI_GetId(self)

    def GetSrcNId(self):
        """
        GetSrcNId(TNEANetEdgeI self) -> int

        Parameters:
            self: TNEANetEdgeI const *

        """
        return _snap.TNEANetEdgeI_GetSrcNId(self)

    def GetDstNId(self):
        """
        GetDstNId(TNEANetEdgeI self) -> int

        Parameters:
            self: TNEANetEdgeI const *

        """
        return _snap.TNEANetEdgeI_GetDstNId(self)

    __swig_destroy__ = _snap.delete_TNEANetEdgeI
TNEANetEdgeI.Next = new_instancemethod(_snap.TNEANetEdgeI_Next,None,TNEANetEdgeI)
TNEANetEdgeI.__lt__ = new_instancemethod(_snap.TNEANetEdgeI___lt__,None,TNEANetEdgeI)
TNEANetEdgeI.__eq__ = new_instancemethod(_snap.TNEANetEdgeI___eq__,None,TNEANetEdgeI)
TNEANetEdgeI.GetId = new_instancemethod(_snap.TNEANetEdgeI_GetId,None,TNEANetEdgeI)
TNEANetEdgeI.GetSrcNId = new_instancemethod(_snap.TNEANetEdgeI_GetSrcNId,None,TNEANetEdgeI)
TNEANetEdgeI.GetDstNId = new_instancemethod(_snap.TNEANetEdgeI_GetDstNId,None,TNEANetEdgeI)
TNEANetEdgeI_swigregister = _snap.TNEANetEdgeI_swigregister
TNEANetEdgeI_swigregister(TNEANetEdgeI)

class TNEANetAIntI(object):
    """Proxy of C++ TNEANetAIntI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetAIntI self) -> TNEANetAIntI
        __init__(TNEANetAIntI self, TIntVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAIntI

        Parameters:
            HIter: TIntVecIter const &
            attribute: TStr
            isEdgeIter: bool
            GraphPt: TNEANet const *

        __init__(TNEANetAIntI self, TNEANet::TAIntI const & I) -> TNEANetAIntI

        Parameters:
            I: TNEANet::TAIntI const &

        """
        _snap.TNEANetAIntI_swiginit(self,_snap.new_TNEANetAIntI(*args))
    def Next(self):
        """
        Next(TNEANetAIntI self) -> TNEANetAIntI

        Parameters:
            self: TNEANetAIntI *

        """
        return _snap.TNEANetAIntI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetAIntI self, TNEANetAIntI I) -> bool

        Parameters:
            I: TNEANetAIntI const &

        """
        return _snap.TNEANetAIntI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetAIntI self, TNEANetAIntI I) -> bool

        Parameters:
            I: TNEANetAIntI const &

        """
        return _snap.TNEANetAIntI___eq__(self, *args)

    def GetDat(self):
        """
        GetDat(TNEANetAIntI self) -> int

        Parameters:
            self: TNEANetAIntI const *

        """
        return _snap.TNEANetAIntI_GetDat(self)

    def IsDeleted(self):
        """
        IsDeleted(TNEANetAIntI self) -> bool

        Parameters:
            self: TNEANetAIntI const *

        """
        return _snap.TNEANetAIntI_IsDeleted(self)

    __swig_destroy__ = _snap.delete_TNEANetAIntI
TNEANetAIntI.Next = new_instancemethod(_snap.TNEANetAIntI_Next,None,TNEANetAIntI)
TNEANetAIntI.__lt__ = new_instancemethod(_snap.TNEANetAIntI___lt__,None,TNEANetAIntI)
TNEANetAIntI.__eq__ = new_instancemethod(_snap.TNEANetAIntI___eq__,None,TNEANetAIntI)
TNEANetAIntI.GetDat = new_instancemethod(_snap.TNEANetAIntI_GetDat,None,TNEANetAIntI)
TNEANetAIntI.IsDeleted = new_instancemethod(_snap.TNEANetAIntI_IsDeleted,None,TNEANetAIntI)
TNEANetAIntI_swigregister = _snap.TNEANetAIntI_swigregister
TNEANetAIntI_swigregister(TNEANetAIntI)

class TNEANetAStrI(object):
    """Proxy of C++ TNEANetAStrI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetAStrI self) -> TNEANetAStrI
        __init__(TNEANetAStrI self, TStrVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAStrI

        Parameters:
            HIter: TStrVecIter const &
            attribute: TStr
            isEdgeIter: bool
            GraphPt: TNEANet const *

        __init__(TNEANetAStrI self, TNEANet::TAStrI const & I) -> TNEANetAStrI

        Parameters:
            I: TNEANet::TAStrI const &

        """
        _snap.TNEANetAStrI_swiginit(self,_snap.new_TNEANetAStrI(*args))
    def Next(self):
        """
        Next(TNEANetAStrI self) -> TNEANetAStrI

        Parameters:
            self: TNEANetAStrI *

        """
        return _snap.TNEANetAStrI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetAStrI self, TNEANetAStrI I) -> bool

        Parameters:
            I: TNEANetAStrI const &

        """
        return _snap.TNEANetAStrI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetAStrI self, TNEANetAStrI I) -> bool

        Parameters:
            I: TNEANetAStrI const &

        """
        return _snap.TNEANetAStrI___eq__(self, *args)

    def GetDat(self):
        """
        GetDat(TNEANetAStrI self) -> char *

        Parameters:
            self: TNEANetAStrI const *

        """
        return _snap.TNEANetAStrI_GetDat(self)

    def IsDeleted(self):
        """
        IsDeleted(TNEANetAStrI self) -> bool

        Parameters:
            self: TNEANetAStrI const *

        """
        return _snap.TNEANetAStrI_IsDeleted(self)

    __swig_destroy__ = _snap.delete_TNEANetAStrI
TNEANetAStrI.Next = new_instancemethod(_snap.TNEANetAStrI_Next,None,TNEANetAStrI)
TNEANetAStrI.__lt__ = new_instancemethod(_snap.TNEANetAStrI___lt__,None,TNEANetAStrI)
TNEANetAStrI.__eq__ = new_instancemethod(_snap.TNEANetAStrI___eq__,None,TNEANetAStrI)
TNEANetAStrI.GetDat = new_instancemethod(_snap.TNEANetAStrI_GetDat,None,TNEANetAStrI)
TNEANetAStrI.IsDeleted = new_instancemethod(_snap.TNEANetAStrI_IsDeleted,None,TNEANetAStrI)
TNEANetAStrI_swigregister = _snap.TNEANetAStrI_swigregister
TNEANetAStrI_swigregister(TNEANetAStrI)

class TNEANetAFltI(object):
    """Proxy of C++ TNEANetAFltI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetAFltI self) -> TNEANetAFltI
        __init__(TNEANetAFltI self, TFltVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAFltI

        Parameters:
            HIter: TFltVecIter const &
            attribute: TStr
            isEdgeIter: bool
            GraphPt: TNEANet const *

        __init__(TNEANetAFltI self, TNEANet::TAFltI const & I) -> TNEANetAFltI

        Parameters:
            I: TNEANet::TAFltI const &

        """
        _snap.TNEANetAFltI_swiginit(self,_snap.new_TNEANetAFltI(*args))
    def Next(self):
        """
        Next(TNEANetAFltI self) -> TNEANetAFltI

        Parameters:
            self: TNEANetAFltI *

        """
        return _snap.TNEANetAFltI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetAFltI self, TNEANetAFltI I) -> bool

        Parameters:
            I: TNEANetAFltI const &

        """
        return _snap.TNEANetAFltI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetAFltI self, TNEANetAFltI I) -> bool

        Parameters:
            I: TNEANetAFltI const &

        """
        return _snap.TNEANetAFltI___eq__(self, *args)

    def GetDat(self):
        """
        GetDat(TNEANetAFltI self) -> double

        Parameters:
            self: TNEANetAFltI const *

        """
        return _snap.TNEANetAFltI_GetDat(self)

    def IsDeleted(self):
        """
        IsDeleted(TNEANetAFltI self) -> bool

        Parameters:
            self: TNEANetAFltI const *

        """
        return _snap.TNEANetAFltI_IsDeleted(self)

    __swig_destroy__ = _snap.delete_TNEANetAFltI
TNEANetAFltI.Next = new_instancemethod(_snap.TNEANetAFltI_Next,None,TNEANetAFltI)
TNEANetAFltI.__lt__ = new_instancemethod(_snap.TNEANetAFltI___lt__,None,TNEANetAFltI)
TNEANetAFltI.__eq__ = new_instancemethod(_snap.TNEANetAFltI___eq__,None,TNEANetAFltI)
TNEANetAFltI.GetDat = new_instancemethod(_snap.TNEANetAFltI_GetDat,None,TNEANetAFltI)
TNEANetAFltI.IsDeleted = new_instancemethod(_snap.TNEANetAFltI_IsDeleted,None,TNEANetAFltI)
TNEANetAFltI_swigregister = _snap.TNEANetAFltI_swigregister
TNEANetAFltI_swigregister(TNEANetAFltI)


def TPrGraph(*args):
  """
    TPrGraph(PUNGraph G) -> TUNGraph

    Parameters:
        G: PUNGraph

    """
  return _snap.TPrGraph(*args)

def accept_array(*args):
  """
    accept_array(int [] array) -> int

    Parameters:
        array: int []

    """
  return _snap.accept_array(*args)

def print_array(*args):
  """
    print_array(int * x, int length)

    Parameters:
        x: int *
        length: int

    """
  return _snap.print_array(*args)

def PyTFltV(*args):
  """
    PyTFltV(double [10] x) -> TFltV

    Parameters:
        x: double [10]

    """
  return _snap.PyTFltV(*args)

def PyToTIntV(*args):
  """
    PyToTIntV(int * array) -> TIntV

    Parameters:
        array: int *

    """
  return _snap.PyToTIntV(*args)

def count(*args):
  """
    count(char * str, char c) -> int

    Parameters:
        str: char *
        c: char

    """
  return _snap.count(*args)

def TIntVToPy(*args):
  """
    TIntVToPy(TIntV originalList)

    Parameters:
        originalList: TIntV

    """
  return _snap.TIntVToPy(*args)
class TNEANet(object):
    """Proxy of C++ TNEANet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANet self) -> TNEANet
        __init__(TNEANet self, int const & Nodes, int const & Edges) -> TNEANet

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TNEANet self, TNEANet Graph) -> TNEANet

        Parameters:
            Graph: TNEANet const &

        __init__(TNEANet self, TSIn SIn) -> TNEANet

        Parameters:
            SIn: TSIn &

        """
        _snap.TNEANet_swiginit(self,_snap.new_TNEANet(*args))
    def Save(self, *args):
        """
        Save(TNEANet self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TNEANet_Save(self, *args)

    def New(*args):
        """
        New() -> PNEANet
        New(int const & Nodes, int const & Edges) -> PNEANet

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNEANet_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PNEANet

        Parameters:
            SIn: TSIn &

        """
        return _snap.TNEANet_Load(*args)

    Load = staticmethod(Load)
    def HasFlag(self, *args):
        """
        HasFlag(TNEANet self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.TNEANet_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(TNEANet self) -> int

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TNEANet self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TNEANet self) -> int
        AddNode(TNEANet self, TNEANet::TNodeI const & NodeId) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &

        """
        return _snap.TNEANet_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TNEANet self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TNEANet self, TNEANet::TNode const & NodeI)

        Parameters:
            NodeI: TNEANet::TNode const &

        """
        return _snap.TNEANet_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TNEANet self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEANet_IsNode(self, *args)

    def GetNI(self, *args):
        """
        GetNI(TNEANet self, int const & NId) -> TNEANet::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TNEANet_GetNI(self, *args)

    def GetNAIntI(self, *args):
        """
        GetNAIntI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.TNEANet_GetNAIntI(self, *args)

    def GetNAStrI(self, *args):
        """
        GetNAStrI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.TNEANet_GetNAStrI(self, *args)

    def GetNAFltI(self, *args):
        """
        GetNAFltI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.TNEANet_GetNAFltI(self, *args)

    def AttrNameNI(self, *args):
        """
        AttrNameNI(TNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        AttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_AttrNameNI(self, *args)

    def AttrValueNI(self, *args):
        """
        AttrValueNI(TNEANet self, TInt NId, TStrV Values)

        Parameters:
            NId: TInt const &
            Values: TStrV &

        AttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.TNEANet_AttrValueNI(self, *args)

    def IntAttrNameNI(self, *args):
        """
        IntAttrNameNI(TNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        IntAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_IntAttrNameNI(self, *args)

    def IntAttrValueNI(self, *args):
        """
        IntAttrValueNI(TNEANet self, TInt NId, TIntV Values)

        Parameters:
            NId: TInt const &
            Values: TIntV &

        IntAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TIntV &

        """
        return _snap.TNEANet_IntAttrValueNI(self, *args)

    def StrAttrNameNI(self, *args):
        """
        StrAttrNameNI(TNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        StrAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_StrAttrNameNI(self, *args)

    def StrAttrValueNI(self, *args):
        """
        StrAttrValueNI(TNEANet self, TInt NId, TStrV Values)

        Parameters:
            NId: TInt const &
            Values: TStrV &

        StrAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.TNEANet_StrAttrValueNI(self, *args)

    def FltAttrNameNI(self, *args):
        """
        FltAttrNameNI(TNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        FltAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_FltAttrNameNI(self, *args)

    def FltAttrValueNI(self, *args):
        """
        FltAttrValueNI(TNEANet self, TInt NId, TFltV & Values)

        Parameters:
            NId: TInt const &
            Values: TFltV &

        FltAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TFltV &

        """
        return _snap.TNEANet_FltAttrValueNI(self, *args)

    def AttrNameEI(self, *args):
        """
        AttrNameEI(TNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        AttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_AttrNameEI(self, *args)

    def AttrValueEI(self, *args):
        """
        AttrValueEI(TNEANet self, TInt EId, TStrV Values)

        Parameters:
            EId: TInt const &
            Values: TStrV &

        AttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.TNEANet_AttrValueEI(self, *args)

    def IntAttrNameEI(self, *args):
        """
        IntAttrNameEI(TNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        IntAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_IntAttrNameEI(self, *args)

    def IntAttrValueEI(self, *args):
        """
        IntAttrValueEI(TNEANet self, TInt EId, TIntV Values)

        Parameters:
            EId: TInt const &
            Values: TIntV &

        IntAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TIntV &

        """
        return _snap.TNEANet_IntAttrValueEI(self, *args)

    def StrAttrNameEI(self, *args):
        """
        StrAttrNameEI(TNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        StrAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_StrAttrNameEI(self, *args)

    def StrAttrValueEI(self, *args):
        """
        StrAttrValueEI(TNEANet self, TInt EId, TStrV Values)

        Parameters:
            EId: TInt const &
            Values: TStrV &

        StrAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.TNEANet_StrAttrValueEI(self, *args)

    def FltAttrNameEI(self, *args):
        """
        FltAttrNameEI(TNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        FltAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_FltAttrNameEI(self, *args)

    def FltAttrValueEI(self, *args):
        """
        FltAttrValueEI(TNEANet self, TInt EId, TFltV & Values)

        Parameters:
            EId: TInt const &
            Values: TFltV &

        FltAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TFltV &

        """
        return _snap.TNEANet_FltAttrValueEI(self, *args)

    def GetEAIntI(self, *args):
        """
        GetEAIntI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.TNEANet_GetEAIntI(self, *args)

    def GetEAStrI(self, *args):
        """
        GetEAStrI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.TNEANet_GetEAStrI(self, *args)

    def GetEAFltI(self, *args):
        """
        GetEAFltI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.TNEANet_GetEAFltI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TNEANet self) -> int

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(TNEANet self) -> int

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TNEANet self, int const & SrcNId, int const & DstNId, int EId=-1) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int

        AddEdge(TNEANet self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(TNEANet self, TNEANet::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TNEANet::TEdgeI const &

        """
        return _snap.TNEANet_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TNEANet self, int const & EId)

        Parameters:
            EId: int const &

        DelEdge(TNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        DelEdge(TNEANet self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEANet_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TNEANet self, int const & EId) -> bool

        Parameters:
            EId: int const &

        IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        IsEdge(TNEANet self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &
            IsDir: bool const &

        IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &

        """
        return _snap.TNEANet_IsEdge(self, *args)

    def GetEId(self, *args):
        """
        GetEId(TNEANet self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEANet_GetEId(self, *args)

    def GetEI(self, *args):
        """
        GetEI(TNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEANet_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TNEANet self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TNEANet self) -> int

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TNEANet self, TRnd Rnd=Rnd) -> TNEANet::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TNEANet self) -> TNEANet::TNodeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_GetRndNI(self, *args)

    def GetRndEId(self, *args):
        """
        GetRndEId(TNEANet self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndEId(TNEANet self) -> int

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_GetRndEId(self, *args)

    def GetRndEI(self, *args):
        """
        GetRndEI(TNEANet self, TRnd Rnd=Rnd) -> TNEANet::TEdgeI

        Parameters:
            Rnd: TRnd &

        GetRndEI(TNEANet self) -> TNEANet::TEdgeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_GetRndEI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TNEANet self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TNEANet_GetNIdV(self, *args)

    def GetEIdV(self, *args):
        """
        GetEIdV(TNEANet self, TIntV EIdV)

        Parameters:
            EIdV: TIntV &

        """
        return _snap.TNEANet_GetEIdV(self, *args)

    def Empty(self):
        """
        Empty(TNEANet self) -> bool

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_Empty(self)

    def Clr(self):
        """
        Clr(TNEANet self)

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TNEANet self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNEANet_Reserve(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TNEANet self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TNEANet self)

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TNEANet self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TNEANet self) -> bool

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TNEANet self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TNEANet self)

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_Dump(self, *args)

    def AddIntAttrDatN(self, *args):
        """
        AddIntAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TInt const &
            attr: TStr const &

        AddIntAttrDatN(TNEANet self, int const & NId, TInt value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TInt const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddIntAttrDatN(self, *args)

    def AddStrAttrDatN(self, *args):
        """
        AddStrAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TStr const &
            attr: TStr const &

        AddStrAttrDatN(TNEANet self, int const & NId, TStr value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TStr const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddStrAttrDatN(self, *args)

    def AddFltAttrDatN(self, *args):
        """
        AddFltAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TFlt const &
            attr: TStr const &

        AddFltAttrDatN(TNEANet self, int const & NId, TFlt value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TFlt const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddFltAttrDatN(self, *args)

    def AddIntAttrDatE(self, *args):
        """
        AddIntAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TInt const &
            attr: TStr const &

        AddIntAttrDatE(TNEANet self, int const & EId, TInt value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TInt const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddIntAttrDatE(self, *args)

    def AddStrAttrDatE(self, *args):
        """
        AddStrAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TStr const &
            attr: TStr const &

        AddStrAttrDatE(TNEANet self, int const & EId, TStr value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TStr const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddStrAttrDatE(self, *args)

    def AddFltAttrDatE(self, *args):
        """
        AddFltAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TFlt const &
            attr: TStr const &

        AddFltAttrDatE(TNEANet self, int const & EId, TFlt value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TFlt const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddFltAttrDatE(self, *args)

    def GetIntAttrDatN(self, *args):
        """
        GetIntAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TInt

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetIntAttrDatN(TNEANet self, int const & NId, TStr attr) -> TInt

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetIntAttrDatN(self, *args)

    def GetStrAttrDatN(self, *args):
        """
        GetStrAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TStr

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetStrAttrDatN(TNEANet self, int const & NId, TStr attr) -> TStr

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetStrAttrDatN(self, *args)

    def GetFltAttrDatN(self, *args):
        """
        GetFltAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetFltAttrDatN(TNEANet self, int const & NId, TStr attr) -> TFlt

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetFltAttrDatN(self, *args)

    def GetIntAttrDatE(self, *args):
        """
        GetIntAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetIntAttrDatE(TNEANet self, int const & EId, TStr attr) -> TInt

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetIntAttrDatE(self, *args)

    def GetStrAttrDatE(self, *args):
        """
        GetStrAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetStrAttrDatE(TNEANet self, int const & EId, TStr attr) -> TStr

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetStrAttrDatE(self, *args)

    def GetFltAttrDatE(self, *args):
        """
        GetFltAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetFltAttrDatE(TNEANet self, int const & EId, TStr attr) -> TFlt

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetFltAttrDatE(self, *args)

    def DelAttrDatN(self, *args):
        """
        DelAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        DelAttrDatN(TNEANet self, int const & NId, TStr attr) -> int

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_DelAttrDatN(self, *args)

    def DelAttrDatE(self, *args):
        """
        DelAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        DelAttrDatE(TNEANet self, int const & EId, TStr attr) -> int

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_DelAttrDatE(self, *args)

    def AddIntAttrN(self, *args):
        """
        AddIntAttrN(TNEANet self, TStr attr, TInt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TInt

        AddIntAttrN(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddIntAttrN(self, *args)

    def AddStrAttrN(self, *args):
        """
        AddStrAttrN(TNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TStr

        AddStrAttrN(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddStrAttrN(self, *args)

    def AddFltAttrN(self, *args):
        """
        AddFltAttrN(TNEANet self, TStr attr, TFlt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TFlt

        AddFltAttrN(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddFltAttrN(self, *args)

    def AddIntAttrE(self, *args):
        """
        AddIntAttrE(TNEANet self, TStr attr, TInt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TInt

        AddIntAttrE(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddIntAttrE(self, *args)

    def AddStrAttrE(self, *args):
        """
        AddStrAttrE(TNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TStr

        AddStrAttrE(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddStrAttrE(self, *args)

    def AddFltAttrE(self, *args):
        """
        AddFltAttrE(TNEANet self, TStr attr, TFlt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TFlt

        AddFltAttrE(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddFltAttrE(self, *args)

    def DelAttrN(self, *args):
        """
        DelAttrN(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_DelAttrN(self, *args)

    def DelAttrE(self, *args):
        """
        DelAttrE(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_DelAttrE(self, *args)

    def NodeAttrIsDeleted(self, *args):
        """
        NodeAttrIsDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_NodeAttrIsDeleted(self, *args)

    def NodeAttrIsIntDeleted(self, *args):
        """
        NodeAttrIsIntDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_NodeAttrIsIntDeleted(self, *args)

    def NodeAttrIsStrDeleted(self, *args):
        """
        NodeAttrIsStrDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_NodeAttrIsStrDeleted(self, *args)

    def NodeAttrIsFltDeleted(self, *args):
        """
        NodeAttrIsFltDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_NodeAttrIsFltDeleted(self, *args)

    def EdgeAttrIsDeleted(self, *args):
        """
        EdgeAttrIsDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_EdgeAttrIsDeleted(self, *args)

    def EdgeAttrIsIntDeleted(self, *args):
        """
        EdgeAttrIsIntDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_EdgeAttrIsIntDeleted(self, *args)

    def EdgeAttrIsStrDeleted(self, *args):
        """
        EdgeAttrIsStrDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_EdgeAttrIsStrDeleted(self, *args)

    def EdgeAttrIsFltDeleted(self, *args):
        """
        EdgeAttrIsFltDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_EdgeAttrIsFltDeleted(self, *args)

    def GetNodeAttrValue(self, *args):
        """
        GetNodeAttrValue(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_GetNodeAttrValue(self, *args)

    def GetEdgeAttrValue(self, *args):
        """
        GetEdgeAttrValue(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_GetEdgeAttrValue(self, *args)

    def BegNI(self, *args):
        """
        BegNI(TNEANet self) -> TNEANet::TNodeI
        BegNI(TNEANet self) -> TNEANetNodeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_BegNI(self, *args)

    def EndNI(self, *args):
        """
        EndNI(TNEANet self) -> TNEANet::TNodeI
        EndNI(TNEANet self) -> TNEANetNodeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_EndNI(self, *args)

    def BegEI(self, *args):
        """
        BegEI(TNEANet self) -> TNEANet::TEdgeI
        BegEI(TNEANet self) -> TNEANetEdgeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_BegEI(self, *args)

    def EndEI(self, *args):
        """
        EndEI(TNEANet self) -> TNEANet::TEdgeI
        EndEI(TNEANet self) -> TNEANetEdgeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_EndEI(self, *args)

    def BegNAIntI(self, *args):
        """
        BegNAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        BegNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegNAIntI(self, *args)

    def EndNAIntI(self, *args):
        """
        EndNAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        EndNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndNAIntI(self, *args)

    def BegNAStrI(self, *args):
        """
        BegNAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        BegNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegNAStrI(self, *args)

    def EndNAStrI(self, *args):
        """
        EndNAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        EndNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndNAStrI(self, *args)

    def BegNAFltI(self, *args):
        """
        BegNAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        BegNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegNAFltI(self, *args)

    def EndNAFltI(self, *args):
        """
        EndNAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        EndNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndNAFltI(self, *args)

    def BegEAIntI(self, *args):
        """
        BegEAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        BegEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegEAIntI(self, *args)

    def EndEAIntI(self, *args):
        """
        EndEAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        EndEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndEAIntI(self, *args)

    def BegEAStrI(self, *args):
        """
        BegEAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        BegEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegEAStrI(self, *args)

    def EndEAStrI(self, *args):
        """
        EndEAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        EndEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndEAStrI(self, *args)

    def BegEAFltI(self, *args):
        """
        BegEAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        BegEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegEAFltI(self, *args)

    def EndEAFltI(self, *args):
        """
        EndEAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        EndEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndEAFltI(self, *args)

    __swig_destroy__ = _snap.delete_TNEANet
TNEANet.Save = new_instancemethod(_snap.TNEANet_Save,None,TNEANet)
TNEANet.HasFlag = new_instancemethod(_snap.TNEANet_HasFlag,None,TNEANet)
TNEANet.GetNodes = new_instancemethod(_snap.TNEANet_GetNodes,None,TNEANet)
TNEANet.AddNode = new_instancemethod(_snap.TNEANet_AddNode,None,TNEANet)
TNEANet.DelNode = new_instancemethod(_snap.TNEANet_DelNode,None,TNEANet)
TNEANet.IsNode = new_instancemethod(_snap.TNEANet_IsNode,None,TNEANet)
TNEANet.GetNI = new_instancemethod(_snap.TNEANet_GetNI,None,TNEANet)
TNEANet.GetNAIntI = new_instancemethod(_snap.TNEANet_GetNAIntI,None,TNEANet)
TNEANet.GetNAStrI = new_instancemethod(_snap.TNEANet_GetNAStrI,None,TNEANet)
TNEANet.GetNAFltI = new_instancemethod(_snap.TNEANet_GetNAFltI,None,TNEANet)
TNEANet.AttrNameNI = new_instancemethod(_snap.TNEANet_AttrNameNI,None,TNEANet)
TNEANet.AttrValueNI = new_instancemethod(_snap.TNEANet_AttrValueNI,None,TNEANet)
TNEANet.IntAttrNameNI = new_instancemethod(_snap.TNEANet_IntAttrNameNI,None,TNEANet)
TNEANet.IntAttrValueNI = new_instancemethod(_snap.TNEANet_IntAttrValueNI,None,TNEANet)
TNEANet.StrAttrNameNI = new_instancemethod(_snap.TNEANet_StrAttrNameNI,None,TNEANet)
TNEANet.StrAttrValueNI = new_instancemethod(_snap.TNEANet_StrAttrValueNI,None,TNEANet)
TNEANet.FltAttrNameNI = new_instancemethod(_snap.TNEANet_FltAttrNameNI,None,TNEANet)
TNEANet.FltAttrValueNI = new_instancemethod(_snap.TNEANet_FltAttrValueNI,None,TNEANet)
TNEANet.AttrNameEI = new_instancemethod(_snap.TNEANet_AttrNameEI,None,TNEANet)
TNEANet.AttrValueEI = new_instancemethod(_snap.TNEANet_AttrValueEI,None,TNEANet)
TNEANet.IntAttrNameEI = new_instancemethod(_snap.TNEANet_IntAttrNameEI,None,TNEANet)
TNEANet.IntAttrValueEI = new_instancemethod(_snap.TNEANet_IntAttrValueEI,None,TNEANet)
TNEANet.StrAttrNameEI = new_instancemethod(_snap.TNEANet_StrAttrNameEI,None,TNEANet)
TNEANet.StrAttrValueEI = new_instancemethod(_snap.TNEANet_StrAttrValueEI,None,TNEANet)
TNEANet.FltAttrNameEI = new_instancemethod(_snap.TNEANet_FltAttrNameEI,None,TNEANet)
TNEANet.FltAttrValueEI = new_instancemethod(_snap.TNEANet_FltAttrValueEI,None,TNEANet)
TNEANet.GetEAIntI = new_instancemethod(_snap.TNEANet_GetEAIntI,None,TNEANet)
TNEANet.GetEAStrI = new_instancemethod(_snap.TNEANet_GetEAStrI,None,TNEANet)
TNEANet.GetEAFltI = new_instancemethod(_snap.TNEANet_GetEAFltI,None,TNEANet)
TNEANet.GetMxNId = new_instancemethod(_snap.TNEANet_GetMxNId,None,TNEANet)
TNEANet.GetEdges = new_instancemethod(_snap.TNEANet_GetEdges,None,TNEANet)
TNEANet.AddEdge = new_instancemethod(_snap.TNEANet_AddEdge,None,TNEANet)
TNEANet.DelEdge = new_instancemethod(_snap.TNEANet_DelEdge,None,TNEANet)
TNEANet.IsEdge = new_instancemethod(_snap.TNEANet_IsEdge,None,TNEANet)
TNEANet.GetEId = new_instancemethod(_snap.TNEANet_GetEId,None,TNEANet)
TNEANet.GetEI = new_instancemethod(_snap.TNEANet_GetEI,None,TNEANet)
TNEANet.GetRndNId = new_instancemethod(_snap.TNEANet_GetRndNId,None,TNEANet)
TNEANet.GetRndNI = new_instancemethod(_snap.TNEANet_GetRndNI,None,TNEANet)
TNEANet.GetRndEId = new_instancemethod(_snap.TNEANet_GetRndEId,None,TNEANet)
TNEANet.GetRndEI = new_instancemethod(_snap.TNEANet_GetRndEI,None,TNEANet)
TNEANet.GetNIdV = new_instancemethod(_snap.TNEANet_GetNIdV,None,TNEANet)
TNEANet.GetEIdV = new_instancemethod(_snap.TNEANet_GetEIdV,None,TNEANet)
TNEANet.Empty = new_instancemethod(_snap.TNEANet_Empty,None,TNEANet)
TNEANet.Clr = new_instancemethod(_snap.TNEANet_Clr,None,TNEANet)
TNEANet.Reserve = new_instancemethod(_snap.TNEANet_Reserve,None,TNEANet)
TNEANet.Defrag = new_instancemethod(_snap.TNEANet_Defrag,None,TNEANet)
TNEANet.IsOk = new_instancemethod(_snap.TNEANet_IsOk,None,TNEANet)
TNEANet.Dump = new_instancemethod(_snap.TNEANet_Dump,None,TNEANet)
TNEANet.AddIntAttrDatN = new_instancemethod(_snap.TNEANet_AddIntAttrDatN,None,TNEANet)
TNEANet.AddStrAttrDatN = new_instancemethod(_snap.TNEANet_AddStrAttrDatN,None,TNEANet)
TNEANet.AddFltAttrDatN = new_instancemethod(_snap.TNEANet_AddFltAttrDatN,None,TNEANet)
TNEANet.AddIntAttrDatE = new_instancemethod(_snap.TNEANet_AddIntAttrDatE,None,TNEANet)
TNEANet.AddStrAttrDatE = new_instancemethod(_snap.TNEANet_AddStrAttrDatE,None,TNEANet)
TNEANet.AddFltAttrDatE = new_instancemethod(_snap.TNEANet_AddFltAttrDatE,None,TNEANet)
TNEANet.GetIntAttrDatN = new_instancemethod(_snap.TNEANet_GetIntAttrDatN,None,TNEANet)
TNEANet.GetStrAttrDatN = new_instancemethod(_snap.TNEANet_GetStrAttrDatN,None,TNEANet)
TNEANet.GetFltAttrDatN = new_instancemethod(_snap.TNEANet_GetFltAttrDatN,None,TNEANet)
TNEANet.GetIntAttrDatE = new_instancemethod(_snap.TNEANet_GetIntAttrDatE,None,TNEANet)
TNEANet.GetStrAttrDatE = new_instancemethod(_snap.TNEANet_GetStrAttrDatE,None,TNEANet)
TNEANet.GetFltAttrDatE = new_instancemethod(_snap.TNEANet_GetFltAttrDatE,None,TNEANet)
TNEANet.DelAttrDatN = new_instancemethod(_snap.TNEANet_DelAttrDatN,None,TNEANet)
TNEANet.DelAttrDatE = new_instancemethod(_snap.TNEANet_DelAttrDatE,None,TNEANet)
TNEANet.AddIntAttrN = new_instancemethod(_snap.TNEANet_AddIntAttrN,None,TNEANet)
TNEANet.AddStrAttrN = new_instancemethod(_snap.TNEANet_AddStrAttrN,None,TNEANet)
TNEANet.AddFltAttrN = new_instancemethod(_snap.TNEANet_AddFltAttrN,None,TNEANet)
TNEANet.AddIntAttrE = new_instancemethod(_snap.TNEANet_AddIntAttrE,None,TNEANet)
TNEANet.AddStrAttrE = new_instancemethod(_snap.TNEANet_AddStrAttrE,None,TNEANet)
TNEANet.AddFltAttrE = new_instancemethod(_snap.TNEANet_AddFltAttrE,None,TNEANet)
TNEANet.DelAttrN = new_instancemethod(_snap.TNEANet_DelAttrN,None,TNEANet)
TNEANet.DelAttrE = new_instancemethod(_snap.TNEANet_DelAttrE,None,TNEANet)
TNEANet.NodeAttrIsDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsDeleted,None,TNEANet)
TNEANet.NodeAttrIsIntDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsIntDeleted,None,TNEANet)
TNEANet.NodeAttrIsStrDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsStrDeleted,None,TNEANet)
TNEANet.NodeAttrIsFltDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsFltDeleted,None,TNEANet)
TNEANet.EdgeAttrIsDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsDeleted,None,TNEANet)
TNEANet.EdgeAttrIsIntDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsIntDeleted,None,TNEANet)
TNEANet.EdgeAttrIsStrDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsStrDeleted,None,TNEANet)
TNEANet.EdgeAttrIsFltDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsFltDeleted,None,TNEANet)
TNEANet.GetNodeAttrValue = new_instancemethod(_snap.TNEANet_GetNodeAttrValue,None,TNEANet)
TNEANet.GetEdgeAttrValue = new_instancemethod(_snap.TNEANet_GetEdgeAttrValue,None,TNEANet)
TNEANet.BegNI = new_instancemethod(_snap.TNEANet_BegNI,None,TNEANet)
TNEANet.EndNI = new_instancemethod(_snap.TNEANet_EndNI,None,TNEANet)
TNEANet.BegEI = new_instancemethod(_snap.TNEANet_BegEI,None,TNEANet)
TNEANet.EndEI = new_instancemethod(_snap.TNEANet_EndEI,None,TNEANet)
TNEANet.BegNAIntI = new_instancemethod(_snap.TNEANet_BegNAIntI,None,TNEANet)
TNEANet.EndNAIntI = new_instancemethod(_snap.TNEANet_EndNAIntI,None,TNEANet)
TNEANet.BegNAStrI = new_instancemethod(_snap.TNEANet_BegNAStrI,None,TNEANet)
TNEANet.EndNAStrI = new_instancemethod(_snap.TNEANet_EndNAStrI,None,TNEANet)
TNEANet.BegNAFltI = new_instancemethod(_snap.TNEANet_BegNAFltI,None,TNEANet)
TNEANet.EndNAFltI = new_instancemethod(_snap.TNEANet_EndNAFltI,None,TNEANet)
TNEANet.BegEAIntI = new_instancemethod(_snap.TNEANet_BegEAIntI,None,TNEANet)
TNEANet.EndEAIntI = new_instancemethod(_snap.TNEANet_EndEAIntI,None,TNEANet)
TNEANet.BegEAStrI = new_instancemethod(_snap.TNEANet_BegEAStrI,None,TNEANet)
TNEANet.EndEAStrI = new_instancemethod(_snap.TNEANet_EndEAStrI,None,TNEANet)
TNEANet.BegEAFltI = new_instancemethod(_snap.TNEANet_BegEAFltI,None,TNEANet)
TNEANet.EndEAFltI = new_instancemethod(_snap.TNEANet_EndEAFltI,None,TNEANet)
TNEANet_swigregister = _snap.TNEANet_swigregister
TNEANet_swigregister(TNEANet)

def TNEANet_New(*args):
  """
    New() -> PNEANet
    TNEANet_New(int const & Nodes, int const & Edges) -> PNEANet

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TNEANet_New(*args)

def TNEANet_Load(*args):
  """
    TNEANet_Load(TSIn SIn) -> PNEANet

    Parameters:
        SIn: TSIn &

    """
  return _snap.TNEANet_Load(*args)


def PercentDegree(*args):
  """
    PercentDegree(PNEANet Graph, int const Threshold=0) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        Threshold: int const

    PercentDegree(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.PercentDegree(*args)

def PercentMxWcc(*args):
  """
    PercentMxWcc(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.PercentMxWcc(*args)

def PercentMxScc(*args):
  """
    PercentMxScc(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.PercentMxScc(*args)

def LoadEdgeList(*args):
  """
    LoadEdgeList(TStr InFNm, int const & SrcColId=0, int const & DstColId=1) -> PNEANet

    Parameters:
        InFNm: TStr const &
        SrcColId: int const &
        DstColId: int const &

    LoadEdgeList(TStr InFNm, int const & SrcColId=0) -> PNEANet

    Parameters:
        InFNm: TStr const &
        SrcColId: int const &

    LoadEdgeList(TStr InFNm) -> PNEANet

    Parameters:
        InFNm: TStr const &

    LoadEdgeList(TStr InFNm, int const & SrcColId, int const & DstColId, char const & Separator) -> PNEANet

    Parameters:
        InFNm: TStr const &
        SrcColId: int const &
        DstColId: int const &
        Separator: char const &

    """
  return _snap.LoadEdgeList(*args)

def PrintGraphStatTable(*args):
  """
    PrintGraphStatTable(PNEANet G, TStr OutFNm, TStr Desc="")

    Parameters:
        G: TPt< TNEANet > const &
        OutFNm: TStr
        Desc: TStr

    PrintGraphStatTable(PNEANet G, TStr OutFNm)

    Parameters:
        G: TPt< TNEANet > const &
        OutFNm: TStr

    """
  return _snap.PrintGraphStatTable(*args)

def GenRndGnm(*args):
  """
    GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True, TRnd Rnd=Rnd) -> PNEANet

    Parameters:
        Nodes: int const &
        Edges: int const &
        IsDir: bool const &
        Rnd: TRnd &

    GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True) -> PNEANet

    Parameters:
        Nodes: int const &
        Edges: int const &
        IsDir: bool const &

    GenRndGnm(int const & Nodes, int const & Edges) -> PNEANet

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.GenRndGnm(*args)

def NodesGTEDegree(*args):
  """
    NodesGTEDegree(PNEANet Graph, int const Threshold=0) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        Threshold: int const

    NodesGTEDegree(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.NodesGTEDegree(*args)

def MxDegree(*args):
  """
    MxDegree(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.MxDegree(*args)

def MxSccSz(*args):
  """
    MxSccSz(PNEANet Graph) -> PNEANet

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.MxSccSz(*args)

def MxWccSz(*args):
  """
    MxWccSz(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.MxWccSz(*args)
class PNEANet(object):
    """Proxy of C++ TPt<(TNEANet)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def New():
        """New() -> PNEANet"""
        return _snap.PNEANet_New()

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_PNEANet
    def Save(self, *args):
        """
        Save(PNEANet self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.PNEANet_Save(self, *args)

    def __deref__(self):
        """
        __deref__(PNEANet self) -> TNEANet

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet___deref__(self)

    def __ref__(self):
        """
        __ref__(PNEANet self) -> TNEANet

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet___ref__(self)

    def __call__(self):
        """
        __call__(PNEANet self) -> TNEANet

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet___call__(self)

    def Empty(self):
        """
        Empty(PNEANet self) -> bool

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_Empty(self)

    def Clr(self):
        """
        Clr(PNEANet self)

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_Clr(self)

    def GetRefs(self):
        """
        GetRefs(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_GetRefs(self)

    def Load(self, *args):
        """
        Load(PNEANet self, TSIn SIn) -> PNEANet

        Parameters:
            SIn: TSIn &

        """
        return _snap.PNEANet_Load(self, *args)

    def HasFlag(self, *args):
        """
        HasFlag(PNEANet self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.PNEANet_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(PNEANet self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(PNEANet self) -> int
        AddNode(PNEANet self, TNEANet::TNodeI const & NodeId) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &

        """
        return _snap.PNEANet_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(PNEANet self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(PNEANet self, TNEANet::TNode const & NodeI)

        Parameters:
            NodeI: TNEANet::TNode const &

        """
        return _snap.PNEANet_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(PNEANet self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.PNEANet_IsNode(self, *args)

    def BegNI(self, *args):
        """
        BegNI(PNEANet self) -> TNEANet::TNodeI
        BegNI(PNEANet self) -> TNEANetNodeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_BegNI(self, *args)

    def EndNI(self, *args):
        """
        EndNI(PNEANet self) -> TNEANet::TNodeI
        EndNI(PNEANet self) -> TNEANetNodeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_EndNI(self, *args)

    def GetNI(self, *args):
        """
        GetNI(PNEANet self, int const & NId) -> TNEANet::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.PNEANet_GetNI(self, *args)

    def BegNAIntI(self, *args):
        """
        BegNAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        BegNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegNAIntI(self, *args)

    def EndNAIntI(self, *args):
        """
        EndNAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        EndNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndNAIntI(self, *args)

    def GetNAIntI(self, *args):
        """
        GetNAIntI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.PNEANet_GetNAIntI(self, *args)

    def BegNAStrI(self, *args):
        """
        BegNAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        BegNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegNAStrI(self, *args)

    def EndNAStrI(self, *args):
        """
        EndNAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        EndNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndNAStrI(self, *args)

    def GetNAStrI(self, *args):
        """
        GetNAStrI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.PNEANet_GetNAStrI(self, *args)

    def BegNAFltI(self, *args):
        """
        BegNAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        BegNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegNAFltI(self, *args)

    def EndNAFltI(self, *args):
        """
        EndNAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        EndNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndNAFltI(self, *args)

    def GetNAFltI(self, *args):
        """
        GetNAFltI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.PNEANet_GetNAFltI(self, *args)

    def AttrNameNI(self, *args):
        """
        AttrNameNI(PNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        AttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_AttrNameNI(self, *args)

    def AttrValueNI(self, *args):
        """
        AttrValueNI(PNEANet self, TInt NId, TStrV Values)

        Parameters:
            NId: TInt const &
            Values: TStrV &

        AttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.PNEANet_AttrValueNI(self, *args)

    def IntAttrNameNI(self, *args):
        """
        IntAttrNameNI(PNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        IntAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_IntAttrNameNI(self, *args)

    def IntAttrValueNI(self, *args):
        """
        IntAttrValueNI(PNEANet self, TInt NId, TIntV Values)

        Parameters:
            NId: TInt const &
            Values: TIntV &

        IntAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TIntV &

        """
        return _snap.PNEANet_IntAttrValueNI(self, *args)

    def StrAttrNameNI(self, *args):
        """
        StrAttrNameNI(PNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        StrAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_StrAttrNameNI(self, *args)

    def StrAttrValueNI(self, *args):
        """
        StrAttrValueNI(PNEANet self, TInt NId, TStrV Values)

        Parameters:
            NId: TInt const &
            Values: TStrV &

        StrAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.PNEANet_StrAttrValueNI(self, *args)

    def FltAttrNameNI(self, *args):
        """
        FltAttrNameNI(PNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        FltAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_FltAttrNameNI(self, *args)

    def FltAttrValueNI(self, *args):
        """
        FltAttrValueNI(PNEANet self, TInt NId, TFltV & Values)

        Parameters:
            NId: TInt const &
            Values: TFltV &

        FltAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TFltV &

        """
        return _snap.PNEANet_FltAttrValueNI(self, *args)

    def AttrNameEI(self, *args):
        """
        AttrNameEI(PNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        AttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_AttrNameEI(self, *args)

    def AttrValueEI(self, *args):
        """
        AttrValueEI(PNEANet self, TInt EId, TStrV Values)

        Parameters:
            EId: TInt const &
            Values: TStrV &

        AttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.PNEANet_AttrValueEI(self, *args)

    def IntAttrNameEI(self, *args):
        """
        IntAttrNameEI(PNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        IntAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_IntAttrNameEI(self, *args)

    def IntAttrValueEI(self, *args):
        """
        IntAttrValueEI(PNEANet self, TInt EId, TIntV Values)

        Parameters:
            EId: TInt const &
            Values: TIntV &

        IntAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TIntV &

        """
        return _snap.PNEANet_IntAttrValueEI(self, *args)

    def StrAttrNameEI(self, *args):
        """
        StrAttrNameEI(PNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        StrAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_StrAttrNameEI(self, *args)

    def StrAttrValueEI(self, *args):
        """
        StrAttrValueEI(PNEANet self, TInt EId, TStrV Values)

        Parameters:
            EId: TInt const &
            Values: TStrV &

        StrAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.PNEANet_StrAttrValueEI(self, *args)

    def FltAttrNameEI(self, *args):
        """
        FltAttrNameEI(PNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        FltAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_FltAttrNameEI(self, *args)

    def FltAttrValueEI(self, *args):
        """
        FltAttrValueEI(PNEANet self, TInt EId, TFltV & Values)

        Parameters:
            EId: TInt const &
            Values: TFltV &

        FltAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TFltV &

        """
        return _snap.PNEANet_FltAttrValueEI(self, *args)

    def BegEAIntI(self, *args):
        """
        BegEAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        BegEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegEAIntI(self, *args)

    def EndEAIntI(self, *args):
        """
        EndEAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        EndEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndEAIntI(self, *args)

    def GetEAIntI(self, *args):
        """
        GetEAIntI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.PNEANet_GetEAIntI(self, *args)

    def BegEAStrI(self, *args):
        """
        BegEAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        BegEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegEAStrI(self, *args)

    def EndEAStrI(self, *args):
        """
        EndEAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        EndEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndEAStrI(self, *args)

    def GetEAStrI(self, *args):
        """
        GetEAStrI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.PNEANet_GetEAStrI(self, *args)

    def BegEAFltI(self, *args):
        """
        BegEAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        BegEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegEAFltI(self, *args)

    def EndEAFltI(self, *args):
        """
        EndEAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        EndEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndEAFltI(self, *args)

    def GetEAFltI(self, *args):
        """
        GetEAFltI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.PNEANet_GetEAFltI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(PNEANet self, int const & SrcNId, int const & DstNId, int EId=-1) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int

        AddEdge(PNEANet self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(PNEANet self, TNEANet::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TNEANet::TEdgeI const &

        """
        return _snap.PNEANet_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(PNEANet self, int const & EId)

        Parameters:
            EId: int const &

        DelEdge(PNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        DelEdge(PNEANet self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.PNEANet_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(PNEANet self, int const & EId) -> bool

        Parameters:
            EId: int const &

        IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        IsEdge(PNEANet self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &
            IsDir: bool const &

        IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &

        """
        return _snap.PNEANet_IsEdge(self, *args)

    def GetEId(self, *args):
        """
        GetEId(PNEANet self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.PNEANet_GetEId(self, *args)

    def BegEI(self, *args):
        """
        BegEI(PNEANet self) -> TNEANet::TEdgeI
        BegEI(PNEANet self) -> TNEANetEdgeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_BegEI(self, *args)

    def EndEI(self, *args):
        """
        EndEI(PNEANet self) -> TNEANet::TEdgeI
        EndEI(PNEANet self) -> TNEANetEdgeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_EndEI(self, *args)

    def GetEI(self, *args):
        """
        GetEI(PNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.PNEANet_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(PNEANet self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(PNEANet self, TRnd Rnd=Rnd) -> TNEANet::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(PNEANet self) -> TNEANet::TNodeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_GetRndNI(self, *args)

    def GetRndEId(self, *args):
        """
        GetRndEId(PNEANet self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndEId(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_GetRndEId(self, *args)

    def GetRndEI(self, *args):
        """
        GetRndEI(PNEANet self, TRnd Rnd=Rnd) -> TNEANet::TEdgeI

        Parameters:
            Rnd: TRnd &

        GetRndEI(PNEANet self) -> TNEANet::TEdgeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_GetRndEI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(PNEANet self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.PNEANet_GetNIdV(self, *args)

    def GetEIdV(self, *args):
        """
        GetEIdV(PNEANet self, TIntV EIdV)

        Parameters:
            EIdV: TIntV &

        """
        return _snap.PNEANet_GetEIdV(self, *args)

    def Reserve(self, *args):
        """
        Reserve(PNEANet self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.PNEANet_Reserve(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(PNEANet self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(PNEANet self)

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(PNEANet self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(PNEANet self) -> bool

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(PNEANet self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(PNEANet self)

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_Dump(self, *args)

    def AddIntAttrDatN(self, *args):
        """
        AddIntAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TInt const &
            attr: TStr const &

        AddIntAttrDatN(PNEANet self, int const & NId, TInt value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TInt const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddIntAttrDatN(self, *args)

    def AddStrAttrDatN(self, *args):
        """
        AddStrAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TStr const &
            attr: TStr const &

        AddStrAttrDatN(PNEANet self, int const & NId, TStr value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TStr const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddStrAttrDatN(self, *args)

    def AddFltAttrDatN(self, *args):
        """
        AddFltAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TFlt const &
            attr: TStr const &

        AddFltAttrDatN(PNEANet self, int const & NId, TFlt value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TFlt const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddFltAttrDatN(self, *args)

    def AddIntAttrDatE(self, *args):
        """
        AddIntAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TInt const &
            attr: TStr const &

        AddIntAttrDatE(PNEANet self, int const & EId, TInt value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TInt const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddIntAttrDatE(self, *args)

    def AddStrAttrDatE(self, *args):
        """
        AddStrAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TStr const &
            attr: TStr const &

        AddStrAttrDatE(PNEANet self, int const & EId, TStr value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TStr const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddStrAttrDatE(self, *args)

    def AddFltAttrDatE(self, *args):
        """
        AddFltAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TFlt const &
            attr: TStr const &

        AddFltAttrDatE(PNEANet self, int const & EId, TFlt value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TFlt const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddFltAttrDatE(self, *args)

    def GetIntAttrDatN(self, *args):
        """
        GetIntAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TInt

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetIntAttrDatN(PNEANet self, int const & NId, TStr attr) -> TInt

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetIntAttrDatN(self, *args)

    def GetStrAttrDatN(self, *args):
        """
        GetStrAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TStr

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetStrAttrDatN(PNEANet self, int const & NId, TStr attr) -> TStr

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetStrAttrDatN(self, *args)

    def GetFltAttrDatN(self, *args):
        """
        GetFltAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetFltAttrDatN(PNEANet self, int const & NId, TStr attr) -> TFlt

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetFltAttrDatN(self, *args)

    def GetIntAttrDatE(self, *args):
        """
        GetIntAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetIntAttrDatE(PNEANet self, int const & EId, TStr attr) -> TInt

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetIntAttrDatE(self, *args)

    def GetStrAttrDatE(self, *args):
        """
        GetStrAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetStrAttrDatE(PNEANet self, int const & EId, TStr attr) -> TStr

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetStrAttrDatE(self, *args)

    def GetFltAttrDatE(self, *args):
        """
        GetFltAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetFltAttrDatE(PNEANet self, int const & EId, TStr attr) -> TFlt

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetFltAttrDatE(self, *args)

    def DelAttrDatN(self, *args):
        """
        DelAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        DelAttrDatN(PNEANet self, int const & NId, TStr attr) -> int

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_DelAttrDatN(self, *args)

    def DelAttrDatE(self, *args):
        """
        DelAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        DelAttrDatE(PNEANet self, int const & EId, TStr attr) -> int

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_DelAttrDatE(self, *args)

    def AddIntAttrN(self, *args):
        """
        AddIntAttrN(PNEANet self, TStr attr, TInt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TInt

        AddIntAttrN(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddIntAttrN(self, *args)

    def AddStrAttrN(self, *args):
        """
        AddStrAttrN(PNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TStr

        AddStrAttrN(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddStrAttrN(self, *args)

    def AddFltAttrN(self, *args):
        """
        AddFltAttrN(PNEANet self, TStr attr, TFlt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TFlt

        AddFltAttrN(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddFltAttrN(self, *args)

    def AddIntAttrE(self, *args):
        """
        AddIntAttrE(PNEANet self, TStr attr, TInt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TInt

        AddIntAttrE(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddIntAttrE(self, *args)

    def AddStrAttrE(self, *args):
        """
        AddStrAttrE(PNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TStr

        AddStrAttrE(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddStrAttrE(self, *args)

    def AddFltAttrE(self, *args):
        """
        AddFltAttrE(PNEANet self, TStr attr, TFlt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TFlt

        AddFltAttrE(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddFltAttrE(self, *args)

    def DelAttrN(self, *args):
        """
        DelAttrN(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_DelAttrN(self, *args)

    def DelAttrE(self, *args):
        """
        DelAttrE(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_DelAttrE(self, *args)

    def NodeAttrIsDeleted(self, *args):
        """
        NodeAttrIsDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_NodeAttrIsDeleted(self, *args)

    def NodeAttrIsIntDeleted(self, *args):
        """
        NodeAttrIsIntDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_NodeAttrIsIntDeleted(self, *args)

    def NodeAttrIsStrDeleted(self, *args):
        """
        NodeAttrIsStrDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_NodeAttrIsStrDeleted(self, *args)

    def NodeAttrIsFltDeleted(self, *args):
        """
        NodeAttrIsFltDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_NodeAttrIsFltDeleted(self, *args)

    def EdgeAttrIsDeleted(self, *args):
        """
        EdgeAttrIsDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_EdgeAttrIsDeleted(self, *args)

    def EdgeAttrIsIntDeleted(self, *args):
        """
        EdgeAttrIsIntDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_EdgeAttrIsIntDeleted(self, *args)

    def EdgeAttrIsStrDeleted(self, *args):
        """
        EdgeAttrIsStrDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_EdgeAttrIsStrDeleted(self, *args)

    def EdgeAttrIsFltDeleted(self, *args):
        """
        EdgeAttrIsFltDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_EdgeAttrIsFltDeleted(self, *args)

    def GetNodeAttrValue(self, *args):
        """
        GetNodeAttrValue(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_GetNodeAttrValue(self, *args)

    def GetEdgeAttrValue(self, *args):
        """
        GetEdgeAttrValue(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_GetEdgeAttrValue(self, *args)

PNEANet.Save = new_instancemethod(_snap.PNEANet_Save,None,PNEANet)
PNEANet.__deref__ = new_instancemethod(_snap.PNEANet___deref__,None,PNEANet)
PNEANet.__ref__ = new_instancemethod(_snap.PNEANet___ref__,None,PNEANet)
PNEANet.__call__ = new_instancemethod(_snap.PNEANet___call__,None,PNEANet)
PNEANet.Empty = new_instancemethod(_snap.PNEANet_Empty,None,PNEANet)
PNEANet.Clr = new_instancemethod(_snap.PNEANet_Clr,None,PNEANet)
PNEANet.GetRefs = new_instancemethod(_snap.PNEANet_GetRefs,None,PNEANet)
PNEANet.Load = new_instancemethod(_snap.PNEANet_Load,None,PNEANet)
PNEANet.HasFlag = new_instancemethod(_snap.PNEANet_HasFlag,None,PNEANet)
PNEANet.GetNodes = new_instancemethod(_snap.PNEANet_GetNodes,None,PNEANet)
PNEANet.AddNode = new_instancemethod(_snap.PNEANet_AddNode,None,PNEANet)
PNEANet.DelNode = new_instancemethod(_snap.PNEANet_DelNode,None,PNEANet)
PNEANet.IsNode = new_instancemethod(_snap.PNEANet_IsNode,None,PNEANet)
PNEANet.BegNI = new_instancemethod(_snap.PNEANet_BegNI,None,PNEANet)
PNEANet.EndNI = new_instancemethod(_snap.PNEANet_EndNI,None,PNEANet)
PNEANet.GetNI = new_instancemethod(_snap.PNEANet_GetNI,None,PNEANet)
PNEANet.BegNAIntI = new_instancemethod(_snap.PNEANet_BegNAIntI,None,PNEANet)
PNEANet.EndNAIntI = new_instancemethod(_snap.PNEANet_EndNAIntI,None,PNEANet)
PNEANet.GetNAIntI = new_instancemethod(_snap.PNEANet_GetNAIntI,None,PNEANet)
PNEANet.BegNAStrI = new_instancemethod(_snap.PNEANet_BegNAStrI,None,PNEANet)
PNEANet.EndNAStrI = new_instancemethod(_snap.PNEANet_EndNAStrI,None,PNEANet)
PNEANet.GetNAStrI = new_instancemethod(_snap.PNEANet_GetNAStrI,None,PNEANet)
PNEANet.BegNAFltI = new_instancemethod(_snap.PNEANet_BegNAFltI,None,PNEANet)
PNEANet.EndNAFltI = new_instancemethod(_snap.PNEANet_EndNAFltI,None,PNEANet)
PNEANet.GetNAFltI = new_instancemethod(_snap.PNEANet_GetNAFltI,None,PNEANet)
PNEANet.AttrNameNI = new_instancemethod(_snap.PNEANet_AttrNameNI,None,PNEANet)
PNEANet.AttrValueNI = new_instancemethod(_snap.PNEANet_AttrValueNI,None,PNEANet)
PNEANet.IntAttrNameNI = new_instancemethod(_snap.PNEANet_IntAttrNameNI,None,PNEANet)
PNEANet.IntAttrValueNI = new_instancemethod(_snap.PNEANet_IntAttrValueNI,None,PNEANet)
PNEANet.StrAttrNameNI = new_instancemethod(_snap.PNEANet_StrAttrNameNI,None,PNEANet)
PNEANet.StrAttrValueNI = new_instancemethod(_snap.PNEANet_StrAttrValueNI,None,PNEANet)
PNEANet.FltAttrNameNI = new_instancemethod(_snap.PNEANet_FltAttrNameNI,None,PNEANet)
PNEANet.FltAttrValueNI = new_instancemethod(_snap.PNEANet_FltAttrValueNI,None,PNEANet)
PNEANet.AttrNameEI = new_instancemethod(_snap.PNEANet_AttrNameEI,None,PNEANet)
PNEANet.AttrValueEI = new_instancemethod(_snap.PNEANet_AttrValueEI,None,PNEANet)
PNEANet.IntAttrNameEI = new_instancemethod(_snap.PNEANet_IntAttrNameEI,None,PNEANet)
PNEANet.IntAttrValueEI = new_instancemethod(_snap.PNEANet_IntAttrValueEI,None,PNEANet)
PNEANet.StrAttrNameEI = new_instancemethod(_snap.PNEANet_StrAttrNameEI,None,PNEANet)
PNEANet.StrAttrValueEI = new_instancemethod(_snap.PNEANet_StrAttrValueEI,None,PNEANet)
PNEANet.FltAttrNameEI = new_instancemethod(_snap.PNEANet_FltAttrNameEI,None,PNEANet)
PNEANet.FltAttrValueEI = new_instancemethod(_snap.PNEANet_FltAttrValueEI,None,PNEANet)
PNEANet.BegEAIntI = new_instancemethod(_snap.PNEANet_BegEAIntI,None,PNEANet)
PNEANet.EndEAIntI = new_instancemethod(_snap.PNEANet_EndEAIntI,None,PNEANet)
PNEANet.GetEAIntI = new_instancemethod(_snap.PNEANet_GetEAIntI,None,PNEANet)
PNEANet.BegEAStrI = new_instancemethod(_snap.PNEANet_BegEAStrI,None,PNEANet)
PNEANet.EndEAStrI = new_instancemethod(_snap.PNEANet_EndEAStrI,None,PNEANet)
PNEANet.GetEAStrI = new_instancemethod(_snap.PNEANet_GetEAStrI,None,PNEANet)
PNEANet.BegEAFltI = new_instancemethod(_snap.PNEANet_BegEAFltI,None,PNEANet)
PNEANet.EndEAFltI = new_instancemethod(_snap.PNEANet_EndEAFltI,None,PNEANet)
PNEANet.GetEAFltI = new_instancemethod(_snap.PNEANet_GetEAFltI,None,PNEANet)
PNEANet.GetMxNId = new_instancemethod(_snap.PNEANet_GetMxNId,None,PNEANet)
PNEANet.GetEdges = new_instancemethod(_snap.PNEANet_GetEdges,None,PNEANet)
PNEANet.AddEdge = new_instancemethod(_snap.PNEANet_AddEdge,None,PNEANet)
PNEANet.DelEdge = new_instancemethod(_snap.PNEANet_DelEdge,None,PNEANet)
PNEANet.IsEdge = new_instancemethod(_snap.PNEANet_IsEdge,None,PNEANet)
PNEANet.GetEId = new_instancemethod(_snap.PNEANet_GetEId,None,PNEANet)
PNEANet.BegEI = new_instancemethod(_snap.PNEANet_BegEI,None,PNEANet)
PNEANet.EndEI = new_instancemethod(_snap.PNEANet_EndEI,None,PNEANet)
PNEANet.GetEI = new_instancemethod(_snap.PNEANet_GetEI,None,PNEANet)
PNEANet.GetRndNId = new_instancemethod(_snap.PNEANet_GetRndNId,None,PNEANet)
PNEANet.GetRndNI = new_instancemethod(_snap.PNEANet_GetRndNI,None,PNEANet)
PNEANet.GetRndEId = new_instancemethod(_snap.PNEANet_GetRndEId,None,PNEANet)
PNEANet.GetRndEI = new_instancemethod(_snap.PNEANet_GetRndEI,None,PNEANet)
PNEANet.GetNIdV = new_instancemethod(_snap.PNEANet_GetNIdV,None,PNEANet)
PNEANet.GetEIdV = new_instancemethod(_snap.PNEANet_GetEIdV,None,PNEANet)
PNEANet.Reserve = new_instancemethod(_snap.PNEANet_Reserve,None,PNEANet)
PNEANet.Defrag = new_instancemethod(_snap.PNEANet_Defrag,None,PNEANet)
PNEANet.IsOk = new_instancemethod(_snap.PNEANet_IsOk,None,PNEANet)
PNEANet.Dump = new_instancemethod(_snap.PNEANet_Dump,None,PNEANet)
PNEANet.AddIntAttrDatN = new_instancemethod(_snap.PNEANet_AddIntAttrDatN,None,PNEANet)
PNEANet.AddStrAttrDatN = new_instancemethod(_snap.PNEANet_AddStrAttrDatN,None,PNEANet)
PNEANet.AddFltAttrDatN = new_instancemethod(_snap.PNEANet_AddFltAttrDatN,None,PNEANet)
PNEANet.AddIntAttrDatE = new_instancemethod(_snap.PNEANet_AddIntAttrDatE,None,PNEANet)
PNEANet.AddStrAttrDatE = new_instancemethod(_snap.PNEANet_AddStrAttrDatE,None,PNEANet)
PNEANet.AddFltAttrDatE = new_instancemethod(_snap.PNEANet_AddFltAttrDatE,None,PNEANet)
PNEANet.GetIntAttrDatN = new_instancemethod(_snap.PNEANet_GetIntAttrDatN,None,PNEANet)
PNEANet.GetStrAttrDatN = new_instancemethod(_snap.PNEANet_GetStrAttrDatN,None,PNEANet)
PNEANet.GetFltAttrDatN = new_instancemethod(_snap.PNEANet_GetFltAttrDatN,None,PNEANet)
PNEANet.GetIntAttrDatE = new_instancemethod(_snap.PNEANet_GetIntAttrDatE,None,PNEANet)
PNEANet.GetStrAttrDatE = new_instancemethod(_snap.PNEANet_GetStrAttrDatE,None,PNEANet)
PNEANet.GetFltAttrDatE = new_instancemethod(_snap.PNEANet_GetFltAttrDatE,None,PNEANet)
PNEANet.DelAttrDatN = new_instancemethod(_snap.PNEANet_DelAttrDatN,None,PNEANet)
PNEANet.DelAttrDatE = new_instancemethod(_snap.PNEANet_DelAttrDatE,None,PNEANet)
PNEANet.AddIntAttrN = new_instancemethod(_snap.PNEANet_AddIntAttrN,None,PNEANet)
PNEANet.AddStrAttrN = new_instancemethod(_snap.PNEANet_AddStrAttrN,None,PNEANet)
PNEANet.AddFltAttrN = new_instancemethod(_snap.PNEANet_AddFltAttrN,None,PNEANet)
PNEANet.AddIntAttrE = new_instancemethod(_snap.PNEANet_AddIntAttrE,None,PNEANet)
PNEANet.AddStrAttrE = new_instancemethod(_snap.PNEANet_AddStrAttrE,None,PNEANet)
PNEANet.AddFltAttrE = new_instancemethod(_snap.PNEANet_AddFltAttrE,None,PNEANet)
PNEANet.DelAttrN = new_instancemethod(_snap.PNEANet_DelAttrN,None,PNEANet)
PNEANet.DelAttrE = new_instancemethod(_snap.PNEANet_DelAttrE,None,PNEANet)
PNEANet.NodeAttrIsDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsDeleted,None,PNEANet)
PNEANet.NodeAttrIsIntDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsIntDeleted,None,PNEANet)
PNEANet.NodeAttrIsStrDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsStrDeleted,None,PNEANet)
PNEANet.NodeAttrIsFltDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsFltDeleted,None,PNEANet)
PNEANet.EdgeAttrIsDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsDeleted,None,PNEANet)
PNEANet.EdgeAttrIsIntDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsIntDeleted,None,PNEANet)
PNEANet.EdgeAttrIsStrDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsStrDeleted,None,PNEANet)
PNEANet.EdgeAttrIsFltDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsFltDeleted,None,PNEANet)
PNEANet.GetNodeAttrValue = new_instancemethod(_snap.PNEANet_GetNodeAttrValue,None,PNEANet)
PNEANet.GetEdgeAttrValue = new_instancemethod(_snap.PNEANet_GetEdgeAttrValue,None,PNEANet)
PNEANet_swigregister = _snap.PNEANet_swigregister
PNEANet_swigregister(PNEANet)

def PNEANet_New():
  """PNEANet_New() -> PNEANet"""
  return _snap.PNEANet_New()


def GetNodeWcc(*args):
  """
    GetNodeWcc(PNEANet Graph, int const & NId, TIntV CnCom)

    Parameters:
        Graph: TPt< TNEANet > const &
        NId: int const &
        CnCom: TIntV &

    """
  return _snap.GetNodeWcc(*args)

def IsConnected(*args):
  """
    IsConnected(PNEANet Graph) -> bool

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.IsConnected(*args)

def IsWeaklyConn(*args):
  """
    IsWeaklyConn(PNEANet Graph) -> bool

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.IsWeaklyConn(*args)

def GetWccSzCnt(*args):
  """
    GetWccSzCnt(PNEANet Graph, TIntPrV & WccSzCnt)

    Parameters:
        Graph: TPt< TNEANet > const &
        WccSzCnt: TIntPrV &

    """
  return _snap.GetWccSzCnt(*args)

def GetWccs(*args):
  """
    GetWccs(PNEANet Graph, TCnComV & CnComV)

    Parameters:
        Graph: TPt< TNEANet > const &
        CnComV: TCnComV &

    """
  return _snap.GetWccs(*args)

def GetSccSzCnt(*args):
  """
    GetSccSzCnt(PNEANet Graph, TIntPrV & SccSzCnt)

    Parameters:
        Graph: TPt< TNEANet > const &
        SccSzCnt: TIntPrV &

    """
  return _snap.GetSccSzCnt(*args)

def GetSccs(*args):
  """
    GetSccs(PNEANet Graph, TCnComV & CnComV)

    Parameters:
        Graph: TPt< TNEANet > const &
        CnComV: TCnComV &

    """
  return _snap.GetSccs(*args)

def GetMxWccSz(*args):
  """
    GetMxWccSz(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxWccSz(*args)

def GetMxWcc(*args):
  """
    GetMxWcc(PNEANet Graph) -> PNEANet

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxWcc(*args)

def GetMxScc(*args):
  """
    GetMxScc(PNEANet Graph) -> PNEANet

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxScc(*args)

def GetMxBiCon(*args):
  """
    GetMxBiCon(PUNGraph const & Graph, bool const & RenumberNodes=False) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        RenumberNodes: bool const &

    GetMxBiCon(PUNGraph const & Graph) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &

    GetMxBiCon(PNEANet Graph) -> PNEANet

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxBiCon(*args)

def CntInDegNodes(*args):
  """
    CntInDegNodes(PNEANet Graph, int const & NodeInDeg) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NodeInDeg: int const &

    """
  return _snap.CntInDegNodes(*args)

def CntOutDegNodes(*args):
  """
    CntOutDegNodes(PNEANet Graph, int const & NodeOutDeg) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NodeOutDeg: int const &

    """
  return _snap.CntOutDegNodes(*args)

def CntDegNodes(*args):
  """
    CntDegNodes(PNEANet Graph, int const & NodeDeg) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NodeDeg: int const &

    """
  return _snap.CntDegNodes(*args)

def CntNonZNodes(*args):
  """
    CntNonZNodes(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntNonZNodes(*args)

def CntEdgesToSet(*args):
  """
    CntEdgesToSet(PNEANet Graph, int const & NId, TIntSet const & NodeSet) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NId: int const &
        NodeSet: TIntSet const &

    """
  return _snap.CntEdgesToSet(*args)

def GetMxDegNId(*args):
  """
    GetMxDegNId(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxDegNId(*args)

def GetMxInDegNId(*args):
  """
    GetMxInDegNId(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxInDegNId(*args)

def GetMxOutDegNId(*args):
  """
    GetMxOutDegNId(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxOutDegNId(*args)

def GetInDegCnt(*args):
  """
    GetInDegCnt(PNEANet Graph, TIntPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TIntPrV &

    GetInDegCnt(PNEANet Graph, TFltPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TFltPrV &

    """
  return _snap.GetInDegCnt(*args)

def GetOutDegCnt(*args):
  """
    GetOutDegCnt(PNEANet Graph, TIntPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TIntPrV &

    GetOutDegCnt(PNEANet Graph, TFltPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TFltPrV &

    """
  return _snap.GetOutDegCnt(*args)

def GetDegCnt(*args):
  """
    GetDegCnt(PNEANet Graph, TIntPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TIntPrV &

    GetDegCnt(PNEANet Graph, TFltPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TFltPrV &

    """
  return _snap.GetDegCnt(*args)

def GetDegSeqV(*args):
  """
    GetDegSeqV(PNEANet Graph, TIntV DegV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegV: TIntV &

    GetDegSeqV(PNEANet Graph, TIntV InDegV, TIntV OutDegV)

    Parameters:
        Graph: TPt< TNEANet > const &
        InDegV: TIntV &
        OutDegV: TIntV &

    """
  return _snap.GetDegSeqV(*args)

def GetNodeInDegV(*args):
  """
    GetNodeInDegV(PNEANet Graph, TIntPrV & NIdInDegV)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdInDegV: TIntPrV &

    """
  return _snap.GetNodeInDegV(*args)

def GetNodeOutDegV(*args):
  """
    GetNodeOutDegV(PNEANet Graph, TIntPrV & NIdOutDegV)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdOutDegV: TIntPrV &

    """
  return _snap.GetNodeOutDegV(*args)

def CntUniqUndirEdges(*args):
  """
    CntUniqUndirEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntUniqUndirEdges(*args)

def CntUniqDirEdges(*args):
  """
    CntUniqDirEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntUniqDirEdges(*args)

def CntUniqBiDirEdges(*args):
  """
    CntUniqBiDirEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntUniqBiDirEdges(*args)

def CntSelfEdges(*args):
  """
    CntSelfEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntSelfEdges(*args)

def GetBfsTree(*args):
  """
    GetBfsTree(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn) -> PNGraph

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        FollowOut: bool const &
        FollowIn: bool const &

    """
  return _snap.GetBfsTree(*args)

def GetSubTreeSz(*args):
  """
    GetSubTreeSz(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn, 
        int & TreeSz, int & TreeDepth) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        FollowOut: bool const &
        FollowIn: bool const &
        TreeSz: int &
        TreeDepth: int &

    """
  return _snap.GetSubTreeSz(*args)

def GetNodesAtHop(*args):
  """
    GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        Hop: int const &
        NIdV: TIntV &
        IsDir: bool const &

    GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        Hop: int const &
        NIdV: TIntV &

    """
  return _snap.GetNodesAtHop(*args)

def GetNodesAtHops(*args):
  """
    GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        HopCntV: TIntPrV &
        IsDir: bool const &

    GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        HopCntV: TIntPrV &

    """
  return _snap.GetNodesAtHops(*args)

def GetShortPath(*args):
  """
    GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        DstNId: int const &
        IsDir: bool const &

    GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        DstNId: int const &

    GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False, int const & MaxDist=Mx) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        NIdToDistH: TIntH &
        IsDir: bool const &
        MaxDist: int const &

    GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        NIdToDistH: TIntH &
        IsDir: bool const &

    GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        NIdToDistH: TIntH &

    """
  return _snap.GetShortPath(*args)

def GetBfsFullDiam(*args):
  """
    GetBfsFullDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        IsDir: bool const &

    GetBfsFullDiam(PNEANet Graph, int const & NTestNodes) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &

    """
  return _snap.GetBfsFullDiam(*args)

def GetBfsEffDiam(*args):
  """
    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        IsDir: bool const &

    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &

    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        IsDir: bool const &
        EffDiam: double &
        FullDiam: int &

    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam, 
        double & AvgSPL) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        IsDir: bool const &
        EffDiam: double &
        FullDiam: int &
        AvgSPL: double &

    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, TIntV SubGraphNIdV, bool const & IsDir, double & EffDiam, 
        int & FullDiam) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        SubGraphNIdV: TIntV const &
        IsDir: bool const &
        EffDiam: double &
        FullDiam: int &

    """
  return _snap.GetBfsEffDiam(*args)

def DrawGViz(*args):
  """
    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False, 
        TIntStrH const & NIdColorH=TIntStrH())

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &
        Desc: TStr const &
        NodeLabels: bool const &
        NIdColorH: TIntStrH const &

    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False)

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &
        Desc: TStr const &
        NodeLabels: bool const &

    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr())

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &
        Desc: TStr const &

    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm)

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &

    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc, TIntStrH const & NodeLabelH)

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &
        Desc: TStr const &
        NodeLabelH: TIntStrH const &

    """
  return _snap.DrawGViz(*args)

def GetClustCf(*args):
  """
    GetClustCf(PNEANet Graph, int SampleNodes=-1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        SampleNodes: int

    GetClustCf(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int SampleNodes=-1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCCfV: TFltPrV &
        SampleNodes: int

    GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCCfV: TFltPrV &

    GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes=-1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCCfV: TFltPrV &
        ClosedTriads: int64 &
        OpenTriads: int64 &
        SampleNodes: int

    GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCCfV: TFltPrV &
        ClosedTriads: int64 &
        OpenTriads: int64 &

    """
  return _snap.GetClustCf(*args)

def GetNodeClustCf(*args):
  """
    GetNodeClustCf(PNEANet Graph, int const & NId) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NId: int const &

    GetNodeClustCf(PNEANet Graph, TIntFltH & NIdCCfH)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdCCfH: TIntFltH &

    """
  return _snap.GetNodeClustCf(*args)

def GetTriads(*args):
  """
    GetTriads(PNEANet Graph, int SampleNodes=-1) -> int64

    Parameters:
        Graph: TPt< TNEANet > const &
        SampleNodes: int

    GetTriads(PNEANet Graph) -> int64

    Parameters:
        Graph: TPt< TNEANet > const &

    GetTriads(PNEANet Graph, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes) -> int64

    Parameters:
        Graph: TPt< TNEANet > const &
        ClosedTriads: int64 &
        OpenTriads: int64 &
        SampleNodes: int

    GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV, int SampleNodes=-1)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdCOTriadV: TIntTrV &
        SampleNodes: int

    GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdCOTriadV: TIntTrV &

    """
  return _snap.GetTriads(*args)

def GetTriadEdges(*args):
  """
    GetTriadEdges(PNEANet Graph, int SampleEdges=-1) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SampleEdges: int

    GetTriadEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetTriadEdges(*args)

def GetTriadParticip(*args):
  """
    GetTriadParticip(PNEANet Graph, TIntPrV & TriadCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        TriadCntV: TIntPrV &

    """
  return _snap.GetTriadParticip(*args)

def GetCmnNbrs(*args):
  """
    GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NId1: int const &
        NId2: int const &

    GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2, TIntV NbrV) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NId1: int const &
        NId2: int const &
        NbrV: TIntV &

    """
  return _snap.GetCmnNbrs(*args)

def GetModularity(*args):
  """
    GetModularity(PNEANet G, TIntV NIdV, int GEdges=-1) -> double

    Parameters:
        G: TPt< TNEANet > const &
        NIdV: TIntV const &
        GEdges: int

    GetModularity(PNEANet G, TIntV NIdV) -> double

    Parameters:
        G: TPt< TNEANet > const &
        NIdV: TIntV const &

    GetModularity(PNEANet G, TCnComV const & CmtyV, int GEdges=-1) -> double

    Parameters:
        G: TPt< TNEANet > const &
        CmtyV: TCnComV const &
        GEdges: int

    GetModularity(PNEANet G, TCnComV const & CmtyV) -> double

    Parameters:
        G: TPt< TNEANet > const &
        CmtyV: TCnComV const &

    """
  return _snap.GetModularity(*args)

def GetEdgesInOut(*args):
  """
    GetEdgesInOut(PNEANet Graph, TIntV NIdV, int & EdgesIn, int & EdgesOut)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdV: TIntV const &
        EdgesIn: int &
        EdgesOut: int &

    """
  return _snap.GetEdgesInOut(*args)

def GetAnf(*args):
  """
    GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir, 
        int const & NApprox=32)

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        DistNbrsV: TIntFltKdV &
        MxDist: int const &
        IsDir: bool const &
        NApprox: int const &

    GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir)

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        DistNbrsV: TIntFltKdV &
        MxDist: int const &
        IsDir: bool const &

    GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir, int const & NApprox=32)

    Parameters:
        Graph: TPt< TNEANet > const &
        DistNbrsV: TIntFltKdV &
        MxDist: int const &
        IsDir: bool const &
        NApprox: int const &

    GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir)

    Parameters:
        Graph: TPt< TNEANet > const &
        DistNbrsV: TIntFltKdV &
        MxDist: int const &
        IsDir: bool const &

    """
  return _snap.GetAnf(*args)

def GetAnfEffDiam(*args):
  """
    GetAnfEffDiam(PNEANet Graph, bool const & IsDir, double const & Percentile, int const & NApprox) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        IsDir: bool const &
        Percentile: double const &
        NApprox: int const &

    GetAnfEffDiam(PNEANet Graph, int const NRuns=1, int NApprox=-1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NRuns: int const
        NApprox: int

    GetAnfEffDiam(PNEANet Graph, int const NRuns=1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NRuns: int const

    GetAnfEffDiam(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetAnfEffDiam(*args)



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



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

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

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

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

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


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr



def CalcEffDiam(*args):
  """
    CalcEffDiam(TIntFltKdV const & DistNbrsCdfV, double const & Percentile=0.9) -> double

    Parameters:
        DistNbrsCdfV: TIntFltKdV const &
        Percentile: double const &

    CalcEffDiam(TIntFltKdV const & DistNbrsCdfV) -> double

    Parameters:
        DistNbrsCdfV: TIntFltKdV const &

    CalcEffDiam(TFltPrV const & DistNbrsCdfV, double const & Percentile=0.9) -> double

    Parameters:
        DistNbrsCdfV: TFltPrV const &
        Percentile: double const &

    CalcEffDiam(TFltPrV const & DistNbrsCdfV) -> double

    Parameters:
        DistNbrsCdfV: TFltPrV const &

    """
  return _snap.CalcEffDiam(*args)

def CalcEffDiamPdf(*args):
  """
    CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV, double const & Percentile=0.9) -> double

    Parameters:
        DistNbrsPdfV: TIntFltKdV const &
        Percentile: double const &

    CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double

    Parameters:
        DistNbrsPdfV: TIntFltKdV const &

    CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV, double const & Percentile=0.9) -> double

    Parameters:
        DistNbrsPdfV: TFltPrV const &
        Percentile: double const &

    CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV) -> double

    Parameters:
        DistNbrsPdfV: TFltPrV const &

    """
  return _snap.CalcEffDiamPdf(*args)

def CalcAvgDiamPdf(*args):
  """
    CalcAvgDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double

    Parameters:
        DistNbrsPdfV: TIntFltKdV const &

    CalcAvgDiamPdf(TFltPrV const & DistNbrsPdfV) -> double

    Parameters:
        DistNbrsPdfV: TFltPrV const &

    """
  return _snap.CalcAvgDiamPdf(*args)
lUndef = _snap.lUndef
lUs = _snap.lUs
lSi = _snap.lSi

def WrNotify(*args):
  """
    WrNotify(char const * CaptionCStr, char const * NotifyCStr)

    Parameters:
        CaptionCStr: char const *
        NotifyCStr: char const *

    """
  return _snap.WrNotify(*args)

def SaveToErrLog(*args):
  """
    SaveToErrLog(char const * MsgCStr)

    Parameters:
        MsgCStr: char const *

    """
  return _snap.SaveToErrLog(*args)

def InfoNotify(*args):
  """
    InfoNotify(char const * NotifyCStr)

    Parameters:
        NotifyCStr: char const *

    """
  return _snap.InfoNotify(*args)

def WarnNotify(*args):
  """
    WarnNotify(char const * NotifyCStr)

    Parameters:
        NotifyCStr: char const *

    """
  return _snap.WarnNotify(*args)

def ErrNotify(*args):
  """
    ErrNotify(char const * NotifyCStr)

    Parameters:
        NotifyCStr: char const *

    """
  return _snap.ErrNotify(*args)

def StatNotify(*args):
  """
    StatNotify(char const * NotifyCStr)

    Parameters:
        NotifyCStr: char const *

    """
  return _snap.StatNotify(*args)

def ExeStop(*args):
  """
    ExeStop(char const * MsgStr, char const * ReasonStr, char const * CondStr, char const * FNm, 
        int const & LnN)

    Parameters:
        MsgStr: char const *
        ReasonStr: char const *
        CondStr: char const *
        FNm: char const *
        LnN: int const &

    """
  return _snap.ExeStop(*args)
loUndef = _snap.loUndef
loNot = _snap.loNot
loAnd = _snap.loAnd
loOr = _snap.loOr
roUndef = _snap.roUndef
roLs = _snap.roLs
roLEq = _snap.roLEq
roEq = _snap.roEq
roNEq = _snap.roNEq
roGEq = _snap.roGEq
roGt = _snap.roGt
class TCRef(object):
    """Proxy of C++ TCRef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(TCRef self) -> TCRef"""
        _snap.TCRef_swiginit(self,_snap.new_TCRef())
    __swig_destroy__ = _snap.delete_TCRef
    def MkRef(self):
        """
        MkRef(TCRef self)

        Parameters:
            self: TCRef *

        """
        return _snap.TCRef_MkRef(self)

    def UnRef(self):
        """
        UnRef(TCRef self)

        Parameters:
            self: TCRef *

        """
        return _snap.TCRef_UnRef(self)

    def NoRef(self):
        """
        NoRef(TCRef self) -> bool

        Parameters:
            self: TCRef const *

        """
        return _snap.TCRef_NoRef(self)

    def GetRefs(self):
        """
        GetRefs(TCRef self) -> int

        Parameters:
            self: TCRef const *

        """
        return _snap.TCRef_GetRefs(self)

TCRef.MkRef = new_instancemethod(_snap.TCRef_MkRef,None,TCRef)
TCRef.UnRef = new_instancemethod(_snap.TCRef_UnRef,None,TCRef)
TCRef.NoRef = new_instancemethod(_snap.TCRef_NoRef,None,TCRef)
TCRef.GetRefs = new_instancemethod(_snap.TCRef_GetRefs,None,TCRef)
TCRef_swigregister = _snap.TCRef_swigregister
TCRef_swigregister(TCRef)

class TSStr(object):
    """Proxy of C++ TSStr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TSStr self) -> TSStr
        __init__(TSStr self, TSStr SStr) -> TSStr

        Parameters:
            SStr: TSStr const &

        __init__(TSStr self, char const * _Bf) -> TSStr

        Parameters:
            _Bf: char const *

        """
        _snap.TSStr_swiginit(self,_snap.new_TSStr(*args))
    __swig_destroy__ = _snap.delete_TSStr
    def CStr(self, *args):
        """
        CStr(TSStr self) -> char
        CStr(TSStr self) -> char const *

        Parameters:
            self: TSStr const *

        """
        return _snap.TSStr_CStr(self, *args)

    def Empty(self):
        """
        Empty(TSStr self) -> bool

        Parameters:
            self: TSStr const *

        """
        return _snap.TSStr_Empty(self)

    def Len(self):
        """
        Len(TSStr self) -> int

        Parameters:
            self: TSStr const *

        """
        return _snap.TSStr_Len(self)

TSStr.CStr = new_instancemethod(_snap.TSStr_CStr,None,TSStr)
TSStr.Empty = new_instancemethod(_snap.TSStr_Empty,None,TSStr)
TSStr.Len = new_instancemethod(_snap.TSStr_Len,None,TSStr)
TSStr_swigregister = _snap.TSStr_swigregister
TSStr_swigregister(TSStr)

class TConv_Pt64Ints32(object):
    """Proxy of C++ TConv_Pt64Ints32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TConv_Pt64Ints32 self) -> TConv_Pt64Ints32
        __init__(TConv_Pt64Ints32 self, void * Pt) -> TConv_Pt64Ints32

        Parameters:
            Pt: void *

        __init__(TConv_Pt64Ints32 self, uint const & Ms, uint const & Ls) -> TConv_Pt64Ints32

        Parameters:
            Ms: uint const &
            Ls: uint const &

        """
        _snap.TConv_Pt64Ints32_swiginit(self,_snap.new_TConv_Pt64Ints32(*args))
    def PutPt(self, *args):
        """
        PutPt(TConv_Pt64Ints32 self, void * Pt)

        Parameters:
            Pt: void *

        """
        return _snap.TConv_Pt64Ints32_PutPt(self, *args)

    def GetPt(self):
        """
        GetPt(TConv_Pt64Ints32 self) -> void *

        Parameters:
            self: TConv_Pt64Ints32 const *

        """
        return _snap.TConv_Pt64Ints32_GetPt(self)

    def PutUInt64(self, *args):
        """
        PutUInt64(TConv_Pt64Ints32 self, uint64 const & _UInt64)

        Parameters:
            _UInt64: uint64 const &

        """
        return _snap.TConv_Pt64Ints32_PutUInt64(self, *args)

    def GetUInt64(self):
        """
        GetUInt64(TConv_Pt64Ints32 self) -> uint64

        Parameters:
            self: TConv_Pt64Ints32 const *

        """
        return _snap.TConv_Pt64Ints32_GetUInt64(self)

    def PutMsUInt32(self, *args):
        """
        PutMsUInt32(TConv_Pt64Ints32 self, uint const & Ms)

        Parameters:
            Ms: uint const &

        """
        return _snap.TConv_Pt64Ints32_PutMsUInt32(self, *args)

    def GetMsUInt32(self):
        """
        GetMsUInt32(TConv_Pt64Ints32 self) -> uint

        Parameters:
            self: TConv_Pt64Ints32 const *

        """
        return _snap.TConv_Pt64Ints32_GetMsUInt32(self)

    def PutLsUInt32(self, *args):
        """
        PutLsUInt32(TConv_Pt64Ints32 self, uint const & Ls)

        Parameters:
            Ls: uint const &

        """
        return _snap.TConv_Pt64Ints32_PutLsUInt32(self, *args)

    def GetLsUInt32(self):
        """
        GetLsUInt32(TConv_Pt64Ints32 self) -> uint

        Parameters:
            self: TConv_Pt64Ints32 const *

        """
        return _snap.TConv_Pt64Ints32_GetLsUInt32(self)

    __swig_destroy__ = _snap.delete_TConv_Pt64Ints32
TConv_Pt64Ints32.PutPt = new_instancemethod(_snap.TConv_Pt64Ints32_PutPt,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.GetPt = new_instancemethod(_snap.TConv_Pt64Ints32_GetPt,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.PutUInt64 = new_instancemethod(_snap.TConv_Pt64Ints32_PutUInt64,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.GetUInt64 = new_instancemethod(_snap.TConv_Pt64Ints32_GetUInt64,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.PutMsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_PutMsUInt32,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.GetMsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_GetMsUInt32,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.PutLsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_PutLsUInt32,None,TConv_Pt64Ints32)
TConv_Pt64Ints32.GetLsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_GetLsUInt32,None,TConv_Pt64Ints32)
TConv_Pt64Ints32_swigregister = _snap.TConv_Pt64Ints32_swigregister
TConv_Pt64Ints32_swigregister(TConv_Pt64Ints32)

class TPairHashImpl1(object):
    """Proxy of C++ TPairHashImpl1 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetHashCd(*args):
        """
        GetHashCd(int const hc1, int const hc2) -> int

        Parameters:
            hc1: int const
            hc2: int const

        """
        return _snap.TPairHashImpl1_GetHashCd(*args)

    GetHashCd = staticmethod(GetHashCd)
    def __init__(self): 
        """__init__(TPairHashImpl1 self) -> TPairHashImpl1"""
        _snap.TPairHashImpl1_swiginit(self,_snap.new_TPairHashImpl1())
    __swig_destroy__ = _snap.delete_TPairHashImpl1
TPairHashImpl1_swigregister = _snap.TPairHashImpl1_swigregister
TPairHashImpl1_swigregister(TPairHashImpl1)

def TPairHashImpl1_GetHashCd(*args):
  """
    TPairHashImpl1_GetHashCd(int const hc1, int const hc2) -> int

    Parameters:
        hc1: int const
        hc2: int const

    """
  return _snap.TPairHashImpl1_GetHashCd(*args)

class TPairHashImpl2(object):
    """Proxy of C++ TPairHashImpl2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetHashCd(*args):
        """
        GetHashCd(int const hc1, int const hc2) -> int

        Parameters:
            hc1: int const
            hc2: int const

        """
        return _snap.TPairHashImpl2_GetHashCd(*args)

    GetHashCd = staticmethod(GetHashCd)
    def __init__(self): 
        """__init__(TPairHashImpl2 self) -> TPairHashImpl2"""
        _snap.TPairHashImpl2_swiginit(self,_snap.new_TPairHashImpl2())
    __swig_destroy__ = _snap.delete_TPairHashImpl2
TPairHashImpl2_swigregister = _snap.TPairHashImpl2_swigregister
TPairHashImpl2_swigregister(TPairHashImpl2)

def TPairHashImpl2_GetHashCd(*args):
  """
    TPairHashImpl2_GetHashCd(int const hc1, int const hc2) -> int

    Parameters:
        hc1: int const
        hc2: int const

    """
  return _snap.TPairHashImpl2_GetHashCd(*args)


def GetDegreeCentr(*args):
  """
    GetDegreeCentr(PUNGraph const & Graph, int const & NId) -> double

    Parameters:
        Graph: PUNGraph const &
        NId: int const &

    """
  return _snap.GetDegreeCentr(*args)

def GetFarnessCentr(*args):
  """
    GetFarnessCentr(PUNGraph const & Graph, int const & NId) -> double

    Parameters:
        Graph: PUNGraph const &
        NId: int const &

    """
  return _snap.GetFarnessCentr(*args)

def GetClosenessCentr(*args):
  """
    GetClosenessCentr(PUNGraph const & Graph, int const & NId) -> double

    Parameters:
        Graph: PUNGraph const &
        NId: int const &

    """
  return _snap.GetClosenessCentr(*args)

def GetBetweennessCentr(*args):
  """
    GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, double const & NodeFrac=1.0)

    Parameters:
        Graph: PUNGraph const &
        NIdBtwH: TIntFltH &
        NodeFrac: double const &

    GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH)

    Parameters:
        Graph: PUNGraph const &
        NIdBtwH: TIntFltH &

    GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0)

    Parameters:
        Graph: PUNGraph const &
        EdgeBtwH: TIntPrFltH &
        NodeFrac: double const &

    GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH)

    Parameters:
        Graph: PUNGraph const &
        EdgeBtwH: TIntPrFltH &

    GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0)

    Parameters:
        Graph: PUNGraph const &
        NIdBtwH: TIntFltH &
        EdgeBtwH: TIntPrFltH &
        NodeFrac: double const &

    GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH)

    Parameters:
        Graph: PUNGraph const &
        NIdBtwH: TIntFltH &
        EdgeBtwH: TIntPrFltH &

    GetBetweennessCentr(PUNGraph const & Graph, TIntV BtwNIdV, TIntFltH & NodeBtwH, bool const & DoNodeCent, 
        TIntPrFltH & EdgeBtwH, bool const & DoEdgeCent)

    Parameters:
        Graph: PUNGraph const &
        BtwNIdV: TIntV const &
        NodeBtwH: TIntFltH &
        DoNodeCent: bool const &
        EdgeBtwH: TIntPrFltH &
        DoEdgeCent: bool const &

    """
  return _snap.GetBetweennessCentr(*args)

def GetEigenVectorCentr(*args):
  """
    GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4, int const & MaxIter=100)

    Parameters:
        Graph: PUNGraph const &
        NIdEigenH: TIntFltH &
        Eps: double const &
        MaxIter: int const &

    GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4)

    Parameters:
        Graph: PUNGraph const &
        NIdEigenH: TIntFltH &
        Eps: double const &

    GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH)

    Parameters:
        Graph: PUNGraph const &
        NIdEigenH: TIntFltH &

    """
  return _snap.GetEigenVectorCentr(*args)

def CommunityGirvanNewman(*args):
  """
    CommunityGirvanNewman(PUNGraph & Graph, TCnComV & CmtyV) -> double

    Parameters:
        Graph: PUNGraph &
        CmtyV: TCnComV &

    """
  return _snap.CommunityGirvanNewman(*args)

def CommunityCNM(*args):
  """
    CommunityCNM(PUNGraph const & Graph, TCnComV & CmtyV) -> double

    Parameters:
        Graph: PUNGraph const &
        CmtyV: TCnComV &

    """
  return _snap.CommunityCNM(*args)

def CmtyGirvanNewmanStep(*args):
  """
    CmtyGirvanNewmanStep(PUNGraph & Graph, TIntV Cmty1, TIntV Cmty2)

    Parameters:
        Graph: PUNGraph &
        Cmty1: TIntV &
        Cmty2: TIntV &

    """
  return _snap.CmtyGirvanNewmanStep(*args)

def GetBiConSzCnt(*args):
  """
    GetBiConSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV)

    Parameters:
        Graph: PUNGraph const &
        SzCntV: TIntPrV &

    """
  return _snap.GetBiConSzCnt(*args)

def GetBiCon(*args):
  """
    GetBiCon(PUNGraph const & Graph, TCnComV & BiCnComV)

    Parameters:
        Graph: PUNGraph const &
        BiCnComV: TCnComV &

    """
  return _snap.GetBiCon(*args)

def GetArtPoints(*args):
  """
    GetArtPoints(PUNGraph const & Graph, TIntV ArtNIdV)

    Parameters:
        Graph: PUNGraph const &
        ArtNIdV: TIntV &

    """
  return _snap.GetArtPoints(*args)

def GetEdgeBridges(*args):
  """
    GetEdgeBridges(PUNGraph const & Graph, TIntPrV & EdgeV)

    Parameters:
        Graph: PUNGraph const &
        EdgeV: TIntPrV &

    """
  return _snap.GetEdgeBridges(*args)

def Get1CnComSzCnt(*args):
  """
    Get1CnComSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV)

    Parameters:
        Graph: PUNGraph const &
        SzCntV: TIntPrV &

    """
  return _snap.Get1CnComSzCnt(*args)

def Get1CnCom(*args):
  """
    Get1CnCom(PUNGraph const & Graph, TCnComV & Cn1ComV)

    Parameters:
        Graph: PUNGraph const &
        Cn1ComV: TCnComV &

    """
  return _snap.Get1CnCom(*args)
class TCnCom(object):
    """Proxy of C++ TCnCom class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NIdV = _swig_property(_snap.TCnCom_NIdV_get, _snap.TCnCom_NIdV_set)
    def __init__(self, *args): 
        """
        __init__(TCnCom self) -> TCnCom
        __init__(TCnCom self, TIntV NodeIdV) -> TCnCom

        Parameters:
            NodeIdV: TIntV const &

        __init__(TCnCom self, TCnCom CC) -> TCnCom

        Parameters:
            CC: TCnCom const &

        __init__(TCnCom self, TSIn SIn) -> TCnCom

        Parameters:
            SIn: TSIn &

        """
        _snap.TCnCom_swiginit(self,_snap.new_TCnCom(*args))
    def Save(self, *args):
        """
        Save(TCnCom self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TCnCom_Save(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TCnCom self, TCnCom CC) -> bool

        Parameters:
            CC: TCnCom const &

        """
        return _snap.TCnCom___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TCnCom self, TCnCom CC) -> bool

        Parameters:
            CC: TCnCom const &

        """
        return _snap.TCnCom___lt__(self, *args)

    def Len(self):
        """
        Len(TCnCom self) -> int

        Parameters:
            self: TCnCom const *

        """
        return _snap.TCnCom_Len(self)

    def Empty(self):
        """
        Empty(TCnCom self) -> bool

        Parameters:
            self: TCnCom const *

        """
        return _snap.TCnCom_Empty(self)

    def Clr(self):
        """
        Clr(TCnCom self)

        Parameters:
            self: TCnCom *

        """
        return _snap.TCnCom_Clr(self)

    def Add(self, *args):
        """
        Add(TCnCom self, int const & NodeId)

        Parameters:
            NodeId: int const &

        """
        return _snap.TCnCom_Add(self, *args)

    def __call__(self, *args):
        """
        __call__(TCnCom self) -> TIntV
        __call__(TCnCom self) -> TIntV

        Parameters:
            self: TCnCom *

        """
        return _snap.TCnCom___call__(self, *args)

    def Sort(self, Asc=True):
        """
        Sort(TCnCom self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        Sort(TCnCom self)

        Parameters:
            self: TCnCom *

        """
        return _snap.TCnCom_Sort(self, Asc)

    def IsNIdIn(self, *args):
        """
        IsNIdIn(TCnCom self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TCnCom_IsNIdIn(self, *args)

    def GetRndNId(self):
        """
        GetRndNId(TCnCom self) -> TInt

        Parameters:
            self: TCnCom const *

        """
        return _snap.TCnCom_GetRndNId(self)

    def Dump(*args):
        """
        Dump(TCnComV const & CnComV, TStr Desc=TStr())

        Parameters:
            CnComV: TCnComV const &
            Desc: TStr const &

        Dump(TCnComV const & CnComV)

        Parameters:
            CnComV: TCnComV const &

        """
        return _snap.TCnCom_Dump(*args)

    Dump = staticmethod(Dump)
    def SaveTxt(*args):
        """
        SaveTxt(TCnComV const & CnComV, TStr FNm, TStr Desc=TStr())

        Parameters:
            CnComV: TCnComV const &
            FNm: TStr const &
            Desc: TStr const &

        SaveTxt(TCnComV const & CnComV, TStr FNm)

        Parameters:
            CnComV: TCnComV const &
            FNm: TStr const &

        """
        return _snap.TCnCom_SaveTxt(*args)

    SaveTxt = staticmethod(SaveTxt)
    __swig_destroy__ = _snap.delete_TCnCom
TCnCom.Save = new_instancemethod(_snap.TCnCom_Save,None,TCnCom)
TCnCom.__eq__ = new_instancemethod(_snap.TCnCom___eq__,None,TCnCom)
TCnCom.__lt__ = new_instancemethod(_snap.TCnCom___lt__,None,TCnCom)
TCnCom.Len = new_instancemethod(_snap.TCnCom_Len,None,TCnCom)
TCnCom.Empty = new_instancemethod(_snap.TCnCom_Empty,None,TCnCom)
TCnCom.Clr = new_instancemethod(_snap.TCnCom_Clr,None,TCnCom)
TCnCom.Add = new_instancemethod(_snap.TCnCom_Add,None,TCnCom)
TCnCom.__call__ = new_instancemethod(_snap.TCnCom___call__,None,TCnCom)
TCnCom.Sort = new_instancemethod(_snap.TCnCom_Sort,None,TCnCom)
TCnCom.IsNIdIn = new_instancemethod(_snap.TCnCom_IsNIdIn,None,TCnCom)
TCnCom.GetRndNId = new_instancemethod(_snap.TCnCom_GetRndNId,None,TCnCom)
TCnCom_swigregister = _snap.TCnCom_swigregister
TCnCom_swigregister(TCnCom)

def TCnCom_Dump(*args):
  """
    Dump(TCnComV const & CnComV, TStr Desc=TStr())

    Parameters:
        CnComV: TCnComV const &
        Desc: TStr const &

    TCnCom_Dump(TCnComV const & CnComV)

    Parameters:
        CnComV: TCnComV const &

    """
  return _snap.TCnCom_Dump(*args)

def TCnCom_SaveTxt(*args):
  """
    SaveTxt(TCnComV const & CnComV, TStr FNm, TStr Desc=TStr())

    Parameters:
        CnComV: TCnComV const &
        FNm: TStr const &
        Desc: TStr const &

    TCnCom_SaveTxt(TCnComV const & CnComV, TStr FNm)

    Parameters:
        CnComV: TCnComV const &
        FNm: TStr const &

    """
  return _snap.TCnCom_SaveTxt(*args)

class TArtPointVisitor(object):
    """Proxy of C++ TArtPointVisitor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    VnLowH = _swig_property(_snap.TArtPointVisitor_VnLowH_get, _snap.TArtPointVisitor_VnLowH_set)
    ParentH = _swig_property(_snap.TArtPointVisitor_ParentH_get, _snap.TArtPointVisitor_ParentH_set)
    ArtSet = _swig_property(_snap.TArtPointVisitor_ArtSet_get, _snap.TArtPointVisitor_ArtSet_set)
    Time = _swig_property(_snap.TArtPointVisitor_Time_get, _snap.TArtPointVisitor_Time_set)
    def __init__(self, *args): 
        """
        __init__(TArtPointVisitor self) -> TArtPointVisitor
        __init__(TArtPointVisitor self, int const & Nodes) -> TArtPointVisitor

        Parameters:
            Nodes: int const &

        """
        _snap.TArtPointVisitor_swiginit(self,_snap.new_TArtPointVisitor(*args))
    def DiscoverNode(self, *args):
        """
        DiscoverNode(TArtPointVisitor self, int NId)

        Parameters:
            NId: int

        """
        return _snap.TArtPointVisitor_DiscoverNode(self, *args)

    def FinishNode(self, *args):
        """
        FinishNode(TArtPointVisitor self, int const & NId)

        Parameters:
            NId: int const &

        """
        return _snap.TArtPointVisitor_FinishNode(self, *args)

    def ExamineEdge(self, *args):
        """
        ExamineEdge(TArtPointVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TArtPointVisitor_ExamineEdge(self, *args)

    def TreeEdge(self, *args):
        """
        TreeEdge(TArtPointVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TArtPointVisitor_TreeEdge(self, *args)

    def BackEdge(self, *args):
        """
        BackEdge(TArtPointVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TArtPointVisitor_BackEdge(self, *args)

    def FwdEdge(self, *args):
        """
        FwdEdge(TArtPointVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TArtPointVisitor_FwdEdge(self, *args)

    __swig_destroy__ = _snap.delete_TArtPointVisitor
TArtPointVisitor.DiscoverNode = new_instancemethod(_snap.TArtPointVisitor_DiscoverNode,None,TArtPointVisitor)
TArtPointVisitor.FinishNode = new_instancemethod(_snap.TArtPointVisitor_FinishNode,None,TArtPointVisitor)
TArtPointVisitor.ExamineEdge = new_instancemethod(_snap.TArtPointVisitor_ExamineEdge,None,TArtPointVisitor)
TArtPointVisitor.TreeEdge = new_instancemethod(_snap.TArtPointVisitor_TreeEdge,None,TArtPointVisitor)
TArtPointVisitor.BackEdge = new_instancemethod(_snap.TArtPointVisitor_BackEdge,None,TArtPointVisitor)
TArtPointVisitor.FwdEdge = new_instancemethod(_snap.TArtPointVisitor_FwdEdge,None,TArtPointVisitor)
TArtPointVisitor_swigregister = _snap.TArtPointVisitor_swigregister
TArtPointVisitor_swigregister(TArtPointVisitor)

class TBiConVisitor(object):
    """Proxy of C++ TBiConVisitor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    VnLowH = _swig_property(_snap.TBiConVisitor_VnLowH_get, _snap.TBiConVisitor_VnLowH_set)
    ParentH = _swig_property(_snap.TBiConVisitor_ParentH_get, _snap.TBiConVisitor_ParentH_set)
    Stack = _swig_property(_snap.TBiConVisitor_Stack_get, _snap.TBiConVisitor_Stack_set)
    CnComV = _swig_property(_snap.TBiConVisitor_CnComV_get, _snap.TBiConVisitor_CnComV_set)
    NSet = _swig_property(_snap.TBiConVisitor_NSet_get, _snap.TBiConVisitor_NSet_set)
    Time = _swig_property(_snap.TBiConVisitor_Time_get, _snap.TBiConVisitor_Time_set)
    def __init__(self, *args): 
        """
        __init__(TBiConVisitor self) -> TBiConVisitor
        __init__(TBiConVisitor self, int const & Nodes) -> TBiConVisitor

        Parameters:
            Nodes: int const &

        """
        _snap.TBiConVisitor_swiginit(self,_snap.new_TBiConVisitor(*args))
    def DiscoverNode(self, *args):
        """
        DiscoverNode(TBiConVisitor self, int NId)

        Parameters:
            NId: int

        """
        return _snap.TBiConVisitor_DiscoverNode(self, *args)

    def FinishNode(self, *args):
        """
        FinishNode(TBiConVisitor self, int const & NId)

        Parameters:
            NId: int const &

        """
        return _snap.TBiConVisitor_FinishNode(self, *args)

    def ExamineEdge(self, *args):
        """
        ExamineEdge(TBiConVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TBiConVisitor_ExamineEdge(self, *args)

    def TreeEdge(self, *args):
        """
        TreeEdge(TBiConVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TBiConVisitor_TreeEdge(self, *args)

    def BackEdge(self, *args):
        """
        BackEdge(TBiConVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TBiConVisitor_BackEdge(self, *args)

    def FwdEdge(self, *args):
        """
        FwdEdge(TBiConVisitor self, int const & NId1, int const & NId2)

        Parameters:
            NId1: int const &
            NId2: int const &

        """
        return _snap.TBiConVisitor_FwdEdge(self, *args)

    __swig_destroy__ = _snap.delete_TBiConVisitor
TBiConVisitor.DiscoverNode = new_instancemethod(_snap.TBiConVisitor_DiscoverNode,None,TBiConVisitor)
TBiConVisitor.FinishNode = new_instancemethod(_snap.TBiConVisitor_FinishNode,None,TBiConVisitor)
TBiConVisitor.ExamineEdge = new_instancemethod(_snap.TBiConVisitor_ExamineEdge,None,TBiConVisitor)
TBiConVisitor.TreeEdge = new_instancemethod(_snap.TBiConVisitor_TreeEdge,None,TBiConVisitor)
TBiConVisitor.BackEdge = new_instancemethod(_snap.TBiConVisitor_BackEdge,None,TBiConVisitor)
TBiConVisitor.FwdEdge = new_instancemethod(_snap.TBiConVisitor_FwdEdge,None,TBiConVisitor)
TBiConVisitor_swigregister = _snap.TBiConVisitor_swigregister
TBiConVisitor_swigregister(TBiConVisitor)

class TForestFire(object):
    """Proxy of C++ TForestFire class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TForestFire self) -> TForestFire
        __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb, 
            double const & DecayProb=1.0, int const & RndSeed=1) -> TForestFire

        Parameters:
            GraphPt: PNGraph const &
            ForwBurnProb: double const &
            BackBurnProb: double const &
            DecayProb: double const &
            RndSeed: int const &

        __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb, 
            double const & DecayProb=1.0) -> TForestFire

        Parameters:
            GraphPt: PNGraph const &
            ForwBurnProb: double const &
            BackBurnProb: double const &
            DecayProb: double const &

        __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb) -> TForestFire

        Parameters:
            GraphPt: PNGraph const &
            ForwBurnProb: double const &
            BackBurnProb: double const &

        """
        _snap.TForestFire_swiginit(self,_snap.new_TForestFire(*args))
    def SetGraph(self, *args):
        """
        SetGraph(TForestFire self, PNGraph const & GraphPt)

        Parameters:
            GraphPt: PNGraph const &

        """
        return _snap.TForestFire_SetGraph(self, *args)

    def GetGraph(self):
        """
        GetGraph(TForestFire self) -> PNGraph

        Parameters:
            self: TForestFire const *

        """
        return _snap.TForestFire_GetGraph(self)

    def SetBurnProb(self, *args):
        """
        SetBurnProb(TForestFire self, double const & ForwBurnProb, double const & BackBurnProb)

        Parameters:
            ForwBurnProb: double const &
            BackBurnProb: double const &

        """
        return _snap.TForestFire_SetBurnProb(self, *args)

    def SetProbDecay(self, *args):
        """
        SetProbDecay(TForestFire self, double const & DecayProb)

        Parameters:
            DecayProb: double const &

        """
        return _snap.TForestFire_SetProbDecay(self, *args)

    def Infect(self, *args):
        """
        Infect(TForestFire self, int const & NodeId)

        Parameters:
            NodeId: int const &

        Infect(TForestFire self, TIntV InfectedNIdV)

        Parameters:
            InfectedNIdV: TIntV const &

        """
        return _snap.TForestFire_Infect(self, *args)

    def InfectAll(self):
        """
        InfectAll(TForestFire self)

        Parameters:
            self: TForestFire *

        """
        return _snap.TForestFire_InfectAll(self)

    def InfectRnd(self, *args):
        """
        InfectRnd(TForestFire self, int const & NInfect)

        Parameters:
            NInfect: int const &

        """
        return _snap.TForestFire_InfectRnd(self, *args)

    def BurnExpFire(self):
        """
        BurnExpFire(TForestFire self)

        Parameters:
            self: TForestFire *

        """
        return _snap.TForestFire_BurnExpFire(self)

    def BurnGeoFire(self):
        """
        BurnGeoFire(TForestFire self)

        Parameters:
            self: TForestFire *

        """
        return _snap.TForestFire_BurnGeoFire(self)

    def GetFireTm(self):
        """
        GetFireTm(TForestFire self) -> int

        Parameters:
            self: TForestFire const *

        """
        return _snap.TForestFire_GetFireTm(self)

    def GetBurned(self):
        """
        GetBurned(TForestFire self) -> int

        Parameters:
            self: TForestFire const *

        """
        return _snap.TForestFire_GetBurned(self)

    def GetBurnedNId(self, *args):
        """
        GetBurnedNId(TForestFire self, int const & NIdN) -> int

        Parameters:
            NIdN: int const &

        """
        return _snap.TForestFire_GetBurnedNId(self, *args)

    def GetBurnedNIdV(self, *args):
        """
        GetBurnedNIdV(TForestFire self) -> TIntV
        GetBurnedNIdV(TForestFire self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TForestFire_GetBurnedNIdV(self, *args)

    def PlotFire(self, *args):
        """
        PlotFire(TForestFire self, TStr FNmPref, TStr Desc, bool const & PlotAllBurned=False)

        Parameters:
            FNmPref: TStr const &
            Desc: TStr const &
            PlotAllBurned: bool const &

        PlotFire(TForestFire self, TStr FNmPref, TStr Desc)

        Parameters:
            FNmPref: TStr const &
            Desc: TStr const &

        """
        return _snap.TForestFire_PlotFire(self, *args)

    def GenGraph(*args):
        """
        GenGraph(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph

        Parameters:
            Nodes: int const &
            FwdProb: double const &
            BckProb: double const &

        """
        return _snap.TForestFire_GenGraph(*args)

    GenGraph = staticmethod(GenGraph)
    __swig_destroy__ = _snap.delete_TForestFire
TForestFire.SetGraph = new_instancemethod(_snap.TForestFire_SetGraph,None,TForestFire)
TForestFire.GetGraph = new_instancemethod(_snap.TForestFire_GetGraph,None,TForestFire)
TForestFire.SetBurnProb = new_instancemethod(_snap.TForestFire_SetBurnProb,None,TForestFire)
TForestFire.SetProbDecay = new_instancemethod(_snap.TForestFire_SetProbDecay,None,TForestFire)
TForestFire.Infect = new_instancemethod(_snap.TForestFire_Infect,None,TForestFire)
TForestFire.InfectAll = new_instancemethod(_snap.TForestFire_InfectAll,None,TForestFire)
TForestFire.InfectRnd = new_instancemethod(_snap.TForestFire_InfectRnd,None,TForestFire)
TForestFire.BurnExpFire = new_instancemethod(_snap.TForestFire_BurnExpFire,None,TForestFire)
TForestFire.BurnGeoFire = new_instancemethod(_snap.TForestFire_BurnGeoFire,None,TForestFire)
TForestFire.GetFireTm = new_instancemethod(_snap.TForestFire_GetFireTm,None,TForestFire)
TForestFire.GetBurned = new_instancemethod(_snap.TForestFire_GetBurned,None,TForestFire)
TForestFire.GetBurnedNId = new_instancemethod(_snap.TForestFire_GetBurnedNId,None,TForestFire)
TForestFire.GetBurnedNIdV = new_instancemethod(_snap.TForestFire_GetBurnedNIdV,None,TForestFire)
TForestFire.PlotFire = new_instancemethod(_snap.TForestFire_PlotFire,None,TForestFire)
TForestFire_swigregister = _snap.TForestFire_swigregister
TForestFire_swigregister(TForestFire)

def TForestFire_GenGraph(*args):
  """
    TForestFire_GenGraph(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph

    Parameters:
        Nodes: int const &
        FwdProb: double const &
        BckProb: double const &

    """
  return _snap.TForestFire_GenGraph(*args)

class TFfGGen(object):
    """Proxy of C++ TFfGGen class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    srUndef = _snap.TFfGGen_srUndef
    srOk = _snap.TFfGGen_srOk
    srFlood = _snap.TFfGGen_srFlood
    srTimeLimit = _snap.TFfGGen_srTimeLimit
    TimeLimitSec = _swig_property(_snap.TFfGGen_TimeLimitSec_get, _snap.TFfGGen_TimeLimitSec_set)
    def __init__(self, *args): 
        """
        __init__(TFfGGen self, bool const & BurnExpFireP, int const & StartNNodes, double const & ForwBurnProb, 
            double const & BackBurnProb, double const & DecayProb, double const & Take2AmbasPrb, 
            double const & OrphanPrb) -> TFfGGen

        Parameters:
            BurnExpFireP: bool const &
            StartNNodes: int const &
            ForwBurnProb: double const &
            BackBurnProb: double const &
            DecayProb: double const &
            Take2AmbasPrb: double const &
            OrphanPrb: double const &

        """
        _snap.TFfGGen_swiginit(self,_snap.new_TFfGGen(*args))
    def GetGraph(self):
        """
        GetGraph(TFfGGen self) -> PNGraph

        Parameters:
            self: TFfGGen const *

        """
        return _snap.TFfGGen_GetGraph(self)

    def SetGraph(self, *args):
        """
        SetGraph(TFfGGen self, PNGraph const & NGraph)

        Parameters:
            NGraph: PNGraph const &

        """
        return _snap.TFfGGen_SetGraph(self, *args)

    def Clr(self):
        """
        Clr(TFfGGen self)

        Parameters:
            self: TFfGGen *

        """
        return _snap.TFfGGen_Clr(self)

    def GetParamStr(self):
        """
        GetParamStr(TFfGGen self) -> TStr

        Parameters:
            self: TFfGGen const *

        """
        return _snap.TFfGGen_GetParamStr(self)

    def AddNodes(self, *args):
        """
        AddNodes(TFfGGen self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            FloodStop: bool const &

        AddNodes(TFfGGen self, int const & GraphNodes) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &

        """
        return _snap.TFfGGen_AddNodes(self, *args)

    def GenGraph(self, *args):
        """
        GenGraph(TFfGGen self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            FloodStop: bool const &

        GenGraph(TFfGGen self, int const & GraphNodes) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &

        GenGraph(TFfGGen self, int const & GraphNodes, PGStatVec & EvolStat, bool const & FloodStop=True) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            EvolStat: PGStatVec &
            FloodStop: bool const &

        GenGraph(TFfGGen self, int const & GraphNodes, PGStatVec & EvolStat) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            EvolStat: PGStatVec &

        """
        return _snap.TFfGGen_GenGraph(self, *args)

    def PlotFireSize(self, *args):
        """
        PlotFireSize(TFfGGen self, TStr FNmPref, TStr DescStr)

        Parameters:
            FNmPref: TStr const &
            DescStr: TStr const &

        """
        return _snap.TFfGGen_PlotFireSize(self, *args)

    def GenFFGraphs(*args):
        """
        GenFFGraphs(double const & FProb, double const & BProb, TStr FNm)

        Parameters:
            FProb: double const &
            BProb: double const &
            FNm: TStr const &

        """
        return _snap.TFfGGen_GenFFGraphs(*args)

    GenFFGraphs = staticmethod(GenFFGraphs)
    __swig_destroy__ = _snap.delete_TFfGGen
TFfGGen.GetGraph = new_instancemethod(_snap.TFfGGen_GetGraph,None,TFfGGen)
TFfGGen.SetGraph = new_instancemethod(_snap.TFfGGen_SetGraph,None,TFfGGen)
TFfGGen.Clr = new_instancemethod(_snap.TFfGGen_Clr,None,TFfGGen)
TFfGGen.GetParamStr = new_instancemethod(_snap.TFfGGen_GetParamStr,None,TFfGGen)
TFfGGen.AddNodes = new_instancemethod(_snap.TFfGGen_AddNodes,None,TFfGGen)
TFfGGen.GenGraph = new_instancemethod(_snap.TFfGGen_GenGraph,None,TFfGGen)
TFfGGen.PlotFireSize = new_instancemethod(_snap.TFfGGen_PlotFireSize,None,TFfGGen)
TFfGGen_swigregister = _snap.TFfGGen_swigregister
TFfGGen_swigregister(TFfGGen)
cvar = _snap.cvar

def TFfGGen_GenFFGraphs(*args):
  """
    TFfGGen_GenFFGraphs(double const & FProb, double const & BProb, TStr FNm)

    Parameters:
        FProb: double const &
        BProb: double const &
        FNm: TStr const &

    """
  return _snap.TFfGGen_GenFFGraphs(*args)

class TUndirFFire(object):
    """Proxy of C++ TUndirFFire class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, _BurnProb=0.3): 
        """
        __init__(TUndirFFire self, double const & _BurnProb=0.3) -> TUndirFFire

        Parameters:
            _BurnProb: double const &

        __init__(TUndirFFire self) -> TUndirFFire
        """
        _snap.TUndirFFire_swiginit(self,_snap.new_TUndirFFire(_BurnProb))
    def SetGraph(self, *args):
        """
        SetGraph(TUndirFFire self, PUNGraph const & GraphPt)

        Parameters:
            GraphPt: PUNGraph const &

        """
        return _snap.TUndirFFire_SetGraph(self, *args)

    def GetGraph(self):
        """
        GetGraph(TUndirFFire self) -> PUNGraph

        Parameters:
            self: TUndirFFire const *

        """
        return _snap.TUndirFFire_GetGraph(self)

    def GetNBurned(self):
        """
        GetNBurned(TUndirFFire self) -> int

        Parameters:
            self: TUndirFFire const *

        """
        return _snap.TUndirFFire_GetNBurned(self)

    def GetBurnedNId(self, *args):
        """
        GetBurnedNId(TUndirFFire self, int const & n) -> int

        Parameters:
            n: int const &

        """
        return _snap.TUndirFFire_GetBurnedNId(self, *args)

    def BurnGeoFire(self, *args):
        """
        BurnGeoFire(TUndirFFire self, int const & StartNId) -> int

        Parameters:
            StartNId: int const &

        """
        return _snap.TUndirFFire_BurnGeoFire(self, *args)

    def AddNodes(self, *args):
        """
        AddNodes(TUndirFFire self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &
            FloodStop: bool const &

        AddNodes(TUndirFFire self, int const & GraphNodes) -> TFfGGen::TStopReason

        Parameters:
            GraphNodes: int const &

        """
        return _snap.TUndirFFire_AddNodes(self, *args)

    __swig_destroy__ = _snap.delete_TUndirFFire
TUndirFFire.SetGraph = new_instancemethod(_snap.TUndirFFire_SetGraph,None,TUndirFFire)
TUndirFFire.GetGraph = new_instancemethod(_snap.TUndirFFire_GetGraph,None,TUndirFFire)
TUndirFFire.GetNBurned = new_instancemethod(_snap.TUndirFFire_GetNBurned,None,TUndirFFire)
TUndirFFire.GetBurnedNId = new_instancemethod(_snap.TUndirFFire_GetBurnedNId,None,TUndirFFire)
TUndirFFire.BurnGeoFire = new_instancemethod(_snap.TUndirFFire_BurnGeoFire,None,TUndirFFire)
TUndirFFire.AddNodes = new_instancemethod(_snap.TUndirFFire_AddNodes,None,TUndirFFire)
TUndirFFire_swigregister = _snap.TUndirFFire_swigregister
TUndirFFire_swigregister(TUndirFFire)

class TCs(object):
    """Proxy of C++ TCs class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TCs self) -> TCs
        __init__(TCs self, TCs Cs) -> TCs

        Parameters:
            Cs: TCs const &

        __init__(TCs self, int const & Int) -> TCs

        Parameters:
            Int: int const &

        """
        _snap.TCs_swiginit(self,_snap.new_TCs(*args))
    def __eq__(self, *args):
        """
        __eq__(TCs self, TCs Cs) -> bool

        Parameters:
            Cs: TCs const &

        """
        return _snap.TCs___eq__(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(TCs self, TCs Cs) -> TCs

        Parameters:
            Cs: TCs const &

        __iadd__(TCs self, char const & Ch) -> TCs

        Parameters:
            Ch: char const &

        __iadd__(TCs self, int const & Int) -> TCs

        Parameters:
            Int: int const &

        """
        return _snap.TCs___iadd__(self, *args)

    def Get(self):
        """
        Get(TCs self) -> int

        Parameters:
            self: TCs const *

        """
        return _snap.TCs_Get(self)

    def GetCsFromBf(*args):
        """
        GetCsFromBf(char * Bf, int const & BfL) -> TCs

        Parameters:
            Bf: char *
            BfL: int const &

        """
        return _snap.TCs_GetCsFromBf(*args)

    GetCsFromBf = staticmethod(GetCsFromBf)
    __swig_destroy__ = _snap.delete_TCs
TCs.__eq__ = new_instancemethod(_snap.TCs___eq__,None,TCs)
TCs.__iadd__ = new_instancemethod(_snap.TCs___iadd__,None,TCs)
TCs.Get = new_instancemethod(_snap.TCs_Get,None,TCs)
TCs_swigregister = _snap.TCs_swigregister
TCs_swigregister(TCs)

def TCs_GetCsFromBf(*args):
  """
    TCs_GetCsFromBf(char * Bf, int const & BfL) -> TCs

    Parameters:
        Bf: char *
        BfL: int const &

    """
  return _snap.TCs_GetCsFromBf(*args)

class TSOutMnp(object):
    """Proxy of C++ TSOutMnp class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def __call__(self, *args):
        """
        __call__(TSOutMnp self, TSOut SOut) -> TSOut

        Parameters:
            SOut: TSOut &

        """
        return _snap.TSOutMnp___call__(self, *args)

    __swig_destroy__ = _snap.delete_TSOutMnp
TSOutMnp.__call__ = new_instancemethod(_snap.TSOutMnp___call__,None,TSOutMnp)
TSOutMnp_swigregister = _snap.TSOutMnp_swigregister
TSOutMnp_swigregister(TSOutMnp)

class TSBase(object):
    """Proxy of C++ TSBase class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TSBase self, TSStr Nm) -> TSBase

        Parameters:
            Nm: TSStr const &

        """
        _snap.TSBase_swiginit(self,_snap.new_TSBase(*args))
    __swig_destroy__ = _snap.delete_TSBase
    def GetSNm(self):
        """
        GetSNm(TSBase self) -> TStr

        Parameters:
            self: TSBase const *

        """
        return _snap.TSBase_GetSNm(self)

TSBase.GetSNm = new_instancemethod(_snap.TSBase_GetSNm,None,TSBase)
TSBase_swigregister = _snap.TSBase_swigregister
TSBase_swigregister(TSBase)

class TSIn(TSBase):
    """Proxy of C++ TSIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TSIn
    def Eof(self):
        """
        Eof(TSIn self) -> bool

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_Eof(self)

    def Len(self):
        """
        Len(TSIn self) -> int

        Parameters:
            self: TSIn const *

        """
        return _snap.TSIn_Len(self)

    def GetCh(self):
        """
        GetCh(TSIn self) -> char

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_GetCh(self)

    def PeekCh(self):
        """
        PeekCh(TSIn self) -> char

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_PeekCh(self)

    def GetBf(self, *args):
        """
        GetBf(TSIn self, void const * Bf, TSize const & BfL) -> int

        Parameters:
            Bf: void const *
            BfL: TSize const &

        """
        return _snap.TSIn_GetBf(self, *args)

    def GetNextLnBf(self, *args):
        """
        GetNextLnBf(TSIn self, TChA LnChA) -> bool

        Parameters:
            LnChA: TChA &

        """
        return _snap.TSIn_GetNextLnBf(self, *args)

    def Reset(self):
        """
        Reset(TSIn self)

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_Reset(self)

    def IsFastMode(self):
        """
        IsFastMode(TSIn self) -> bool

        Parameters:
            self: TSIn const *

        """
        return _snap.TSIn_IsFastMode(self)

    def SetFastMode(self, *args):
        """
        SetFastMode(TSIn self, bool const & _FastMode)

        Parameters:
            _FastMode: bool const &

        """
        return _snap.TSIn_SetFastMode(self, *args)

    def LoadCs(self):
        """
        LoadCs(TSIn self)

        Parameters:
            self: TSIn *

        """
        return _snap.TSIn_LoadCs(self)

    def LoadBf(self, *args):
        """
        LoadBf(TSIn self, void const * Bf, TSize const & BfL)

        Parameters:
            Bf: void const *
            BfL: TSize const &

        """
        return _snap.TSIn_LoadBf(self, *args)

    def LoadNewBf(self, *args):
        """
        LoadNewBf(TSIn self, int const & BfL) -> void *

        Parameters:
            BfL: int const &

        """
        return _snap.TSIn_LoadNewBf(self, *args)

    def Load(self, *args):
        """
        Load(TSIn self, bool & Bool)

        Parameters:
            Bool: bool &

        Load(TSIn self, uchar & UCh)

        Parameters:
            UCh: uchar &

        Load(TSIn self, char & Ch)

        Parameters:
            Ch: char &

        Load(TSIn self, short & Short)

        Parameters:
            Short: short &

        Load(TSIn self, ushort & UShort)

        Parameters:
            UShort: ushort &

        Load(TSIn self, int & Int)

        Parameters:
            Int: int &

        Load(TSIn self, uint & UInt)

        Parameters:
            UInt: uint &

        Load(TSIn self, int64 & Int)

        Parameters:
            Int: int64 &

        Load(TSIn self, uint64 & UInt)

        Parameters:
            UInt: uint64 &

        Load(TSIn self, double & Flt)

        Parameters:
            Flt: double &

        Load(TSIn self, sdouble & SFlt)

        Parameters:
            SFlt: sdouble &

        Load(TSIn self, ldouble & LFlt)

        Parameters:
            LFlt: ldouble &

        Load(TSIn self, char *& CStr, int const & MxCStrLen, int const & CStrLen)

        Parameters:
            CStr: char *&
            MxCStrLen: int const &
            CStrLen: int const &

        Load(TSIn self, char *& CStr)

        Parameters:
            CStr: char *&

        """
        return _snap.TSIn_Load(self, *args)

    def __rshift__(self, *args):
        """
        __rshift__(TSIn self, bool & Bool) -> TSIn

        Parameters:
            Bool: bool &

        __rshift__(TSIn self, uchar & UCh) -> TSIn

        Parameters:
            UCh: uchar &

        __rshift__(TSIn self, char & Ch) -> TSIn

        Parameters:
            Ch: char &

        __rshift__(TSIn self, short & Sh) -> TSIn

        Parameters:
            Sh: short &

        __rshift__(TSIn self, ushort & USh) -> TSIn

        Parameters:
            USh: ushort &

        __rshift__(TSIn self, int & Int) -> TSIn

        Parameters:
            Int: int &

        __rshift__(TSIn self, uint & UInt) -> TSIn

        Parameters:
            UInt: uint &

        __rshift__(TSIn self, int64 & Int) -> TSIn

        Parameters:
            Int: int64 &

        __rshift__(TSIn self, uint64 & UInt) -> TSIn

        Parameters:
            UInt: uint64 &

        __rshift__(TSIn self, float & Flt) -> TSIn

        Parameters:
            Flt: float &

        __rshift__(TSIn self, double & Double) -> TSIn

        Parameters:
            Double: double &

        __rshift__(TSIn self, long double & LDouble) -> TSIn

        Parameters:
            LDouble: long double &

        """
        return _snap.TSIn___rshift__(self, *args)

    def GetNextLn(self, *args):
        """
        GetNextLn(TSIn self, TStr LnStr) -> bool

        Parameters:
            LnStr: TStr &

        GetNextLn(TSIn self, TChA LnChA) -> bool

        Parameters:
            LnChA: TChA &

        """
        return _snap.TSIn_GetNextLn(self, *args)

TSIn.Eof = new_instancemethod(_snap.TSIn_Eof,None,TSIn)
TSIn.Len = new_instancemethod(_snap.TSIn_Len,None,TSIn)
TSIn.GetCh = new_instancemethod(_snap.TSIn_GetCh,None,TSIn)
TSIn.PeekCh = new_instancemethod(_snap.TSIn_PeekCh,None,TSIn)
TSIn.GetBf = new_instancemethod(_snap.TSIn_GetBf,None,TSIn)
TSIn.GetNextLnBf = new_instancemethod(_snap.TSIn_GetNextLnBf,None,TSIn)
TSIn.Reset = new_instancemethod(_snap.TSIn_Reset,None,TSIn)
TSIn.IsFastMode = new_instancemethod(_snap.TSIn_IsFastMode,None,TSIn)
TSIn.SetFastMode = new_instancemethod(_snap.TSIn_SetFastMode,None,TSIn)
TSIn.LoadCs = new_instancemethod(_snap.TSIn_LoadCs,None,TSIn)
TSIn.LoadBf = new_instancemethod(_snap.TSIn_LoadBf,None,TSIn)
TSIn.LoadNewBf = new_instancemethod(_snap.TSIn_LoadNewBf,None,TSIn)
TSIn.Load = new_instancemethod(_snap.TSIn_Load,None,TSIn)
TSIn.__rshift__ = new_instancemethod(_snap.TSIn___rshift__,None,TSIn)
TSIn.GetNextLn = new_instancemethod(_snap.TSIn_GetNextLn,None,TSIn)
TSIn_swigregister = _snap.TSIn_swigregister
TSIn_swigregister(TSIn)
TSIn.StdIn = _snap.cvar.TSIn_StdIn

class TSOut(TSBase):
    """Proxy of C++ TSOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TSOut
    def EnableLnTrunc(self, *args):
        """
        EnableLnTrunc(TSOut self, int const & _MxLnLen)

        Parameters:
            _MxLnLen: int const &

        """
        return _snap.TSOut_EnableLnTrunc(self, *args)

    def DisableLnTrunc(self):
        """
        DisableLnTrunc(TSOut self)

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_DisableLnTrunc(self)

    def PutBf(self, *args):
        """
        PutBf(TSOut self, void const * LBf, TSize const & LBfL) -> int

        Parameters:
            LBf: void const *
            LBfL: TSize const &

        """
        return _snap.TSOut_PutBf(self, *args)

    def Flush(self):
        """
        Flush(TSOut self)

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_Flush(self)

    def GetFileId(self):
        """
        GetFileId(TSOut self) -> TFileId

        Parameters:
            self: TSOut const *

        """
        return _snap.TSOut_GetFileId(self)

    def PutMem(self, *args):
        """
        PutMem(TSOut self, TMem Mem) -> int

        Parameters:
            Mem: TMem const &

        """
        return _snap.TSOut_PutMem(self, *args)

    def PutCh(self, *args):
        """
        PutCh(TSOut self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        PutCh(TSOut self, char const & Ch, int const & Chs) -> int

        Parameters:
            Ch: char const &
            Chs: int const &

        """
        return _snap.TSOut_PutCh(self, *args)

    def PutBool(self, *args):
        """
        PutBool(TSOut self, bool const & Bool) -> int

        Parameters:
            Bool: bool const &

        """
        return _snap.TSOut_PutBool(self, *args)

    def PutInt(self, *args):
        """
        PutInt(TSOut self, int const & Int) -> int

        Parameters:
            Int: int const &

        PutInt(TSOut self, int const & Int, char const * FmtStr) -> int

        Parameters:
            Int: int const &
            FmtStr: char const *

        """
        return _snap.TSOut_PutInt(self, *args)

    def PutUInt(self, *args):
        """
        PutUInt(TSOut self, uint const & Int) -> int

        Parameters:
            Int: uint const &

        PutUInt(TSOut self, uint const & Int, char const * FmtStr) -> int

        Parameters:
            Int: uint const &
            FmtStr: char const *

        """
        return _snap.TSOut_PutUInt(self, *args)

    def PutFlt(self, *args):
        """
        PutFlt(TSOut self, double const & Flt) -> int

        Parameters:
            Flt: double const &

        PutFlt(TSOut self, double const & Flt, char const * FmtStr) -> int

        Parameters:
            Flt: double const &
            FmtStr: char const *

        """
        return _snap.TSOut_PutFlt(self, *args)

    def PutStr(self, *args):
        """
        PutStr(TSOut self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        PutStr(TSOut self, TChA ChA) -> int

        Parameters:
            ChA: TChA const &

        PutStr(TSOut self, TStr Str, char const * FmtStr) -> int

        Parameters:
            Str: TStr const &
            FmtStr: char const *

        PutStr(TSOut self, TStr Str, bool const & ForceInLn=False) -> int

        Parameters:
            Str: TStr const &
            ForceInLn: bool const &

        PutStr(TSOut self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TSOut_PutStr(self, *args)

    def PutStrLn(self, *args):
        """
        PutStrLn(TSOut self, TStr Str, bool const & ForceInLn=False) -> int

        Parameters:
            Str: TStr const &
            ForceInLn: bool const &

        PutStrLn(TSOut self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TSOut_PutStrLn(self, *args)

    def PutStrFmt(self, *args):
        """
        PutStrFmt(TSOut self, char const * FmtStr) -> int

        Parameters:
            FmtStr: char const *

        """
        return _snap.TSOut_PutStrFmt(self, *args)

    def PutStrFmtLn(self, *args):
        """
        PutStrFmtLn(TSOut self, char const * FmtStr) -> int

        Parameters:
            FmtStr: char const *

        """
        return _snap.TSOut_PutStrFmtLn(self, *args)

    def PutIndent(self, IndentLev=1):
        """
        PutIndent(TSOut self, int const & IndentLev=1) -> int

        Parameters:
            IndentLev: int const &

        PutIndent(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutIndent(self, IndentLev)

    def PutLn(self, Lns=1):
        """
        PutLn(TSOut self, int const & Lns=1) -> int

        Parameters:
            Lns: int const &

        PutLn(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutLn(self, Lns)

    def PutDosLn(self, Lns=1):
        """
        PutDosLn(TSOut self, int const & Lns=1) -> int

        Parameters:
            Lns: int const &

        PutDosLn(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutDosLn(self, Lns)

    def PutSep(self, NextStrLen=0):
        """
        PutSep(TSOut self, int const & NextStrLen=0) -> int

        Parameters:
            NextStrLen: int const &

        PutSep(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutSep(self, NextStrLen)

    def PutSepLn(self, Lns=0):
        """
        PutSepLn(TSOut self, int const & Lns=0) -> int

        Parameters:
            Lns: int const &

        PutSepLn(TSOut self) -> int

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_PutSepLn(self, Lns)

    def SaveCs(self):
        """
        SaveCs(TSOut self)

        Parameters:
            self: TSOut *

        """
        return _snap.TSOut_SaveCs(self)

    def SaveBf(self, *args):
        """
        SaveBf(TSOut self, void const * Bf, TSize const & BfL)

        Parameters:
            Bf: void const *
            BfL: TSize const &

        """
        return _snap.TSOut_SaveBf(self, *args)

    def Save(self, *args):
        """
        Save(TSOut self, bool const & Bool)

        Parameters:
            Bool: bool const &

        Save(TSOut self, char const & Ch)

        Parameters:
            Ch: char const &

        Save(TSOut self, uchar const & UCh)

        Parameters:
            UCh: uchar const &

        Save(TSOut self, short const & Short)

        Parameters:
            Short: short const &

        Save(TSOut self, ushort const & UShort)

        Parameters:
            UShort: ushort const &

        Save(TSOut self, int const & Int)

        Parameters:
            Int: int const &

        Save(TSOut self, uint const & UInt)

        Parameters:
            UInt: uint const &

        Save(TSOut self, int64 const & Int)

        Parameters:
            Int: int64 const &

        Save(TSOut self, uint64 const & UInt)

        Parameters:
            UInt: uint64 const &

        Save(TSOut self, double const & Flt)

        Parameters:
            Flt: double const &

        Save(TSOut self, sdouble const & SFlt)

        Parameters:
            SFlt: sdouble const &

        Save(TSOut self, ldouble const & LFlt)

        Parameters:
            LFlt: ldouble const &

        Save(TSOut self, char const * CStr, TSize const & CStrLen)

        Parameters:
            CStr: char const *
            CStrLen: TSize const &

        Save(TSOut self, char const * CStr)

        Parameters:
            CStr: char const *

        Save(TSOut self, TSIn SIn, TSize const & BfL=-1)

        Parameters:
            SIn: TSIn &
            BfL: TSize const &

        Save(TSOut self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        Save(TSOut self, PSIn const & SIn, TSize const & BfL=-1)

        Parameters:
            SIn: PSIn const &
            BfL: TSize const &

        Save(TSOut self, PSIn const & SIn)

        Parameters:
            SIn: PSIn const &

        Save(TSOut self, void const * Bf, TSize const & BfL)

        Parameters:
            Bf: void const *
            BfL: TSize const &

        """
        return _snap.TSOut_Save(self, *args)

    def __lshift__(self, *args):
        """
        __lshift__(TSOut self, bool const & Bool) -> TSOut

        Parameters:
            Bool: bool const &

        __lshift__(TSOut self, uchar const & UCh) -> TSOut

        Parameters:
            UCh: uchar const &

        __lshift__(TSOut self, char const & Ch) -> TSOut

        Parameters:
            Ch: char const &

        __lshift__(TSOut self, short const & Sh) -> TSOut

        Parameters:
            Sh: short const &

        __lshift__(TSOut self, ushort const & USh) -> TSOut

        Parameters:
            USh: ushort const &

        __lshift__(TSOut self, int const & Int) -> TSOut

        Parameters:
            Int: int const &

        __lshift__(TSOut self, uint const & Int) -> TSOut

        Parameters:
            Int: uint const &

        __lshift__(TSOut self, int64 const & Int) -> TSOut

        Parameters:
            Int: int64 const &

        __lshift__(TSOut self, uint64 const & UInt) -> TSOut

        Parameters:
            UInt: uint64 const &

        __lshift__(TSOut self, float const & Flt) -> TSOut

        Parameters:
            Flt: float const &

        __lshift__(TSOut self, double const & Double) -> TSOut

        Parameters:
            Double: double const &

        __lshift__(TSOut self, long double const & LDouble) -> TSOut

        Parameters:
            LDouble: long double const &

        __lshift__(TSOut self, TSOutMnp Mnp) -> TSOut

        Parameters:
            Mnp: TSOutMnp const &

        __lshift__(TSOut self, TSOut &(*)(TSOut &) FuncPt) -> TSOut

        Parameters:
            FuncPt: TSOut &(*)(TSOut &)

        __lshift__(TSOut self, TSIn SIn) -> TSOut

        Parameters:
            SIn: TSIn &

        __lshift__(TSOut self, PSIn & SIn) -> TSOut

        Parameters:
            SIn: PSIn &

        """
        return _snap.TSOut___lshift__(self, *args)

TSOut.EnableLnTrunc = new_instancemethod(_snap.TSOut_EnableLnTrunc,None,TSOut)
TSOut.DisableLnTrunc = new_instancemethod(_snap.TSOut_DisableLnTrunc,None,TSOut)
TSOut.PutBf = new_instancemethod(_snap.TSOut_PutBf,None,TSOut)
TSOut.Flush = new_instancemethod(_snap.TSOut_Flush,None,TSOut)
TSOut.GetFileId = new_instancemethod(_snap.TSOut_GetFileId,None,TSOut)
TSOut.PutMem = new_instancemethod(_snap.TSOut_PutMem,None,TSOut)
TSOut.PutCh = new_instancemethod(_snap.TSOut_PutCh,None,TSOut)
TSOut.PutBool = new_instancemethod(_snap.TSOut_PutBool,None,TSOut)
TSOut.PutInt = new_instancemethod(_snap.TSOut_PutInt,None,TSOut)
TSOut.PutUInt = new_instancemethod(_snap.TSOut_PutUInt,None,TSOut)
TSOut.PutFlt = new_instancemethod(_snap.TSOut_PutFlt,None,TSOut)
TSOut.PutStr = new_instancemethod(_snap.TSOut_PutStr,None,TSOut)
TSOut.PutStrLn = new_instancemethod(_snap.TSOut_PutStrLn,None,TSOut)
TSOut.PutStrFmt = new_instancemethod(_snap.TSOut_PutStrFmt,None,TSOut)
TSOut.PutStrFmtLn = new_instancemethod(_snap.TSOut_PutStrFmtLn,None,TSOut)
TSOut.PutIndent = new_instancemethod(_snap.TSOut_PutIndent,None,TSOut)
TSOut.PutLn = new_instancemethod(_snap.TSOut_PutLn,None,TSOut)
TSOut.PutDosLn = new_instancemethod(_snap.TSOut_PutDosLn,None,TSOut)
TSOut.PutSep = new_instancemethod(_snap.TSOut_PutSep,None,TSOut)
TSOut.PutSepLn = new_instancemethod(_snap.TSOut_PutSepLn,None,TSOut)
TSOut.SaveCs = new_instancemethod(_snap.TSOut_SaveCs,None,TSOut)
TSOut.SaveBf = new_instancemethod(_snap.TSOut_SaveBf,None,TSOut)
TSOut.Save = new_instancemethod(_snap.TSOut_Save,None,TSOut)
TSOut.__lshift__ = new_instancemethod(_snap.TSOut___lshift__,None,TSOut)
TSOut_swigregister = _snap.TSOut_swigregister
TSOut_swigregister(TSOut)
TSOut.StdOut = _snap.cvar.TSOut_StdOut

class TSInOut(TSIn,TSOut):
    """Proxy of C++ TSInOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TSInOut
    def SetPos(self, *args):
        """
        SetPos(TSInOut self, int const & Pos)

        Parameters:
            Pos: int const &

        """
        return _snap.TSInOut_SetPos(self, *args)

    def MovePos(self, *args):
        """
        MovePos(TSInOut self, int const & DPos)

        Parameters:
            DPos: int const &

        """
        return _snap.TSInOut_MovePos(self, *args)

    def GetPos(self):
        """
        GetPos(TSInOut self) -> int

        Parameters:
            self: TSInOut const *

        """
        return _snap.TSInOut_GetPos(self)

    def GetSize(self):
        """
        GetSize(TSInOut self) -> int

        Parameters:
            self: TSInOut const *

        """
        return _snap.TSInOut_GetSize(self)

    def Clr(self):
        """
        Clr(TSInOut self)

        Parameters:
            self: TSInOut *

        """
        return _snap.TSInOut_Clr(self)

TSInOut.SetPos = new_instancemethod(_snap.TSInOut_SetPos,None,TSInOut)
TSInOut.MovePos = new_instancemethod(_snap.TSInOut_MovePos,None,TSInOut)
TSInOut.GetPos = new_instancemethod(_snap.TSInOut_GetPos,None,TSInOut)
TSInOut.GetSize = new_instancemethod(_snap.TSInOut_GetSize,None,TSInOut)
TSInOut.Clr = new_instancemethod(_snap.TSInOut_Clr,None,TSInOut)
TSInOut_swigregister = _snap.TSInOut_swigregister
TSInOut_swigregister(TSInOut)

class TStdIn(TSIn):
    """Proxy of C++ TStdIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(TStdIn self) -> TStdIn"""
        _snap.TStdIn_swiginit(self,_snap.new_TStdIn())
    def New():
        """New() -> TPt< TSIn >"""
        return _snap.TStdIn_New()

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TStdIn
TStdIn_swigregister = _snap.TStdIn_swigregister
TStdIn_swigregister(TStdIn)

def TStdIn_New():
  """TStdIn_New() -> TPt< TSIn >"""
  return _snap.TStdIn_New()

class TStdOut(TSOut):
    """Proxy of C++ TStdOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(TStdOut self) -> TStdOut"""
        _snap.TStdOut_swiginit(self,_snap.new_TStdOut())
    def New():
        """New() -> TPt< TSOut >"""
        return _snap.TStdOut_New()

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TStdOut
TStdOut_swigregister = _snap.TStdOut_swigregister
TStdOut_swigregister(TStdOut)

def TStdOut_New():
  """TStdOut_New() -> TPt< TSOut >"""
  return _snap.TStdOut_New()

class TFIn(TSIn):
    """Proxy of C++ TFIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TFIn self, TStr FNm) -> TFIn

        Parameters:
            FNm: TStr const &

        __init__(TFIn self, TStr FNm, bool & OpenedP) -> TFIn

        Parameters:
            FNm: TStr const &
            OpenedP: bool &

        """
        _snap.TFIn_swiginit(self,_snap.new_TFIn(*args))
    def New(*args):
        """
        New(TStr FNm) -> PSIn

        Parameters:
            FNm: TStr const &

        New(TStr FNm, bool & OpenedP) -> PSIn

        Parameters:
            FNm: TStr const &
            OpenedP: bool &

        """
        return _snap.TFIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TFIn
TFIn_swigregister = _snap.TFIn_swigregister
TFIn_swigregister(TFIn)

def TFIn_New(*args):
  """
    New(TStr FNm) -> PSIn

    Parameters:
        FNm: TStr const &

    TFIn_New(TStr FNm, bool & OpenedP) -> PSIn

    Parameters:
        FNm: TStr const &
        OpenedP: bool &

    """
  return _snap.TFIn_New(*args)

class TFOut(TSOut):
    """Proxy of C++ TFOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TFOut self, TStr _FNm, bool const & Append=False) -> TFOut

        Parameters:
            _FNm: TStr const &
            Append: bool const &

        __init__(TFOut self, TStr _FNm) -> TFOut

        Parameters:
            _FNm: TStr const &

        __init__(TFOut self, TStr _FNm, bool const & Append, bool & OpenedP) -> TFOut

        Parameters:
            _FNm: TStr const &
            Append: bool const &
            OpenedP: bool &

        """
        _snap.TFOut_swiginit(self,_snap.new_TFOut(*args))
    def New(*args):
        """
        New(TStr FNm, bool const & Append=False) -> PSOut

        Parameters:
            FNm: TStr const &
            Append: bool const &

        New(TStr FNm) -> PSOut

        Parameters:
            FNm: TStr const &

        New(TStr FNm, bool const & Append, bool & OpenedP) -> PSOut

        Parameters:
            FNm: TStr const &
            Append: bool const &
            OpenedP: bool &

        """
        return _snap.TFOut_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TFOut
TFOut_swigregister = _snap.TFOut_swigregister
TFOut_swigregister(TFOut)

def TFOut_New(*args):
  """
    New(TStr FNm, bool const & Append=False) -> PSOut

    Parameters:
        FNm: TStr const &
        Append: bool const &

    New(TStr FNm) -> PSOut

    Parameters:
        FNm: TStr const &

    TFOut_New(TStr FNm, bool const & Append, bool & OpenedP) -> PSOut

    Parameters:
        FNm: TStr const &
        Append: bool const &
        OpenedP: bool &

    """
  return _snap.TFOut_New(*args)

faUndef = _snap.faUndef
faCreate = _snap.faCreate
faUpdate = _snap.faUpdate
faAppend = _snap.faAppend
faRdOnly = _snap.faRdOnly
faRestore = _snap.faRestore
class TMIn(TSIn):
    """Proxy of C++ TMIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TMIn self, void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> TMIn

        Parameters:
            _Bf: void const *
            _BfL: int const &
            TakeBf: bool const &

        __init__(TMIn self, void const * _Bf, int const & _BfL) -> TMIn

        Parameters:
            _Bf: void const *
            _BfL: int const &

        __init__(TMIn self, TSIn SIn) -> TMIn

        Parameters:
            SIn: TSIn &

        __init__(TMIn self, char const * CStr) -> TMIn

        Parameters:
            CStr: char const *

        __init__(TMIn self, TStr Str) -> TMIn

        Parameters:
            Str: TStr const &

        __init__(TMIn self, TChA ChA) -> TMIn

        Parameters:
            ChA: TChA const &

        """
        _snap.TMIn_swiginit(self,_snap.new_TMIn(*args))
    def New(*args):
        """
        New(void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> PSIn

        Parameters:
            _Bf: void const *
            _BfL: int const &
            TakeBf: bool const &

        New(void const * _Bf, int const & _BfL) -> PSIn

        Parameters:
            _Bf: void const *
            _BfL: int const &

        New(char const * CStr) -> PSIn

        Parameters:
            CStr: char const *

        New(TStr Str) -> PSIn

        Parameters:
            Str: TStr const &

        New(TChA ChA) -> PSIn

        Parameters:
            ChA: TChA const &

        """
        return _snap.TMIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TMIn
    def GetBfAddr(self):
        """
        GetBfAddr(TMIn self) -> char *

        Parameters:
            self: TMIn *

        """
        return _snap.TMIn_GetBfAddr(self)

TMIn.GetBfAddr = new_instancemethod(_snap.TMIn_GetBfAddr,None,TMIn)
TMIn_swigregister = _snap.TMIn_swigregister
TMIn_swigregister(TMIn)

def TMIn_New(*args):
  """
    New(void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> PSIn

    Parameters:
        _Bf: void const *
        _BfL: int const &
        TakeBf: bool const &

    New(void const * _Bf, int const & _BfL) -> PSIn

    Parameters:
        _Bf: void const *
        _BfL: int const &

    New(char const * CStr) -> PSIn

    Parameters:
        CStr: char const *

    New(TStr Str) -> PSIn

    Parameters:
        Str: TStr const &

    TMIn_New(TChA ChA) -> PSIn

    Parameters:
        ChA: TChA const &

    """
  return _snap.TMIn_New(*args)

class TMOut(TSOut):
    """Proxy of C++ TMOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def New(MxBfL=1024):
        """
        New(int const & MxBfL=1024) -> PSOut

        Parameters:
            MxBfL: int const &

        New() -> PSOut
        """
        return _snap.TMOut_New(MxBfL)

    New = staticmethod(New)
    def __init__(self, *args): 
        """
        __init__(TMOut self, int const & _MxBfL=1024) -> TMOut

        Parameters:
            _MxBfL: int const &

        __init__(TMOut self) -> TMOut
        __init__(TMOut self, char * _Bf, int const & _MxBfL) -> TMOut

        Parameters:
            _Bf: char *
            _MxBfL: int const &

        """
        _snap.TMOut_swiginit(self,_snap.new_TMOut(*args))
    __swig_destroy__ = _snap.delete_TMOut
    def AppendBf(self, *args):
        """
        AppendBf(TMOut self, void const * LBf, TSize const & LBfL)

        Parameters:
            LBf: void const *
            LBfL: TSize const &

        """
        return _snap.TMOut_AppendBf(self, *args)

    def Len(self):
        """
        Len(TMOut self) -> int

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_Len(self)

    def Clr(self):
        """
        Clr(TMOut self)

        Parameters:
            self: TMOut *

        """
        return _snap.TMOut_Clr(self)

    def GetCh(self, *args):
        """
        GetCh(TMOut self, int const & ChN) -> char

        Parameters:
            ChN: int const &

        """
        return _snap.TMOut_GetCh(self, *args)

    def GetAsStr(self):
        """
        GetAsStr(TMOut self) -> TStr

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_GetAsStr(self)

    def CutBf(self, *args):
        """
        CutBf(TMOut self, int const & CutBfL)

        Parameters:
            CutBfL: int const &

        """
        return _snap.TMOut_CutBf(self, *args)

    def GetSIn(self, *args):
        """
        GetSIn(TMOut self, bool const & IsCut=True, int const & CutBfL=-1) -> PSIn

        Parameters:
            IsCut: bool const &
            CutBfL: int const &

        GetSIn(TMOut self, bool const & IsCut=True) -> PSIn

        Parameters:
            IsCut: bool const &

        GetSIn(TMOut self) -> PSIn

        Parameters:
            self: TMOut *

        """
        return _snap.TMOut_GetSIn(self, *args)

    def GetBfAddr(self):
        """
        GetBfAddr(TMOut self) -> char *

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_GetBfAddr(self)

    def IsCrLfLn(self):
        """
        IsCrLfLn(TMOut self) -> bool

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_IsCrLfLn(self)

    def GetCrLfLn(self):
        """
        GetCrLfLn(TMOut self) -> TStr

        Parameters:
            self: TMOut *

        """
        return _snap.TMOut_GetCrLfLn(self)

    def IsEolnLn(self):
        """
        IsEolnLn(TMOut self) -> bool

        Parameters:
            self: TMOut const *

        """
        return _snap.TMOut_IsEolnLn(self)

    def GetEolnLn(self, *args):
        """
        GetEolnLn(TMOut self, bool const & DoAddEoln, bool const & DoCutBf) -> TStr

        Parameters:
            DoAddEoln: bool const &
            DoCutBf: bool const &

        """
        return _snap.TMOut_GetEolnLn(self, *args)

    def MkEolnLn(self):
        """
        MkEolnLn(TMOut self)

        Parameters:
            self: TMOut *

        """
        return _snap.TMOut_MkEolnLn(self)

TMOut.AppendBf = new_instancemethod(_snap.TMOut_AppendBf,None,TMOut)
TMOut.Len = new_instancemethod(_snap.TMOut_Len,None,TMOut)
TMOut.Clr = new_instancemethod(_snap.TMOut_Clr,None,TMOut)
TMOut.GetCh = new_instancemethod(_snap.TMOut_GetCh,None,TMOut)
TMOut.GetAsStr = new_instancemethod(_snap.TMOut_GetAsStr,None,TMOut)
TMOut.CutBf = new_instancemethod(_snap.TMOut_CutBf,None,TMOut)
TMOut.GetSIn = new_instancemethod(_snap.TMOut_GetSIn,None,TMOut)
TMOut.GetBfAddr = new_instancemethod(_snap.TMOut_GetBfAddr,None,TMOut)
TMOut.IsCrLfLn = new_instancemethod(_snap.TMOut_IsCrLfLn,None,TMOut)
TMOut.GetCrLfLn = new_instancemethod(_snap.TMOut_GetCrLfLn,None,TMOut)
TMOut.IsEolnLn = new_instancemethod(_snap.TMOut_IsEolnLn,None,TMOut)
TMOut.GetEolnLn = new_instancemethod(_snap.TMOut_GetEolnLn,None,TMOut)
TMOut.MkEolnLn = new_instancemethod(_snap.TMOut_MkEolnLn,None,TMOut)
TMOut_swigregister = _snap.TMOut_swigregister
TMOut_swigregister(TMOut)

def TMOut_New(MxBfL=1024):
  """
    New(int const & MxBfL=1024) -> PSOut

    Parameters:
        MxBfL: int const &

    TMOut_New() -> PSOut
    """
  return _snap.TMOut_New(MxBfL)

class TChRet(object):
    """Proxy of C++ TChRet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TChRet self, PSIn const & _SIn, char const & _EofCh=0) -> TChRet

        Parameters:
            _SIn: PSIn const &
            _EofCh: char const &

        __init__(TChRet self, PSIn const & _SIn) -> TChRet

        Parameters:
            _SIn: PSIn const &

        """
        _snap.TChRet_swiginit(self,_snap.new_TChRet(*args))
    def Eof(self):
        """
        Eof(TChRet self) -> bool

        Parameters:
            self: TChRet const *

        """
        return _snap.TChRet_Eof(self)

    def GetCh(self):
        """
        GetCh(TChRet self) -> char

        Parameters:
            self: TChRet *

        """
        return _snap.TChRet_GetCh(self)

    def __call__(self):
        """
        __call__(TChRet self) -> char

        Parameters:
            self: TChRet *

        """
        return _snap.TChRet___call__(self)

    __swig_destroy__ = _snap.delete_TChRet
TChRet.Eof = new_instancemethod(_snap.TChRet_Eof,None,TChRet)
TChRet.GetCh = new_instancemethod(_snap.TChRet_GetCh,None,TChRet)
TChRet.__call__ = new_instancemethod(_snap.TChRet___call__,None,TChRet)
TChRet_swigregister = _snap.TChRet_swigregister
TChRet_swigregister(TChRet)

class TLnRet(object):
    """Proxy of C++ TLnRet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TLnRet self, PSIn const & _SIn) -> TLnRet

        Parameters:
            _SIn: PSIn const &

        """
        _snap.TLnRet_swiginit(self,_snap.new_TLnRet(*args))
    def NextLn(self, *args):
        """
        NextLn(TLnRet self, TStr LnStr) -> bool

        Parameters:
            LnStr: TStr &

        """
        return _snap.TLnRet_NextLn(self, *args)

    __swig_destroy__ = _snap.delete_TLnRet
TLnRet.NextLn = new_instancemethod(_snap.TLnRet_NextLn,None,TLnRet)
TLnRet_swigregister = _snap.TLnRet_swigregister
TLnRet_swigregister(TLnRet)

class TFile(object):
    """Proxy of C++ TFile class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def Exists(*args):
        """
        Exists(TStr FNm) -> bool

        Parameters:
            FNm: TStr const &

        """
        return _snap.TFile_Exists(*args)

    Exists = staticmethod(Exists)
    def Del(*args):
        """
        Del(TStr FNm, bool const & ThrowExceptP=True)

        Parameters:
            FNm: TStr const &
            ThrowExceptP: bool const &

        Del(TStr FNm)

        Parameters:
            FNm: TStr const &

        """
        return _snap.TFile_Del(*args)

    Del = staticmethod(Del)
    def DelWc(*args):
        """
        DelWc(TStr WcStr, bool const & RecurseDirP=False)

        Parameters:
            WcStr: TStr const &
            RecurseDirP: bool const &

        DelWc(TStr WcStr)

        Parameters:
            WcStr: TStr const &

        """
        return _snap.TFile_DelWc(*args)

    DelWc = staticmethod(DelWc)
    def Rename(*args):
        """
        Rename(TStr SrcFNm, TStr DstFNm)

        Parameters:
            SrcFNm: TStr const &
            DstFNm: TStr const &

        """
        return _snap.TFile_Rename(*args)

    Rename = staticmethod(Rename)
    def GetUniqueFNm(*args):
        """
        GetUniqueFNm(TStr FNm) -> TStr

        Parameters:
            FNm: TStr const &

        """
        return _snap.TFile_GetUniqueFNm(*args)

    GetUniqueFNm = staticmethod(GetUniqueFNm)
    def __init__(self): 
        """__init__(TFile self) -> TFile"""
        _snap.TFile_swiginit(self,_snap.new_TFile())
    __swig_destroy__ = _snap.delete_TFile
TFile_swigregister = _snap.TFile_swigregister
TFile_swigregister(TFile)
TFile.TxtFExt = _snap.cvar.TFile_TxtFExt
TFile.HtmlFExt = _snap.cvar.TFile_HtmlFExt
TFile.HtmFExt = _snap.cvar.TFile_HtmFExt
TFile.GifFExt = _snap.cvar.TFile_GifFExt
TFile.JarFExt = _snap.cvar.TFile_JarFExt

def TFile_Exists(*args):
  """
    TFile_Exists(TStr FNm) -> bool

    Parameters:
        FNm: TStr const &

    """
  return _snap.TFile_Exists(*args)

def TFile_Del(*args):
  """
    Del(TStr FNm, bool const & ThrowExceptP=True)

    Parameters:
        FNm: TStr const &
        ThrowExceptP: bool const &

    TFile_Del(TStr FNm)

    Parameters:
        FNm: TStr const &

    """
  return _snap.TFile_Del(*args)

def TFile_DelWc(*args):
  """
    DelWc(TStr WcStr, bool const & RecurseDirP=False)

    Parameters:
        WcStr: TStr const &
        RecurseDirP: bool const &

    TFile_DelWc(TStr WcStr)

    Parameters:
        WcStr: TStr const &

    """
  return _snap.TFile_DelWc(*args)

def TFile_Rename(*args):
  """
    TFile_Rename(TStr SrcFNm, TStr DstFNm)

    Parameters:
        SrcFNm: TStr const &
        DstFNm: TStr const &

    """
  return _snap.TFile_Rename(*args)

def TFile_GetUniqueFNm(*args):
  """
    TFile_GetUniqueFNm(TStr FNm) -> TStr

    Parameters:
        FNm: TStr const &

    """
  return _snap.TFile_GetUniqueFNm(*args)

class TUNGraph(object):
    """Proxy of C++ TUNGraph class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TUNGraph self) -> TUNGraph
        __init__(TUNGraph self, int const & Nodes, int const & Edges) -> TUNGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TUNGraph self, TUNGraph Graph) -> TUNGraph

        Parameters:
            Graph: TUNGraph const &

        __init__(TUNGraph self, TSIn SIn) -> TUNGraph

        Parameters:
            SIn: TSIn &

        """
        _snap.TUNGraph_swiginit(self,_snap.new_TUNGraph(*args))
    def Save(self, *args):
        """
        Save(TUNGraph self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TUNGraph_Save(self, *args)

    def New(*args):
        """
        New() -> PUNGraph
        New(int const & Nodes, int const & Edges) -> PUNGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TUNGraph_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PUNGraph

        Parameters:
            SIn: TSIn &

        """
        return _snap.TUNGraph_Load(*args)

    Load = staticmethod(Load)
    def HasFlag(self, *args):
        """
        HasFlag(TUNGraph self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.TUNGraph_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(TUNGraph self) -> int

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TUNGraph self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TUNGraph self) -> int
        AddNode(TUNGraph self, TUNGraph::TNodeI const & NodeI) -> int

        Parameters:
            NodeI: TUNGraph::TNodeI const &

        AddNode(TUNGraph self, int const & NId, TIntV NbrNIdV) -> int

        Parameters:
            NId: int const &
            NbrNIdV: TIntV const &

        AddNode(TUNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & NIdVId) -> int

        Parameters:
            NId: int const &
            Pool: TVecPool< TInt > const &
            NIdVId: int const &

        """
        return _snap.TUNGraph_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TUNGraph self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TUNGraph self, TUNGraph::TNode const & NodeI)

        Parameters:
            NodeI: TUNGraph::TNode const &

        """
        return _snap.TUNGraph_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TUNGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraph_IsNode(self, *args)

    def BegNI(self):
        """
        BegNI(TUNGraph self) -> TUNGraph::TNodeI

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_BegNI(self)

    def EndNI(self):
        """
        EndNI(TUNGraph self) -> TUNGraph::TNodeI

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_EndNI(self)

    def GetNI(self, *args):
        """
        GetNI(TUNGraph self, int const & NId) -> TUNGraph::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraph_GetNI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TUNGraph self) -> int

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(TUNGraph self) -> int

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TUNGraph self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(TUNGraph self, TUNGraph::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TUNGraph::TEdgeI const &

        """
        return _snap.TUNGraph_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TUNGraph self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TUNGraph_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TUNGraph self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TUNGraph_IsEdge(self, *args)

    def BegEI(self):
        """
        BegEI(TUNGraph self) -> TUNGraph::TEdgeI

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_BegEI(self)

    def EndEI(self):
        """
        EndEI(TUNGraph self) -> TUNGraph::TEdgeI

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_EndEI(self)

    def GetEI(self, *args):
        """
        GetEI(TUNGraph self, int const & SrcNId, int const & DstNId) -> TUNGraph::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TUNGraph_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TUNGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TUNGraph self) -> int

        Parameters:
            self: TUNGraph *

        """
        return _snap.TUNGraph_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TUNGraph self, TRnd Rnd=Rnd) -> TUNGraph::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TUNGraph self) -> TUNGraph::TNodeI

        Parameters:
            self: TUNGraph *

        """
        return _snap.TUNGraph_GetRndNI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TUNGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TUNGraph_GetNIdV(self, *args)

    def Empty(self):
        """
        Empty(TUNGraph self) -> bool

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_Empty(self)

    def Clr(self):
        """
        Clr(TUNGraph self)

        Parameters:
            self: TUNGraph *

        """
        return _snap.TUNGraph_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TUNGraph self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TUNGraph_Reserve(self, *args)

    def ReserveNIdDeg(self, *args):
        """
        ReserveNIdDeg(TUNGraph self, int const & NId, int const & Deg)

        Parameters:
            NId: int const &
            Deg: int const &

        """
        return _snap.TUNGraph_ReserveNIdDeg(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TUNGraph self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TUNGraph self)

        Parameters:
            self: TUNGraph *

        """
        return _snap.TUNGraph_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TUNGraph self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TUNGraph self) -> bool

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TUNGraph self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TUNGraph self)

        Parameters:
            self: TUNGraph const *

        """
        return _snap.TUNGraph_Dump(self, *args)

    def GetSmallGraph():
        """GetSmallGraph() -> PUNGraph"""
        return _snap.TUNGraph_GetSmallGraph()

    GetSmallGraph = staticmethod(GetSmallGraph)
    __swig_destroy__ = _snap.delete_TUNGraph
TUNGraph.Save = new_instancemethod(_snap.TUNGraph_Save,None,TUNGraph)
TUNGraph.HasFlag = new_instancemethod(_snap.TUNGraph_HasFlag,None,TUNGraph)
TUNGraph.GetNodes = new_instancemethod(_snap.TUNGraph_GetNodes,None,TUNGraph)
TUNGraph.AddNode = new_instancemethod(_snap.TUNGraph_AddNode,None,TUNGraph)
TUNGraph.DelNode = new_instancemethod(_snap.TUNGraph_DelNode,None,TUNGraph)
TUNGraph.IsNode = new_instancemethod(_snap.TUNGraph_IsNode,None,TUNGraph)
TUNGraph.BegNI = new_instancemethod(_snap.TUNGraph_BegNI,None,TUNGraph)
TUNGraph.EndNI = new_instancemethod(_snap.TUNGraph_EndNI,None,TUNGraph)
TUNGraph.GetNI = new_instancemethod(_snap.TUNGraph_GetNI,None,TUNGraph)
TUNGraph.GetMxNId = new_instancemethod(_snap.TUNGraph_GetMxNId,None,TUNGraph)
TUNGraph.GetEdges = new_instancemethod(_snap.TUNGraph_GetEdges,None,TUNGraph)
TUNGraph.AddEdge = new_instancemethod(_snap.TUNGraph_AddEdge,None,TUNGraph)
TUNGraph.DelEdge = new_instancemethod(_snap.TUNGraph_DelEdge,None,TUNGraph)
TUNGraph.IsEdge = new_instancemethod(_snap.TUNGraph_IsEdge,None,TUNGraph)
TUNGraph.BegEI = new_instancemethod(_snap.TUNGraph_BegEI,None,TUNGraph)
TUNGraph.EndEI = new_instancemethod(_snap.TUNGraph_EndEI,None,TUNGraph)
TUNGraph.GetEI = new_instancemethod(_snap.TUNGraph_GetEI,None,TUNGraph)
TUNGraph.GetRndNId = new_instancemethod(_snap.TUNGraph_GetRndNId,None,TUNGraph)
TUNGraph.GetRndNI = new_instancemethod(_snap.TUNGraph_GetRndNI,None,TUNGraph)
TUNGraph.GetNIdV = new_instancemethod(_snap.TUNGraph_GetNIdV,None,TUNGraph)
TUNGraph.Empty = new_instancemethod(_snap.TUNGraph_Empty,None,TUNGraph)
TUNGraph.Clr = new_instancemethod(_snap.TUNGraph_Clr,None,TUNGraph)
TUNGraph.Reserve = new_instancemethod(_snap.TUNGraph_Reserve,None,TUNGraph)
TUNGraph.ReserveNIdDeg = new_instancemethod(_snap.TUNGraph_ReserveNIdDeg,None,TUNGraph)
TUNGraph.Defrag = new_instancemethod(_snap.TUNGraph_Defrag,None,TUNGraph)
TUNGraph.IsOk = new_instancemethod(_snap.TUNGraph_IsOk,None,TUNGraph)
TUNGraph.Dump = new_instancemethod(_snap.TUNGraph_Dump,None,TUNGraph)
TUNGraph_swigregister = _snap.TUNGraph_swigregister
TUNGraph_swigregister(TUNGraph)

def TUNGraph_New(*args):
  """
    New() -> PUNGraph
    TUNGraph_New(int const & Nodes, int const & Edges) -> PUNGraph

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TUNGraph_New(*args)

def TUNGraph_Load(*args):
  """
    TUNGraph_Load(TSIn SIn) -> PUNGraph

    Parameters:
        SIn: TSIn &

    """
  return _snap.TUNGraph_Load(*args)

def TUNGraph_GetSmallGraph():
  """TUNGraph_GetSmallGraph() -> PUNGraph"""
  return _snap.TUNGraph_GetSmallGraph()

class TNGraph(object):
    """Proxy of C++ TNGraph class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNGraph self) -> TNGraph
        __init__(TNGraph self, int const & Nodes, int const & Edges) -> TNGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TNGraph self, TNGraph Graph) -> TNGraph

        Parameters:
            Graph: TNGraph const &

        __init__(TNGraph self, TSIn SIn) -> TNGraph

        Parameters:
            SIn: TSIn &

        """
        _snap.TNGraph_swiginit(self,_snap.new_TNGraph(*args))
    def Save(self, *args):
        """
        Save(TNGraph self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TNGraph_Save(self, *args)

    def New(*args):
        """
        New() -> PNGraph
        New(int const & Nodes, int const & Edges) -> PNGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNGraph_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PNGraph

        Parameters:
            SIn: TSIn &

        """
        return _snap.TNGraph_Load(*args)

    Load = staticmethod(Load)
    def HasFlag(self, *args):
        """
        HasFlag(TNGraph self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.TNGraph_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(TNGraph self) -> int

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TNGraph self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TNGraph self) -> int
        AddNode(TNGraph self, TNGraph::TNodeI const & NodeId) -> int

        Parameters:
            NodeId: TNGraph::TNodeI const &

        AddNode(TNGraph self, int const & NId, TIntV InNIdV, TIntV OutNIdV) -> int

        Parameters:
            NId: int const &
            InNIdV: TIntV const &
            OutNIdV: TIntV const &

        AddNode(TNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & SrcVId, int const & DstVId) -> int

        Parameters:
            NId: int const &
            Pool: TVecPool< TInt > const &
            SrcVId: int const &
            DstVId: int const &

        """
        return _snap.TNGraph_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TNGraph self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TNGraph self, TNGraph::TNode const & NodeI)

        Parameters:
            NodeI: TNGraph::TNode const &

        """
        return _snap.TNGraph_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TNGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNGraph_IsNode(self, *args)

    def BegNI(self):
        """
        BegNI(TNGraph self) -> TNGraph::TNodeI

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_BegNI(self)

    def EndNI(self):
        """
        EndNI(TNGraph self) -> TNGraph::TNodeI

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_EndNI(self)

    def GetNI(self, *args):
        """
        GetNI(TNGraph self, int const & NId) -> TNGraph::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TNGraph_GetNI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TNGraph self) -> int

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(TNGraph self) -> int

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TNGraph self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(TNGraph self, TNGraph::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TNGraph::TEdgeI const &

        """
        return _snap.TNGraph_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TNGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        DelEdge(TNGraph self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNGraph_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TNGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        IsEdge(TNGraph self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNGraph_IsEdge(self, *args)

    def BegEI(self):
        """
        BegEI(TNGraph self) -> TNGraph::TEdgeI

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_BegEI(self)

    def EndEI(self):
        """
        EndEI(TNGraph self) -> TNGraph::TEdgeI

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_EndEI(self)

    def GetEI(self, *args):
        """
        GetEI(TNGraph self, int const & SrcNId, int const & DstNId) -> TNGraph::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNGraph_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TNGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TNGraph self) -> int

        Parameters:
            self: TNGraph *

        """
        return _snap.TNGraph_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TNGraph self, TRnd Rnd=Rnd) -> TNGraph::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TNGraph self) -> TNGraph::TNodeI

        Parameters:
            self: TNGraph *

        """
        return _snap.TNGraph_GetRndNI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TNGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TNGraph_GetNIdV(self, *args)

    def Empty(self):
        """
        Empty(TNGraph self) -> bool

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_Empty(self)

    def Clr(self):
        """
        Clr(TNGraph self)

        Parameters:
            self: TNGraph *

        """
        return _snap.TNGraph_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TNGraph self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNGraph_Reserve(self, *args)

    def ReserveNIdInDeg(self, *args):
        """
        ReserveNIdInDeg(TNGraph self, int const & NId, int const & InDeg)

        Parameters:
            NId: int const &
            InDeg: int const &

        """
        return _snap.TNGraph_ReserveNIdInDeg(self, *args)

    def ReserveNIdOutDeg(self, *args):
        """
        ReserveNIdOutDeg(TNGraph self, int const & NId, int const & OutDeg)

        Parameters:
            NId: int const &
            OutDeg: int const &

        """
        return _snap.TNGraph_ReserveNIdOutDeg(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TNGraph self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TNGraph self)

        Parameters:
            self: TNGraph *

        """
        return _snap.TNGraph_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TNGraph self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TNGraph self) -> bool

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TNGraph self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TNGraph self)

        Parameters:
            self: TNGraph const *

        """
        return _snap.TNGraph_Dump(self, *args)

    def GetSmallGraph():
        """GetSmallGraph() -> PNGraph"""
        return _snap.TNGraph_GetSmallGraph()

    GetSmallGraph = staticmethod(GetSmallGraph)
    __swig_destroy__ = _snap.delete_TNGraph
TNGraph.Save = new_instancemethod(_snap.TNGraph_Save,None,TNGraph)
TNGraph.HasFlag = new_instancemethod(_snap.TNGraph_HasFlag,None,TNGraph)
TNGraph.GetNodes = new_instancemethod(_snap.TNGraph_GetNodes,None,TNGraph)
TNGraph.AddNode = new_instancemethod(_snap.TNGraph_AddNode,None,TNGraph)
TNGraph.DelNode = new_instancemethod(_snap.TNGraph_DelNode,None,TNGraph)
TNGraph.IsNode = new_instancemethod(_snap.TNGraph_IsNode,None,TNGraph)
TNGraph.BegNI = new_instancemethod(_snap.TNGraph_BegNI,None,TNGraph)
TNGraph.EndNI = new_instancemethod(_snap.TNGraph_EndNI,None,TNGraph)
TNGraph.GetNI = new_instancemethod(_snap.TNGraph_GetNI,None,TNGraph)
TNGraph.GetMxNId = new_instancemethod(_snap.TNGraph_GetMxNId,None,TNGraph)
TNGraph.GetEdges = new_instancemethod(_snap.TNGraph_GetEdges,None,TNGraph)
TNGraph.AddEdge = new_instancemethod(_snap.TNGraph_AddEdge,None,TNGraph)
TNGraph.DelEdge = new_instancemethod(_snap.TNGraph_DelEdge,None,TNGraph)
TNGraph.IsEdge = new_instancemethod(_snap.TNGraph_IsEdge,None,TNGraph)
TNGraph.BegEI = new_instancemethod(_snap.TNGraph_BegEI,None,TNGraph)
TNGraph.EndEI = new_instancemethod(_snap.TNGraph_EndEI,None,TNGraph)
TNGraph.GetEI = new_instancemethod(_snap.TNGraph_GetEI,None,TNGraph)
TNGraph.GetRndNId = new_instancemethod(_snap.TNGraph_GetRndNId,None,TNGraph)
TNGraph.GetRndNI = new_instancemethod(_snap.TNGraph_GetRndNI,None,TNGraph)
TNGraph.GetNIdV = new_instancemethod(_snap.TNGraph_GetNIdV,None,TNGraph)
TNGraph.Empty = new_instancemethod(_snap.TNGraph_Empty,None,TNGraph)
TNGraph.Clr = new_instancemethod(_snap.TNGraph_Clr,None,TNGraph)
TNGraph.Reserve = new_instancemethod(_snap.TNGraph_Reserve,None,TNGraph)
TNGraph.ReserveNIdInDeg = new_instancemethod(_snap.TNGraph_ReserveNIdInDeg,None,TNGraph)
TNGraph.ReserveNIdOutDeg = new_instancemethod(_snap.TNGraph_ReserveNIdOutDeg,None,TNGraph)
TNGraph.Defrag = new_instancemethod(_snap.TNGraph_Defrag,None,TNGraph)
TNGraph.IsOk = new_instancemethod(_snap.TNGraph_IsOk,None,TNGraph)
TNGraph.Dump = new_instancemethod(_snap.TNGraph_Dump,None,TNGraph)
TNGraph_swigregister = _snap.TNGraph_swigregister
TNGraph_swigregister(TNGraph)

def TNGraph_New(*args):
  """
    New() -> PNGraph
    TNGraph_New(int const & Nodes, int const & Edges) -> PNGraph

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TNGraph_New(*args)

def TNGraph_Load(*args):
  """
    TNGraph_Load(TSIn SIn) -> PNGraph

    Parameters:
        SIn: TSIn &

    """
  return _snap.TNGraph_Load(*args)

def TNGraph_GetSmallGraph():
  """TNGraph_GetSmallGraph() -> PNGraph"""
  return _snap.TNGraph_GetSmallGraph()

class TNEGraph(object):
    """Proxy of C++ TNEGraph class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEGraph self) -> TNEGraph
        __init__(TNEGraph self, int const & Nodes, int const & Edges) -> TNEGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TNEGraph self, TNEGraph Graph) -> TNEGraph

        Parameters:
            Graph: TNEGraph const &

        __init__(TNEGraph self, TSIn SIn) -> TNEGraph

        Parameters:
            SIn: TSIn &

        """
        _snap.TNEGraph_swiginit(self,_snap.new_TNEGraph(*args))
    def Save(self, *args):
        """
        Save(TNEGraph self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TNEGraph_Save(self, *args)

    def New(*args):
        """
        New() -> PNEGraph
        New(int const & Nodes, int const & Edges) -> PNEGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNEGraph_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PNEGraph

        Parameters:
            SIn: TSIn &

        """
        return _snap.TNEGraph_Load(*args)

    Load = staticmethod(Load)
    def HasFlag(self, *args):
        """
        HasFlag(TNEGraph self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.TNEGraph_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(TNEGraph self) -> int

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TNEGraph self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TNEGraph self) -> int
        AddNode(TNEGraph self, TNEGraph::TNodeI const & NodeId) -> int

        Parameters:
            NodeId: TNEGraph::TNodeI const &

        """
        return _snap.TNEGraph_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TNEGraph self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TNEGraph self, TNEGraph::TNode const & NodeI)

        Parameters:
            NodeI: TNEGraph::TNode const &

        """
        return _snap.TNEGraph_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TNEGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEGraph_IsNode(self, *args)

    def BegNI(self):
        """
        BegNI(TNEGraph self) -> TNEGraph::TNodeI

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_BegNI(self)

    def EndNI(self):
        """
        EndNI(TNEGraph self) -> TNEGraph::TNodeI

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_EndNI(self)

    def GetNI(self, *args):
        """
        GetNI(TNEGraph self, int const & NId) -> TNEGraph::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TNEGraph_GetNI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TNEGraph self) -> int

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(TNEGraph self) -> int

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int EId=-1) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int

        AddEdge(TNEGraph self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(TNEGraph self, TNEGraph::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TNEGraph::TEdgeI const &

        """
        return _snap.TNEGraph_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TNEGraph self, int const & EId)

        Parameters:
            EId: int const &

        DelEdge(TNEGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        DelEdge(TNEGraph self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEGraph_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TNEGraph self, int const & EId) -> bool

        Parameters:
            EId: int const &

        IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &
            IsDir: bool const &

        IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int & EId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &

        """
        return _snap.TNEGraph_IsEdge(self, *args)

    def GetEId(self, *args):
        """
        GetEId(TNEGraph self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEGraph_GetEId(self, *args)

    def BegEI(self):
        """
        BegEI(TNEGraph self) -> TNEGraph::TEdgeI

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_BegEI(self)

    def EndEI(self):
        """
        EndEI(TNEGraph self) -> TNEGraph::TEdgeI

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_EndEI(self)

    def GetEI(self, *args):
        """
        GetEI(TNEGraph self, int const & EId) -> TNEGraph::TEdgeI

        Parameters:
            EId: int const &

        GetEI(TNEGraph self, int const & SrcNId, int const & DstNId) -> TNEGraph::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEGraph_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TNEGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TNEGraph self) -> int

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TNEGraph self, TRnd Rnd=Rnd) -> TNEGraph::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TNEGraph self) -> TNEGraph::TNodeI

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_GetRndNI(self, *args)

    def GetRndEId(self, *args):
        """
        GetRndEId(TNEGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndEId(TNEGraph self) -> int

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_GetRndEId(self, *args)

    def GetRndEI(self, *args):
        """
        GetRndEI(TNEGraph self, TRnd Rnd=Rnd) -> TNEGraph::TEdgeI

        Parameters:
            Rnd: TRnd &

        GetRndEI(TNEGraph self) -> TNEGraph::TEdgeI

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_GetRndEI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TNEGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TNEGraph_GetNIdV(self, *args)

    def GetEIdV(self, *args):
        """
        GetEIdV(TNEGraph self, TIntV EIdV)

        Parameters:
            EIdV: TIntV &

        """
        return _snap.TNEGraph_GetEIdV(self, *args)

    def Empty(self):
        """
        Empty(TNEGraph self) -> bool

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_Empty(self)

    def Clr(self):
        """
        Clr(TNEGraph self)

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TNEGraph self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNEGraph_Reserve(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TNEGraph self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TNEGraph self)

        Parameters:
            self: TNEGraph *

        """
        return _snap.TNEGraph_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TNEGraph self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TNEGraph self) -> bool

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TNEGraph self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TNEGraph self)

        Parameters:
            self: TNEGraph const *

        """
        return _snap.TNEGraph_Dump(self, *args)

    __swig_destroy__ = _snap.delete_TNEGraph
TNEGraph.Save = new_instancemethod(_snap.TNEGraph_Save,None,TNEGraph)
TNEGraph.HasFlag = new_instancemethod(_snap.TNEGraph_HasFlag,None,TNEGraph)
TNEGraph.GetNodes = new_instancemethod(_snap.TNEGraph_GetNodes,None,TNEGraph)
TNEGraph.AddNode = new_instancemethod(_snap.TNEGraph_AddNode,None,TNEGraph)
TNEGraph.DelNode = new_instancemethod(_snap.TNEGraph_DelNode,None,TNEGraph)
TNEGraph.IsNode = new_instancemethod(_snap.TNEGraph_IsNode,None,TNEGraph)
TNEGraph.BegNI = new_instancemethod(_snap.TNEGraph_BegNI,None,TNEGraph)
TNEGraph.EndNI = new_instancemethod(_snap.TNEGraph_EndNI,None,TNEGraph)
TNEGraph.GetNI = new_instancemethod(_snap.TNEGraph_GetNI,None,TNEGraph)
TNEGraph.GetMxNId = new_instancemethod(_snap.TNEGraph_GetMxNId,None,TNEGraph)
TNEGraph.GetEdges = new_instancemethod(_snap.TNEGraph_GetEdges,None,TNEGraph)
TNEGraph.AddEdge = new_instancemethod(_snap.TNEGraph_AddEdge,None,TNEGraph)
TNEGraph.DelEdge = new_instancemethod(_snap.TNEGraph_DelEdge,None,TNEGraph)
TNEGraph.IsEdge = new_instancemethod(_snap.TNEGraph_IsEdge,None,TNEGraph)
TNEGraph.GetEId = new_instancemethod(_snap.TNEGraph_GetEId,None,TNEGraph)
TNEGraph.BegEI = new_instancemethod(_snap.TNEGraph_BegEI,None,TNEGraph)
TNEGraph.EndEI = new_instancemethod(_snap.TNEGraph_EndEI,None,TNEGraph)
TNEGraph.GetEI = new_instancemethod(_snap.TNEGraph_GetEI,None,TNEGraph)
TNEGraph.GetRndNId = new_instancemethod(_snap.TNEGraph_GetRndNId,None,TNEGraph)
TNEGraph.GetRndNI = new_instancemethod(_snap.TNEGraph_GetRndNI,None,TNEGraph)
TNEGraph.GetRndEId = new_instancemethod(_snap.TNEGraph_GetRndEId,None,TNEGraph)
TNEGraph.GetRndEI = new_instancemethod(_snap.TNEGraph_GetRndEI,None,TNEGraph)
TNEGraph.GetNIdV = new_instancemethod(_snap.TNEGraph_GetNIdV,None,TNEGraph)
TNEGraph.GetEIdV = new_instancemethod(_snap.TNEGraph_GetEIdV,None,TNEGraph)
TNEGraph.Empty = new_instancemethod(_snap.TNEGraph_Empty,None,TNEGraph)
TNEGraph.Clr = new_instancemethod(_snap.TNEGraph_Clr,None,TNEGraph)
TNEGraph.Reserve = new_instancemethod(_snap.TNEGraph_Reserve,None,TNEGraph)
TNEGraph.Defrag = new_instancemethod(_snap.TNEGraph_Defrag,None,TNEGraph)
TNEGraph.IsOk = new_instancemethod(_snap.TNEGraph_IsOk,None,TNEGraph)
TNEGraph.Dump = new_instancemethod(_snap.TNEGraph_Dump,None,TNEGraph)
TNEGraph_swigregister = _snap.TNEGraph_swigregister
TNEGraph_swigregister(TNEGraph)

def TNEGraph_New(*args):
  """
    New() -> PNEGraph
    TNEGraph_New(int const & Nodes, int const & Edges) -> PNEGraph

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TNEGraph_New(*args)

def TNEGraph_Load(*args):
  """
    TNEGraph_Load(TSIn SIn) -> PNEGraph

    Parameters:
        SIn: TSIn &

    """
  return _snap.TNEGraph_Load(*args)

class TBPGraph(object):
    """Proxy of C++ TBPGraph class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    bgsUndef = _snap.TBPGraph_bgsUndef
    bgsLeft = _snap.TBPGraph_bgsLeft
    bgsRight = _snap.TBPGraph_bgsRight
    bgsBoth = _snap.TBPGraph_bgsBoth
    def __init__(self, *args): 
        """
        __init__(TBPGraph self) -> TBPGraph
        __init__(TBPGraph self, int const & Nodes, int const & Edges) -> TBPGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TBPGraph self, TBPGraph BPGraph) -> TBPGraph

        Parameters:
            BPGraph: TBPGraph const &

        __init__(TBPGraph self, TSIn SIn) -> TBPGraph

        Parameters:
            SIn: TSIn &

        """
        _snap.TBPGraph_swiginit(self,_snap.new_TBPGraph(*args))
    def Save(self, *args):
        """
        Save(TBPGraph self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TBPGraph_Save(self, *args)

    def New(*args):
        """
        New() -> PBPGraph
        New(int const & Nodes, int const & Edges) -> PBPGraph

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TBPGraph_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PBPGraph

        Parameters:
            SIn: TSIn &

        """
        return _snap.TBPGraph_Load(*args)

    Load = staticmethod(Load)
    def GetNodes(self):
        """
        GetNodes(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetNodes(self)

    def GetLNodes(self):
        """
        GetLNodes(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetLNodes(self)

    def GetRNodes(self):
        """
        GetRNodes(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetRNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TBPGraph self, int NId=-1, bool const & LeftNode=True) -> int

        Parameters:
            NId: int
            LeftNode: bool const &

        AddNode(TBPGraph self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TBPGraph self) -> int
        AddNode(TBPGraph self, TBPGraph::TNodeI const & NodeI) -> int

        Parameters:
            NodeI: TBPGraph::TNodeI const &

        """
        return _snap.TBPGraph_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TBPGraph self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TBPGraph self, TBPGraph::TNode const & NodeI)

        Parameters:
            NodeI: TBPGraph::TNode const &

        """
        return _snap.TBPGraph_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TBPGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TBPGraph_IsNode(self, *args)

    def IsLNode(self, *args):
        """
        IsLNode(TBPGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TBPGraph_IsLNode(self, *args)

    def IsRNode(self, *args):
        """
        IsRNode(TBPGraph self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TBPGraph_IsRNode(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetMxNId(self)

    def BegNI(self):
        """
        BegNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_BegNI(self)

    def EndNI(self):
        """
        EndNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_EndNI(self)

    def GetNI(self, *args):
        """
        GetNI(TBPGraph self, int const & NId) -> TBPGraph::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TBPGraph_GetNI(self, *args)

    def BegLNI(self):
        """
        BegLNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_BegLNI(self)

    def EndLNI(self):
        """
        EndLNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_EndLNI(self)

    def BegRNI(self):
        """
        BegRNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_BegRNI(self)

    def EndRNI(self):
        """
        EndRNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_EndRNI(self)

    def GetEdges(self):
        """
        GetEdges(TBPGraph self) -> int

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TBPGraph self, int const & LeftNId, int const & RightNId) -> int

        Parameters:
            LeftNId: int const &
            RightNId: int const &

        AddEdge(TBPGraph self, TBPGraph::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TBPGraph::TEdgeI const &

        """
        return _snap.TBPGraph_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TBPGraph self, int const & LeftNId, int const & RightNId)

        Parameters:
            LeftNId: int const &
            RightNId: int const &

        """
        return _snap.TBPGraph_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TBPGraph self, int const & LeftNId, int const & RightNId) -> bool

        Parameters:
            LeftNId: int const &
            RightNId: int const &

        """
        return _snap.TBPGraph_IsEdge(self, *args)

    def BegEI(self):
        """
        BegEI(TBPGraph self) -> TBPGraph::TEdgeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_BegEI(self)

    def EndEI(self):
        """
        EndEI(TBPGraph self) -> TBPGraph::TEdgeI

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_EndEI(self)

    def GetEI(self, *args):
        """
        GetEI(TBPGraph self, int const & LeftNId, int const & RightNId) -> TBPGraph::TEdgeI

        Parameters:
            LeftNId: int const &
            RightNId: int const &

        """
        return _snap.TBPGraph_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TBPGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TBPGraph self) -> int

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_GetRndNId(self, *args)

    def GetRndLNId(self, *args):
        """
        GetRndLNId(TBPGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndLNId(TBPGraph self) -> int

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_GetRndLNId(self, *args)

    def GetRndRNId(self, *args):
        """
        GetRndRNId(TBPGraph self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndRNId(TBPGraph self) -> int

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_GetRndRNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TBPGraph self, TRnd Rnd=Rnd) -> TBPGraph::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TBPGraph self) -> TBPGraph::TNodeI

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_GetRndNI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TBPGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TBPGraph_GetNIdV(self, *args)

    def GetLNIdV(self, *args):
        """
        GetLNIdV(TBPGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TBPGraph_GetLNIdV(self, *args)

    def GetRNIdV(self, *args):
        """
        GetRNIdV(TBPGraph self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TBPGraph_GetRNIdV(self, *args)

    def Empty(self):
        """
        Empty(TBPGraph self) -> bool

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_Empty(self)

    def Clr(self):
        """
        Clr(TBPGraph self)

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TBPGraph self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TBPGraph_Reserve(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TBPGraph self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TBPGraph self)

        Parameters:
            self: TBPGraph *

        """
        return _snap.TBPGraph_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TBPGraph self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TBPGraph self) -> bool

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TBPGraph self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TBPGraph self)

        Parameters:
            self: TBPGraph const *

        """
        return _snap.TBPGraph_Dump(self, *args)

    def GetSmallGraph():
        """GetSmallGraph() -> PBPGraph"""
        return _snap.TBPGraph_GetSmallGraph()

    GetSmallGraph = staticmethod(GetSmallGraph)
    __swig_destroy__ = _snap.delete_TBPGraph
TBPGraph.Save = new_instancemethod(_snap.TBPGraph_Save,None,TBPGraph)
TBPGraph.GetNodes = new_instancemethod(_snap.TBPGraph_GetNodes,None,TBPGraph)
TBPGraph.GetLNodes = new_instancemethod(_snap.TBPGraph_GetLNodes,None,TBPGraph)
TBPGraph.GetRNodes = new_instancemethod(_snap.TBPGraph_GetRNodes,None,TBPGraph)
TBPGraph.AddNode = new_instancemethod(_snap.TBPGraph_AddNode,None,TBPGraph)
TBPGraph.DelNode = new_instancemethod(_snap.TBPGraph_DelNode,None,TBPGraph)
TBPGraph.IsNode = new_instancemethod(_snap.TBPGraph_IsNode,None,TBPGraph)
TBPGraph.IsLNode = new_instancemethod(_snap.TBPGraph_IsLNode,None,TBPGraph)
TBPGraph.IsRNode = new_instancemethod(_snap.TBPGraph_IsRNode,None,TBPGraph)
TBPGraph.GetMxNId = new_instancemethod(_snap.TBPGraph_GetMxNId,None,TBPGraph)
TBPGraph.BegNI = new_instancemethod(_snap.TBPGraph_BegNI,None,TBPGraph)
TBPGraph.EndNI = new_instancemethod(_snap.TBPGraph_EndNI,None,TBPGraph)
TBPGraph.GetNI = new_instancemethod(_snap.TBPGraph_GetNI,None,TBPGraph)
TBPGraph.BegLNI = new_instancemethod(_snap.TBPGraph_BegLNI,None,TBPGraph)
TBPGraph.EndLNI = new_instancemethod(_snap.TBPGraph_EndLNI,None,TBPGraph)
TBPGraph.BegRNI = new_instancemethod(_snap.TBPGraph_BegRNI,None,TBPGraph)
TBPGraph.EndRNI = new_instancemethod(_snap.TBPGraph_EndRNI,None,TBPGraph)
TBPGraph.GetEdges = new_instancemethod(_snap.TBPGraph_GetEdges,None,TBPGraph)
TBPGraph.AddEdge = new_instancemethod(_snap.TBPGraph_AddEdge,None,TBPGraph)
TBPGraph.DelEdge = new_instancemethod(_snap.TBPGraph_DelEdge,None,TBPGraph)
TBPGraph.IsEdge = new_instancemethod(_snap.TBPGraph_IsEdge,None,TBPGraph)
TBPGraph.BegEI = new_instancemethod(_snap.TBPGraph_BegEI,None,TBPGraph)
TBPGraph.EndEI = new_instancemethod(_snap.TBPGraph_EndEI,None,TBPGraph)
TBPGraph.GetEI = new_instancemethod(_snap.TBPGraph_GetEI,None,TBPGraph)
TBPGraph.GetRndNId = new_instancemethod(_snap.TBPGraph_GetRndNId,None,TBPGraph)
TBPGraph.GetRndLNId = new_instancemethod(_snap.TBPGraph_GetRndLNId,None,TBPGraph)
TBPGraph.GetRndRNId = new_instancemethod(_snap.TBPGraph_GetRndRNId,None,TBPGraph)
TBPGraph.GetRndNI = new_instancemethod(_snap.TBPGraph_GetRndNI,None,TBPGraph)
TBPGraph.GetNIdV = new_instancemethod(_snap.TBPGraph_GetNIdV,None,TBPGraph)
TBPGraph.GetLNIdV = new_instancemethod(_snap.TBPGraph_GetLNIdV,None,TBPGraph)
TBPGraph.GetRNIdV = new_instancemethod(_snap.TBPGraph_GetRNIdV,None,TBPGraph)
TBPGraph.Empty = new_instancemethod(_snap.TBPGraph_Empty,None,TBPGraph)
TBPGraph.Clr = new_instancemethod(_snap.TBPGraph_Clr,None,TBPGraph)
TBPGraph.Reserve = new_instancemethod(_snap.TBPGraph_Reserve,None,TBPGraph)
TBPGraph.Defrag = new_instancemethod(_snap.TBPGraph_Defrag,None,TBPGraph)
TBPGraph.IsOk = new_instancemethod(_snap.TBPGraph_IsOk,None,TBPGraph)
TBPGraph.Dump = new_instancemethod(_snap.TBPGraph_Dump,None,TBPGraph)
TBPGraph_swigregister = _snap.TBPGraph_swigregister
TBPGraph_swigregister(TBPGraph)

def TBPGraph_New(*args):
  """
    New() -> PBPGraph
    TBPGraph_New(int const & Nodes, int const & Edges) -> PBPGraph

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TBPGraph_New(*args)

def TBPGraph_Load(*args):
  """
    TBPGraph_Load(TSIn SIn) -> PBPGraph

    Parameters:
        SIn: TSIn &

    """
  return _snap.TBPGraph_Load(*args)

def TBPGraph_GetSmallGraph():
  """TBPGraph_GetSmallGraph() -> PBPGraph"""
  return _snap.TBPGraph_GetSmallGraph()

class TNGraphMtx(object):
    """Proxy of C++ TNGraphMtx class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNGraphMtx self, PNGraph const & GraphPt) -> TNGraphMtx

        Parameters:
            GraphPt: PNGraph const &

        __init__(TNGraphMtx self, TNGraphMtx GraphMtx) -> TNGraphMtx

        Parameters:
            GraphMtx: TNGraphMtx const &

        """
        _snap.TNGraphMtx_swiginit(self,_snap.new_TNGraphMtx(*args))
    def PGetRows(self):
        """
        PGetRows(TNGraphMtx self) -> int

        Parameters:
            self: TNGraphMtx const *

        """
        return _snap.TNGraphMtx_PGetRows(self)

    def PGetCols(self):
        """
        PGetCols(TNGraphMtx self) -> int

        Parameters:
            self: TNGraphMtx const *

        """
        return _snap.TNGraphMtx_PGetCols(self)

    def PMultiply(self, *args):
        """
        PMultiply(TNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)

        Parameters:
            B: TFltVV const &
            ColId: int
            Result: TFltV &

        PMultiply(TNGraphMtx self, TFltV const & Vec, TFltV & Result)

        Parameters:
            Vec: TFltV const &
            Result: TFltV &

        """
        return _snap.TNGraphMtx_PMultiply(self, *args)

    def PMultiplyT(self, *args):
        """
        PMultiplyT(TNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)

        Parameters:
            B: TFltVV const &
            ColId: int
            Result: TFltV &

        PMultiplyT(TNGraphMtx self, TFltV const & Vec, TFltV & Result)

        Parameters:
            Vec: TFltV const &
            Result: TFltV &

        """
        return _snap.TNGraphMtx_PMultiplyT(self, *args)

    __swig_destroy__ = _snap.delete_TNGraphMtx
TNGraphMtx.PGetRows = new_instancemethod(_snap.TNGraphMtx_PGetRows,None,TNGraphMtx)
TNGraphMtx.PGetCols = new_instancemethod(_snap.TNGraphMtx_PGetCols,None,TNGraphMtx)
TNGraphMtx.PMultiply = new_instancemethod(_snap.TNGraphMtx_PMultiply,None,TNGraphMtx)
TNGraphMtx.PMultiplyT = new_instancemethod(_snap.TNGraphMtx_PMultiplyT,None,TNGraphMtx)
TNGraphMtx_swigregister = _snap.TNGraphMtx_swigregister
TNGraphMtx_swigregister(TNGraphMtx)

class TUNGraphMtx(object):
    """Proxy of C++ TUNGraphMtx class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TUNGraphMtx self, PUNGraph const & GraphPt) -> TUNGraphMtx

        Parameters:
            GraphPt: PUNGraph const &

        __init__(TUNGraphMtx self, TUNGraphMtx GraphMtx) -> TUNGraphMtx

        Parameters:
            GraphMtx: TUNGraphMtx const &

        """
        _snap.TUNGraphMtx_swiginit(self,_snap.new_TUNGraphMtx(*args))
    def PGetRows(self):
        """
        PGetRows(TUNGraphMtx self) -> int

        Parameters:
            self: TUNGraphMtx const *

        """
        return _snap.TUNGraphMtx_PGetRows(self)

    def PGetCols(self):
        """
        PGetCols(TUNGraphMtx self) -> int

        Parameters:
            self: TUNGraphMtx const *

        """
        return _snap.TUNGraphMtx_PGetCols(self)

    def PMultiply(self, *args):
        """
        PMultiply(TUNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)

        Parameters:
            B: TFltVV const &
            ColId: int
            Result: TFltV &

        PMultiply(TUNGraphMtx self, TFltV const & Vec, TFltV & Result)

        Parameters:
            Vec: TFltV const &
            Result: TFltV &

        """
        return _snap.TUNGraphMtx_PMultiply(self, *args)

    def PMultiplyT(self, *args):
        """
        PMultiplyT(TUNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)

        Parameters:
            B: TFltVV const &
            ColId: int
            Result: TFltV &

        PMultiplyT(TUNGraphMtx self, TFltV const & Vec, TFltV & Result)

        Parameters:
            Vec: TFltV const &
            Result: TFltV &

        """
        return _snap.TUNGraphMtx_PMultiplyT(self, *args)

    __swig_destroy__ = _snap.delete_TUNGraphMtx
TUNGraphMtx.PGetRows = new_instancemethod(_snap.TUNGraphMtx_PGetRows,None,TUNGraphMtx)
TUNGraphMtx.PGetCols = new_instancemethod(_snap.TUNGraphMtx_PGetCols,None,TUNGraphMtx)
TUNGraphMtx.PMultiply = new_instancemethod(_snap.TUNGraphMtx_PMultiply,None,TUNGraphMtx)
TUNGraphMtx.PMultiplyT = new_instancemethod(_snap.TUNGraphMtx_PMultiplyT,None,TUNGraphMtx)
TUNGraphMtx_swigregister = _snap.TUNGraphMtx_swigregister
TUNGraphMtx_swigregister(TUNGraphMtx)


def GetSngVals(*args):
  """
    GetSngVals(PNGraph const & Graph, int const & SngVals, TFltV & SngValV)

    Parameters:
        Graph: PNGraph const &
        SngVals: int const &
        SngValV: TFltV &

    """
  return _snap.GetSngVals(*args)

def GetSngVec(*args):
  """
    GetSngVec(PNGraph const & Graph, TFltV & LeftSV, TFltV & RightSV)

    Parameters:
        Graph: PNGraph const &
        LeftSV: TFltV &
        RightSV: TFltV &

    GetSngVec(PNGraph const & Graph, int const & SngVecs, TFltV & SngValV, TVec< TFltV > & LeftSV, 
        TVec< TFltV > & RightSV)

    Parameters:
        Graph: PNGraph const &
        SngVecs: int const &
        SngValV: TFltV &
        LeftSV: TVec< TFltV > &
        RightSV: TVec< TFltV > &

    """
  return _snap.GetSngVec(*args)

def GetEigVals(*args):
  """
    GetEigVals(PUNGraph const & Graph, int const & EigVals, TFltV & EigValV)

    Parameters:
        Graph: PUNGraph const &
        EigVals: int const &
        EigValV: TFltV &

    """
  return _snap.GetEigVals(*args)

def GetEigVec(*args):
  """
    GetEigVec(PUNGraph const & Graph, TFltV & EigVecV)

    Parameters:
        Graph: PUNGraph const &
        EigVecV: TFltV &

    GetEigVec(PUNGraph const & Graph, int const & EigVecs, TFltV & EigValV, TVec< TFltV > & EigVecV)

    Parameters:
        Graph: PUNGraph const &
        EigVecs: int const &
        EigValV: TFltV &
        EigVecV: TVec< TFltV > &

    """
  return _snap.GetEigVec(*args)

def GetInvParticipRat(*args):
  """
    GetInvParticipRat(PUNGraph const & Graph, int MaxEigVecs, int TimeLimit, TFltPrV & EigValIprV)

    Parameters:
        Graph: PUNGraph const &
        MaxEigVecs: int
        TimeLimit: int
        EigValIprV: TFltPrV &

    """
  return _snap.GetInvParticipRat(*args)

def GetInvParticipRatEig(*args):
  """
    GetInvParticipRatEig(TFltV const & EigVec) -> double

    Parameters:
        EigVec: TFltV const &

    """
  return _snap.GetInvParticipRatEig(*args)

def LoadDyNet(*args):
  """
    LoadDyNet(TStr FNm) -> PNGraph

    Parameters:
        FNm: TStr const &

    """
  return _snap.LoadDyNet(*args)

def LoadDyNetGraphV(*args):
  """
    LoadDyNetGraphV(TStr FNm) -> TVec< PNGraph >

    Parameters:
        FNm: TStr const &

    """
  return _snap.LoadDyNetGraphV(*args)
gvlDot = _snap.gvlDot
gvlNeato = _snap.gvlNeato
gvlTwopi = _snap.gvlTwopi
gvlCirco = _snap.gvlCirco

def GVizDoLayout(*args):
  """
    GVizDoLayout(TStr GraphInFNm, TStr OutFNm, TGVizLayout const & Layout)

    Parameters:
        GraphInFNm: TStr const &
        OutFNm: TStr
        Layout: TGVizLayout const &

    """
  return _snap.GVizDoLayout(*args)

def GVizGetLayoutStr(*args):
  """
    GVizGetLayoutStr(TGVizLayout const & Layout) -> TStr

    Parameters:
        Layout: TGVizLayout const &

    """
  return _snap.GVizGetLayoutStr(*args)
class TBigStrPool(object):
    """Proxy of C++ TBigStrPool class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TBigStrPool self, TSize MxBfLen=0, uint _GrowBy=16*1024*1024) -> TBigStrPool

        Parameters:
            MxBfLen: TSize
            _GrowBy: uint

        __init__(TBigStrPool self, TSize MxBfLen=0) -> TBigStrPool

        Parameters:
            MxBfLen: TSize

        __init__(TBigStrPool self) -> TBigStrPool
        __init__(TBigStrPool self, TSIn SIn, bool LoadCompact=True) -> TBigStrPool

        Parameters:
            SIn: TSIn &
            LoadCompact: bool

        __init__(TBigStrPool self, TSIn SIn) -> TBigStrPool

        Parameters:
            SIn: TSIn &

        __init__(TBigStrPool self, TBigStrPool Pool) -> TBigStrPool

        Parameters:
            Pool: TBigStrPool const &

        """
        _snap.TBigStrPool_swiginit(self,_snap.new_TBigStrPool(*args))
    __swig_destroy__ = _snap.delete_TBigStrPool
    def New(*args):
        """
        New(TSize _MxBfLen=0, uint _GrowBy=16*1024*1024) -> PBigStrPool

        Parameters:
            _MxBfLen: TSize
            _GrowBy: uint

        New(TSize _MxBfLen=0) -> PBigStrPool

        Parameters:
            _MxBfLen: TSize

        New() -> PBigStrPool
        New(TSIn SIn) -> PBigStrPool

        Parameters:
            SIn: TSIn &

        New(TStr fileName) -> PBigStrPool

        Parameters:
            fileName: TStr const &

        """
        return _snap.TBigStrPool_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn, bool LoadCompacted=True) -> PBigStrPool

        Parameters:
            SIn: TSIn &
            LoadCompacted: bool

        Load(TSIn SIn) -> PBigStrPool

        Parameters:
            SIn: TSIn &

        """
        return _snap.TBigStrPool_Load(*args)

    Load = staticmethod(Load)
    def Save(self, *args):
        """
        Save(TBigStrPool self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        Save(TBigStrPool self, TStr fileName)

        Parameters:
            fileName: TStr const &

        """
        return _snap.TBigStrPool_Save(self, *args)

    def GetStrs(self):
        """
        GetStrs(TBigStrPool self) -> int

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool_GetStrs(self)

    def Len(self):
        """
        Len(TBigStrPool self) -> TSize

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool_Len(self)

    def Size(self):
        """
        Size(TBigStrPool self) -> TSize

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool_Size(self)

    def Empty(self):
        """
        Empty(TBigStrPool self) -> bool

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool_Empty(self)

    def __call__(self):
        """
        __call__(TBigStrPool self) -> char *

        Parameters:
            self: TBigStrPool const *

        """
        return _snap.TBigStrPool___call__(self)

    def AddStr(self, *args):
        """
        AddStr(TBigStrPool self, char const * Str, uint Len) -> int

        Parameters:
            Str: char const *
            Len: uint

        AddStr(TBigStrPool self, char const * Str) -> int

        Parameters:
            Str: char const *

        AddStr(TBigStrPool self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TBigStrPool_AddStr(self, *args)

    def GetCStr(self, *args):
        """
        GetCStr(TBigStrPool self, int const & StrId) -> char const *

        Parameters:
            StrId: int const &

        """
        return _snap.TBigStrPool_GetCStr(self, *args)

    def GetStrFromOffset(self, *args):
        """
        GetStrFromOffset(TBigStrPool self, TSize const & Offset) -> TStr

        Parameters:
            Offset: TSize const &

        """
        return _snap.TBigStrPool_GetStrFromOffset(self, *args)

    def GetCStrFromOffset(self, *args):
        """
        GetCStrFromOffset(TBigStrPool self, TSize const & Offset) -> char const *

        Parameters:
            Offset: TSize const &

        """
        return _snap.TBigStrPool_GetCStrFromOffset(self, *args)

    def Clr(self, DoDel=False):
        """
        Clr(TBigStrPool self, bool DoDel=False)

        Parameters:
            DoDel: bool

        Clr(TBigStrPool self)

        Parameters:
            self: TBigStrPool *

        """
        return _snap.TBigStrPool_Clr(self, DoDel)

    def Cmp(self, *args):
        """
        Cmp(TBigStrPool self, int const & StrId, char const * Str) -> int

        Parameters:
            StrId: int const &
            Str: char const *

        """
        return _snap.TBigStrPool_Cmp(self, *args)

    def GetPrimHashCd(self, *args):
        """
        GetPrimHashCd(TBigStrPool self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        GetPrimHashCd(TBigStrPool self, int const & StrId) -> int

        Parameters:
            StrId: int const &

        """
        return _snap.TBigStrPool_GetPrimHashCd(self, *args)

    def GetSecHashCd(self, *args):
        """
        GetSecHashCd(TBigStrPool self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        GetSecHashCd(TBigStrPool self, int const & StrId) -> int

        Parameters:
            StrId: int const &

        """
        return _snap.TBigStrPool_GetSecHashCd(self, *args)

TBigStrPool.Save = new_instancemethod(_snap.TBigStrPool_Save,None,TBigStrPool)
TBigStrPool.GetStrs = new_instancemethod(_snap.TBigStrPool_GetStrs,None,TBigStrPool)
TBigStrPool.Len = new_instancemethod(_snap.TBigStrPool_Len,None,TBigStrPool)
TBigStrPool.Size = new_instancemethod(_snap.TBigStrPool_Size,None,TBigStrPool)
TBigStrPool.Empty = new_instancemethod(_snap.TBigStrPool_Empty,None,TBigStrPool)
TBigStrPool.__call__ = new_instancemethod(_snap.TBigStrPool___call__,None,TBigStrPool)
TBigStrPool.AddStr = new_instancemethod(_snap.TBigStrPool_AddStr,None,TBigStrPool)
TBigStrPool.GetCStr = new_instancemethod(_snap.TBigStrPool_GetCStr,None,TBigStrPool)
TBigStrPool.GetStrFromOffset = new_instancemethod(_snap.TBigStrPool_GetStrFromOffset,None,TBigStrPool)
TBigStrPool.GetCStrFromOffset = new_instancemethod(_snap.TBigStrPool_GetCStrFromOffset,None,TBigStrPool)
TBigStrPool.Clr = new_instancemethod(_snap.TBigStrPool_Clr,None,TBigStrPool)
TBigStrPool.Cmp = new_instancemethod(_snap.TBigStrPool_Cmp,None,TBigStrPool)
TBigStrPool.GetPrimHashCd = new_instancemethod(_snap.TBigStrPool_GetPrimHashCd,None,TBigStrPool)
TBigStrPool.GetSecHashCd = new_instancemethod(_snap.TBigStrPool_GetSecHashCd,None,TBigStrPool)
TBigStrPool_swigregister = _snap.TBigStrPool_swigregister
TBigStrPool_swigregister(TBigStrPool)

def TBigStrPool_New(*args):
  """
    New(TSize _MxBfLen=0, uint _GrowBy=16*1024*1024) -> PBigStrPool

    Parameters:
        _MxBfLen: TSize
        _GrowBy: uint

    New(TSize _MxBfLen=0) -> PBigStrPool

    Parameters:
        _MxBfLen: TSize

    New() -> PBigStrPool
    New(TSIn SIn) -> PBigStrPool

    Parameters:
        SIn: TSIn &

    TBigStrPool_New(TStr fileName) -> PBigStrPool

    Parameters:
        fileName: TStr const &

    """
  return _snap.TBigStrPool_New(*args)

def TBigStrPool_Load(*args):
  """
    Load(TSIn SIn, bool LoadCompacted=True) -> PBigStrPool

    Parameters:
        SIn: TSIn &
        LoadCompacted: bool

    TBigStrPool_Load(TSIn SIn) -> PBigStrPool

    Parameters:
        SIn: TSIn &

    """
  return _snap.TBigStrPool_Load(*args)

class TStrHashF_OldGLib(object):
    """Proxy of C++ TStrHashF_OldGLib class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetPrimHashCd(*args):
        """
        GetPrimHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetPrimHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_OldGLib_GetPrimHashCd(*args)

    GetPrimHashCd = staticmethod(GetPrimHashCd)
    def GetSecHashCd(*args):
        """
        GetSecHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetSecHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_OldGLib_GetSecHashCd(*args)

    GetSecHashCd = staticmethod(GetSecHashCd)
    def __init__(self): 
        """__init__(TStrHashF_OldGLib self) -> TStrHashF_OldGLib"""
        _snap.TStrHashF_OldGLib_swiginit(self,_snap.new_TStrHashF_OldGLib())
    __swig_destroy__ = _snap.delete_TStrHashF_OldGLib
TStrHashF_OldGLib_swigregister = _snap.TStrHashF_OldGLib_swigregister
TStrHashF_OldGLib_swigregister(TStrHashF_OldGLib)

def TStrHashF_OldGLib_GetPrimHashCd(*args):
  """
    GetPrimHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_OldGLib_GetPrimHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_OldGLib_GetPrimHashCd(*args)

def TStrHashF_OldGLib_GetSecHashCd(*args):
  """
    GetSecHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_OldGLib_GetSecHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_OldGLib_GetSecHashCd(*args)

class TStrHashF_Md5(object):
    """Proxy of C++ TStrHashF_Md5 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetPrimHashCd(*args):
        """
        GetPrimHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetPrimHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_Md5_GetPrimHashCd(*args)

    GetPrimHashCd = staticmethod(GetPrimHashCd)
    def GetSecHashCd(*args):
        """
        GetSecHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetSecHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_Md5_GetSecHashCd(*args)

    GetSecHashCd = staticmethod(GetSecHashCd)
    def __init__(self): 
        """__init__(TStrHashF_Md5 self) -> TStrHashF_Md5"""
        _snap.TStrHashF_Md5_swiginit(self,_snap.new_TStrHashF_Md5())
    __swig_destroy__ = _snap.delete_TStrHashF_Md5
TStrHashF_Md5_swigregister = _snap.TStrHashF_Md5_swigregister
TStrHashF_Md5_swigregister(TStrHashF_Md5)

def TStrHashF_Md5_GetPrimHashCd(*args):
  """
    GetPrimHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_Md5_GetPrimHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_Md5_GetPrimHashCd(*args)

def TStrHashF_Md5_GetSecHashCd(*args):
  """
    GetSecHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_Md5_GetSecHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_Md5_GetSecHashCd(*args)

class TStrHashF_DJB(object):
    """Proxy of C++ TStrHashF_DJB class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetPrimHashCd(*args):
        """
        GetPrimHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetPrimHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_DJB_GetPrimHashCd(*args)

    GetPrimHashCd = staticmethod(GetPrimHashCd)
    def GetSecHashCd(*args):
        """
        GetSecHashCd(char const * p) -> int

        Parameters:
            p: char const *

        GetSecHashCd(TStr s) -> int

        Parameters:
            s: TStr const &

        """
        return _snap.TStrHashF_DJB_GetSecHashCd(*args)

    GetSecHashCd = staticmethod(GetSecHashCd)
    def __init__(self): 
        """__init__(TStrHashF_DJB self) -> TStrHashF_DJB"""
        _snap.TStrHashF_DJB_swiginit(self,_snap.new_TStrHashF_DJB())
    __swig_destroy__ = _snap.delete_TStrHashF_DJB
TStrHashF_DJB_swigregister = _snap.TStrHashF_DJB_swigregister
TStrHashF_DJB_swigregister(TStrHashF_DJB)

def TStrHashF_DJB_GetPrimHashCd(*args):
  """
    GetPrimHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_DJB_GetPrimHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_DJB_GetPrimHashCd(*args)

def TStrHashF_DJB_GetSecHashCd(*args):
  """
    GetSecHashCd(char const * p) -> int

    Parameters:
        p: char const *

    TStrHashF_DJB_GetSecHashCd(TStr s) -> int

    Parameters:
        s: TStr const &

    """
  return _snap.TStrHashF_DJB_GetSecHashCd(*args)


def GenRndBipart(*args):
  """
    GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges, TRnd Rnd=Rnd) -> PBPGraph

    Parameters:
        LeftNodes: int const &
        RightNodes: int const &
        Edges: int const &
        Rnd: TRnd &

    GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges) -> PBPGraph

    Parameters:
        LeftNodes: int const &
        RightNodes: int const &
        Edges: int const &

    """
  return _snap.GenRndBipart(*args)

def GenRndDegK(*args):
  """
    GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeDeg: int const &
        NSwitch: int const &
        Rnd: TRnd &

    GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeDeg: int const &
        NSwitch: int const &

    GenRndDegK(int const & Nodes, int const & NodeDeg) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeDeg: int const &

    """
  return _snap.GenRndDegK(*args)

def GenRndPowerLaw(*args):
  """
    GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        PowerExp: double const &
        ConfModel: bool const &
        Rnd: TRnd &

    GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True) -> PUNGraph

    Parameters:
        Nodes: int const &
        PowerExp: double const &
        ConfModel: bool const &

    GenRndPowerLaw(int const & Nodes, double const & PowerExp) -> PUNGraph

    Parameters:
        Nodes: int const &
        PowerExp: double const &

    """
  return _snap.GenRndPowerLaw(*args)

def GenDegSeq(*args):
  """
    GenDegSeq(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        DegSeqV: TIntV const &
        Rnd: TRnd &

    GenDegSeq(TIntV DegSeqV) -> PUNGraph

    Parameters:
        DegSeqV: TIntV const &

    """
  return _snap.GenDegSeq(*args)

def GenPrefAttach(*args):
  """
    GenPrefAttach(int const & Nodes, int const & NodeOutDeg, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeOutDeg: int const &
        Rnd: TRnd &

    GenPrefAttach(int const & Nodes, int const & NodeOutDeg) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeOutDeg: int const &

    """
  return _snap.GenPrefAttach(*args)

def GenGeoPrefAttach(*args):
  """
    GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        OutDeg: int const &
        Beta: double const &
        Rnd: TRnd &

    GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta) -> PUNGraph

    Parameters:
        Nodes: int const &
        OutDeg: int const &
        Beta: double const &

    """
  return _snap.GenGeoPrefAttach(*args)

def GenSmallWorld(*args):
  """
    GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeOutDeg: int const &
        RewireProb: double const &
        Rnd: TRnd &

    GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb) -> PUNGraph

    Parameters:
        Nodes: int const &
        NodeOutDeg: int const &
        RewireProb: double const &

    """
  return _snap.GenSmallWorld(*args)

def GenForestFire(*args):
  """
    GenForestFire(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph

    Parameters:
        Nodes: int const &
        FwdProb: double const &
        BckProb: double const &

    """
  return _snap.GenForestFire(*args)

def GenCopyModel(*args):
  """
    GenCopyModel(int const & Nodes, double const & Beta, TRnd Rnd=Rnd) -> PNGraph

    Parameters:
        Nodes: int const &
        Beta: double const &
        Rnd: TRnd &

    GenCopyModel(int const & Nodes, double const & Beta) -> PNGraph

    Parameters:
        Nodes: int const &
        Beta: double const &

    """
  return _snap.GenCopyModel(*args)

def GenRMat(*args):
  """
    GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C, 
        TRnd Rnd=Rnd) -> PNGraph

    Parameters:
        Nodes: int const &
        Edges: int const &
        A: double const &
        B: double const &
        C: double const &
        Rnd: TRnd &

    GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C) -> PNGraph

    Parameters:
        Nodes: int const &
        Edges: int const &
        A: double const &
        B: double const &
        C: double const &

    """
  return _snap.GenRMat(*args)

def GenRMatEpinions():
  """GenRMatEpinions() -> PNGraph"""
  return _snap.GenRMatEpinions()

def GenRewire(*args):
  """
    GenRewire(PUNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        NSwitch: int const &
        Rnd: TRnd &

    GenRewire(PUNGraph const & Graph, int const & NSwitch=100) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        NSwitch: int const &

    GenRewire(PUNGraph const & Graph) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &

    GenRewire(PNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PNGraph

    Parameters:
        Graph: PNGraph const &
        NSwitch: int const &
        Rnd: TRnd &

    GenRewire(PNGraph const & Graph, int const & NSwitch=100) -> PNGraph

    Parameters:
        Graph: PNGraph const &
        NSwitch: int const &

    GenRewire(PNGraph const & Graph) -> PNGraph

    Parameters:
        Graph: PNGraph const &

    GenRewire(PBPGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PBPGraph

    Parameters:
        Graph: PBPGraph const &
        NSwitch: int const &
        Rnd: TRnd &

    GenRewire(PBPGraph const & Graph, int const & NSwitch=100) -> PBPGraph

    Parameters:
        Graph: PBPGraph const &
        NSwitch: int const &

    GenRewire(PBPGraph const & Graph) -> PBPGraph

    Parameters:
        Graph: PBPGraph const &

    """
  return _snap.GenRewire(*args)

def GenConfModel(*args):
  """
    GenConfModel(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph

    Parameters:
        DegSeqV: TIntV const &
        Rnd: TRnd &

    GenConfModel(TIntV DegSeqV) -> PUNGraph

    Parameters:
        DegSeqV: TIntV const &

    GenConfModel(PUNGraph const & G) -> PUNGraph

    Parameters:
        G: PUNGraph const &

    """
  return _snap.GenConfModel(*args)

def GetSubGraph(*args):
  """
    GetSubGraph(PUNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        NIdV: TIntV const &
        RenumberNodes: bool const &

    GetSubGraph(PUNGraph const & Graph, TIntV NIdV) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        NIdV: TIntV const &

    GetSubGraph(PNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PNGraph

    Parameters:
        Graph: PNGraph const &
        NIdV: TIntV const &
        RenumberNodes: bool const &

    GetSubGraph(PNGraph const & Graph, TIntV NIdV) -> PNGraph

    Parameters:
        Graph: PNGraph const &
        NIdV: TIntV const &

    """
  return _snap.GetSubGraph(*args)
class TGUtil(object):
    """Proxy of C++ TGUtil class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetCdf(*args):
        """
        GetCdf(TIntPrV const & PdfV, TIntPrV & CdfV)

        Parameters:
            PdfV: TIntPrV const &
            CdfV: TIntPrV &

        GetCdf(TFltPrV const & PdfV, TFltPrV & CdfV)

        Parameters:
            PdfV: TFltPrV const &
            CdfV: TFltPrV &

        GetCdf(TIntFltKdV const & PdfV, TIntFltKdV & CdfV)

        Parameters:
            PdfV: TIntFltKdV const &
            CdfV: TIntFltKdV &

        GetCdf(TIntPrV const & PdfV) -> TIntPrV

        Parameters:
            PdfV: TIntPrV const &

        GetCdf(TFltPrV const & PdfV) -> TFltPrV

        Parameters:
            PdfV: TFltPrV const &

        """
        return _snap.TGUtil_GetCdf(*args)

    GetCdf = staticmethod(GetCdf)
    def GetCCdf(*args):
        """
        GetCCdf(TIntPrV const & PdfV, TIntPrV & CCdfV)

        Parameters:
            PdfV: TIntPrV const &
            CCdfV: TIntPrV &

        GetCCdf(TFltPrV const & PdfV, TFltPrV & CCdfV)

        Parameters:
            PdfV: TFltPrV const &
            CCdfV: TFltPrV &

        GetCCdf(TIntFltKdV const & PdfV, TIntFltKdV & CCdfV)

        Parameters:
            PdfV: TIntFltKdV const &
            CCdfV: TIntFltKdV &

        GetCCdf(TIntPrV const & PdfV) -> TIntPrV

        Parameters:
            PdfV: TIntPrV const &

        GetCCdf(TFltPrV const & PdfV) -> TFltPrV

        Parameters:
            PdfV: TFltPrV const &

        """
        return _snap.TGUtil_GetCCdf(*args)

    GetCCdf = staticmethod(GetCCdf)
    def GetPdf(*args):
        """
        GetPdf(TIntPrV const & CdfV, TIntPrV & PdfV)

        Parameters:
            CdfV: TIntPrV const &
            PdfV: TIntPrV &

        GetPdf(TFltPrV const & CdfV, TFltPrV & PdfV)

        Parameters:
            CdfV: TFltPrV const &
            PdfV: TFltPrV &

        GetPdf(TIntFltKdV const & CdfV, TIntFltKdV & PdfV)

        Parameters:
            CdfV: TIntFltKdV const &
            PdfV: TIntFltKdV &

        """
        return _snap.TGUtil_GetPdf(*args)

    GetPdf = staticmethod(GetPdf)
    def Normalize(*args):
        """
        Normalize(TFltPrV & PdfV)

        Parameters:
            PdfV: TFltPrV &

        Normalize(TIntFltKdV & PdfV)

        Parameters:
            PdfV: TIntFltKdV &

        """
        return _snap.TGUtil_Normalize(*args)

    Normalize = staticmethod(Normalize)
    def MakeExpBins(*args):
        """
        MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)

        Parameters:
            XYValV: TFltPrV const &
            ExpXYValV: TFltPrV &
            BinFactor: double const &
            MinYVal: double const &

        MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2)

        Parameters:
            XYValV: TFltPrV const &
            ExpXYValV: TFltPrV &
            BinFactor: double const &

        MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV)

        Parameters:
            XYValV: TFltPrV const &
            ExpXYValV: TFltPrV &

        MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)

        Parameters:
            XYValV: TFltKdV const &
            ExpXYValV: TFltKdV &
            BinFactor: double const &
            MinYVal: double const &

        MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2)

        Parameters:
            XYValV: TFltKdV const &
            ExpXYValV: TFltKdV &
            BinFactor: double const &

        MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV)

        Parameters:
            XYValV: TFltKdV const &
            ExpXYValV: TFltKdV &

        MakeExpBins(TFltV const & YValV, TFltV & ExpYValV, double const & BinFactor=1.01)

        Parameters:
            YValV: TFltV const &
            ExpYValV: TFltV &
            BinFactor: double const &

        MakeExpBins(TFltV const & YValV, TFltV & ExpYValV)

        Parameters:
            YValV: TFltV const &
            ExpYValV: TFltV &

        MakeExpBins(TIntV YValV, TIntV ExpYValV, double const & BinFactor=1.01)

        Parameters:
            YValV: TIntV const &
            ExpYValV: TIntV &
            BinFactor: double const &

        MakeExpBins(TIntV YValV, TIntV ExpYValV)

        Parameters:
            YValV: TIntV const &
            ExpYValV: TIntV &

        """
        return _snap.TGUtil_MakeExpBins(*args)

    MakeExpBins = staticmethod(MakeExpBins)
    def __init__(self): 
        """__init__(TGUtil self) -> TGUtil"""
        _snap.TGUtil_swiginit(self,_snap.new_TGUtil())
    __swig_destroy__ = _snap.delete_TGUtil
TGUtil_swigregister = _snap.TGUtil_swigregister
TGUtil_swigregister(TGUtil)

def TGUtil_GetCdf(*args):
  """
    GetCdf(TIntPrV const & PdfV, TIntPrV & CdfV)

    Parameters:
        PdfV: TIntPrV const &
        CdfV: TIntPrV &

    GetCdf(TFltPrV const & PdfV, TFltPrV & CdfV)

    Parameters:
        PdfV: TFltPrV const &
        CdfV: TFltPrV &

    GetCdf(TIntFltKdV const & PdfV, TIntFltKdV & CdfV)

    Parameters:
        PdfV: TIntFltKdV const &
        CdfV: TIntFltKdV &

    GetCdf(TIntPrV const & PdfV) -> TIntPrV

    Parameters:
        PdfV: TIntPrV const &

    TGUtil_GetCdf(TFltPrV const & PdfV) -> TFltPrV

    Parameters:
        PdfV: TFltPrV const &

    """
  return _snap.TGUtil_GetCdf(*args)

def TGUtil_GetCCdf(*args):
  """
    GetCCdf(TIntPrV const & PdfV, TIntPrV & CCdfV)

    Parameters:
        PdfV: TIntPrV const &
        CCdfV: TIntPrV &

    GetCCdf(TFltPrV const & PdfV, TFltPrV & CCdfV)

    Parameters:
        PdfV: TFltPrV const &
        CCdfV: TFltPrV &

    GetCCdf(TIntFltKdV const & PdfV, TIntFltKdV & CCdfV)

    Parameters:
        PdfV: TIntFltKdV const &
        CCdfV: TIntFltKdV &

    GetCCdf(TIntPrV const & PdfV) -> TIntPrV

    Parameters:
        PdfV: TIntPrV const &

    TGUtil_GetCCdf(TFltPrV const & PdfV) -> TFltPrV

    Parameters:
        PdfV: TFltPrV const &

    """
  return _snap.TGUtil_GetCCdf(*args)

def TGUtil_GetPdf(*args):
  """
    GetPdf(TIntPrV const & CdfV, TIntPrV & PdfV)

    Parameters:
        CdfV: TIntPrV const &
        PdfV: TIntPrV &

    GetPdf(TFltPrV const & CdfV, TFltPrV & PdfV)

    Parameters:
        CdfV: TFltPrV const &
        PdfV: TFltPrV &

    TGUtil_GetPdf(TIntFltKdV const & CdfV, TIntFltKdV & PdfV)

    Parameters:
        CdfV: TIntFltKdV const &
        PdfV: TIntFltKdV &

    """
  return _snap.TGUtil_GetPdf(*args)

def TGUtil_Normalize(*args):
  """
    Normalize(TFltPrV & PdfV)

    Parameters:
        PdfV: TFltPrV &

    TGUtil_Normalize(TIntFltKdV & PdfV)

    Parameters:
        PdfV: TIntFltKdV &

    """
  return _snap.TGUtil_Normalize(*args)

def TGUtil_MakeExpBins(*args):
  """
    MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)

    Parameters:
        XYValV: TFltPrV const &
        ExpXYValV: TFltPrV &
        BinFactor: double const &
        MinYVal: double const &

    MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2)

    Parameters:
        XYValV: TFltPrV const &
        ExpXYValV: TFltPrV &
        BinFactor: double const &

    MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV)

    Parameters:
        XYValV: TFltPrV const &
        ExpXYValV: TFltPrV &

    MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)

    Parameters:
        XYValV: TFltKdV const &
        ExpXYValV: TFltKdV &
        BinFactor: double const &
        MinYVal: double const &

    MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2)

    Parameters:
        XYValV: TFltKdV const &
        ExpXYValV: TFltKdV &
        BinFactor: double const &

    MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV)

    Parameters:
        XYValV: TFltKdV const &
        ExpXYValV: TFltKdV &

    MakeExpBins(TFltV const & YValV, TFltV & ExpYValV, double const & BinFactor=1.01)

    Parameters:
        YValV: TFltV const &
        ExpYValV: TFltV &
        BinFactor: double const &

    MakeExpBins(TFltV const & YValV, TFltV & ExpYValV)

    Parameters:
        YValV: TFltV const &
        ExpYValV: TFltV &

    MakeExpBins(TIntV YValV, TIntV ExpYValV, double const & BinFactor=1.01)

    Parameters:
        YValV: TIntV const &
        ExpYValV: TIntV &
        BinFactor: double const &

    TGUtil_MakeExpBins(TIntV YValV, TIntV ExpYValV)

    Parameters:
        YValV: TIntV const &
        ExpYValV: TIntV &

    """
  return _snap.TGUtil_MakeExpBins(*args)

class TStrUtil(object):
    """Proxy of C++ TStrUtil class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetXmlTagVal(*args):
        """
        GetXmlTagVal(TXmlLx & XmlLx, TChA TagNm) -> TChA

        Parameters:
            XmlLx: TXmlLx &
            TagNm: TChA const &

        """
        return _snap.TStrUtil_GetXmlTagVal(*args)

    GetXmlTagVal = staticmethod(GetXmlTagVal)
    def GetXmlTagNmVal(*args):
        """
        GetXmlTagNmVal(TXmlLx & XmlLx, TChA TagNm, TChA TagVal)

        Parameters:
            XmlLx: TXmlLx &
            TagNm: TChA &
            TagVal: TChA &

        """
        return _snap.TStrUtil_GetXmlTagNmVal(*args)

    GetXmlTagNmVal = staticmethod(GetXmlTagNmVal)
    def GetXmlTagNmVal2(*args):
        """
        GetXmlTagNmVal2(TXmlLx & XmlLx, TChA TagNm, TChA TagVal, bool const & TakeTagNms) -> bool

        Parameters:
            XmlLx: TXmlLx &
            TagNm: TChA &
            TagVal: TChA &
            TakeTagNms: bool const &

        """
        return _snap.TStrUtil_GetXmlTagNmVal2(*args)

    GetXmlTagNmVal2 = staticmethod(GetXmlTagNmVal2)
    def GetDomNm(*args):
        """
        GetDomNm(TChA UrlChA) -> TChA

        Parameters:
            UrlChA: TChA const &

        """
        return _snap.TStrUtil_GetDomNm(*args)

    GetDomNm = staticmethod(GetDomNm)
    def GetDomNm2(*args):
        """
        GetDomNm2(TChA UrlChA) -> TChA

        Parameters:
            UrlChA: TChA const &

        """
        return _snap.TStrUtil_GetDomNm2(*args)

    GetDomNm2 = staticmethod(GetDomNm2)
    def GetWebsiteNm(*args):
        """
        GetWebsiteNm(TChA UrlChA) -> TChA

        Parameters:
            UrlChA: TChA const &

        """
        return _snap.TStrUtil_GetWebsiteNm(*args)

    GetWebsiteNm = staticmethod(GetWebsiteNm)
    def GetNormalizedUrl(*args):
        """
        GetNormalizedUrl(TChA UrlIn, TChA BaseUrl, TChA UrlOut) -> bool

        Parameters:
            UrlIn: TChA const &
            BaseUrl: TChA const &
            UrlOut: TChA &

        """
        return _snap.TStrUtil_GetNormalizedUrl(*args)

    GetNormalizedUrl = staticmethod(GetNormalizedUrl)
    def StripEnd(*args):
        """
        StripEnd(TChA Str, TChA SearchStr, TChA NewStr) -> bool

        Parameters:
            Str: TChA const &
            SearchStr: TChA const &
            NewStr: TChA &

        """
        return _snap.TStrUtil_StripEnd(*args)

    StripEnd = staticmethod(StripEnd)
    def GetShorStr(*args):
        """
        GetShorStr(TChA LongStr, int const MaxLen=50) -> TChA

        Parameters:
            LongStr: TChA const &
            MaxLen: int const

        GetShorStr(TChA LongStr) -> TChA

        Parameters:
            LongStr: TChA const &

        """
        return _snap.TStrUtil_GetShorStr(*args)

    GetShorStr = staticmethod(GetShorStr)
    def GetCleanStr(*args):
        """
        GetCleanStr(TChA ChA) -> TChA

        Parameters:
            ChA: TChA const &

        """
        return _snap.TStrUtil_GetCleanStr(*args)

    GetCleanStr = staticmethod(GetCleanStr)
    def GetCleanWrdStr(*args):
        """
        GetCleanWrdStr(TChA ChA) -> TChA

        Parameters:
            ChA: TChA const &

        """
        return _snap.TStrUtil_GetCleanWrdStr(*args)

    GetCleanWrdStr = staticmethod(GetCleanWrdStr)
    def CountWords(*args):
        """
        CountWords(char const * CStr) -> int

        Parameters:
            CStr: char const *

        CountWords(TChA ChA) -> int

        Parameters:
            ChA: TChA const &

        CountWords(TChA ChA, TStrHash< TInt > const & StopWordH) -> int

        Parameters:
            ChA: TChA const &
            StopWordH: TStrHash< TInt > const &

        """
        return _snap.TStrUtil_CountWords(*args)

    CountWords = staticmethod(CountWords)
    def SplitWords(*args):
        """
        SplitWords(TChA ChA, TVec< char * > & WrdV, bool const & SplitOnWs=True) -> int

        Parameters:
            ChA: TChA &
            WrdV: TVec< char * > &
            SplitOnWs: bool const &

        SplitWords(TChA ChA, TVec< char * > & WrdV) -> int

        Parameters:
            ChA: TChA &
            WrdV: TVec< char * > &

        """
        return _snap.TStrUtil_SplitWords(*args)

    SplitWords = staticmethod(SplitWords)
    def SplitOnCh(*args):
        """
        SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch, bool const & SkipEmpty=False) -> int

        Parameters:
            ChA: TChA &
            WrdV: TVec< char * > &
            Ch: char const &
            SkipEmpty: bool const &

        SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch) -> int

        Parameters:
            ChA: TChA &
            WrdV: TVec< char * > &
            Ch: char const &

        """
        return _snap.TStrUtil_SplitOnCh(*args)

    SplitOnCh = staticmethod(SplitOnCh)
    def SplitLines(*args):
        """
        SplitLines(TChA ChA, TVec< char * > & LineV, bool const & SkipEmpty=False) -> int

        Parameters:
            ChA: TChA &
            LineV: TVec< char * > &
            SkipEmpty: bool const &

        SplitLines(TChA ChA, TVec< char * > & LineV) -> int

        Parameters:
            ChA: TChA &
            LineV: TVec< char * > &

        """
        return _snap.TStrUtil_SplitLines(*args)

    SplitLines = staticmethod(SplitLines)
    def SplitSentences(*args):
        """
        SplitSentences(TChA ChA, TVec< char * > & SentenceV) -> int

        Parameters:
            ChA: TChA &
            SentenceV: TVec< char * > &

        """
        return _snap.TStrUtil_SplitSentences(*args)

    SplitSentences = staticmethod(SplitSentences)
    def RemoveHtmlTags(*args):
        """
        RemoveHtmlTags(TChA HtmlStr, TChA TextStr)

        Parameters:
            HtmlStr: TChA const &
            TextStr: TChA &

        """
        return _snap.TStrUtil_RemoveHtmlTags(*args)

    RemoveHtmlTags = staticmethod(RemoveHtmlTags)
    def IsLatinStr(*args):
        """
        IsLatinStr(TChA Str, double const & MinAlFrac) -> bool

        Parameters:
            Str: TChA const &
            MinAlFrac: double const &

        """
        return _snap.TStrUtil_IsLatinStr(*args)

    IsLatinStr = staticmethod(IsLatinStr)
    def GetWIdV(*args):
        """
        GetWIdV(TStrHash< TInt > const & StrH, char const * CStr, TIntV WIdV)

        Parameters:
            StrH: TStrHash< TInt > const &
            CStr: char const *
            WIdV: TIntV &

        """
        return _snap.TStrUtil_GetWIdV(*args)

    GetWIdV = staticmethod(GetWIdV)
    def GetAddWIdV(*args):
        """
        GetAddWIdV(TStrHash< TInt > & StrH, char const * CStr, TIntV WIdV)

        Parameters:
            StrH: TStrHash< TInt > &
            CStr: char const *
            WIdV: TIntV &

        """
        return _snap.TStrUtil_GetAddWIdV(*args)

    GetAddWIdV = staticmethod(GetAddWIdV)
    def GetTmFromStr(*args):
        """
        GetTmFromStr(char const * TmStr, TSecTm & Tm) -> bool

        Parameters:
            TmStr: char const *
            Tm: TSecTm &

        """
        return _snap.TStrUtil_GetTmFromStr(*args)

    GetTmFromStr = staticmethod(GetTmFromStr)
    def GetStdName(*args):
        """
        GetStdName(TStr AuthorName) -> TStr

        Parameters:
            AuthorName: TStr

        """
        return _snap.TStrUtil_GetStdName(*args)

    GetStdName = staticmethod(GetStdName)
    def GetStdNameV(*args):
        """
        GetStdNameV(TStr AuthorNames, TStrV StdNameV)

        Parameters:
            AuthorNames: TStr
            StdNameV: TStrV &

        """
        return _snap.TStrUtil_GetStdNameV(*args)

    GetStdNameV = staticmethod(GetStdNameV)
    def __init__(self): 
        """__init__(TStrUtil self) -> TStrUtil"""
        _snap.TStrUtil_swiginit(self,_snap.new_TStrUtil())
    __swig_destroy__ = _snap.delete_TStrUtil
TStrUtil_swigregister = _snap.TStrUtil_swigregister
TStrUtil_swigregister(TStrUtil)

def TStrUtil_GetXmlTagVal(*args):
  """
    TStrUtil_GetXmlTagVal(TXmlLx & XmlLx, TChA TagNm) -> TChA

    Parameters:
        XmlLx: TXmlLx &
        TagNm: TChA const &

    """
  return _snap.TStrUtil_GetXmlTagVal(*args)

def TStrUtil_GetXmlTagNmVal(*args):
  """
    TStrUtil_GetXmlTagNmVal(TXmlLx & XmlLx, TChA TagNm, TChA TagVal)

    Parameters:
        XmlLx: TXmlLx &
        TagNm: TChA &
        TagVal: TChA &

    """
  return _snap.TStrUtil_GetXmlTagNmVal(*args)

def TStrUtil_GetXmlTagNmVal2(*args):
  """
    TStrUtil_GetXmlTagNmVal2(TXmlLx & XmlLx, TChA TagNm, TChA TagVal, bool const & TakeTagNms) -> bool

    Parameters:
        XmlLx: TXmlLx &
        TagNm: TChA &
        TagVal: TChA &
        TakeTagNms: bool const &

    """
  return _snap.TStrUtil_GetXmlTagNmVal2(*args)

def TStrUtil_GetDomNm(*args):
  """
    TStrUtil_GetDomNm(TChA UrlChA) -> TChA

    Parameters:
        UrlChA: TChA const &

    """
  return _snap.TStrUtil_GetDomNm(*args)

def TStrUtil_GetDomNm2(*args):
  """
    TStrUtil_GetDomNm2(TChA UrlChA) -> TChA

    Parameters:
        UrlChA: TChA const &

    """
  return _snap.TStrUtil_GetDomNm2(*args)

def TStrUtil_GetWebsiteNm(*args):
  """
    TStrUtil_GetWebsiteNm(TChA UrlChA) -> TChA

    Parameters:
        UrlChA: TChA const &

    """
  return _snap.TStrUtil_GetWebsiteNm(*args)

def TStrUtil_GetNormalizedUrl(*args):
  """
    TStrUtil_GetNormalizedUrl(TChA UrlIn, TChA BaseUrl, TChA UrlOut) -> bool

    Parameters:
        UrlIn: TChA const &
        BaseUrl: TChA const &
        UrlOut: TChA &

    """
  return _snap.TStrUtil_GetNormalizedUrl(*args)

def TStrUtil_StripEnd(*args):
  """
    TStrUtil_StripEnd(TChA Str, TChA SearchStr, TChA NewStr) -> bool

    Parameters:
        Str: TChA const &
        SearchStr: TChA const &
        NewStr: TChA &

    """
  return _snap.TStrUtil_StripEnd(*args)

def TStrUtil_GetShorStr(*args):
  """
    GetShorStr(TChA LongStr, int const MaxLen=50) -> TChA

    Parameters:
        LongStr: TChA const &
        MaxLen: int const

    TStrUtil_GetShorStr(TChA LongStr) -> TChA

    Parameters:
        LongStr: TChA const &

    """
  return _snap.TStrUtil_GetShorStr(*args)

def TStrUtil_GetCleanStr(*args):
  """
    TStrUtil_GetCleanStr(TChA ChA) -> TChA

    Parameters:
        ChA: TChA const &

    """
  return _snap.TStrUtil_GetCleanStr(*args)

def TStrUtil_GetCleanWrdStr(*args):
  """
    TStrUtil_GetCleanWrdStr(TChA ChA) -> TChA

    Parameters:
        ChA: TChA const &

    """
  return _snap.TStrUtil_GetCleanWrdStr(*args)

def TStrUtil_CountWords(*args):
  """
    CountWords(char const * CStr) -> int

    Parameters:
        CStr: char const *

    CountWords(TChA ChA) -> int

    Parameters:
        ChA: TChA const &

    TStrUtil_CountWords(TChA ChA, TStrHash< TInt > const & StopWordH) -> int

    Parameters:
        ChA: TChA const &
        StopWordH: TStrHash< TInt > const &

    """
  return _snap.TStrUtil_CountWords(*args)

def TStrUtil_SplitWords(*args):
  """
    SplitWords(TChA ChA, TVec< char * > & WrdV, bool const & SplitOnWs=True) -> int

    Parameters:
        ChA: TChA &
        WrdV: TVec< char * > &
        SplitOnWs: bool const &

    TStrUtil_SplitWords(TChA ChA, TVec< char * > & WrdV) -> int

    Parameters:
        ChA: TChA &
        WrdV: TVec< char * > &

    """
  return _snap.TStrUtil_SplitWords(*args)

def TStrUtil_SplitOnCh(*args):
  """
    SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch, bool const & SkipEmpty=False) -> int

    Parameters:
        ChA: TChA &
        WrdV: TVec< char * > &
        Ch: char const &
        SkipEmpty: bool const &

    TStrUtil_SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch) -> int

    Parameters:
        ChA: TChA &
        WrdV: TVec< char * > &
        Ch: char const &

    """
  return _snap.TStrUtil_SplitOnCh(*args)

def TStrUtil_SplitLines(*args):
  """
    SplitLines(TChA ChA, TVec< char * > & LineV, bool const & SkipEmpty=False) -> int

    Parameters:
        ChA: TChA &
        LineV: TVec< char * > &
        SkipEmpty: bool const &

    TStrUtil_SplitLines(TChA ChA, TVec< char * > & LineV) -> int

    Parameters:
        ChA: TChA &
        LineV: TVec< char * > &

    """
  return _snap.TStrUtil_SplitLines(*args)

def TStrUtil_SplitSentences(*args):
  """
    TStrUtil_SplitSentences(TChA ChA, TVec< char * > & SentenceV) -> int

    Parameters:
        ChA: TChA &
        SentenceV: TVec< char * > &

    """
  return _snap.TStrUtil_SplitSentences(*args)

def TStrUtil_RemoveHtmlTags(*args):
  """
    TStrUtil_RemoveHtmlTags(TChA HtmlStr, TChA TextStr)

    Parameters:
        HtmlStr: TChA const &
        TextStr: TChA &

    """
  return _snap.TStrUtil_RemoveHtmlTags(*args)

def TStrUtil_IsLatinStr(*args):
  """
    TStrUtil_IsLatinStr(TChA Str, double const & MinAlFrac) -> bool

    Parameters:
        Str: TChA const &
        MinAlFrac: double const &

    """
  return _snap.TStrUtil_IsLatinStr(*args)

def TStrUtil_GetWIdV(*args):
  """
    TStrUtil_GetWIdV(TStrHash< TInt > const & StrH, char const * CStr, TIntV WIdV)

    Parameters:
        StrH: TStrHash< TInt > const &
        CStr: char const *
        WIdV: TIntV &

    """
  return _snap.TStrUtil_GetWIdV(*args)

def TStrUtil_GetAddWIdV(*args):
  """
    TStrUtil_GetAddWIdV(TStrHash< TInt > & StrH, char const * CStr, TIntV WIdV)

    Parameters:
        StrH: TStrHash< TInt > &
        CStr: char const *
        WIdV: TIntV &

    """
  return _snap.TStrUtil_GetAddWIdV(*args)

def TStrUtil_GetTmFromStr(*args):
  """
    TStrUtil_GetTmFromStr(char const * TmStr, TSecTm & Tm) -> bool

    Parameters:
        TmStr: char const *
        Tm: TSecTm &

    """
  return _snap.TStrUtil_GetTmFromStr(*args)

def TStrUtil_GetStdName(*args):
  """
    TStrUtil_GetStdName(TStr AuthorName) -> TStr

    Parameters:
        AuthorName: TStr

    """
  return _snap.TStrUtil_GetStdName(*args)

def TStrUtil_GetStdNameV(*args):
  """
    TStrUtil_GetStdNameV(TStr AuthorNames, TStrV StdNameV)

    Parameters:
        AuthorNames: TStr
        StdNameV: TStrV &

    """
  return _snap.TStrUtil_GetStdNameV(*args)

class TRnd(object):
    """Proxy of C++ TRnd class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TRnd self, int const & _Seed=1, int const & Steps=0) -> TRnd

        Parameters:
            _Seed: int const &
            Steps: int const &

        __init__(TRnd self, int const & _Seed=1) -> TRnd

        Parameters:
            _Seed: int const &

        __init__(TRnd self) -> TRnd
        __init__(TRnd self, TSIn SIn) -> TRnd

        Parameters:
            SIn: TSIn &

        """
        _snap.TRnd_swiginit(self,_snap.new_TRnd(*args))
    def Save(self, *args):
        """
        Save(TRnd self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TRnd_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TRnd self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TRnd_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TRnd self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TRnd_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TRnd self, TRnd arg2) -> bool

        Parameters:
            arg2: TRnd const &

        """
        return _snap.TRnd___eq__(self, *args)

    def GetUniDev(self):
        """
        GetUniDev(TRnd self) -> double

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_GetUniDev(self)

    def GetUniDevInt(self, *args):
        """
        GetUniDevInt(TRnd self, int const & Range=0) -> int

        Parameters:
            Range: int const &

        GetUniDevInt(TRnd self) -> int
        GetUniDevInt(TRnd self, int const & MnVal, int const & MxVal) -> int

        Parameters:
            MnVal: int const &
            MxVal: int const &

        """
        return _snap.TRnd_GetUniDevInt(self, *args)

    def GetUniDevUInt(self, Range=0):
        """
        GetUniDevUInt(TRnd self, uint const & Range=0) -> uint

        Parameters:
            Range: uint const &

        GetUniDevUInt(TRnd self) -> uint

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_GetUniDevUInt(self, Range)

    def GetUniDevInt64(self, Range=0):
        """
        GetUniDevInt64(TRnd self, int64 const & Range=0) -> int64

        Parameters:
            Range: int64 const &

        GetUniDevInt64(TRnd self) -> int64

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_GetUniDevInt64(self, Range)

    def GetUniDevUInt64(self, Range=0):
        """
        GetUniDevUInt64(TRnd self, uint64 const & Range=0) -> uint64

        Parameters:
            Range: uint64 const &

        GetUniDevUInt64(TRnd self) -> uint64

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_GetUniDevUInt64(self, Range)

    def GetNrmDev(self, *args):
        """
        GetNrmDev(TRnd self) -> double
        GetNrmDev(TRnd self, double const & Mean, double const & SDev, double const & Mn, double const & Mx) -> double

        Parameters:
            Mean: double const &
            SDev: double const &
            Mn: double const &
            Mx: double const &

        """
        return _snap.TRnd_GetNrmDev(self, *args)

    def GetExpDev(self, *args):
        """
        GetExpDev(TRnd self) -> double
        GetExpDev(TRnd self, double const & Lambda) -> double

        Parameters:
            Lambda: double const &

        """
        return _snap.TRnd_GetExpDev(self, *args)

    def GetGammaDev(self, *args):
        """
        GetGammaDev(TRnd self, int const & Order) -> double

        Parameters:
            Order: int const &

        """
        return _snap.TRnd_GetGammaDev(self, *args)

    def GetPoissonDev(self, *args):
        """
        GetPoissonDev(TRnd self, double const & Mean) -> double

        Parameters:
            Mean: double const &

        """
        return _snap.TRnd_GetPoissonDev(self, *args)

    def GetBinomialDev(self, *args):
        """
        GetBinomialDev(TRnd self, double const & Prb, int const & Trials) -> double

        Parameters:
            Prb: double const &
            Trials: int const &

        """
        return _snap.TRnd_GetBinomialDev(self, *args)

    def GetGeoDev(self, *args):
        """
        GetGeoDev(TRnd self, double const & Prb) -> int

        Parameters:
            Prb: double const &

        """
        return _snap.TRnd_GetGeoDev(self, *args)

    def GetPowerDev(self, *args):
        """
        GetPowerDev(TRnd self, double const & AlphaSlope) -> double

        Parameters:
            AlphaSlope: double const &

        """
        return _snap.TRnd_GetPowerDev(self, *args)

    def GetRayleigh(self, *args):
        """
        GetRayleigh(TRnd self, double const & Sigma) -> double

        Parameters:
            Sigma: double const &

        """
        return _snap.TRnd_GetRayleigh(self, *args)

    def GetWeibull(self, *args):
        """
        GetWeibull(TRnd self, double const & K, double const & Lambda) -> double

        Parameters:
            K: double const &
            Lambda: double const &

        """
        return _snap.TRnd_GetWeibull(self, *args)

    def PutSeed(self, *args):
        """
        PutSeed(TRnd self, int const & _Seed)

        Parameters:
            _Seed: int const &

        """
        return _snap.TRnd_PutSeed(self, *args)

    def GetSeed(self):
        """
        GetSeed(TRnd self) -> int

        Parameters:
            self: TRnd const *

        """
        return _snap.TRnd_GetSeed(self)

    def Randomize(self):
        """
        Randomize(TRnd self)

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_Randomize(self)

    def Move(self, *args):
        """
        Move(TRnd self, int const & Steps)

        Parameters:
            Steps: int const &

        """
        return _snap.TRnd_Move(self, *args)

    def Check(self):
        """
        Check(TRnd self) -> bool

        Parameters:
            self: TRnd *

        """
        return _snap.TRnd_Check(self)

    def GetUniDevStep(*args):
        """
        GetUniDevStep(int const & Seed, int const & Steps) -> double

        Parameters:
            Seed: int const &
            Steps: int const &

        """
        return _snap.TRnd_GetUniDevStep(*args)

    GetUniDevStep = staticmethod(GetUniDevStep)
    def GetNrmDevStep(*args):
        """
        GetNrmDevStep(int const & Seed, int const & Steps) -> double

        Parameters:
            Seed: int const &
            Steps: int const &

        """
        return _snap.TRnd_GetNrmDevStep(*args)

    GetNrmDevStep = staticmethod(GetNrmDevStep)
    def GetExpDevStep(*args):
        """
        GetExpDevStep(int const & Seed, int const & Steps) -> double

        Parameters:
            Seed: int const &
            Steps: int const &

        """
        return _snap.TRnd_GetExpDevStep(*args)

    GetExpDevStep = staticmethod(GetExpDevStep)
    def LoadTxt(*args):
        """
        LoadTxt(TILx & Lx) -> TRnd

        Parameters:
            Lx: TILx &

        """
        return _snap.TRnd_LoadTxt(*args)

    LoadTxt = staticmethod(LoadTxt)
    def SaveTxt(self, *args):
        """
        SaveTxt(TRnd self, TOLx & Lx)

        Parameters:
            Lx: TOLx &

        """
        return _snap.TRnd_SaveTxt(self, *args)

    __swig_destroy__ = _snap.delete_TRnd
TRnd.Save = new_instancemethod(_snap.TRnd_Save,None,TRnd)
TRnd.LoadXml = new_instancemethod(_snap.TRnd_LoadXml,None,TRnd)
TRnd.SaveXml = new_instancemethod(_snap.TRnd_SaveXml,None,TRnd)
TRnd.__eq__ = new_instancemethod(_snap.TRnd___eq__,None,TRnd)
TRnd.GetUniDev = new_instancemethod(_snap.TRnd_GetUniDev,None,TRnd)
TRnd.GetUniDevInt = new_instancemethod(_snap.TRnd_GetUniDevInt,None,TRnd)
TRnd.GetUniDevUInt = new_instancemethod(_snap.TRnd_GetUniDevUInt,None,TRnd)
TRnd.GetUniDevInt64 = new_instancemethod(_snap.TRnd_GetUniDevInt64,None,TRnd)
TRnd.GetUniDevUInt64 = new_instancemethod(_snap.TRnd_GetUniDevUInt64,None,TRnd)
TRnd.GetNrmDev = new_instancemethod(_snap.TRnd_GetNrmDev,None,TRnd)
TRnd.GetExpDev = new_instancemethod(_snap.TRnd_GetExpDev,None,TRnd)
TRnd.GetGammaDev = new_instancemethod(_snap.TRnd_GetGammaDev,None,TRnd)
TRnd.GetPoissonDev = new_instancemethod(_snap.TRnd_GetPoissonDev,None,TRnd)
TRnd.GetBinomialDev = new_instancemethod(_snap.TRnd_GetBinomialDev,None,TRnd)
TRnd.GetGeoDev = new_instancemethod(_snap.TRnd_GetGeoDev,None,TRnd)
TRnd.GetPowerDev = new_instancemethod(_snap.TRnd_GetPowerDev,None,TRnd)
TRnd.GetRayleigh = new_instancemethod(_snap.TRnd_GetRayleigh,None,TRnd)
TRnd.GetWeibull = new_instancemethod(_snap.TRnd_GetWeibull,None,TRnd)
TRnd.PutSeed = new_instancemethod(_snap.TRnd_PutSeed,None,TRnd)
TRnd.GetSeed = new_instancemethod(_snap.TRnd_GetSeed,None,TRnd)
TRnd.Randomize = new_instancemethod(_snap.TRnd_Randomize,None,TRnd)
TRnd.Move = new_instancemethod(_snap.TRnd_Move,None,TRnd)
TRnd.Check = new_instancemethod(_snap.TRnd_Check,None,TRnd)
TRnd.SaveTxt = new_instancemethod(_snap.TRnd_SaveTxt,None,TRnd)
TRnd_swigregister = _snap.TRnd_swigregister
TRnd_swigregister(TRnd)
TRnd.RndSeed = _snap.cvar.TRnd_RndSeed

def TRnd_GetUniDevStep(*args):
  """
    TRnd_GetUniDevStep(int const & Seed, int const & Steps) -> double

    Parameters:
        Seed: int const &
        Steps: int const &

    """
  return _snap.TRnd_GetUniDevStep(*args)

def TRnd_GetNrmDevStep(*args):
  """
    TRnd_GetNrmDevStep(int const & Seed, int const & Steps) -> double

    Parameters:
        Seed: int const &
        Steps: int const &

    """
  return _snap.TRnd_GetNrmDevStep(*args)

def TRnd_GetExpDevStep(*args):
  """
    TRnd_GetExpDevStep(int const & Seed, int const & Steps) -> double

    Parameters:
        Seed: int const &
        Steps: int const &

    """
  return _snap.TRnd_GetExpDevStep(*args)

def TRnd_LoadTxt(*args):
  """
    TRnd_LoadTxt(TILx & Lx) -> TRnd

    Parameters:
        Lx: TILx &

    """
  return _snap.TRnd_LoadTxt(*args)

class TMem(object):
    """Proxy of C++ TMem class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def New(*args):
        """
        New(int const & MxBfL=0) -> PMem

        Parameters:
            MxBfL: int const &

        New() -> PMem
        New(void const * Bf, int const & BfL) -> PMem

        Parameters:
            Bf: void const *
            BfL: int const &

        New(TMem Mem) -> PMem

        Parameters:
            Mem: TMem const &

        New(PMem const & Mem) -> PMem

        Parameters:
            Mem: PMem const &

        New(TStr Str) -> PMem

        Parameters:
            Str: TStr const &

        """
        return _snap.TMem_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TMem
    def __init__(self, *args): 
        """
        __init__(TMem self, int const & _MxBfL=0) -> TMem

        Parameters:
            _MxBfL: int const &

        __init__(TMem self) -> TMem
        __init__(TMem self, void const * _Bf, int const & _BfL) -> TMem

        Parameters:
            _Bf: void const *
            _BfL: int const &

        __init__(TMem self, TMem Mem) -> TMem

        Parameters:
            Mem: TMem const &

        __init__(TMem self, TStr Str) -> TMem

        Parameters:
            Str: TStr const &

        __init__(TMem self, TSIn SIn) -> TMem

        Parameters:
            SIn: TSIn &

        """
        _snap.TMem_swiginit(self,_snap.new_TMem(*args))
    def Save(self, *args):
        """
        Save(TMem self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TMem_Save(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TMem self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TMem_SaveXml(self, *args)

    def __call__(self):
        """
        __call__(TMem self) -> char *

        Parameters:
            self: TMem const *

        """
        return _snap.TMem___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TMem self, char const & Ch) -> TMem

        Parameters:
            Ch: char const &

        __iadd__(TMem self, TMem Mem) -> TMem

        Parameters:
            Mem: TMem const &

        __iadd__(TMem self, TStr Str) -> TMem

        Parameters:
            Str: TStr const &

        __iadd__(TMem self, PSIn const & SIn) -> TMem

        Parameters:
            SIn: PSIn const &

        """
        return _snap.TMem___iadd__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TMem self) -> int

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_GetMemUsed(self)

    def Gen(self, *args):
        """
        Gen(TMem self, int const & _BfL)

        Parameters:
            _BfL: int const &

        """
        return _snap.TMem_Gen(self, *args)

    def GenZeros(self, *args):
        """
        GenZeros(TMem self, int const & _BfL)

        Parameters:
            _BfL: int const &

        """
        return _snap.TMem_GenZeros(self, *args)

    def Reserve(self, *args):
        """
        Reserve(TMem self, int const & _MxBfL, bool const & DoClr=True)

        Parameters:
            _MxBfL: int const &
            DoClr: bool const &

        Reserve(TMem self, int const & _MxBfL)

        Parameters:
            _MxBfL: int const &

        """
        return _snap.TMem_Reserve(self, *args)

    def Del(self, *args):
        """
        Del(TMem self, int const & BChN, int const & EChN)

        Parameters:
            BChN: int const &
            EChN: int const &

        """
        return _snap.TMem_Del(self, *args)

    def Clr(self, DoDel=True):
        """
        Clr(TMem self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TMem self)

        Parameters:
            self: TMem *

        """
        return _snap.TMem_Clr(self, DoDel)

    def Len(self):
        """
        Len(TMem self) -> int

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_Len(self)

    def Empty(self):
        """
        Empty(TMem self) -> bool

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_Empty(self)

    def Trunc(self, *args):
        """
        Trunc(TMem self, int const & _BfL)

        Parameters:
            _BfL: int const &

        """
        return _snap.TMem_Trunc(self, *args)

    def Push(self, *args):
        """
        Push(TMem self, char const & Ch)

        Parameters:
            Ch: char const &

        """
        return _snap.TMem_Push(self, *args)

    def Pop(self):
        """
        Pop(TMem self) -> char

        Parameters:
            self: TMem *

        """
        return _snap.TMem_Pop(self)

    def DoFitStr(self, *args):
        """
        DoFitStr(TMem self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TMem_DoFitStr(self, *args)

    def AddBf(self, *args):
        """
        AddBf(TMem self, void const * Bf, int const & BfL)

        Parameters:
            Bf: void const *
            BfL: int const &

        """
        return _snap.TMem_AddBf(self, *args)

    def GetBf(self):
        """
        GetBf(TMem self) -> char *

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_GetBf(self)

    def GetAsStr(self, NewNullCh='\0'):
        """
        GetAsStr(TMem self, char const & NewNullCh='\0') -> TStr

        Parameters:
            NewNullCh: char const &

        GetAsStr(TMem self) -> TStr

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_GetAsStr(self, NewNullCh)

    def GetSIn(self):
        """
        GetSIn(TMem self) -> PSIn

        Parameters:
            self: TMem const *

        """
        return _snap.TMem_GetSIn(self)

    def LoadMem(*args):
        """
        LoadMem(PSIn const & SIn, TMem Mem)

        Parameters:
            SIn: PSIn const &
            Mem: TMem &

        LoadMem(PSIn const & SIn, PMem const & Mem)

        Parameters:
            SIn: PSIn const &
            Mem: PMem const &

        """
        return _snap.TMem_LoadMem(*args)

    LoadMem = staticmethod(LoadMem)
    def SaveMem(self, *args):
        """
        SaveMem(TMem self, PSOut const & SOut)

        Parameters:
            SOut: PSOut const &

        """
        return _snap.TMem_SaveMem(self, *args)

TMem.Save = new_instancemethod(_snap.TMem_Save,None,TMem)
TMem.SaveXml = new_instancemethod(_snap.TMem_SaveXml,None,TMem)
TMem.__call__ = new_instancemethod(_snap.TMem___call__,None,TMem)
TMem.__iadd__ = new_instancemethod(_snap.TMem___iadd__,None,TMem)
TMem.GetMemUsed = new_instancemethod(_snap.TMem_GetMemUsed,None,TMem)
TMem.Gen = new_instancemethod(_snap.TMem_Gen,None,TMem)
TMem.GenZeros = new_instancemethod(_snap.TMem_GenZeros,None,TMem)
TMem.Reserve = new_instancemethod(_snap.TMem_Reserve,None,TMem)
TMem.Del = new_instancemethod(_snap.TMem_Del,None,TMem)
TMem.Clr = new_instancemethod(_snap.TMem_Clr,None,TMem)
TMem.Len = new_instancemethod(_snap.TMem_Len,None,TMem)
TMem.Empty = new_instancemethod(_snap.TMem_Empty,None,TMem)
TMem.Trunc = new_instancemethod(_snap.TMem_Trunc,None,TMem)
TMem.Push = new_instancemethod(_snap.TMem_Push,None,TMem)
TMem.Pop = new_instancemethod(_snap.TMem_Pop,None,TMem)
TMem.DoFitStr = new_instancemethod(_snap.TMem_DoFitStr,None,TMem)
TMem.AddBf = new_instancemethod(_snap.TMem_AddBf,None,TMem)
TMem.GetBf = new_instancemethod(_snap.TMem_GetBf,None,TMem)
TMem.GetAsStr = new_instancemethod(_snap.TMem_GetAsStr,None,TMem)
TMem.GetSIn = new_instancemethod(_snap.TMem_GetSIn,None,TMem)
TMem.SaveMem = new_instancemethod(_snap.TMem_SaveMem,None,TMem)
TMem_swigregister = _snap.TMem_swigregister
TMem_swigregister(TMem)

def TMem_New(*args):
  """
    New(int const & MxBfL=0) -> PMem

    Parameters:
        MxBfL: int const &

    New() -> PMem
    New(void const * Bf, int const & BfL) -> PMem

    Parameters:
        Bf: void const *
        BfL: int const &

    New(TMem Mem) -> PMem

    Parameters:
        Mem: TMem const &

    New(PMem const & Mem) -> PMem

    Parameters:
        Mem: PMem const &

    TMem_New(TStr Str) -> PMem

    Parameters:
        Str: TStr const &

    """
  return _snap.TMem_New(*args)

def TMem_LoadMem(*args):
  """
    LoadMem(PSIn const & SIn, TMem Mem)

    Parameters:
        SIn: PSIn const &
        Mem: TMem &

    TMem_LoadMem(PSIn const & SIn, PMem const & Mem)

    Parameters:
        SIn: PSIn const &
        Mem: PMem const &

    """
  return _snap.TMem_LoadMem(*args)

class TMemIn(TSIn):
    """Proxy of C++ TMemIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TMemIn self, TMem _Mem, int const & _BfC=0) -> TMemIn

        Parameters:
            _Mem: TMem const &
            _BfC: int const &

        __init__(TMemIn self, TMem _Mem) -> TMemIn

        Parameters:
            _Mem: TMem const &

        """
        _snap.TMemIn_swiginit(self,_snap.new_TMemIn(*args))
    def New(*args):
        """
        New(TMem Mem) -> PSIn

        Parameters:
            Mem: TMem const &

        New(PMem const & Mem) -> PSIn

        Parameters:
            Mem: PMem const &

        """
        return _snap.TMemIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TMemIn
TMemIn_swigregister = _snap.TMemIn_swigregister
TMemIn_swigregister(TMemIn)

def TMemIn_New(*args):
  """
    New(TMem Mem) -> PSIn

    Parameters:
        Mem: TMem const &

    TMemIn_New(PMem const & Mem) -> PSIn

    Parameters:
        Mem: PMem const &

    """
  return _snap.TMemIn_New(*args)

class TMemOut(TSOut):
    """Proxy of C++ TMemOut class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TMemOut self, PMem const & _Mem) -> TMemOut

        Parameters:
            _Mem: PMem const &

        """
        _snap.TMemOut_swiginit(self,_snap.new_TMemOut(*args))
    def New(*args):
        """
        New(PMem const & Mem) -> PSOut

        Parameters:
            Mem: PMem const &

        """
        return _snap.TMemOut_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TMemOut
TMemOut_swigregister = _snap.TMemOut_swigregister
TMemOut_swigregister(TMemOut)

def TMemOut_New(*args):
  """
    TMemOut_New(PMem const & Mem) -> PSOut

    Parameters:
        Mem: PMem const &

    """
  return _snap.TMemOut_New(*args)

class TChA(object):
    """Proxy of C++ TChA class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TChA
    def __init__(self, *args): 
        """
        __init__(TChA self, int const & _MxBfL=256) -> TChA

        Parameters:
            _MxBfL: int const &

        __init__(TChA self) -> TChA
        __init__(TChA self, char const * CStr) -> TChA

        Parameters:
            CStr: char const *

        __init__(TChA self, char const * CStr, int const & StrLen) -> TChA

        Parameters:
            CStr: char const *
            StrLen: int const &

        __init__(TChA self, TChA ChA) -> TChA

        Parameters:
            ChA: TChA const &

        __init__(TChA self, TStr Str) -> TChA

        Parameters:
            Str: TStr const &

        __init__(TChA self, TMem Mem) -> TChA

        Parameters:
            Mem: TMem const &

        __init__(TChA self, TSIn SIn) -> TChA

        Parameters:
            SIn: TSIn &

        """
        _snap.TChA_swiginit(self,_snap.new_TChA(*args))
    def Load(self, *args):
        """
        Load(TChA self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TChA_Load(self, *args)

    def Save(self, *args):
        """
        Save(TChA self, TSOut SOut, bool const & SaveCompact=True)

        Parameters:
            SOut: TSOut &
            SaveCompact: bool const &

        Save(TChA self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TChA_Save(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TChA self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TChA_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TChA self, TChA ChA) -> bool

        Parameters:
            ChA: TChA const &

        __eq__(TChA self, char const * _CStr) -> bool

        Parameters:
            _CStr: char const *

        __eq__(TChA self, char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TChA___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TChA self, TChA ChA) -> bool

        Parameters:
            ChA: TChA const &

        __ne__(TChA self, char const * _CStr) -> bool

        Parameters:
            _CStr: char const *

        __ne__(TChA self, char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TChA___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TChA self, TChA ChA) -> bool

        Parameters:
            ChA: TChA const &

        """
        return _snap.TChA___lt__(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(TChA self, TMem Mem) -> TChA

        Parameters:
            Mem: TMem const &

        __iadd__(TChA self, TChA ChA) -> TChA

        Parameters:
            ChA: TChA const &

        __iadd__(TChA self, TStr Str) -> TChA

        Parameters:
            Str: TStr const &

        __iadd__(TChA self, char const * CStr) -> TChA

        Parameters:
            CStr: char const *

        __iadd__(TChA self, char const & Ch) -> TChA

        Parameters:
            Ch: char const &

        """
        return _snap.TChA___iadd__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TChA self) -> int

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_GetMemUsed(self)

    def __call__(self, *args):
        """
        __call__(TChA self) -> char
        __call__(TChA self) -> char const *

        Parameters:
            self: TChA const *

        """
        return _snap.TChA___call__(self, *args)

    def CStr(self, *args):
        """
        CStr(TChA self) -> char
        CStr(TChA self) -> char const *

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_CStr(self, *args)

    def Clr(self):
        """
        Clr(TChA self)

        Parameters:
            self: TChA *

        """
        return _snap.TChA_Clr(self)

    def Len(self):
        """
        Len(TChA self) -> int

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_Len(self)

    def Empty(self):
        """
        Empty(TChA self) -> bool

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_Empty(self)

    def Ins(self, *args):
        """
        Ins(TChA self, int const & BChN, char const * CStr)

        Parameters:
            BChN: int const &
            CStr: char const *

        """
        return _snap.TChA_Ins(self, *args)

    def Del(self, *args):
        """
        Del(TChA self, int const & ChN)

        Parameters:
            ChN: int const &

        """
        return _snap.TChA_Del(self, *args)

    def DelLastCh(self):
        """
        DelLastCh(TChA self)

        Parameters:
            self: TChA *

        """
        return _snap.TChA_DelLastCh(self)

    def Push(self, *args):
        """
        Push(TChA self, char const & Ch)

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_Push(self, *args)

    def Pop(self):
        """
        Pop(TChA self) -> char

        Parameters:
            self: TChA *

        """
        return _snap.TChA_Pop(self)

    def Trunc(self, *args):
        """
        Trunc(TChA self)
        Trunc(TChA self, int const & _BfL)

        Parameters:
            _BfL: int const &

        """
        return _snap.TChA_Trunc(self, *args)

    def Reverse(self):
        """
        Reverse(TChA self)

        Parameters:
            self: TChA *

        """
        return _snap.TChA_Reverse(self)

    def AddCh(self, *args):
        """
        AddCh(TChA self, char const & Ch, int const & MxLen=-1)

        Parameters:
            Ch: char const &
            MxLen: int const &

        AddCh(TChA self, char const & Ch)

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_AddCh(self, *args)

    def AddChTo(self, *args):
        """
        AddChTo(TChA self, char const & Ch, int const & ToChN)

        Parameters:
            Ch: char const &
            ToChN: int const &

        """
        return _snap.TChA_AddChTo(self, *args)

    def AddBf(self, *args):
        """
        AddBf(TChA self, char * NewBf, int const & BfS)

        Parameters:
            NewBf: char *
            BfS: int const &

        """
        return _snap.TChA_AddBf(self, *args)

    def PutCh(self, *args):
        """
        PutCh(TChA self, int const & ChN, char const & Ch)

        Parameters:
            ChN: int const &
            Ch: char const &

        """
        return _snap.TChA_PutCh(self, *args)

    def GetCh(self, *args):
        """
        GetCh(TChA self, int const & ChN) -> char

        Parameters:
            ChN: int const &

        """
        return _snap.TChA_GetCh(self, *args)

    def LastCh(self):
        """
        LastCh(TChA self) -> char

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_LastCh(self)

    def LastLastCh(self):
        """
        LastLastCh(TChA self) -> char

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_LastLastCh(self)

    def GetSubStr(self, *args):
        """
        GetSubStr(TChA self, int const & BChN, int const & EChN) -> TChA

        Parameters:
            BChN: int const &
            EChN: int const &

        """
        return _snap.TChA_GetSubStr(self, *args)

    def CountCh(self, *args):
        """
        CountCh(TChA self, char const & Ch, int const & BChN=0) -> int

        Parameters:
            Ch: char const &
            BChN: int const &

        CountCh(TChA self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_CountCh(self, *args)

    def SearchCh(self, *args):
        """
        SearchCh(TChA self, char const & Ch, int const & BChN=0) -> int

        Parameters:
            Ch: char const &
            BChN: int const &

        SearchCh(TChA self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_SearchCh(self, *args)

    def SearchChBack(self, *args):
        """
        SearchChBack(TChA self, char const & Ch, int BChN=-1) -> int

        Parameters:
            Ch: char const &
            BChN: int

        SearchChBack(TChA self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_SearchChBack(self, *args)

    def SearchStr(self, *args):
        """
        SearchStr(TChA self, TChA Str, int const & BChN=0) -> int

        Parameters:
            Str: TChA const &
            BChN: int const &

        SearchStr(TChA self, TChA Str) -> int

        Parameters:
            Str: TChA const &

        SearchStr(TChA self, TStr Str, int const & BChN=0) -> int

        Parameters:
            Str: TStr const &
            BChN: int const &

        SearchStr(TChA self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        SearchStr(TChA self, char const * CStr, int const & BChN=0) -> int

        Parameters:
            CStr: char const *
            BChN: int const &

        SearchStr(TChA self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        """
        return _snap.TChA_SearchStr(self, *args)

    def IsStrIn(self, *args):
        """
        IsStrIn(TChA self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TChA_IsStrIn(self, *args)

    def IsPrefix(self, *args):
        """
        IsPrefix(TChA self, char const * CStr, int const & BChN=0) -> bool

        Parameters:
            CStr: char const *
            BChN: int const &

        IsPrefix(TChA self, char const * CStr) -> bool

        Parameters:
            CStr: char const *

        IsPrefix(TChA self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        IsPrefix(TChA self, TChA Str) -> bool

        Parameters:
            Str: TChA const &

        """
        return _snap.TChA_IsPrefix(self, *args)

    def IsSuffix(self, *args):
        """
        IsSuffix(TChA self, char const * CStr) -> bool

        Parameters:
            CStr: char const *

        IsSuffix(TChA self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        IsSuffix(TChA self, TChA Str) -> bool

        Parameters:
            Str: TChA const &

        """
        return _snap.TChA_IsSuffix(self, *args)

    def IsChIn(self, *args):
        """
        IsChIn(TChA self, char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TChA_IsChIn(self, *args)

    def ChangeCh(self, *args):
        """
        ChangeCh(TChA self, char const & SrcCh, char const & DstCh)

        Parameters:
            SrcCh: char const &
            DstCh: char const &

        """
        return _snap.TChA_ChangeCh(self, *args)

    def ToUc(self):
        """
        ToUc(TChA self) -> TChA

        Parameters:
            self: TChA *

        """
        return _snap.TChA_ToUc(self)

    def ToLc(self):
        """
        ToLc(TChA self) -> TChA

        Parameters:
            self: TChA *

        """
        return _snap.TChA_ToLc(self)

    def ToTrunc(self):
        """
        ToTrunc(TChA self) -> TChA

        Parameters:
            self: TChA *

        """
        return _snap.TChA_ToTrunc(self)

    def CompressWs(self):
        """
        CompressWs(TChA self)

        Parameters:
            self: TChA *

        """
        return _snap.TChA_CompressWs(self)

    def Swap(self, *args):
        """
        Swap(TChA self, int const & ChN1, int const & ChN2)

        Parameters:
            ChN1: int const &
            ChN2: int const &

        Swap(TChA self, TChA ChA)

        Parameters:
            ChA: TChA &

        """
        return _snap.TChA_Swap(self, *args)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TChA self) -> int

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TChA self) -> int

        Parameters:
            self: TChA const *

        """
        return _snap.TChA_GetSecHashCd(self)

    def LoadTxt(*args):
        """
        LoadTxt(PSIn const & SIn, TChA ChA)

        Parameters:
            SIn: PSIn const &
            ChA: TChA &

        """
        return _snap.TChA_LoadTxt(*args)

    LoadTxt = staticmethod(LoadTxt)
    def SaveTxt(self, *args):
        """
        SaveTxt(TChA self, PSOut const & SOut)

        Parameters:
            SOut: PSOut const &

        """
        return _snap.TChA_SaveTxt(self, *args)

TChA.Load = new_instancemethod(_snap.TChA_Load,None,TChA)
TChA.Save = new_instancemethod(_snap.TChA_Save,None,TChA)
TChA.SaveXml = new_instancemethod(_snap.TChA_SaveXml,None,TChA)
TChA.__eq__ = new_instancemethod(_snap.TChA___eq__,None,TChA)
TChA.__ne__ = new_instancemethod(_snap.TChA___ne__,None,TChA)
TChA.__lt__ = new_instancemethod(_snap.TChA___lt__,None,TChA)
TChA.__iadd__ = new_instancemethod(_snap.TChA___iadd__,None,TChA)
TChA.GetMemUsed = new_instancemethod(_snap.TChA_GetMemUsed,None,TChA)
TChA.__call__ = new_instancemethod(_snap.TChA___call__,None,TChA)
TChA.CStr = new_instancemethod(_snap.TChA_CStr,None,TChA)
TChA.Clr = new_instancemethod(_snap.TChA_Clr,None,TChA)
TChA.Len = new_instancemethod(_snap.TChA_Len,None,TChA)
TChA.Empty = new_instancemethod(_snap.TChA_Empty,None,TChA)
TChA.Ins = new_instancemethod(_snap.TChA_Ins,None,TChA)
TChA.Del = new_instancemethod(_snap.TChA_Del,None,TChA)
TChA.DelLastCh = new_instancemethod(_snap.TChA_DelLastCh,None,TChA)
TChA.Push = new_instancemethod(_snap.TChA_Push,None,TChA)
TChA.Pop = new_instancemethod(_snap.TChA_Pop,None,TChA)
TChA.Trunc = new_instancemethod(_snap.TChA_Trunc,None,TChA)
TChA.Reverse = new_instancemethod(_snap.TChA_Reverse,None,TChA)
TChA.AddCh = new_instancemethod(_snap.TChA_AddCh,None,TChA)
TChA.AddChTo = new_instancemethod(_snap.TChA_AddChTo,None,TChA)
TChA.AddBf = new_instancemethod(_snap.TChA_AddBf,None,TChA)
TChA.PutCh = new_instancemethod(_snap.TChA_PutCh,None,TChA)
TChA.GetCh = new_instancemethod(_snap.TChA_GetCh,None,TChA)
TChA.LastCh = new_instancemethod(_snap.TChA_LastCh,None,TChA)
TChA.LastLastCh = new_instancemethod(_snap.TChA_LastLastCh,None,TChA)
TChA.GetSubStr = new_instancemethod(_snap.TChA_GetSubStr,None,TChA)
TChA.CountCh = new_instancemethod(_snap.TChA_CountCh,None,TChA)
TChA.SearchCh = new_instancemethod(_snap.TChA_SearchCh,None,TChA)
TChA.SearchChBack = new_instancemethod(_snap.TChA_SearchChBack,None,TChA)
TChA.SearchStr = new_instancemethod(_snap.TChA_SearchStr,None,TChA)
TChA.IsStrIn = new_instancemethod(_snap.TChA_IsStrIn,None,TChA)
TChA.IsPrefix = new_instancemethod(_snap.TChA_IsPrefix,None,TChA)
TChA.IsSuffix = new_instancemethod(_snap.TChA_IsSuffix,None,TChA)
TChA.IsChIn = new_instancemethod(_snap.TChA_IsChIn,None,TChA)
TChA.ChangeCh = new_instancemethod(_snap.TChA_ChangeCh,None,TChA)
TChA.ToUc = new_instancemethod(_snap.TChA_ToUc,None,TChA)
TChA.ToLc = new_instancemethod(_snap.TChA_ToLc,None,TChA)
TChA.ToTrunc = new_instancemethod(_snap.TChA_ToTrunc,None,TChA)
TChA.CompressWs = new_instancemethod(_snap.TChA_CompressWs,None,TChA)
TChA.Swap = new_instancemethod(_snap.TChA_Swap,None,TChA)
TChA.GetPrimHashCd = new_instancemethod(_snap.TChA_GetPrimHashCd,None,TChA)
TChA.GetSecHashCd = new_instancemethod(_snap.TChA_GetSecHashCd,None,TChA)
TChA.SaveTxt = new_instancemethod(_snap.TChA_SaveTxt,None,TChA)
TChA_swigregister = _snap.TChA_swigregister
TChA_swigregister(TChA)

def TChA_LoadTxt(*args):
  """
    TChA_LoadTxt(PSIn const & SIn, TChA ChA)

    Parameters:
        SIn: PSIn const &
        ChA: TChA &

    """
  return _snap.TChA_LoadTxt(*args)

class TChAIn(TSIn):
    """Proxy of C++ TChAIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TChAIn self, TChA ChA, int const & _BfC=0) -> TChAIn

        Parameters:
            ChA: TChA const &
            _BfC: int const &

        __init__(TChAIn self, TChA ChA) -> TChAIn

        Parameters:
            ChA: TChA const &

        """
        _snap.TChAIn_swiginit(self,_snap.new_TChAIn(*args))
    def New(*args):
        """
        New(TChA ChA) -> PSIn

        Parameters:
            ChA: TChA const &

        """
        return _snap.TChAIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TChAIn
TChAIn_swigregister = _snap.TChAIn_swigregister
TChAIn_swigregister(TChAIn)

def TChAIn_New(*args):
  """
    TChAIn_New(TChA ChA) -> PSIn

    Parameters:
        ChA: TChA const &

    """
  return _snap.TChAIn_New(*args)

class TRStr(object):
    """Proxy of C++ TRStr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Bf = _swig_property(_snap.TRStr_Bf_get, _snap.TRStr_Bf_set)
    Refs = _swig_property(_snap.TRStr_Refs_get, _snap.TRStr_Refs_set)
    __swig_destroy__ = _snap.delete_TRStr
    def __init__(self, *args): 
        """
        __init__(TRStr self) -> TRStr
        __init__(TRStr self, int const & Len) -> TRStr

        Parameters:
            Len: int const &

        __init__(TRStr self, char const * CStr) -> TRStr

        Parameters:
            CStr: char const *

        __init__(TRStr self, char const * CStr, int const & MxLen) -> TRStr

        Parameters:
            CStr: char const *
            MxLen: int const &

        __init__(TRStr self, char const * CStr1, char const * CStr2) -> TRStr

        Parameters:
            CStr1: char const *
            CStr2: char const *

        __init__(TRStr self, char const & Ch) -> TRStr

        Parameters:
            Ch: char const &

        __init__(TRStr self, char const & Ch1, char const & Ch2) -> TRStr

        Parameters:
            Ch1: char const &
            Ch2: char const &

        __init__(TRStr self, TSIn SIn, bool const & IsSmall) -> TRStr

        Parameters:
            SIn: TSIn &
            IsSmall: bool const &

        """
        _snap.TRStr_swiginit(self,_snap.new_TRStr(*args))
    def Save(self, *args):
        """
        Save(TRStr self, TSOut SOut, bool const & IsSmall)

        Parameters:
            SOut: TSOut &
            IsSmall: bool const &

        """
        return _snap.TRStr_Save(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TRStr self) -> int

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_GetMemUsed(self)

    def MkRef(self):
        """
        MkRef(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_MkRef(self)

    def UnRef(self):
        """
        UnRef(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_UnRef(self)

    def CStr(self, *args):
        """
        CStr(TRStr self) -> char const
        CStr(TRStr self) -> char *

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_CStr(self, *args)

    def Empty(self):
        """
        Empty(TRStr self) -> bool

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_Empty(self)

    def Len(self):
        """
        Len(TRStr self) -> int

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_Len(self)

    def PutCh(self, *args):
        """
        PutCh(TRStr self, int const & ChN, char const & Ch)

        Parameters:
            ChN: int const &
            Ch: char const &

        """
        return _snap.TRStr_PutCh(self, *args)

    def GetCh(self, *args):
        """
        GetCh(TRStr self, int const & ChN) -> char

        Parameters:
            ChN: int const &

        """
        return _snap.TRStr_GetCh(self, *args)

    def IsUc(self):
        """
        IsUc(TRStr self) -> bool

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_IsUc(self)

    def ToUc(self):
        """
        ToUc(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_ToUc(self)

    def IsLc(self):
        """
        IsLc(TRStr self) -> bool

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_IsLc(self)

    def ToLc(self):
        """
        ToLc(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_ToLc(self)

    def ToCap(self):
        """
        ToCap(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_ToCap(self)

    def ConvUsFromYuAscii(self):
        """
        ConvUsFromYuAscii(TRStr self)

        Parameters:
            self: TRStr *

        """
        return _snap.TRStr_ConvUsFromYuAscii(self)

    def CmpI(*args):
        """
        CmpI(char const * CStr1, char const * CStr2) -> int

        Parameters:
            CStr1: char const *
            CStr2: char const *

        """
        return _snap.TRStr_CmpI(*args)

    CmpI = staticmethod(CmpI)
    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TRStr self) -> int

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TRStr self) -> int

        Parameters:
            self: TRStr const *

        """
        return _snap.TRStr_GetSecHashCd(self)

    def GetNullRStr():
        """GetNullRStr() -> TRStr"""
        return _snap.TRStr_GetNullRStr()

    GetNullRStr = staticmethod(GetNullRStr)
TRStr.Save = new_instancemethod(_snap.TRStr_Save,None,TRStr)
TRStr.GetMemUsed = new_instancemethod(_snap.TRStr_GetMemUsed,None,TRStr)
TRStr.MkRef = new_instancemethod(_snap.TRStr_MkRef,None,TRStr)
TRStr.UnRef = new_instancemethod(_snap.TRStr_UnRef,None,TRStr)
TRStr.CStr = new_instancemethod(_snap.TRStr_CStr,None,TRStr)
TRStr.Empty = new_instancemethod(_snap.TRStr_Empty,None,TRStr)
TRStr.Len = new_instancemethod(_snap.TRStr_Len,None,TRStr)
TRStr.PutCh = new_instancemethod(_snap.TRStr_PutCh,None,TRStr)
TRStr.GetCh = new_instancemethod(_snap.TRStr_GetCh,None,TRStr)
TRStr.IsUc = new_instancemethod(_snap.TRStr_IsUc,None,TRStr)
TRStr.ToUc = new_instancemethod(_snap.TRStr_ToUc,None,TRStr)
TRStr.IsLc = new_instancemethod(_snap.TRStr_IsLc,None,TRStr)
TRStr.ToLc = new_instancemethod(_snap.TRStr_ToLc,None,TRStr)
TRStr.ToCap = new_instancemethod(_snap.TRStr_ToCap,None,TRStr)
TRStr.ConvUsFromYuAscii = new_instancemethod(_snap.TRStr_ConvUsFromYuAscii,None,TRStr)
TRStr.GetPrimHashCd = new_instancemethod(_snap.TRStr_GetPrimHashCd,None,TRStr)
TRStr.GetSecHashCd = new_instancemethod(_snap.TRStr_GetSecHashCd,None,TRStr)
TRStr_swigregister = _snap.TRStr_swigregister
TRStr_swigregister(TRStr)

def TRStr_CmpI(*args):
  """
    TRStr_CmpI(char const * CStr1, char const * CStr2) -> int

    Parameters:
        CStr1: char const *
        CStr2: char const *

    """
  return _snap.TRStr_CmpI(*args)

def TRStr_GetNullRStr():
  """TRStr_GetNullRStr() -> TRStr"""
  return _snap.TRStr_GetNullRStr()

class TStr(object):
    """Proxy of C++ TStr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TStr
    def __init__(self, *args): 
        """
        __init__(TStr self) -> TStr
        __init__(TStr self, TStr Str) -> TStr

        Parameters:
            Str: TStr const &

        __init__(TStr self, TChA ChA) -> TStr

        Parameters:
            ChA: TChA const &

        __init__(TStr self, TSStr SStr) -> TStr

        Parameters:
            SStr: TSStr const &

        __init__(TStr self, char const * CStr) -> TStr

        Parameters:
            CStr: char const *

        __init__(TStr self, char const & Ch) -> TStr

        Parameters:
            Ch: char const &

        __init__(TStr self, TMem Mem) -> TStr

        Parameters:
            Mem: TMem const &

        __init__(TStr self, PSIn const & SIn) -> TStr

        Parameters:
            SIn: PSIn const &

        __init__(TStr self, TSIn SIn, bool const & IsSmall=False) -> TStr

        Parameters:
            SIn: TSIn &
            IsSmall: bool const &

        __init__(TStr self, TSIn SIn) -> TStr

        Parameters:
            SIn: TSIn &

        """
        _snap.TStr_swiginit(self,_snap.new_TStr(*args))
    def Load(self, *args):
        """
        Load(TStr self, TSIn SIn, bool const & IsSmall=False)

        Parameters:
            SIn: TSIn &
            IsSmall: bool const &

        Load(TStr self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TStr_Load(self, *args)

    def Save(self, *args):
        """
        Save(TStr self, TSOut SOut, bool const & IsSmall=False)

        Parameters:
            SOut: TSOut &
            IsSmall: bool const &

        Save(TStr self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TStr_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TStr self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TStr_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TStr self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TStr_SaveXml(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(TStr self, TStr Str) -> TStr

        Parameters:
            Str: TStr const &

        __iadd__(TStr self, char const * CStr) -> TStr

        Parameters:
            CStr: char const *

        """
        return _snap.TStr___iadd__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        __eq__(TStr self, char const * CStr) -> bool

        Parameters:
            CStr: char const *

        """
        return _snap.TStr___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TStr self, char const * CStr) -> bool

        Parameters:
            CStr: char const *

        """
        return _snap.TStr___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TStr self) -> int

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetMemUsed(self)

    def CStr(self, *args):
        """
        CStr(TStr self) -> char
        CStr(TStr self) -> char const *

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_CStr(self, *args)

    def PutCh(self, *args):
        """
        PutCh(TStr self, int const & ChN, char const & Ch)

        Parameters:
            ChN: int const &
            Ch: char const &

        """
        return _snap.TStr_PutCh(self, *args)

    def GetCh(self, *args):
        """
        GetCh(TStr self, int const & ChN) -> char

        Parameters:
            ChN: int const &

        """
        return _snap.TStr_GetCh(self, *args)

    def LastCh(self):
        """
        LastCh(TStr self) -> char

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_LastCh(self)

    def Clr(self):
        """
        Clr(TStr self)

        Parameters:
            self: TStr *

        """
        return _snap.TStr_Clr(self)

    def Len(self):
        """
        Len(TStr self) -> int

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_Len(self)

    def Empty(self):
        """
        Empty(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_Empty(self)

    def IsUc(self):
        """
        IsUc(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsUc(self)

    def ToUc(self):
        """
        ToUc(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToUc(self)

    def GetUc(self):
        """
        GetUc(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetUc(self)

    def CmpI(self, *args):
        """
        CmpI(TStr self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_CmpI(self, *args)

    def EqI(self, *args):
        """
        EqI(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_EqI(self, *args)

    def IsLc(self):
        """
        IsLc(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsLc(self)

    def ToLc(self):
        """
        ToLc(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToLc(self)

    def GetLc(self):
        """
        GetLc(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetLc(self)

    def ToCap(self):
        """
        ToCap(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToCap(self)

    def GetCap(self):
        """
        GetCap(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetCap(self)

    def ToTrunc(self):
        """
        ToTrunc(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToTrunc(self)

    def GetTrunc(self):
        """
        GetTrunc(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetTrunc(self)

    def ConvUsFromYuAscii(self):
        """
        ConvUsFromYuAscii(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ConvUsFromYuAscii(self)

    def GetUsFromYuAscii(self):
        """
        GetUsFromYuAscii(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetUsFromYuAscii(self)

    def ToHex(self):
        """
        ToHex(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_ToHex(self)

    def GetHex(self):
        """
        GetHex(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetHex(self)

    def FromHex(self):
        """
        FromHex(TStr self) -> TStr

        Parameters:
            self: TStr *

        """
        return _snap.TStr_FromHex(self)

    def GetFromHex(self):
        """
        GetFromHex(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFromHex(self)

    def GetSubStr(self, *args):
        """
        GetSubStr(TStr self, int const & BChN, int const & EChN) -> TStr

        Parameters:
            BChN: int const &
            EChN: int const &

        GetSubStr(TStr self, int const & BChN) -> TStr

        Parameters:
            BChN: int const &

        """
        return _snap.TStr_GetSubStr(self, *args)

    def InsStr(self, *args):
        """
        InsStr(TStr self, int const & BChN, TStr Str)

        Parameters:
            BChN: int const &
            Str: TStr const &

        """
        return _snap.TStr_InsStr(self, *args)

    def DelChAll(self, *args):
        """
        DelChAll(TStr self, char const & Ch)

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_DelChAll(self, *args)

    def DelSubStr(self, *args):
        """
        DelSubStr(TStr self, int const & BChN, int const & EChN)

        Parameters:
            BChN: int const &
            EChN: int const &

        """
        return _snap.TStr_DelSubStr(self, *args)

    def DelStr(self, *args):
        """
        DelStr(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_DelStr(self, *args)

    def LeftOf(self, *args):
        """
        LeftOf(TStr self, char const & SplitCh) -> TStr

        Parameters:
            SplitCh: char const &

        """
        return _snap.TStr_LeftOf(self, *args)

    def LeftOfLast(self, *args):
        """
        LeftOfLast(TStr self, char const & SplitCh) -> TStr

        Parameters:
            SplitCh: char const &

        """
        return _snap.TStr_LeftOfLast(self, *args)

    def RightOf(self, *args):
        """
        RightOf(TStr self, char const & SplitCh) -> TStr

        Parameters:
            SplitCh: char const &

        """
        return _snap.TStr_RightOf(self, *args)

    def RightOfLast(self, *args):
        """
        RightOfLast(TStr self, char const & SplitCh) -> TStr

        Parameters:
            SplitCh: char const &

        """
        return _snap.TStr_RightOfLast(self, *args)

    def SplitOnCh(self, *args):
        """
        SplitOnCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr)

        Parameters:
            LStr: TStr &
            SplitCh: char const &
            RStr: TStr &

        """
        return _snap.TStr_SplitOnCh(self, *args)

    def SplitOnLastCh(self, *args):
        """
        SplitOnLastCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr)

        Parameters:
            LStr: TStr &
            SplitCh: char const &
            RStr: TStr &

        """
        return _snap.TStr_SplitOnLastCh(self, *args)

    def SplitOnAllCh(self, *args):
        """
        SplitOnAllCh(TStr self, char const & SplitCh, TStrV StrV, bool const & SkipEmpty=True)

        Parameters:
            SplitCh: char const &
            StrV: TStrV &
            SkipEmpty: bool const &

        SplitOnAllCh(TStr self, char const & SplitCh, TStrV StrV)

        Parameters:
            SplitCh: char const &
            StrV: TStrV &

        """
        return _snap.TStr_SplitOnAllCh(self, *args)

    def SplitOnAllAnyCh(self, *args):
        """
        SplitOnAllAnyCh(TStr self, TStr SplitChStr, TStrV StrV, bool const & SkipEmpty=True)

        Parameters:
            SplitChStr: TStr const &
            StrV: TStrV &
            SkipEmpty: bool const &

        SplitOnAllAnyCh(TStr self, TStr SplitChStr, TStrV StrV)

        Parameters:
            SplitChStr: TStr const &
            StrV: TStrV &

        """
        return _snap.TStr_SplitOnAllAnyCh(self, *args)

    def SplitOnWs(self, *args):
        """
        SplitOnWs(TStr self, TStrV StrV)

        Parameters:
            StrV: TStrV &

        """
        return _snap.TStr_SplitOnWs(self, *args)

    def SplitOnNonAlNum(self, *args):
        """
        SplitOnNonAlNum(TStr self, TStrV StrV)

        Parameters:
            StrV: TStrV &

        """
        return _snap.TStr_SplitOnNonAlNum(self, *args)

    def SplitOnStr(self, *args):
        """
        SplitOnStr(TStr self, TStr SplitStr, TStrV StrV)

        Parameters:
            SplitStr: TStr const &
            StrV: TStrV &

        SplitOnStr(TStr self, TStr LeftStr, TStr MidStr, TStr RightStr)

        Parameters:
            LeftStr: TStr &
            MidStr: TStr const &
            RightStr: TStr &

        """
        return _snap.TStr_SplitOnStr(self, *args)

    def Mid(self, *args):
        """
        Mid(TStr self, int const & BChN, int const & Chs) -> TStr

        Parameters:
            BChN: int const &
            Chs: int const &

        Mid(TStr self, int const & BChN) -> TStr

        Parameters:
            BChN: int const &

        """
        return _snap.TStr_Mid(self, *args)

    def Left(self, *args):
        """
        Left(TStr self, int const & EChN) -> TStr

        Parameters:
            EChN: int const &

        """
        return _snap.TStr_Left(self, *args)

    def Right(self, *args):
        """
        Right(TStr self, int const & BChN) -> TStr

        Parameters:
            BChN: int const &

        """
        return _snap.TStr_Right(self, *args)

    def Slice(self, *args):
        """
        Slice(TStr self, int BChN, int EChNP1) -> TStr

        Parameters:
            BChN: int
            EChNP1: int

        """
        return _snap.TStr_Slice(self, *args)

    def __call__(self, *args):
        """
        __call__(TStr self) -> char
        __call__(TStr self) -> char const
        __call__(TStr self, int const & BChN, int const & EChNP1) -> TStr

        Parameters:
            BChN: int const &
            EChNP1: int const &

        """
        return _snap.TStr___call__(self, *args)

    def CountCh(self, *args):
        """
        CountCh(TStr self, char const & Ch, int const & BChN=0) -> int

        Parameters:
            Ch: char const &
            BChN: int const &

        CountCh(TStr self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_CountCh(self, *args)

    def SearchCh(self, *args):
        """
        SearchCh(TStr self, char const & Ch, int const & BChN=0) -> int

        Parameters:
            Ch: char const &
            BChN: int const &

        SearchCh(TStr self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_SearchCh(self, *args)

    def SearchChBack(self, *args):
        """
        SearchChBack(TStr self, char const & Ch, int BChN=-1) -> int

        Parameters:
            Ch: char const &
            BChN: int

        SearchChBack(TStr self, char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_SearchChBack(self, *args)

    def SearchStr(self, *args):
        """
        SearchStr(TStr self, TStr Str, int const & BChN=0) -> int

        Parameters:
            Str: TStr const &
            BChN: int const &

        SearchStr(TStr self, TStr Str) -> int

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_SearchStr(self, *args)

    def IsChIn(self, *args):
        """
        IsChIn(TStr self, char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_IsChIn(self, *args)

    def IsStrIn(self, *args):
        """
        IsStrIn(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_IsStrIn(self, *args)

    def IsPrefix(self, *args):
        """
        IsPrefix(TStr self, char const * Str) -> bool

        Parameters:
            Str: char const *

        IsPrefix(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_IsPrefix(self, *args)

    def IsSuffix(self, *args):
        """
        IsSuffix(TStr self, char const * Str) -> bool

        Parameters:
            Str: char const *

        IsSuffix(TStr self, TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_IsSuffix(self, *args)

    def ChangeCh(self, *args):
        """
        ChangeCh(TStr self, char const & SrcCh, char const & DstCh, int const & BChN=0) -> int

        Parameters:
            SrcCh: char const &
            DstCh: char const &
            BChN: int const &

        ChangeCh(TStr self, char const & SrcCh, char const & DstCh) -> int

        Parameters:
            SrcCh: char const &
            DstCh: char const &

        """
        return _snap.TStr_ChangeCh(self, *args)

    def ChangeChAll(self, *args):
        """
        ChangeChAll(TStr self, char const & SrcCh, char const & DstCh) -> int

        Parameters:
            SrcCh: char const &
            DstCh: char const &

        """
        return _snap.TStr_ChangeChAll(self, *args)

    def ChangeStr(self, *args):
        """
        ChangeStr(TStr self, TStr SrcStr, TStr DstStr, int const & BChN=0) -> int

        Parameters:
            SrcStr: TStr const &
            DstStr: TStr const &
            BChN: int const &

        ChangeStr(TStr self, TStr SrcStr, TStr DstStr) -> int

        Parameters:
            SrcStr: TStr const &
            DstStr: TStr const &

        """
        return _snap.TStr_ChangeStr(self, *args)

    def ChangeStrAll(self, *args):
        """
        ChangeStrAll(TStr self, TStr SrcStr, TStr DstStr, bool const & FromStartP=False) -> int

        Parameters:
            SrcStr: TStr const &
            DstStr: TStr const &
            FromStartP: bool const &

        ChangeStrAll(TStr self, TStr SrcStr, TStr DstStr) -> int

        Parameters:
            SrcStr: TStr const &
            DstStr: TStr const &

        """
        return _snap.TStr_ChangeStrAll(self, *args)

    def Reverse(self):
        """
        Reverse(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_Reverse(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TStr self) -> int

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TStr self) -> int

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetSecHashCd(self)

    def IsBool(self, *args):
        """
        IsBool(TStr self, bool & Val) -> bool

        Parameters:
            Val: bool &

        """
        return _snap.TStr_IsBool(self, *args)

    def IsInt(self, *args):
        """
        IsInt(TStr self, bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: int const &
            MxVal: int const &
            Val: int &

        IsInt(TStr self, int & Val) -> bool

        Parameters:
            Val: int &

        IsInt(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsInt(self, *args)

    def GetInt(self, *args):
        """
        GetInt(TStr self) -> int
        GetInt(TStr self, int const & DfVal) -> int

        Parameters:
            DfVal: int const &

        """
        return _snap.TStr_GetInt(self, *args)

    def IsUInt(self, *args):
        """
        IsUInt(TStr self, bool const & Check, uint const & MnVal, uint const & MxVal, uint & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: uint const &
            MxVal: uint const &
            Val: uint &

        IsUInt(TStr self, uint & Val) -> bool

        Parameters:
            Val: uint &

        IsUInt(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsUInt(self, *args)

    def GetUInt(self, *args):
        """
        GetUInt(TStr self) -> uint
        GetUInt(TStr self, uint const & DfVal) -> uint

        Parameters:
            DfVal: uint const &

        """
        return _snap.TStr_GetUInt(self, *args)

    def IsInt64(self, *args):
        """
        IsInt64(TStr self, bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: int64 const &
            MxVal: int64 const &
            Val: int64 &

        IsInt64(TStr self, int64 & Val) -> bool

        Parameters:
            Val: int64 &

        IsInt64(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsInt64(self, *args)

    def GetInt64(self, *args):
        """
        GetInt64(TStr self) -> int64
        GetInt64(TStr self, int64 const & DfVal) -> int64

        Parameters:
            DfVal: int64 const &

        """
        return _snap.TStr_GetInt64(self, *args)

    def IsUInt64(self, *args):
        """
        IsUInt64(TStr self, bool const & Check, uint64 const & MnVal, uint64 const & MxVal, uint64 & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: uint64 const &
            MxVal: uint64 const &
            Val: uint64 &

        IsUInt64(TStr self, uint64 & Val) -> bool

        Parameters:
            Val: uint64 &

        IsUInt64(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsUInt64(self, *args)

    def GetUInt64(self, *args):
        """
        GetUInt64(TStr self) -> uint64
        GetUInt64(TStr self, uint64 const & DfVal) -> uint64

        Parameters:
            DfVal: uint64 const &

        """
        return _snap.TStr_GetUInt64(self, *args)

    def IsHexInt(self, *args):
        """
        IsHexInt(TStr self, bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: int const &
            MxVal: int const &
            Val: int &

        IsHexInt(TStr self, int & Val) -> bool

        Parameters:
            Val: int &

        IsHexInt(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsHexInt(self, *args)

    def GetHexInt(self, *args):
        """
        GetHexInt(TStr self) -> int
        GetHexInt(TStr self, int const & DfVal) -> int

        Parameters:
            DfVal: int const &

        """
        return _snap.TStr_GetHexInt(self, *args)

    def IsHexInt64(self, *args):
        """
        IsHexInt64(TStr self, bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: int64 const &
            MxVal: int64 const &
            Val: int64 &

        IsHexInt64(TStr self, int64 & Val) -> bool

        Parameters:
            Val: int64 &

        IsHexInt64(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsHexInt64(self, *args)

    def GetHexInt64(self, *args):
        """
        GetHexInt64(TStr self) -> int64
        GetHexInt64(TStr self, int64 const & DfVal) -> int64

        Parameters:
            DfVal: int64 const &

        """
        return _snap.TStr_GetHexInt64(self, *args)

    def IsFlt(self, *args):
        """
        IsFlt(TStr self, bool const & Check, double const & MnVal, double const & MxVal, double & Val, char const & DecDelimCh='.') -> bool

        Parameters:
            Check: bool const &
            MnVal: double const &
            MxVal: double const &
            Val: double &
            DecDelimCh: char const &

        IsFlt(TStr self, bool const & Check, double const & MnVal, double const & MxVal, double & Val) -> bool

        Parameters:
            Check: bool const &
            MnVal: double const &
            MxVal: double const &
            Val: double &

        IsFlt(TStr self, double & Val) -> bool

        Parameters:
            Val: double &

        IsFlt(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsFlt(self, *args)

    def GetFlt(self, *args):
        """
        GetFlt(TStr self) -> double
        GetFlt(TStr self, double const & DfVal) -> double

        Parameters:
            DfVal: double const &

        """
        return _snap.TStr_GetFlt(self, *args)

    def IsWord(self, WsPrefixP=True, FirstUcAllowedP=True):
        """
        IsWord(TStr self, bool const & WsPrefixP=True, bool const & FirstUcAllowedP=True) -> bool

        Parameters:
            WsPrefixP: bool const &
            FirstUcAllowedP: bool const &

        IsWord(TStr self, bool const & WsPrefixP=True) -> bool

        Parameters:
            WsPrefixP: bool const &

        IsWord(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsWord(self, WsPrefixP, FirstUcAllowedP)

    def IsWs(self):
        """
        IsWs(TStr self) -> bool

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_IsWs(self)

    def IsWcMatch(self, *args):
        """
        IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*', 
            char const & QuestCh='?') -> bool

        Parameters:
            StrBChN: int const &
            WcStr: TStr const &
            WcStrBChN: int const &
            StarStrV: TStrV &
            StarCh: char const &
            QuestCh: char const &

        IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*') -> bool

        Parameters:
            StrBChN: int const &
            WcStr: TStr const &
            WcStrBChN: int const &
            StarStrV: TStrV &
            StarCh: char const &

        IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV) -> bool

        Parameters:
            StrBChN: int const &
            WcStr: TStr const &
            WcStrBChN: int const &
            StarStrV: TStrV &

        IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV, char const & StarCh='*', char const & QuestCh='?') -> bool

        Parameters:
            WcStr: TStr const &
            StarStrV: TStrV &
            StarCh: char const &
            QuestCh: char const &

        IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV, char const & StarCh='*') -> bool

        Parameters:
            WcStr: TStr const &
            StarStrV: TStrV &
            StarCh: char const &

        IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV) -> bool

        Parameters:
            WcStr: TStr const &
            StarStrV: TStrV &

        IsWcMatch(TStr self, TStr WcStr, char const & StarCh, char const & QuestCh) -> bool

        Parameters:
            WcStr: TStr const &
            StarCh: char const &
            QuestCh: char const &

        IsWcMatch(TStr self, TStr WcStr, int const & StarStrN, TStr StarStr) -> bool

        Parameters:
            WcStr: TStr const &
            StarStrN: int const &
            StarStr: TStr &

        IsWcMatch(TStr self, TStr WcStr) -> bool

        Parameters:
            WcStr: TStr const &

        """
        return _snap.TStr_IsWcMatch(self, *args)

    def GetWcMatch(self, *args):
        """
        GetWcMatch(TStr self, TStr WcStr, int const & StarStrN=0) -> TStr

        Parameters:
            WcStr: TStr const &
            StarStrN: int const &

        GetWcMatch(TStr self, TStr WcStr) -> TStr

        Parameters:
            WcStr: TStr const &

        """
        return _snap.TStr_GetWcMatch(self, *args)

    def GetFPath(self):
        """
        GetFPath(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFPath(self)

    def GetFBase(self):
        """
        GetFBase(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFBase(self)

    def GetFMid(self):
        """
        GetFMid(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFMid(self)

    def GetFExt(self):
        """
        GetFExt(TStr self) -> TStr

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetFExt(self)

    def GetNrFPath(*args):
        """
        GetNrFPath(TStr FPath) -> TStr

        Parameters:
            FPath: TStr const &

        """
        return _snap.TStr_GetNrFPath(*args)

    GetNrFPath = staticmethod(GetNrFPath)
    def GetNrFMid(*args):
        """
        GetNrFMid(TStr FMid) -> TStr

        Parameters:
            FMid: TStr const &

        """
        return _snap.TStr_GetNrFMid(*args)

    GetNrFMid = staticmethod(GetNrFMid)
    def GetNrFExt(*args):
        """
        GetNrFExt(TStr FExt) -> TStr

        Parameters:
            FExt: TStr const &

        """
        return _snap.TStr_GetNrFExt(*args)

    GetNrFExt = staticmethod(GetNrFExt)
    def GetNrNumFExt(*args):
        """
        GetNrNumFExt(int const & FExtN) -> TStr

        Parameters:
            FExtN: int const &

        """
        return _snap.TStr_GetNrNumFExt(*args)

    GetNrNumFExt = staticmethod(GetNrNumFExt)
    def GetNrFNm(*args):
        """
        GetNrFNm(TStr FNm) -> TStr

        Parameters:
            FNm: TStr const &

        """
        return _snap.TStr_GetNrFNm(*args)

    GetNrFNm = staticmethod(GetNrFNm)
    def GetNrAbsFPath(*args):
        """
        GetNrAbsFPath(TStr FPath, TStr BaseFPath=TStr()) -> TStr

        Parameters:
            FPath: TStr const &
            BaseFPath: TStr const &

        GetNrAbsFPath(TStr FPath) -> TStr

        Parameters:
            FPath: TStr const &

        """
        return _snap.TStr_GetNrAbsFPath(*args)

    GetNrAbsFPath = staticmethod(GetNrAbsFPath)
    def IsAbsFPath(*args):
        """
        IsAbsFPath(TStr FPath) -> bool

        Parameters:
            FPath: TStr const &

        """
        return _snap.TStr_IsAbsFPath(*args)

    IsAbsFPath = staticmethod(IsAbsFPath)
    def PutFExt(*args):
        """
        PutFExt(TStr FNm, TStr FExt) -> TStr

        Parameters:
            FNm: TStr const &
            FExt: TStr const &

        """
        return _snap.TStr_PutFExt(*args)

    PutFExt = staticmethod(PutFExt)
    def PutFExtIfEmpty(*args):
        """
        PutFExtIfEmpty(TStr FNm, TStr FExt) -> TStr

        Parameters:
            FNm: TStr const &
            FExt: TStr const &

        """
        return _snap.TStr_PutFExtIfEmpty(*args)

    PutFExtIfEmpty = staticmethod(PutFExtIfEmpty)
    def PutFBase(*args):
        """
        PutFBase(TStr FNm, TStr FBase) -> TStr

        Parameters:
            FNm: TStr const &
            FBase: TStr const &

        """
        return _snap.TStr_PutFBase(*args)

    PutFBase = staticmethod(PutFBase)
    def PutFBaseIfEmpty(*args):
        """
        PutFBaseIfEmpty(TStr FNm, TStr FBase) -> TStr

        Parameters:
            FNm: TStr const &
            FBase: TStr const &

        """
        return _snap.TStr_PutFBaseIfEmpty(*args)

    PutFBaseIfEmpty = staticmethod(PutFBaseIfEmpty)
    def AddToFMid(*args):
        """
        AddToFMid(TStr FNm, TStr ExtFMid) -> TStr

        Parameters:
            FNm: TStr const &
            ExtFMid: TStr const &

        """
        return _snap.TStr_AddToFMid(*args)

    AddToFMid = staticmethod(AddToFMid)
    def GetNumFNm(*args):
        """
        GetNumFNm(TStr FNm, int const & Num) -> TStr

        Parameters:
            FNm: TStr const &
            Num: int const &

        """
        return _snap.TStr_GetNumFNm(*args)

    GetNumFNm = staticmethod(GetNumFNm)
    def GetFNmStr(*args):
        """
        GetFNmStr(TStr Str, bool const & AlNumOnlyP=True) -> TStr

        Parameters:
            Str: TStr const &
            AlNumOnlyP: bool const &

        GetFNmStr(TStr Str) -> TStr

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_GetFNmStr(*args)

    GetFNmStr = staticmethod(GetFNmStr)
    def LoadTxt(*args):
        """
        LoadTxt(PSIn const & SIn) -> TStr

        Parameters:
            SIn: PSIn const &

        LoadTxt(TStr FNm) -> TStr

        Parameters:
            FNm: TStr const &

        """
        return _snap.TStr_LoadTxt(*args)

    LoadTxt = staticmethod(LoadTxt)
    def SaveTxt(self, *args):
        """
        SaveTxt(TStr self, PSOut const & SOut)

        Parameters:
            SOut: PSOut const &

        SaveTxt(TStr self, TStr FNm)

        Parameters:
            FNm: TStr const &

        """
        return _snap.TStr_SaveTxt(self, *args)

    def GetChStr(*args):
        """
        GetChStr(char const & Ch) -> TStr

        Parameters:
            Ch: char const &

        """
        return _snap.TStr_GetChStr(*args)

    GetChStr = staticmethod(GetChStr)
    def GetDChStr(*args):
        """
        GetDChStr(char const & Ch1, char const & Ch2) -> TStr

        Parameters:
            Ch1: char const &
            Ch2: char const &

        """
        return _snap.TStr_GetDChStr(*args)

    GetDChStr = staticmethod(GetDChStr)
    def Fmt(*args):
        """
        Fmt(char const * FmtStr) -> TStr

        Parameters:
            FmtStr: char const *

        """
        return _snap.TStr_Fmt(*args)

    Fmt = staticmethod(Fmt)
    def GetSpaceStr(*args):
        """
        GetSpaceStr(int const & Spaces) -> TStr

        Parameters:
            Spaces: int const &

        """
        return _snap.TStr_GetSpaceStr(*args)

    GetSpaceStr = staticmethod(GetSpaceStr)
    def GetCStr(self):
        """
        GetCStr(TStr self) -> char *

        Parameters:
            self: TStr const *

        """
        return _snap.TStr_GetCStr(self)

    def MkClone(*args):
        """
        MkClone(TStr Str) -> TStr

        Parameters:
            Str: TStr const &

        """
        return _snap.TStr_MkClone(*args)

    MkClone = staticmethod(MkClone)
    def GetNullStr():
        """GetNullStr() -> TStr"""
        return _snap.TStr_GetNullStr()

    GetNullStr = staticmethod(GetNullStr)
TStr.Load = new_instancemethod(_snap.TStr_Load,None,TStr)
TStr.Save = new_instancemethod(_snap.TStr_Save,None,TStr)
TStr.LoadXml = new_instancemethod(_snap.TStr_LoadXml,None,TStr)
TStr.SaveXml = new_instancemethod(_snap.TStr_SaveXml,None,TStr)
TStr.__iadd__ = new_instancemethod(_snap.TStr___iadd__,None,TStr)
TStr.__eq__ = new_instancemethod(_snap.TStr___eq__,None,TStr)
TStr.__ne__ = new_instancemethod(_snap.TStr___ne__,None,TStr)
TStr.__lt__ = new_instancemethod(_snap.TStr___lt__,None,TStr)
TStr.GetMemUsed = new_instancemethod(_snap.TStr_GetMemUsed,None,TStr)
TStr.CStr = new_instancemethod(_snap.TStr_CStr,None,TStr)
TStr.PutCh = new_instancemethod(_snap.TStr_PutCh,None,TStr)
TStr.GetCh = new_instancemethod(_snap.TStr_GetCh,None,TStr)
TStr.LastCh = new_instancemethod(_snap.TStr_LastCh,None,TStr)
TStr.Clr = new_instancemethod(_snap.TStr_Clr,None,TStr)
TStr.Len = new_instancemethod(_snap.TStr_Len,None,TStr)
TStr.Empty = new_instancemethod(_snap.TStr_Empty,None,TStr)
TStr.IsUc = new_instancemethod(_snap.TStr_IsUc,None,TStr)
TStr.ToUc = new_instancemethod(_snap.TStr_ToUc,None,TStr)
TStr.GetUc = new_instancemethod(_snap.TStr_GetUc,None,TStr)
TStr.CmpI = new_instancemethod(_snap.TStr_CmpI,None,TStr)
TStr.EqI = new_instancemethod(_snap.TStr_EqI,None,TStr)
TStr.IsLc = new_instancemethod(_snap.TStr_IsLc,None,TStr)
TStr.ToLc = new_instancemethod(_snap.TStr_ToLc,None,TStr)
TStr.GetLc = new_instancemethod(_snap.TStr_GetLc,None,TStr)
TStr.ToCap = new_instancemethod(_snap.TStr_ToCap,None,TStr)
TStr.GetCap = new_instancemethod(_snap.TStr_GetCap,None,TStr)
TStr.ToTrunc = new_instancemethod(_snap.TStr_ToTrunc,None,TStr)
TStr.GetTrunc = new_instancemethod(_snap.TStr_GetTrunc,None,TStr)
TStr.ConvUsFromYuAscii = new_instancemethod(_snap.TStr_ConvUsFromYuAscii,None,TStr)
TStr.GetUsFromYuAscii = new_instancemethod(_snap.TStr_GetUsFromYuAscii,None,TStr)
TStr.ToHex = new_instancemethod(_snap.TStr_ToHex,None,TStr)
TStr.GetHex = new_instancemethod(_snap.TStr_GetHex,None,TStr)
TStr.FromHex = new_instancemethod(_snap.TStr_FromHex,None,TStr)
TStr.GetFromHex = new_instancemethod(_snap.TStr_GetFromHex,None,TStr)
TStr.GetSubStr = new_instancemethod(_snap.TStr_GetSubStr,None,TStr)
TStr.InsStr = new_instancemethod(_snap.TStr_InsStr,None,TStr)
TStr.DelChAll = new_instancemethod(_snap.TStr_DelChAll,None,TStr)
TStr.DelSubStr = new_instancemethod(_snap.TStr_DelSubStr,None,TStr)
TStr.DelStr = new_instancemethod(_snap.TStr_DelStr,None,TStr)
TStr.LeftOf = new_instancemethod(_snap.TStr_LeftOf,None,TStr)
TStr.LeftOfLast = new_instancemethod(_snap.TStr_LeftOfLast,None,TStr)
TStr.RightOf = new_instancemethod(_snap.TStr_RightOf,None,TStr)
TStr.RightOfLast = new_instancemethod(_snap.TStr_RightOfLast,None,TStr)
TStr.SplitOnCh = new_instancemethod(_snap.TStr_SplitOnCh,None,TStr)
TStr.SplitOnLastCh = new_instancemethod(_snap.TStr_SplitOnLastCh,None,TStr)
TStr.SplitOnAllCh = new_instancemethod(_snap.TStr_SplitOnAllCh,None,TStr)
TStr.SplitOnAllAnyCh = new_instancemethod(_snap.TStr_SplitOnAllAnyCh,None,TStr)
TStr.SplitOnWs = new_instancemethod(_snap.TStr_SplitOnWs,None,TStr)
TStr.SplitOnNonAlNum = new_instancemethod(_snap.TStr_SplitOnNonAlNum,None,TStr)
TStr.SplitOnStr = new_instancemethod(_snap.TStr_SplitOnStr,None,TStr)
TStr.Mid = new_instancemethod(_snap.TStr_Mid,None,TStr)
TStr.Left = new_instancemethod(_snap.TStr_Left,None,TStr)
TStr.Right = new_instancemethod(_snap.TStr_Right,None,TStr)
TStr.Slice = new_instancemethod(_snap.TStr_Slice,None,TStr)
TStr.__call__ = new_instancemethod(_snap.TStr___call__,None,TStr)
TStr.CountCh = new_instancemethod(_snap.TStr_CountCh,None,TStr)
TStr.SearchCh = new_instancemethod(_snap.TStr_SearchCh,None,TStr)
TStr.SearchChBack = new_instancemethod(_snap.TStr_SearchChBack,None,TStr)
TStr.SearchStr = new_instancemethod(_snap.TStr_SearchStr,None,TStr)
TStr.IsChIn = new_instancemethod(_snap.TStr_IsChIn,None,TStr)
TStr.IsStrIn = new_instancemethod(_snap.TStr_IsStrIn,None,TStr)
TStr.IsPrefix = new_instancemethod(_snap.TStr_IsPrefix,None,TStr)
TStr.IsSuffix = new_instancemethod(_snap.TStr_IsSuffix,None,TStr)
TStr.ChangeCh = new_instancemethod(_snap.TStr_ChangeCh,None,TStr)
TStr.ChangeChAll = new_instancemethod(_snap.TStr_ChangeChAll,None,TStr)
TStr.ChangeStr = new_instancemethod(_snap.TStr_ChangeStr,None,TStr)
TStr.ChangeStrAll = new_instancemethod(_snap.TStr_ChangeStrAll,None,TStr)
TStr.Reverse = new_instancemethod(_snap.TStr_Reverse,None,TStr)
TStr.GetPrimHashCd = new_instancemethod(_snap.TStr_GetPrimHashCd,None,TStr)
TStr.GetSecHashCd = new_instancemethod(_snap.TStr_GetSecHashCd,None,TStr)
TStr.IsBool = new_instancemethod(_snap.TStr_IsBool,None,TStr)
TStr.IsInt = new_instancemethod(_snap.TStr_IsInt,None,TStr)
TStr.GetInt = new_instancemethod(_snap.TStr_GetInt,None,TStr)
TStr.IsUInt = new_instancemethod(_snap.TStr_IsUInt,None,TStr)
TStr.GetUInt = new_instancemethod(_snap.TStr_GetUInt,None,TStr)
TStr.IsInt64 = new_instancemethod(_snap.TStr_IsInt64,None,TStr)
TStr.GetInt64 = new_instancemethod(_snap.TStr_GetInt64,None,TStr)
TStr.IsUInt64 = new_instancemethod(_snap.TStr_IsUInt64,None,TStr)
TStr.GetUInt64 = new_instancemethod(_snap.TStr_GetUInt64,None,TStr)
TStr.IsHexInt = new_instancemethod(_snap.TStr_IsHexInt,None,TStr)
TStr.GetHexInt = new_instancemethod(_snap.TStr_GetHexInt,None,TStr)
TStr.IsHexInt64 = new_instancemethod(_snap.TStr_IsHexInt64,None,TStr)
TStr.GetHexInt64 = new_instancemethod(_snap.TStr_GetHexInt64,None,TStr)
TStr.IsFlt = new_instancemethod(_snap.TStr_IsFlt,None,TStr)
TStr.GetFlt = new_instancemethod(_snap.TStr_GetFlt,None,TStr)
TStr.IsWord = new_instancemethod(_snap.TStr_IsWord,None,TStr)
TStr.IsWs = new_instancemethod(_snap.TStr_IsWs,None,TStr)
TStr.IsWcMatch = new_instancemethod(_snap.TStr_IsWcMatch,None,TStr)
TStr.GetWcMatch = new_instancemethod(_snap.TStr_GetWcMatch,None,TStr)
TStr.GetFPath = new_instancemethod(_snap.TStr_GetFPath,None,TStr)
TStr.GetFBase = new_instancemethod(_snap.TStr_GetFBase,None,TStr)
TStr.GetFMid = new_instancemethod(_snap.TStr_GetFMid,None,TStr)
TStr.GetFExt = new_instancemethod(_snap.TStr_GetFExt,None,TStr)
TStr.SaveTxt = new_instancemethod(_snap.TStr_SaveTxt,None,TStr)
TStr.GetCStr = new_instancemethod(_snap.TStr_GetCStr,None,TStr)
TStr_swigregister = _snap.TStr_swigregister
TStr_swigregister(TStr)

def TStr_GetNrFPath(*args):
  """
    TStr_GetNrFPath(TStr FPath) -> TStr

    Parameters:
        FPath: TStr const &

    """
  return _snap.TStr_GetNrFPath(*args)

def TStr_GetNrFMid(*args):
  """
    TStr_GetNrFMid(TStr FMid) -> TStr

    Parameters:
        FMid: TStr const &

    """
  return _snap.TStr_GetNrFMid(*args)

def TStr_GetNrFExt(*args):
  """
    TStr_GetNrFExt(TStr FExt) -> TStr

    Parameters:
        FExt: TStr const &

    """
  return _snap.TStr_GetNrFExt(*args)

def TStr_GetNrNumFExt(*args):
  """
    TStr_GetNrNumFExt(int const & FExtN) -> TStr

    Parameters:
        FExtN: int const &

    """
  return _snap.TStr_GetNrNumFExt(*args)

def TStr_GetNrFNm(*args):
  """
    TStr_GetNrFNm(TStr FNm) -> TStr

    Parameters:
        FNm: TStr const &

    """
  return _snap.TStr_GetNrFNm(*args)

def TStr_GetNrAbsFPath(*args):
  """
    GetNrAbsFPath(TStr FPath, TStr BaseFPath=TStr()) -> TStr

    Parameters:
        FPath: TStr const &
        BaseFPath: TStr const &

    TStr_GetNrAbsFPath(TStr FPath) -> TStr

    Parameters:
        FPath: TStr const &

    """
  return _snap.TStr_GetNrAbsFPath(*args)

def TStr_IsAbsFPath(*args):
  """
    TStr_IsAbsFPath(TStr FPath) -> bool

    Parameters:
        FPath: TStr const &

    """
  return _snap.TStr_IsAbsFPath(*args)

def TStr_PutFExt(*args):
  """
    TStr_PutFExt(TStr FNm, TStr FExt) -> TStr

    Parameters:
        FNm: TStr const &
        FExt: TStr const &

    """
  return _snap.TStr_PutFExt(*args)

def TStr_PutFExtIfEmpty(*args):
  """
    TStr_PutFExtIfEmpty(TStr FNm, TStr FExt) -> TStr

    Parameters:
        FNm: TStr const &
        FExt: TStr const &

    """
  return _snap.TStr_PutFExtIfEmpty(*args)

def TStr_PutFBase(*args):
  """
    TStr_PutFBase(TStr FNm, TStr FBase) -> TStr

    Parameters:
        FNm: TStr const &
        FBase: TStr const &

    """
  return _snap.TStr_PutFBase(*args)

def TStr_PutFBaseIfEmpty(*args):
  """
    TStr_PutFBaseIfEmpty(TStr FNm, TStr FBase) -> TStr

    Parameters:
        FNm: TStr const &
        FBase: TStr const &

    """
  return _snap.TStr_PutFBaseIfEmpty(*args)

def TStr_AddToFMid(*args):
  """
    TStr_AddToFMid(TStr FNm, TStr ExtFMid) -> TStr

    Parameters:
        FNm: TStr const &
        ExtFMid: TStr const &

    """
  return _snap.TStr_AddToFMid(*args)

def TStr_GetNumFNm(*args):
  """
    TStr_GetNumFNm(TStr FNm, int const & Num) -> TStr

    Parameters:
        FNm: TStr const &
        Num: int const &

    """
  return _snap.TStr_GetNumFNm(*args)

def TStr_GetFNmStr(*args):
  """
    GetFNmStr(TStr Str, bool const & AlNumOnlyP=True) -> TStr

    Parameters:
        Str: TStr const &
        AlNumOnlyP: bool const &

    TStr_GetFNmStr(TStr Str) -> TStr

    Parameters:
        Str: TStr const &

    """
  return _snap.TStr_GetFNmStr(*args)

def TStr_LoadTxt(*args):
  """
    LoadTxt(PSIn const & SIn) -> TStr

    Parameters:
        SIn: PSIn const &

    TStr_LoadTxt(TStr FNm) -> TStr

    Parameters:
        FNm: TStr const &

    """
  return _snap.TStr_LoadTxt(*args)

def TStr_GetChStr(*args):
  """
    TStr_GetChStr(char const & Ch) -> TStr

    Parameters:
        Ch: char const &

    """
  return _snap.TStr_GetChStr(*args)

def TStr_GetDChStr(*args):
  """
    TStr_GetDChStr(char const & Ch1, char const & Ch2) -> TStr

    Parameters:
        Ch1: char const &
        Ch2: char const &

    """
  return _snap.TStr_GetDChStr(*args)

def TStr_Fmt(*args):
  """
    TStr_Fmt(char const * FmtStr) -> TStr

    Parameters:
        FmtStr: char const *

    """
  return _snap.TStr_Fmt(*args)

def TStr_GetSpaceStr(*args):
  """
    TStr_GetSpaceStr(int const & Spaces) -> TStr

    Parameters:
        Spaces: int const &

    """
  return _snap.TStr_GetSpaceStr(*args)

def TStr_MkClone(*args):
  """
    TStr_MkClone(TStr Str) -> TStr

    Parameters:
        Str: TStr const &

    """
  return _snap.TStr_MkClone(*args)

def TStr_GetNullStr():
  """TStr_GetNullStr() -> TStr"""
  return _snap.TStr_GetNullStr()

class TStrIn(TSIn):
    """Proxy of C++ TStrIn class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TStrIn self, TStr _Str) -> TStrIn

        Parameters:
            _Str: TStr const &

        """
        _snap.TStrIn_swiginit(self,_snap.new_TStrIn(*args))
    def New(*args):
        """
        New(TStr Str) -> PSIn

        Parameters:
            Str: TStr const &

        """
        return _snap.TStrIn_New(*args)

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_TStrIn
TStrIn_swigregister = _snap.TStrIn_swigregister
TStrIn_swigregister(TStrIn)

def TStrIn_New(*args):
  """
    TStrIn_New(TStr Str) -> PSIn

    Parameters:
        Str: TStr const &

    """
  return _snap.TStrIn_New(*args)

class TDbStr(object):
    """Proxy of C++ TDbStr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Str1 = _swig_property(_snap.TDbStr_Str1_get, _snap.TDbStr_Str1_set)
    Str2 = _swig_property(_snap.TDbStr_Str2_get, _snap.TDbStr_Str2_set)
    def __init__(self, *args): 
        """
        __init__(TDbStr self) -> TDbStr
        __init__(TDbStr self, TDbStr DbStr) -> TDbStr

        Parameters:
            DbStr: TDbStr const &

        __init__(TDbStr self, TStr _Str1) -> TDbStr

        Parameters:
            _Str1: TStr const &

        __init__(TDbStr self, TStr _Str1, TStr _Str2) -> TDbStr

        Parameters:
            _Str1: TStr const &
            _Str2: TStr const &

        __init__(TDbStr self, TSIn SIn) -> TDbStr

        Parameters:
            SIn: TSIn &

        """
        _snap.TDbStr_swiginit(self,_snap.new_TDbStr(*args))
    def Save(self, *args):
        """
        Save(TDbStr self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TDbStr_Save(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TDbStr self, TDbStr DbStr) -> bool

        Parameters:
            DbStr: TDbStr const &

        """
        return _snap.TDbStr___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TDbStr self, TDbStr DbStr) -> bool

        Parameters:
            DbStr: TDbStr const &

        """
        return _snap.TDbStr___lt__(self, *args)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TDbStr self) -> int

        Parameters:
            self: TDbStr const *

        """
        return _snap.TDbStr_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TDbStr self) -> int

        Parameters:
            self: TDbStr const *

        """
        return _snap.TDbStr_GetSecHashCd(self)

    def Empty(self):
        """
        Empty(TDbStr self) -> bool

        Parameters:
            self: TDbStr const *

        """
        return _snap.TDbStr_Empty(self)

    def Filled(self):
        """
        Filled(TDbStr self) -> bool

        Parameters:
            self: TDbStr const *

        """
        return _snap.TDbStr_Filled(self)

    __swig_destroy__ = _snap.delete_TDbStr
TDbStr.Save = new_instancemethod(_snap.TDbStr_Save,None,TDbStr)
TDbStr.__eq__ = new_instancemethod(_snap.TDbStr___eq__,None,TDbStr)
TDbStr.__lt__ = new_instancemethod(_snap.TDbStr___lt__,None,TDbStr)
TDbStr.GetPrimHashCd = new_instancemethod(_snap.TDbStr_GetPrimHashCd,None,TDbStr)
TDbStr.GetSecHashCd = new_instancemethod(_snap.TDbStr_GetSecHashCd,None,TDbStr)
TDbStr.Empty = new_instancemethod(_snap.TDbStr_Empty,None,TDbStr)
TDbStr.Filled = new_instancemethod(_snap.TDbStr_Filled,None,TDbStr)
TDbStr_swigregister = _snap.TDbStr_swigregister
TDbStr_swigregister(TDbStr)

class TStrPool(object):
    """Proxy of C++ TStrPool class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TStrPool self, uint const & MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> TStrPool

        Parameters:
            MxBfLen: uint const &
            _GrowBy: uint const &

        __init__(TStrPool self, uint const & MxBfLen=0) -> TStrPool

        Parameters:
            MxBfLen: uint const &

        __init__(TStrPool self) -> TStrPool
        __init__(TStrPool self, TSIn SIn, bool LoadCompact=True) -> TStrPool

        Parameters:
            SIn: TSIn &
            LoadCompact: bool

        __init__(TStrPool self, TSIn SIn) -> TStrPool

        Parameters:
            SIn: TSIn &

        __init__(TStrPool self, TStrPool Pool) -> TStrPool

        Parameters:
            Pool: TStrPool const &

        """
        _snap.TStrPool_swiginit(self,_snap.new_TStrPool(*args))
    __swig_destroy__ = _snap.delete_TStrPool
    def New(*args):
        """
        New(uint const & _MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> PStrPool

        Parameters:
            _MxBfLen: uint const &
            _GrowBy: uint const &

        New(uint const & _MxBfLen=0) -> PStrPool

        Parameters:
            _MxBfLen: uint const &

        New() -> PStrPool
        New(TSIn SIn) -> PStrPool

        Parameters:
            SIn: TSIn &

        New(TStr fileName) -> PStrPool

        Parameters:
            fileName: TStr const &

        """
        return _snap.TStrPool_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn, bool LoadCompacted=True) -> PStrPool

        Parameters:
            SIn: TSIn &
            LoadCompacted: bool

        Load(TSIn SIn) -> PStrPool

        Parameters:
            SIn: TSIn &

        """
        return _snap.TStrPool_Load(*args)

    Load = staticmethod(Load)
    def Save(self, *args):
        """
        Save(TStrPool self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        Save(TStrPool self, TStr FNm)

        Parameters:
            FNm: TStr const &

        """
        return _snap.TStrPool_Save(self, *args)

    def Len(self):
        """
        Len(TStrPool self) -> uint

        Parameters:
            self: TStrPool const *

        """
        return _snap.TStrPool_Len(self)

    def Size(self):
        """
        Size(TStrPool self) -> uint

        Parameters:
            self: TStrPool const *

        """
        return _snap.TStrPool_Size(self)

    def Empty(self):
        """
        Empty(TStrPool self) -> bool

        Parameters:
            self: TStrPool const *

        """
        return _snap.TStrPool_Empty(self)

    def __call__(self):
        """
        __call__(TStrPool self) -> char *

        Parameters:
            self: TStrPool const *

        """
        return _snap.TStrPool___call__(self)

    def AddStr(self, *args):
        """
        AddStr(TStrPool self, char const * Str, uint const & Len) -> uint

        Parameters:
            Str: char const *
            Len: uint const &

        AddStr(TStrPool self, char const * Str) -> uint

        Parameters:
            Str: char const *

        AddStr(TStrPool self, TStr Str) -> uint

        Parameters:
            Str: TStr const &

        """
        return _snap.TStrPool_AddStr(self, *args)

    def GetCStr(self, *args):
        """
        GetCStr(TStrPool self, uint const & Offset) -> char const *

        Parameters:
            Offset: uint const &

        """
        return _snap.TStrPool_GetCStr(self, *args)

    def Clr(self, DoDel=False):
        """
        Clr(TStrPool self, bool DoDel=False)

        Parameters:
            DoDel: bool

        Clr(TStrPool self)

        Parameters:
            self: TStrPool *

        """
        return _snap.TStrPool_Clr(self, DoDel)

    def Cmp(self, *args):
        """
        Cmp(TStrPool self, uint const & Offset, char const * Str) -> int

        Parameters:
            Offset: uint const &
            Str: char const *

        """
        return _snap.TStrPool_Cmp(self, *args)

    def GetPrimHashCd(self, *args):
        """
        GetPrimHashCd(TStrPool self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        GetPrimHashCd(TStrPool self, uint const & Offset) -> int

        Parameters:
            Offset: uint const &

        """
        return _snap.TStrPool_GetPrimHashCd(self, *args)

    def GetSecHashCd(self, *args):
        """
        GetSecHashCd(TStrPool self, char const * CStr) -> int

        Parameters:
            CStr: char const *

        GetSecHashCd(TStrPool self, uint const & Offset) -> int

        Parameters:
            Offset: uint const &

        """
        return _snap.TStrPool_GetSecHashCd(self, *args)

TStrPool.Save = new_instancemethod(_snap.TStrPool_Save,None,TStrPool)
TStrPool.Len = new_instancemethod(_snap.TStrPool_Len,None,TStrPool)
TStrPool.Size = new_instancemethod(_snap.TStrPool_Size,None,TStrPool)
TStrPool.Empty = new_instancemethod(_snap.TStrPool_Empty,None,TStrPool)
TStrPool.__call__ = new_instancemethod(_snap.TStrPool___call__,None,TStrPool)
TStrPool.AddStr = new_instancemethod(_snap.TStrPool_AddStr,None,TStrPool)
TStrPool.GetCStr = new_instancemethod(_snap.TStrPool_GetCStr,None,TStrPool)
TStrPool.Clr = new_instancemethod(_snap.TStrPool_Clr,None,TStrPool)
TStrPool.Cmp = new_instancemethod(_snap.TStrPool_Cmp,None,TStrPool)
TStrPool.GetPrimHashCd = new_instancemethod(_snap.TStrPool_GetPrimHashCd,None,TStrPool)
TStrPool.GetSecHashCd = new_instancemethod(_snap.TStrPool_GetSecHashCd,None,TStrPool)
TStrPool_swigregister = _snap.TStrPool_swigregister
TStrPool_swigregister(TStrPool)

def TStrPool_New(*args):
  """
    New(uint const & _MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> PStrPool

    Parameters:
        _MxBfLen: uint const &
        _GrowBy: uint const &

    New(uint const & _MxBfLen=0) -> PStrPool

    Parameters:
        _MxBfLen: uint const &

    New() -> PStrPool
    New(TSIn SIn) -> PStrPool

    Parameters:
        SIn: TSIn &

    TStrPool_New(TStr fileName) -> PStrPool

    Parameters:
        fileName: TStr const &

    """
  return _snap.TStrPool_New(*args)

def TStrPool_Load(*args):
  """
    Load(TSIn SIn, bool LoadCompacted=True) -> PStrPool

    Parameters:
        SIn: TSIn &
        LoadCompacted: bool

    TStrPool_Load(TSIn SIn) -> PStrPool

    Parameters:
        SIn: TSIn &

    """
  return _snap.TStrPool_Load(*args)

class TStrPool64(object):
    """Proxy of C++ TStrPool64 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TStrPool64 self, ::TSize _MxBfL=0, ::TSize _GrowBy=16*1024*1024) -> TStrPool64

        Parameters:
            _MxBfL: ::TSize
            _GrowBy: ::TSize

        __init__(TStrPool64 self, ::TSize _MxBfL=0) -> TStrPool64

        Parameters:
            _MxBfL: ::TSize

        __init__(TStrPool64 self) -> TStrPool64
        __init__(TStrPool64 self, TStrPool64 StrPool) -> TStrPool64

        Parameters:
            StrPool: TStrPool64 const &

        __init__(TStrPool64 self, TSIn SIn, bool LoadCompact=True) -> TStrPool64

        Parameters:
            SIn: TSIn &
            LoadCompact: bool

        __init__(TStrPool64 self, TSIn SIn) -> TStrPool64

        Parameters:
            SIn: TSIn &

        """
        _snap.TStrPool64_swiginit(self,_snap.new_TStrPool64(*args))
    __swig_destroy__ = _snap.delete_TStrPool64
    def Save(self, *args):
        """
        Save(TStrPool64 self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TStrPool64_Save(self, *args)

    def New(MxBfL=0, GrowBy=16*1024*1024):
        """
        New(::TSize MxBfL=0, ::TSize GrowBy=16*1024*1024) -> PStrPool64

        Parameters:
            MxBfL: ::TSize
            GrowBy: ::TSize

        New(::TSize MxBfL=0) -> PStrPool64

        Parameters:
            MxBfL: ::TSize

        New() -> PStrPool64
        """
        return _snap.TStrPool64_New(MxBfL, GrowBy)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn, bool LoadCompact=True) -> PStrPool64

        Parameters:
            SIn: TSIn &
            LoadCompact: bool

        Load(TSIn SIn) -> PStrPool64

        Parameters:
            SIn: TSIn &

        """
        return _snap.TStrPool64_Load(*args)

    Load = staticmethod(Load)
    def GetMemUsed(self):
        """
        GetMemUsed(TStrPool64 self) -> uint64

        Parameters:
            self: TStrPool64 const *

        """
        return _snap.TStrPool64_GetMemUsed(self)

    def Empty(self):
        """
        Empty(TStrPool64 self) -> bool

        Parameters:
            self: TStrPool64 const *

        """
        return _snap.TStrPool64_Empty(self)

    def Len(self):
        """
        Len(TStrPool64 self) -> uint64

        Parameters:
            self: TStrPool64 const *

        """
        return _snap.TStrPool64_Len(self)

    def Reserved(self):
        """
        Reserved(TStrPool64 self) -> uint64

        Parameters:
            self: TStrPool64 const *

        """
        return _snap.TStrPool64_Reserved(self)

    def Clr(self, DoDel=False):
        """
        Clr(TStrPool64 self, bool DoDel=False)

        Parameters:
            DoDel: bool

        Clr(TStrPool64 self)

        Parameters:
            self: TStrPool64 *

        """
        return _snap.TStrPool64_Clr(self, DoDel)

    def Cmp(self, *args):
        """
        Cmp(TStrPool64 self, uint64 Offset, char const * Str) -> int

        Parameters:
            Offset: uint64
            Str: char const *

        """
        return _snap.TStrPool64_Cmp(self, *args)

    def AddStr(self, *args):
        """
        AddStr(TStrPool64 self, TStr Str) -> uint64

        Parameters:
            Str: TStr const &

        """
        return _snap.TStrPool64_AddStr(self, *args)

TStrPool64.Save = new_instancemethod(_snap.TStrPool64_Save,None,TStrPool64)
TStrPool64.GetMemUsed = new_instancemethod(_snap.TStrPool64_GetMemUsed,None,TStrPool64)
TStrPool64.Empty = new_instancemethod(_snap.TStrPool64_Empty,None,TStrPool64)
TStrPool64.Len = new_instancemethod(_snap.TStrPool64_Len,None,TStrPool64)
TStrPool64.Reserved = new_instancemethod(_snap.TStrPool64_Reserved,None,TStrPool64)
TStrPool64.Clr = new_instancemethod(_snap.TStrPool64_Clr,None,TStrPool64)
TStrPool64.Cmp = new_instancemethod(_snap.TStrPool64_Cmp,None,TStrPool64)
TStrPool64.AddStr = new_instancemethod(_snap.TStrPool64_AddStr,None,TStrPool64)
TStrPool64_swigregister = _snap.TStrPool64_swigregister
TStrPool64_swigregister(TStrPool64)

def TStrPool64_New(MxBfL=0, GrowBy=16*1024*1024):
  """
    New(::TSize MxBfL=0, ::TSize GrowBy=16*1024*1024) -> PStrPool64

    Parameters:
        MxBfL: ::TSize
        GrowBy: ::TSize

    New(::TSize MxBfL=0) -> PStrPool64

    Parameters:
        MxBfL: ::TSize

    TStrPool64_New() -> PStrPool64
    """
  return _snap.TStrPool64_New(MxBfL, GrowBy)

def TStrPool64_Load(*args):
  """
    Load(TSIn SIn, bool LoadCompact=True) -> PStrPool64

    Parameters:
        SIn: TSIn &
        LoadCompact: bool

    TStrPool64_Load(TSIn SIn) -> PStrPool64

    Parameters:
        SIn: TSIn &

    """
  return _snap.TStrPool64_Load(*args)

class TVoid(object):
    """Proxy of C++ TVoid class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TVoid self) -> TVoid
        __init__(TVoid self, TSIn arg2) -> TVoid

        Parameters:
            arg2: TSIn &

        """
        _snap.TVoid_swiginit(self,_snap.new_TVoid(*args))
    def Save(self, *args):
        """
        Save(TVoid self, TSOut arg2)

        Parameters:
            arg2: TSOut &

        """
        return _snap.TVoid_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TVoid self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TVoid_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TVoid self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TVoid_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TVoid self, TVoid arg2) -> bool

        Parameters:
            arg2: TVoid const &

        """
        return _snap.TVoid___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TVoid self, TVoid arg2) -> bool

        Parameters:
            arg2: TVoid const &

        """
        return _snap.TVoid___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TVoid self) -> int

        Parameters:
            self: TVoid const *

        """
        return _snap.TVoid_GetMemUsed(self)

    __swig_destroy__ = _snap.delete_TVoid
TVoid.Save = new_instancemethod(_snap.TVoid_Save,None,TVoid)
TVoid.LoadXml = new_instancemethod(_snap.TVoid_LoadXml,None,TVoid)
TVoid.SaveXml = new_instancemethod(_snap.TVoid_SaveXml,None,TVoid)
TVoid.__eq__ = new_instancemethod(_snap.TVoid___eq__,None,TVoid)
TVoid.__lt__ = new_instancemethod(_snap.TVoid___lt__,None,TVoid)
TVoid.GetMemUsed = new_instancemethod(_snap.TVoid_GetMemUsed,None,TVoid)
TVoid_swigregister = _snap.TVoid_swigregister
TVoid_swigregister(TVoid)

class TBool(object):
    """Proxy of C++ TBool class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TBool_Val_get, _snap.TBool_Val_set)
    Rnd = _swig_property(_snap.TBool_Rnd_get, _snap.TBool_Rnd_set)
    def __nonzero__(self):
        return _snap.TBool___nonzero__(self)
    __bool__ = __nonzero__


    def __init__(self, *args): 
        """
        __init__(TBool self) -> TBool
        __init__(TBool self, bool const & _Val) -> TBool

        Parameters:
            _Val: bool const &

        __init__(TBool self, TSIn SIn) -> TBool

        Parameters:
            SIn: TSIn &

        """
        _snap.TBool_swiginit(self,_snap.new_TBool(*args))
    def Load(self, *args):
        """
        Load(TBool self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TBool_Load(self, *args)

    def Save(self, *args):
        """
        Save(TBool self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TBool_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TBool self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TBool_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TBool self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TBool_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TBool self, TBool Bool) -> bool

        Parameters:
            Bool: TBool const &

        """
        return _snap.TBool___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TBool self, TBool Bool) -> bool

        Parameters:
            Bool: TBool const &

        """
        return _snap.TBool___lt__(self, *args)

    def __call__(self):
        """
        __call__(TBool self) -> bool

        Parameters:
            self: TBool const *

        """
        return _snap.TBool___call__(self)

    def GetMemUsed(self):
        """
        GetMemUsed(TBool self) -> int

        Parameters:
            self: TBool const *

        """
        return _snap.TBool_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TBool self) -> int

        Parameters:
            self: TBool const *

        """
        return _snap.TBool_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TBool self) -> int

        Parameters:
            self: TBool const *

        """
        return _snap.TBool_GetSecHashCd(self)

    def GetRnd():
        """GetRnd() -> bool"""
        return _snap.TBool_GetRnd()

    GetRnd = staticmethod(GetRnd)
    def GetYNStr(*args):
        """
        GetYNStr(bool const & Val) -> TStr

        Parameters:
            Val: bool const &

        """
        return _snap.TBool_GetYNStr(*args)

    GetYNStr = staticmethod(GetYNStr)
    def GetYesNoStr(*args):
        """
        GetYesNoStr(bool const & Val) -> TStr

        Parameters:
            Val: bool const &

        """
        return _snap.TBool_GetYesNoStr(*args)

    GetYesNoStr = staticmethod(GetYesNoStr)
    def Get01Str(*args):
        """
        Get01Str(bool const & Val) -> TStr

        Parameters:
            Val: bool const &

        """
        return _snap.TBool_Get01Str(*args)

    Get01Str = staticmethod(Get01Str)
    def IsValStr(*args):
        """
        IsValStr(TStr Str) -> bool

        Parameters:
            Str: TStr const &

        """
        return _snap.TBool_IsValStr(*args)

    IsValStr = staticmethod(IsValStr)
    def GetValFromStr(*args):
        """
        GetValFromStr(TStr Str) -> bool

        Parameters:
            Str: TStr const &

        GetValFromStr(TStr Str, bool const & DfVal) -> bool

        Parameters:
            Str: TStr const &
            DfVal: bool const &

        """
        return _snap.TBool_GetValFromStr(*args)

    GetValFromStr = staticmethod(GetValFromStr)
    __swig_destroy__ = _snap.delete_TBool
TBool.Load = new_instancemethod(_snap.TBool_Load,None,TBool)
TBool.Save = new_instancemethod(_snap.TBool_Save,None,TBool)
TBool.LoadXml = new_instancemethod(_snap.TBool_LoadXml,None,TBool)
TBool.SaveXml = new_instancemethod(_snap.TBool_SaveXml,None,TBool)
TBool.__eq__ = new_instancemethod(_snap.TBool___eq__,None,TBool)
TBool.__lt__ = new_instancemethod(_snap.TBool___lt__,None,TBool)
TBool.__call__ = new_instancemethod(_snap.TBool___call__,None,TBool)
TBool.GetMemUsed = new_instancemethod(_snap.TBool_GetMemUsed,None,TBool)
TBool.GetPrimHashCd = new_instancemethod(_snap.TBool_GetPrimHashCd,None,TBool)
TBool.GetSecHashCd = new_instancemethod(_snap.TBool_GetSecHashCd,None,TBool)
TBool_swigregister = _snap.TBool_swigregister
TBool_swigregister(TBool)
TBool.Mn = _snap.cvar.TBool_Mn
TBool.Mx = _snap.cvar.TBool_Mx
TBool.Vals = _snap.cvar.TBool_Vals
TBool.FalseStr = _snap.cvar.TBool_FalseStr
TBool.TrueStr = _snap.cvar.TBool_TrueStr
TBool.NStr = _snap.cvar.TBool_NStr
TBool.YStr = _snap.cvar.TBool_YStr
TBool.NoStr = _snap.cvar.TBool_NoStr
TBool.YesStr = _snap.cvar.TBool_YesStr

def TBool_GetRnd():
  """TBool_GetRnd() -> bool"""
  return _snap.TBool_GetRnd()

def TBool_GetYNStr(*args):
  """
    TBool_GetYNStr(bool const & Val) -> TStr

    Parameters:
        Val: bool const &

    """
  return _snap.TBool_GetYNStr(*args)

def TBool_GetYesNoStr(*args):
  """
    TBool_GetYesNoStr(bool const & Val) -> TStr

    Parameters:
        Val: bool const &

    """
  return _snap.TBool_GetYesNoStr(*args)

def TBool_Get01Str(*args):
  """
    TBool_Get01Str(bool const & Val) -> TStr

    Parameters:
        Val: bool const &

    """
  return _snap.TBool_Get01Str(*args)

def TBool_IsValStr(*args):
  """
    TBool_IsValStr(TStr Str) -> bool

    Parameters:
        Str: TStr const &

    """
  return _snap.TBool_IsValStr(*args)

def TBool_GetValFromStr(*args):
  """
    GetValFromStr(TStr Str) -> bool

    Parameters:
        Str: TStr const &

    TBool_GetValFromStr(TStr Str, bool const & DfVal) -> bool

    Parameters:
        Str: TStr const &
        DfVal: bool const &

    """
  return _snap.TBool_GetValFromStr(*args)

class TCh(object):
    """Proxy of C++ TCh class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TCh_Val_get, _snap.TCh_Val_set)
    def __init__(self, *args): 
        """
        __init__(TCh self) -> TCh
        __init__(TCh self, char const & _Val) -> TCh

        Parameters:
            _Val: char const &

        __init__(TCh self, TSIn SIn) -> TCh

        Parameters:
            SIn: TSIn &

        """
        _snap.TCh_swiginit(self,_snap.new_TCh(*args))
    def Save(self, *args):
        """
        Save(TCh self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TCh_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TCh self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TCh_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TCh self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TCh_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TCh self, TCh Ch) -> bool

        Parameters:
            Ch: TCh const &

        """
        return _snap.TCh___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TCh self, TCh Ch) -> bool

        Parameters:
            Ch: TCh const &

        """
        return _snap.TCh___lt__(self, *args)

    def __call__(self):
        """
        __call__(TCh self) -> char

        Parameters:
            self: TCh const *

        """
        return _snap.TCh___call__(self)

    def GetMemUsed(self):
        """
        GetMemUsed(TCh self) -> int

        Parameters:
            self: TCh const *

        """
        return _snap.TCh_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TCh self) -> int

        Parameters:
            self: TCh const *

        """
        return _snap.TCh_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TCh self) -> int

        Parameters:
            self: TCh const *

        """
        return _snap.TCh_GetSecHashCd(self)

    def IsWs(*args):
        """
        IsWs(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsWs(*args)

    IsWs = staticmethod(IsWs)
    def IsAlpha(*args):
        """
        IsAlpha(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsAlpha(*args)

    IsAlpha = staticmethod(IsAlpha)
    def IsNum(*args):
        """
        IsNum(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsNum(*args)

    IsNum = staticmethod(IsNum)
    def IsAlNum(*args):
        """
        IsAlNum(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsAlNum(*args)

    IsAlNum = staticmethod(IsAlNum)
    def GetNum(*args):
        """
        GetNum(char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_GetNum(*args)

    GetNum = staticmethod(GetNum)
    def IsHex(*args):
        """
        IsHex(char const & Ch) -> bool

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsHex(*args)

    IsHex = staticmethod(IsHex)
    def GetHex(*args):
        """
        GetHex(char const & Ch) -> int

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_GetHex(*args)

    GetHex = staticmethod(GetHex)
    def GetHexCh(*args):
        """
        GetHexCh(int const & Val) -> char

        Parameters:
            Val: int const &

        """
        return _snap.TCh_GetHexCh(*args)

    GetHexCh = staticmethod(GetHexCh)
    def IsUc(*args):
        """
        IsUc(char const & Ch) -> char

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_IsUc(*args)

    IsUc = staticmethod(IsUc)
    def GetUc(*args):
        """
        GetUc(char const & Ch) -> char

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_GetUc(*args)

    GetUc = staticmethod(GetUc)
    def GetUsFromYuAscii(*args):
        """
        GetUsFromYuAscii(char const & Ch) -> char

        Parameters:
            Ch: char const &

        """
        return _snap.TCh_GetUsFromYuAscii(*args)

    GetUsFromYuAscii = staticmethod(GetUsFromYuAscii)
    __swig_destroy__ = _snap.delete_TCh
TCh.Save = new_instancemethod(_snap.TCh_Save,None,TCh)
TCh.LoadXml = new_instancemethod(_snap.TCh_LoadXml,None,TCh)
TCh.SaveXml = new_instancemethod(_snap.TCh_SaveXml,None,TCh)
TCh.__eq__ = new_instancemethod(_snap.TCh___eq__,None,TCh)
TCh.__lt__ = new_instancemethod(_snap.TCh___lt__,None,TCh)
TCh.__call__ = new_instancemethod(_snap.TCh___call__,None,TCh)
TCh.GetMemUsed = new_instancemethod(_snap.TCh_GetMemUsed,None,TCh)
TCh.GetPrimHashCd = new_instancemethod(_snap.TCh_GetPrimHashCd,None,TCh)
TCh.GetSecHashCd = new_instancemethod(_snap.TCh_GetSecHashCd,None,TCh)
TCh_swigregister = _snap.TCh_swigregister
TCh_swigregister(TCh)
TCh.Mn = _snap.cvar.TCh_Mn
TCh.Mx = _snap.cvar.TCh_Mx
TCh.Vals = _snap.cvar.TCh_Vals
TCh.NullCh = _snap.cvar.TCh_NullCh
TCh.TabCh = _snap.cvar.TCh_TabCh
TCh.LfCh = _snap.cvar.TCh_LfCh
TCh.CrCh = _snap.cvar.TCh_CrCh
TCh.EofCh = _snap.cvar.TCh_EofCh
TCh.HashCh = _snap.cvar.TCh_HashCh

def TCh_IsWs(*args):
  """
    TCh_IsWs(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsWs(*args)

def TCh_IsAlpha(*args):
  """
    TCh_IsAlpha(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsAlpha(*args)

def TCh_IsNum(*args):
  """
    TCh_IsNum(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsNum(*args)

def TCh_IsAlNum(*args):
  """
    TCh_IsAlNum(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsAlNum(*args)

def TCh_GetNum(*args):
  """
    TCh_GetNum(char const & Ch) -> int

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_GetNum(*args)

def TCh_IsHex(*args):
  """
    TCh_IsHex(char const & Ch) -> bool

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsHex(*args)

def TCh_GetHex(*args):
  """
    TCh_GetHex(char const & Ch) -> int

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_GetHex(*args)

def TCh_GetHexCh(*args):
  """
    TCh_GetHexCh(int const & Val) -> char

    Parameters:
        Val: int const &

    """
  return _snap.TCh_GetHexCh(*args)

def TCh_IsUc(*args):
  """
    TCh_IsUc(char const & Ch) -> char

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_IsUc(*args)

def TCh_GetUc(*args):
  """
    TCh_GetUc(char const & Ch) -> char

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_GetUc(*args)

def TCh_GetUsFromYuAscii(*args):
  """
    TCh_GetUsFromYuAscii(char const & Ch) -> char

    Parameters:
        Ch: char const &

    """
  return _snap.TCh_GetUsFromYuAscii(*args)

class TUCh(object):
    """Proxy of C++ TUCh class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TUCh_Val_get, _snap.TUCh_Val_set)
    def __init__(self, *args): 
        """
        __init__(TUCh self) -> TUCh
        __init__(TUCh self, uchar const & _Val) -> TUCh

        Parameters:
            _Val: uchar const &

        __init__(TUCh self, TSIn SIn) -> TUCh

        Parameters:
            SIn: TSIn &

        """
        _snap.TUCh_swiginit(self,_snap.new_TUCh(*args))
    def Save(self, *args):
        """
        Save(TUCh self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TUCh_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TUCh self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TUCh_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TUCh self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TUCh_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TUCh self, TUCh UCh) -> bool

        Parameters:
            UCh: TUCh const &

        """
        return _snap.TUCh___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TUCh self, TUCh UCh) -> bool

        Parameters:
            UCh: TUCh const &

        """
        return _snap.TUCh___lt__(self, *args)

    def __call__(self):
        """
        __call__(TUCh self) -> uchar

        Parameters:
            self: TUCh const *

        """
        return _snap.TUCh___call__(self)

    def GetMemUsed(self):
        """
        GetMemUsed(TUCh self) -> int

        Parameters:
            self: TUCh const *

        """
        return _snap.TUCh_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TUCh self) -> int

        Parameters:
            self: TUCh const *

        """
        return _snap.TUCh_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TUCh self) -> int

        Parameters:
            self: TUCh const *

        """
        return _snap.TUCh_GetSecHashCd(self)

    __swig_destroy__ = _snap.delete_TUCh
TUCh.Save = new_instancemethod(_snap.TUCh_Save,None,TUCh)
TUCh.LoadXml = new_instancemethod(_snap.TUCh_LoadXml,None,TUCh)
TUCh.SaveXml = new_instancemethod(_snap.TUCh_SaveXml,None,TUCh)
TUCh.__eq__ = new_instancemethod(_snap.TUCh___eq__,None,TUCh)
TUCh.__lt__ = new_instancemethod(_snap.TUCh___lt__,None,TUCh)
TUCh.__call__ = new_instancemethod(_snap.TUCh___call__,None,TUCh)
TUCh.GetMemUsed = new_instancemethod(_snap.TUCh_GetMemUsed,None,TUCh)
TUCh.GetPrimHashCd = new_instancemethod(_snap.TUCh_GetPrimHashCd,None,TUCh)
TUCh.GetSecHashCd = new_instancemethod(_snap.TUCh_GetSecHashCd,None,TUCh)
TUCh_swigregister = _snap.TUCh_swigregister
TUCh_swigregister(TUCh)
TUCh.Mn = _snap.cvar.TUCh_Mn
TUCh.Mx = _snap.cvar.TUCh_Mx
TUCh.Vals = _snap.cvar.TUCh_Vals

class TSInt(object):
    """Proxy of C++ TSInt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TSInt_Val_get, _snap.TSInt_Val_set)
    def __init__(self, *args): 
        """
        __init__(TSInt self) -> TSInt
        __init__(TSInt self, int16 const & _Val) -> TSInt

        Parameters:
            _Val: int16 const &

        __init__(TSInt self, TSIn SIn) -> TSInt

        Parameters:
            SIn: TSIn &

        """
        _snap.TSInt_swiginit(self,_snap.new_TSInt(*args))
    def Load(self, *args):
        """
        Load(TSInt self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TSInt_Load(self, *args)

    def Save(self, *args):
        """
        Save(TSInt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TSInt_Save(self, *args)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TSInt self) -> int

        Parameters:
            self: TSInt const *

        """
        return _snap.TSInt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TSInt self) -> int

        Parameters:
            self: TSInt const *

        """
        return _snap.TSInt_GetSecHashCd(self)

    __swig_destroy__ = _snap.delete_TSInt
TSInt.Load = new_instancemethod(_snap.TSInt_Load,None,TSInt)
TSInt.Save = new_instancemethod(_snap.TSInt_Save,None,TSInt)
TSInt.GetPrimHashCd = new_instancemethod(_snap.TSInt_GetPrimHashCd,None,TSInt)
TSInt.GetSecHashCd = new_instancemethod(_snap.TSInt_GetSecHashCd,None,TSInt)
TSInt_swigregister = _snap.TSInt_swigregister
TSInt_swigregister(TSInt)

class TInt(object):
    """Proxy of C++ TInt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TInt_Val_get, _snap.TInt_Val_set)
    Rnd = _swig_property(_snap.TInt_Rnd_get, _snap.TInt_Rnd_set)
    def __init__(self, *args): 
        """
        __init__(TInt self) -> TInt
        __init__(TInt self, int const & _Val) -> TInt

        Parameters:
            _Val: int const &

        __init__(TInt self, TSIn SIn) -> TInt

        Parameters:
            SIn: TSIn &

        """
        _snap.TInt_swiginit(self,_snap.new_TInt(*args))
    def Load(self, *args):
        """
        Load(TInt self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TInt_Load(self, *args)

    def Save(self, *args):
        """
        Save(TInt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TInt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TInt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TInt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TInt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TInt_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TInt self, TInt Int) -> bool

        Parameters:
            Int: TInt const &

        __eq__(TInt self, int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TInt self, int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TInt self, TInt Int) -> bool

        Parameters:
            Int: TInt const &

        __lt__(TInt self, int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt___lt__(self, *args)

    def __call__(self):
        """
        __call__(TInt self) -> int

        Parameters:
            self: TInt const *

        """
        return _snap.TInt___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TInt self, int const & Int) -> TInt

        Parameters:
            Int: int const &

        """
        return _snap.TInt___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TInt self, int const & Int) -> TInt

        Parameters:
            Int: int const &

        """
        return _snap.TInt___isub__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TInt self) -> int

        Parameters:
            self: TInt const *

        """
        return _snap.TInt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TInt self) -> int

        Parameters:
            self: TInt const *

        """
        return _snap.TInt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TInt self) -> int

        Parameters:
            self: TInt const *

        """
        return _snap.TInt_GetSecHashCd(self)

    def Abs(*args):
        """
        Abs(int const & Int) -> int

        Parameters:
            Int: int const &

        """
        return _snap.TInt_Abs(*args)

    Abs = staticmethod(Abs)
    def Sign(*args):
        """
        Sign(int const & Int) -> int

        Parameters:
            Int: int const &

        """
        return _snap.TInt_Sign(*args)

    Sign = staticmethod(Sign)
    def Swap(*args):
        """
        Swap(int & Int1, int & Int2)

        Parameters:
            Int1: int &
            Int2: int &

        """
        return _snap.TInt_Swap(*args)

    Swap = staticmethod(Swap)
    def GetRnd(Range=0):
        """
        GetRnd(int const & Range=0) -> int

        Parameters:
            Range: int const &

        GetRnd() -> int
        """
        return _snap.TInt_GetRnd(Range)

    GetRnd = staticmethod(GetRnd)
    def IsOdd(*args):
        """
        IsOdd(int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt_IsOdd(*args)

    IsOdd = staticmethod(IsOdd)
    def IsEven(*args):
        """
        IsEven(int const & Int) -> bool

        Parameters:
            Int: int const &

        """
        return _snap.TInt_IsEven(*args)

    IsEven = staticmethod(IsEven)
    def GetMn(*args):
        """
        GetMn(int const & Int1, int const & Int2) -> int

        Parameters:
            Int1: int const &
            Int2: int const &

        GetMn(int const & Int1, int const & Int2, int const & Int3) -> int

        Parameters:
            Int1: int const &
            Int2: int const &
            Int3: int const &

        GetMn(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int

        Parameters:
            Int1: int const &
            Int2: int const &
            Int3: int const &
            Int4: int const &

        """
        return _snap.TInt_GetMn(*args)

    GetMn = staticmethod(GetMn)
    def GetMx(*args):
        """
        GetMx(int const & Int1, int const & Int2) -> int

        Parameters:
            Int1: int const &
            Int2: int const &

        GetMx(int const & Int1, int const & Int2, int const & Int3) -> int

        Parameters:
            Int1: int const &
            Int2: int const &
            Int3: int const &

        GetMx(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int

        Parameters:
            Int1: int const &
            Int2: int const &
            Int3: int const &
            Int4: int const &

        """
        return _snap.TInt_GetMx(*args)

    GetMx = staticmethod(GetMx)
    def GetInRng(*args):
        """
        GetInRng(int const & Val, int const & Mn, int const & Mx) -> int

        Parameters:
            Val: int const &
            Mn: int const &
            Mx: int const &

        """
        return _snap.TInt_GetInRng(*args)

    GetInRng = staticmethod(GetInRng)
    def GetHexStr(*args):
        """
        GetHexStr(int const & Val) -> TStr

        Parameters:
            Val: int const &

        GetHexStr(TInt Int) -> TStr

        Parameters:
            Int: TInt const &

        """
        return _snap.TInt_GetHexStr(*args)

    GetHexStr = staticmethod(GetHexStr)
    def GetKiloStr(*args):
        """
        GetKiloStr(int const & Val) -> TStr

        Parameters:
            Val: int const &

        """
        return _snap.TInt_GetKiloStr(*args)

    GetKiloStr = staticmethod(GetKiloStr)
    def GetMegaStr(*args):
        """
        GetMegaStr(int const & Val) -> TStr

        Parameters:
            Val: int const &

        """
        return _snap.TInt_GetMegaStr(*args)

    GetMegaStr = staticmethod(GetMegaStr)
    def SaveFrugalInt(*args):
        """
        SaveFrugalInt(char * pDest, int i) -> char *

        Parameters:
            pDest: char *
            i: int

        """
        return _snap.TInt_SaveFrugalInt(*args)

    SaveFrugalInt = staticmethod(SaveFrugalInt)
    def LoadFrugalInt(*args):
        """
        LoadFrugalInt(char * pSrc, int & i) -> char *

        Parameters:
            pSrc: char *
            i: int &

        """
        return _snap.TInt_LoadFrugalInt(*args)

    LoadFrugalInt = staticmethod(LoadFrugalInt)
    def TestFrugalInt():
        """TestFrugalInt()"""
        return _snap.TInt_TestFrugalInt()

    TestFrugalInt = staticmethod(TestFrugalInt)
    def SaveFrugalIntV(*args):
        """
        SaveFrugalIntV(TSOut SOut, TIntV IntV)

        Parameters:
            SOut: TSOut &
            IntV: TVec< TInt,int > const &

        """
        return _snap.TInt_SaveFrugalIntV(*args)

    SaveFrugalIntV = staticmethod(SaveFrugalIntV)
    def LoadFrugalIntV(*args):
        """
        LoadFrugalIntV(TSIn SIn, TIntV IntV, bool ClrP=True)

        Parameters:
            SIn: TSIn &
            IntV: TVec< TInt,int > &
            ClrP: bool

        LoadFrugalIntV(TSIn SIn, TIntV IntV)

        Parameters:
            SIn: TSIn &
            IntV: TVec< TInt,int > &

        """
        return _snap.TInt_LoadFrugalIntV(*args)

    LoadFrugalIntV = staticmethod(LoadFrugalIntV)
    __swig_destroy__ = _snap.delete_TInt
TInt.Load = new_instancemethod(_snap.TInt_Load,None,TInt)
TInt.Save = new_instancemethod(_snap.TInt_Save,None,TInt)
TInt.LoadXml = new_instancemethod(_snap.TInt_LoadXml,None,TInt)
TInt.SaveXml = new_instancemethod(_snap.TInt_SaveXml,None,TInt)
TInt.__eq__ = new_instancemethod(_snap.TInt___eq__,None,TInt)
TInt.__ne__ = new_instancemethod(_snap.TInt___ne__,None,TInt)
TInt.__lt__ = new_instancemethod(_snap.TInt___lt__,None,TInt)
TInt.__call__ = new_instancemethod(_snap.TInt___call__,None,TInt)
TInt.__iadd__ = new_instancemethod(_snap.TInt___iadd__,None,TInt)
TInt.__isub__ = new_instancemethod(_snap.TInt___isub__,None,TInt)
TInt.GetMemUsed = new_instancemethod(_snap.TInt_GetMemUsed,None,TInt)
TInt.GetPrimHashCd = new_instancemethod(_snap.TInt_GetPrimHashCd,None,TInt)
TInt.GetSecHashCd = new_instancemethod(_snap.TInt_GetSecHashCd,None,TInt)
TInt_swigregister = _snap.TInt_swigregister
TInt_swigregister(TInt)
TInt.Mn = _snap.cvar.TInt_Mn
TInt.Mx = _snap.cvar.TInt_Mx
TInt.Kilo = _snap.cvar.TInt_Kilo
TInt.Mega = _snap.cvar.TInt_Mega
TInt.Giga = _snap.cvar.TInt_Giga

def TInt_Abs(*args):
  """
    TInt_Abs(int const & Int) -> int

    Parameters:
        Int: int const &

    """
  return _snap.TInt_Abs(*args)

def TInt_Sign(*args):
  """
    TInt_Sign(int const & Int) -> int

    Parameters:
        Int: int const &

    """
  return _snap.TInt_Sign(*args)

def TInt_Swap(*args):
  """
    TInt_Swap(int & Int1, int & Int2)

    Parameters:
        Int1: int &
        Int2: int &

    """
  return _snap.TInt_Swap(*args)

def TInt_GetRnd(Range=0):
  """
    GetRnd(int const & Range=0) -> int

    Parameters:
        Range: int const &

    TInt_GetRnd() -> int
    """
  return _snap.TInt_GetRnd(Range)

def TInt_IsOdd(*args):
  """
    TInt_IsOdd(int const & Int) -> bool

    Parameters:
        Int: int const &

    """
  return _snap.TInt_IsOdd(*args)

def TInt_IsEven(*args):
  """
    TInt_IsEven(int const & Int) -> bool

    Parameters:
        Int: int const &

    """
  return _snap.TInt_IsEven(*args)

def TInt_GetMn(*args):
  """
    GetMn(int const & Int1, int const & Int2) -> int

    Parameters:
        Int1: int const &
        Int2: int const &

    GetMn(int const & Int1, int const & Int2, int const & Int3) -> int

    Parameters:
        Int1: int const &
        Int2: int const &
        Int3: int const &

    TInt_GetMn(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int

    Parameters:
        Int1: int const &
        Int2: int const &
        Int3: int const &
        Int4: int const &

    """
  return _snap.TInt_GetMn(*args)

def TInt_GetMx(*args):
  """
    GetMx(int const & Int1, int const & Int2) -> int

    Parameters:
        Int1: int const &
        Int2: int const &

    GetMx(int const & Int1, int const & Int2, int const & Int3) -> int

    Parameters:
        Int1: int const &
        Int2: int const &
        Int3: int const &

    TInt_GetMx(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int

    Parameters:
        Int1: int const &
        Int2: int const &
        Int3: int const &
        Int4: int const &

    """
  return _snap.TInt_GetMx(*args)

def TInt_GetInRng(*args):
  """
    TInt_GetInRng(int const & Val, int const & Mn, int const & Mx) -> int

    Parameters:
        Val: int const &
        Mn: int const &
        Mx: int const &

    """
  return _snap.TInt_GetInRng(*args)

def TInt_GetHexStr(*args):
  """
    GetHexStr(int const & Val) -> TStr

    Parameters:
        Val: int const &

    TInt_GetHexStr(TInt Int) -> TStr

    Parameters:
        Int: TInt const &

    """
  return _snap.TInt_GetHexStr(*args)

def TInt_GetKiloStr(*args):
  """
    TInt_GetKiloStr(int const & Val) -> TStr

    Parameters:
        Val: int const &

    """
  return _snap.TInt_GetKiloStr(*args)

def TInt_GetMegaStr(*args):
  """
    TInt_GetMegaStr(int const & Val) -> TStr

    Parameters:
        Val: int const &

    """
  return _snap.TInt_GetMegaStr(*args)

def TInt_SaveFrugalInt(*args):
  """
    TInt_SaveFrugalInt(char * pDest, int i) -> char *

    Parameters:
        pDest: char *
        i: int

    """
  return _snap.TInt_SaveFrugalInt(*args)

def TInt_LoadFrugalInt(*args):
  """
    TInt_LoadFrugalInt(char * pSrc, int & i) -> char *

    Parameters:
        pSrc: char *
        i: int &

    """
  return _snap.TInt_LoadFrugalInt(*args)

def TInt_TestFrugalInt():
  """TInt_TestFrugalInt()"""
  return _snap.TInt_TestFrugalInt()

def TInt_SaveFrugalIntV(*args):
  """
    TInt_SaveFrugalIntV(TSOut SOut, TIntV IntV)

    Parameters:
        SOut: TSOut &
        IntV: TVec< TInt,int > const &

    """
  return _snap.TInt_SaveFrugalIntV(*args)

def TInt_LoadFrugalIntV(*args):
  """
    LoadFrugalIntV(TSIn SIn, TIntV IntV, bool ClrP=True)

    Parameters:
        SIn: TSIn &
        IntV: TVec< TInt,int > &
        ClrP: bool

    TInt_LoadFrugalIntV(TSIn SIn, TIntV IntV)

    Parameters:
        SIn: TSIn &
        IntV: TVec< TInt,int > &

    """
  return _snap.TInt_LoadFrugalIntV(*args)

class TUInt(object):
    """Proxy of C++ TUInt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TUInt_Val_get, _snap.TUInt_Val_set)
    Rnd = _swig_property(_snap.TUInt_Rnd_get, _snap.TUInt_Rnd_set)
    def __init__(self, *args): 
        """
        __init__(TUInt self) -> TUInt
        __init__(TUInt self, uint const & _Val) -> TUInt

        Parameters:
            _Val: uint const &

        __init__(TUInt self, TSIn SIn) -> TUInt

        Parameters:
            SIn: TSIn &

        """
        _snap.TUInt_swiginit(self,_snap.new_TUInt(*args))
    def Load(self, *args):
        """
        Load(TUInt self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TUInt_Load(self, *args)

    def Save(self, *args):
        """
        Save(TUInt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TUInt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TUInt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TUInt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TUInt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TUInt_SaveXml(self, *args)

    def __call__(self, *args):
        """
        __call__(TUInt self) -> uint
        __call__(TUInt self) -> uint &

        Parameters:
            self: TUInt *

        """
        return _snap.TUInt___call__(self, *args)

    def __invert__(self):
        """
        __invert__(TUInt self) -> TUInt

        Parameters:
            self: TUInt *

        """
        return _snap.TUInt___invert__(self)

    def __iand__(self, *args):
        """
        __iand__(TUInt self, TUInt UInt) -> TUInt

        Parameters:
            UInt: TUInt const &

        """
        return _snap.TUInt___iand__(self, *args)

    def __ior__(self, *args):
        """
        __ior__(TUInt self, TUInt UInt) -> TUInt

        Parameters:
            UInt: TUInt const &

        """
        return _snap.TUInt___ior__(self, *args)

    def __ixor__(self, *args):
        """
        __ixor__(TUInt self, TUInt UInt) -> TUInt

        Parameters:
            UInt: TUInt const &

        """
        return _snap.TUInt___ixor__(self, *args)

    def __irshift__(self, *args):
        """
        __irshift__(TUInt self, int const & ShiftBits) -> TUInt

        Parameters:
            ShiftBits: int const &

        """
        return _snap.TUInt___irshift__(self, *args)

    def __ilshift__(self, *args):
        """
        __ilshift__(TUInt self, int const & ShiftBits) -> TUInt

        Parameters:
            ShiftBits: int const &

        """
        return _snap.TUInt___ilshift__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TUInt self) -> int

        Parameters:
            self: TUInt const *

        """
        return _snap.TUInt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TUInt self) -> int

        Parameters:
            self: TUInt const *

        """
        return _snap.TUInt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TUInt self) -> int

        Parameters:
            self: TUInt const *

        """
        return _snap.TUInt_GetSecHashCd(self)

    def GetRnd(Range=0):
        """
        GetRnd(uint const & Range=0) -> uint

        Parameters:
            Range: uint const &

        GetRnd() -> uint
        """
        return _snap.TUInt_GetRnd(Range)

    GetRnd = staticmethod(GetRnd)
    def GetKiloStr(*args):
        """
        GetKiloStr(uint const & Val) -> TStr

        Parameters:
            Val: uint const &

        """
        return _snap.TUInt_GetKiloStr(*args)

    GetKiloStr = staticmethod(GetKiloStr)
    def GetMegaStr(*args):
        """
        GetMegaStr(uint const & Val) -> TStr

        Parameters:
            Val: uint const &

        """
        return _snap.TUInt_GetMegaStr(*args)

    GetMegaStr = staticmethod(GetMegaStr)
    def JavaUIntToCppUInt(*args):
        """
        JavaUIntToCppUInt(uint const & JavaUInt) -> uint

        Parameters:
            JavaUInt: uint const &

        """
        return _snap.TUInt_JavaUIntToCppUInt(*args)

    JavaUIntToCppUInt = staticmethod(JavaUIntToCppUInt)
    def IsIpStr(*args):
        """
        IsIpStr(TStr IpStr, uint & Ip, char const & SplitCh='.') -> bool

        Parameters:
            IpStr: TStr const &
            Ip: uint &
            SplitCh: char const &

        IsIpStr(TStr IpStr, uint & Ip) -> bool

        Parameters:
            IpStr: TStr const &
            Ip: uint &

        IsIpStr(TStr IpStr, char const & SplitCh='.') -> bool

        Parameters:
            IpStr: TStr const &
            SplitCh: char const &

        IsIpStr(TStr IpStr) -> bool

        Parameters:
            IpStr: TStr const &

        """
        return _snap.TUInt_IsIpStr(*args)

    IsIpStr = staticmethod(IsIpStr)
    def GetUIntFromIpStr(*args):
        """
        GetUIntFromIpStr(TStr IpStr, char const & SplitCh='.') -> uint

        Parameters:
            IpStr: TStr const &
            SplitCh: char const &

        GetUIntFromIpStr(TStr IpStr) -> uint

        Parameters:
            IpStr: TStr const &

        """
        return _snap.TUInt_GetUIntFromIpStr(*args)

    GetUIntFromIpStr = staticmethod(GetUIntFromIpStr)
    def GetStrFromIpUInt(*args):
        """
        GetStrFromIpUInt(uint const & Ip) -> TStr

        Parameters:
            Ip: uint const &

        """
        return _snap.TUInt_GetStrFromIpUInt(*args)

    GetStrFromIpUInt = staticmethod(GetStrFromIpUInt)
    def IsIpv6Str(*args):
        """
        IsIpv6Str(TStr IpStr, char const & SplitCh=':') -> bool

        Parameters:
            IpStr: TStr const &
            SplitCh: char const &

        IsIpv6Str(TStr IpStr) -> bool

        Parameters:
            IpStr: TStr const &

        """
        return _snap.TUInt_IsIpv6Str(*args)

    IsIpv6Str = staticmethod(IsIpv6Str)
    __swig_destroy__ = _snap.delete_TUInt
TUInt.Load = new_instancemethod(_snap.TUInt_Load,None,TUInt)
TUInt.Save = new_instancemethod(_snap.TUInt_Save,None,TUInt)
TUInt.LoadXml = new_instancemethod(_snap.TUInt_LoadXml,None,TUInt)
TUInt.SaveXml = new_instancemethod(_snap.TUInt_SaveXml,None,TUInt)
TUInt.__call__ = new_instancemethod(_snap.TUInt___call__,None,TUInt)
TUInt.__invert__ = new_instancemethod(_snap.TUInt___invert__,None,TUInt)
TUInt.__iand__ = new_instancemethod(_snap.TUInt___iand__,None,TUInt)
TUInt.__ior__ = new_instancemethod(_snap.TUInt___ior__,None,TUInt)
TUInt.__ixor__ = new_instancemethod(_snap.TUInt___ixor__,None,TUInt)
TUInt.__irshift__ = new_instancemethod(_snap.TUInt___irshift__,None,TUInt)
TUInt.__ilshift__ = new_instancemethod(_snap.TUInt___ilshift__,None,TUInt)
TUInt.GetMemUsed = new_instancemethod(_snap.TUInt_GetMemUsed,None,TUInt)
TUInt.GetPrimHashCd = new_instancemethod(_snap.TUInt_GetPrimHashCd,None,TUInt)
TUInt.GetSecHashCd = new_instancemethod(_snap.TUInt_GetSecHashCd,None,TUInt)
TUInt_swigregister = _snap.TUInt_swigregister
TUInt_swigregister(TUInt)
TUInt.Mn = _snap.cvar.TUInt_Mn
TUInt.Mx = _snap.cvar.TUInt_Mx

def TUInt_GetRnd(Range=0):
  """
    GetRnd(uint const & Range=0) -> uint

    Parameters:
        Range: uint const &

    TUInt_GetRnd() -> uint
    """
  return _snap.TUInt_GetRnd(Range)

def TUInt_GetKiloStr(*args):
  """
    TUInt_GetKiloStr(uint const & Val) -> TStr

    Parameters:
        Val: uint const &

    """
  return _snap.TUInt_GetKiloStr(*args)

def TUInt_GetMegaStr(*args):
  """
    TUInt_GetMegaStr(uint const & Val) -> TStr

    Parameters:
        Val: uint const &

    """
  return _snap.TUInt_GetMegaStr(*args)

def TUInt_JavaUIntToCppUInt(*args):
  """
    TUInt_JavaUIntToCppUInt(uint const & JavaUInt) -> uint

    Parameters:
        JavaUInt: uint const &

    """
  return _snap.TUInt_JavaUIntToCppUInt(*args)

def TUInt_IsIpStr(*args):
  """
    IsIpStr(TStr IpStr, uint & Ip, char const & SplitCh='.') -> bool

    Parameters:
        IpStr: TStr const &
        Ip: uint &
        SplitCh: char const &

    IsIpStr(TStr IpStr, uint & Ip) -> bool

    Parameters:
        IpStr: TStr const &
        Ip: uint &

    IsIpStr(TStr IpStr, char const & SplitCh='.') -> bool

    Parameters:
        IpStr: TStr const &
        SplitCh: char const &

    TUInt_IsIpStr(TStr IpStr) -> bool

    Parameters:
        IpStr: TStr const &

    """
  return _snap.TUInt_IsIpStr(*args)

def TUInt_GetUIntFromIpStr(*args):
  """
    GetUIntFromIpStr(TStr IpStr, char const & SplitCh='.') -> uint

    Parameters:
        IpStr: TStr const &
        SplitCh: char const &

    TUInt_GetUIntFromIpStr(TStr IpStr) -> uint

    Parameters:
        IpStr: TStr const &

    """
  return _snap.TUInt_GetUIntFromIpStr(*args)

def TUInt_GetStrFromIpUInt(*args):
  """
    TUInt_GetStrFromIpUInt(uint const & Ip) -> TStr

    Parameters:
        Ip: uint const &

    """
  return _snap.TUInt_GetStrFromIpUInt(*args)

def TUInt_IsIpv6Str(*args):
  """
    IsIpv6Str(TStr IpStr, char const & SplitCh=':') -> bool

    Parameters:
        IpStr: TStr const &
        SplitCh: char const &

    TUInt_IsIpv6Str(TStr IpStr) -> bool

    Parameters:
        IpStr: TStr const &

    """
  return _snap.TUInt_IsIpv6Str(*args)

class TUInt64(object):
    """Proxy of C++ TUInt64 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TUInt64_Val_get, _snap.TUInt64_Val_set)
    def __init__(self, *args): 
        """
        __init__(TUInt64 self) -> TUInt64
        __init__(TUInt64 self, TUInt64 Int) -> TUInt64

        Parameters:
            Int: TUInt64 const &

        __init__(TUInt64 self, uint64 const & Int) -> TUInt64

        Parameters:
            Int: uint64 const &

        __init__(TUInt64 self, uint const & MsVal, uint const & LsVal) -> TUInt64

        Parameters:
            MsVal: uint const &
            LsVal: uint const &

        __init__(TUInt64 self, void * Pt) -> TUInt64

        Parameters:
            Pt: void *

        __init__(TUInt64 self, TSIn SIn) -> TUInt64

        Parameters:
            SIn: TSIn &

        """
        _snap.TUInt64_swiginit(self,_snap.new_TUInt64(*args))
    def Load(self, *args):
        """
        Load(TUInt64 self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TUInt64_Load(self, *args)

    def Save(self, *args):
        """
        Save(TUInt64 self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TUInt64_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TUInt64 self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TUInt64_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TUInt64 self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TUInt64_SaveXml(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(TUInt64 self, TUInt64 Int) -> TUInt64

        Parameters:
            Int: TUInt64 const &

        """
        return _snap.TUInt64___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TUInt64 self, TUInt64 Int) -> TUInt64

        Parameters:
            Int: TUInt64 const &

        """
        return _snap.TUInt64___isub__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TUInt64 self) -> int

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TUInt64 self) -> int

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TUInt64 self) -> int

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetSecHashCd(self)

    def GetMsVal(self):
        """
        GetMsVal(TUInt64 self) -> uint

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetMsVal(self)

    def GetLsVal(self):
        """
        GetLsVal(TUInt64 self) -> uint

        Parameters:
            self: TUInt64 const *

        """
        return _snap.TUInt64_GetLsVal(self)

    def GetHexStr(*args):
        """
        GetHexStr(TUInt64 Int) -> TStr

        Parameters:
            Int: TUInt64 const &

        """
        return _snap.TUInt64_GetHexStr(*args)

    GetHexStr = staticmethod(GetHexStr)
    def GetKiloStr(*args):
        """
        GetKiloStr(uint64 const & Val) -> TStr

        Parameters:
            Val: uint64 const &

        """
        return _snap.TUInt64_GetKiloStr(*args)

    GetKiloStr = staticmethod(GetKiloStr)
    def GetMegaStr(*args):
        """
        GetMegaStr(uint64 const & Val) -> TStr

        Parameters:
            Val: uint64 const &

        """
        return _snap.TUInt64_GetMegaStr(*args)

    GetMegaStr = staticmethod(GetMegaStr)
    __swig_destroy__ = _snap.delete_TUInt64
TUInt64.Load = new_instancemethod(_snap.TUInt64_Load,None,TUInt64)
TUInt64.Save = new_instancemethod(_snap.TUInt64_Save,None,TUInt64)
TUInt64.LoadXml = new_instancemethod(_snap.TUInt64_LoadXml,None,TUInt64)
TUInt64.SaveXml = new_instancemethod(_snap.TUInt64_SaveXml,None,TUInt64)
TUInt64.__iadd__ = new_instancemethod(_snap.TUInt64___iadd__,None,TUInt64)
TUInt64.__isub__ = new_instancemethod(_snap.TUInt64___isub__,None,TUInt64)
TUInt64.GetMemUsed = new_instancemethod(_snap.TUInt64_GetMemUsed,None,TUInt64)
TUInt64.GetPrimHashCd = new_instancemethod(_snap.TUInt64_GetPrimHashCd,None,TUInt64)
TUInt64.GetSecHashCd = new_instancemethod(_snap.TUInt64_GetSecHashCd,None,TUInt64)
TUInt64.GetMsVal = new_instancemethod(_snap.TUInt64_GetMsVal,None,TUInt64)
TUInt64.GetLsVal = new_instancemethod(_snap.TUInt64_GetLsVal,None,TUInt64)
TUInt64_swigregister = _snap.TUInt64_swigregister
TUInt64_swigregister(TUInt64)
TUInt64.Mn = _snap.cvar.TUInt64_Mn
TUInt64.Mx = _snap.cvar.TUInt64_Mx

def TUInt64_GetHexStr(*args):
  """
    TUInt64_GetHexStr(TUInt64 Int) -> TStr

    Parameters:
        Int: TUInt64 const &

    """
  return _snap.TUInt64_GetHexStr(*args)

def TUInt64_GetKiloStr(*args):
  """
    TUInt64_GetKiloStr(uint64 const & Val) -> TStr

    Parameters:
        Val: uint64 const &

    """
  return _snap.TUInt64_GetKiloStr(*args)

def TUInt64_GetMegaStr(*args):
  """
    TUInt64_GetMegaStr(uint64 const & Val) -> TStr

    Parameters:
        Val: uint64 const &

    """
  return _snap.TUInt64_GetMegaStr(*args)

class TFlt(object):
    """Proxy of C++ TFlt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TFlt_Val_get, _snap.TFlt_Val_set)
    Rnd = _swig_property(_snap.TFlt_Rnd_get, _snap.TFlt_Rnd_set)
    def __init__(self, *args): 
        """
        __init__(TFlt self) -> TFlt
        __init__(TFlt self, double const & _Val) -> TFlt

        Parameters:
            _Val: double const &

        __init__(TFlt self, TSIn SIn) -> TFlt

        Parameters:
            SIn: TSIn &

        __init__(TFlt self, TSIn SIn, bool const & IsTxt) -> TFlt

        Parameters:
            SIn: TSIn &
            IsTxt: bool const &

        """
        _snap.TFlt_swiginit(self,_snap.new_TFlt(*args))
    def Load(self, *args):
        """
        Load(TFlt self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TFlt_Load(self, *args)

    def Save(self, *args):
        """
        Save(TFlt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        Save(TFlt self, TSOut SOut, bool const & IsTxt)

        Parameters:
            SOut: TSOut &
            IsTxt: bool const &

        """
        return _snap.TFlt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TFlt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TFlt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TFlt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TFlt_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TFlt self, TFlt Flt) -> bool

        Parameters:
            Flt: TFlt const &

        __eq__(TFlt self, double const & Flt) -> bool

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TFlt self, double const & Flt) -> bool

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___ne__(self, *args)

    def __call__(self):
        """
        __call__(TFlt self) -> double

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TFlt self, double const & Flt) -> TFlt

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TFlt self, double const & Flt) -> TFlt

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___isub__(self, *args)

    def __imul__(self, *args):
        """
        __imul__(TFlt self, double const & Flt) -> TFlt

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(TFlt self, double const & Flt) -> TFlt

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt___idiv__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TFlt self) -> int

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TFlt self) -> int

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TFlt self) -> int

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_GetSecHashCd(self)

    def Abs(*args):
        """
        Abs(double const & Flt) -> double

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt_Abs(*args)

    Abs = staticmethod(Abs)
    def Sign(*args):
        """
        Sign(double const & Flt) -> int

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt_Sign(*args)

    Sign = staticmethod(Sign)
    def Round(*args):
        """
        Round(double const & Flt) -> int

        Parameters:
            Flt: double const &

        """
        return _snap.TFlt_Round(*args)

    Round = staticmethod(Round)
    def GetRnd():
        """GetRnd() -> double"""
        return _snap.TFlt_GetRnd()

    GetRnd = staticmethod(GetRnd)
    def Eq6(*args):
        """
        Eq6(double const & LFlt, double const & RFlt) -> bool

        Parameters:
            LFlt: double const &
            RFlt: double const &

        """
        return _snap.TFlt_Eq6(*args)

    Eq6 = staticmethod(Eq6)
    def GetMn(*args):
        """
        GetMn(double const & Flt1, double const & Flt2) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &

        GetMn(double const & Flt1, double const & Flt2, double const & Flt3) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &
            Flt3: double const &

        GetMn(double const & Flt1, double const & Flt2, double const & Flt3, double const & Flt4) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &
            Flt3: double const &
            Flt4: double const &

        """
        return _snap.TFlt_GetMn(*args)

    GetMn = staticmethod(GetMn)
    def GetMx(*args):
        """
        GetMx(double const & Flt1, double const & Flt2) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &

        GetMx(double const & Flt1, double const & Flt2, double const Flt3) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &
            Flt3: double const

        GetMx(double const & Flt1, double const & Flt2, double const Flt3, double const & Flt4) -> double

        Parameters:
            Flt1: double const &
            Flt2: double const &
            Flt3: double const
            Flt4: double const &

        """
        return _snap.TFlt_GetMx(*args)

    GetMx = staticmethod(GetMx)
    def GetInRng(*args):
        """
        GetInRng(double const & Val, double const & Mn, double const & Mx) -> double

        Parameters:
            Val: double const &
            Mn: double const &
            Mx: double const &

        """
        return _snap.TFlt_GetInRng(*args)

    GetInRng = staticmethod(GetInRng)
    def IsNum(self, *args):
        """
        IsNum(TFlt self, double const & Val) -> bool

        Parameters:
            Val: double const &

        IsNum(TFlt self) -> bool

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_IsNum(self, *args)

    def IsNan(self, *args):
        """
        IsNan(TFlt self, double const & Val) -> bool

        Parameters:
            Val: double const &

        IsNan(TFlt self) -> bool

        Parameters:
            self: TFlt const *

        """
        return _snap.TFlt_IsNan(self, *args)

    def GetPrcStr(*args):
        """
        GetPrcStr(double const & RelVal, double const & FullVal) -> TStr

        Parameters:
            RelVal: double const &
            FullVal: double const &

        """
        return _snap.TFlt_GetPrcStr(*args)

    GetPrcStr = staticmethod(GetPrcStr)
    def GetKiloStr(*args):
        """
        GetKiloStr(double const & Val) -> TStr

        Parameters:
            Val: double const &

        """
        return _snap.TFlt_GetKiloStr(*args)

    GetKiloStr = staticmethod(GetKiloStr)
    def GetMegaStr(*args):
        """
        GetMegaStr(double const & Val) -> TStr

        Parameters:
            Val: double const &

        """
        return _snap.TFlt_GetMegaStr(*args)

    GetMegaStr = staticmethod(GetMegaStr)
    def GetGigaStr(*args):
        """
        GetGigaStr(double const & Val) -> TStr

        Parameters:
            Val: double const &

        """
        return _snap.TFlt_GetGigaStr(*args)

    GetGigaStr = staticmethod(GetGigaStr)
    __swig_destroy__ = _snap.delete_TFlt
TFlt.Load = new_instancemethod(_snap.TFlt_Load,None,TFlt)
TFlt.Save = new_instancemethod(_snap.TFlt_Save,None,TFlt)
TFlt.LoadXml = new_instancemethod(_snap.TFlt_LoadXml,None,TFlt)
TFlt.SaveXml = new_instancemethod(_snap.TFlt_SaveXml,None,TFlt)
TFlt.__eq__ = new_instancemethod(_snap.TFlt___eq__,None,TFlt)
TFlt.__ne__ = new_instancemethod(_snap.TFlt___ne__,None,TFlt)
TFlt.__call__ = new_instancemethod(_snap.TFlt___call__,None,TFlt)
TFlt.__iadd__ = new_instancemethod(_snap.TFlt___iadd__,None,TFlt)
TFlt.__isub__ = new_instancemethod(_snap.TFlt___isub__,None,TFlt)
TFlt.__imul__ = new_instancemethod(_snap.TFlt___imul__,None,TFlt)
TFlt.__idiv__ = new_instancemethod(_snap.TFlt___idiv__,None,TFlt)
TFlt.GetMemUsed = new_instancemethod(_snap.TFlt_GetMemUsed,None,TFlt)
TFlt.GetPrimHashCd = new_instancemethod(_snap.TFlt_GetPrimHashCd,None,TFlt)
TFlt.GetSecHashCd = new_instancemethod(_snap.TFlt_GetSecHashCd,None,TFlt)
TFlt.IsNum = new_instancemethod(_snap.TFlt_IsNum,None,TFlt)
TFlt.IsNan = new_instancemethod(_snap.TFlt_IsNan,None,TFlt)
TFlt_swigregister = _snap.TFlt_swigregister
TFlt_swigregister(TFlt)
TFlt.Mn = _snap.cvar.TFlt_Mn
TFlt.Mx = _snap.cvar.TFlt_Mx
TFlt.NInf = _snap.cvar.TFlt_NInf
TFlt.PInf = _snap.cvar.TFlt_PInf
TFlt.Eps = _snap.cvar.TFlt_Eps
TFlt.EpsHalf = _snap.cvar.TFlt_EpsHalf

def TFlt_Abs(*args):
  """
    TFlt_Abs(double const & Flt) -> double

    Parameters:
        Flt: double const &

    """
  return _snap.TFlt_Abs(*args)

def TFlt_Sign(*args):
  """
    TFlt_Sign(double const & Flt) -> int

    Parameters:
        Flt: double const &

    """
  return _snap.TFlt_Sign(*args)

def TFlt_Round(*args):
  """
    TFlt_Round(double const & Flt) -> int

    Parameters:
        Flt: double const &

    """
  return _snap.TFlt_Round(*args)

def TFlt_GetRnd():
  """TFlt_GetRnd() -> double"""
  return _snap.TFlt_GetRnd()

def TFlt_Eq6(*args):
  """
    TFlt_Eq6(double const & LFlt, double const & RFlt) -> bool

    Parameters:
        LFlt: double const &
        RFlt: double const &

    """
  return _snap.TFlt_Eq6(*args)

def TFlt_GetMn(*args):
  """
    GetMn(double const & Flt1, double const & Flt2) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &

    GetMn(double const & Flt1, double const & Flt2, double const & Flt3) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &
        Flt3: double const &

    TFlt_GetMn(double const & Flt1, double const & Flt2, double const & Flt3, double const & Flt4) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &
        Flt3: double const &
        Flt4: double const &

    """
  return _snap.TFlt_GetMn(*args)

def TFlt_GetMx(*args):
  """
    GetMx(double const & Flt1, double const & Flt2) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &

    GetMx(double const & Flt1, double const & Flt2, double const Flt3) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &
        Flt3: double const

    TFlt_GetMx(double const & Flt1, double const & Flt2, double const Flt3, double const & Flt4) -> double

    Parameters:
        Flt1: double const &
        Flt2: double const &
        Flt3: double const
        Flt4: double const &

    """
  return _snap.TFlt_GetMx(*args)

def TFlt_GetInRng(*args):
  """
    TFlt_GetInRng(double const & Val, double const & Mn, double const & Mx) -> double

    Parameters:
        Val: double const &
        Mn: double const &
        Mx: double const &

    """
  return _snap.TFlt_GetInRng(*args)

def TFlt_GetPrcStr(*args):
  """
    TFlt_GetPrcStr(double const & RelVal, double const & FullVal) -> TStr

    Parameters:
        RelVal: double const &
        FullVal: double const &

    """
  return _snap.TFlt_GetPrcStr(*args)

def TFlt_GetKiloStr(*args):
  """
    TFlt_GetKiloStr(double const & Val) -> TStr

    Parameters:
        Val: double const &

    """
  return _snap.TFlt_GetKiloStr(*args)

def TFlt_GetMegaStr(*args):
  """
    TFlt_GetMegaStr(double const & Val) -> TStr

    Parameters:
        Val: double const &

    """
  return _snap.TFlt_GetMegaStr(*args)

def TFlt_GetGigaStr(*args):
  """
    TFlt_GetGigaStr(double const & Val) -> TStr

    Parameters:
        Val: double const &

    """
  return _snap.TFlt_GetGigaStr(*args)

class TAscFlt(TFlt):
    """Proxy of C++ TAscFlt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TAscFlt self) -> TAscFlt
        __init__(TAscFlt self, double const & Val) -> TAscFlt

        Parameters:
            Val: double const &

        __init__(TAscFlt self, TSIn SIn) -> TAscFlt

        Parameters:
            SIn: TSIn &

        """
        _snap.TAscFlt_swiginit(self,_snap.new_TAscFlt(*args))
    def Save(self, *args):
        """
        Save(TAscFlt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TAscFlt_Save(self, *args)

    __swig_destroy__ = _snap.delete_TAscFlt
TAscFlt.Save = new_instancemethod(_snap.TAscFlt_Save,None,TAscFlt)
TAscFlt_swigregister = _snap.TAscFlt_swigregister
TAscFlt_swigregister(TAscFlt)

class TSFlt(object):
    """Proxy of C++ TSFlt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TSFlt_Val_get, _snap.TSFlt_Val_set)
    def __init__(self, *args): 
        """
        __init__(TSFlt self) -> TSFlt
        __init__(TSFlt self, sdouble const & _Val) -> TSFlt

        Parameters:
            _Val: sdouble const &

        __init__(TSFlt self, TSIn SIn) -> TSFlt

        Parameters:
            SIn: TSIn &

        """
        _snap.TSFlt_swiginit(self,_snap.new_TSFlt(*args))
    def Save(self, *args):
        """
        Save(TSFlt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TSFlt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TSFlt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TSFlt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TSFlt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TSFlt_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TSFlt self, TSFlt SFlt) -> bool

        Parameters:
            SFlt: TSFlt const &

        __eq__(TSFlt self, double const & Flt) -> bool

        Parameters:
            Flt: double const &

        """
        return _snap.TSFlt___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TSFlt self, double const & Flt) -> bool

        Parameters:
            Flt: double const &

        """
        return _snap.TSFlt___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TSFlt self, TSFlt SFlt) -> bool

        Parameters:
            SFlt: TSFlt const &

        """
        return _snap.TSFlt___lt__(self, *args)

    def __call__(self):
        """
        __call__(TSFlt self) -> sdouble

        Parameters:
            self: TSFlt const *

        """
        return _snap.TSFlt___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TSFlt self, double const & SFlt) -> TSFlt

        Parameters:
            SFlt: double const &

        """
        return _snap.TSFlt___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TSFlt self, double const & SFlt) -> TSFlt

        Parameters:
            SFlt: double const &

        """
        return _snap.TSFlt___isub__(self, *args)

    def __imul__(self, *args):
        """
        __imul__(TSFlt self, double const & SFlt) -> TSFlt

        Parameters:
            SFlt: double const &

        """
        return _snap.TSFlt___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(TSFlt self, double const & SFlt) -> TSFlt

        Parameters:
            SFlt: double const &

        """
        return _snap.TSFlt___idiv__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TSFlt self) -> int

        Parameters:
            self: TSFlt const *

        """
        return _snap.TSFlt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TSFlt self) -> int

        Parameters:
            self: TSFlt const *

        """
        return _snap.TSFlt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TSFlt self) -> int

        Parameters:
            self: TSFlt const *

        """
        return _snap.TSFlt_GetSecHashCd(self)

    __swig_destroy__ = _snap.delete_TSFlt
TSFlt.Save = new_instancemethod(_snap.TSFlt_Save,None,TSFlt)
TSFlt.LoadXml = new_instancemethod(_snap.TSFlt_LoadXml,None,TSFlt)
TSFlt.SaveXml = new_instancemethod(_snap.TSFlt_SaveXml,None,TSFlt)
TSFlt.__eq__ = new_instancemethod(_snap.TSFlt___eq__,None,TSFlt)
TSFlt.__ne__ = new_instancemethod(_snap.TSFlt___ne__,None,TSFlt)
TSFlt.__lt__ = new_instancemethod(_snap.TSFlt___lt__,None,TSFlt)
TSFlt.__call__ = new_instancemethod(_snap.TSFlt___call__,None,TSFlt)
TSFlt.__iadd__ = new_instancemethod(_snap.TSFlt___iadd__,None,TSFlt)
TSFlt.__isub__ = new_instancemethod(_snap.TSFlt___isub__,None,TSFlt)
TSFlt.__imul__ = new_instancemethod(_snap.TSFlt___imul__,None,TSFlt)
TSFlt.__idiv__ = new_instancemethod(_snap.TSFlt___idiv__,None,TSFlt)
TSFlt.GetMemUsed = new_instancemethod(_snap.TSFlt_GetMemUsed,None,TSFlt)
TSFlt.GetPrimHashCd = new_instancemethod(_snap.TSFlt_GetPrimHashCd,None,TSFlt)
TSFlt.GetSecHashCd = new_instancemethod(_snap.TSFlt_GetSecHashCd,None,TSFlt)
TSFlt_swigregister = _snap.TSFlt_swigregister
TSFlt_swigregister(TSFlt)
TSFlt.Mn = _snap.cvar.TSFlt_Mn
TSFlt.Mx = _snap.cvar.TSFlt_Mx

class TLFlt(object):
    """Proxy of C++ TLFlt class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Val = _swig_property(_snap.TLFlt_Val_get, _snap.TLFlt_Val_set)
    def __init__(self, *args): 
        """
        __init__(TLFlt self) -> TLFlt
        __init__(TLFlt self, ldouble const & _Val) -> TLFlt

        Parameters:
            _Val: ldouble const &

        __init__(TLFlt self, TSIn SIn) -> TLFlt

        Parameters:
            SIn: TSIn &

        """
        _snap.TLFlt_swiginit(self,_snap.new_TLFlt(*args))
    def Save(self, *args):
        """
        Save(TLFlt self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TLFlt_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TLFlt self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TLFlt_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TLFlt self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TLFlt_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TLFlt self, TLFlt LFlt) -> bool

        Parameters:
            LFlt: TLFlt const &

        __eq__(TLFlt self, ldouble const & LFlt) -> bool

        Parameters:
            LFlt: ldouble const &

        """
        return _snap.TLFlt___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(TLFlt self, ldouble const & LFlt) -> bool

        Parameters:
            LFlt: ldouble const &

        """
        return _snap.TLFlt___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TLFlt self, TLFlt LFlt) -> bool

        Parameters:
            LFlt: TLFlt const &

        """
        return _snap.TLFlt___lt__(self, *args)

    def __call__(self):
        """
        __call__(TLFlt self) -> ldouble

        Parameters:
            self: TLFlt const *

        """
        return _snap.TLFlt___call__(self)

    def __iadd__(self, *args):
        """
        __iadd__(TLFlt self, ldouble const & LFlt) -> TLFlt

        Parameters:
            LFlt: ldouble const &

        """
        return _snap.TLFlt___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(TLFlt self, ldouble const & LFlt) -> TLFlt

        Parameters:
            LFlt: ldouble const &

        """
        return _snap.TLFlt___isub__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TLFlt self) -> int

        Parameters:
            self: TLFlt const *

        """
        return _snap.TLFlt_GetMemUsed(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TLFlt self) -> int

        Parameters:
            self: TLFlt const *

        """
        return _snap.TLFlt_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TLFlt self) -> int

        Parameters:
            self: TLFlt const *

        """
        return _snap.TLFlt_GetSecHashCd(self)

    __swig_destroy__ = _snap.delete_TLFlt
TLFlt.Save = new_instancemethod(_snap.TLFlt_Save,None,TLFlt)
TLFlt.LoadXml = new_instancemethod(_snap.TLFlt_LoadXml,None,TLFlt)
TLFlt.SaveXml = new_instancemethod(_snap.TLFlt_SaveXml,None,TLFlt)
TLFlt.__eq__ = new_instancemethod(_snap.TLFlt___eq__,None,TLFlt)
TLFlt.__ne__ = new_instancemethod(_snap.TLFlt___ne__,None,TLFlt)
TLFlt.__lt__ = new_instancemethod(_snap.TLFlt___lt__,None,TLFlt)
TLFlt.__call__ = new_instancemethod(_snap.TLFlt___call__,None,TLFlt)
TLFlt.__iadd__ = new_instancemethod(_snap.TLFlt___iadd__,None,TLFlt)
TLFlt.__isub__ = new_instancemethod(_snap.TLFlt___isub__,None,TLFlt)
TLFlt.GetMemUsed = new_instancemethod(_snap.TLFlt_GetMemUsed,None,TLFlt)
TLFlt.GetPrimHashCd = new_instancemethod(_snap.TLFlt_GetPrimHashCd,None,TLFlt)
TLFlt.GetSecHashCd = new_instancemethod(_snap.TLFlt_GetSecHashCd,None,TLFlt)
TLFlt_swigregister = _snap.TLFlt_swigregister
TLFlt_swigregister(TLFlt)
TLFlt.Mn = _snap.cvar.TLFlt_Mn
TLFlt.Mx = _snap.cvar.TLFlt_Mx

class TFltRect(object):
    """Proxy of C++ TFltRect class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    MnX = _swig_property(_snap.TFltRect_MnX_get, _snap.TFltRect_MnX_set)
    MnY = _swig_property(_snap.TFltRect_MnY_get, _snap.TFltRect_MnY_set)
    MxX = _swig_property(_snap.TFltRect_MxX_get, _snap.TFltRect_MxX_set)
    MxY = _swig_property(_snap.TFltRect_MxY_get, _snap.TFltRect_MxY_set)
    def __init__(self, *args): 
        """
        __init__(TFltRect self) -> TFltRect
        __init__(TFltRect self, TFltRect FltRect) -> TFltRect

        Parameters:
            FltRect: TFltRect const &

        __init__(TFltRect self, double const & _MnX, double const & _MnY, double const & _MxX, double const & _MxY) -> TFltRect

        Parameters:
            _MnX: double const &
            _MnY: double const &
            _MxX: double const &
            _MxY: double const &

        __init__(TFltRect self, TSIn SIn) -> TFltRect

        Parameters:
            SIn: TSIn &

        """
        _snap.TFltRect_swiginit(self,_snap.new_TFltRect(*args))
    def Save(self, *args):
        """
        Save(TFltRect self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TFltRect_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TFltRect self, PXmlTok const & XmlTok, TStr Nm)

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        """
        return _snap.TFltRect_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TFltRect self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TFltRect_SaveXml(self, *args)

    def GetMnX(self):
        """
        GetMnX(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetMnX(self)

    def GetMnY(self):
        """
        GetMnY(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetMnY(self)

    def GetMxX(self):
        """
        GetMxX(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetMxX(self)

    def GetMxY(self):
        """
        GetMxY(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetMxY(self)

    def GetXLen(self):
        """
        GetXLen(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetXLen(self)

    def GetYLen(self):
        """
        GetYLen(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetYLen(self)

    def GetXCenter(self):
        """
        GetXCenter(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetXCenter(self)

    def GetYCenter(self):
        """
        GetYCenter(TFltRect self) -> double

        Parameters:
            self: TFltRect const *

        """
        return _snap.TFltRect_GetYCenter(self)

    def IsXYIn(self, *args):
        """
        IsXYIn(TFltRect self, double const & X, double const & Y) -> bool

        Parameters:
            X: double const &
            Y: double const &

        """
        return _snap.TFltRect_IsXYIn(self, *args)

    def Intersection(*args):
        """
        Intersection(TFltRect Rect1, TFltRect Rect2) -> bool

        Parameters:
            Rect1: TFltRect const &
            Rect2: TFltRect const &

        """
        return _snap.TFltRect_Intersection(*args)

    Intersection = staticmethod(Intersection)
    __swig_destroy__ = _snap.delete_TFltRect
TFltRect.Save = new_instancemethod(_snap.TFltRect_Save,None,TFltRect)
TFltRect.LoadXml = new_instancemethod(_snap.TFltRect_LoadXml,None,TFltRect)
TFltRect.SaveXml = new_instancemethod(_snap.TFltRect_SaveXml,None,TFltRect)
TFltRect.GetMnX = new_instancemethod(_snap.TFltRect_GetMnX,None,TFltRect)
TFltRect.GetMnY = new_instancemethod(_snap.TFltRect_GetMnY,None,TFltRect)
TFltRect.GetMxX = new_instancemethod(_snap.TFltRect_GetMxX,None,TFltRect)
TFltRect.GetMxY = new_instancemethod(_snap.TFltRect_GetMxY,None,TFltRect)
TFltRect.GetXLen = new_instancemethod(_snap.TFltRect_GetXLen,None,TFltRect)
TFltRect.GetYLen = new_instancemethod(_snap.TFltRect_GetYLen,None,TFltRect)
TFltRect.GetXCenter = new_instancemethod(_snap.TFltRect_GetXCenter,None,TFltRect)
TFltRect.GetYCenter = new_instancemethod(_snap.TFltRect_GetYCenter,None,TFltRect)
TFltRect.IsXYIn = new_instancemethod(_snap.TFltRect_IsXYIn,None,TFltRect)
TFltRect_swigregister = _snap.TFltRect_swigregister
TFltRect_swigregister(TFltRect)

def TFltRect_Intersection(*args):
  """
    TFltRect_Intersection(TFltRect Rect1, TFltRect Rect2) -> bool

    Parameters:
        Rect1: TFltRect const &
        Rect2: TFltRect const &

    """
  return _snap.TFltRect_Intersection(*args)

class TIntV(object):
    """Proxy of C++ TVec<(TInt,int)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TIntV
    def __init__(self, *args): 
        """
        __init__(TVec<(TInt,int)> self) -> TIntV
        __init__(TVec<(TInt,int)> self, TIntV Vec) -> TIntV

        Parameters:
            Vec: TVec< TInt,int > const &

        __init__(TVec<(TInt,int)> self, int const & _Vals) -> TIntV

        Parameters:
            _Vals: int const &

        __init__(TVec<(TInt,int)> self, int const & _MxVals, int const & _Vals) -> TIntV

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        __init__(TVec<(TInt,int)> self, TInt _ValT, int const & _Vals) -> TIntV

        Parameters:
            _ValT: TInt *
            _Vals: int const &

        __init__(TVec<(TInt,int)> self, TSIn SIn) -> TIntV

        Parameters:
            SIn: TSIn &

        """
        _snap.TIntV_swiginit(self,_snap.new_TIntV(*args))
    def Load(self, *args):
        """
        Load(TIntV self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TIntV_Load(self, *args)

    def Save(self, *args):
        """
        Save(TIntV self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TIntV_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TIntV self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TIntV self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TIntV_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TIntV self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TIntV_SaveXml(self, *args)

    def __add__(self, *args):
        """
        __add__(TIntV self, TInt Val) -> TIntV

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV___add__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TIntV self, TIntV Vec) -> bool

        Parameters:
            Vec: TVec< TInt,int > const &

        """
        return _snap.TIntV___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntV self, TIntV Vec) -> bool

        Parameters:
            Vec: TVec< TInt,int > const &

        """
        return _snap.TIntV___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetMemUsed(self)

    def GetMemSize(self):
        """
        GetMemSize(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetMemSize(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetSecHashCd(self)

    def Gen(self, *args):
        """
        Gen(TIntV self, int const & _Vals)

        Parameters:
            _Vals: int const &

        Gen(TIntV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TIntV_Gen(self, *args)

    def GenExt(self, *args):
        """
        GenExt(TIntV self, TInt _ValT, int const & _Vals)

        Parameters:
            _ValT: TInt *
            _Vals: int const &

        """
        return _snap.TIntV_GenExt(self, *args)

    def IsExt(self):
        """
        IsExt(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_IsExt(self)

    def Reserve(self, *args):
        """
        Reserve(TIntV self, int const & _MxVals)

        Parameters:
            _MxVals: int const &

        Reserve(TIntV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TIntV_Reserve(self, *args)

    def Clr(self, *args):
        """
        Clr(TIntV self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TIntV self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Clr(self, *args)

    def Trunc(self, *args):
        """
        Trunc(TIntV self, int const & _Vals=-1)

        Parameters:
            _Vals: int const &

        Trunc(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Trunc(self, *args)

    def Pack(self):
        """
        Pack(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Pack(self)

    def MoveFrom(self, *args):
        """
        MoveFrom(TIntV self, TIntV Vec)

        Parameters:
            Vec: TVec< TInt,int > &

        """
        return _snap.TIntV_MoveFrom(self, *args)

    def Empty(self):
        """
        Empty(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_Empty(self)

    def Len(self):
        """
        Len(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_Len(self)

    def Reserved(self):
        """
        Reserved(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_Reserved(self)

    def Last(self, *args):
        """
        Last(TIntV self) -> TInt
        Last(TIntV self) -> TInt

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Last(self, *args)

    def LastValN(self):
        """
        LastValN(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_LastValN(self)

    def LastLast(self, *args):
        """
        LastLast(TIntV self) -> TInt
        LastLast(TIntV self) -> TInt

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_LastLast(self, *args)

    def BegI(self):
        """
        BegI(TIntV self) -> TInt

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_BegI(self)

    def EndI(self):
        """
        EndI(TIntV self) -> TInt

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_EndI(self)

    def GetI(self, *args):
        """
        GetI(TIntV self, int const & ValN) -> TInt

        Parameters:
            ValN: int const &

        """
        return _snap.TIntV_GetI(self, *args)

    def AddV(self, *args):
        """
        AddV(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_AddV(self, *args)

    def AddSorted(self, *args):
        """
        AddSorted(TIntV self, TInt Val, bool const & Asc=True, int const & _MxVals=-1) -> int

        Parameters:
            Val: TInt const &
            Asc: bool const &
            _MxVals: int const &

        AddSorted(TIntV self, TInt Val, bool const & Asc=True) -> int

        Parameters:
            Val: TInt const &
            Asc: bool const &

        AddSorted(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_AddSorted(self, *args)

    def AddBackSorted(self, *args):
        """
        AddBackSorted(TIntV self, TInt Val, bool const & Asc) -> int

        Parameters:
            Val: TInt const &
            Asc: bool const &

        """
        return _snap.TIntV_AddBackSorted(self, *args)

    def AddVMerged(self, *args):
        """
        AddVMerged(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_AddVMerged(self, *args)

    def AddUnique(self, *args):
        """
        AddUnique(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_AddUnique(self, *args)

    def GetVal(self, *args):
        """
        GetVal(TIntV self, int const & ValN) -> TInt

        Parameters:
            ValN: int const &

        GetVal(TIntV self, int const & ValN) -> TInt

        Parameters:
            ValN: int const &

        """
        return _snap.TIntV_GetVal(self, *args)

    def GetSubValV(self, *args):
        """
        GetSubValV(TIntV self, int const & BValN, int const & EValN, TIntV ValV)

        Parameters:
            BValN: int const &
            EValN: int const &
            ValV: TVec< TInt,int > &

        """
        return _snap.TIntV_GetSubValV(self, *args)

    def Ins(self, *args):
        """
        Ins(TIntV self, int const & ValN, TInt Val)

        Parameters:
            ValN: int const &
            Val: TInt const &

        """
        return _snap.TIntV_Ins(self, *args)

    def Del(self, *args):
        """
        Del(TIntV self, int const & ValN)

        Parameters:
            ValN: int const &

        Del(TIntV self, int const & MnValN, int const & MxValN)

        Parameters:
            MnValN: int const &
            MxValN: int const &

        """
        return _snap.TIntV_Del(self, *args)

    def DelLast(self):
        """
        DelLast(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_DelLast(self)

    def DelIfIn(self, *args):
        """
        DelIfIn(TIntV self, TInt Val) -> bool

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_DelIfIn(self, *args)

    def DelAll(self, *args):
        """
        DelAll(TIntV self, TInt Val)

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_DelAll(self, *args)

    def PutAll(self, *args):
        """
        PutAll(TIntV self, TInt Val)

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_PutAll(self, *args)

    def Swap(self, *args):
        """
        Swap(TIntV self, TIntV Vec)

        Parameters:
            Vec: TVec< TInt,int > &

        Swap(TIntV self, int const & ValN1, int const & ValN2)

        Parameters:
            ValN1: int const &
            ValN2: int const &

        """
        return _snap.TIntV_Swap(self, *args)

    def SwapI(*args):
        """
        SwapI(TInt LVal, TInt RVal)

        Parameters:
            LVal: TVec< TInt,int >::TIter
            RVal: TVec< TInt,int >::TIter

        """
        return _snap.TIntV_SwapI(*args)

    SwapI = staticmethod(SwapI)
    def NextPerm(self):
        """
        NextPerm(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_NextPerm(self)

    def PrevPerm(self):
        """
        PrevPerm(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_PrevPerm(self)

    def GetPivotValN(self, *args):
        """
        GetPivotValN(TIntV self, int const & LValN, int const & RValN) -> int

        Parameters:
            LValN: int const &
            RValN: int const &

        """
        return _snap.TIntV_GetPivotValN(self, *args)

    def BSort(self, *args):
        """
        BSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntV_BSort(self, *args)

    def ISort(self, *args):
        """
        ISort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntV_ISort(self, *args)

    def Partition(self, *args):
        """
        Partition(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntV_Partition(self, *args)

    def QSort(self, *args):
        """
        QSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntV_QSort(self, *args)

    def Sort(self, Asc=True):
        """
        Sort(TIntV self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        Sort(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Sort(self, Asc)

    def IsSorted(self, Asc=True):
        """
        IsSorted(TIntV self, bool const & Asc=True) -> bool

        Parameters:
            Asc: bool const &

        IsSorted(TIntV self) -> bool

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_IsSorted(self, Asc)

    def Shuffle(self, *args):
        """
        Shuffle(TIntV self, TRnd Rnd)

        Parameters:
            Rnd: TRnd &

        """
        return _snap.TIntV_Shuffle(self, *args)

    def Reverse(self, *args):
        """
        Reverse(TIntV self)
        Reverse(TIntV self, int LValN, int RValN)

        Parameters:
            LValN: int
            RValN: int

        """
        return _snap.TIntV_Reverse(self, *args)

    def Merge(self):
        """
        Merge(TIntV self)

        Parameters:
            self: TVec< TInt,int > *

        """
        return _snap.TIntV_Merge(self)

    def Intrs(self, *args):
        """
        Intrs(TIntV self, TIntV ValV)

        Parameters:
            ValV: TVec< TInt,int > const &

        Intrs(TIntV self, TIntV ValV, TIntV DstValV)

        Parameters:
            ValV: TVec< TInt,int > const &
            DstValV: TVec< TInt,int > &

        """
        return _snap.TIntV_Intrs(self, *args)

    def Union(self, *args):
        """
        Union(TIntV self, TIntV ValV)

        Parameters:
            ValV: TVec< TInt,int > const &

        Union(TIntV self, TIntV ValV, TIntV DstValV)

        Parameters:
            ValV: TVec< TInt,int > const &
            DstValV: TVec< TInt,int > &

        """
        return _snap.TIntV_Union(self, *args)

    def Diff(self, *args):
        """
        Diff(TIntV self, TIntV ValV)

        Parameters:
            ValV: TVec< TInt,int > const &

        Diff(TIntV self, TIntV ValV, TIntV DstValV)

        Parameters:
            ValV: TVec< TInt,int > const &
            DstValV: TVec< TInt,int > &

        """
        return _snap.TIntV_Diff(self, *args)

    def IntrsLen(self, *args):
        """
        IntrsLen(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_IntrsLen(self, *args)

    def UnionLen(self, *args):
        """
        UnionLen(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_UnionLen(self, *args)

    def Count(self, *args):
        """
        Count(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_Count(self, *args)

    def SearchBin(self, *args):
        """
        SearchBin(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        SearchBin(TIntV self, TInt Val, int & InsValN) -> int

        Parameters:
            Val: TInt const &
            InsValN: int &

        """
        return _snap.TIntV_SearchBin(self, *args)

    def SearchForw(self, *args):
        """
        SearchForw(TIntV self, TInt Val, int const & BValN=0) -> int

        Parameters:
            Val: TInt const &
            BValN: int const &

        SearchForw(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_SearchForw(self, *args)

    def SearchBack(self, *args):
        """
        SearchBack(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_SearchBack(self, *args)

    def SearchVForw(self, *args):
        """
        SearchVForw(TIntV self, TIntV ValV, int const & BValN=0) -> int

        Parameters:
            ValV: TVec< TInt,int > const &
            BValN: int const &

        SearchVForw(TIntV self, TIntV ValV) -> int

        Parameters:
            ValV: TVec< TInt,int > const &

        """
        return _snap.TIntV_SearchVForw(self, *args)

    def IsIn(self, *args):
        """
        IsIn(TIntV self, TInt Val) -> bool

        Parameters:
            Val: TInt const &

        IsIn(TIntV self, TInt Val, int & ValN) -> bool

        Parameters:
            Val: TInt const &
            ValN: int &

        """
        return _snap.TIntV_IsIn(self, *args)

    def IsInBin(self, *args):
        """
        IsInBin(TIntV self, TInt Val) -> bool

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_IsInBin(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TIntV self, TInt Val) -> TInt

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_GetDat(self, *args)

    def GetAddDat(self, *args):
        """
        GetAddDat(TIntV self, TInt Val) -> TInt

        Parameters:
            Val: TInt const &

        """
        return _snap.TIntV_GetAddDat(self, *args)

    def GetMxValN(self):
        """
        GetMxValN(TIntV self) -> int

        Parameters:
            self: TVec< TInt,int > const *

        """
        return _snap.TIntV_GetMxValN(self)

    def GetV(*args):
        """
        GetV(TInt Val1) -> TIntV

        Parameters:
            Val1: TInt const &

        GetV(TInt Val1, TInt Val2) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &
            Val6: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &
            Val6: TInt const &
            Val7: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &
            Val6: TInt const &
            Val7: TInt const &
            Val8: TInt const &

        GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8, 
            TInt Val9) -> TIntV

        Parameters:
            Val1: TInt const &
            Val2: TInt const &
            Val3: TInt const &
            Val4: TInt const &
            Val5: TInt const &
            Val6: TInt const &
            Val7: TInt const &
            Val8: TInt const &
            Val9: TInt const &

        """
        return _snap.TIntV_GetV(*args)

    GetV = staticmethod(GetV)
    def Add(self, *args):
        """
        Add(TIntV self) -> int
        Add(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        Add(TIntV self, TInt Val, int const & ResizeLen) -> int

        Parameters:
            Val: TInt const &
            ResizeLen: int const &

        Add(TIntV self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntV_Add(self, *args)

    def AddMerged(self, *args):
        """
        AddMerged(TIntV self, TInt Val) -> int

        Parameters:
            Val: TInt const &

        AddMerged(TIntV self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntV_AddMerged(self, *args)

TIntV.Load = new_instancemethod(_snap.TIntV_Load,None,TIntV)
TIntV.Save = new_instancemethod(_snap.TIntV_Save,None,TIntV)
TIntV.LoadXml = new_instancemethod(_snap.TIntV_LoadXml,None,TIntV)
TIntV.SaveXml = new_instancemethod(_snap.TIntV_SaveXml,None,TIntV)
TIntV.__add__ = new_instancemethod(_snap.TIntV___add__,None,TIntV)
TIntV.__eq__ = new_instancemethod(_snap.TIntV___eq__,None,TIntV)
TIntV.__lt__ = new_instancemethod(_snap.TIntV___lt__,None,TIntV)
TIntV.GetMemUsed = new_instancemethod(_snap.TIntV_GetMemUsed,None,TIntV)
TIntV.GetMemSize = new_instancemethod(_snap.TIntV_GetMemSize,None,TIntV)
TIntV.GetPrimHashCd = new_instancemethod(_snap.TIntV_GetPrimHashCd,None,TIntV)
TIntV.GetSecHashCd = new_instancemethod(_snap.TIntV_GetSecHashCd,None,TIntV)
TIntV.Gen = new_instancemethod(_snap.TIntV_Gen,None,TIntV)
TIntV.GenExt = new_instancemethod(_snap.TIntV_GenExt,None,TIntV)
TIntV.IsExt = new_instancemethod(_snap.TIntV_IsExt,None,TIntV)
TIntV.Reserve = new_instancemethod(_snap.TIntV_Reserve,None,TIntV)
TIntV.Clr = new_instancemethod(_snap.TIntV_Clr,None,TIntV)
TIntV.Trunc = new_instancemethod(_snap.TIntV_Trunc,None,TIntV)
TIntV.Pack = new_instancemethod(_snap.TIntV_Pack,None,TIntV)
TIntV.MoveFrom = new_instancemethod(_snap.TIntV_MoveFrom,None,TIntV)
TIntV.Empty = new_instancemethod(_snap.TIntV_Empty,None,TIntV)
TIntV.Len = new_instancemethod(_snap.TIntV_Len,None,TIntV)
TIntV.Reserved = new_instancemethod(_snap.TIntV_Reserved,None,TIntV)
TIntV.Last = new_instancemethod(_snap.TIntV_Last,None,TIntV)
TIntV.LastValN = new_instancemethod(_snap.TIntV_LastValN,None,TIntV)
TIntV.LastLast = new_instancemethod(_snap.TIntV_LastLast,None,TIntV)
TIntV.BegI = new_instancemethod(_snap.TIntV_BegI,None,TIntV)
TIntV.EndI = new_instancemethod(_snap.TIntV_EndI,None,TIntV)
TIntV.GetI = new_instancemethod(_snap.TIntV_GetI,None,TIntV)
TIntV.AddV = new_instancemethod(_snap.TIntV_AddV,None,TIntV)
TIntV.AddSorted = new_instancemethod(_snap.TIntV_AddSorted,None,TIntV)
TIntV.AddBackSorted = new_instancemethod(_snap.TIntV_AddBackSorted,None,TIntV)
TIntV.AddVMerged = new_instancemethod(_snap.TIntV_AddVMerged,None,TIntV)
TIntV.AddUnique = new_instancemethod(_snap.TIntV_AddUnique,None,TIntV)
TIntV.GetVal = new_instancemethod(_snap.TIntV_GetVal,None,TIntV)
TIntV.GetSubValV = new_instancemethod(_snap.TIntV_GetSubValV,None,TIntV)
TIntV.Ins = new_instancemethod(_snap.TIntV_Ins,None,TIntV)
TIntV.Del = new_instancemethod(_snap.TIntV_Del,None,TIntV)
TIntV.DelLast = new_instancemethod(_snap.TIntV_DelLast,None,TIntV)
TIntV.DelIfIn = new_instancemethod(_snap.TIntV_DelIfIn,None,TIntV)
TIntV.DelAll = new_instancemethod(_snap.TIntV_DelAll,None,TIntV)
TIntV.PutAll = new_instancemethod(_snap.TIntV_PutAll,None,TIntV)
TIntV.Swap = new_instancemethod(_snap.TIntV_Swap,None,TIntV)
TIntV.NextPerm = new_instancemethod(_snap.TIntV_NextPerm,None,TIntV)
TIntV.PrevPerm = new_instancemethod(_snap.TIntV_PrevPerm,None,TIntV)
TIntV.GetPivotValN = new_instancemethod(_snap.TIntV_GetPivotValN,None,TIntV)
TIntV.BSort = new_instancemethod(_snap.TIntV_BSort,None,TIntV)
TIntV.ISort = new_instancemethod(_snap.TIntV_ISort,None,TIntV)
TIntV.Partition = new_instancemethod(_snap.TIntV_Partition,None,TIntV)
TIntV.QSort = new_instancemethod(_snap.TIntV_QSort,None,TIntV)
TIntV.Sort = new_instancemethod(_snap.TIntV_Sort,None,TIntV)
TIntV.IsSorted = new_instancemethod(_snap.TIntV_IsSorted,None,TIntV)
TIntV.Shuffle = new_instancemethod(_snap.TIntV_Shuffle,None,TIntV)
TIntV.Reverse = new_instancemethod(_snap.TIntV_Reverse,None,TIntV)
TIntV.Merge = new_instancemethod(_snap.TIntV_Merge,None,TIntV)
TIntV.Intrs = new_instancemethod(_snap.TIntV_Intrs,None,TIntV)
TIntV.Union = new_instancemethod(_snap.TIntV_Union,None,TIntV)
TIntV.Diff = new_instancemethod(_snap.TIntV_Diff,None,TIntV)
TIntV.IntrsLen = new_instancemethod(_snap.TIntV_IntrsLen,None,TIntV)
TIntV.UnionLen = new_instancemethod(_snap.TIntV_UnionLen,None,TIntV)
TIntV.Count = new_instancemethod(_snap.TIntV_Count,None,TIntV)
TIntV.SearchBin = new_instancemethod(_snap.TIntV_SearchBin,None,TIntV)
TIntV.SearchForw = new_instancemethod(_snap.TIntV_SearchForw,None,TIntV)
TIntV.SearchBack = new_instancemethod(_snap.TIntV_SearchBack,None,TIntV)
TIntV.SearchVForw = new_instancemethod(_snap.TIntV_SearchVForw,None,TIntV)
TIntV.IsIn = new_instancemethod(_snap.TIntV_IsIn,None,TIntV)
TIntV.IsInBin = new_instancemethod(_snap.TIntV_IsInBin,None,TIntV)
TIntV.GetDat = new_instancemethod(_snap.TIntV_GetDat,None,TIntV)
TIntV.GetAddDat = new_instancemethod(_snap.TIntV_GetAddDat,None,TIntV)
TIntV.GetMxValN = new_instancemethod(_snap.TIntV_GetMxValN,None,TIntV)
TIntV.Add = new_instancemethod(_snap.TIntV_Add,None,TIntV)
TIntV.AddMerged = new_instancemethod(_snap.TIntV_AddMerged,None,TIntV)
TIntV_swigregister = _snap.TIntV_swigregister
TIntV_swigregister(TIntV)

def TIntV_SwapI(*args):
  """
    TIntV_SwapI(TInt LVal, TInt RVal)

    Parameters:
        LVal: TVec< TInt,int >::TIter
        RVal: TVec< TInt,int >::TIter

    """
  return _snap.TIntV_SwapI(*args)

def TIntV_GetV(*args):
  """
    GetV(TInt Val1) -> TIntV

    Parameters:
        Val1: TInt const &

    GetV(TInt Val1, TInt Val2) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &
        Val6: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &
        Val6: TInt const &
        Val7: TInt const &

    GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &
        Val6: TInt const &
        Val7: TInt const &
        Val8: TInt const &

    TIntV_GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8, 
        TInt Val9) -> TIntV

    Parameters:
        Val1: TInt const &
        Val2: TInt const &
        Val3: TInt const &
        Val4: TInt const &
        Val5: TInt const &
        Val6: TInt const &
        Val7: TInt const &
        Val8: TInt const &
        Val9: TInt const &

    """
  return _snap.TIntV_GetV(*args)

class TIntIntVV(object):
    """Proxy of C++ TVec<(TVec<(TInt,int)>,int)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TIntIntVV
    def __init__(self, *args): 
        """
        __init__(TVec<(TVec<(TInt,int)>,int)> self) -> TIntIntVV
        __init__(TVec<(TVec<(TInt,int)>,int)> self, TIntIntVV Vec) -> TIntIntVV

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > const &

        __init__(TVec<(TVec<(TInt,int)>,int)> self, int const & _Vals) -> TIntIntVV

        Parameters:
            _Vals: int const &

        __init__(TVec<(TVec<(TInt,int)>,int)> self, int const & _MxVals, int const & _Vals) -> TIntIntVV

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        __init__(TVec<(TVec<(TInt,int)>,int)> self, TIntV _ValT, int const & _Vals) -> TIntIntVV

        Parameters:
            _ValT: TVec< TInt,int > *
            _Vals: int const &

        __init__(TVec<(TVec<(TInt,int)>,int)> self, TSIn SIn) -> TIntIntVV

        Parameters:
            SIn: TSIn &

        """
        _snap.TIntIntVV_swiginit(self,_snap.new_TIntIntVV(*args))
    def Load(self, *args):
        """
        Load(TIntIntVV self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TIntIntVV_Load(self, *args)

    def Save(self, *args):
        """
        Save(TIntIntVV self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TIntIntVV_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TIntIntVV self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TIntIntVV self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TIntIntVV_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TIntIntVV self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TIntIntVV_SaveXml(self, *args)

    def __add__(self, *args):
        """
        __add__(TIntIntVV self, TIntV Val) -> TIntIntVV

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV___add__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TIntIntVV self, TIntIntVV Vec) -> bool

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntIntVV self, TIntIntVV Vec) -> bool

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetMemUsed(self)

    def GetMemSize(self):
        """
        GetMemSize(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetMemSize(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetSecHashCd(self)

    def Gen(self, *args):
        """
        Gen(TIntIntVV self, int const & _Vals)

        Parameters:
            _Vals: int const &

        Gen(TIntIntVV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TIntIntVV_Gen(self, *args)

    def GenExt(self, *args):
        """
        GenExt(TIntIntVV self, TIntV _ValT, int const & _Vals)

        Parameters:
            _ValT: TVec< TInt,int > *
            _Vals: int const &

        """
        return _snap.TIntIntVV_GenExt(self, *args)

    def IsExt(self):
        """
        IsExt(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_IsExt(self)

    def Reserve(self, *args):
        """
        Reserve(TIntIntVV self, int const & _MxVals)

        Parameters:
            _MxVals: int const &

        Reserve(TIntIntVV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TIntIntVV_Reserve(self, *args)

    def Clr(self, *args):
        """
        Clr(TIntIntVV self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TIntIntVV self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Clr(self, *args)

    def Trunc(self, *args):
        """
        Trunc(TIntIntVV self, int const & _Vals=-1)

        Parameters:
            _Vals: int const &

        Trunc(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Trunc(self, *args)

    def Pack(self):
        """
        Pack(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Pack(self)

    def MoveFrom(self, *args):
        """
        MoveFrom(TIntIntVV self, TIntIntVV Vec)

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_MoveFrom(self, *args)

    def Empty(self):
        """
        Empty(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_Empty(self)

    def Len(self):
        """
        Len(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_Len(self)

    def Reserved(self):
        """
        Reserved(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_Reserved(self)

    def Last(self, *args):
        """
        Last(TIntIntVV self) -> TIntV
        Last(TIntIntVV self) -> TIntV

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Last(self, *args)

    def LastValN(self):
        """
        LastValN(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_LastValN(self)

    def LastLast(self, *args):
        """
        LastLast(TIntIntVV self) -> TIntV
        LastLast(TIntIntVV self) -> TIntV

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_LastLast(self, *args)

    def BegI(self):
        """
        BegI(TIntIntVV self) -> TIntV

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_BegI(self)

    def EndI(self):
        """
        EndI(TIntIntVV self) -> TIntV

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_EndI(self)

    def GetI(self, *args):
        """
        GetI(TIntIntVV self, int const & ValN) -> TIntV

        Parameters:
            ValN: int const &

        """
        return _snap.TIntIntVV_GetI(self, *args)

    def AddV(self, *args):
        """
        AddV(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_AddV(self, *args)

    def AddSorted(self, *args):
        """
        AddSorted(TIntIntVV self, TIntV Val, bool const & Asc=True, int const & _MxVals=-1) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            Asc: bool const &
            _MxVals: int const &

        AddSorted(TIntIntVV self, TIntV Val, bool const & Asc=True) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            Asc: bool const &

        AddSorted(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_AddSorted(self, *args)

    def AddBackSorted(self, *args):
        """
        AddBackSorted(TIntIntVV self, TIntV Val, bool const & Asc) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_AddBackSorted(self, *args)

    def AddVMerged(self, *args):
        """
        AddVMerged(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_AddVMerged(self, *args)

    def AddUnique(self, *args):
        """
        AddUnique(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_AddUnique(self, *args)

    def GetVal(self, *args):
        """
        GetVal(TIntIntVV self, int const & ValN) -> TIntV

        Parameters:
            ValN: int const &

        GetVal(TIntIntVV self, int const & ValN) -> TIntV

        Parameters:
            ValN: int const &

        """
        return _snap.TIntIntVV_GetVal(self, *args)

    def GetSubValV(self, *args):
        """
        GetSubValV(TIntIntVV self, int const & BValN, int const & EValN, TIntIntVV ValV)

        Parameters:
            BValN: int const &
            EValN: int const &
            ValV: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_GetSubValV(self, *args)

    def Ins(self, *args):
        """
        Ins(TIntIntVV self, int const & ValN, TIntV Val)

        Parameters:
            ValN: int const &
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_Ins(self, *args)

    def Del(self, *args):
        """
        Del(TIntIntVV self, int const & ValN)

        Parameters:
            ValN: int const &

        Del(TIntIntVV self, int const & MnValN, int const & MxValN)

        Parameters:
            MnValN: int const &
            MxValN: int const &

        """
        return _snap.TIntIntVV_Del(self, *args)

    def DelLast(self):
        """
        DelLast(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_DelLast(self)

    def DelIfIn(self, *args):
        """
        DelIfIn(TIntIntVV self, TIntV Val) -> bool

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_DelIfIn(self, *args)

    def DelAll(self, *args):
        """
        DelAll(TIntIntVV self, TIntV Val)

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_DelAll(self, *args)

    def PutAll(self, *args):
        """
        PutAll(TIntIntVV self, TIntV Val)

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_PutAll(self, *args)

    def Swap(self, *args):
        """
        Swap(TIntIntVV self, TIntIntVV Vec)

        Parameters:
            Vec: TVec< TVec< TInt,int >,int > &

        Swap(TIntIntVV self, int const & ValN1, int const & ValN2)

        Parameters:
            ValN1: int const &
            ValN2: int const &

        """
        return _snap.TIntIntVV_Swap(self, *args)

    def SwapI(*args):
        """
        SwapI(TIntV LVal, TIntV RVal)

        Parameters:
            LVal: TVec< TVec< TInt,int >,int >::TIter
            RVal: TVec< TVec< TInt,int >,int >::TIter

        """
        return _snap.TIntIntVV_SwapI(*args)

    SwapI = staticmethod(SwapI)
    def NextPerm(self):
        """
        NextPerm(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_NextPerm(self)

    def PrevPerm(self):
        """
        PrevPerm(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_PrevPerm(self)

    def GetPivotValN(self, *args):
        """
        GetPivotValN(TIntIntVV self, int const & LValN, int const & RValN) -> int

        Parameters:
            LValN: int const &
            RValN: int const &

        """
        return _snap.TIntIntVV_GetPivotValN(self, *args)

    def BSort(self, *args):
        """
        BSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_BSort(self, *args)

    def ISort(self, *args):
        """
        ISort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_ISort(self, *args)

    def Partition(self, *args):
        """
        Partition(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_Partition(self, *args)

    def QSort(self, *args):
        """
        QSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TIntIntVV_QSort(self, *args)

    def Sort(self, Asc=True):
        """
        Sort(TIntIntVV self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        Sort(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Sort(self, Asc)

    def IsSorted(self, Asc=True):
        """
        IsSorted(TIntIntVV self, bool const & Asc=True) -> bool

        Parameters:
            Asc: bool const &

        IsSorted(TIntIntVV self) -> bool

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_IsSorted(self, Asc)

    def Shuffle(self, *args):
        """
        Shuffle(TIntIntVV self, TRnd Rnd)

        Parameters:
            Rnd: TRnd &

        """
        return _snap.TIntIntVV_Shuffle(self, *args)

    def Reverse(self, *args):
        """
        Reverse(TIntIntVV self)
        Reverse(TIntIntVV self, int LValN, int RValN)

        Parameters:
            LValN: int
            RValN: int

        """
        return _snap.TIntIntVV_Reverse(self, *args)

    def Merge(self):
        """
        Merge(TIntIntVV self)

        Parameters:
            self: TVec< TVec< TInt,int >,int > *

        """
        return _snap.TIntIntVV_Merge(self)

    def Intrs(self, *args):
        """
        Intrs(TIntIntVV self, TIntIntVV ValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        Intrs(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &
            DstValV: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_Intrs(self, *args)

    def Union(self, *args):
        """
        Union(TIntIntVV self, TIntIntVV ValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        Union(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &
            DstValV: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_Union(self, *args)

    def Diff(self, *args):
        """
        Diff(TIntIntVV self, TIntIntVV ValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        Diff(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &
            DstValV: TVec< TVec< TInt,int >,int > &

        """
        return _snap.TIntIntVV_Diff(self, *args)

    def IntrsLen(self, *args):
        """
        IntrsLen(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_IntrsLen(self, *args)

    def UnionLen(self, *args):
        """
        UnionLen(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_UnionLen(self, *args)

    def Count(self, *args):
        """
        Count(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_Count(self, *args)

    def SearchBin(self, *args):
        """
        SearchBin(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        SearchBin(TIntIntVV self, TIntV Val, int & InsValN) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            InsValN: int &

        """
        return _snap.TIntIntVV_SearchBin(self, *args)

    def SearchForw(self, *args):
        """
        SearchForw(TIntIntVV self, TIntV Val, int const & BValN=0) -> int

        Parameters:
            Val: TVec< TInt,int > const &
            BValN: int const &

        SearchForw(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_SearchForw(self, *args)

    def SearchBack(self, *args):
        """
        SearchBack(TIntIntVV self, TIntV Val) -> int

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_SearchBack(self, *args)

    def SearchVForw(self, *args):
        """
        SearchVForw(TIntIntVV self, TIntIntVV ValV, int const & BValN=0) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &
            BValN: int const &

        SearchVForw(TIntIntVV self, TIntIntVV ValV) -> int

        Parameters:
            ValV: TVec< TVec< TInt,int >,int > const &

        """
        return _snap.TIntIntVV_SearchVForw(self, *args)

    def IsIn(self, *args):
        """
        IsIn(TIntIntVV self, TIntV Val) -> bool

        Parameters:
            Val: TVec< TInt,int > const &

        IsIn(TIntIntVV self, TIntV Val, int & ValN) -> bool

        Parameters:
            Val: TVec< TInt,int > const &
            ValN: int &

        """
        return _snap.TIntIntVV_IsIn(self, *args)

    def IsInBin(self, *args):
        """
        IsInBin(TIntIntVV self, TIntV Val) -> bool

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_IsInBin(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TIntIntVV self, TIntV Val) -> TIntV

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_GetDat(self, *args)

    def GetAddDat(self, *args):
        """
        GetAddDat(TIntIntVV self, TIntV Val) -> TIntV

        Parameters:
            Val: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_GetAddDat(self, *args)

    def GetMxValN(self):
        """
        GetMxValN(TIntIntVV self) -> int

        Parameters:
            self: TVec< TVec< TInt,int >,int > const *

        """
        return _snap.TIntIntVV_GetMxValN(self)

    def GetV(*args):
        """
        GetV(TIntV Val1) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &
            Val6: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &
            Val6: TVec< TInt,int > const &
            Val7: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, 
            TIntV Val8) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &
            Val6: TVec< TInt,int > const &
            Val7: TVec< TInt,int > const &
            Val8: TVec< TInt,int > const &

        GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, 
            TIntV Val8, TIntV Val9) -> TIntIntVV

        Parameters:
            Val1: TVec< TInt,int > const &
            Val2: TVec< TInt,int > const &
            Val3: TVec< TInt,int > const &
            Val4: TVec< TInt,int > const &
            Val5: TVec< TInt,int > const &
            Val6: TVec< TInt,int > const &
            Val7: TVec< TInt,int > const &
            Val8: TVec< TInt,int > const &
            Val9: TVec< TInt,int > const &

        """
        return _snap.TIntIntVV_GetV(*args)

    GetV = staticmethod(GetV)
TIntIntVV.Load = new_instancemethod(_snap.TIntIntVV_Load,None,TIntIntVV)
TIntIntVV.Save = new_instancemethod(_snap.TIntIntVV_Save,None,TIntIntVV)
TIntIntVV.LoadXml = new_instancemethod(_snap.TIntIntVV_LoadXml,None,TIntIntVV)
TIntIntVV.SaveXml = new_instancemethod(_snap.TIntIntVV_SaveXml,None,TIntIntVV)
TIntIntVV.__add__ = new_instancemethod(_snap.TIntIntVV___add__,None,TIntIntVV)
TIntIntVV.__eq__ = new_instancemethod(_snap.TIntIntVV___eq__,None,TIntIntVV)
TIntIntVV.__lt__ = new_instancemethod(_snap.TIntIntVV___lt__,None,TIntIntVV)
TIntIntVV.GetMemUsed = new_instancemethod(_snap.TIntIntVV_GetMemUsed,None,TIntIntVV)
TIntIntVV.GetMemSize = new_instancemethod(_snap.TIntIntVV_GetMemSize,None,TIntIntVV)
TIntIntVV.GetPrimHashCd = new_instancemethod(_snap.TIntIntVV_GetPrimHashCd,None,TIntIntVV)
TIntIntVV.GetSecHashCd = new_instancemethod(_snap.TIntIntVV_GetSecHashCd,None,TIntIntVV)
TIntIntVV.Gen = new_instancemethod(_snap.TIntIntVV_Gen,None,TIntIntVV)
TIntIntVV.GenExt = new_instancemethod(_snap.TIntIntVV_GenExt,None,TIntIntVV)
TIntIntVV.IsExt = new_instancemethod(_snap.TIntIntVV_IsExt,None,TIntIntVV)
TIntIntVV.Reserve = new_instancemethod(_snap.TIntIntVV_Reserve,None,TIntIntVV)
TIntIntVV.Clr = new_instancemethod(_snap.TIntIntVV_Clr,None,TIntIntVV)
TIntIntVV.Trunc = new_instancemethod(_snap.TIntIntVV_Trunc,None,TIntIntVV)
TIntIntVV.Pack = new_instancemethod(_snap.TIntIntVV_Pack,None,TIntIntVV)
TIntIntVV.MoveFrom = new_instancemethod(_snap.TIntIntVV_MoveFrom,None,TIntIntVV)
TIntIntVV.Empty = new_instancemethod(_snap.TIntIntVV_Empty,None,TIntIntVV)
TIntIntVV.Len = new_instancemethod(_snap.TIntIntVV_Len,None,TIntIntVV)
TIntIntVV.Reserved = new_instancemethod(_snap.TIntIntVV_Reserved,None,TIntIntVV)
TIntIntVV.Last = new_instancemethod(_snap.TIntIntVV_Last,None,TIntIntVV)
TIntIntVV.LastValN = new_instancemethod(_snap.TIntIntVV_LastValN,None,TIntIntVV)
TIntIntVV.LastLast = new_instancemethod(_snap.TIntIntVV_LastLast,None,TIntIntVV)
TIntIntVV.BegI = new_instancemethod(_snap.TIntIntVV_BegI,None,TIntIntVV)
TIntIntVV.EndI = new_instancemethod(_snap.TIntIntVV_EndI,None,TIntIntVV)
TIntIntVV.GetI = new_instancemethod(_snap.TIntIntVV_GetI,None,TIntIntVV)
TIntIntVV.AddV = new_instancemethod(_snap.TIntIntVV_AddV,None,TIntIntVV)
TIntIntVV.AddSorted = new_instancemethod(_snap.TIntIntVV_AddSorted,None,TIntIntVV)
TIntIntVV.AddBackSorted = new_instancemethod(_snap.TIntIntVV_AddBackSorted,None,TIntIntVV)
TIntIntVV.AddVMerged = new_instancemethod(_snap.TIntIntVV_AddVMerged,None,TIntIntVV)
TIntIntVV.AddUnique = new_instancemethod(_snap.TIntIntVV_AddUnique,None,TIntIntVV)
TIntIntVV.GetVal = new_instancemethod(_snap.TIntIntVV_GetVal,None,TIntIntVV)
TIntIntVV.GetSubValV = new_instancemethod(_snap.TIntIntVV_GetSubValV,None,TIntIntVV)
TIntIntVV.Ins = new_instancemethod(_snap.TIntIntVV_Ins,None,TIntIntVV)
TIntIntVV.Del = new_instancemethod(_snap.TIntIntVV_Del,None,TIntIntVV)
TIntIntVV.DelLast = new_instancemethod(_snap.TIntIntVV_DelLast,None,TIntIntVV)
TIntIntVV.DelIfIn = new_instancemethod(_snap.TIntIntVV_DelIfIn,None,TIntIntVV)
TIntIntVV.DelAll = new_instancemethod(_snap.TIntIntVV_DelAll,None,TIntIntVV)
TIntIntVV.PutAll = new_instancemethod(_snap.TIntIntVV_PutAll,None,TIntIntVV)
TIntIntVV.Swap = new_instancemethod(_snap.TIntIntVV_Swap,None,TIntIntVV)
TIntIntVV.NextPerm = new_instancemethod(_snap.TIntIntVV_NextPerm,None,TIntIntVV)
TIntIntVV.PrevPerm = new_instancemethod(_snap.TIntIntVV_PrevPerm,None,TIntIntVV)
TIntIntVV.GetPivotValN = new_instancemethod(_snap.TIntIntVV_GetPivotValN,None,TIntIntVV)
TIntIntVV.BSort = new_instancemethod(_snap.TIntIntVV_BSort,None,TIntIntVV)
TIntIntVV.ISort = new_instancemethod(_snap.TIntIntVV_ISort,None,TIntIntVV)
TIntIntVV.Partition = new_instancemethod(_snap.TIntIntVV_Partition,None,TIntIntVV)
TIntIntVV.QSort = new_instancemethod(_snap.TIntIntVV_QSort,None,TIntIntVV)
TIntIntVV.Sort = new_instancemethod(_snap.TIntIntVV_Sort,None,TIntIntVV)
TIntIntVV.IsSorted = new_instancemethod(_snap.TIntIntVV_IsSorted,None,TIntIntVV)
TIntIntVV.Shuffle = new_instancemethod(_snap.TIntIntVV_Shuffle,None,TIntIntVV)
TIntIntVV.Reverse = new_instancemethod(_snap.TIntIntVV_Reverse,None,TIntIntVV)
TIntIntVV.Merge = new_instancemethod(_snap.TIntIntVV_Merge,None,TIntIntVV)
TIntIntVV.Intrs = new_instancemethod(_snap.TIntIntVV_Intrs,None,TIntIntVV)
TIntIntVV.Union = new_instancemethod(_snap.TIntIntVV_Union,None,TIntIntVV)
TIntIntVV.Diff = new_instancemethod(_snap.TIntIntVV_Diff,None,TIntIntVV)
TIntIntVV.IntrsLen = new_instancemethod(_snap.TIntIntVV_IntrsLen,None,TIntIntVV)
TIntIntVV.UnionLen = new_instancemethod(_snap.TIntIntVV_UnionLen,None,TIntIntVV)
TIntIntVV.Count = new_instancemethod(_snap.TIntIntVV_Count,None,TIntIntVV)
TIntIntVV.SearchBin = new_instancemethod(_snap.TIntIntVV_SearchBin,None,TIntIntVV)
TIntIntVV.SearchForw = new_instancemethod(_snap.TIntIntVV_SearchForw,None,TIntIntVV)
TIntIntVV.SearchBack = new_instancemethod(_snap.TIntIntVV_SearchBack,None,TIntIntVV)
TIntIntVV.SearchVForw = new_instancemethod(_snap.TIntIntVV_SearchVForw,None,TIntIntVV)
TIntIntVV.IsIn = new_instancemethod(_snap.TIntIntVV_IsIn,None,TIntIntVV)
TIntIntVV.IsInBin = new_instancemethod(_snap.TIntIntVV_IsInBin,None,TIntIntVV)
TIntIntVV.GetDat = new_instancemethod(_snap.TIntIntVV_GetDat,None,TIntIntVV)
TIntIntVV.GetAddDat = new_instancemethod(_snap.TIntIntVV_GetAddDat,None,TIntIntVV)
TIntIntVV.GetMxValN = new_instancemethod(_snap.TIntIntVV_GetMxValN,None,TIntIntVV)
TIntIntVV_swigregister = _snap.TIntIntVV_swigregister
TIntIntVV_swigregister(TIntIntVV)

def TIntIntVV_SwapI(*args):
  """
    TIntIntVV_SwapI(TIntV LVal, TIntV RVal)

    Parameters:
        LVal: TVec< TVec< TInt,int >,int >::TIter
        RVal: TVec< TVec< TInt,int >,int >::TIter

    """
  return _snap.TIntIntVV_SwapI(*args)

def TIntIntVV_GetV(*args):
  """
    GetV(TIntV Val1) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &
        Val6: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &
        Val6: TVec< TInt,int > const &
        Val7: TVec< TInt,int > const &

    GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, 
        TIntV Val8) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &
        Val6: TVec< TInt,int > const &
        Val7: TVec< TInt,int > const &
        Val8: TVec< TInt,int > const &

    TIntIntVV_GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, 
        TIntV Val8, TIntV Val9) -> TIntIntVV

    Parameters:
        Val1: TVec< TInt,int > const &
        Val2: TVec< TInt,int > const &
        Val3: TVec< TInt,int > const &
        Val4: TVec< TInt,int > const &
        Val5: TVec< TInt,int > const &
        Val6: TVec< TInt,int > const &
        Val7: TVec< TInt,int > const &
        Val8: TVec< TInt,int > const &
        Val9: TVec< TInt,int > const &

    """
  return _snap.TIntIntVV_GetV(*args)

class TIntIntVH(object):
    """Proxy of C++ THash<(TInt,TVec<(TInt,int)>)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    HashPrimes = _snap.TIntIntVH_HashPrimes
    def __init__(self, *args): 
        """
        __init__(THash<(TInt,TVec<(TInt,int)>)> self) -> TIntIntVH
        __init__(THash<(TInt,TVec<(TInt,int)>)> self, TIntIntVH Hash) -> TIntIntVH

        Parameters:
            Hash: THash< TInt,TVec< TInt,int > > const &

        __init__(THash<(TInt,TVec<(TInt,int)>)> self, int const & ExpectVals, bool const & _AutoSizeP=False) -> TIntIntVH

        Parameters:
            ExpectVals: int const &
            _AutoSizeP: bool const &

        __init__(THash<(TInt,TVec<(TInt,int)>)> self, int const & ExpectVals) -> TIntIntVH

        Parameters:
            ExpectVals: int const &

        __init__(THash<(TInt,TVec<(TInt,int)>)> self, TSIn SIn) -> TIntIntVH

        Parameters:
            SIn: TSIn &

        """
        _snap.TIntIntVH_swiginit(self,_snap.new_TIntIntVH(*args))
    def Load(self, *args):
        """
        Load(TIntIntVH self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TIntIntVH_Load(self, *args)

    def Save(self, *args):
        """
        Save(TIntIntVH self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TIntIntVH_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TIntIntVH self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TIntIntVH self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TIntIntVH_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TIntIntVH self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TIntIntVH_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TIntIntVH self, TIntIntVH Hash) -> bool

        Parameters:
            Hash: THash< TInt,TVec< TInt,int > > const &

        """
        return _snap.TIntIntVH___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntIntVH self, TIntIntVH Hash) -> bool

        Parameters:
            Hash: THash< TInt,TVec< TInt,int > > const &

        """
        return _snap.TIntIntVH___lt__(self, *args)

    def __call__(self, *args):
        """
        __call__(TIntIntVH self, TInt Key) -> TIntV

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH___call__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TIntIntVH self) -> ::TSize

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_GetMemUsed(self)

    def BegI(self):
        """
        BegI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_BegI(self)

    def EndI(self):
        """
        EndI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_EndI(self)

    def GetI(self, *args):
        """
        GetI(TIntIntVH self, TInt Key) -> THash< TInt,TVec< TInt,int > >::TIter

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_GetI(self, *args)

    def Gen(self, *args):
        """
        Gen(TIntIntVH self, int const & ExpectVals)

        Parameters:
            ExpectVals: int const &

        """
        return _snap.TIntIntVH_Gen(self, *args)

    def Clr(self, *args):
        """
        Clr(TIntIntVH self, bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &
            ResetDat: bool const &

        Clr(TIntIntVH self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TIntIntVH self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_Clr(self, *args)

    def Empty(self):
        """
        Empty(TIntIntVH self) -> bool

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_Empty(self)

    def Len(self):
        """
        Len(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_Len(self)

    def GetPorts(self):
        """
        GetPorts(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_GetPorts(self)

    def IsAutoSize(self):
        """
        IsAutoSize(TIntIntVH self) -> bool

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_IsAutoSize(self)

    def GetMxKeyIds(self):
        """
        GetMxKeyIds(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_GetMxKeyIds(self)

    def GetReservedKeyIds(self):
        """
        GetReservedKeyIds(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_GetReservedKeyIds(self)

    def IsKeyIdEqKeyN(self):
        """
        IsKeyIdEqKeyN(TIntIntVH self) -> bool

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_IsKeyIdEqKeyN(self)

    def DelKey(self, *args):
        """
        DelKey(TIntIntVH self, TInt Key)

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_DelKey(self, *args)

    def DelIfKey(self, *args):
        """
        DelIfKey(TIntIntVH self, TInt Key) -> bool

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_DelIfKey(self, *args)

    def DelKeyId(self, *args):
        """
        DelKeyId(TIntIntVH self, int const & KeyId)

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntIntVH_DelKeyId(self, *args)

    def DelKeyIdV(self, *args):
        """
        DelKeyIdV(TIntIntVH self, TIntV KeyIdV)

        Parameters:
            KeyIdV: TIntV const &

        """
        return _snap.TIntIntVH_DelKeyIdV(self, *args)

    def MarkDelKey(self, *args):
        """
        MarkDelKey(TIntIntVH self, TInt Key)

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_MarkDelKey(self, *args)

    def MarkDelKeyId(self, *args):
        """
        MarkDelKeyId(TIntIntVH self, int const & KeyId)

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntIntVH_MarkDelKeyId(self, *args)

    def GetKey(self, *args):
        """
        GetKey(TIntIntVH self, int const & KeyId) -> TInt

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntIntVH_GetKey(self, *args)

    def GetKeyId(self, *args):
        """
        GetKeyId(TIntIntVH self, TInt Key) -> int

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntIntVH_GetKeyId(self, *args)

    def GetRndKeyId(self, *args):
        """
        GetRndKeyId(TIntIntVH self, TRnd Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndKeyId(TIntIntVH self, TRnd Rnd, double const & EmptyFrac) -> int

        Parameters:
            Rnd: TRnd &
            EmptyFrac: double const &

        """
        return _snap.TIntIntVH_GetRndKeyId(self, *args)

    def IsKeyId(self, *args):
        """
        IsKeyId(TIntIntVH self, int const & KeyId) -> bool

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntIntVH_IsKeyId(self, *args)

    def GetKeyDat(self, *args):
        """
        GetKeyDat(TIntIntVH self, int const & KeyId, TInt Key, TIntV Dat)

        Parameters:
            KeyId: int const &
            Key: TInt &
            Dat: TVec< TInt,int > &

        """
        return _snap.TIntIntVH_GetKeyDat(self, *args)

    def IsKeyGetDat(self, *args):
        """
        IsKeyGetDat(TIntIntVH self, TInt Key, TIntV Dat) -> bool

        Parameters:
            Key: TInt const &
            Dat: TVec< TInt,int > &

        """
        return _snap.TIntIntVH_IsKeyGetDat(self, *args)

    def FFirstKeyId(self):
        """
        FFirstKeyId(TIntIntVH self) -> int

        Parameters:
            self: THash< TInt,TVec< TInt,int > > const *

        """
        return _snap.TIntIntVH_FFirstKeyId(self)

    def FNextKeyId(self, *args):
        """
        FNextKeyId(TIntIntVH self, int & KeyId) -> bool

        Parameters:
            KeyId: int &

        """
        return _snap.TIntIntVH_FNextKeyId(self, *args)

    def GetKeyV(self, *args):
        """
        GetKeyV(TIntIntVH self, TIntV KeyV)

        Parameters:
            KeyV: TVec< TInt > &

        """
        return _snap.TIntIntVH_GetKeyV(self, *args)

    def GetDatV(self, *args):
        """
        GetDatV(TIntIntVH self, TIntIntVV DatV)

        Parameters:
            DatV: TVec< TVec< TInt,int > > &

        """
        return _snap.TIntIntVH_GetDatV(self, *args)

    def GetKeyDatPrV(self, *args):
        """
        GetKeyDatPrV(TIntIntVH self, TVec< TPair< TInt,TVec< TInt,int > > > & KeyDatPrV)

        Parameters:
            KeyDatPrV: TVec< TPair< TInt,TVec< TInt,int > > > &

        """
        return _snap.TIntIntVH_GetKeyDatPrV(self, *args)

    def GetDatKeyPrV(self, *args):
        """
        GetDatKeyPrV(TIntIntVH self, TVec< TPair< TVec< TInt,int >,TInt > > & DatKeyPrV)

        Parameters:
            DatKeyPrV: TVec< TPair< TVec< TInt,int >,TInt > > &

        """
        return _snap.TIntIntVH_GetDatKeyPrV(self, *args)

    def GetKeyDatKdV(self, *args):
        """
        GetKeyDatKdV(TIntIntVH self, TVec< TKeyDat< TInt,TVec< TInt,int > > > & KeyDatKdV)

        Parameters:
            KeyDatKdV: TVec< TKeyDat< TInt,TVec< TInt,int > > > &

        """
        return _snap.TIntIntVH_GetKeyDatKdV(self, *args)

    def GetDatKeyKdV(self, *args):
        """
        GetDatKeyKdV(TIntIntVH self, TVec< TKeyDat< TVec< TInt,int >,TInt > > & DatKeyKdV)

        Parameters:
            DatKeyKdV: TVec< TKeyDat< TVec< TInt,int >,TInt > > &

        """
        return _snap.TIntIntVH_GetDatKeyKdV(self, *args)

    def Swap(self, *args):
        """
        Swap(TIntIntVH self, TIntIntVH Hash)

        Parameters:
            Hash: THash< TInt,TVec< TInt,int > > &

        """
        return _snap.TIntIntVH_Swap(self, *args)

    def Defrag(self):
        """
        Defrag(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_Defrag(self)

    def Pack(self):
        """
        Pack(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_Pack(self)

    def Sort(self, *args):
        """
        Sort(TIntIntVH self, bool const & CmpKey, bool const & Asc)

        Parameters:
            CmpKey: bool const &
            Asc: bool const &

        """
        return _snap.TIntIntVH_Sort(self, *args)

    def SortByKey(self, Asc=True):
        """
        SortByKey(TIntIntVH self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        SortByKey(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_SortByKey(self, Asc)

    def SortByDat(self, Asc=True):
        """
        SortByDat(TIntIntVH self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        SortByDat(TIntIntVH self)

        Parameters:
            self: THash< TInt,TVec< TInt,int > > *

        """
        return _snap.TIntIntVH_SortByDat(self, Asc)

    def AddKey(self, *args):
        """
        AddKey(TIntIntVH self, TInt Key) -> int

        Parameters:
            Key: TInt const &

        AddKey(TIntIntVH self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntIntVH_AddKey(self, *args)

    def IsKey(self, *args):
        """
        IsKey(TIntIntVH self, TInt Key) -> bool

        Parameters:
            Key: TInt const &

        IsKey(TIntIntVH self, TInt Key, int & KeyId) -> bool

        Parameters:
            Key: TInt const &
            KeyId: int &

        IsKey(TIntIntVH self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntIntVH_IsKey(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TIntIntVH self, TInt Key) -> TIntV

        Parameters:
            Key: TInt const &

        GetDat(TIntIntVH self, TInt Key) -> TIntV

        Parameters:
            Key: TInt const &

        GetDat(TIntIntVH self, int Val) -> TIntV

        Parameters:
            Val: int

        """
        return _snap.TIntIntVH_GetDat(self, *args)

    __swig_destroy__ = _snap.delete_TIntIntVH
TIntIntVH.Load = new_instancemethod(_snap.TIntIntVH_Load,None,TIntIntVH)
TIntIntVH.Save = new_instancemethod(_snap.TIntIntVH_Save,None,TIntIntVH)
TIntIntVH.LoadXml = new_instancemethod(_snap.TIntIntVH_LoadXml,None,TIntIntVH)
TIntIntVH.SaveXml = new_instancemethod(_snap.TIntIntVH_SaveXml,None,TIntIntVH)
TIntIntVH.__eq__ = new_instancemethod(_snap.TIntIntVH___eq__,None,TIntIntVH)
TIntIntVH.__lt__ = new_instancemethod(_snap.TIntIntVH___lt__,None,TIntIntVH)
TIntIntVH.__call__ = new_instancemethod(_snap.TIntIntVH___call__,None,TIntIntVH)
TIntIntVH.GetMemUsed = new_instancemethod(_snap.TIntIntVH_GetMemUsed,None,TIntIntVH)
TIntIntVH.BegI = new_instancemethod(_snap.TIntIntVH_BegI,None,TIntIntVH)
TIntIntVH.EndI = new_instancemethod(_snap.TIntIntVH_EndI,None,TIntIntVH)
TIntIntVH.GetI = new_instancemethod(_snap.TIntIntVH_GetI,None,TIntIntVH)
TIntIntVH.Gen = new_instancemethod(_snap.TIntIntVH_Gen,None,TIntIntVH)
TIntIntVH.Clr = new_instancemethod(_snap.TIntIntVH_Clr,None,TIntIntVH)
TIntIntVH.Empty = new_instancemethod(_snap.TIntIntVH_Empty,None,TIntIntVH)
TIntIntVH.Len = new_instancemethod(_snap.TIntIntVH_Len,None,TIntIntVH)
TIntIntVH.GetPorts = new_instancemethod(_snap.TIntIntVH_GetPorts,None,TIntIntVH)
TIntIntVH.IsAutoSize = new_instancemethod(_snap.TIntIntVH_IsAutoSize,None,TIntIntVH)
TIntIntVH.GetMxKeyIds = new_instancemethod(_snap.TIntIntVH_GetMxKeyIds,None,TIntIntVH)
TIntIntVH.GetReservedKeyIds = new_instancemethod(_snap.TIntIntVH_GetReservedKeyIds,None,TIntIntVH)
TIntIntVH.IsKeyIdEqKeyN = new_instancemethod(_snap.TIntIntVH_IsKeyIdEqKeyN,None,TIntIntVH)
TIntIntVH.DelKey = new_instancemethod(_snap.TIntIntVH_DelKey,None,TIntIntVH)
TIntIntVH.DelIfKey = new_instancemethod(_snap.TIntIntVH_DelIfKey,None,TIntIntVH)
TIntIntVH.DelKeyId = new_instancemethod(_snap.TIntIntVH_DelKeyId,None,TIntIntVH)
TIntIntVH.DelKeyIdV = new_instancemethod(_snap.TIntIntVH_DelKeyIdV,None,TIntIntVH)
TIntIntVH.MarkDelKey = new_instancemethod(_snap.TIntIntVH_MarkDelKey,None,TIntIntVH)
TIntIntVH.MarkDelKeyId = new_instancemethod(_snap.TIntIntVH_MarkDelKeyId,None,TIntIntVH)
TIntIntVH.GetKey = new_instancemethod(_snap.TIntIntVH_GetKey,None,TIntIntVH)
TIntIntVH.GetKeyId = new_instancemethod(_snap.TIntIntVH_GetKeyId,None,TIntIntVH)
TIntIntVH.GetRndKeyId = new_instancemethod(_snap.TIntIntVH_GetRndKeyId,None,TIntIntVH)
TIntIntVH.IsKeyId = new_instancemethod(_snap.TIntIntVH_IsKeyId,None,TIntIntVH)
TIntIntVH.GetKeyDat = new_instancemethod(_snap.TIntIntVH_GetKeyDat,None,TIntIntVH)
TIntIntVH.IsKeyGetDat = new_instancemethod(_snap.TIntIntVH_IsKeyGetDat,None,TIntIntVH)
TIntIntVH.FFirstKeyId = new_instancemethod(_snap.TIntIntVH_FFirstKeyId,None,TIntIntVH)
TIntIntVH.FNextKeyId = new_instancemethod(_snap.TIntIntVH_FNextKeyId,None,TIntIntVH)
TIntIntVH.GetKeyV = new_instancemethod(_snap.TIntIntVH_GetKeyV,None,TIntIntVH)
TIntIntVH.GetDatV = new_instancemethod(_snap.TIntIntVH_GetDatV,None,TIntIntVH)
TIntIntVH.GetKeyDatPrV = new_instancemethod(_snap.TIntIntVH_GetKeyDatPrV,None,TIntIntVH)
TIntIntVH.GetDatKeyPrV = new_instancemethod(_snap.TIntIntVH_GetDatKeyPrV,None,TIntIntVH)
TIntIntVH.GetKeyDatKdV = new_instancemethod(_snap.TIntIntVH_GetKeyDatKdV,None,TIntIntVH)
TIntIntVH.GetDatKeyKdV = new_instancemethod(_snap.TIntIntVH_GetDatKeyKdV,None,TIntIntVH)
TIntIntVH.Swap = new_instancemethod(_snap.TIntIntVH_Swap,None,TIntIntVH)
TIntIntVH.Defrag = new_instancemethod(_snap.TIntIntVH_Defrag,None,TIntIntVH)
TIntIntVH.Pack = new_instancemethod(_snap.TIntIntVH_Pack,None,TIntIntVH)
TIntIntVH.Sort = new_instancemethod(_snap.TIntIntVH_Sort,None,TIntIntVH)
TIntIntVH.SortByKey = new_instancemethod(_snap.TIntIntVH_SortByKey,None,TIntIntVH)
TIntIntVH.SortByDat = new_instancemethod(_snap.TIntIntVH_SortByDat,None,TIntIntVH)
TIntIntVH.AddKey = new_instancemethod(_snap.TIntIntVH_AddKey,None,TIntIntVH)
TIntIntVH.IsKey = new_instancemethod(_snap.TIntIntVH_IsKey,None,TIntIntVH)
TIntIntVH.GetDat = new_instancemethod(_snap.TIntIntVH_GetDat,None,TIntIntVH)
TIntIntVH_swigregister = _snap.TIntIntVH_swigregister
TIntIntVH_swigregister(TIntIntVH)

class TIntH(object):
    """Proxy of C++ THash<(TInt,TInt)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    HashPrimes = _snap.TIntH_HashPrimes
    def __init__(self, *args): 
        """
        __init__(THash<(TInt,TInt)> self) -> TIntH
        __init__(THash<(TInt,TInt)> self, TIntH Hash) -> TIntH

        Parameters:
            Hash: THash< TInt,TInt > const &

        __init__(THash<(TInt,TInt)> self, int const & ExpectVals, bool const & _AutoSizeP=False) -> TIntH

        Parameters:
            ExpectVals: int const &
            _AutoSizeP: bool const &

        __init__(THash<(TInt,TInt)> self, int const & ExpectVals) -> TIntH

        Parameters:
            ExpectVals: int const &

        __init__(THash<(TInt,TInt)> self, TSIn SIn) -> TIntH

        Parameters:
            SIn: TSIn &

        """
        _snap.TIntH_swiginit(self,_snap.new_TIntH(*args))
    def Load(self, *args):
        """
        Load(TIntH self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TIntH_Load(self, *args)

    def Save(self, *args):
        """
        Save(TIntH self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TIntH_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TIntH self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TIntH self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TIntH_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TIntH self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TIntH_SaveXml(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TIntH self, TIntH Hash) -> bool

        Parameters:
            Hash: THash< TInt,TInt > const &

        """
        return _snap.TIntH___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntH self, TIntH Hash) -> bool

        Parameters:
            Hash: THash< TInt,TInt > const &

        """
        return _snap.TIntH___lt__(self, *args)

    def __call__(self, *args):
        """
        __call__(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH___call__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TIntH self) -> ::TSize

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_GetMemUsed(self)

    def BegI(self):
        """
        BegI(TIntH self) -> TIntHI

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_BegI(self)

    def EndI(self):
        """
        EndI(TIntH self) -> TIntHI

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_EndI(self)

    def GetI(self, *args):
        """
        GetI(TIntH self, TInt Key) -> TIntHI

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_GetI(self, *args)

    def Gen(self, *args):
        """
        Gen(TIntH self, int const & ExpectVals)

        Parameters:
            ExpectVals: int const &

        """
        return _snap.TIntH_Gen(self, *args)

    def Clr(self, *args):
        """
        Clr(TIntH self, bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &
            ResetDat: bool const &

        Clr(TIntH self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TIntH self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_Clr(self, *args)

    def Empty(self):
        """
        Empty(TIntH self) -> bool

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_Empty(self)

    def Len(self):
        """
        Len(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_Len(self)

    def GetPorts(self):
        """
        GetPorts(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_GetPorts(self)

    def IsAutoSize(self):
        """
        IsAutoSize(TIntH self) -> bool

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_IsAutoSize(self)

    def GetMxKeyIds(self):
        """
        GetMxKeyIds(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_GetMxKeyIds(self)

    def GetReservedKeyIds(self):
        """
        GetReservedKeyIds(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_GetReservedKeyIds(self)

    def IsKeyIdEqKeyN(self):
        """
        IsKeyIdEqKeyN(TIntH self) -> bool

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_IsKeyIdEqKeyN(self)

    def AddDatId(self, *args):
        """
        AddDatId(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_AddDatId(self, *args)

    def DelKey(self, *args):
        """
        DelKey(TIntH self, TInt Key)

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_DelKey(self, *args)

    def DelIfKey(self, *args):
        """
        DelIfKey(TIntH self, TInt Key) -> bool

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_DelIfKey(self, *args)

    def DelKeyId(self, *args):
        """
        DelKeyId(TIntH self, int const & KeyId)

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntH_DelKeyId(self, *args)

    def DelKeyIdV(self, *args):
        """
        DelKeyIdV(TIntH self, TIntV KeyIdV)

        Parameters:
            KeyIdV: TIntV const &

        """
        return _snap.TIntH_DelKeyIdV(self, *args)

    def MarkDelKey(self, *args):
        """
        MarkDelKey(TIntH self, TInt Key)

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_MarkDelKey(self, *args)

    def MarkDelKeyId(self, *args):
        """
        MarkDelKeyId(TIntH self, int const & KeyId)

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntH_MarkDelKeyId(self, *args)

    def GetKey(self, *args):
        """
        GetKey(TIntH self, int const & KeyId) -> TInt

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntH_GetKey(self, *args)

    def GetKeyId(self, *args):
        """
        GetKeyId(TIntH self, TInt Key) -> int

        Parameters:
            Key: TInt const &

        """
        return _snap.TIntH_GetKeyId(self, *args)

    def GetRndKeyId(self, *args):
        """
        GetRndKeyId(TIntH self, TRnd Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndKeyId(TIntH self, TRnd Rnd, double const & EmptyFrac) -> int

        Parameters:
            Rnd: TRnd &
            EmptyFrac: double const &

        """
        return _snap.TIntH_GetRndKeyId(self, *args)

    def IsKeyId(self, *args):
        """
        IsKeyId(TIntH self, int const & KeyId) -> bool

        Parameters:
            KeyId: int const &

        """
        return _snap.TIntH_IsKeyId(self, *args)

    def GetKeyDat(self, *args):
        """
        GetKeyDat(TIntH self, int const & KeyId, TInt Key, TInt Dat)

        Parameters:
            KeyId: int const &
            Key: TInt &
            Dat: TInt &

        """
        return _snap.TIntH_GetKeyDat(self, *args)

    def IsKeyGetDat(self, *args):
        """
        IsKeyGetDat(TIntH self, TInt Key, TInt Dat) -> bool

        Parameters:
            Key: TInt const &
            Dat: TInt &

        """
        return _snap.TIntH_IsKeyGetDat(self, *args)

    def FFirstKeyId(self):
        """
        FFirstKeyId(TIntH self) -> int

        Parameters:
            self: THash< TInt,TInt > const *

        """
        return _snap.TIntH_FFirstKeyId(self)

    def FNextKeyId(self, *args):
        """
        FNextKeyId(TIntH self, int & KeyId) -> bool

        Parameters:
            KeyId: int &

        """
        return _snap.TIntH_FNextKeyId(self, *args)

    def GetKeyV(self, *args):
        """
        GetKeyV(TIntH self, TIntV KeyV)

        Parameters:
            KeyV: TVec< TInt > &

        """
        return _snap.TIntH_GetKeyV(self, *args)

    def GetDatV(self, *args):
        """
        GetDatV(TIntH self, TIntV DatV)

        Parameters:
            DatV: TVec< TInt > &

        """
        return _snap.TIntH_GetDatV(self, *args)

    def GetKeyDatPrV(self, *args):
        """
        GetKeyDatPrV(TIntH self, TVec< TPair< TInt,TInt > > & KeyDatPrV)

        Parameters:
            KeyDatPrV: TVec< TPair< TInt,TInt > > &

        """
        return _snap.TIntH_GetKeyDatPrV(self, *args)

    def GetDatKeyPrV(self, *args):
        """
        GetDatKeyPrV(TIntH self, TVec< TPair< TInt,TInt > > & DatKeyPrV)

        Parameters:
            DatKeyPrV: TVec< TPair< TInt,TInt > > &

        """
        return _snap.TIntH_GetDatKeyPrV(self, *args)

    def GetKeyDatKdV(self, *args):
        """
        GetKeyDatKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & KeyDatKdV)

        Parameters:
            KeyDatKdV: TVec< TKeyDat< TInt,TInt > > &

        """
        return _snap.TIntH_GetKeyDatKdV(self, *args)

    def GetDatKeyKdV(self, *args):
        """
        GetDatKeyKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & DatKeyKdV)

        Parameters:
            DatKeyKdV: TVec< TKeyDat< TInt,TInt > > &

        """
        return _snap.TIntH_GetDatKeyKdV(self, *args)

    def Swap(self, *args):
        """
        Swap(TIntH self, TIntH Hash)

        Parameters:
            Hash: THash< TInt,TInt > &

        """
        return _snap.TIntH_Swap(self, *args)

    def Defrag(self):
        """
        Defrag(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_Defrag(self)

    def Pack(self):
        """
        Pack(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_Pack(self)

    def Sort(self, *args):
        """
        Sort(TIntH self, bool const & CmpKey, bool const & Asc)

        Parameters:
            CmpKey: bool const &
            Asc: bool const &

        """
        return _snap.TIntH_Sort(self, *args)

    def SortByKey(self, Asc=True):
        """
        SortByKey(TIntH self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        SortByKey(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_SortByKey(self, Asc)

    def SortByDat(self, Asc=True):
        """
        SortByDat(TIntH self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        SortByDat(TIntH self)

        Parameters:
            self: THash< TInt,TInt > *

        """
        return _snap.TIntH_SortByDat(self, Asc)

    def AddKey(self, *args):
        """
        AddKey(TIntH self, TInt Key) -> int

        Parameters:
            Key: TInt const &

        AddKey(TIntH self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntH_AddKey(self, *args)

    def IsKey(self, *args):
        """
        IsKey(TIntH self, TInt Key) -> bool

        Parameters:
            Key: TInt const &

        IsKey(TIntH self, TInt Key, int & KeyId) -> bool

        Parameters:
            Key: TInt const &
            KeyId: int &

        IsKey(TIntH self, int Val) -> int

        Parameters:
            Val: int

        """
        return _snap.TIntH_IsKey(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        GetDat(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        GetDat(TIntH self, int Val) -> TInt

        Parameters:
            Val: int

        """
        return _snap.TIntH_GetDat(self, *args)

    def AddDat(self, *args):
        """
        AddDat(TIntH self, TInt Key) -> TInt

        Parameters:
            Key: TInt const &

        AddDat(TIntH self, TInt Key, TInt Dat) -> TInt

        Parameters:
            Key: TInt const &
            Dat: TInt const &

        AddDat(TIntH self, int Key, int Val) -> TInt

        Parameters:
            Key: int
            Val: int

        """
        return _snap.TIntH_AddDat(self, *args)

    __swig_destroy__ = _snap.delete_TIntH
TIntH.Load = new_instancemethod(_snap.TIntH_Load,None,TIntH)
TIntH.Save = new_instancemethod(_snap.TIntH_Save,None,TIntH)
TIntH.LoadXml = new_instancemethod(_snap.TIntH_LoadXml,None,TIntH)
TIntH.SaveXml = new_instancemethod(_snap.TIntH_SaveXml,None,TIntH)
TIntH.__eq__ = new_instancemethod(_snap.TIntH___eq__,None,TIntH)
TIntH.__lt__ = new_instancemethod(_snap.TIntH___lt__,None,TIntH)
TIntH.__call__ = new_instancemethod(_snap.TIntH___call__,None,TIntH)
TIntH.GetMemUsed = new_instancemethod(_snap.TIntH_GetMemUsed,None,TIntH)
TIntH.BegI = new_instancemethod(_snap.TIntH_BegI,None,TIntH)
TIntH.EndI = new_instancemethod(_snap.TIntH_EndI,None,TIntH)
TIntH.GetI = new_instancemethod(_snap.TIntH_GetI,None,TIntH)
TIntH.Gen = new_instancemethod(_snap.TIntH_Gen,None,TIntH)
TIntH.Clr = new_instancemethod(_snap.TIntH_Clr,None,TIntH)
TIntH.Empty = new_instancemethod(_snap.TIntH_Empty,None,TIntH)
TIntH.Len = new_instancemethod(_snap.TIntH_Len,None,TIntH)
TIntH.GetPorts = new_instancemethod(_snap.TIntH_GetPorts,None,TIntH)
TIntH.IsAutoSize = new_instancemethod(_snap.TIntH_IsAutoSize,None,TIntH)
TIntH.GetMxKeyIds = new_instancemethod(_snap.TIntH_GetMxKeyIds,None,TIntH)
TIntH.GetReservedKeyIds = new_instancemethod(_snap.TIntH_GetReservedKeyIds,None,TIntH)
TIntH.IsKeyIdEqKeyN = new_instancemethod(_snap.TIntH_IsKeyIdEqKeyN,None,TIntH)
TIntH.AddDatId = new_instancemethod(_snap.TIntH_AddDatId,None,TIntH)
TIntH.DelKey = new_instancemethod(_snap.TIntH_DelKey,None,TIntH)
TIntH.DelIfKey = new_instancemethod(_snap.TIntH_DelIfKey,None,TIntH)
TIntH.DelKeyId = new_instancemethod(_snap.TIntH_DelKeyId,None,TIntH)
TIntH.DelKeyIdV = new_instancemethod(_snap.TIntH_DelKeyIdV,None,TIntH)
TIntH.MarkDelKey = new_instancemethod(_snap.TIntH_MarkDelKey,None,TIntH)
TIntH.MarkDelKeyId = new_instancemethod(_snap.TIntH_MarkDelKeyId,None,TIntH)
TIntH.GetKey = new_instancemethod(_snap.TIntH_GetKey,None,TIntH)
TIntH.GetKeyId = new_instancemethod(_snap.TIntH_GetKeyId,None,TIntH)
TIntH.GetRndKeyId = new_instancemethod(_snap.TIntH_GetRndKeyId,None,TIntH)
TIntH.IsKeyId = new_instancemethod(_snap.TIntH_IsKeyId,None,TIntH)
TIntH.GetKeyDat = new_instancemethod(_snap.TIntH_GetKeyDat,None,TIntH)
TIntH.IsKeyGetDat = new_instancemethod(_snap.TIntH_IsKeyGetDat,None,TIntH)
TIntH.FFirstKeyId = new_instancemethod(_snap.TIntH_FFirstKeyId,None,TIntH)
TIntH.FNextKeyId = new_instancemethod(_snap.TIntH_FNextKeyId,None,TIntH)
TIntH.GetKeyV = new_instancemethod(_snap.TIntH_GetKeyV,None,TIntH)
TIntH.GetDatV = new_instancemethod(_snap.TIntH_GetDatV,None,TIntH)
TIntH.GetKeyDatPrV = new_instancemethod(_snap.TIntH_GetKeyDatPrV,None,TIntH)
TIntH.GetDatKeyPrV = new_instancemethod(_snap.TIntH_GetDatKeyPrV,None,TIntH)
TIntH.GetKeyDatKdV = new_instancemethod(_snap.TIntH_GetKeyDatKdV,None,TIntH)
TIntH.GetDatKeyKdV = new_instancemethod(_snap.TIntH_GetDatKeyKdV,None,TIntH)
TIntH.Swap = new_instancemethod(_snap.TIntH_Swap,None,TIntH)
TIntH.Defrag = new_instancemethod(_snap.TIntH_Defrag,None,TIntH)
TIntH.Pack = new_instancemethod(_snap.TIntH_Pack,None,TIntH)
TIntH.Sort = new_instancemethod(_snap.TIntH_Sort,None,TIntH)
TIntH.SortByKey = new_instancemethod(_snap.TIntH_SortByKey,None,TIntH)
TIntH.SortByDat = new_instancemethod(_snap.TIntH_SortByDat,None,TIntH)
TIntH.AddKey = new_instancemethod(_snap.TIntH_AddKey,None,TIntH)
TIntH.IsKey = new_instancemethod(_snap.TIntH_IsKey,None,TIntH)
TIntH.GetDat = new_instancemethod(_snap.TIntH_GetDat,None,TIntH)
TIntH.AddDat = new_instancemethod(_snap.TIntH_AddDat,None,TIntH)
TIntH_swigregister = _snap.TIntH_swigregister
TIntH_swigregister(TIntH)

class TIntHI(object):
    """Proxy of C++ THashKeyDatI<(TInt,TInt)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(THashKeyDatI<(TInt,TInt)> self) -> TIntHI
        __init__(THashKeyDatI<(TInt,TInt)> self, TIntHI _HashKeyDatI) -> TIntHI

        Parameters:
            _HashKeyDatI: THashKeyDatI< TInt,TInt > const &

        __init__(THashKeyDatI<(TInt,TInt)> self, THashKeyDatI< TInt,TInt >::THKeyDat const * _KeyDatI, THashKeyDatI< TInt,TInt >::THKeyDat const * _EndI) -> TIntHI

        Parameters:
            _KeyDatI: THashKeyDatI< TInt,TInt >::THKeyDat const *
            _EndI: THashKeyDatI< TInt,TInt >::THKeyDat const *

        """
        _snap.TIntHI_swiginit(self,_snap.new_TIntHI(*args))
    def __eq__(self, *args):
        """
        __eq__(TIntHI self, TIntHI HashKeyDatI) -> bool

        Parameters:
            HashKeyDatI: THashKeyDatI< TInt,TInt > const &

        """
        return _snap.TIntHI___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TIntHI self, TIntHI HashKeyDatI) -> bool

        Parameters:
            HashKeyDatI: THashKeyDatI< TInt,TInt > const &

        """
        return _snap.TIntHI___lt__(self, *args)

    def __ref__(self):
        """
        __ref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat &

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI___ref__(self)

    def __call__(self):
        """
        __call__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat &

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI___call__(self)

    def __deref__(self):
        """
        __deref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat *

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI___deref__(self)

    def Next(self):
        """
        Next(TIntHI self) -> TIntHI

        Parameters:
            self: THashKeyDatI< TInt,TInt > *

        """
        return _snap.TIntHI_Next(self)

    def IsEmpty(self):
        """
        IsEmpty(TIntHI self) -> bool

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI_IsEmpty(self)

    def IsEnd(self):
        """
        IsEnd(TIntHI self) -> bool

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI_IsEnd(self)

    def GetKey(self):
        """
        GetKey(TIntHI self) -> TInt

        Parameters:
            self: THashKeyDatI< TInt,TInt > const *

        """
        return _snap.TIntHI_GetKey(self)

    def GetDat(self, *args):
        """
        GetDat(TIntHI self) -> TInt
        GetDat(TIntHI self) -> TInt

        Parameters:
            self: THashKeyDatI< TInt,TInt > *

        """
        return _snap.TIntHI_GetDat(self, *args)

    __swig_destroy__ = _snap.delete_TIntHI
TIntHI.__eq__ = new_instancemethod(_snap.TIntHI___eq__,None,TIntHI)
TIntHI.__lt__ = new_instancemethod(_snap.TIntHI___lt__,None,TIntHI)
TIntHI.__ref__ = new_instancemethod(_snap.TIntHI___ref__,None,TIntHI)
TIntHI.__call__ = new_instancemethod(_snap.TIntHI___call__,None,TIntHI)
TIntHI.__deref__ = new_instancemethod(_snap.TIntHI___deref__,None,TIntHI)
TIntHI.Next = new_instancemethod(_snap.TIntHI_Next,None,TIntHI)
TIntHI.IsEmpty = new_instancemethod(_snap.TIntHI_IsEmpty,None,TIntHI)
TIntHI.IsEnd = new_instancemethod(_snap.TIntHI_IsEnd,None,TIntHI)
TIntHI.GetKey = new_instancemethod(_snap.TIntHI_GetKey,None,TIntHI)
TIntHI.GetDat = new_instancemethod(_snap.TIntHI_GetDat,None,TIntHI)
TIntHI_swigregister = _snap.TIntHI_swigregister
TIntHI_swigregister(TIntHI)

class TStrV(object):
    """Proxy of C++ TVec<(TStr,int)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _snap.delete_TStrV
    def __init__(self, *args): 
        """
        __init__(TVec<(TStr,int)> self) -> TStrV
        __init__(TVec<(TStr,int)> self, TStrV Vec) -> TStrV

        Parameters:
            Vec: TVec< TStr,int > const &

        __init__(TVec<(TStr,int)> self, int const & _Vals) -> TStrV

        Parameters:
            _Vals: int const &

        __init__(TVec<(TStr,int)> self, int const & _MxVals, int const & _Vals) -> TStrV

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        __init__(TVec<(TStr,int)> self, TStr _ValT, int const & _Vals) -> TStrV

        Parameters:
            _ValT: TStr *
            _Vals: int const &

        __init__(TVec<(TStr,int)> self, TSIn SIn) -> TStrV

        Parameters:
            SIn: TSIn &

        """
        _snap.TStrV_swiginit(self,_snap.new_TStrV(*args))
    def Load(self, *args):
        """
        Load(TStrV self, TSIn SIn)

        Parameters:
            SIn: TSIn &

        """
        return _snap.TStrV_Load(self, *args)

    def Save(self, *args):
        """
        Save(TStrV self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TStrV_Save(self, *args)

    def LoadXml(self, *args):
        """
        LoadXml(TStrV self, PXmlTok const & XmlTok, TStr Nm="")

        Parameters:
            XmlTok: PXmlTok const &
            Nm: TStr const &

        LoadXml(TStrV self, PXmlTok const & XmlTok)

        Parameters:
            XmlTok: PXmlTok const &

        """
        return _snap.TStrV_LoadXml(self, *args)

    def SaveXml(self, *args):
        """
        SaveXml(TStrV self, TSOut SOut, TStr Nm)

        Parameters:
            SOut: TSOut &
            Nm: TStr const &

        """
        return _snap.TStrV_SaveXml(self, *args)

    def __add__(self, *args):
        """
        __add__(TStrV self, TStr Val) -> TStrV

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV___add__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TStrV self, TStrV Vec) -> bool

        Parameters:
            Vec: TVec< TStr,int > const &

        """
        return _snap.TStrV___eq__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(TStrV self, TStrV Vec) -> bool

        Parameters:
            Vec: TVec< TStr,int > const &

        """
        return _snap.TStrV___lt__(self, *args)

    def GetMemUsed(self):
        """
        GetMemUsed(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetMemUsed(self)

    def GetMemSize(self):
        """
        GetMemSize(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetMemSize(self)

    def GetPrimHashCd(self):
        """
        GetPrimHashCd(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetPrimHashCd(self)

    def GetSecHashCd(self):
        """
        GetSecHashCd(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetSecHashCd(self)

    def Gen(self, *args):
        """
        Gen(TStrV self, int const & _Vals)

        Parameters:
            _Vals: int const &

        Gen(TStrV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TStrV_Gen(self, *args)

    def GenExt(self, *args):
        """
        GenExt(TStrV self, TStr _ValT, int const & _Vals)

        Parameters:
            _ValT: TStr *
            _Vals: int const &

        """
        return _snap.TStrV_GenExt(self, *args)

    def IsExt(self):
        """
        IsExt(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_IsExt(self)

    def Reserve(self, *args):
        """
        Reserve(TStrV self, int const & _MxVals)

        Parameters:
            _MxVals: int const &

        Reserve(TStrV self, int const & _MxVals, int const & _Vals)

        Parameters:
            _MxVals: int const &
            _Vals: int const &

        """
        return _snap.TStrV_Reserve(self, *args)

    def Clr(self, *args):
        """
        Clr(TStrV self, bool const & DoDel=True, int const & NoDelLim=-1)

        Parameters:
            DoDel: bool const &
            NoDelLim: int const &

        Clr(TStrV self, bool const & DoDel=True)

        Parameters:
            DoDel: bool const &

        Clr(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Clr(self, *args)

    def Trunc(self, *args):
        """
        Trunc(TStrV self, int const & _Vals=-1)

        Parameters:
            _Vals: int const &

        Trunc(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Trunc(self, *args)

    def Pack(self):
        """
        Pack(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Pack(self)

    def MoveFrom(self, *args):
        """
        MoveFrom(TStrV self, TStrV Vec)

        Parameters:
            Vec: TVec< TStr,int > &

        """
        return _snap.TStrV_MoveFrom(self, *args)

    def Empty(self):
        """
        Empty(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_Empty(self)

    def Len(self):
        """
        Len(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_Len(self)

    def Reserved(self):
        """
        Reserved(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_Reserved(self)

    def Last(self, *args):
        """
        Last(TStrV self) -> TStr
        Last(TStrV self) -> TStr

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Last(self, *args)

    def LastValN(self):
        """
        LastValN(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_LastValN(self)

    def LastLast(self, *args):
        """
        LastLast(TStrV self) -> TStr
        LastLast(TStrV self) -> TStr

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_LastLast(self, *args)

    def BegI(self):
        """
        BegI(TStrV self) -> TStr

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_BegI(self)

    def EndI(self):
        """
        EndI(TStrV self) -> TStr

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_EndI(self)

    def GetI(self, *args):
        """
        GetI(TStrV self, int const & ValN) -> TStr

        Parameters:
            ValN: int const &

        """
        return _snap.TStrV_GetI(self, *args)

    def AddV(self, *args):
        """
        AddV(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_AddV(self, *args)

    def AddSorted(self, *args):
        """
        AddSorted(TStrV self, TStr Val, bool const & Asc=True, int const & _MxVals=-1) -> int

        Parameters:
            Val: TStr const &
            Asc: bool const &
            _MxVals: int const &

        AddSorted(TStrV self, TStr Val, bool const & Asc=True) -> int

        Parameters:
            Val: TStr const &
            Asc: bool const &

        AddSorted(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_AddSorted(self, *args)

    def AddBackSorted(self, *args):
        """
        AddBackSorted(TStrV self, TStr Val, bool const & Asc) -> int

        Parameters:
            Val: TStr const &
            Asc: bool const &

        """
        return _snap.TStrV_AddBackSorted(self, *args)

    def AddVMerged(self, *args):
        """
        AddVMerged(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_AddVMerged(self, *args)

    def AddUnique(self, *args):
        """
        AddUnique(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_AddUnique(self, *args)

    def GetVal(self, *args):
        """
        GetVal(TStrV self, int const & ValN) -> TStr

        Parameters:
            ValN: int const &

        GetVal(TStrV self, int const & ValN) -> TStr

        Parameters:
            ValN: int const &

        """
        return _snap.TStrV_GetVal(self, *args)

    def GetSubValV(self, *args):
        """
        GetSubValV(TStrV self, int const & BValN, int const & EValN, TStrV ValV)

        Parameters:
            BValN: int const &
            EValN: int const &
            ValV: TVec< TStr,int > &

        """
        return _snap.TStrV_GetSubValV(self, *args)

    def Ins(self, *args):
        """
        Ins(TStrV self, int const & ValN, TStr Val)

        Parameters:
            ValN: int const &
            Val: TStr const &

        """
        return _snap.TStrV_Ins(self, *args)

    def Del(self, *args):
        """
        Del(TStrV self, int const & ValN)

        Parameters:
            ValN: int const &

        Del(TStrV self, int const & MnValN, int const & MxValN)

        Parameters:
            MnValN: int const &
            MxValN: int const &

        """
        return _snap.TStrV_Del(self, *args)

    def DelLast(self):
        """
        DelLast(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_DelLast(self)

    def DelIfIn(self, *args):
        """
        DelIfIn(TStrV self, TStr Val) -> bool

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_DelIfIn(self, *args)

    def DelAll(self, *args):
        """
        DelAll(TStrV self, TStr Val)

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_DelAll(self, *args)

    def PutAll(self, *args):
        """
        PutAll(TStrV self, TStr Val)

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_PutAll(self, *args)

    def Swap(self, *args):
        """
        Swap(TStrV self, TStrV Vec)

        Parameters:
            Vec: TVec< TStr,int > &

        Swap(TStrV self, int const & ValN1, int const & ValN2)

        Parameters:
            ValN1: int const &
            ValN2: int const &

        """
        return _snap.TStrV_Swap(self, *args)

    def SwapI(*args):
        """
        SwapI(TStr LVal, TStr RVal)

        Parameters:
            LVal: TVec< TStr,int >::TIter
            RVal: TVec< TStr,int >::TIter

        """
        return _snap.TStrV_SwapI(*args)

    SwapI = staticmethod(SwapI)
    def NextPerm(self):
        """
        NextPerm(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_NextPerm(self)

    def PrevPerm(self):
        """
        PrevPerm(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_PrevPerm(self)

    def GetPivotValN(self, *args):
        """
        GetPivotValN(TStrV self, int const & LValN, int const & RValN) -> int

        Parameters:
            LValN: int const &
            RValN: int const &

        """
        return _snap.TStrV_GetPivotValN(self, *args)

    def BSort(self, *args):
        """
        BSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TStrV_BSort(self, *args)

    def ISort(self, *args):
        """
        ISort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TStrV_ISort(self, *args)

    def Partition(self, *args):
        """
        Partition(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TStrV_Partition(self, *args)

    def QSort(self, *args):
        """
        QSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)

        Parameters:
            MnLValN: int const &
            MxRValN: int const &
            Asc: bool const &

        """
        return _snap.TStrV_QSort(self, *args)

    def Sort(self, Asc=True):
        """
        Sort(TStrV self, bool const & Asc=True)

        Parameters:
            Asc: bool const &

        Sort(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Sort(self, Asc)

    def IsSorted(self, Asc=True):
        """
        IsSorted(TStrV self, bool const & Asc=True) -> bool

        Parameters:
            Asc: bool const &

        IsSorted(TStrV self) -> bool

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_IsSorted(self, Asc)

    def Shuffle(self, *args):
        """
        Shuffle(TStrV self, TRnd Rnd)

        Parameters:
            Rnd: TRnd &

        """
        return _snap.TStrV_Shuffle(self, *args)

    def Reverse(self, *args):
        """
        Reverse(TStrV self)
        Reverse(TStrV self, int LValN, int RValN)

        Parameters:
            LValN: int
            RValN: int

        """
        return _snap.TStrV_Reverse(self, *args)

    def Merge(self):
        """
        Merge(TStrV self)

        Parameters:
            self: TVec< TStr,int > *

        """
        return _snap.TStrV_Merge(self)

    def Intrs(self, *args):
        """
        Intrs(TStrV self, TStrV ValV)

        Parameters:
            ValV: TVec< TStr,int > const &

        Intrs(TStrV self, TStrV ValV, TStrV DstValV)

        Parameters:
            ValV: TVec< TStr,int > const &
            DstValV: TVec< TStr,int > &

        """
        return _snap.TStrV_Intrs(self, *args)

    def Union(self, *args):
        """
        Union(TStrV self, TStrV ValV)

        Parameters:
            ValV: TVec< TStr,int > const &

        Union(TStrV self, TStrV ValV, TStrV DstValV)

        Parameters:
            ValV: TVec< TStr,int > const &
            DstValV: TVec< TStr,int > &

        """
        return _snap.TStrV_Union(self, *args)

    def Diff(self, *args):
        """
        Diff(TStrV self, TStrV ValV)

        Parameters:
            ValV: TVec< TStr,int > const &

        Diff(TStrV self, TStrV ValV, TStrV DstValV)

        Parameters:
            ValV: TVec< TStr,int > const &
            DstValV: TVec< TStr,int > &

        """
        return _snap.TStrV_Diff(self, *args)

    def IntrsLen(self, *args):
        """
        IntrsLen(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_IntrsLen(self, *args)

    def UnionLen(self, *args):
        """
        UnionLen(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_UnionLen(self, *args)

    def Count(self, *args):
        """
        Count(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_Count(self, *args)

    def SearchBin(self, *args):
        """
        SearchBin(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        SearchBin(TStrV self, TStr Val, int & InsValN) -> int

        Parameters:
            Val: TStr const &
            InsValN: int &

        """
        return _snap.TStrV_SearchBin(self, *args)

    def SearchForw(self, *args):
        """
        SearchForw(TStrV self, TStr Val, int const & BValN=0) -> int

        Parameters:
            Val: TStr const &
            BValN: int const &

        SearchForw(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_SearchForw(self, *args)

    def SearchBack(self, *args):
        """
        SearchBack(TStrV self, TStr Val) -> int

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_SearchBack(self, *args)

    def SearchVForw(self, *args):
        """
        SearchVForw(TStrV self, TStrV ValV, int const & BValN=0) -> int

        Parameters:
            ValV: TVec< TStr,int > const &
            BValN: int const &

        SearchVForw(TStrV self, TStrV ValV) -> int

        Parameters:
            ValV: TVec< TStr,int > const &

        """
        return _snap.TStrV_SearchVForw(self, *args)

    def IsIn(self, *args):
        """
        IsIn(TStrV self, TStr Val) -> bool

        Parameters:
            Val: TStr const &

        IsIn(TStrV self, TStr Val, int & ValN) -> bool

        Parameters:
            Val: TStr const &
            ValN: int &

        """
        return _snap.TStrV_IsIn(self, *args)

    def IsInBin(self, *args):
        """
        IsInBin(TStrV self, TStr Val) -> bool

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_IsInBin(self, *args)

    def GetDat(self, *args):
        """
        GetDat(TStrV self, TStr Val) -> TStr

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_GetDat(self, *args)

    def GetAddDat(self, *args):
        """
        GetAddDat(TStrV self, TStr Val) -> TStr

        Parameters:
            Val: TStr const &

        """
        return _snap.TStrV_GetAddDat(self, *args)

    def GetMxValN(self):
        """
        GetMxValN(TStrV self) -> int

        Parameters:
            self: TVec< TStr,int > const *

        """
        return _snap.TStrV_GetMxValN(self)

    def GetV(*args):
        """
        GetV(TStr Val1) -> TStrV

        Parameters:
            Val1: TStr const &

        GetV(TStr Val1, TStr Val2) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &
            Val6: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &
            Val6: TStr const &
            Val7: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &
            Val6: TStr const &
            Val7: TStr const &
            Val8: TStr const &

        GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8, 
            TStr Val9) -> TStrV

        Parameters:
            Val1: TStr const &
            Val2: TStr const &
            Val3: TStr const &
            Val4: TStr const &
            Val5: TStr const &
            Val6: TStr const &
            Val7: TStr const &
            Val8: TStr const &
            Val9: TStr const &

        """
        return _snap.TStrV_GetV(*args)

    GetV = staticmethod(GetV)
TStrV.Load = new_instancemethod(_snap.TStrV_Load,None,TStrV)
TStrV.Save = new_instancemethod(_snap.TStrV_Save,None,TStrV)
TStrV.LoadXml = new_instancemethod(_snap.TStrV_LoadXml,None,TStrV)
TStrV.SaveXml = new_instancemethod(_snap.TStrV_SaveXml,None,TStrV)
TStrV.__add__ = new_instancemethod(_snap.TStrV___add__,None,TStrV)
TStrV.__eq__ = new_instancemethod(_snap.TStrV___eq__,None,TStrV)
TStrV.__lt__ = new_instancemethod(_snap.TStrV___lt__,None,TStrV)
TStrV.GetMemUsed = new_instancemethod(_snap.TStrV_GetMemUsed,None,TStrV)
TStrV.GetMemSize = new_instancemethod(_snap.TStrV_GetMemSize,None,TStrV)
TStrV.GetPrimHashCd = new_instancemethod(_snap.TStrV_GetPrimHashCd,None,TStrV)
TStrV.GetSecHashCd = new_instancemethod(_snap.TStrV_GetSecHashCd,None,TStrV)
TStrV.Gen = new_instancemethod(_snap.TStrV_Gen,None,TStrV)
TStrV.GenExt = new_instancemethod(_snap.TStrV_GenExt,None,TStrV)
TStrV.IsExt = new_instancemethod(_snap.TStrV_IsExt,None,TStrV)
TStrV.Reserve = new_instancemethod(_snap.TStrV_Reserve,None,TStrV)
TStrV.Clr = new_instancemethod(_snap.TStrV_Clr,None,TStrV)
TStrV.Trunc = new_instancemethod(_snap.TStrV_Trunc,None,TStrV)
TStrV.Pack = new_instancemethod(_snap.TStrV_Pack,None,TStrV)
TStrV.MoveFrom = new_instancemethod(_snap.TStrV_MoveFrom,None,TStrV)
TStrV.Empty = new_instancemethod(_snap.TStrV_Empty,None,TStrV)
TStrV.Len = new_instancemethod(_snap.TStrV_Len,None,TStrV)
TStrV.Reserved = new_instancemethod(_snap.TStrV_Reserved,None,TStrV)
TStrV.Last = new_instancemethod(_snap.TStrV_Last,None,TStrV)
TStrV.LastValN = new_instancemethod(_snap.TStrV_LastValN,None,TStrV)
TStrV.LastLast = new_instancemethod(_snap.TStrV_LastLast,None,TStrV)
TStrV.BegI = new_instancemethod(_snap.TStrV_BegI,None,TStrV)
TStrV.EndI = new_instancemethod(_snap.TStrV_EndI,None,TStrV)
TStrV.GetI = new_instancemethod(_snap.TStrV_GetI,None,TStrV)
TStrV.AddV = new_instancemethod(_snap.TStrV_AddV,None,TStrV)
TStrV.AddSorted = new_instancemethod(_snap.TStrV_AddSorted,None,TStrV)
TStrV.AddBackSorted = new_instancemethod(_snap.TStrV_AddBackSorted,None,TStrV)
TStrV.AddVMerged = new_instancemethod(_snap.TStrV_AddVMerged,None,TStrV)
TStrV.AddUnique = new_instancemethod(_snap.TStrV_AddUnique,None,TStrV)
TStrV.GetVal = new_instancemethod(_snap.TStrV_GetVal,None,TStrV)
TStrV.GetSubValV = new_instancemethod(_snap.TStrV_GetSubValV,None,TStrV)
TStrV.Ins = new_instancemethod(_snap.TStrV_Ins,None,TStrV)
TStrV.Del = new_instancemethod(_snap.TStrV_Del,None,TStrV)
TStrV.DelLast = new_instancemethod(_snap.TStrV_DelLast,None,TStrV)
TStrV.DelIfIn = new_instancemethod(_snap.TStrV_DelIfIn,None,TStrV)
TStrV.DelAll = new_instancemethod(_snap.TStrV_DelAll,None,TStrV)
TStrV.PutAll = new_instancemethod(_snap.TStrV_PutAll,None,TStrV)
TStrV.Swap = new_instancemethod(_snap.TStrV_Swap,None,TStrV)
TStrV.NextPerm = new_instancemethod(_snap.TStrV_NextPerm,None,TStrV)
TStrV.PrevPerm = new_instancemethod(_snap.TStrV_PrevPerm,None,TStrV)
TStrV.GetPivotValN = new_instancemethod(_snap.TStrV_GetPivotValN,None,TStrV)
TStrV.BSort = new_instancemethod(_snap.TStrV_BSort,None,TStrV)
TStrV.ISort = new_instancemethod(_snap.TStrV_ISort,None,TStrV)
TStrV.Partition = new_instancemethod(_snap.TStrV_Partition,None,TStrV)
TStrV.QSort = new_instancemethod(_snap.TStrV_QSort,None,TStrV)
TStrV.Sort = new_instancemethod(_snap.TStrV_Sort,None,TStrV)
TStrV.IsSorted = new_instancemethod(_snap.TStrV_IsSorted,None,TStrV)
TStrV.Shuffle = new_instancemethod(_snap.TStrV_Shuffle,None,TStrV)
TStrV.Reverse = new_instancemethod(_snap.TStrV_Reverse,None,TStrV)
TStrV.Merge = new_instancemethod(_snap.TStrV_Merge,None,TStrV)
TStrV.Intrs = new_instancemethod(_snap.TStrV_Intrs,None,TStrV)
TStrV.Union = new_instancemethod(_snap.TStrV_Union,None,TStrV)
TStrV.Diff = new_instancemethod(_snap.TStrV_Diff,None,TStrV)
TStrV.IntrsLen = new_instancemethod(_snap.TStrV_IntrsLen,None,TStrV)
TStrV.UnionLen = new_instancemethod(_snap.TStrV_UnionLen,None,TStrV)
TStrV.Count = new_instancemethod(_snap.TStrV_Count,None,TStrV)
TStrV.SearchBin = new_instancemethod(_snap.TStrV_SearchBin,None,TStrV)
TStrV.SearchForw = new_instancemethod(_snap.TStrV_SearchForw,None,TStrV)
TStrV.SearchBack = new_instancemethod(_snap.TStrV_SearchBack,None,TStrV)
TStrV.SearchVForw = new_instancemethod(_snap.TStrV_SearchVForw,None,TStrV)
TStrV.IsIn = new_instancemethod(_snap.TStrV_IsIn,None,TStrV)
TStrV.IsInBin = new_instancemethod(_snap.TStrV_IsInBin,None,TStrV)
TStrV.GetDat = new_instancemethod(_snap.TStrV_GetDat,None,TStrV)
TStrV.GetAddDat = new_instancemethod(_snap.TStrV_GetAddDat,None,TStrV)
TStrV.GetMxValN = new_instancemethod(_snap.TStrV_GetMxValN,None,TStrV)
TStrV_swigregister = _snap.TStrV_swigregister
TStrV_swigregister(TStrV)

def TStrV_SwapI(*args):
  """
    TStrV_SwapI(TStr LVal, TStr RVal)

    Parameters:
        LVal: TVec< TStr,int >::TIter
        RVal: TVec< TStr,int >::TIter

    """
  return _snap.TStrV_SwapI(*args)

def TStrV_GetV(*args):
  """
    GetV(TStr Val1) -> TStrV

    Parameters:
        Val1: TStr const &

    GetV(TStr Val1, TStr Val2) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &
        Val6: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &
        Val6: TStr const &
        Val7: TStr const &

    GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &
        Val6: TStr const &
        Val7: TStr const &
        Val8: TStr const &

    TStrV_GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8, 
        TStr Val9) -> TStrV

    Parameters:
        Val1: TStr const &
        Val2: TStr const &
        Val3: TStr const &
        Val4: TStr const &
        Val5: TStr const &
        Val6: TStr const &
        Val7: TStr const &
        Val8: TStr const &
        Val9: TStr const &

    """
  return _snap.TStrV_GetV(*args)

class TNGraphNodeI(object):
    """Proxy of C++ TNGraphNodeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNGraphNodeI self) -> TNGraphNodeI
        __init__(TNGraphNodeI self, TNGraph::TNodeI const & NodeI) -> TNGraphNodeI

        Parameters:
            NodeI: TNGraph::TNodeI const &

        """
        _snap.TNGraphNodeI_swiginit(self,_snap.new_TNGraphNodeI(*args))
    def Next(self):
        """
        Next(TNGraphNodeI self) -> TNGraphNodeI

        Parameters:
            self: TNGraphNodeI *

        """
        return _snap.TNGraphNodeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool

        Parameters:
            NodeI: TNGraphNodeI const &

        """
        return _snap.TNGraphNodeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool

        Parameters:
            NodeI: TNGraphNodeI const &

        """
        return _snap.TNGraphNodeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TNGraphNodeI self) -> int

        Parameters:
            self: TNGraphNodeI const *

        """
        return _snap.TNGraphNodeI_GetId(self)

    def GetDeg(self):
        """
        GetDeg(TNGraphNodeI self) -> int

        Parameters:
            self: TNGraphNodeI const *

        """
        return _snap.TNGraphNodeI_GetDeg(self)

    def GetInDeg(self):
        """
        GetInDeg(TNGraphNodeI self) -> int

        Parameters:
            self: TNGraphNodeI const *

        """
        return _snap.TNGraphNodeI_GetInDeg(self)

    def GetOutDeg(self):
        """
        GetOutDeg(TNGraphNodeI self) -> int

        Parameters:
            self: TNGraphNodeI const *

        """
        return _snap.TNGraphNodeI_GetOutDeg(self)

    def GetInNId(self, *args):
        """
        GetInNId(TNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNGraphNodeI_GetInNId(self, *args)

    def GetOutNId(self, *args):
        """
        GetOutNId(TNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNGraphNodeI_GetOutNId(self, *args)

    def GetNbrNId(self, *args):
        """
        GetNbrNId(TNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNGraphNodeI_GetNbrNId(self, *args)

    def IsInNId(self, *args):
        """
        IsInNId(TNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNGraphNodeI_IsInNId(self, *args)

    def IsOutNId(self, *args):
        """
        IsOutNId(TNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNGraphNodeI_IsOutNId(self, *args)

    def IsNbrNId(self, *args):
        """
        IsNbrNId(TNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNGraphNodeI_IsNbrNId(self, *args)

    __swig_destroy__ = _snap.delete_TNGraphNodeI
TNGraphNodeI.Next = new_instancemethod(_snap.TNGraphNodeI_Next,None,TNGraphNodeI)
TNGraphNodeI.__lt__ = new_instancemethod(_snap.TNGraphNodeI___lt__,None,TNGraphNodeI)
TNGraphNodeI.__eq__ = new_instancemethod(_snap.TNGraphNodeI___eq__,None,TNGraphNodeI)
TNGraphNodeI.GetId = new_instancemethod(_snap.TNGraphNodeI_GetId,None,TNGraphNodeI)
TNGraphNodeI.GetDeg = new_instancemethod(_snap.TNGraphNodeI_GetDeg,None,TNGraphNodeI)
TNGraphNodeI.GetInDeg = new_instancemethod(_snap.TNGraphNodeI_GetInDeg,None,TNGraphNodeI)
TNGraphNodeI.GetOutDeg = new_instancemethod(_snap.TNGraphNodeI_GetOutDeg,None,TNGraphNodeI)
TNGraphNodeI.GetInNId = new_instancemethod(_snap.TNGraphNodeI_GetInNId,None,TNGraphNodeI)
TNGraphNodeI.GetOutNId = new_instancemethod(_snap.TNGraphNodeI_GetOutNId,None,TNGraphNodeI)
TNGraphNodeI.GetNbrNId = new_instancemethod(_snap.TNGraphNodeI_GetNbrNId,None,TNGraphNodeI)
TNGraphNodeI.IsInNId = new_instancemethod(_snap.TNGraphNodeI_IsInNId,None,TNGraphNodeI)
TNGraphNodeI.IsOutNId = new_instancemethod(_snap.TNGraphNodeI_IsOutNId,None,TNGraphNodeI)
TNGraphNodeI.IsNbrNId = new_instancemethod(_snap.TNGraphNodeI_IsNbrNId,None,TNGraphNodeI)
TNGraphNodeI_swigregister = _snap.TNGraphNodeI_swigregister
TNGraphNodeI_swigregister(TNGraphNodeI)

class TNGraphEdgeI(object):
    """Proxy of C++ TNGraphEdgeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNGraphEdgeI self) -> TNGraphEdgeI
        __init__(TNGraphEdgeI self, TNGraph::TEdgeI const & EdgeI) -> TNGraphEdgeI

        Parameters:
            EdgeI: TNGraph::TEdgeI const &

        """
        _snap.TNGraphEdgeI_swiginit(self,_snap.new_TNGraphEdgeI(*args))
    def Next(self):
        """
        Next(TNGraphEdgeI self) -> TNGraphEdgeI

        Parameters:
            self: TNGraphEdgeI *

        """
        return _snap.TNGraphEdgeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TNGraphEdgeI const &

        """
        return _snap.TNGraphEdgeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TNGraphEdgeI const &

        """
        return _snap.TNGraphEdgeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TNGraphEdgeI self) -> int

        Parameters:
            self: TNGraphEdgeI const *

        """
        return _snap.TNGraphEdgeI_GetId(self)

    def GetSrcNId(self):
        """
        GetSrcNId(TNGraphEdgeI self) -> int

        Parameters:
            self: TNGraphEdgeI const *

        """
        return _snap.TNGraphEdgeI_GetSrcNId(self)

    def GetDstNId(self):
        """
        GetDstNId(TNGraphEdgeI self) -> int

        Parameters:
            self: TNGraphEdgeI const *

        """
        return _snap.TNGraphEdgeI_GetDstNId(self)

    __swig_destroy__ = _snap.delete_TNGraphEdgeI
TNGraphEdgeI.Next = new_instancemethod(_snap.TNGraphEdgeI_Next,None,TNGraphEdgeI)
TNGraphEdgeI.__lt__ = new_instancemethod(_snap.TNGraphEdgeI___lt__,None,TNGraphEdgeI)
TNGraphEdgeI.__eq__ = new_instancemethod(_snap.TNGraphEdgeI___eq__,None,TNGraphEdgeI)
TNGraphEdgeI.GetId = new_instancemethod(_snap.TNGraphEdgeI_GetId,None,TNGraphEdgeI)
TNGraphEdgeI.GetSrcNId = new_instancemethod(_snap.TNGraphEdgeI_GetSrcNId,None,TNGraphEdgeI)
TNGraphEdgeI.GetDstNId = new_instancemethod(_snap.TNGraphEdgeI_GetDstNId,None,TNGraphEdgeI)
TNGraphEdgeI_swigregister = _snap.TNGraphEdgeI_swigregister
TNGraphEdgeI_swigregister(TNGraphEdgeI)

class TUNGraphNodeI(object):
    """Proxy of C++ TUNGraphNodeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TUNGraphNodeI self) -> TUNGraphNodeI
        __init__(TUNGraphNodeI self, TUNGraph::TNodeI const & NodeI) -> TUNGraphNodeI

        Parameters:
            NodeI: TUNGraph::TNodeI const &

        """
        _snap.TUNGraphNodeI_swiginit(self,_snap.new_TUNGraphNodeI(*args))
    def Next(self):
        """
        Next(TUNGraphNodeI self) -> TUNGraphNodeI

        Parameters:
            self: TUNGraphNodeI *

        """
        return _snap.TUNGraphNodeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool

        Parameters:
            NodeI: TUNGraphNodeI const &

        """
        return _snap.TUNGraphNodeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool

        Parameters:
            NodeI: TUNGraphNodeI const &

        """
        return _snap.TUNGraphNodeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TUNGraphNodeI self) -> int

        Parameters:
            self: TUNGraphNodeI const *

        """
        return _snap.TUNGraphNodeI_GetId(self)

    def GetDeg(self):
        """
        GetDeg(TUNGraphNodeI self) -> int

        Parameters:
            self: TUNGraphNodeI const *

        """
        return _snap.TUNGraphNodeI_GetDeg(self)

    def GetInDeg(self):
        """
        GetInDeg(TUNGraphNodeI self) -> int

        Parameters:
            self: TUNGraphNodeI const *

        """
        return _snap.TUNGraphNodeI_GetInDeg(self)

    def GetOutDeg(self):
        """
        GetOutDeg(TUNGraphNodeI self) -> int

        Parameters:
            self: TUNGraphNodeI const *

        """
        return _snap.TUNGraphNodeI_GetOutDeg(self)

    def GetInNId(self, *args):
        """
        GetInNId(TUNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TUNGraphNodeI_GetInNId(self, *args)

    def GetOutNId(self, *args):
        """
        GetOutNId(TUNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TUNGraphNodeI_GetOutNId(self, *args)

    def GetNbrNId(self, *args):
        """
        GetNbrNId(TUNGraphNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TUNGraphNodeI_GetNbrNId(self, *args)

    def IsInNId(self, *args):
        """
        IsInNId(TUNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraphNodeI_IsInNId(self, *args)

    def IsOutNId(self, *args):
        """
        IsOutNId(TUNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraphNodeI_IsOutNId(self, *args)

    def IsNbrNId(self, *args):
        """
        IsNbrNId(TUNGraphNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TUNGraphNodeI_IsNbrNId(self, *args)

    __swig_destroy__ = _snap.delete_TUNGraphNodeI
TUNGraphNodeI.Next = new_instancemethod(_snap.TUNGraphNodeI_Next,None,TUNGraphNodeI)
TUNGraphNodeI.__lt__ = new_instancemethod(_snap.TUNGraphNodeI___lt__,None,TUNGraphNodeI)
TUNGraphNodeI.__eq__ = new_instancemethod(_snap.TUNGraphNodeI___eq__,None,TUNGraphNodeI)
TUNGraphNodeI.GetId = new_instancemethod(_snap.TUNGraphNodeI_GetId,None,TUNGraphNodeI)
TUNGraphNodeI.GetDeg = new_instancemethod(_snap.TUNGraphNodeI_GetDeg,None,TUNGraphNodeI)
TUNGraphNodeI.GetInDeg = new_instancemethod(_snap.TUNGraphNodeI_GetInDeg,None,TUNGraphNodeI)
TUNGraphNodeI.GetOutDeg = new_instancemethod(_snap.TUNGraphNodeI_GetOutDeg,None,TUNGraphNodeI)
TUNGraphNodeI.GetInNId = new_instancemethod(_snap.TUNGraphNodeI_GetInNId,None,TUNGraphNodeI)
TUNGraphNodeI.GetOutNId = new_instancemethod(_snap.TUNGraphNodeI_GetOutNId,None,TUNGraphNodeI)
TUNGraphNodeI.GetNbrNId = new_instancemethod(_snap.TUNGraphNodeI_GetNbrNId,None,TUNGraphNodeI)
TUNGraphNodeI.IsInNId = new_instancemethod(_snap.TUNGraphNodeI_IsInNId,None,TUNGraphNodeI)
TUNGraphNodeI.IsOutNId = new_instancemethod(_snap.TUNGraphNodeI_IsOutNId,None,TUNGraphNodeI)
TUNGraphNodeI.IsNbrNId = new_instancemethod(_snap.TUNGraphNodeI_IsNbrNId,None,TUNGraphNodeI)
TUNGraphNodeI_swigregister = _snap.TUNGraphNodeI_swigregister
TUNGraphNodeI_swigregister(TUNGraphNodeI)

class TUNGraphEdgeI(object):
    """Proxy of C++ TUNGraphEdgeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TUNGraphEdgeI self) -> TUNGraphEdgeI
        __init__(TUNGraphEdgeI self, TUNGraph::TEdgeI const & EdgeI) -> TUNGraphEdgeI

        Parameters:
            EdgeI: TUNGraph::TEdgeI const &

        """
        _snap.TUNGraphEdgeI_swiginit(self,_snap.new_TUNGraphEdgeI(*args))
    def Next(self):
        """
        Next(TUNGraphEdgeI self) -> TUNGraphEdgeI

        Parameters:
            self: TUNGraphEdgeI *

        """
        return _snap.TUNGraphEdgeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TUNGraphEdgeI const &

        """
        return _snap.TUNGraphEdgeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TUNGraphEdgeI const &

        """
        return _snap.TUNGraphEdgeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TUNGraphEdgeI self) -> int

        Parameters:
            self: TUNGraphEdgeI const *

        """
        return _snap.TUNGraphEdgeI_GetId(self)

    def GetSrcNId(self):
        """
        GetSrcNId(TUNGraphEdgeI self) -> int

        Parameters:
            self: TUNGraphEdgeI const *

        """
        return _snap.TUNGraphEdgeI_GetSrcNId(self)

    def GetDstNId(self):
        """
        GetDstNId(TUNGraphEdgeI self) -> int

        Parameters:
            self: TUNGraphEdgeI const *

        """
        return _snap.TUNGraphEdgeI_GetDstNId(self)

    __swig_destroy__ = _snap.delete_TUNGraphEdgeI
TUNGraphEdgeI.Next = new_instancemethod(_snap.TUNGraphEdgeI_Next,None,TUNGraphEdgeI)
TUNGraphEdgeI.__lt__ = new_instancemethod(_snap.TUNGraphEdgeI___lt__,None,TUNGraphEdgeI)
TUNGraphEdgeI.__eq__ = new_instancemethod(_snap.TUNGraphEdgeI___eq__,None,TUNGraphEdgeI)
TUNGraphEdgeI.GetId = new_instancemethod(_snap.TUNGraphEdgeI_GetId,None,TUNGraphEdgeI)
TUNGraphEdgeI.GetSrcNId = new_instancemethod(_snap.TUNGraphEdgeI_GetSrcNId,None,TUNGraphEdgeI)
TUNGraphEdgeI.GetDstNId = new_instancemethod(_snap.TUNGraphEdgeI_GetDstNId,None,TUNGraphEdgeI)
TUNGraphEdgeI_swigregister = _snap.TUNGraphEdgeI_swigregister
TUNGraphEdgeI_swigregister(TUNGraphEdgeI)

class TNEANetNodeI(object):
    """Proxy of C++ TNEANetNodeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetNodeI self) -> TNEANetNodeI
        __init__(TNEANetNodeI self, TNEANet::TNodeI const & NodeI) -> TNEANetNodeI

        Parameters:
            NodeI: TNEANet::TNodeI const &

        """
        _snap.TNEANetNodeI_swiginit(self,_snap.new_TNEANetNodeI(*args))
    def Next(self):
        """
        Next(TNEANetNodeI self) -> TNEANetNodeI

        Parameters:
            self: TNEANetNodeI *

        """
        return _snap.TNEANetNodeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool

        Parameters:
            NodeI: TNEANetNodeI const &

        """
        return _snap.TNEANetNodeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool

        Parameters:
            NodeI: TNEANetNodeI const &

        """
        return _snap.TNEANetNodeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TNEANetNodeI self) -> int

        Parameters:
            self: TNEANetNodeI const *

        """
        return _snap.TNEANetNodeI_GetId(self)

    def GetDeg(self):
        """
        GetDeg(TNEANetNodeI self) -> int

        Parameters:
            self: TNEANetNodeI const *

        """
        return _snap.TNEANetNodeI_GetDeg(self)

    def GetInDeg(self):
        """
        GetInDeg(TNEANetNodeI self) -> int

        Parameters:
            self: TNEANetNodeI const *

        """
        return _snap.TNEANetNodeI_GetInDeg(self)

    def GetOutDeg(self):
        """
        GetOutDeg(TNEANetNodeI self) -> int

        Parameters:
            self: TNEANetNodeI const *

        """
        return _snap.TNEANetNodeI_GetOutDeg(self)

    def GetInNId(self, *args):
        """
        GetInNId(TNEANetNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNEANetNodeI_GetInNId(self, *args)

    def GetOutNId(self, *args):
        """
        GetOutNId(TNEANetNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNEANetNodeI_GetOutNId(self, *args)

    def GetNbrNId(self, *args):
        """
        GetNbrNId(TNEANetNodeI self, int const & NodeN) -> int

        Parameters:
            NodeN: int const &

        """
        return _snap.TNEANetNodeI_GetNbrNId(self, *args)

    def IsInNId(self, *args):
        """
        IsInNId(TNEANetNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEANetNodeI_IsInNId(self, *args)

    def IsOutNId(self, *args):
        """
        IsOutNId(TNEANetNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEANetNodeI_IsOutNId(self, *args)

    def IsNbrNId(self, *args):
        """
        IsNbrNId(TNEANetNodeI self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEANetNodeI_IsNbrNId(self, *args)

    __swig_destroy__ = _snap.delete_TNEANetNodeI
TNEANetNodeI.Next = new_instancemethod(_snap.TNEANetNodeI_Next,None,TNEANetNodeI)
TNEANetNodeI.__lt__ = new_instancemethod(_snap.TNEANetNodeI___lt__,None,TNEANetNodeI)
TNEANetNodeI.__eq__ = new_instancemethod(_snap.TNEANetNodeI___eq__,None,TNEANetNodeI)
TNEANetNodeI.GetId = new_instancemethod(_snap.TNEANetNodeI_GetId,None,TNEANetNodeI)
TNEANetNodeI.GetDeg = new_instancemethod(_snap.TNEANetNodeI_GetDeg,None,TNEANetNodeI)
TNEANetNodeI.GetInDeg = new_instancemethod(_snap.TNEANetNodeI_GetInDeg,None,TNEANetNodeI)
TNEANetNodeI.GetOutDeg = new_instancemethod(_snap.TNEANetNodeI_GetOutDeg,None,TNEANetNodeI)
TNEANetNodeI.GetInNId = new_instancemethod(_snap.TNEANetNodeI_GetInNId,None,TNEANetNodeI)
TNEANetNodeI.GetOutNId = new_instancemethod(_snap.TNEANetNodeI_GetOutNId,None,TNEANetNodeI)
TNEANetNodeI.GetNbrNId = new_instancemethod(_snap.TNEANetNodeI_GetNbrNId,None,TNEANetNodeI)
TNEANetNodeI.IsInNId = new_instancemethod(_snap.TNEANetNodeI_IsInNId,None,TNEANetNodeI)
TNEANetNodeI.IsOutNId = new_instancemethod(_snap.TNEANetNodeI_IsOutNId,None,TNEANetNodeI)
TNEANetNodeI.IsNbrNId = new_instancemethod(_snap.TNEANetNodeI_IsNbrNId,None,TNEANetNodeI)
TNEANetNodeI_swigregister = _snap.TNEANetNodeI_swigregister
TNEANetNodeI_swigregister(TNEANetNodeI)

class TNEANetEdgeI(object):
    """Proxy of C++ TNEANetEdgeI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetEdgeI self) -> TNEANetEdgeI
        __init__(TNEANetEdgeI self, TNEANet::TEdgeI const & EdgeI) -> TNEANetEdgeI

        Parameters:
            EdgeI: TNEANet::TEdgeI const &

        """
        _snap.TNEANetEdgeI_swiginit(self,_snap.new_TNEANetEdgeI(*args))
    def Next(self):
        """
        Next(TNEANetEdgeI self) -> TNEANetEdgeI

        Parameters:
            self: TNEANetEdgeI *

        """
        return _snap.TNEANetEdgeI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TNEANetEdgeI const &

        """
        return _snap.TNEANetEdgeI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool

        Parameters:
            EdgeI: TNEANetEdgeI const &

        """
        return _snap.TNEANetEdgeI___eq__(self, *args)

    def GetId(self):
        """
        GetId(TNEANetEdgeI self) -> int

        Parameters:
            self: TNEANetEdgeI const *

        """
        return _snap.TNEANetEdgeI_GetId(self)

    def GetSrcNId(self):
        """
        GetSrcNId(TNEANetEdgeI self) -> int

        Parameters:
            self: TNEANetEdgeI const *

        """
        return _snap.TNEANetEdgeI_GetSrcNId(self)

    def GetDstNId(self):
        """
        GetDstNId(TNEANetEdgeI self) -> int

        Parameters:
            self: TNEANetEdgeI const *

        """
        return _snap.TNEANetEdgeI_GetDstNId(self)

    __swig_destroy__ = _snap.delete_TNEANetEdgeI
TNEANetEdgeI.Next = new_instancemethod(_snap.TNEANetEdgeI_Next,None,TNEANetEdgeI)
TNEANetEdgeI.__lt__ = new_instancemethod(_snap.TNEANetEdgeI___lt__,None,TNEANetEdgeI)
TNEANetEdgeI.__eq__ = new_instancemethod(_snap.TNEANetEdgeI___eq__,None,TNEANetEdgeI)
TNEANetEdgeI.GetId = new_instancemethod(_snap.TNEANetEdgeI_GetId,None,TNEANetEdgeI)
TNEANetEdgeI.GetSrcNId = new_instancemethod(_snap.TNEANetEdgeI_GetSrcNId,None,TNEANetEdgeI)
TNEANetEdgeI.GetDstNId = new_instancemethod(_snap.TNEANetEdgeI_GetDstNId,None,TNEANetEdgeI)
TNEANetEdgeI_swigregister = _snap.TNEANetEdgeI_swigregister
TNEANetEdgeI_swigregister(TNEANetEdgeI)

class TNEANetAIntI(object):
    """Proxy of C++ TNEANetAIntI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetAIntI self) -> TNEANetAIntI
        __init__(TNEANetAIntI self, TIntVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAIntI

        Parameters:
            HIter: TIntVecIter const &
            attribute: TStr
            isEdgeIter: bool
            GraphPt: TNEANet const *

        __init__(TNEANetAIntI self, TNEANet::TAIntI const & I) -> TNEANetAIntI

        Parameters:
            I: TNEANet::TAIntI const &

        """
        _snap.TNEANetAIntI_swiginit(self,_snap.new_TNEANetAIntI(*args))
    def Next(self):
        """
        Next(TNEANetAIntI self) -> TNEANetAIntI

        Parameters:
            self: TNEANetAIntI *

        """
        return _snap.TNEANetAIntI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetAIntI self, TNEANetAIntI I) -> bool

        Parameters:
            I: TNEANetAIntI const &

        """
        return _snap.TNEANetAIntI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetAIntI self, TNEANetAIntI I) -> bool

        Parameters:
            I: TNEANetAIntI const &

        """
        return _snap.TNEANetAIntI___eq__(self, *args)

    def GetDat(self):
        """
        GetDat(TNEANetAIntI self) -> int

        Parameters:
            self: TNEANetAIntI const *

        """
        return _snap.TNEANetAIntI_GetDat(self)

    def IsDeleted(self):
        """
        IsDeleted(TNEANetAIntI self) -> bool

        Parameters:
            self: TNEANetAIntI const *

        """
        return _snap.TNEANetAIntI_IsDeleted(self)

    __swig_destroy__ = _snap.delete_TNEANetAIntI
TNEANetAIntI.Next = new_instancemethod(_snap.TNEANetAIntI_Next,None,TNEANetAIntI)
TNEANetAIntI.__lt__ = new_instancemethod(_snap.TNEANetAIntI___lt__,None,TNEANetAIntI)
TNEANetAIntI.__eq__ = new_instancemethod(_snap.TNEANetAIntI___eq__,None,TNEANetAIntI)
TNEANetAIntI.GetDat = new_instancemethod(_snap.TNEANetAIntI_GetDat,None,TNEANetAIntI)
TNEANetAIntI.IsDeleted = new_instancemethod(_snap.TNEANetAIntI_IsDeleted,None,TNEANetAIntI)
TNEANetAIntI_swigregister = _snap.TNEANetAIntI_swigregister
TNEANetAIntI_swigregister(TNEANetAIntI)

class TNEANetAStrI(object):
    """Proxy of C++ TNEANetAStrI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetAStrI self) -> TNEANetAStrI
        __init__(TNEANetAStrI self, TStrVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAStrI

        Parameters:
            HIter: TStrVecIter const &
            attribute: TStr
            isEdgeIter: bool
            GraphPt: TNEANet const *

        __init__(TNEANetAStrI self, TNEANet::TAStrI const & I) -> TNEANetAStrI

        Parameters:
            I: TNEANet::TAStrI const &

        """
        _snap.TNEANetAStrI_swiginit(self,_snap.new_TNEANetAStrI(*args))
    def Next(self):
        """
        Next(TNEANetAStrI self) -> TNEANetAStrI

        Parameters:
            self: TNEANetAStrI *

        """
        return _snap.TNEANetAStrI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetAStrI self, TNEANetAStrI I) -> bool

        Parameters:
            I: TNEANetAStrI const &

        """
        return _snap.TNEANetAStrI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetAStrI self, TNEANetAStrI I) -> bool

        Parameters:
            I: TNEANetAStrI const &

        """
        return _snap.TNEANetAStrI___eq__(self, *args)

    def GetDat(self):
        """
        GetDat(TNEANetAStrI self) -> char *

        Parameters:
            self: TNEANetAStrI const *

        """
        return _snap.TNEANetAStrI_GetDat(self)

    def IsDeleted(self):
        """
        IsDeleted(TNEANetAStrI self) -> bool

        Parameters:
            self: TNEANetAStrI const *

        """
        return _snap.TNEANetAStrI_IsDeleted(self)

    __swig_destroy__ = _snap.delete_TNEANetAStrI
TNEANetAStrI.Next = new_instancemethod(_snap.TNEANetAStrI_Next,None,TNEANetAStrI)
TNEANetAStrI.__lt__ = new_instancemethod(_snap.TNEANetAStrI___lt__,None,TNEANetAStrI)
TNEANetAStrI.__eq__ = new_instancemethod(_snap.TNEANetAStrI___eq__,None,TNEANetAStrI)
TNEANetAStrI.GetDat = new_instancemethod(_snap.TNEANetAStrI_GetDat,None,TNEANetAStrI)
TNEANetAStrI.IsDeleted = new_instancemethod(_snap.TNEANetAStrI_IsDeleted,None,TNEANetAStrI)
TNEANetAStrI_swigregister = _snap.TNEANetAStrI_swigregister
TNEANetAStrI_swigregister(TNEANetAStrI)

class TNEANetAFltI(object):
    """Proxy of C++ TNEANetAFltI class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANetAFltI self) -> TNEANetAFltI
        __init__(TNEANetAFltI self, TFltVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAFltI

        Parameters:
            HIter: TFltVecIter const &
            attribute: TStr
            isEdgeIter: bool
            GraphPt: TNEANet const *

        __init__(TNEANetAFltI self, TNEANet::TAFltI const & I) -> TNEANetAFltI

        Parameters:
            I: TNEANet::TAFltI const &

        """
        _snap.TNEANetAFltI_swiginit(self,_snap.new_TNEANetAFltI(*args))
    def Next(self):
        """
        Next(TNEANetAFltI self) -> TNEANetAFltI

        Parameters:
            self: TNEANetAFltI *

        """
        return _snap.TNEANetAFltI_Next(self)

    def __lt__(self, *args):
        """
        __lt__(TNEANetAFltI self, TNEANetAFltI I) -> bool

        Parameters:
            I: TNEANetAFltI const &

        """
        return _snap.TNEANetAFltI___lt__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(TNEANetAFltI self, TNEANetAFltI I) -> bool

        Parameters:
            I: TNEANetAFltI const &

        """
        return _snap.TNEANetAFltI___eq__(self, *args)

    def GetDat(self):
        """
        GetDat(TNEANetAFltI self) -> double

        Parameters:
            self: TNEANetAFltI const *

        """
        return _snap.TNEANetAFltI_GetDat(self)

    def IsDeleted(self):
        """
        IsDeleted(TNEANetAFltI self) -> bool

        Parameters:
            self: TNEANetAFltI const *

        """
        return _snap.TNEANetAFltI_IsDeleted(self)

    __swig_destroy__ = _snap.delete_TNEANetAFltI
TNEANetAFltI.Next = new_instancemethod(_snap.TNEANetAFltI_Next,None,TNEANetAFltI)
TNEANetAFltI.__lt__ = new_instancemethod(_snap.TNEANetAFltI___lt__,None,TNEANetAFltI)
TNEANetAFltI.__eq__ = new_instancemethod(_snap.TNEANetAFltI___eq__,None,TNEANetAFltI)
TNEANetAFltI.GetDat = new_instancemethod(_snap.TNEANetAFltI_GetDat,None,TNEANetAFltI)
TNEANetAFltI.IsDeleted = new_instancemethod(_snap.TNEANetAFltI_IsDeleted,None,TNEANetAFltI)
TNEANetAFltI_swigregister = _snap.TNEANetAFltI_swigregister
TNEANetAFltI_swigregister(TNEANetAFltI)


def TPrGraph(*args):
  """
    TPrGraph(PUNGraph G) -> TUNGraph

    Parameters:
        G: PUNGraph

    """
  return _snap.TPrGraph(*args)

def accept_array(*args):
  """
    accept_array(int [] array) -> int

    Parameters:
        array: int []

    """
  return _snap.accept_array(*args)

def print_array(*args):
  """
    print_array(int * x, int length)

    Parameters:
        x: int *
        length: int

    """
  return _snap.print_array(*args)

def PyTFltV(*args):
  """
    PyTFltV(double [10] x) -> TFltV

    Parameters:
        x: double [10]

    """
  return _snap.PyTFltV(*args)

def PyToTIntV(*args):
  """
    PyToTIntV(int * array) -> TIntV

    Parameters:
        array: int *

    """
  return _snap.PyToTIntV(*args)

def count(*args):
  """
    count(char * str, char c) -> int

    Parameters:
        str: char *
        c: char

    """
  return _snap.count(*args)

def TIntVToPy(*args):
  """
    TIntVToPy(TIntV originalList)

    Parameters:
        originalList: TIntV

    """
  return _snap.TIntVToPy(*args)
class TNEANet(object):
    """Proxy of C++ TNEANet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(TNEANet self) -> TNEANet
        __init__(TNEANet self, int const & Nodes, int const & Edges) -> TNEANet

        Parameters:
            Nodes: int const &
            Edges: int const &

        __init__(TNEANet self, TNEANet Graph) -> TNEANet

        Parameters:
            Graph: TNEANet const &

        __init__(TNEANet self, TSIn SIn) -> TNEANet

        Parameters:
            SIn: TSIn &

        """
        _snap.TNEANet_swiginit(self,_snap.new_TNEANet(*args))
    def Save(self, *args):
        """
        Save(TNEANet self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.TNEANet_Save(self, *args)

    def New(*args):
        """
        New() -> PNEANet
        New(int const & Nodes, int const & Edges) -> PNEANet

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNEANet_New(*args)

    New = staticmethod(New)
    def Load(*args):
        """
        Load(TSIn SIn) -> PNEANet

        Parameters:
            SIn: TSIn &

        """
        return _snap.TNEANet_Load(*args)

    Load = staticmethod(Load)
    def HasFlag(self, *args):
        """
        HasFlag(TNEANet self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.TNEANet_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(TNEANet self) -> int

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(TNEANet self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(TNEANet self) -> int
        AddNode(TNEANet self, TNEANet::TNodeI const & NodeId) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &

        """
        return _snap.TNEANet_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(TNEANet self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(TNEANet self, TNEANet::TNode const & NodeI)

        Parameters:
            NodeI: TNEANet::TNode const &

        """
        return _snap.TNEANet_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(TNEANet self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.TNEANet_IsNode(self, *args)

    def GetNI(self, *args):
        """
        GetNI(TNEANet self, int const & NId) -> TNEANet::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.TNEANet_GetNI(self, *args)

    def GetNAIntI(self, *args):
        """
        GetNAIntI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.TNEANet_GetNAIntI(self, *args)

    def GetNAStrI(self, *args):
        """
        GetNAStrI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.TNEANet_GetNAStrI(self, *args)

    def GetNAFltI(self, *args):
        """
        GetNAFltI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.TNEANet_GetNAFltI(self, *args)

    def AttrNameNI(self, *args):
        """
        AttrNameNI(TNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        AttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_AttrNameNI(self, *args)

    def AttrValueNI(self, *args):
        """
        AttrValueNI(TNEANet self, TInt NId, TStrV Values)

        Parameters:
            NId: TInt const &
            Values: TStrV &

        AttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.TNEANet_AttrValueNI(self, *args)

    def IntAttrNameNI(self, *args):
        """
        IntAttrNameNI(TNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        IntAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_IntAttrNameNI(self, *args)

    def IntAttrValueNI(self, *args):
        """
        IntAttrValueNI(TNEANet self, TInt NId, TIntV Values)

        Parameters:
            NId: TInt const &
            Values: TIntV &

        IntAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TIntV &

        """
        return _snap.TNEANet_IntAttrValueNI(self, *args)

    def StrAttrNameNI(self, *args):
        """
        StrAttrNameNI(TNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        StrAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_StrAttrNameNI(self, *args)

    def StrAttrValueNI(self, *args):
        """
        StrAttrValueNI(TNEANet self, TInt NId, TStrV Values)

        Parameters:
            NId: TInt const &
            Values: TStrV &

        StrAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.TNEANet_StrAttrValueNI(self, *args)

    def FltAttrNameNI(self, *args):
        """
        FltAttrNameNI(TNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        FltAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_FltAttrNameNI(self, *args)

    def FltAttrValueNI(self, *args):
        """
        FltAttrValueNI(TNEANet self, TInt NId, TFltV & Values)

        Parameters:
            NId: TInt const &
            Values: TFltV &

        FltAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TFltV &

        """
        return _snap.TNEANet_FltAttrValueNI(self, *args)

    def AttrNameEI(self, *args):
        """
        AttrNameEI(TNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        AttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_AttrNameEI(self, *args)

    def AttrValueEI(self, *args):
        """
        AttrValueEI(TNEANet self, TInt EId, TStrV Values)

        Parameters:
            EId: TInt const &
            Values: TStrV &

        AttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.TNEANet_AttrValueEI(self, *args)

    def IntAttrNameEI(self, *args):
        """
        IntAttrNameEI(TNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        IntAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_IntAttrNameEI(self, *args)

    def IntAttrValueEI(self, *args):
        """
        IntAttrValueEI(TNEANet self, TInt EId, TIntV Values)

        Parameters:
            EId: TInt const &
            Values: TIntV &

        IntAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TIntV &

        """
        return _snap.TNEANet_IntAttrValueEI(self, *args)

    def StrAttrNameEI(self, *args):
        """
        StrAttrNameEI(TNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        StrAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_StrAttrNameEI(self, *args)

    def StrAttrValueEI(self, *args):
        """
        StrAttrValueEI(TNEANet self, TInt EId, TStrV Values)

        Parameters:
            EId: TInt const &
            Values: TStrV &

        StrAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.TNEANet_StrAttrValueEI(self, *args)

    def FltAttrNameEI(self, *args):
        """
        FltAttrNameEI(TNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        FltAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.TNEANet_FltAttrNameEI(self, *args)

    def FltAttrValueEI(self, *args):
        """
        FltAttrValueEI(TNEANet self, TInt EId, TFltV & Values)

        Parameters:
            EId: TInt const &
            Values: TFltV &

        FltAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TFltV &

        """
        return _snap.TNEANet_FltAttrValueEI(self, *args)

    def GetEAIntI(self, *args):
        """
        GetEAIntI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.TNEANet_GetEAIntI(self, *args)

    def GetEAStrI(self, *args):
        """
        GetEAStrI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.TNEANet_GetEAStrI(self, *args)

    def GetEAFltI(self, *args):
        """
        GetEAFltI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.TNEANet_GetEAFltI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(TNEANet self) -> int

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(TNEANet self) -> int

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(TNEANet self, int const & SrcNId, int const & DstNId, int EId=-1) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int

        AddEdge(TNEANet self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(TNEANet self, TNEANet::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TNEANet::TEdgeI const &

        """
        return _snap.TNEANet_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(TNEANet self, int const & EId)

        Parameters:
            EId: int const &

        DelEdge(TNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        DelEdge(TNEANet self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEANet_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(TNEANet self, int const & EId) -> bool

        Parameters:
            EId: int const &

        IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        IsEdge(TNEANet self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &
            IsDir: bool const &

        IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &

        """
        return _snap.TNEANet_IsEdge(self, *args)

    def GetEId(self, *args):
        """
        GetEId(TNEANet self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEANet_GetEId(self, *args)

    def GetEI(self, *args):
        """
        GetEI(TNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.TNEANet_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(TNEANet self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(TNEANet self) -> int

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(TNEANet self, TRnd Rnd=Rnd) -> TNEANet::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(TNEANet self) -> TNEANet::TNodeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_GetRndNI(self, *args)

    def GetRndEId(self, *args):
        """
        GetRndEId(TNEANet self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndEId(TNEANet self) -> int

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_GetRndEId(self, *args)

    def GetRndEI(self, *args):
        """
        GetRndEI(TNEANet self, TRnd Rnd=Rnd) -> TNEANet::TEdgeI

        Parameters:
            Rnd: TRnd &

        GetRndEI(TNEANet self) -> TNEANet::TEdgeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_GetRndEI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(TNEANet self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.TNEANet_GetNIdV(self, *args)

    def GetEIdV(self, *args):
        """
        GetEIdV(TNEANet self, TIntV EIdV)

        Parameters:
            EIdV: TIntV &

        """
        return _snap.TNEANet_GetEIdV(self, *args)

    def Empty(self):
        """
        Empty(TNEANet self) -> bool

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_Empty(self)

    def Clr(self):
        """
        Clr(TNEANet self)

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_Clr(self)

    def Reserve(self, *args):
        """
        Reserve(TNEANet self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.TNEANet_Reserve(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(TNEANet self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(TNEANet self)

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(TNEANet self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(TNEANet self) -> bool

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(TNEANet self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(TNEANet self)

        Parameters:
            self: TNEANet const *

        """
        return _snap.TNEANet_Dump(self, *args)

    def AddIntAttrDatN(self, *args):
        """
        AddIntAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TInt const &
            attr: TStr const &

        AddIntAttrDatN(TNEANet self, int const & NId, TInt value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TInt const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddIntAttrDatN(self, *args)

    def AddStrAttrDatN(self, *args):
        """
        AddStrAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TStr const &
            attr: TStr const &

        AddStrAttrDatN(TNEANet self, int const & NId, TStr value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TStr const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddStrAttrDatN(self, *args)

    def AddFltAttrDatN(self, *args):
        """
        AddFltAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TFlt const &
            attr: TStr const &

        AddFltAttrDatN(TNEANet self, int const & NId, TFlt value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TFlt const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddFltAttrDatN(self, *args)

    def AddIntAttrDatE(self, *args):
        """
        AddIntAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TInt const &
            attr: TStr const &

        AddIntAttrDatE(TNEANet self, int const & EId, TInt value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TInt const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddIntAttrDatE(self, *args)

    def AddStrAttrDatE(self, *args):
        """
        AddStrAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TStr const &
            attr: TStr const &

        AddStrAttrDatE(TNEANet self, int const & EId, TStr value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TStr const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddStrAttrDatE(self, *args)

    def AddFltAttrDatE(self, *args):
        """
        AddFltAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TFlt const &
            attr: TStr const &

        AddFltAttrDatE(TNEANet self, int const & EId, TFlt value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TFlt const &
            attr: TStr const &

        """
        return _snap.TNEANet_AddFltAttrDatE(self, *args)

    def GetIntAttrDatN(self, *args):
        """
        GetIntAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TInt

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetIntAttrDatN(TNEANet self, int const & NId, TStr attr) -> TInt

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetIntAttrDatN(self, *args)

    def GetStrAttrDatN(self, *args):
        """
        GetStrAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TStr

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetStrAttrDatN(TNEANet self, int const & NId, TStr attr) -> TStr

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetStrAttrDatN(self, *args)

    def GetFltAttrDatN(self, *args):
        """
        GetFltAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetFltAttrDatN(TNEANet self, int const & NId, TStr attr) -> TFlt

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetFltAttrDatN(self, *args)

    def GetIntAttrDatE(self, *args):
        """
        GetIntAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetIntAttrDatE(TNEANet self, int const & EId, TStr attr) -> TInt

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetIntAttrDatE(self, *args)

    def GetStrAttrDatE(self, *args):
        """
        GetStrAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetStrAttrDatE(TNEANet self, int const & EId, TStr attr) -> TStr

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetStrAttrDatE(self, *args)

    def GetFltAttrDatE(self, *args):
        """
        GetFltAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetFltAttrDatE(TNEANet self, int const & EId, TStr attr) -> TFlt

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_GetFltAttrDatE(self, *args)

    def DelAttrDatN(self, *args):
        """
        DelAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        DelAttrDatN(TNEANet self, int const & NId, TStr attr) -> int

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_DelAttrDatN(self, *args)

    def DelAttrDatE(self, *args):
        """
        DelAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        DelAttrDatE(TNEANet self, int const & EId, TStr attr) -> int

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.TNEANet_DelAttrDatE(self, *args)

    def AddIntAttrN(self, *args):
        """
        AddIntAttrN(TNEANet self, TStr attr, TInt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TInt

        AddIntAttrN(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddIntAttrN(self, *args)

    def AddStrAttrN(self, *args):
        """
        AddStrAttrN(TNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TStr

        AddStrAttrN(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddStrAttrN(self, *args)

    def AddFltAttrN(self, *args):
        """
        AddFltAttrN(TNEANet self, TStr attr, TFlt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TFlt

        AddFltAttrN(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddFltAttrN(self, *args)

    def AddIntAttrE(self, *args):
        """
        AddIntAttrE(TNEANet self, TStr attr, TInt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TInt

        AddIntAttrE(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddIntAttrE(self, *args)

    def AddStrAttrE(self, *args):
        """
        AddStrAttrE(TNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TStr

        AddStrAttrE(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddStrAttrE(self, *args)

    def AddFltAttrE(self, *args):
        """
        AddFltAttrE(TNEANet self, TStr attr, TFlt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TFlt

        AddFltAttrE(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_AddFltAttrE(self, *args)

    def DelAttrN(self, *args):
        """
        DelAttrN(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_DelAttrN(self, *args)

    def DelAttrE(self, *args):
        """
        DelAttrE(TNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_DelAttrE(self, *args)

    def NodeAttrIsDeleted(self, *args):
        """
        NodeAttrIsDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_NodeAttrIsDeleted(self, *args)

    def NodeAttrIsIntDeleted(self, *args):
        """
        NodeAttrIsIntDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_NodeAttrIsIntDeleted(self, *args)

    def NodeAttrIsStrDeleted(self, *args):
        """
        NodeAttrIsStrDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_NodeAttrIsStrDeleted(self, *args)

    def NodeAttrIsFltDeleted(self, *args):
        """
        NodeAttrIsFltDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_NodeAttrIsFltDeleted(self, *args)

    def EdgeAttrIsDeleted(self, *args):
        """
        EdgeAttrIsDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_EdgeAttrIsDeleted(self, *args)

    def EdgeAttrIsIntDeleted(self, *args):
        """
        EdgeAttrIsIntDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_EdgeAttrIsIntDeleted(self, *args)

    def EdgeAttrIsStrDeleted(self, *args):
        """
        EdgeAttrIsStrDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_EdgeAttrIsStrDeleted(self, *args)

    def EdgeAttrIsFltDeleted(self, *args):
        """
        EdgeAttrIsFltDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_EdgeAttrIsFltDeleted(self, *args)

    def GetNodeAttrValue(self, *args):
        """
        GetNodeAttrValue(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_GetNodeAttrValue(self, *args)

    def GetEdgeAttrValue(self, *args):
        """
        GetEdgeAttrValue(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.TNEANet_GetEdgeAttrValue(self, *args)

    def BegNI(self, *args):
        """
        BegNI(TNEANet self) -> TNEANet::TNodeI
        BegNI(TNEANet self) -> TNEANetNodeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_BegNI(self, *args)

    def EndNI(self, *args):
        """
        EndNI(TNEANet self) -> TNEANet::TNodeI
        EndNI(TNEANet self) -> TNEANetNodeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_EndNI(self, *args)

    def BegEI(self, *args):
        """
        BegEI(TNEANet self) -> TNEANet::TEdgeI
        BegEI(TNEANet self) -> TNEANetEdgeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_BegEI(self, *args)

    def EndEI(self, *args):
        """
        EndEI(TNEANet self) -> TNEANet::TEdgeI
        EndEI(TNEANet self) -> TNEANetEdgeI

        Parameters:
            self: TNEANet *

        """
        return _snap.TNEANet_EndEI(self, *args)

    def BegNAIntI(self, *args):
        """
        BegNAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        BegNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegNAIntI(self, *args)

    def EndNAIntI(self, *args):
        """
        EndNAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        EndNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndNAIntI(self, *args)

    def BegNAStrI(self, *args):
        """
        BegNAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        BegNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegNAStrI(self, *args)

    def EndNAStrI(self, *args):
        """
        EndNAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        EndNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndNAStrI(self, *args)

    def BegNAFltI(self, *args):
        """
        BegNAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        BegNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegNAFltI(self, *args)

    def EndNAFltI(self, *args):
        """
        EndNAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        EndNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndNAFltI(self, *args)

    def BegEAIntI(self, *args):
        """
        BegEAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        BegEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegEAIntI(self, *args)

    def EndEAIntI(self, *args):
        """
        EndEAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        EndEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndEAIntI(self, *args)

    def BegEAStrI(self, *args):
        """
        BegEAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        BegEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegEAStrI(self, *args)

    def EndEAStrI(self, *args):
        """
        EndEAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        EndEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndEAStrI(self, *args)

    def BegEAFltI(self, *args):
        """
        BegEAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        BegEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_BegEAFltI(self, *args)

    def EndEAFltI(self, *args):
        """
        EndEAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        EndEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.TNEANet_EndEAFltI(self, *args)

    __swig_destroy__ = _snap.delete_TNEANet
TNEANet.Save = new_instancemethod(_snap.TNEANet_Save,None,TNEANet)
TNEANet.HasFlag = new_instancemethod(_snap.TNEANet_HasFlag,None,TNEANet)
TNEANet.GetNodes = new_instancemethod(_snap.TNEANet_GetNodes,None,TNEANet)
TNEANet.AddNode = new_instancemethod(_snap.TNEANet_AddNode,None,TNEANet)
TNEANet.DelNode = new_instancemethod(_snap.TNEANet_DelNode,None,TNEANet)
TNEANet.IsNode = new_instancemethod(_snap.TNEANet_IsNode,None,TNEANet)
TNEANet.GetNI = new_instancemethod(_snap.TNEANet_GetNI,None,TNEANet)
TNEANet.GetNAIntI = new_instancemethod(_snap.TNEANet_GetNAIntI,None,TNEANet)
TNEANet.GetNAStrI = new_instancemethod(_snap.TNEANet_GetNAStrI,None,TNEANet)
TNEANet.GetNAFltI = new_instancemethod(_snap.TNEANet_GetNAFltI,None,TNEANet)
TNEANet.AttrNameNI = new_instancemethod(_snap.TNEANet_AttrNameNI,None,TNEANet)
TNEANet.AttrValueNI = new_instancemethod(_snap.TNEANet_AttrValueNI,None,TNEANet)
TNEANet.IntAttrNameNI = new_instancemethod(_snap.TNEANet_IntAttrNameNI,None,TNEANet)
TNEANet.IntAttrValueNI = new_instancemethod(_snap.TNEANet_IntAttrValueNI,None,TNEANet)
TNEANet.StrAttrNameNI = new_instancemethod(_snap.TNEANet_StrAttrNameNI,None,TNEANet)
TNEANet.StrAttrValueNI = new_instancemethod(_snap.TNEANet_StrAttrValueNI,None,TNEANet)
TNEANet.FltAttrNameNI = new_instancemethod(_snap.TNEANet_FltAttrNameNI,None,TNEANet)
TNEANet.FltAttrValueNI = new_instancemethod(_snap.TNEANet_FltAttrValueNI,None,TNEANet)
TNEANet.AttrNameEI = new_instancemethod(_snap.TNEANet_AttrNameEI,None,TNEANet)
TNEANet.AttrValueEI = new_instancemethod(_snap.TNEANet_AttrValueEI,None,TNEANet)
TNEANet.IntAttrNameEI = new_instancemethod(_snap.TNEANet_IntAttrNameEI,None,TNEANet)
TNEANet.IntAttrValueEI = new_instancemethod(_snap.TNEANet_IntAttrValueEI,None,TNEANet)
TNEANet.StrAttrNameEI = new_instancemethod(_snap.TNEANet_StrAttrNameEI,None,TNEANet)
TNEANet.StrAttrValueEI = new_instancemethod(_snap.TNEANet_StrAttrValueEI,None,TNEANet)
TNEANet.FltAttrNameEI = new_instancemethod(_snap.TNEANet_FltAttrNameEI,None,TNEANet)
TNEANet.FltAttrValueEI = new_instancemethod(_snap.TNEANet_FltAttrValueEI,None,TNEANet)
TNEANet.GetEAIntI = new_instancemethod(_snap.TNEANet_GetEAIntI,None,TNEANet)
TNEANet.GetEAStrI = new_instancemethod(_snap.TNEANet_GetEAStrI,None,TNEANet)
TNEANet.GetEAFltI = new_instancemethod(_snap.TNEANet_GetEAFltI,None,TNEANet)
TNEANet.GetMxNId = new_instancemethod(_snap.TNEANet_GetMxNId,None,TNEANet)
TNEANet.GetEdges = new_instancemethod(_snap.TNEANet_GetEdges,None,TNEANet)
TNEANet.AddEdge = new_instancemethod(_snap.TNEANet_AddEdge,None,TNEANet)
TNEANet.DelEdge = new_instancemethod(_snap.TNEANet_DelEdge,None,TNEANet)
TNEANet.IsEdge = new_instancemethod(_snap.TNEANet_IsEdge,None,TNEANet)
TNEANet.GetEId = new_instancemethod(_snap.TNEANet_GetEId,None,TNEANet)
TNEANet.GetEI = new_instancemethod(_snap.TNEANet_GetEI,None,TNEANet)
TNEANet.GetRndNId = new_instancemethod(_snap.TNEANet_GetRndNId,None,TNEANet)
TNEANet.GetRndNI = new_instancemethod(_snap.TNEANet_GetRndNI,None,TNEANet)
TNEANet.GetRndEId = new_instancemethod(_snap.TNEANet_GetRndEId,None,TNEANet)
TNEANet.GetRndEI = new_instancemethod(_snap.TNEANet_GetRndEI,None,TNEANet)
TNEANet.GetNIdV = new_instancemethod(_snap.TNEANet_GetNIdV,None,TNEANet)
TNEANet.GetEIdV = new_instancemethod(_snap.TNEANet_GetEIdV,None,TNEANet)
TNEANet.Empty = new_instancemethod(_snap.TNEANet_Empty,None,TNEANet)
TNEANet.Clr = new_instancemethod(_snap.TNEANet_Clr,None,TNEANet)
TNEANet.Reserve = new_instancemethod(_snap.TNEANet_Reserve,None,TNEANet)
TNEANet.Defrag = new_instancemethod(_snap.TNEANet_Defrag,None,TNEANet)
TNEANet.IsOk = new_instancemethod(_snap.TNEANet_IsOk,None,TNEANet)
TNEANet.Dump = new_instancemethod(_snap.TNEANet_Dump,None,TNEANet)
TNEANet.AddIntAttrDatN = new_instancemethod(_snap.TNEANet_AddIntAttrDatN,None,TNEANet)
TNEANet.AddStrAttrDatN = new_instancemethod(_snap.TNEANet_AddStrAttrDatN,None,TNEANet)
TNEANet.AddFltAttrDatN = new_instancemethod(_snap.TNEANet_AddFltAttrDatN,None,TNEANet)
TNEANet.AddIntAttrDatE = new_instancemethod(_snap.TNEANet_AddIntAttrDatE,None,TNEANet)
TNEANet.AddStrAttrDatE = new_instancemethod(_snap.TNEANet_AddStrAttrDatE,None,TNEANet)
TNEANet.AddFltAttrDatE = new_instancemethod(_snap.TNEANet_AddFltAttrDatE,None,TNEANet)
TNEANet.GetIntAttrDatN = new_instancemethod(_snap.TNEANet_GetIntAttrDatN,None,TNEANet)
TNEANet.GetStrAttrDatN = new_instancemethod(_snap.TNEANet_GetStrAttrDatN,None,TNEANet)
TNEANet.GetFltAttrDatN = new_instancemethod(_snap.TNEANet_GetFltAttrDatN,None,TNEANet)
TNEANet.GetIntAttrDatE = new_instancemethod(_snap.TNEANet_GetIntAttrDatE,None,TNEANet)
TNEANet.GetStrAttrDatE = new_instancemethod(_snap.TNEANet_GetStrAttrDatE,None,TNEANet)
TNEANet.GetFltAttrDatE = new_instancemethod(_snap.TNEANet_GetFltAttrDatE,None,TNEANet)
TNEANet.DelAttrDatN = new_instancemethod(_snap.TNEANet_DelAttrDatN,None,TNEANet)
TNEANet.DelAttrDatE = new_instancemethod(_snap.TNEANet_DelAttrDatE,None,TNEANet)
TNEANet.AddIntAttrN = new_instancemethod(_snap.TNEANet_AddIntAttrN,None,TNEANet)
TNEANet.AddStrAttrN = new_instancemethod(_snap.TNEANet_AddStrAttrN,None,TNEANet)
TNEANet.AddFltAttrN = new_instancemethod(_snap.TNEANet_AddFltAttrN,None,TNEANet)
TNEANet.AddIntAttrE = new_instancemethod(_snap.TNEANet_AddIntAttrE,None,TNEANet)
TNEANet.AddStrAttrE = new_instancemethod(_snap.TNEANet_AddStrAttrE,None,TNEANet)
TNEANet.AddFltAttrE = new_instancemethod(_snap.TNEANet_AddFltAttrE,None,TNEANet)
TNEANet.DelAttrN = new_instancemethod(_snap.TNEANet_DelAttrN,None,TNEANet)
TNEANet.DelAttrE = new_instancemethod(_snap.TNEANet_DelAttrE,None,TNEANet)
TNEANet.NodeAttrIsDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsDeleted,None,TNEANet)
TNEANet.NodeAttrIsIntDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsIntDeleted,None,TNEANet)
TNEANet.NodeAttrIsStrDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsStrDeleted,None,TNEANet)
TNEANet.NodeAttrIsFltDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsFltDeleted,None,TNEANet)
TNEANet.EdgeAttrIsDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsDeleted,None,TNEANet)
TNEANet.EdgeAttrIsIntDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsIntDeleted,None,TNEANet)
TNEANet.EdgeAttrIsStrDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsStrDeleted,None,TNEANet)
TNEANet.EdgeAttrIsFltDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsFltDeleted,None,TNEANet)
TNEANet.GetNodeAttrValue = new_instancemethod(_snap.TNEANet_GetNodeAttrValue,None,TNEANet)
TNEANet.GetEdgeAttrValue = new_instancemethod(_snap.TNEANet_GetEdgeAttrValue,None,TNEANet)
TNEANet.BegNI = new_instancemethod(_snap.TNEANet_BegNI,None,TNEANet)
TNEANet.EndNI = new_instancemethod(_snap.TNEANet_EndNI,None,TNEANet)
TNEANet.BegEI = new_instancemethod(_snap.TNEANet_BegEI,None,TNEANet)
TNEANet.EndEI = new_instancemethod(_snap.TNEANet_EndEI,None,TNEANet)
TNEANet.BegNAIntI = new_instancemethod(_snap.TNEANet_BegNAIntI,None,TNEANet)
TNEANet.EndNAIntI = new_instancemethod(_snap.TNEANet_EndNAIntI,None,TNEANet)
TNEANet.BegNAStrI = new_instancemethod(_snap.TNEANet_BegNAStrI,None,TNEANet)
TNEANet.EndNAStrI = new_instancemethod(_snap.TNEANet_EndNAStrI,None,TNEANet)
TNEANet.BegNAFltI = new_instancemethod(_snap.TNEANet_BegNAFltI,None,TNEANet)
TNEANet.EndNAFltI = new_instancemethod(_snap.TNEANet_EndNAFltI,None,TNEANet)
TNEANet.BegEAIntI = new_instancemethod(_snap.TNEANet_BegEAIntI,None,TNEANet)
TNEANet.EndEAIntI = new_instancemethod(_snap.TNEANet_EndEAIntI,None,TNEANet)
TNEANet.BegEAStrI = new_instancemethod(_snap.TNEANet_BegEAStrI,None,TNEANet)
TNEANet.EndEAStrI = new_instancemethod(_snap.TNEANet_EndEAStrI,None,TNEANet)
TNEANet.BegEAFltI = new_instancemethod(_snap.TNEANet_BegEAFltI,None,TNEANet)
TNEANet.EndEAFltI = new_instancemethod(_snap.TNEANet_EndEAFltI,None,TNEANet)
TNEANet_swigregister = _snap.TNEANet_swigregister
TNEANet_swigregister(TNEANet)

def TNEANet_New(*args):
  """
    New() -> PNEANet
    TNEANet_New(int const & Nodes, int const & Edges) -> PNEANet

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.TNEANet_New(*args)

def TNEANet_Load(*args):
  """
    TNEANet_Load(TSIn SIn) -> PNEANet

    Parameters:
        SIn: TSIn &

    """
  return _snap.TNEANet_Load(*args)


def PercentDegree(*args):
  """
    PercentDegree(PNEANet Graph, int const Threshold=0) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        Threshold: int const

    PercentDegree(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.PercentDegree(*args)

def PercentMxWcc(*args):
  """
    PercentMxWcc(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.PercentMxWcc(*args)

def PercentMxScc(*args):
  """
    PercentMxScc(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.PercentMxScc(*args)

def LoadEdgeList(*args):
  """
    LoadEdgeList(TStr InFNm, int const & SrcColId=0, int const & DstColId=1) -> PNEANet

    Parameters:
        InFNm: TStr const &
        SrcColId: int const &
        DstColId: int const &

    LoadEdgeList(TStr InFNm, int const & SrcColId=0) -> PNEANet

    Parameters:
        InFNm: TStr const &
        SrcColId: int const &

    LoadEdgeList(TStr InFNm) -> PNEANet

    Parameters:
        InFNm: TStr const &

    LoadEdgeList(TStr InFNm, int const & SrcColId, int const & DstColId, char const & Separator) -> PNEANet

    Parameters:
        InFNm: TStr const &
        SrcColId: int const &
        DstColId: int const &
        Separator: char const &

    """
  return _snap.LoadEdgeList(*args)

def PrintGraphStatTable(*args):
  """
    PrintGraphStatTable(PNEANet G, TStr OutFNm, TStr Desc="")

    Parameters:
        G: TPt< TNEANet > const &
        OutFNm: TStr
        Desc: TStr

    PrintGraphStatTable(PNEANet G, TStr OutFNm)

    Parameters:
        G: TPt< TNEANet > const &
        OutFNm: TStr

    """
  return _snap.PrintGraphStatTable(*args)

def GenRndGnm(*args):
  """
    GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True, TRnd Rnd=Rnd) -> PNEANet

    Parameters:
        Nodes: int const &
        Edges: int const &
        IsDir: bool const &
        Rnd: TRnd &

    GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True) -> PNEANet

    Parameters:
        Nodes: int const &
        Edges: int const &
        IsDir: bool const &

    GenRndGnm(int const & Nodes, int const & Edges) -> PNEANet

    Parameters:
        Nodes: int const &
        Edges: int const &

    """
  return _snap.GenRndGnm(*args)

def NodesGTEDegree(*args):
  """
    NodesGTEDegree(PNEANet Graph, int const Threshold=0) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        Threshold: int const

    NodesGTEDegree(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.NodesGTEDegree(*args)

def MxDegree(*args):
  """
    MxDegree(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.MxDegree(*args)

def MxSccSz(*args):
  """
    MxSccSz(PNEANet Graph) -> PNEANet

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.MxSccSz(*args)

def MxWccSz(*args):
  """
    MxWccSz(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.MxWccSz(*args)
class PNEANet(object):
    """Proxy of C++ TPt<(TNEANet)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def New():
        """New() -> PNEANet"""
        return _snap.PNEANet_New()

    New = staticmethod(New)
    __swig_destroy__ = _snap.delete_PNEANet
    def Save(self, *args):
        """
        Save(PNEANet self, TSOut SOut)

        Parameters:
            SOut: TSOut &

        """
        return _snap.PNEANet_Save(self, *args)

    def __deref__(self):
        """
        __deref__(PNEANet self) -> TNEANet

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet___deref__(self)

    def __ref__(self):
        """
        __ref__(PNEANet self) -> TNEANet

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet___ref__(self)

    def __call__(self):
        """
        __call__(PNEANet self) -> TNEANet

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet___call__(self)

    def Empty(self):
        """
        Empty(PNEANet self) -> bool

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_Empty(self)

    def Clr(self):
        """
        Clr(PNEANet self)

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_Clr(self)

    def GetRefs(self):
        """
        GetRefs(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_GetRefs(self)

    def Load(self, *args):
        """
        Load(PNEANet self, TSIn SIn) -> PNEANet

        Parameters:
            SIn: TSIn &

        """
        return _snap.PNEANet_Load(self, *args)

    def HasFlag(self, *args):
        """
        HasFlag(PNEANet self, TGraphFlag const & Flag) -> bool

        Parameters:
            Flag: TGraphFlag const &

        """
        return _snap.PNEANet_HasFlag(self, *args)

    def GetNodes(self):
        """
        GetNodes(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_GetNodes(self)

    def AddNode(self, *args):
        """
        AddNode(PNEANet self, int NId=-1) -> int

        Parameters:
            NId: int

        AddNode(PNEANet self) -> int
        AddNode(PNEANet self, TNEANet::TNodeI const & NodeId) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &

        """
        return _snap.PNEANet_AddNode(self, *args)

    def DelNode(self, *args):
        """
        DelNode(PNEANet self, int const & NId)

        Parameters:
            NId: int const &

        DelNode(PNEANet self, TNEANet::TNode const & NodeI)

        Parameters:
            NodeI: TNEANet::TNode const &

        """
        return _snap.PNEANet_DelNode(self, *args)

    def IsNode(self, *args):
        """
        IsNode(PNEANet self, int const & NId) -> bool

        Parameters:
            NId: int const &

        """
        return _snap.PNEANet_IsNode(self, *args)

    def BegNI(self, *args):
        """
        BegNI(PNEANet self) -> TNEANet::TNodeI
        BegNI(PNEANet self) -> TNEANetNodeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_BegNI(self, *args)

    def EndNI(self, *args):
        """
        EndNI(PNEANet self) -> TNEANet::TNodeI
        EndNI(PNEANet self) -> TNEANetNodeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_EndNI(self, *args)

    def GetNI(self, *args):
        """
        GetNI(PNEANet self, int const & NId) -> TNEANet::TNodeI

        Parameters:
            NId: int const &

        """
        return _snap.PNEANet_GetNI(self, *args)

    def BegNAIntI(self, *args):
        """
        BegNAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        BegNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegNAIntI(self, *args)

    def EndNAIntI(self, *args):
        """
        EndNAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        EndNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndNAIntI(self, *args)

    def GetNAIntI(self, *args):
        """
        GetNAIntI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.PNEANet_GetNAIntI(self, *args)

    def BegNAStrI(self, *args):
        """
        BegNAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        BegNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegNAStrI(self, *args)

    def EndNAStrI(self, *args):
        """
        EndNAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        EndNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndNAStrI(self, *args)

    def GetNAStrI(self, *args):
        """
        GetNAStrI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.PNEANet_GetNAStrI(self, *args)

    def BegNAFltI(self, *args):
        """
        BegNAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        BegNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegNAFltI(self, *args)

    def EndNAFltI(self, *args):
        """
        EndNAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        EndNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndNAFltI(self, *args)

    def GetNAFltI(self, *args):
        """
        GetNAFltI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &
            NId: int const &

        """
        return _snap.PNEANet_GetNAFltI(self, *args)

    def AttrNameNI(self, *args):
        """
        AttrNameNI(PNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        AttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_AttrNameNI(self, *args)

    def AttrValueNI(self, *args):
        """
        AttrValueNI(PNEANet self, TInt NId, TStrV Values)

        Parameters:
            NId: TInt const &
            Values: TStrV &

        AttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.PNEANet_AttrValueNI(self, *args)

    def IntAttrNameNI(self, *args):
        """
        IntAttrNameNI(PNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        IntAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_IntAttrNameNI(self, *args)

    def IntAttrValueNI(self, *args):
        """
        IntAttrValueNI(PNEANet self, TInt NId, TIntV Values)

        Parameters:
            NId: TInt const &
            Values: TIntV &

        IntAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TIntV &

        """
        return _snap.PNEANet_IntAttrValueNI(self, *args)

    def StrAttrNameNI(self, *args):
        """
        StrAttrNameNI(PNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        StrAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_StrAttrNameNI(self, *args)

    def StrAttrValueNI(self, *args):
        """
        StrAttrValueNI(PNEANet self, TInt NId, TStrV Values)

        Parameters:
            NId: TInt const &
            Values: TStrV &

        StrAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.PNEANet_StrAttrValueNI(self, *args)

    def FltAttrNameNI(self, *args):
        """
        FltAttrNameNI(PNEANet self, TInt NId, TStrV Names)

        Parameters:
            NId: TInt const &
            Names: TStrV &

        FltAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_FltAttrNameNI(self, *args)

    def FltAttrValueNI(self, *args):
        """
        FltAttrValueNI(PNEANet self, TInt NId, TFltV & Values)

        Parameters:
            NId: TInt const &
            Values: TFltV &

        FltAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values)

        Parameters:
            NId: TInt const &
            NodeHI: TStrIntPrH::TIter
            Values: TFltV &

        """
        return _snap.PNEANet_FltAttrValueNI(self, *args)

    def AttrNameEI(self, *args):
        """
        AttrNameEI(PNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        AttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_AttrNameEI(self, *args)

    def AttrValueEI(self, *args):
        """
        AttrValueEI(PNEANet self, TInt EId, TStrV Values)

        Parameters:
            EId: TInt const &
            Values: TStrV &

        AttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.PNEANet_AttrValueEI(self, *args)

    def IntAttrNameEI(self, *args):
        """
        IntAttrNameEI(PNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        IntAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_IntAttrNameEI(self, *args)

    def IntAttrValueEI(self, *args):
        """
        IntAttrValueEI(PNEANet self, TInt EId, TIntV Values)

        Parameters:
            EId: TInt const &
            Values: TIntV &

        IntAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TIntV &

        """
        return _snap.PNEANet_IntAttrValueEI(self, *args)

    def StrAttrNameEI(self, *args):
        """
        StrAttrNameEI(PNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        StrAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_StrAttrNameEI(self, *args)

    def StrAttrValueEI(self, *args):
        """
        StrAttrValueEI(PNEANet self, TInt EId, TStrV Values)

        Parameters:
            EId: TInt const &
            Values: TStrV &

        StrAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TStrV &

        """
        return _snap.PNEANet_StrAttrValueEI(self, *args)

    def FltAttrNameEI(self, *args):
        """
        FltAttrNameEI(PNEANet self, TInt EId, TStrV Names)

        Parameters:
            EId: TInt const &
            Names: TStrV &

        FltAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Names: TStrV &

        """
        return _snap.PNEANet_FltAttrNameEI(self, *args)

    def FltAttrValueEI(self, *args):
        """
        FltAttrValueEI(PNEANet self, TInt EId, TFltV & Values)

        Parameters:
            EId: TInt const &
            Values: TFltV &

        FltAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values)

        Parameters:
            EId: TInt const &
            EdgeHI: TStrIntPrH::TIter
            Values: TFltV &

        """
        return _snap.PNEANet_FltAttrValueEI(self, *args)

    def BegEAIntI(self, *args):
        """
        BegEAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        BegEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegEAIntI(self, *args)

    def EndEAIntI(self, *args):
        """
        EndEAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &

        EndEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndEAIntI(self, *args)

    def GetEAIntI(self, *args):
        """
        GetEAIntI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.PNEANet_GetEAIntI(self, *args)

    def BegEAStrI(self, *args):
        """
        BegEAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        BegEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegEAStrI(self, *args)

    def EndEAStrI(self, *args):
        """
        EndEAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &

        EndEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndEAStrI(self, *args)

    def GetEAStrI(self, *args):
        """
        GetEAStrI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.PNEANet_GetEAStrI(self, *args)

    def BegEAFltI(self, *args):
        """
        BegEAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        BegEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_BegEAFltI(self, *args)

    def EndEAFltI(self, *args):
        """
        EndEAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &

        EndEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_EndEAFltI(self, *args)

    def GetEAFltI(self, *args):
        """
        GetEAFltI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI

        Parameters:
            attr: TStr const &
            EId: int const &

        """
        return _snap.PNEANet_GetEAFltI(self, *args)

    def GetMxNId(self):
        """
        GetMxNId(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_GetMxNId(self)

    def GetEdges(self):
        """
        GetEdges(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_GetEdges(self)

    def AddEdge(self, *args):
        """
        AddEdge(PNEANet self, int const & SrcNId, int const & DstNId, int EId=-1) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int

        AddEdge(PNEANet self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        AddEdge(PNEANet self, TNEANet::TEdgeI const & EdgeI) -> int

        Parameters:
            EdgeI: TNEANet::TEdgeI const &

        """
        return _snap.PNEANet_AddEdge(self, *args)

    def DelEdge(self, *args):
        """
        DelEdge(PNEANet self, int const & EId)

        Parameters:
            EId: int const &

        DelEdge(PNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        DelEdge(PNEANet self, int const & SrcNId, int const & DstNId)

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.PNEANet_DelEdge(self, *args)

    def IsEdge(self, *args):
        """
        IsEdge(PNEANet self, int const & EId) -> bool

        Parameters:
            EId: int const &

        IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            IsDir: bool const &

        IsEdge(PNEANet self, int const & SrcNId, int const & DstNId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &
            IsDir: bool const &

        IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool

        Parameters:
            SrcNId: int const &
            DstNId: int const &
            EId: int &

        """
        return _snap.PNEANet_IsEdge(self, *args)

    def GetEId(self, *args):
        """
        GetEId(PNEANet self, int const & SrcNId, int const & DstNId) -> int

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.PNEANet_GetEId(self, *args)

    def BegEI(self, *args):
        """
        BegEI(PNEANet self) -> TNEANet::TEdgeI
        BegEI(PNEANet self) -> TNEANetEdgeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_BegEI(self, *args)

    def EndEI(self, *args):
        """
        EndEI(PNEANet self) -> TNEANet::TEdgeI
        EndEI(PNEANet self) -> TNEANetEdgeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_EndEI(self, *args)

    def GetEI(self, *args):
        """
        GetEI(PNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI

        Parameters:
            SrcNId: int const &
            DstNId: int const &

        """
        return _snap.PNEANet_GetEI(self, *args)

    def GetRndNId(self, *args):
        """
        GetRndNId(PNEANet self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndNId(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_GetRndNId(self, *args)

    def GetRndNI(self, *args):
        """
        GetRndNI(PNEANet self, TRnd Rnd=Rnd) -> TNEANet::TNodeI

        Parameters:
            Rnd: TRnd &

        GetRndNI(PNEANet self) -> TNEANet::TNodeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_GetRndNI(self, *args)

    def GetRndEId(self, *args):
        """
        GetRndEId(PNEANet self, TRnd Rnd=Rnd) -> int

        Parameters:
            Rnd: TRnd &

        GetRndEId(PNEANet self) -> int

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_GetRndEId(self, *args)

    def GetRndEI(self, *args):
        """
        GetRndEI(PNEANet self, TRnd Rnd=Rnd) -> TNEANet::TEdgeI

        Parameters:
            Rnd: TRnd &

        GetRndEI(PNEANet self) -> TNEANet::TEdgeI

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_GetRndEI(self, *args)

    def GetNIdV(self, *args):
        """
        GetNIdV(PNEANet self, TIntV NIdV)

        Parameters:
            NIdV: TIntV &

        """
        return _snap.PNEANet_GetNIdV(self, *args)

    def GetEIdV(self, *args):
        """
        GetEIdV(PNEANet self, TIntV EIdV)

        Parameters:
            EIdV: TIntV &

        """
        return _snap.PNEANet_GetEIdV(self, *args)

    def Reserve(self, *args):
        """
        Reserve(PNEANet self, int const & Nodes, int const & Edges)

        Parameters:
            Nodes: int const &
            Edges: int const &

        """
        return _snap.PNEANet_Reserve(self, *args)

    def Defrag(self, OnlyNodeLinks=False):
        """
        Defrag(PNEANet self, bool const & OnlyNodeLinks=False)

        Parameters:
            OnlyNodeLinks: bool const &

        Defrag(PNEANet self)

        Parameters:
            self: TPt< TNEANet > *

        """
        return _snap.PNEANet_Defrag(self, OnlyNodeLinks)

    def IsOk(self, ThrowExcept=True):
        """
        IsOk(PNEANet self, bool const & ThrowExcept=True) -> bool

        Parameters:
            ThrowExcept: bool const &

        IsOk(PNEANet self) -> bool

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_IsOk(self, ThrowExcept)

    def Dump(self, *args):
        """
        Dump(PNEANet self, FILE * OutF=stdout)

        Parameters:
            OutF: FILE *

        Dump(PNEANet self)

        Parameters:
            self: TPt< TNEANet > const *

        """
        return _snap.PNEANet_Dump(self, *args)

    def AddIntAttrDatN(self, *args):
        """
        AddIntAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TInt const &
            attr: TStr const &

        AddIntAttrDatN(PNEANet self, int const & NId, TInt value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TInt const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddIntAttrDatN(self, *args)

    def AddStrAttrDatN(self, *args):
        """
        AddStrAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TStr const &
            attr: TStr const &

        AddStrAttrDatN(PNEANet self, int const & NId, TStr value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TStr const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddStrAttrDatN(self, *args)

    def AddFltAttrDatN(self, *args):
        """
        AddFltAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            value: TFlt const &
            attr: TStr const &

        AddFltAttrDatN(PNEANet self, int const & NId, TFlt value, TStr attr) -> int

        Parameters:
            NId: int const &
            value: TFlt const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddFltAttrDatN(self, *args)

    def AddIntAttrDatE(self, *args):
        """
        AddIntAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TInt const &
            attr: TStr const &

        AddIntAttrDatE(PNEANet self, int const & EId, TInt value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TInt const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddIntAttrDatE(self, *args)

    def AddStrAttrDatE(self, *args):
        """
        AddStrAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TStr const &
            attr: TStr const &

        AddStrAttrDatE(PNEANet self, int const & EId, TStr value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TStr const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddStrAttrDatE(self, *args)

    def AddFltAttrDatE(self, *args):
        """
        AddFltAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            value: TFlt const &
            attr: TStr const &

        AddFltAttrDatE(PNEANet self, int const & EId, TFlt value, TStr attr) -> int

        Parameters:
            EId: int const &
            value: TFlt const &
            attr: TStr const &

        """
        return _snap.PNEANet_AddFltAttrDatE(self, *args)

    def GetIntAttrDatN(self, *args):
        """
        GetIntAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TInt

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetIntAttrDatN(PNEANet self, int const & NId, TStr attr) -> TInt

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetIntAttrDatN(self, *args)

    def GetStrAttrDatN(self, *args):
        """
        GetStrAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TStr

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetStrAttrDatN(PNEANet self, int const & NId, TStr attr) -> TStr

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetStrAttrDatN(self, *args)

    def GetFltAttrDatN(self, *args):
        """
        GetFltAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        GetFltAttrDatN(PNEANet self, int const & NId, TStr attr) -> TFlt

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetFltAttrDatN(self, *args)

    def GetIntAttrDatE(self, *args):
        """
        GetIntAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetIntAttrDatE(PNEANet self, int const & EId, TStr attr) -> TInt

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetIntAttrDatE(self, *args)

    def GetStrAttrDatE(self, *args):
        """
        GetStrAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetStrAttrDatE(PNEANet self, int const & EId, TStr attr) -> TStr

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetStrAttrDatE(self, *args)

    def GetFltAttrDatE(self, *args):
        """
        GetFltAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        GetFltAttrDatE(PNEANet self, int const & EId, TStr attr) -> TFlt

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_GetFltAttrDatE(self, *args)

    def DelAttrDatN(self, *args):
        """
        DelAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> int

        Parameters:
            NodeId: TNEANet::TNodeI const &
            attr: TStr const &

        DelAttrDatN(PNEANet self, int const & NId, TStr attr) -> int

        Parameters:
            NId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_DelAttrDatN(self, *args)

    def DelAttrDatE(self, *args):
        """
        DelAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> int

        Parameters:
            EdgeId: TNEANet::TEdgeI const &
            attr: TStr const &

        DelAttrDatE(PNEANet self, int const & EId, TStr attr) -> int

        Parameters:
            EId: int const &
            attr: TStr const &

        """
        return _snap.PNEANet_DelAttrDatE(self, *args)

    def AddIntAttrN(self, *args):
        """
        AddIntAttrN(PNEANet self, TStr attr, TInt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TInt

        AddIntAttrN(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddIntAttrN(self, *args)

    def AddStrAttrN(self, *args):
        """
        AddStrAttrN(PNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TStr

        AddStrAttrN(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddStrAttrN(self, *args)

    def AddFltAttrN(self, *args):
        """
        AddFltAttrN(PNEANet self, TStr attr, TFlt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TFlt

        AddFltAttrN(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddFltAttrN(self, *args)

    def AddIntAttrE(self, *args):
        """
        AddIntAttrE(PNEANet self, TStr attr, TInt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TInt

        AddIntAttrE(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddIntAttrE(self, *args)

    def AddStrAttrE(self, *args):
        """
        AddStrAttrE(PNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TStr

        AddStrAttrE(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddStrAttrE(self, *args)

    def AddFltAttrE(self, *args):
        """
        AddFltAttrE(PNEANet self, TStr attr, TFlt defaultValue=Mn) -> int

        Parameters:
            attr: TStr const &
            defaultValue: TFlt

        AddFltAttrE(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_AddFltAttrE(self, *args)

    def DelAttrN(self, *args):
        """
        DelAttrN(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_DelAttrN(self, *args)

    def DelAttrE(self, *args):
        """
        DelAttrE(PNEANet self, TStr attr) -> int

        Parameters:
            attr: TStr const &

        """
        return _snap.PNEANet_DelAttrE(self, *args)

    def NodeAttrIsDeleted(self, *args):
        """
        NodeAttrIsDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_NodeAttrIsDeleted(self, *args)

    def NodeAttrIsIntDeleted(self, *args):
        """
        NodeAttrIsIntDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_NodeAttrIsIntDeleted(self, *args)

    def NodeAttrIsStrDeleted(self, *args):
        """
        NodeAttrIsStrDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_NodeAttrIsStrDeleted(self, *args)

    def NodeAttrIsFltDeleted(self, *args):
        """
        NodeAttrIsFltDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_NodeAttrIsFltDeleted(self, *args)

    def EdgeAttrIsDeleted(self, *args):
        """
        EdgeAttrIsDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_EdgeAttrIsDeleted(self, *args)

    def EdgeAttrIsIntDeleted(self, *args):
        """
        EdgeAttrIsIntDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_EdgeAttrIsIntDeleted(self, *args)

    def EdgeAttrIsStrDeleted(self, *args):
        """
        EdgeAttrIsStrDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_EdgeAttrIsStrDeleted(self, *args)

    def EdgeAttrIsFltDeleted(self, *args):
        """
        EdgeAttrIsFltDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_EdgeAttrIsFltDeleted(self, *args)

    def GetNodeAttrValue(self, *args):
        """
        GetNodeAttrValue(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr

        Parameters:
            NId: int const &
            NodeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_GetNodeAttrValue(self, *args)

    def GetEdgeAttrValue(self, *args):
        """
        GetEdgeAttrValue(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr

        Parameters:
            EId: int const &
            EdgeHI: TStrIntPrH::TIter const &

        """
        return _snap.PNEANet_GetEdgeAttrValue(self, *args)

PNEANet.Save = new_instancemethod(_snap.PNEANet_Save,None,PNEANet)
PNEANet.__deref__ = new_instancemethod(_snap.PNEANet___deref__,None,PNEANet)
PNEANet.__ref__ = new_instancemethod(_snap.PNEANet___ref__,None,PNEANet)
PNEANet.__call__ = new_instancemethod(_snap.PNEANet___call__,None,PNEANet)
PNEANet.Empty = new_instancemethod(_snap.PNEANet_Empty,None,PNEANet)
PNEANet.Clr = new_instancemethod(_snap.PNEANet_Clr,None,PNEANet)
PNEANet.GetRefs = new_instancemethod(_snap.PNEANet_GetRefs,None,PNEANet)
PNEANet.Load = new_instancemethod(_snap.PNEANet_Load,None,PNEANet)
PNEANet.HasFlag = new_instancemethod(_snap.PNEANet_HasFlag,None,PNEANet)
PNEANet.GetNodes = new_instancemethod(_snap.PNEANet_GetNodes,None,PNEANet)
PNEANet.AddNode = new_instancemethod(_snap.PNEANet_AddNode,None,PNEANet)
PNEANet.DelNode = new_instancemethod(_snap.PNEANet_DelNode,None,PNEANet)
PNEANet.IsNode = new_instancemethod(_snap.PNEANet_IsNode,None,PNEANet)
PNEANet.BegNI = new_instancemethod(_snap.PNEANet_BegNI,None,PNEANet)
PNEANet.EndNI = new_instancemethod(_snap.PNEANet_EndNI,None,PNEANet)
PNEANet.GetNI = new_instancemethod(_snap.PNEANet_GetNI,None,PNEANet)
PNEANet.BegNAIntI = new_instancemethod(_snap.PNEANet_BegNAIntI,None,PNEANet)
PNEANet.EndNAIntI = new_instancemethod(_snap.PNEANet_EndNAIntI,None,PNEANet)
PNEANet.GetNAIntI = new_instancemethod(_snap.PNEANet_GetNAIntI,None,PNEANet)
PNEANet.BegNAStrI = new_instancemethod(_snap.PNEANet_BegNAStrI,None,PNEANet)
PNEANet.EndNAStrI = new_instancemethod(_snap.PNEANet_EndNAStrI,None,PNEANet)
PNEANet.GetNAStrI = new_instancemethod(_snap.PNEANet_GetNAStrI,None,PNEANet)
PNEANet.BegNAFltI = new_instancemethod(_snap.PNEANet_BegNAFltI,None,PNEANet)
PNEANet.EndNAFltI = new_instancemethod(_snap.PNEANet_EndNAFltI,None,PNEANet)
PNEANet.GetNAFltI = new_instancemethod(_snap.PNEANet_GetNAFltI,None,PNEANet)
PNEANet.AttrNameNI = new_instancemethod(_snap.PNEANet_AttrNameNI,None,PNEANet)
PNEANet.AttrValueNI = new_instancemethod(_snap.PNEANet_AttrValueNI,None,PNEANet)
PNEANet.IntAttrNameNI = new_instancemethod(_snap.PNEANet_IntAttrNameNI,None,PNEANet)
PNEANet.IntAttrValueNI = new_instancemethod(_snap.PNEANet_IntAttrValueNI,None,PNEANet)
PNEANet.StrAttrNameNI = new_instancemethod(_snap.PNEANet_StrAttrNameNI,None,PNEANet)
PNEANet.StrAttrValueNI = new_instancemethod(_snap.PNEANet_StrAttrValueNI,None,PNEANet)
PNEANet.FltAttrNameNI = new_instancemethod(_snap.PNEANet_FltAttrNameNI,None,PNEANet)
PNEANet.FltAttrValueNI = new_instancemethod(_snap.PNEANet_FltAttrValueNI,None,PNEANet)
PNEANet.AttrNameEI = new_instancemethod(_snap.PNEANet_AttrNameEI,None,PNEANet)
PNEANet.AttrValueEI = new_instancemethod(_snap.PNEANet_AttrValueEI,None,PNEANet)
PNEANet.IntAttrNameEI = new_instancemethod(_snap.PNEANet_IntAttrNameEI,None,PNEANet)
PNEANet.IntAttrValueEI = new_instancemethod(_snap.PNEANet_IntAttrValueEI,None,PNEANet)
PNEANet.StrAttrNameEI = new_instancemethod(_snap.PNEANet_StrAttrNameEI,None,PNEANet)
PNEANet.StrAttrValueEI = new_instancemethod(_snap.PNEANet_StrAttrValueEI,None,PNEANet)
PNEANet.FltAttrNameEI = new_instancemethod(_snap.PNEANet_FltAttrNameEI,None,PNEANet)
PNEANet.FltAttrValueEI = new_instancemethod(_snap.PNEANet_FltAttrValueEI,None,PNEANet)
PNEANet.BegEAIntI = new_instancemethod(_snap.PNEANet_BegEAIntI,None,PNEANet)
PNEANet.EndEAIntI = new_instancemethod(_snap.PNEANet_EndEAIntI,None,PNEANet)
PNEANet.GetEAIntI = new_instancemethod(_snap.PNEANet_GetEAIntI,None,PNEANet)
PNEANet.BegEAStrI = new_instancemethod(_snap.PNEANet_BegEAStrI,None,PNEANet)
PNEANet.EndEAStrI = new_instancemethod(_snap.PNEANet_EndEAStrI,None,PNEANet)
PNEANet.GetEAStrI = new_instancemethod(_snap.PNEANet_GetEAStrI,None,PNEANet)
PNEANet.BegEAFltI = new_instancemethod(_snap.PNEANet_BegEAFltI,None,PNEANet)
PNEANet.EndEAFltI = new_instancemethod(_snap.PNEANet_EndEAFltI,None,PNEANet)
PNEANet.GetEAFltI = new_instancemethod(_snap.PNEANet_GetEAFltI,None,PNEANet)
PNEANet.GetMxNId = new_instancemethod(_snap.PNEANet_GetMxNId,None,PNEANet)
PNEANet.GetEdges = new_instancemethod(_snap.PNEANet_GetEdges,None,PNEANet)
PNEANet.AddEdge = new_instancemethod(_snap.PNEANet_AddEdge,None,PNEANet)
PNEANet.DelEdge = new_instancemethod(_snap.PNEANet_DelEdge,None,PNEANet)
PNEANet.IsEdge = new_instancemethod(_snap.PNEANet_IsEdge,None,PNEANet)
PNEANet.GetEId = new_instancemethod(_snap.PNEANet_GetEId,None,PNEANet)
PNEANet.BegEI = new_instancemethod(_snap.PNEANet_BegEI,None,PNEANet)
PNEANet.EndEI = new_instancemethod(_snap.PNEANet_EndEI,None,PNEANet)
PNEANet.GetEI = new_instancemethod(_snap.PNEANet_GetEI,None,PNEANet)
PNEANet.GetRndNId = new_instancemethod(_snap.PNEANet_GetRndNId,None,PNEANet)
PNEANet.GetRndNI = new_instancemethod(_snap.PNEANet_GetRndNI,None,PNEANet)
PNEANet.GetRndEId = new_instancemethod(_snap.PNEANet_GetRndEId,None,PNEANet)
PNEANet.GetRndEI = new_instancemethod(_snap.PNEANet_GetRndEI,None,PNEANet)
PNEANet.GetNIdV = new_instancemethod(_snap.PNEANet_GetNIdV,None,PNEANet)
PNEANet.GetEIdV = new_instancemethod(_snap.PNEANet_GetEIdV,None,PNEANet)
PNEANet.Reserve = new_instancemethod(_snap.PNEANet_Reserve,None,PNEANet)
PNEANet.Defrag = new_instancemethod(_snap.PNEANet_Defrag,None,PNEANet)
PNEANet.IsOk = new_instancemethod(_snap.PNEANet_IsOk,None,PNEANet)
PNEANet.Dump = new_instancemethod(_snap.PNEANet_Dump,None,PNEANet)
PNEANet.AddIntAttrDatN = new_instancemethod(_snap.PNEANet_AddIntAttrDatN,None,PNEANet)
PNEANet.AddStrAttrDatN = new_instancemethod(_snap.PNEANet_AddStrAttrDatN,None,PNEANet)
PNEANet.AddFltAttrDatN = new_instancemethod(_snap.PNEANet_AddFltAttrDatN,None,PNEANet)
PNEANet.AddIntAttrDatE = new_instancemethod(_snap.PNEANet_AddIntAttrDatE,None,PNEANet)
PNEANet.AddStrAttrDatE = new_instancemethod(_snap.PNEANet_AddStrAttrDatE,None,PNEANet)
PNEANet.AddFltAttrDatE = new_instancemethod(_snap.PNEANet_AddFltAttrDatE,None,PNEANet)
PNEANet.GetIntAttrDatN = new_instancemethod(_snap.PNEANet_GetIntAttrDatN,None,PNEANet)
PNEANet.GetStrAttrDatN = new_instancemethod(_snap.PNEANet_GetStrAttrDatN,None,PNEANet)
PNEANet.GetFltAttrDatN = new_instancemethod(_snap.PNEANet_GetFltAttrDatN,None,PNEANet)
PNEANet.GetIntAttrDatE = new_instancemethod(_snap.PNEANet_GetIntAttrDatE,None,PNEANet)
PNEANet.GetStrAttrDatE = new_instancemethod(_snap.PNEANet_GetStrAttrDatE,None,PNEANet)
PNEANet.GetFltAttrDatE = new_instancemethod(_snap.PNEANet_GetFltAttrDatE,None,PNEANet)
PNEANet.DelAttrDatN = new_instancemethod(_snap.PNEANet_DelAttrDatN,None,PNEANet)
PNEANet.DelAttrDatE = new_instancemethod(_snap.PNEANet_DelAttrDatE,None,PNEANet)
PNEANet.AddIntAttrN = new_instancemethod(_snap.PNEANet_AddIntAttrN,None,PNEANet)
PNEANet.AddStrAttrN = new_instancemethod(_snap.PNEANet_AddStrAttrN,None,PNEANet)
PNEANet.AddFltAttrN = new_instancemethod(_snap.PNEANet_AddFltAttrN,None,PNEANet)
PNEANet.AddIntAttrE = new_instancemethod(_snap.PNEANet_AddIntAttrE,None,PNEANet)
PNEANet.AddStrAttrE = new_instancemethod(_snap.PNEANet_AddStrAttrE,None,PNEANet)
PNEANet.AddFltAttrE = new_instancemethod(_snap.PNEANet_AddFltAttrE,None,PNEANet)
PNEANet.DelAttrN = new_instancemethod(_snap.PNEANet_DelAttrN,None,PNEANet)
PNEANet.DelAttrE = new_instancemethod(_snap.PNEANet_DelAttrE,None,PNEANet)
PNEANet.NodeAttrIsDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsDeleted,None,PNEANet)
PNEANet.NodeAttrIsIntDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsIntDeleted,None,PNEANet)
PNEANet.NodeAttrIsStrDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsStrDeleted,None,PNEANet)
PNEANet.NodeAttrIsFltDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsFltDeleted,None,PNEANet)
PNEANet.EdgeAttrIsDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsDeleted,None,PNEANet)
PNEANet.EdgeAttrIsIntDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsIntDeleted,None,PNEANet)
PNEANet.EdgeAttrIsStrDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsStrDeleted,None,PNEANet)
PNEANet.EdgeAttrIsFltDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsFltDeleted,None,PNEANet)
PNEANet.GetNodeAttrValue = new_instancemethod(_snap.PNEANet_GetNodeAttrValue,None,PNEANet)
PNEANet.GetEdgeAttrValue = new_instancemethod(_snap.PNEANet_GetEdgeAttrValue,None,PNEANet)
PNEANet_swigregister = _snap.PNEANet_swigregister
PNEANet_swigregister(PNEANet)

def PNEANet_New():
  """PNEANet_New() -> PNEANet"""
  return _snap.PNEANet_New()


def GetNodeWcc(*args):
  """
    GetNodeWcc(PNEANet Graph, int const & NId, TIntV CnCom)

    Parameters:
        Graph: TPt< TNEANet > const &
        NId: int const &
        CnCom: TIntV &

    """
  return _snap.GetNodeWcc(*args)

def IsConnected(*args):
  """
    IsConnected(PNEANet Graph) -> bool

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.IsConnected(*args)

def IsWeaklyConn(*args):
  """
    IsWeaklyConn(PNEANet Graph) -> bool

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.IsWeaklyConn(*args)

def GetWccSzCnt(*args):
  """
    GetWccSzCnt(PNEANet Graph, TIntPrV & WccSzCnt)

    Parameters:
        Graph: TPt< TNEANet > const &
        WccSzCnt: TIntPrV &

    """
  return _snap.GetWccSzCnt(*args)

def GetWccs(*args):
  """
    GetWccs(PNEANet Graph, TCnComV & CnComV)

    Parameters:
        Graph: TPt< TNEANet > const &
        CnComV: TCnComV &

    """
  return _snap.GetWccs(*args)

def GetSccSzCnt(*args):
  """
    GetSccSzCnt(PNEANet Graph, TIntPrV & SccSzCnt)

    Parameters:
        Graph: TPt< TNEANet > const &
        SccSzCnt: TIntPrV &

    """
  return _snap.GetSccSzCnt(*args)

def GetSccs(*args):
  """
    GetSccs(PNEANet Graph, TCnComV & CnComV)

    Parameters:
        Graph: TPt< TNEANet > const &
        CnComV: TCnComV &

    """
  return _snap.GetSccs(*args)

def GetMxWccSz(*args):
  """
    GetMxWccSz(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxWccSz(*args)

def GetMxWcc(*args):
  """
    GetMxWcc(PNEANet Graph) -> PNEANet

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxWcc(*args)

def GetMxScc(*args):
  """
    GetMxScc(PNEANet Graph) -> PNEANet

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxScc(*args)

def GetMxBiCon(*args):
  """
    GetMxBiCon(PUNGraph const & Graph, bool const & RenumberNodes=False) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &
        RenumberNodes: bool const &

    GetMxBiCon(PUNGraph const & Graph) -> PUNGraph

    Parameters:
        Graph: PUNGraph const &

    GetMxBiCon(PNEANet Graph) -> PNEANet

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxBiCon(*args)

def CntInDegNodes(*args):
  """
    CntInDegNodes(PNEANet Graph, int const & NodeInDeg) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NodeInDeg: int const &

    """
  return _snap.CntInDegNodes(*args)

def CntOutDegNodes(*args):
  """
    CntOutDegNodes(PNEANet Graph, int const & NodeOutDeg) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NodeOutDeg: int const &

    """
  return _snap.CntOutDegNodes(*args)

def CntDegNodes(*args):
  """
    CntDegNodes(PNEANet Graph, int const & NodeDeg) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NodeDeg: int const &

    """
  return _snap.CntDegNodes(*args)

def CntNonZNodes(*args):
  """
    CntNonZNodes(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntNonZNodes(*args)

def CntEdgesToSet(*args):
  """
    CntEdgesToSet(PNEANet Graph, int const & NId, TIntSet const & NodeSet) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NId: int const &
        NodeSet: TIntSet const &

    """
  return _snap.CntEdgesToSet(*args)

def GetMxDegNId(*args):
  """
    GetMxDegNId(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxDegNId(*args)

def GetMxInDegNId(*args):
  """
    GetMxInDegNId(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxInDegNId(*args)

def GetMxOutDegNId(*args):
  """
    GetMxOutDegNId(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetMxOutDegNId(*args)

def GetInDegCnt(*args):
  """
    GetInDegCnt(PNEANet Graph, TIntPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TIntPrV &

    GetInDegCnt(PNEANet Graph, TFltPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TFltPrV &

    """
  return _snap.GetInDegCnt(*args)

def GetOutDegCnt(*args):
  """
    GetOutDegCnt(PNEANet Graph, TIntPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TIntPrV &

    GetOutDegCnt(PNEANet Graph, TFltPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TFltPrV &

    """
  return _snap.GetOutDegCnt(*args)

def GetDegCnt(*args):
  """
    GetDegCnt(PNEANet Graph, TIntPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TIntPrV &

    GetDegCnt(PNEANet Graph, TFltPrV & DegToCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCntV: TFltPrV &

    """
  return _snap.GetDegCnt(*args)

def GetDegSeqV(*args):
  """
    GetDegSeqV(PNEANet Graph, TIntV DegV)

    Parameters:
        Graph: TPt< TNEANet > const &
        DegV: TIntV &

    GetDegSeqV(PNEANet Graph, TIntV InDegV, TIntV OutDegV)

    Parameters:
        Graph: TPt< TNEANet > const &
        InDegV: TIntV &
        OutDegV: TIntV &

    """
  return _snap.GetDegSeqV(*args)

def GetNodeInDegV(*args):
  """
    GetNodeInDegV(PNEANet Graph, TIntPrV & NIdInDegV)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdInDegV: TIntPrV &

    """
  return _snap.GetNodeInDegV(*args)

def GetNodeOutDegV(*args):
  """
    GetNodeOutDegV(PNEANet Graph, TIntPrV & NIdOutDegV)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdOutDegV: TIntPrV &

    """
  return _snap.GetNodeOutDegV(*args)

def CntUniqUndirEdges(*args):
  """
    CntUniqUndirEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntUniqUndirEdges(*args)

def CntUniqDirEdges(*args):
  """
    CntUniqDirEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntUniqDirEdges(*args)

def CntUniqBiDirEdges(*args):
  """
    CntUniqBiDirEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntUniqBiDirEdges(*args)

def CntSelfEdges(*args):
  """
    CntSelfEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.CntSelfEdges(*args)

def GetBfsTree(*args):
  """
    GetBfsTree(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn) -> PNGraph

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        FollowOut: bool const &
        FollowIn: bool const &

    """
  return _snap.GetBfsTree(*args)

def GetSubTreeSz(*args):
  """
    GetSubTreeSz(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn, 
        int & TreeSz, int & TreeDepth) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        FollowOut: bool const &
        FollowIn: bool const &
        TreeSz: int &
        TreeDepth: int &

    """
  return _snap.GetSubTreeSz(*args)

def GetNodesAtHop(*args):
  """
    GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        Hop: int const &
        NIdV: TIntV &
        IsDir: bool const &

    GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        Hop: int const &
        NIdV: TIntV &

    """
  return _snap.GetNodesAtHop(*args)

def GetNodesAtHops(*args):
  """
    GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        HopCntV: TIntPrV &
        IsDir: bool const &

    GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        StartNId: int const &
        HopCntV: TIntPrV &

    """
  return _snap.GetNodesAtHops(*args)

def GetShortPath(*args):
  """
    GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        DstNId: int const &
        IsDir: bool const &

    GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        DstNId: int const &

    GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False, int const & MaxDist=Mx) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        NIdToDistH: TIntH &
        IsDir: bool const &
        MaxDist: int const &

    GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        NIdToDistH: TIntH &
        IsDir: bool const &

    GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        NIdToDistH: TIntH &

    """
  return _snap.GetShortPath(*args)

def GetBfsFullDiam(*args):
  """
    GetBfsFullDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        IsDir: bool const &

    GetBfsFullDiam(PNEANet Graph, int const & NTestNodes) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &

    """
  return _snap.GetBfsFullDiam(*args)

def GetBfsEffDiam(*args):
  """
    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        IsDir: bool const &

    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &

    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        IsDir: bool const &
        EffDiam: double &
        FullDiam: int &

    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam, 
        double & AvgSPL) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        IsDir: bool const &
        EffDiam: double &
        FullDiam: int &
        AvgSPL: double &

    GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, TIntV SubGraphNIdV, bool const & IsDir, double & EffDiam, 
        int & FullDiam) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NTestNodes: int const &
        SubGraphNIdV: TIntV const &
        IsDir: bool const &
        EffDiam: double &
        FullDiam: int &

    """
  return _snap.GetBfsEffDiam(*args)

def DrawGViz(*args):
  """
    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False, 
        TIntStrH const & NIdColorH=TIntStrH())

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &
        Desc: TStr const &
        NodeLabels: bool const &
        NIdColorH: TIntStrH const &

    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False)

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &
        Desc: TStr const &
        NodeLabels: bool const &

    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr())

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &
        Desc: TStr const &

    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm)

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &

    DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc, TIntStrH const & NodeLabelH)

    Parameters:
        Graph: TPt< TNEANet > const &
        Layout: TGVizLayout const &
        PltFNm: TStr const &
        Desc: TStr const &
        NodeLabelH: TIntStrH const &

    """
  return _snap.DrawGViz(*args)

def GetClustCf(*args):
  """
    GetClustCf(PNEANet Graph, int SampleNodes=-1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        SampleNodes: int

    GetClustCf(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int SampleNodes=-1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCCfV: TFltPrV &
        SampleNodes: int

    GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCCfV: TFltPrV &

    GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes=-1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCCfV: TFltPrV &
        ClosedTriads: int64 &
        OpenTriads: int64 &
        SampleNodes: int

    GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        DegToCCfV: TFltPrV &
        ClosedTriads: int64 &
        OpenTriads: int64 &

    """
  return _snap.GetClustCf(*args)

def GetNodeClustCf(*args):
  """
    GetNodeClustCf(PNEANet Graph, int const & NId) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NId: int const &

    GetNodeClustCf(PNEANet Graph, TIntFltH & NIdCCfH)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdCCfH: TIntFltH &

    """
  return _snap.GetNodeClustCf(*args)

def GetTriads(*args):
  """
    GetTriads(PNEANet Graph, int SampleNodes=-1) -> int64

    Parameters:
        Graph: TPt< TNEANet > const &
        SampleNodes: int

    GetTriads(PNEANet Graph) -> int64

    Parameters:
        Graph: TPt< TNEANet > const &

    GetTriads(PNEANet Graph, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes) -> int64

    Parameters:
        Graph: TPt< TNEANet > const &
        ClosedTriads: int64 &
        OpenTriads: int64 &
        SampleNodes: int

    GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV, int SampleNodes=-1)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdCOTriadV: TIntTrV &
        SampleNodes: int

    GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdCOTriadV: TIntTrV &

    """
  return _snap.GetTriads(*args)

def GetTriadEdges(*args):
  """
    GetTriadEdges(PNEANet Graph, int SampleEdges=-1) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        SampleEdges: int

    GetTriadEdges(PNEANet Graph) -> int

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetTriadEdges(*args)

def GetTriadParticip(*args):
  """
    GetTriadParticip(PNEANet Graph, TIntPrV & TriadCntV)

    Parameters:
        Graph: TPt< TNEANet > const &
        TriadCntV: TIntPrV &

    """
  return _snap.GetTriadParticip(*args)

def GetCmnNbrs(*args):
  """
    GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NId1: int const &
        NId2: int const &

    GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2, TIntV NbrV) -> int

    Parameters:
        Graph: TPt< TNEANet > const &
        NId1: int const &
        NId2: int const &
        NbrV: TIntV &

    """
  return _snap.GetCmnNbrs(*args)

def GetModularity(*args):
  """
    GetModularity(PNEANet G, TIntV NIdV, int GEdges=-1) -> double

    Parameters:
        G: TPt< TNEANet > const &
        NIdV: TIntV const &
        GEdges: int

    GetModularity(PNEANet G, TIntV NIdV) -> double

    Parameters:
        G: TPt< TNEANet > const &
        NIdV: TIntV const &

    GetModularity(PNEANet G, TCnComV const & CmtyV, int GEdges=-1) -> double

    Parameters:
        G: TPt< TNEANet > const &
        CmtyV: TCnComV const &
        GEdges: int

    GetModularity(PNEANet G, TCnComV const & CmtyV) -> double

    Parameters:
        G: TPt< TNEANet > const &
        CmtyV: TCnComV const &

    """
  return _snap.GetModularity(*args)

def GetEdgesInOut(*args):
  """
    GetEdgesInOut(PNEANet Graph, TIntV NIdV, int & EdgesIn, int & EdgesOut)

    Parameters:
        Graph: TPt< TNEANet > const &
        NIdV: TIntV const &
        EdgesIn: int &
        EdgesOut: int &

    """
  return _snap.GetEdgesInOut(*args)

def GetAnf(*args):
  """
    GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir, 
        int const & NApprox=32)

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        DistNbrsV: TIntFltKdV &
        MxDist: int const &
        IsDir: bool const &
        NApprox: int const &

    GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir)

    Parameters:
        Graph: TPt< TNEANet > const &
        SrcNId: int const &
        DistNbrsV: TIntFltKdV &
        MxDist: int const &
        IsDir: bool const &

    GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir, int const & NApprox=32)

    Parameters:
        Graph: TPt< TNEANet > const &
        DistNbrsV: TIntFltKdV &
        MxDist: int const &
        IsDir: bool const &
        NApprox: int const &

    GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir)

    Parameters:
        Graph: TPt< TNEANet > const &
        DistNbrsV: TIntFltKdV &
        MxDist: int const &
        IsDir: bool const &

    """
  return _snap.GetAnf(*args)

def GetAnfEffDiam(*args):
  """
    GetAnfEffDiam(PNEANet Graph, bool const & IsDir, double const & Percentile, int const & NApprox) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        IsDir: bool const &
        Percentile: double const &
        NApprox: int const &

    GetAnfEffDiam(PNEANet Graph, int const NRuns=1, int NApprox=-1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NRuns: int const
        NApprox: int

    GetAnfEffDiam(PNEANet Graph, int const NRuns=1) -> double

    Parameters:
        Graph: TPt< TNEANet > const &
        NRuns: int const

    GetAnfEffDiam(PNEANet Graph) -> double

    Parameters:
        Graph: TPt< TNEANet > const &

    """
  return _snap.GetAnfEffDiam(*args)



# This file was automatically generated by SWIG (http://www.swig.org). # Version 2.0.9 # # Do not make changes to this file unless you know what you are doing--modify # the SWIG interface file instead. # Python < 2.2 doesn't have 'property'. CalcEffDiam(TIntFltKdV const & DistNbrsCdfV, double const & Percentile=0.9) -> double      Parameters:         DistNbrsCdfV: TIntFltKdV const &         Percentile: double const &      CalcEffDiam(TIntFltKdV const & DistNbrsCdfV) -> double      Parameters:         DistNbrsCdfV: TIntFltKdV const &      CalcEffDiam(TFltPrV const & DistNbrsCdfV, double const & Percentile=0.9) -> double      Parameters:         DistNbrsCdfV: TFltPrV const &         Percentile: double const &      CalcEffDiam(TFltPrV const & DistNbrsCdfV) -> double      Parameters:         DistNbrsCdfV: TFltPrV const & CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV, double const & Percentile=0.9) -> double      Parameters:         DistNbrsPdfV: TIntFltKdV const &         Percentile: double const &      CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double      Parameters:         DistNbrsPdfV: TIntFltKdV const &      CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV, double const & Percentile=0.9) -> double      Parameters:         DistNbrsPdfV: TFltPrV const &         Percentile: double const &      CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV) -> double      Parameters:         DistNbrsPdfV: TFltPrV const & CalcAvgDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double      Parameters:         DistNbrsPdfV: TIntFltKdV const &      CalcAvgDiamPdf(TFltPrV const & DistNbrsPdfV) -> double      Parameters:         DistNbrsPdfV: TFltPrV const & WrNotify(char const * CaptionCStr, char const * NotifyCStr)      Parameters:         CaptionCStr: char const *         NotifyCStr: char const * SaveToErrLog(char const * MsgCStr)      Parameters:         MsgCStr: char const * InfoNotify(char const * NotifyCStr)      Parameters:         NotifyCStr: char const * WarnNotify(char const * NotifyCStr)      Parameters:         NotifyCStr: char const * ErrNotify(char const * NotifyCStr)      Parameters:         NotifyCStr: char const * StatNotify(char const * NotifyCStr)      Parameters:         NotifyCStr: char const * ExeStop(char const * MsgStr, char const * ReasonStr, char const * CondStr, char const * FNm,          int const & LnN)      Parameters:         MsgStr: char const *         ReasonStr: char const *         CondStr: char const *         FNm: char const *         LnN: int const & Proxy of C++ TCRef class __init__(TCRef self) -> TCRef MkRef(TCRef self)          Parameters:             self: TCRef * UnRef(TCRef self)          Parameters:             self: TCRef * NoRef(TCRef self) -> bool          Parameters:             self: TCRef const * GetRefs(TCRef self) -> int          Parameters:             self: TCRef const * Proxy of C++ TSStr class __init__(TSStr self) -> TSStr         __init__(TSStr self, TSStr SStr) -> TSStr          Parameters:             SStr: TSStr const &          __init__(TSStr self, char const * _Bf) -> TSStr          Parameters:             _Bf: char const * CStr(TSStr self) -> char         CStr(TSStr self) -> char const *          Parameters:             self: TSStr const * Empty(TSStr self) -> bool          Parameters:             self: TSStr const * Len(TSStr self) -> int          Parameters:             self: TSStr const * Proxy of C++ TConv_Pt64Ints32 class __init__(TConv_Pt64Ints32 self) -> TConv_Pt64Ints32         __init__(TConv_Pt64Ints32 self, void * Pt) -> TConv_Pt64Ints32          Parameters:             Pt: void *          __init__(TConv_Pt64Ints32 self, uint const & Ms, uint const & Ls) -> TConv_Pt64Ints32          Parameters:             Ms: uint const &             Ls: uint const & PutPt(TConv_Pt64Ints32 self, void * Pt)          Parameters:             Pt: void * GetPt(TConv_Pt64Ints32 self) -> void *          Parameters:             self: TConv_Pt64Ints32 const * PutUInt64(TConv_Pt64Ints32 self, uint64 const & _UInt64)          Parameters:             _UInt64: uint64 const & GetUInt64(TConv_Pt64Ints32 self) -> uint64          Parameters:             self: TConv_Pt64Ints32 const * PutMsUInt32(TConv_Pt64Ints32 self, uint const & Ms)          Parameters:             Ms: uint const & GetMsUInt32(TConv_Pt64Ints32 self) -> uint          Parameters:             self: TConv_Pt64Ints32 const * PutLsUInt32(TConv_Pt64Ints32 self, uint const & Ls)          Parameters:             Ls: uint const & GetLsUInt32(TConv_Pt64Ints32 self) -> uint          Parameters:             self: TConv_Pt64Ints32 const * Proxy of C++ TPairHashImpl1 class GetHashCd(int const hc1, int const hc2) -> int          Parameters:             hc1: int const             hc2: int const __init__(TPairHashImpl1 self) -> TPairHashImpl1 TPairHashImpl1_GetHashCd(int const hc1, int const hc2) -> int      Parameters:         hc1: int const         hc2: int const Proxy of C++ TPairHashImpl2 class GetHashCd(int const hc1, int const hc2) -> int          Parameters:             hc1: int const             hc2: int const __init__(TPairHashImpl2 self) -> TPairHashImpl2 TPairHashImpl2_GetHashCd(int const hc1, int const hc2) -> int      Parameters:         hc1: int const         hc2: int const GetDegreeCentr(PUNGraph const & Graph, int const & NId) -> double      Parameters:         Graph: PUNGraph const &         NId: int const & GetFarnessCentr(PUNGraph const & Graph, int const & NId) -> double      Parameters:         Graph: PUNGraph const &         NId: int const & GetClosenessCentr(PUNGraph const & Graph, int const & NId) -> double      Parameters:         Graph: PUNGraph const &         NId: int const & GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, double const & NodeFrac=1.0)      Parameters:         Graph: PUNGraph const &         NIdBtwH: TIntFltH &         NodeFrac: double const &      GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH)      Parameters:         Graph: PUNGraph const &         NIdBtwH: TIntFltH &      GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0)      Parameters:         Graph: PUNGraph const &         EdgeBtwH: TIntPrFltH &         NodeFrac: double const &      GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH)      Parameters:         Graph: PUNGraph const &         EdgeBtwH: TIntPrFltH &      GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0)      Parameters:         Graph: PUNGraph const &         NIdBtwH: TIntFltH &         EdgeBtwH: TIntPrFltH &         NodeFrac: double const &      GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH)      Parameters:         Graph: PUNGraph const &         NIdBtwH: TIntFltH &         EdgeBtwH: TIntPrFltH &      GetBetweennessCentr(PUNGraph const & Graph, TIntV BtwNIdV, TIntFltH & NodeBtwH, bool const & DoNodeCent,          TIntPrFltH & EdgeBtwH, bool const & DoEdgeCent)      Parameters:         Graph: PUNGraph const &         BtwNIdV: TIntV const &         NodeBtwH: TIntFltH &         DoNodeCent: bool const &         EdgeBtwH: TIntPrFltH &         DoEdgeCent: bool const & GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4, int const & MaxIter=100)      Parameters:         Graph: PUNGraph const &         NIdEigenH: TIntFltH &         Eps: double const &         MaxIter: int const &      GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4)      Parameters:         Graph: PUNGraph const &         NIdEigenH: TIntFltH &         Eps: double const &      GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH)      Parameters:         Graph: PUNGraph const &         NIdEigenH: TIntFltH & CommunityGirvanNewman(PUNGraph & Graph, TCnComV & CmtyV) -> double      Parameters:         Graph: PUNGraph &         CmtyV: TCnComV & CommunityCNM(PUNGraph const & Graph, TCnComV & CmtyV) -> double      Parameters:         Graph: PUNGraph const &         CmtyV: TCnComV & CmtyGirvanNewmanStep(PUNGraph & Graph, TIntV Cmty1, TIntV Cmty2)      Parameters:         Graph: PUNGraph &         Cmty1: TIntV &         Cmty2: TIntV & GetBiConSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV)      Parameters:         Graph: PUNGraph const &         SzCntV: TIntPrV & GetBiCon(PUNGraph const & Graph, TCnComV & BiCnComV)      Parameters:         Graph: PUNGraph const &         BiCnComV: TCnComV & GetArtPoints(PUNGraph const & Graph, TIntV ArtNIdV)      Parameters:         Graph: PUNGraph const &         ArtNIdV: TIntV & GetEdgeBridges(PUNGraph const & Graph, TIntPrV & EdgeV)      Parameters:         Graph: PUNGraph const &         EdgeV: TIntPrV & Get1CnComSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV)      Parameters:         Graph: PUNGraph const &         SzCntV: TIntPrV & Get1CnCom(PUNGraph const & Graph, TCnComV & Cn1ComV)      Parameters:         Graph: PUNGraph const &         Cn1ComV: TCnComV & Proxy of C++ TCnCom class __init__(TCnCom self) -> TCnCom         __init__(TCnCom self, TIntV NodeIdV) -> TCnCom          Parameters:             NodeIdV: TIntV const &          __init__(TCnCom self, TCnCom CC) -> TCnCom          Parameters:             CC: TCnCom const &          __init__(TCnCom self, TSIn SIn) -> TCnCom          Parameters:             SIn: TSIn & Save(TCnCom self, TSOut SOut)          Parameters:             SOut: TSOut & __eq__(TCnCom self, TCnCom CC) -> bool          Parameters:             CC: TCnCom const & __lt__(TCnCom self, TCnCom CC) -> bool          Parameters:             CC: TCnCom const & Len(TCnCom self) -> int          Parameters:             self: TCnCom const * Empty(TCnCom self) -> bool          Parameters:             self: TCnCom const * Clr(TCnCom self)          Parameters:             self: TCnCom * Add(TCnCom self, int const & NodeId)          Parameters:             NodeId: int const & __call__(TCnCom self) -> TIntV         __call__(TCnCom self) -> TIntV          Parameters:             self: TCnCom * Sort(TCnCom self, bool const & Asc=True)          Parameters:             Asc: bool const &          Sort(TCnCom self)          Parameters:             self: TCnCom * IsNIdIn(TCnCom self, int const & NId) -> bool          Parameters:             NId: int const & GetRndNId(TCnCom self) -> TInt          Parameters:             self: TCnCom const * Dump(TCnComV const & CnComV, TStr Desc=TStr())          Parameters:             CnComV: TCnComV const &             Desc: TStr const &          Dump(TCnComV const & CnComV)          Parameters:             CnComV: TCnComV const & SaveTxt(TCnComV const & CnComV, TStr FNm, TStr Desc=TStr())          Parameters:             CnComV: TCnComV const &             FNm: TStr const &             Desc: TStr const &          SaveTxt(TCnComV const & CnComV, TStr FNm)          Parameters:             CnComV: TCnComV const &             FNm: TStr const & Dump(TCnComV const & CnComV, TStr Desc=TStr())      Parameters:         CnComV: TCnComV const &         Desc: TStr const &      TCnCom_Dump(TCnComV const & CnComV)      Parameters:         CnComV: TCnComV const & SaveTxt(TCnComV const & CnComV, TStr FNm, TStr Desc=TStr())      Parameters:         CnComV: TCnComV const &         FNm: TStr const &         Desc: TStr const &      TCnCom_SaveTxt(TCnComV const & CnComV, TStr FNm)      Parameters:         CnComV: TCnComV const &         FNm: TStr const & Proxy of C++ TArtPointVisitor class __init__(TArtPointVisitor self) -> TArtPointVisitor         __init__(TArtPointVisitor self, int const & Nodes) -> TArtPointVisitor          Parameters:             Nodes: int const & DiscoverNode(TArtPointVisitor self, int NId)          Parameters:             NId: int FinishNode(TArtPointVisitor self, int const & NId)          Parameters:             NId: int const & ExamineEdge(TArtPointVisitor self, int const & NId1, int const & NId2)          Parameters:             NId1: int const &             NId2: int const & TreeEdge(TArtPointVisitor self, int const & NId1, int const & NId2)          Parameters:             NId1: int const &             NId2: int const & BackEdge(TArtPointVisitor self, int const & NId1, int const & NId2)          Parameters:             NId1: int const &             NId2: int const & FwdEdge(TArtPointVisitor self, int const & NId1, int const & NId2)          Parameters:             NId1: int const &             NId2: int const & Proxy of C++ TBiConVisitor class __init__(TBiConVisitor self) -> TBiConVisitor         __init__(TBiConVisitor self, int const & Nodes) -> TBiConVisitor          Parameters:             Nodes: int const & DiscoverNode(TBiConVisitor self, int NId)          Parameters:             NId: int FinishNode(TBiConVisitor self, int const & NId)          Parameters:             NId: int const & ExamineEdge(TBiConVisitor self, int const & NId1, int const & NId2)          Parameters:             NId1: int const &             NId2: int const & TreeEdge(TBiConVisitor self, int const & NId1, int const & NId2)          Parameters:             NId1: int const &             NId2: int const & BackEdge(TBiConVisitor self, int const & NId1, int const & NId2)          Parameters:             NId1: int const &             NId2: int const & FwdEdge(TBiConVisitor self, int const & NId1, int const & NId2)          Parameters:             NId1: int const &             NId2: int const & Proxy of C++ TForestFire class __init__(TForestFire self) -> TForestFire         __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb,              double const & DecayProb=1.0, int const & RndSeed=1) -> TForestFire          Parameters:             GraphPt: PNGraph const &             ForwBurnProb: double const &             BackBurnProb: double const &             DecayProb: double const &             RndSeed: int const &          __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb,              double const & DecayProb=1.0) -> TForestFire          Parameters:             GraphPt: PNGraph const &             ForwBurnProb: double const &             BackBurnProb: double const &             DecayProb: double const &          __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb) -> TForestFire          Parameters:             GraphPt: PNGraph const &             ForwBurnProb: double const &             BackBurnProb: double const & SetGraph(TForestFire self, PNGraph const & GraphPt)          Parameters:             GraphPt: PNGraph const & GetGraph(TForestFire self) -> PNGraph          Parameters:             self: TForestFire const * SetBurnProb(TForestFire self, double const & ForwBurnProb, double const & BackBurnProb)          Parameters:             ForwBurnProb: double const &             BackBurnProb: double const & SetProbDecay(TForestFire self, double const & DecayProb)          Parameters:             DecayProb: double const & Infect(TForestFire self, int const & NodeId)          Parameters:             NodeId: int const &          Infect(TForestFire self, TIntV InfectedNIdV)          Parameters:             InfectedNIdV: TIntV const & InfectAll(TForestFire self)          Parameters:             self: TForestFire * InfectRnd(TForestFire self, int const & NInfect)          Parameters:             NInfect: int const & BurnExpFire(TForestFire self)          Parameters:             self: TForestFire * BurnGeoFire(TForestFire self)          Parameters:             self: TForestFire * GetFireTm(TForestFire self) -> int          Parameters:             self: TForestFire const * GetBurned(TForestFire self) -> int          Parameters:             self: TForestFire const * GetBurnedNId(TForestFire self, int const & NIdN) -> int          Parameters:             NIdN: int const & GetBurnedNIdV(TForestFire self) -> TIntV         GetBurnedNIdV(TForestFire self, TIntV NIdV)          Parameters:             NIdV: TIntV & PlotFire(TForestFire self, TStr FNmPref, TStr Desc, bool const & PlotAllBurned=False)          Parameters:             FNmPref: TStr const &             Desc: TStr const &             PlotAllBurned: bool const &          PlotFire(TForestFire self, TStr FNmPref, TStr Desc)          Parameters:             FNmPref: TStr const &             Desc: TStr const & GenGraph(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph          Parameters:             Nodes: int const &             FwdProb: double const &             BckProb: double const & TForestFire_GenGraph(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph      Parameters:         Nodes: int const &         FwdProb: double const &         BckProb: double const & Proxy of C++ TFfGGen class __init__(TFfGGen self, bool const & BurnExpFireP, int const & StartNNodes, double const & ForwBurnProb,              double const & BackBurnProb, double const & DecayProb, double const & Take2AmbasPrb,              double const & OrphanPrb) -> TFfGGen          Parameters:             BurnExpFireP: bool const &             StartNNodes: int const &             ForwBurnProb: double const &             BackBurnProb: double const &             DecayProb: double const &             Take2AmbasPrb: double const &             OrphanPrb: double const & GetGraph(TFfGGen self) -> PNGraph          Parameters:             self: TFfGGen const * SetGraph(TFfGGen self, PNGraph const & NGraph)          Parameters:             NGraph: PNGraph const & Clr(TFfGGen self)          Parameters:             self: TFfGGen * GetParamStr(TFfGGen self) -> TStr          Parameters:             self: TFfGGen const * AddNodes(TFfGGen self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason          Parameters:             GraphNodes: int const &             FloodStop: bool const &          AddNodes(TFfGGen self, int const & GraphNodes) -> TFfGGen::TStopReason          Parameters:             GraphNodes: int const & GenGraph(TFfGGen self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason          Parameters:             GraphNodes: int const &             FloodStop: bool const &          GenGraph(TFfGGen self, int const & GraphNodes) -> TFfGGen::TStopReason          Parameters:             GraphNodes: int const &          GenGraph(TFfGGen self, int const & GraphNodes, PGStatVec & EvolStat, bool const & FloodStop=True) -> TFfGGen::TStopReason          Parameters:             GraphNodes: int const &             EvolStat: PGStatVec &             FloodStop: bool const &          GenGraph(TFfGGen self, int const & GraphNodes, PGStatVec & EvolStat) -> TFfGGen::TStopReason          Parameters:             GraphNodes: int const &             EvolStat: PGStatVec & PlotFireSize(TFfGGen self, TStr FNmPref, TStr DescStr)          Parameters:             FNmPref: TStr const &             DescStr: TStr const & GenFFGraphs(double const & FProb, double const & BProb, TStr FNm)          Parameters:             FProb: double const &             BProb: double const &             FNm: TStr const & TFfGGen_GenFFGraphs(double const & FProb, double const & BProb, TStr FNm)      Parameters:         FProb: double const &         BProb: double const &         FNm: TStr const & Proxy of C++ TUndirFFire class __init__(TUndirFFire self, double const & _BurnProb=0.3) -> TUndirFFire          Parameters:             _BurnProb: double const &          __init__(TUndirFFire self) -> TUndirFFire SetGraph(TUndirFFire self, PUNGraph const & GraphPt)          Parameters:             GraphPt: PUNGraph const & GetGraph(TUndirFFire self) -> PUNGraph          Parameters:             self: TUndirFFire const * GetNBurned(TUndirFFire self) -> int          Parameters:             self: TUndirFFire const * GetBurnedNId(TUndirFFire self, int const & n) -> int          Parameters:             n: int const & BurnGeoFire(TUndirFFire self, int const & StartNId) -> int          Parameters:             StartNId: int const & AddNodes(TUndirFFire self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason          Parameters:             GraphNodes: int const &             FloodStop: bool const &          AddNodes(TUndirFFire self, int const & GraphNodes) -> TFfGGen::TStopReason          Parameters:             GraphNodes: int const & Proxy of C++ TCs class __init__(TCs self) -> TCs         __init__(TCs self, TCs Cs) -> TCs          Parameters:             Cs: TCs const &          __init__(TCs self, int const & Int) -> TCs          Parameters:             Int: int const & __eq__(TCs self, TCs Cs) -> bool          Parameters:             Cs: TCs const & __iadd__(TCs self, TCs Cs) -> TCs          Parameters:             Cs: TCs const &          __iadd__(TCs self, char const & Ch) -> TCs          Parameters:             Ch: char const &          __iadd__(TCs self, int const & Int) -> TCs          Parameters:             Int: int const & Get(TCs self) -> int          Parameters:             self: TCs const * GetCsFromBf(char * Bf, int const & BfL) -> TCs          Parameters:             Bf: char *             BfL: int const & TCs_GetCsFromBf(char * Bf, int const & BfL) -> TCs      Parameters:         Bf: char *         BfL: int const & Proxy of C++ TSOutMnp class __call__(TSOutMnp self, TSOut SOut) -> TSOut          Parameters:             SOut: TSOut & Proxy of C++ TSBase class __init__(TSBase self, TSStr Nm) -> TSBase          Parameters:             Nm: TSStr const & GetSNm(TSBase self) -> TStr          Parameters:             self: TSBase const * Proxy of C++ TSIn class Eof(TSIn self) -> bool          Parameters:             self: TSIn * Len(TSIn self) -> int          Parameters:             self: TSIn const * GetCh(TSIn self) -> char          Parameters:             self: TSIn * PeekCh(TSIn self) -> char          Parameters:             self: TSIn * GetBf(TSIn self, void const * Bf, TSize const & BfL) -> int          Parameters:             Bf: void const *             BfL: TSize const & GetNextLnBf(TSIn self, TChA LnChA) -> bool          Parameters:             LnChA: TChA & Reset(TSIn self)          Parameters:             self: TSIn * IsFastMode(TSIn self) -> bool          Parameters:             self: TSIn const * SetFastMode(TSIn self, bool const & _FastMode)          Parameters:             _FastMode: bool const & LoadCs(TSIn self)          Parameters:             self: TSIn * LoadBf(TSIn self, void const * Bf, TSize const & BfL)          Parameters:             Bf: void const *             BfL: TSize const & LoadNewBf(TSIn self, int const & BfL) -> void *          Parameters:             BfL: int const & Load(TSIn self, bool & Bool)          Parameters:             Bool: bool &          Load(TSIn self, uchar & UCh)          Parameters:             UCh: uchar &          Load(TSIn self, char & Ch)          Parameters:             Ch: char &          Load(TSIn self, short & Short)          Parameters:             Short: short &          Load(TSIn self, ushort & UShort)          Parameters:             UShort: ushort &          Load(TSIn self, int & Int)          Parameters:             Int: int &          Load(TSIn self, uint & UInt)          Parameters:             UInt: uint &          Load(TSIn self, int64 & Int)          Parameters:             Int: int64 &          Load(TSIn self, uint64 & UInt)          Parameters:             UInt: uint64 &          Load(TSIn self, double & Flt)          Parameters:             Flt: double &          Load(TSIn self, sdouble & SFlt)          Parameters:             SFlt: sdouble &          Load(TSIn self, ldouble & LFlt)          Parameters:             LFlt: ldouble &          Load(TSIn self, char *& CStr, int const & MxCStrLen, int const & CStrLen)          Parameters:             CStr: char *&             MxCStrLen: int const &             CStrLen: int const &          Load(TSIn self, char *& CStr)          Parameters:             CStr: char *& __rshift__(TSIn self, bool & Bool) -> TSIn          Parameters:             Bool: bool &          __rshift__(TSIn self, uchar & UCh) -> TSIn          Parameters:             UCh: uchar &          __rshift__(TSIn self, char & Ch) -> TSIn          Parameters:             Ch: char &          __rshift__(TSIn self, short & Sh) -> TSIn          Parameters:             Sh: short &          __rshift__(TSIn self, ushort & USh) -> TSIn          Parameters:             USh: ushort &          __rshift__(TSIn self, int & Int) -> TSIn          Parameters:             Int: int &          __rshift__(TSIn self, uint & UInt) -> TSIn          Parameters:             UInt: uint &          __rshift__(TSIn self, int64 & Int) -> TSIn          Parameters:             Int: int64 &          __rshift__(TSIn self, uint64 & UInt) -> TSIn          Parameters:             UInt: uint64 &          __rshift__(TSIn self, float & Flt) -> TSIn          Parameters:             Flt: float &          __rshift__(TSIn self, double & Double) -> TSIn          Parameters:             Double: double &          __rshift__(TSIn self, long double & LDouble) -> TSIn          Parameters:             LDouble: long double & GetNextLn(TSIn self, TStr LnStr) -> bool          Parameters:             LnStr: TStr &          GetNextLn(TSIn self, TChA LnChA) -> bool          Parameters:             LnChA: TChA & Proxy of C++ TSOut class EnableLnTrunc(TSOut self, int const & _MxLnLen)          Parameters:             _MxLnLen: int const & DisableLnTrunc(TSOut self)          Parameters:             self: TSOut * PutBf(TSOut self, void const * LBf, TSize const & LBfL) -> int          Parameters:             LBf: void const *             LBfL: TSize const & Flush(TSOut self)          Parameters:             self: TSOut * GetFileId(TSOut self) -> TFileId          Parameters:             self: TSOut const * PutMem(TSOut self, TMem Mem) -> int          Parameters:             Mem: TMem const & PutCh(TSOut self, char const & Ch) -> int          Parameters:             Ch: char const &          PutCh(TSOut self, char const & Ch, int const & Chs) -> int          Parameters:             Ch: char const &             Chs: int const & PutBool(TSOut self, bool const & Bool) -> int          Parameters:             Bool: bool const & PutInt(TSOut self, int const & Int) -> int          Parameters:             Int: int const &          PutInt(TSOut self, int const & Int, char const * FmtStr) -> int          Parameters:             Int: int const &             FmtStr: char const * PutUInt(TSOut self, uint const & Int) -> int          Parameters:             Int: uint const &          PutUInt(TSOut self, uint const & Int, char const * FmtStr) -> int          Parameters:             Int: uint const &             FmtStr: char const * PutFlt(TSOut self, double const & Flt) -> int          Parameters:             Flt: double const &          PutFlt(TSOut self, double const & Flt, char const * FmtStr) -> int          Parameters:             Flt: double const &             FmtStr: char const * PutStr(TSOut self, char const * CStr) -> int          Parameters:             CStr: char const *          PutStr(TSOut self, TChA ChA) -> int          Parameters:             ChA: TChA const &          PutStr(TSOut self, TStr Str, char const * FmtStr) -> int          Parameters:             Str: TStr const &             FmtStr: char const *          PutStr(TSOut self, TStr Str, bool const & ForceInLn=False) -> int          Parameters:             Str: TStr const &             ForceInLn: bool const &          PutStr(TSOut self, TStr Str) -> int          Parameters:             Str: TStr const & PutStrLn(TSOut self, TStr Str, bool const & ForceInLn=False) -> int          Parameters:             Str: TStr const &             ForceInLn: bool const &          PutStrLn(TSOut self, TStr Str) -> int          Parameters:             Str: TStr const & PutStrFmt(TSOut self, char const * FmtStr) -> int          Parameters:             FmtStr: char const * PutStrFmtLn(TSOut self, char const * FmtStr) -> int          Parameters:             FmtStr: char const * PutIndent(TSOut self, int const & IndentLev=1) -> int          Parameters:             IndentLev: int const &          PutIndent(TSOut self) -> int          Parameters:             self: TSOut * PutLn(TSOut self, int const & Lns=1) -> int          Parameters:             Lns: int const &          PutLn(TSOut self) -> int          Parameters:             self: TSOut * PutDosLn(TSOut self, int const & Lns=1) -> int          Parameters:             Lns: int const &          PutDosLn(TSOut self) -> int          Parameters:             self: TSOut * PutSep(TSOut self, int const & NextStrLen=0) -> int          Parameters:             NextStrLen: int const &          PutSep(TSOut self) -> int          Parameters:             self: TSOut * PutSepLn(TSOut self, int const & Lns=0) -> int          Parameters:             Lns: int const &          PutSepLn(TSOut self) -> int          Parameters:             self: TSOut * SaveCs(TSOut self)          Parameters:             self: TSOut * SaveBf(TSOut self, void const * Bf, TSize const & BfL)          Parameters:             Bf: void const *             BfL: TSize const & Save(TSOut self, bool const & Bool)          Parameters:             Bool: bool const &          Save(TSOut self, char const & Ch)          Parameters:             Ch: char const &          Save(TSOut self, uchar const & UCh)          Parameters:             UCh: uchar const &          Save(TSOut self, short const & Short)          Parameters:             Short: short const &          Save(TSOut self, ushort const & UShort)          Parameters:             UShort: ushort const &          Save(TSOut self, int const & Int)          Parameters:             Int: int const &          Save(TSOut self, uint const & UInt)          Parameters:             UInt: uint const &          Save(TSOut self, int64 const & Int)          Parameters:             Int: int64 const &          Save(TSOut self, uint64 const & UInt)          Parameters:             UInt: uint64 const &          Save(TSOut self, double const & Flt)          Parameters:             Flt: double const &          Save(TSOut self, sdouble const & SFlt)          Parameters:             SFlt: sdouble const &          Save(TSOut self, ldouble const & LFlt)          Parameters:             LFlt: ldouble const &          Save(TSOut self, char const * CStr, TSize const & CStrLen)          Parameters:             CStr: char const *             CStrLen: TSize const &          Save(TSOut self, char const * CStr)          Parameters:             CStr: char const *          Save(TSOut self, TSIn SIn, TSize const & BfL=-1)          Parameters:             SIn: TSIn &             BfL: TSize const &          Save(TSOut self, TSIn SIn)          Parameters:             SIn: TSIn &          Save(TSOut self, PSIn const & SIn, TSize const & BfL=-1)          Parameters:             SIn: PSIn const &             BfL: TSize const &          Save(TSOut self, PSIn const & SIn)          Parameters:             SIn: PSIn const &          Save(TSOut self, void const * Bf, TSize const & BfL)          Parameters:             Bf: void const *             BfL: TSize const & __lshift__(TSOut self, bool const & Bool) -> TSOut          Parameters:             Bool: bool const &          __lshift__(TSOut self, uchar const & UCh) -> TSOut          Parameters:             UCh: uchar const &          __lshift__(TSOut self, char const & Ch) -> TSOut          Parameters:             Ch: char const &          __lshift__(TSOut self, short const & Sh) -> TSOut          Parameters:             Sh: short const &          __lshift__(TSOut self, ushort const & USh) -> TSOut          Parameters:             USh: ushort const &          __lshift__(TSOut self, int const & Int) -> TSOut          Parameters:             Int: int const &          __lshift__(TSOut self, uint const & Int) -> TSOut          Parameters:             Int: uint const &          __lshift__(TSOut self, int64 const & Int) -> TSOut          Parameters:             Int: int64 const &          __lshift__(TSOut self, uint64 const & UInt) -> TSOut          Parameters:             UInt: uint64 const &          __lshift__(TSOut self, float const & Flt) -> TSOut          Parameters:             Flt: float const &          __lshift__(TSOut self, double const & Double) -> TSOut          Parameters:             Double: double const &          __lshift__(TSOut self, long double const & LDouble) -> TSOut          Parameters:             LDouble: long double const &          __lshift__(TSOut self, TSOutMnp Mnp) -> TSOut          Parameters:             Mnp: TSOutMnp const &          __lshift__(TSOut self, TSOut &(*)(TSOut &) FuncPt) -> TSOut          Parameters:             FuncPt: TSOut &(*)(TSOut &)          __lshift__(TSOut self, TSIn SIn) -> TSOut          Parameters:             SIn: TSIn &          __lshift__(TSOut self, PSIn & SIn) -> TSOut          Parameters:             SIn: PSIn & Proxy of C++ TSInOut class SetPos(TSInOut self, int const & Pos)          Parameters:             Pos: int const & MovePos(TSInOut self, int const & DPos)          Parameters:             DPos: int const & GetPos(TSInOut self) -> int          Parameters:             self: TSInOut const * GetSize(TSInOut self) -> int          Parameters:             self: TSInOut const * Clr(TSInOut self)          Parameters:             self: TSInOut * Proxy of C++ TStdIn class __init__(TStdIn self) -> TStdIn New() -> TPt< TSIn > TStdIn_New() -> TPt< TSIn > Proxy of C++ TStdOut class __init__(TStdOut self) -> TStdOut New() -> TPt< TSOut > TStdOut_New() -> TPt< TSOut > Proxy of C++ TFIn class __init__(TFIn self, TStr FNm) -> TFIn          Parameters:             FNm: TStr const &          __init__(TFIn self, TStr FNm, bool & OpenedP) -> TFIn          Parameters:             FNm: TStr const &             OpenedP: bool & New(TStr FNm) -> PSIn          Parameters:             FNm: TStr const &          New(TStr FNm, bool & OpenedP) -> PSIn          Parameters:             FNm: TStr const &             OpenedP: bool & New(TStr FNm) -> PSIn      Parameters:         FNm: TStr const &      TFIn_New(TStr FNm, bool & OpenedP) -> PSIn      Parameters:         FNm: TStr const &         OpenedP: bool & Proxy of C++ TFOut class __init__(TFOut self, TStr _FNm, bool const & Append=False) -> TFOut          Parameters:             _FNm: TStr const &             Append: bool const &          __init__(TFOut self, TStr _FNm) -> TFOut          Parameters:             _FNm: TStr const &          __init__(TFOut self, TStr _FNm, bool const & Append, bool & OpenedP) -> TFOut          Parameters:             _FNm: TStr const &             Append: bool const &             OpenedP: bool & New(TStr FNm, bool const & Append=False) -> PSOut          Parameters:             FNm: TStr const &             Append: bool const &          New(TStr FNm) -> PSOut          Parameters:             FNm: TStr const &          New(TStr FNm, bool const & Append, bool & OpenedP) -> PSOut          Parameters:             FNm: TStr const &             Append: bool const &             OpenedP: bool & New(TStr FNm, bool const & Append=False) -> PSOut      Parameters:         FNm: TStr const &         Append: bool const &      New(TStr FNm) -> PSOut      Parameters:         FNm: TStr const &      TFOut_New(TStr FNm, bool const & Append, bool & OpenedP) -> PSOut      Parameters:         FNm: TStr const &         Append: bool const &         OpenedP: bool & Proxy of C++ TMIn class __init__(TMIn self, void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> TMIn          Parameters:             _Bf: void const *             _BfL: int const &             TakeBf: bool const &          __init__(TMIn self, void const * _Bf, int const & _BfL) -> TMIn          Parameters:             _Bf: void const *             _BfL: int const &          __init__(TMIn self, TSIn SIn) -> TMIn          Parameters:             SIn: TSIn &          __init__(TMIn self, char const * CStr) -> TMIn          Parameters:             CStr: char const *          __init__(TMIn self, TStr Str) -> TMIn          Parameters:             Str: TStr const &          __init__(TMIn self, TChA ChA) -> TMIn          Parameters:             ChA: TChA const & New(void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> PSIn          Parameters:             _Bf: void const *             _BfL: int const &             TakeBf: bool const &          New(void const * _Bf, int const & _BfL) -> PSIn          Parameters:             _Bf: void const *             _BfL: int const &          New(char const * CStr) -> PSIn          Parameters:             CStr: char const *          New(TStr Str) -> PSIn          Parameters:             Str: TStr const &          New(TChA ChA) -> PSIn          Parameters:             ChA: TChA const & GetBfAddr(TMIn self) -> char *          Parameters:             self: TMIn * New(void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> PSIn      Parameters:         _Bf: void const *         _BfL: int const &         TakeBf: bool const &      New(void const * _Bf, int const & _BfL) -> PSIn      Parameters:         _Bf: void const *         _BfL: int const &      New(char const * CStr) -> PSIn      Parameters:         CStr: char const *      New(TStr Str) -> PSIn      Parameters:         Str: TStr const &      TMIn_New(TChA ChA) -> PSIn      Parameters:         ChA: TChA const & Proxy of C++ TMOut class New(int const & MxBfL=1024) -> PSOut          Parameters:             MxBfL: int const &          New() -> PSOut __init__(TMOut self, int const & _MxBfL=1024) -> TMOut          Parameters:             _MxBfL: int const &          __init__(TMOut self) -> TMOut         __init__(TMOut self, char * _Bf, int const & _MxBfL) -> TMOut          Parameters:             _Bf: char *             _MxBfL: int const & AppendBf(TMOut self, void const * LBf, TSize const & LBfL)          Parameters:             LBf: void const *             LBfL: TSize const & Len(TMOut self) -> int          Parameters:             self: TMOut const * Clr(TMOut self)          Parameters:             self: TMOut * GetCh(TMOut self, int const & ChN) -> char          Parameters:             ChN: int const & GetAsStr(TMOut self) -> TStr          Parameters:             self: TMOut const * CutBf(TMOut self, int const & CutBfL)          Parameters:             CutBfL: int const & GetSIn(TMOut self, bool const & IsCut=True, int const & CutBfL=-1) -> PSIn          Parameters:             IsCut: bool const &             CutBfL: int const &          GetSIn(TMOut self, bool const & IsCut=True) -> PSIn          Parameters:             IsCut: bool const &          GetSIn(TMOut self) -> PSIn          Parameters:             self: TMOut * GetBfAddr(TMOut self) -> char *          Parameters:             self: TMOut const * IsCrLfLn(TMOut self) -> bool          Parameters:             self: TMOut const * GetCrLfLn(TMOut self) -> TStr          Parameters:             self: TMOut * IsEolnLn(TMOut self) -> bool          Parameters:             self: TMOut const * GetEolnLn(TMOut self, bool const & DoAddEoln, bool const & DoCutBf) -> TStr          Parameters:             DoAddEoln: bool const &             DoCutBf: bool const & MkEolnLn(TMOut self)          Parameters:             self: TMOut * New(int const & MxBfL=1024) -> PSOut      Parameters:         MxBfL: int const &      TMOut_New() -> PSOut Proxy of C++ TChRet class __init__(TChRet self, PSIn const & _SIn, char const & _EofCh=0) -> TChRet          Parameters:             _SIn: PSIn const &             _EofCh: char const &          __init__(TChRet self, PSIn const & _SIn) -> TChRet          Parameters:             _SIn: PSIn const & Eof(TChRet self) -> bool          Parameters:             self: TChRet const * GetCh(TChRet self) -> char          Parameters:             self: TChRet * __call__(TChRet self) -> char          Parameters:             self: TChRet * Proxy of C++ TLnRet class __init__(TLnRet self, PSIn const & _SIn) -> TLnRet          Parameters:             _SIn: PSIn const & NextLn(TLnRet self, TStr LnStr) -> bool          Parameters:             LnStr: TStr & Proxy of C++ TFile class Exists(TStr FNm) -> bool          Parameters:             FNm: TStr const & Del(TStr FNm, bool const & ThrowExceptP=True)          Parameters:             FNm: TStr const &             ThrowExceptP: bool const &          Del(TStr FNm)          Parameters:             FNm: TStr const & DelWc(TStr WcStr, bool const & RecurseDirP=False)          Parameters:             WcStr: TStr const &             RecurseDirP: bool const &          DelWc(TStr WcStr)          Parameters:             WcStr: TStr const & Rename(TStr SrcFNm, TStr DstFNm)          Parameters:             SrcFNm: TStr const &             DstFNm: TStr const & GetUniqueFNm(TStr FNm) -> TStr          Parameters:             FNm: TStr const & __init__(TFile self) -> TFile TFile_Exists(TStr FNm) -> bool      Parameters:         FNm: TStr const & Del(TStr FNm, bool const & ThrowExceptP=True)      Parameters:         FNm: TStr const &         ThrowExceptP: bool const &      TFile_Del(TStr FNm)      Parameters:         FNm: TStr const & DelWc(TStr WcStr, bool const & RecurseDirP=False)      Parameters:         WcStr: TStr const &         RecurseDirP: bool const &      TFile_DelWc(TStr WcStr)      Parameters:         WcStr: TStr const & TFile_Rename(TStr SrcFNm, TStr DstFNm)      Parameters:         SrcFNm: TStr const &         DstFNm: TStr const & TFile_GetUniqueFNm(TStr FNm) -> TStr      Parameters:         FNm: TStr const & Proxy of C++ TUNGraph class __init__(TUNGraph self) -> TUNGraph         __init__(TUNGraph self, int const & Nodes, int const & Edges) -> TUNGraph          Parameters:             Nodes: int const &             Edges: int const &          __init__(TUNGraph self, TUNGraph Graph) -> TUNGraph          Parameters:             Graph: TUNGraph const &          __init__(TUNGraph self, TSIn SIn) -> TUNGraph          Parameters:             SIn: TSIn & Save(TUNGraph self, TSOut SOut)          Parameters:             SOut: TSOut & New() -> PUNGraph         New(int const & Nodes, int const & Edges) -> PUNGraph          Parameters:             Nodes: int const &             Edges: int const & Load(TSIn SIn) -> PUNGraph          Parameters:             SIn: TSIn & HasFlag(TUNGraph self, TGraphFlag const & Flag) -> bool          Parameters:             Flag: TGraphFlag const & GetNodes(TUNGraph self) -> int          Parameters:             self: TUNGraph const * AddNode(TUNGraph self, int NId=-1) -> int          Parameters:             NId: int          AddNode(TUNGraph self) -> int         AddNode(TUNGraph self, TUNGraph::TNodeI const & NodeI) -> int          Parameters:             NodeI: TUNGraph::TNodeI const &          AddNode(TUNGraph self, int const & NId, TIntV NbrNIdV) -> int          Parameters:             NId: int const &             NbrNIdV: TIntV const &          AddNode(TUNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & NIdVId) -> int          Parameters:             NId: int const &             Pool: TVecPool< TInt > const &             NIdVId: int const & DelNode(TUNGraph self, int const & NId)          Parameters:             NId: int const &          DelNode(TUNGraph self, TUNGraph::TNode const & NodeI)          Parameters:             NodeI: TUNGraph::TNode const & IsNode(TUNGraph self, int const & NId) -> bool          Parameters:             NId: int const & BegNI(TUNGraph self) -> TUNGraph::TNodeI          Parameters:             self: TUNGraph const * EndNI(TUNGraph self) -> TUNGraph::TNodeI          Parameters:             self: TUNGraph const * GetNI(TUNGraph self, int const & NId) -> TUNGraph::TNodeI          Parameters:             NId: int const & GetMxNId(TUNGraph self) -> int          Parameters:             self: TUNGraph const * GetEdges(TUNGraph self) -> int          Parameters:             self: TUNGraph const * AddEdge(TUNGraph self, int const & SrcNId, int const & DstNId) -> int          Parameters:             SrcNId: int const &             DstNId: int const &          AddEdge(TUNGraph self, TUNGraph::TEdgeI const & EdgeI) -> int          Parameters:             EdgeI: TUNGraph::TEdgeI const & DelEdge(TUNGraph self, int const & SrcNId, int const & DstNId)          Parameters:             SrcNId: int const &             DstNId: int const & IsEdge(TUNGraph self, int const & SrcNId, int const & DstNId) -> bool          Parameters:             SrcNId: int const &             DstNId: int const & BegEI(TUNGraph self) -> TUNGraph::TEdgeI          Parameters:             self: TUNGraph const * EndEI(TUNGraph self) -> TUNGraph::TEdgeI          Parameters:             self: TUNGraph const * GetEI(TUNGraph self, int const & SrcNId, int const & DstNId) -> TUNGraph::TEdgeI          Parameters:             SrcNId: int const &             DstNId: int const & GetRndNId(TUNGraph self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndNId(TUNGraph self) -> int          Parameters:             self: TUNGraph * GetRndNI(TUNGraph self, TRnd Rnd=Rnd) -> TUNGraph::TNodeI          Parameters:             Rnd: TRnd &          GetRndNI(TUNGraph self) -> TUNGraph::TNodeI          Parameters:             self: TUNGraph * GetNIdV(TUNGraph self, TIntV NIdV)          Parameters:             NIdV: TIntV & Empty(TUNGraph self) -> bool          Parameters:             self: TUNGraph const * Clr(TUNGraph self)          Parameters:             self: TUNGraph * Reserve(TUNGraph self, int const & Nodes, int const & Edges)          Parameters:             Nodes: int const &             Edges: int const & ReserveNIdDeg(TUNGraph self, int const & NId, int const & Deg)          Parameters:             NId: int const &             Deg: int const & Defrag(TUNGraph self, bool const & OnlyNodeLinks=False)          Parameters:             OnlyNodeLinks: bool const &          Defrag(TUNGraph self)          Parameters:             self: TUNGraph * IsOk(TUNGraph self, bool const & ThrowExcept=True) -> bool          Parameters:             ThrowExcept: bool const &          IsOk(TUNGraph self) -> bool          Parameters:             self: TUNGraph const * Dump(TUNGraph self, FILE * OutF=stdout)          Parameters:             OutF: FILE *          Dump(TUNGraph self)          Parameters:             self: TUNGraph const * GetSmallGraph() -> PUNGraph New() -> PUNGraph     TUNGraph_New(int const & Nodes, int const & Edges) -> PUNGraph      Parameters:         Nodes: int const &         Edges: int const & TUNGraph_Load(TSIn SIn) -> PUNGraph      Parameters:         SIn: TSIn & TUNGraph_GetSmallGraph() -> PUNGraph Proxy of C++ TNGraph class __init__(TNGraph self) -> TNGraph         __init__(TNGraph self, int const & Nodes, int const & Edges) -> TNGraph          Parameters:             Nodes: int const &             Edges: int const &          __init__(TNGraph self, TNGraph Graph) -> TNGraph          Parameters:             Graph: TNGraph const &          __init__(TNGraph self, TSIn SIn) -> TNGraph          Parameters:             SIn: TSIn & Save(TNGraph self, TSOut SOut)          Parameters:             SOut: TSOut & New() -> PNGraph         New(int const & Nodes, int const & Edges) -> PNGraph          Parameters:             Nodes: int const &             Edges: int const & Load(TSIn SIn) -> PNGraph          Parameters:             SIn: TSIn & HasFlag(TNGraph self, TGraphFlag const & Flag) -> bool          Parameters:             Flag: TGraphFlag const & GetNodes(TNGraph self) -> int          Parameters:             self: TNGraph const * AddNode(TNGraph self, int NId=-1) -> int          Parameters:             NId: int          AddNode(TNGraph self) -> int         AddNode(TNGraph self, TNGraph::TNodeI const & NodeId) -> int          Parameters:             NodeId: TNGraph::TNodeI const &          AddNode(TNGraph self, int const & NId, TIntV InNIdV, TIntV OutNIdV) -> int          Parameters:             NId: int const &             InNIdV: TIntV const &             OutNIdV: TIntV const &          AddNode(TNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & SrcVId, int const & DstVId) -> int          Parameters:             NId: int const &             Pool: TVecPool< TInt > const &             SrcVId: int const &             DstVId: int const & DelNode(TNGraph self, int const & NId)          Parameters:             NId: int const &          DelNode(TNGraph self, TNGraph::TNode const & NodeI)          Parameters:             NodeI: TNGraph::TNode const & IsNode(TNGraph self, int const & NId) -> bool          Parameters:             NId: int const & BegNI(TNGraph self) -> TNGraph::TNodeI          Parameters:             self: TNGraph const * EndNI(TNGraph self) -> TNGraph::TNodeI          Parameters:             self: TNGraph const * GetNI(TNGraph self, int const & NId) -> TNGraph::TNodeI          Parameters:             NId: int const & GetMxNId(TNGraph self) -> int          Parameters:             self: TNGraph const * GetEdges(TNGraph self) -> int          Parameters:             self: TNGraph const * AddEdge(TNGraph self, int const & SrcNId, int const & DstNId) -> int          Parameters:             SrcNId: int const &             DstNId: int const &          AddEdge(TNGraph self, TNGraph::TEdgeI const & EdgeI) -> int          Parameters:             EdgeI: TNGraph::TEdgeI const & DelEdge(TNGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)          Parameters:             SrcNId: int const &             DstNId: int const &             IsDir: bool const &          DelEdge(TNGraph self, int const & SrcNId, int const & DstNId)          Parameters:             SrcNId: int const &             DstNId: int const & IsEdge(TNGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             IsDir: bool const &          IsEdge(TNGraph self, int const & SrcNId, int const & DstNId) -> bool          Parameters:             SrcNId: int const &             DstNId: int const & BegEI(TNGraph self) -> TNGraph::TEdgeI          Parameters:             self: TNGraph const * EndEI(TNGraph self) -> TNGraph::TEdgeI          Parameters:             self: TNGraph const * GetEI(TNGraph self, int const & SrcNId, int const & DstNId) -> TNGraph::TEdgeI          Parameters:             SrcNId: int const &             DstNId: int const & GetRndNId(TNGraph self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndNId(TNGraph self) -> int          Parameters:             self: TNGraph * GetRndNI(TNGraph self, TRnd Rnd=Rnd) -> TNGraph::TNodeI          Parameters:             Rnd: TRnd &          GetRndNI(TNGraph self) -> TNGraph::TNodeI          Parameters:             self: TNGraph * GetNIdV(TNGraph self, TIntV NIdV)          Parameters:             NIdV: TIntV & Empty(TNGraph self) -> bool          Parameters:             self: TNGraph const * Clr(TNGraph self)          Parameters:             self: TNGraph * Reserve(TNGraph self, int const & Nodes, int const & Edges)          Parameters:             Nodes: int const &             Edges: int const & ReserveNIdInDeg(TNGraph self, int const & NId, int const & InDeg)          Parameters:             NId: int const &             InDeg: int const & ReserveNIdOutDeg(TNGraph self, int const & NId, int const & OutDeg)          Parameters:             NId: int const &             OutDeg: int const & Defrag(TNGraph self, bool const & OnlyNodeLinks=False)          Parameters:             OnlyNodeLinks: bool const &          Defrag(TNGraph self)          Parameters:             self: TNGraph * IsOk(TNGraph self, bool const & ThrowExcept=True) -> bool          Parameters:             ThrowExcept: bool const &          IsOk(TNGraph self) -> bool          Parameters:             self: TNGraph const * Dump(TNGraph self, FILE * OutF=stdout)          Parameters:             OutF: FILE *          Dump(TNGraph self)          Parameters:             self: TNGraph const * GetSmallGraph() -> PNGraph New() -> PNGraph     TNGraph_New(int const & Nodes, int const & Edges) -> PNGraph      Parameters:         Nodes: int const &         Edges: int const & TNGraph_Load(TSIn SIn) -> PNGraph      Parameters:         SIn: TSIn & TNGraph_GetSmallGraph() -> PNGraph Proxy of C++ TNEGraph class __init__(TNEGraph self) -> TNEGraph         __init__(TNEGraph self, int const & Nodes, int const & Edges) -> TNEGraph          Parameters:             Nodes: int const &             Edges: int const &          __init__(TNEGraph self, TNEGraph Graph) -> TNEGraph          Parameters:             Graph: TNEGraph const &          __init__(TNEGraph self, TSIn SIn) -> TNEGraph          Parameters:             SIn: TSIn & Save(TNEGraph self, TSOut SOut)          Parameters:             SOut: TSOut & New() -> PNEGraph         New(int const & Nodes, int const & Edges) -> PNEGraph          Parameters:             Nodes: int const &             Edges: int const & Load(TSIn SIn) -> PNEGraph          Parameters:             SIn: TSIn & HasFlag(TNEGraph self, TGraphFlag const & Flag) -> bool          Parameters:             Flag: TGraphFlag const & GetNodes(TNEGraph self) -> int          Parameters:             self: TNEGraph const * AddNode(TNEGraph self, int NId=-1) -> int          Parameters:             NId: int          AddNode(TNEGraph self) -> int         AddNode(TNEGraph self, TNEGraph::TNodeI const & NodeId) -> int          Parameters:             NodeId: TNEGraph::TNodeI const & DelNode(TNEGraph self, int const & NId)          Parameters:             NId: int const &          DelNode(TNEGraph self, TNEGraph::TNode const & NodeI)          Parameters:             NodeI: TNEGraph::TNode const & IsNode(TNEGraph self, int const & NId) -> bool          Parameters:             NId: int const & BegNI(TNEGraph self) -> TNEGraph::TNodeI          Parameters:             self: TNEGraph const * EndNI(TNEGraph self) -> TNEGraph::TNodeI          Parameters:             self: TNEGraph const * GetNI(TNEGraph self, int const & NId) -> TNEGraph::TNodeI          Parameters:             NId: int const & GetMxNId(TNEGraph self) -> int          Parameters:             self: TNEGraph const * GetEdges(TNEGraph self) -> int          Parameters:             self: TNEGraph const * AddEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int EId=-1) -> int          Parameters:             SrcNId: int const &             DstNId: int const &             EId: int          AddEdge(TNEGraph self, int const & SrcNId, int const & DstNId) -> int          Parameters:             SrcNId: int const &             DstNId: int const &          AddEdge(TNEGraph self, TNEGraph::TEdgeI const & EdgeI) -> int          Parameters:             EdgeI: TNEGraph::TEdgeI const & DelEdge(TNEGraph self, int const & EId)          Parameters:             EId: int const &          DelEdge(TNEGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)          Parameters:             SrcNId: int const &             DstNId: int const &             IsDir: bool const &          DelEdge(TNEGraph self, int const & SrcNId, int const & DstNId)          Parameters:             SrcNId: int const &             DstNId: int const & IsEdge(TNEGraph self, int const & EId) -> bool          Parameters:             EId: int const &          IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             IsDir: bool const &          IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &          IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             EId: int &             IsDir: bool const &          IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int & EId) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             EId: int & GetEId(TNEGraph self, int const & SrcNId, int const & DstNId) -> int          Parameters:             SrcNId: int const &             DstNId: int const & BegEI(TNEGraph self) -> TNEGraph::TEdgeI          Parameters:             self: TNEGraph const * EndEI(TNEGraph self) -> TNEGraph::TEdgeI          Parameters:             self: TNEGraph const * GetEI(TNEGraph self, int const & EId) -> TNEGraph::TEdgeI          Parameters:             EId: int const &          GetEI(TNEGraph self, int const & SrcNId, int const & DstNId) -> TNEGraph::TEdgeI          Parameters:             SrcNId: int const &             DstNId: int const & GetRndNId(TNEGraph self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndNId(TNEGraph self) -> int          Parameters:             self: TNEGraph * GetRndNI(TNEGraph self, TRnd Rnd=Rnd) -> TNEGraph::TNodeI          Parameters:             Rnd: TRnd &          GetRndNI(TNEGraph self) -> TNEGraph::TNodeI          Parameters:             self: TNEGraph * GetRndEId(TNEGraph self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndEId(TNEGraph self) -> int          Parameters:             self: TNEGraph * GetRndEI(TNEGraph self, TRnd Rnd=Rnd) -> TNEGraph::TEdgeI          Parameters:             Rnd: TRnd &          GetRndEI(TNEGraph self) -> TNEGraph::TEdgeI          Parameters:             self: TNEGraph * GetNIdV(TNEGraph self, TIntV NIdV)          Parameters:             NIdV: TIntV & GetEIdV(TNEGraph self, TIntV EIdV)          Parameters:             EIdV: TIntV & Empty(TNEGraph self) -> bool          Parameters:             self: TNEGraph const * Clr(TNEGraph self)          Parameters:             self: TNEGraph * Reserve(TNEGraph self, int const & Nodes, int const & Edges)          Parameters:             Nodes: int const &             Edges: int const & Defrag(TNEGraph self, bool const & OnlyNodeLinks=False)          Parameters:             OnlyNodeLinks: bool const &          Defrag(TNEGraph self)          Parameters:             self: TNEGraph * IsOk(TNEGraph self, bool const & ThrowExcept=True) -> bool          Parameters:             ThrowExcept: bool const &          IsOk(TNEGraph self) -> bool          Parameters:             self: TNEGraph const * Dump(TNEGraph self, FILE * OutF=stdout)          Parameters:             OutF: FILE *          Dump(TNEGraph self)          Parameters:             self: TNEGraph const * New() -> PNEGraph     TNEGraph_New(int const & Nodes, int const & Edges) -> PNEGraph      Parameters:         Nodes: int const &         Edges: int const & TNEGraph_Load(TSIn SIn) -> PNEGraph      Parameters:         SIn: TSIn & Proxy of C++ TBPGraph class __init__(TBPGraph self) -> TBPGraph         __init__(TBPGraph self, int const & Nodes, int const & Edges) -> TBPGraph          Parameters:             Nodes: int const &             Edges: int const &          __init__(TBPGraph self, TBPGraph BPGraph) -> TBPGraph          Parameters:             BPGraph: TBPGraph const &          __init__(TBPGraph self, TSIn SIn) -> TBPGraph          Parameters:             SIn: TSIn & Save(TBPGraph self, TSOut SOut)          Parameters:             SOut: TSOut & New() -> PBPGraph         New(int const & Nodes, int const & Edges) -> PBPGraph          Parameters:             Nodes: int const &             Edges: int const & Load(TSIn SIn) -> PBPGraph          Parameters:             SIn: TSIn & GetNodes(TBPGraph self) -> int          Parameters:             self: TBPGraph const * GetLNodes(TBPGraph self) -> int          Parameters:             self: TBPGraph const * GetRNodes(TBPGraph self) -> int          Parameters:             self: TBPGraph const * AddNode(TBPGraph self, int NId=-1, bool const & LeftNode=True) -> int          Parameters:             NId: int             LeftNode: bool const &          AddNode(TBPGraph self, int NId=-1) -> int          Parameters:             NId: int          AddNode(TBPGraph self) -> int         AddNode(TBPGraph self, TBPGraph::TNodeI const & NodeI) -> int          Parameters:             NodeI: TBPGraph::TNodeI const & DelNode(TBPGraph self, int const & NId)          Parameters:             NId: int const &          DelNode(TBPGraph self, TBPGraph::TNode const & NodeI)          Parameters:             NodeI: TBPGraph::TNode const & IsNode(TBPGraph self, int const & NId) -> bool          Parameters:             NId: int const & IsLNode(TBPGraph self, int const & NId) -> bool          Parameters:             NId: int const & IsRNode(TBPGraph self, int const & NId) -> bool          Parameters:             NId: int const & GetMxNId(TBPGraph self) -> int          Parameters:             self: TBPGraph const * BegNI(TBPGraph self) -> TBPGraph::TNodeI          Parameters:             self: TBPGraph const * EndNI(TBPGraph self) -> TBPGraph::TNodeI          Parameters:             self: TBPGraph const * GetNI(TBPGraph self, int const & NId) -> TBPGraph::TNodeI          Parameters:             NId: int const & BegLNI(TBPGraph self) -> TBPGraph::TNodeI          Parameters:             self: TBPGraph const * EndLNI(TBPGraph self) -> TBPGraph::TNodeI          Parameters:             self: TBPGraph const * BegRNI(TBPGraph self) -> TBPGraph::TNodeI          Parameters:             self: TBPGraph const * EndRNI(TBPGraph self) -> TBPGraph::TNodeI          Parameters:             self: TBPGraph const * GetEdges(TBPGraph self) -> int          Parameters:             self: TBPGraph const * AddEdge(TBPGraph self, int const & LeftNId, int const & RightNId) -> int          Parameters:             LeftNId: int const &             RightNId: int const &          AddEdge(TBPGraph self, TBPGraph::TEdgeI const & EdgeI) -> int          Parameters:             EdgeI: TBPGraph::TEdgeI const & DelEdge(TBPGraph self, int const & LeftNId, int const & RightNId)          Parameters:             LeftNId: int const &             RightNId: int const & IsEdge(TBPGraph self, int const & LeftNId, int const & RightNId) -> bool          Parameters:             LeftNId: int const &             RightNId: int const & BegEI(TBPGraph self) -> TBPGraph::TEdgeI          Parameters:             self: TBPGraph const * EndEI(TBPGraph self) -> TBPGraph::TEdgeI          Parameters:             self: TBPGraph const * GetEI(TBPGraph self, int const & LeftNId, int const & RightNId) -> TBPGraph::TEdgeI          Parameters:             LeftNId: int const &             RightNId: int const & GetRndNId(TBPGraph self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndNId(TBPGraph self) -> int          Parameters:             self: TBPGraph * GetRndLNId(TBPGraph self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndLNId(TBPGraph self) -> int          Parameters:             self: TBPGraph * GetRndRNId(TBPGraph self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndRNId(TBPGraph self) -> int          Parameters:             self: TBPGraph * GetRndNI(TBPGraph self, TRnd Rnd=Rnd) -> TBPGraph::TNodeI          Parameters:             Rnd: TRnd &          GetRndNI(TBPGraph self) -> TBPGraph::TNodeI          Parameters:             self: TBPGraph * GetNIdV(TBPGraph self, TIntV NIdV)          Parameters:             NIdV: TIntV & GetLNIdV(TBPGraph self, TIntV NIdV)          Parameters:             NIdV: TIntV & GetRNIdV(TBPGraph self, TIntV NIdV)          Parameters:             NIdV: TIntV & Empty(TBPGraph self) -> bool          Parameters:             self: TBPGraph const * Clr(TBPGraph self)          Parameters:             self: TBPGraph * Reserve(TBPGraph self, int const & Nodes, int const & Edges)          Parameters:             Nodes: int const &             Edges: int const & Defrag(TBPGraph self, bool const & OnlyNodeLinks=False)          Parameters:             OnlyNodeLinks: bool const &          Defrag(TBPGraph self)          Parameters:             self: TBPGraph * IsOk(TBPGraph self, bool const & ThrowExcept=True) -> bool          Parameters:             ThrowExcept: bool const &          IsOk(TBPGraph self) -> bool          Parameters:             self: TBPGraph const * Dump(TBPGraph self, FILE * OutF=stdout)          Parameters:             OutF: FILE *          Dump(TBPGraph self)          Parameters:             self: TBPGraph const * GetSmallGraph() -> PBPGraph New() -> PBPGraph     TBPGraph_New(int const & Nodes, int const & Edges) -> PBPGraph      Parameters:         Nodes: int const &         Edges: int const & TBPGraph_Load(TSIn SIn) -> PBPGraph      Parameters:         SIn: TSIn & TBPGraph_GetSmallGraph() -> PBPGraph Proxy of C++ TNGraphMtx class __init__(TNGraphMtx self, PNGraph const & GraphPt) -> TNGraphMtx          Parameters:             GraphPt: PNGraph const &          __init__(TNGraphMtx self, TNGraphMtx GraphMtx) -> TNGraphMtx          Parameters:             GraphMtx: TNGraphMtx const & PGetRows(TNGraphMtx self) -> int          Parameters:             self: TNGraphMtx const * PGetCols(TNGraphMtx self) -> int          Parameters:             self: TNGraphMtx const * PMultiply(TNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)          Parameters:             B: TFltVV const &             ColId: int             Result: TFltV &          PMultiply(TNGraphMtx self, TFltV const & Vec, TFltV & Result)          Parameters:             Vec: TFltV const &             Result: TFltV & PMultiplyT(TNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)          Parameters:             B: TFltVV const &             ColId: int             Result: TFltV &          PMultiplyT(TNGraphMtx self, TFltV const & Vec, TFltV & Result)          Parameters:             Vec: TFltV const &             Result: TFltV & Proxy of C++ TUNGraphMtx class __init__(TUNGraphMtx self, PUNGraph const & GraphPt) -> TUNGraphMtx          Parameters:             GraphPt: PUNGraph const &          __init__(TUNGraphMtx self, TUNGraphMtx GraphMtx) -> TUNGraphMtx          Parameters:             GraphMtx: TUNGraphMtx const & PGetRows(TUNGraphMtx self) -> int          Parameters:             self: TUNGraphMtx const * PGetCols(TUNGraphMtx self) -> int          Parameters:             self: TUNGraphMtx const * PMultiply(TUNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)          Parameters:             B: TFltVV const &             ColId: int             Result: TFltV &          PMultiply(TUNGraphMtx self, TFltV const & Vec, TFltV & Result)          Parameters:             Vec: TFltV const &             Result: TFltV & PMultiplyT(TUNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result)          Parameters:             B: TFltVV const &             ColId: int             Result: TFltV &          PMultiplyT(TUNGraphMtx self, TFltV const & Vec, TFltV & Result)          Parameters:             Vec: TFltV const &             Result: TFltV & GetSngVals(PNGraph const & Graph, int const & SngVals, TFltV & SngValV)      Parameters:         Graph: PNGraph const &         SngVals: int const &         SngValV: TFltV & GetSngVec(PNGraph const & Graph, TFltV & LeftSV, TFltV & RightSV)      Parameters:         Graph: PNGraph const &         LeftSV: TFltV &         RightSV: TFltV &      GetSngVec(PNGraph const & Graph, int const & SngVecs, TFltV & SngValV, TVec< TFltV > & LeftSV,          TVec< TFltV > & RightSV)      Parameters:         Graph: PNGraph const &         SngVecs: int const &         SngValV: TFltV &         LeftSV: TVec< TFltV > &         RightSV: TVec< TFltV > & GetEigVals(PUNGraph const & Graph, int const & EigVals, TFltV & EigValV)      Parameters:         Graph: PUNGraph const &         EigVals: int const &         EigValV: TFltV & GetEigVec(PUNGraph const & Graph, TFltV & EigVecV)      Parameters:         Graph: PUNGraph const &         EigVecV: TFltV &      GetEigVec(PUNGraph const & Graph, int const & EigVecs, TFltV & EigValV, TVec< TFltV > & EigVecV)      Parameters:         Graph: PUNGraph const &         EigVecs: int const &         EigValV: TFltV &         EigVecV: TVec< TFltV > & GetInvParticipRat(PUNGraph const & Graph, int MaxEigVecs, int TimeLimit, TFltPrV & EigValIprV)      Parameters:         Graph: PUNGraph const &         MaxEigVecs: int         TimeLimit: int         EigValIprV: TFltPrV & GetInvParticipRatEig(TFltV const & EigVec) -> double      Parameters:         EigVec: TFltV const & LoadDyNet(TStr FNm) -> PNGraph      Parameters:         FNm: TStr const & LoadDyNetGraphV(TStr FNm) -> TVec< PNGraph >      Parameters:         FNm: TStr const & GVizDoLayout(TStr GraphInFNm, TStr OutFNm, TGVizLayout const & Layout)      Parameters:         GraphInFNm: TStr const &         OutFNm: TStr         Layout: TGVizLayout const & GVizGetLayoutStr(TGVizLayout const & Layout) -> TStr      Parameters:         Layout: TGVizLayout const & Proxy of C++ TBigStrPool class __init__(TBigStrPool self, TSize MxBfLen=0, uint _GrowBy=16*1024*1024) -> TBigStrPool          Parameters:             MxBfLen: TSize             _GrowBy: uint          __init__(TBigStrPool self, TSize MxBfLen=0) -> TBigStrPool          Parameters:             MxBfLen: TSize          __init__(TBigStrPool self) -> TBigStrPool         __init__(TBigStrPool self, TSIn SIn, bool LoadCompact=True) -> TBigStrPool          Parameters:             SIn: TSIn &             LoadCompact: bool          __init__(TBigStrPool self, TSIn SIn) -> TBigStrPool          Parameters:             SIn: TSIn &          __init__(TBigStrPool self, TBigStrPool Pool) -> TBigStrPool          Parameters:             Pool: TBigStrPool const & New(TSize _MxBfLen=0, uint _GrowBy=16*1024*1024) -> PBigStrPool          Parameters:             _MxBfLen: TSize             _GrowBy: uint          New(TSize _MxBfLen=0) -> PBigStrPool          Parameters:             _MxBfLen: TSize          New() -> PBigStrPool         New(TSIn SIn) -> PBigStrPool          Parameters:             SIn: TSIn &          New(TStr fileName) -> PBigStrPool          Parameters:             fileName: TStr const & Load(TSIn SIn, bool LoadCompacted=True) -> PBigStrPool          Parameters:             SIn: TSIn &             LoadCompacted: bool          Load(TSIn SIn) -> PBigStrPool          Parameters:             SIn: TSIn & Save(TBigStrPool self, TSOut SOut)          Parameters:             SOut: TSOut &          Save(TBigStrPool self, TStr fileName)          Parameters:             fileName: TStr const & GetStrs(TBigStrPool self) -> int          Parameters:             self: TBigStrPool const * Len(TBigStrPool self) -> TSize          Parameters:             self: TBigStrPool const * Size(TBigStrPool self) -> TSize          Parameters:             self: TBigStrPool const * Empty(TBigStrPool self) -> bool          Parameters:             self: TBigStrPool const * __call__(TBigStrPool self) -> char *          Parameters:             self: TBigStrPool const * AddStr(TBigStrPool self, char const * Str, uint Len) -> int          Parameters:             Str: char const *             Len: uint          AddStr(TBigStrPool self, char const * Str) -> int          Parameters:             Str: char const *          AddStr(TBigStrPool self, TStr Str) -> int          Parameters:             Str: TStr const & GetCStr(TBigStrPool self, int const & StrId) -> char const *          Parameters:             StrId: int const & GetStrFromOffset(TBigStrPool self, TSize const & Offset) -> TStr          Parameters:             Offset: TSize const & GetCStrFromOffset(TBigStrPool self, TSize const & Offset) -> char const *          Parameters:             Offset: TSize const & Clr(TBigStrPool self, bool DoDel=False)          Parameters:             DoDel: bool          Clr(TBigStrPool self)          Parameters:             self: TBigStrPool * Cmp(TBigStrPool self, int const & StrId, char const * Str) -> int          Parameters:             StrId: int const &             Str: char const * GetPrimHashCd(TBigStrPool self, char const * CStr) -> int          Parameters:             CStr: char const *          GetPrimHashCd(TBigStrPool self, int const & StrId) -> int          Parameters:             StrId: int const & GetSecHashCd(TBigStrPool self, char const * CStr) -> int          Parameters:             CStr: char const *          GetSecHashCd(TBigStrPool self, int const & StrId) -> int          Parameters:             StrId: int const & New(TSize _MxBfLen=0, uint _GrowBy=16*1024*1024) -> PBigStrPool      Parameters:         _MxBfLen: TSize         _GrowBy: uint      New(TSize _MxBfLen=0) -> PBigStrPool      Parameters:         _MxBfLen: TSize      New() -> PBigStrPool     New(TSIn SIn) -> PBigStrPool      Parameters:         SIn: TSIn &      TBigStrPool_New(TStr fileName) -> PBigStrPool      Parameters:         fileName: TStr const & Load(TSIn SIn, bool LoadCompacted=True) -> PBigStrPool      Parameters:         SIn: TSIn &         LoadCompacted: bool      TBigStrPool_Load(TSIn SIn) -> PBigStrPool      Parameters:         SIn: TSIn & Proxy of C++ TStrHashF_OldGLib class GetPrimHashCd(char const * p) -> int          Parameters:             p: char const *          GetPrimHashCd(TStr s) -> int          Parameters:             s: TStr const & GetSecHashCd(char const * p) -> int          Parameters:             p: char const *          GetSecHashCd(TStr s) -> int          Parameters:             s: TStr const & __init__(TStrHashF_OldGLib self) -> TStrHashF_OldGLib GetPrimHashCd(char const * p) -> int      Parameters:         p: char const *      TStrHashF_OldGLib_GetPrimHashCd(TStr s) -> int      Parameters:         s: TStr const & GetSecHashCd(char const * p) -> int      Parameters:         p: char const *      TStrHashF_OldGLib_GetSecHashCd(TStr s) -> int      Parameters:         s: TStr const & Proxy of C++ TStrHashF_Md5 class GetPrimHashCd(char const * p) -> int          Parameters:             p: char const *          GetPrimHashCd(TStr s) -> int          Parameters:             s: TStr const & GetSecHashCd(char const * p) -> int          Parameters:             p: char const *          GetSecHashCd(TStr s) -> int          Parameters:             s: TStr const & __init__(TStrHashF_Md5 self) -> TStrHashF_Md5 GetPrimHashCd(char const * p) -> int      Parameters:         p: char const *      TStrHashF_Md5_GetPrimHashCd(TStr s) -> int      Parameters:         s: TStr const & GetSecHashCd(char const * p) -> int      Parameters:         p: char const *      TStrHashF_Md5_GetSecHashCd(TStr s) -> int      Parameters:         s: TStr const & Proxy of C++ TStrHashF_DJB class GetPrimHashCd(char const * p) -> int          Parameters:             p: char const *          GetPrimHashCd(TStr s) -> int          Parameters:             s: TStr const & GetSecHashCd(char const * p) -> int          Parameters:             p: char const *          GetSecHashCd(TStr s) -> int          Parameters:             s: TStr const & __init__(TStrHashF_DJB self) -> TStrHashF_DJB GetPrimHashCd(char const * p) -> int      Parameters:         p: char const *      TStrHashF_DJB_GetPrimHashCd(TStr s) -> int      Parameters:         s: TStr const & GetSecHashCd(char const * p) -> int      Parameters:         p: char const *      TStrHashF_DJB_GetSecHashCd(TStr s) -> int      Parameters:         s: TStr const & GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges, TRnd Rnd=Rnd) -> PBPGraph      Parameters:         LeftNodes: int const &         RightNodes: int const &         Edges: int const &         Rnd: TRnd &      GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges) -> PBPGraph      Parameters:         LeftNodes: int const &         RightNodes: int const &         Edges: int const & GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph      Parameters:         Nodes: int const &         NodeDeg: int const &         NSwitch: int const &         Rnd: TRnd &      GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100) -> PUNGraph      Parameters:         Nodes: int const &         NodeDeg: int const &         NSwitch: int const &      GenRndDegK(int const & Nodes, int const & NodeDeg) -> PUNGraph      Parameters:         Nodes: int const &         NodeDeg: int const & GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True, TRnd Rnd=Rnd) -> PUNGraph      Parameters:         Nodes: int const &         PowerExp: double const &         ConfModel: bool const &         Rnd: TRnd &      GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True) -> PUNGraph      Parameters:         Nodes: int const &         PowerExp: double const &         ConfModel: bool const &      GenRndPowerLaw(int const & Nodes, double const & PowerExp) -> PUNGraph      Parameters:         Nodes: int const &         PowerExp: double const & GenDegSeq(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph      Parameters:         DegSeqV: TIntV const &         Rnd: TRnd &      GenDegSeq(TIntV DegSeqV) -> PUNGraph      Parameters:         DegSeqV: TIntV const & GenPrefAttach(int const & Nodes, int const & NodeOutDeg, TRnd Rnd=Rnd) -> PUNGraph      Parameters:         Nodes: int const &         NodeOutDeg: int const &         Rnd: TRnd &      GenPrefAttach(int const & Nodes, int const & NodeOutDeg) -> PUNGraph      Parameters:         Nodes: int const &         NodeOutDeg: int const & GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta, TRnd Rnd=Rnd) -> PUNGraph      Parameters:         Nodes: int const &         OutDeg: int const &         Beta: double const &         Rnd: TRnd &      GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta) -> PUNGraph      Parameters:         Nodes: int const &         OutDeg: int const &         Beta: double const & GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb, TRnd Rnd=Rnd) -> PUNGraph      Parameters:         Nodes: int const &         NodeOutDeg: int const &         RewireProb: double const &         Rnd: TRnd &      GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb) -> PUNGraph      Parameters:         Nodes: int const &         NodeOutDeg: int const &         RewireProb: double const & GenForestFire(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph      Parameters:         Nodes: int const &         FwdProb: double const &         BckProb: double const & GenCopyModel(int const & Nodes, double const & Beta, TRnd Rnd=Rnd) -> PNGraph      Parameters:         Nodes: int const &         Beta: double const &         Rnd: TRnd &      GenCopyModel(int const & Nodes, double const & Beta) -> PNGraph      Parameters:         Nodes: int const &         Beta: double const & GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C,          TRnd Rnd=Rnd) -> PNGraph      Parameters:         Nodes: int const &         Edges: int const &         A: double const &         B: double const &         C: double const &         Rnd: TRnd &      GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C) -> PNGraph      Parameters:         Nodes: int const &         Edges: int const &         A: double const &         B: double const &         C: double const & GenRMatEpinions() -> PNGraph GenRewire(PUNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph      Parameters:         Graph: PUNGraph const &         NSwitch: int const &         Rnd: TRnd &      GenRewire(PUNGraph const & Graph, int const & NSwitch=100) -> PUNGraph      Parameters:         Graph: PUNGraph const &         NSwitch: int const &      GenRewire(PUNGraph const & Graph) -> PUNGraph      Parameters:         Graph: PUNGraph const &      GenRewire(PNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PNGraph      Parameters:         Graph: PNGraph const &         NSwitch: int const &         Rnd: TRnd &      GenRewire(PNGraph const & Graph, int const & NSwitch=100) -> PNGraph      Parameters:         Graph: PNGraph const &         NSwitch: int const &      GenRewire(PNGraph const & Graph) -> PNGraph      Parameters:         Graph: PNGraph const &      GenRewire(PBPGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PBPGraph      Parameters:         Graph: PBPGraph const &         NSwitch: int const &         Rnd: TRnd &      GenRewire(PBPGraph const & Graph, int const & NSwitch=100) -> PBPGraph      Parameters:         Graph: PBPGraph const &         NSwitch: int const &      GenRewire(PBPGraph const & Graph) -> PBPGraph      Parameters:         Graph: PBPGraph const & GenConfModel(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph      Parameters:         DegSeqV: TIntV const &         Rnd: TRnd &      GenConfModel(TIntV DegSeqV) -> PUNGraph      Parameters:         DegSeqV: TIntV const &      GenConfModel(PUNGraph const & G) -> PUNGraph      Parameters:         G: PUNGraph const & GetSubGraph(PUNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PUNGraph      Parameters:         Graph: PUNGraph const &         NIdV: TIntV const &         RenumberNodes: bool const &      GetSubGraph(PUNGraph const & Graph, TIntV NIdV) -> PUNGraph      Parameters:         Graph: PUNGraph const &         NIdV: TIntV const &      GetSubGraph(PNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PNGraph      Parameters:         Graph: PNGraph const &         NIdV: TIntV const &         RenumberNodes: bool const &      GetSubGraph(PNGraph const & Graph, TIntV NIdV) -> PNGraph      Parameters:         Graph: PNGraph const &         NIdV: TIntV const & Proxy of C++ TGUtil class GetCdf(TIntPrV const & PdfV, TIntPrV & CdfV)          Parameters:             PdfV: TIntPrV const &             CdfV: TIntPrV &          GetCdf(TFltPrV const & PdfV, TFltPrV & CdfV)          Parameters:             PdfV: TFltPrV const &             CdfV: TFltPrV &          GetCdf(TIntFltKdV const & PdfV, TIntFltKdV & CdfV)          Parameters:             PdfV: TIntFltKdV const &             CdfV: TIntFltKdV &          GetCdf(TIntPrV const & PdfV) -> TIntPrV          Parameters:             PdfV: TIntPrV const &          GetCdf(TFltPrV const & PdfV) -> TFltPrV          Parameters:             PdfV: TFltPrV const & GetCCdf(TIntPrV const & PdfV, TIntPrV & CCdfV)          Parameters:             PdfV: TIntPrV const &             CCdfV: TIntPrV &          GetCCdf(TFltPrV const & PdfV, TFltPrV & CCdfV)          Parameters:             PdfV: TFltPrV const &             CCdfV: TFltPrV &          GetCCdf(TIntFltKdV const & PdfV, TIntFltKdV & CCdfV)          Parameters:             PdfV: TIntFltKdV const &             CCdfV: TIntFltKdV &          GetCCdf(TIntPrV const & PdfV) -> TIntPrV          Parameters:             PdfV: TIntPrV const &          GetCCdf(TFltPrV const & PdfV) -> TFltPrV          Parameters:             PdfV: TFltPrV const & GetPdf(TIntPrV const & CdfV, TIntPrV & PdfV)          Parameters:             CdfV: TIntPrV const &             PdfV: TIntPrV &          GetPdf(TFltPrV const & CdfV, TFltPrV & PdfV)          Parameters:             CdfV: TFltPrV const &             PdfV: TFltPrV &          GetPdf(TIntFltKdV const & CdfV, TIntFltKdV & PdfV)          Parameters:             CdfV: TIntFltKdV const &             PdfV: TIntFltKdV & Normalize(TFltPrV & PdfV)          Parameters:             PdfV: TFltPrV &          Normalize(TIntFltKdV & PdfV)          Parameters:             PdfV: TIntFltKdV & MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)          Parameters:             XYValV: TFltPrV const &             ExpXYValV: TFltPrV &             BinFactor: double const &             MinYVal: double const &          MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2)          Parameters:             XYValV: TFltPrV const &             ExpXYValV: TFltPrV &             BinFactor: double const &          MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV)          Parameters:             XYValV: TFltPrV const &             ExpXYValV: TFltPrV &          MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)          Parameters:             XYValV: TFltKdV const &             ExpXYValV: TFltKdV &             BinFactor: double const &             MinYVal: double const &          MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2)          Parameters:             XYValV: TFltKdV const &             ExpXYValV: TFltKdV &             BinFactor: double const &          MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV)          Parameters:             XYValV: TFltKdV const &             ExpXYValV: TFltKdV &          MakeExpBins(TFltV const & YValV, TFltV & ExpYValV, double const & BinFactor=1.01)          Parameters:             YValV: TFltV const &             ExpYValV: TFltV &             BinFactor: double const &          MakeExpBins(TFltV const & YValV, TFltV & ExpYValV)          Parameters:             YValV: TFltV const &             ExpYValV: TFltV &          MakeExpBins(TIntV YValV, TIntV ExpYValV, double const & BinFactor=1.01)          Parameters:             YValV: TIntV const &             ExpYValV: TIntV &             BinFactor: double const &          MakeExpBins(TIntV YValV, TIntV ExpYValV)          Parameters:             YValV: TIntV const &             ExpYValV: TIntV & __init__(TGUtil self) -> TGUtil GetCdf(TIntPrV const & PdfV, TIntPrV & CdfV)      Parameters:         PdfV: TIntPrV const &         CdfV: TIntPrV &      GetCdf(TFltPrV const & PdfV, TFltPrV & CdfV)      Parameters:         PdfV: TFltPrV const &         CdfV: TFltPrV &      GetCdf(TIntFltKdV const & PdfV, TIntFltKdV & CdfV)      Parameters:         PdfV: TIntFltKdV const &         CdfV: TIntFltKdV &      GetCdf(TIntPrV const & PdfV) -> TIntPrV      Parameters:         PdfV: TIntPrV const &      TGUtil_GetCdf(TFltPrV const & PdfV) -> TFltPrV      Parameters:         PdfV: TFltPrV const & GetCCdf(TIntPrV const & PdfV, TIntPrV & CCdfV)      Parameters:         PdfV: TIntPrV const &         CCdfV: TIntPrV &      GetCCdf(TFltPrV const & PdfV, TFltPrV & CCdfV)      Parameters:         PdfV: TFltPrV const &         CCdfV: TFltPrV &      GetCCdf(TIntFltKdV const & PdfV, TIntFltKdV & CCdfV)      Parameters:         PdfV: TIntFltKdV const &         CCdfV: TIntFltKdV &      GetCCdf(TIntPrV const & PdfV) -> TIntPrV      Parameters:         PdfV: TIntPrV const &      TGUtil_GetCCdf(TFltPrV const & PdfV) -> TFltPrV      Parameters:         PdfV: TFltPrV const & GetPdf(TIntPrV const & CdfV, TIntPrV & PdfV)      Parameters:         CdfV: TIntPrV const &         PdfV: TIntPrV &      GetPdf(TFltPrV const & CdfV, TFltPrV & PdfV)      Parameters:         CdfV: TFltPrV const &         PdfV: TFltPrV &      TGUtil_GetPdf(TIntFltKdV const & CdfV, TIntFltKdV & PdfV)      Parameters:         CdfV: TIntFltKdV const &         PdfV: TIntFltKdV & Normalize(TFltPrV & PdfV)      Parameters:         PdfV: TFltPrV &      TGUtil_Normalize(TIntFltKdV & PdfV)      Parameters:         PdfV: TIntFltKdV & MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)      Parameters:         XYValV: TFltPrV const &         ExpXYValV: TFltPrV &         BinFactor: double const &         MinYVal: double const &      MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2)      Parameters:         XYValV: TFltPrV const &         ExpXYValV: TFltPrV &         BinFactor: double const &      MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV)      Parameters:         XYValV: TFltPrV const &         ExpXYValV: TFltPrV &      MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)      Parameters:         XYValV: TFltKdV const &         ExpXYValV: TFltKdV &         BinFactor: double const &         MinYVal: double const &      MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2)      Parameters:         XYValV: TFltKdV const &         ExpXYValV: TFltKdV &         BinFactor: double const &      MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV)      Parameters:         XYValV: TFltKdV const &         ExpXYValV: TFltKdV &      MakeExpBins(TFltV const & YValV, TFltV & ExpYValV, double const & BinFactor=1.01)      Parameters:         YValV: TFltV const &         ExpYValV: TFltV &         BinFactor: double const &      MakeExpBins(TFltV const & YValV, TFltV & ExpYValV)      Parameters:         YValV: TFltV const &         ExpYValV: TFltV &      MakeExpBins(TIntV YValV, TIntV ExpYValV, double const & BinFactor=1.01)      Parameters:         YValV: TIntV const &         ExpYValV: TIntV &         BinFactor: double const &      TGUtil_MakeExpBins(TIntV YValV, TIntV ExpYValV)      Parameters:         YValV: TIntV const &         ExpYValV: TIntV & Proxy of C++ TStrUtil class GetXmlTagVal(TXmlLx & XmlLx, TChA TagNm) -> TChA          Parameters:             XmlLx: TXmlLx &             TagNm: TChA const & GetXmlTagNmVal(TXmlLx & XmlLx, TChA TagNm, TChA TagVal)          Parameters:             XmlLx: TXmlLx &             TagNm: TChA &             TagVal: TChA & GetXmlTagNmVal2(TXmlLx & XmlLx, TChA TagNm, TChA TagVal, bool const & TakeTagNms) -> bool          Parameters:             XmlLx: TXmlLx &             TagNm: TChA &             TagVal: TChA &             TakeTagNms: bool const & GetDomNm(TChA UrlChA) -> TChA          Parameters:             UrlChA: TChA const & GetDomNm2(TChA UrlChA) -> TChA          Parameters:             UrlChA: TChA const & GetWebsiteNm(TChA UrlChA) -> TChA          Parameters:             UrlChA: TChA const & GetNormalizedUrl(TChA UrlIn, TChA BaseUrl, TChA UrlOut) -> bool          Parameters:             UrlIn: TChA const &             BaseUrl: TChA const &             UrlOut: TChA & StripEnd(TChA Str, TChA SearchStr, TChA NewStr) -> bool          Parameters:             Str: TChA const &             SearchStr: TChA const &             NewStr: TChA & GetShorStr(TChA LongStr, int const MaxLen=50) -> TChA          Parameters:             LongStr: TChA const &             MaxLen: int const          GetShorStr(TChA LongStr) -> TChA          Parameters:             LongStr: TChA const & GetCleanStr(TChA ChA) -> TChA          Parameters:             ChA: TChA const & GetCleanWrdStr(TChA ChA) -> TChA          Parameters:             ChA: TChA const & CountWords(char const * CStr) -> int          Parameters:             CStr: char const *          CountWords(TChA ChA) -> int          Parameters:             ChA: TChA const &          CountWords(TChA ChA, TStrHash< TInt > const & StopWordH) -> int          Parameters:             ChA: TChA const &             StopWordH: TStrHash< TInt > const & SplitWords(TChA ChA, TVec< char * > & WrdV, bool const & SplitOnWs=True) -> int          Parameters:             ChA: TChA &             WrdV: TVec< char * > &             SplitOnWs: bool const &          SplitWords(TChA ChA, TVec< char * > & WrdV) -> int          Parameters:             ChA: TChA &             WrdV: TVec< char * > & SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch, bool const & SkipEmpty=False) -> int          Parameters:             ChA: TChA &             WrdV: TVec< char * > &             Ch: char const &             SkipEmpty: bool const &          SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch) -> int          Parameters:             ChA: TChA &             WrdV: TVec< char * > &             Ch: char const & SplitLines(TChA ChA, TVec< char * > & LineV, bool const & SkipEmpty=False) -> int          Parameters:             ChA: TChA &             LineV: TVec< char * > &             SkipEmpty: bool const &          SplitLines(TChA ChA, TVec< char * > & LineV) -> int          Parameters:             ChA: TChA &             LineV: TVec< char * > & SplitSentences(TChA ChA, TVec< char * > & SentenceV) -> int          Parameters:             ChA: TChA &             SentenceV: TVec< char * > & RemoveHtmlTags(TChA HtmlStr, TChA TextStr)          Parameters:             HtmlStr: TChA const &             TextStr: TChA & IsLatinStr(TChA Str, double const & MinAlFrac) -> bool          Parameters:             Str: TChA const &             MinAlFrac: double const & GetWIdV(TStrHash< TInt > const & StrH, char const * CStr, TIntV WIdV)          Parameters:             StrH: TStrHash< TInt > const &             CStr: char const *             WIdV: TIntV & GetAddWIdV(TStrHash< TInt > & StrH, char const * CStr, TIntV WIdV)          Parameters:             StrH: TStrHash< TInt > &             CStr: char const *             WIdV: TIntV & GetTmFromStr(char const * TmStr, TSecTm & Tm) -> bool          Parameters:             TmStr: char const *             Tm: TSecTm & GetStdName(TStr AuthorName) -> TStr          Parameters:             AuthorName: TStr GetStdNameV(TStr AuthorNames, TStrV StdNameV)          Parameters:             AuthorNames: TStr             StdNameV: TStrV & __init__(TStrUtil self) -> TStrUtil TStrUtil_GetXmlTagVal(TXmlLx & XmlLx, TChA TagNm) -> TChA      Parameters:         XmlLx: TXmlLx &         TagNm: TChA const & TStrUtil_GetXmlTagNmVal(TXmlLx & XmlLx, TChA TagNm, TChA TagVal)      Parameters:         XmlLx: TXmlLx &         TagNm: TChA &         TagVal: TChA & TStrUtil_GetXmlTagNmVal2(TXmlLx & XmlLx, TChA TagNm, TChA TagVal, bool const & TakeTagNms) -> bool      Parameters:         XmlLx: TXmlLx &         TagNm: TChA &         TagVal: TChA &         TakeTagNms: bool const & TStrUtil_GetDomNm(TChA UrlChA) -> TChA      Parameters:         UrlChA: TChA const & TStrUtil_GetDomNm2(TChA UrlChA) -> TChA      Parameters:         UrlChA: TChA const & TStrUtil_GetWebsiteNm(TChA UrlChA) -> TChA      Parameters:         UrlChA: TChA const & TStrUtil_GetNormalizedUrl(TChA UrlIn, TChA BaseUrl, TChA UrlOut) -> bool      Parameters:         UrlIn: TChA const &         BaseUrl: TChA const &         UrlOut: TChA & TStrUtil_StripEnd(TChA Str, TChA SearchStr, TChA NewStr) -> bool      Parameters:         Str: TChA const &         SearchStr: TChA const &         NewStr: TChA & GetShorStr(TChA LongStr, int const MaxLen=50) -> TChA      Parameters:         LongStr: TChA const &         MaxLen: int const      TStrUtil_GetShorStr(TChA LongStr) -> TChA      Parameters:         LongStr: TChA const & TStrUtil_GetCleanStr(TChA ChA) -> TChA      Parameters:         ChA: TChA const & TStrUtil_GetCleanWrdStr(TChA ChA) -> TChA      Parameters:         ChA: TChA const & CountWords(char const * CStr) -> int      Parameters:         CStr: char const *      CountWords(TChA ChA) -> int      Parameters:         ChA: TChA const &      TStrUtil_CountWords(TChA ChA, TStrHash< TInt > const & StopWordH) -> int      Parameters:         ChA: TChA const &         StopWordH: TStrHash< TInt > const & SplitWords(TChA ChA, TVec< char * > & WrdV, bool const & SplitOnWs=True) -> int      Parameters:         ChA: TChA &         WrdV: TVec< char * > &         SplitOnWs: bool const &      TStrUtil_SplitWords(TChA ChA, TVec< char * > & WrdV) -> int      Parameters:         ChA: TChA &         WrdV: TVec< char * > & SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch, bool const & SkipEmpty=False) -> int      Parameters:         ChA: TChA &         WrdV: TVec< char * > &         Ch: char const &         SkipEmpty: bool const &      TStrUtil_SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch) -> int      Parameters:         ChA: TChA &         WrdV: TVec< char * > &         Ch: char const & SplitLines(TChA ChA, TVec< char * > & LineV, bool const & SkipEmpty=False) -> int      Parameters:         ChA: TChA &         LineV: TVec< char * > &         SkipEmpty: bool const &      TStrUtil_SplitLines(TChA ChA, TVec< char * > & LineV) -> int      Parameters:         ChA: TChA &         LineV: TVec< char * > & TStrUtil_SplitSentences(TChA ChA, TVec< char * > & SentenceV) -> int      Parameters:         ChA: TChA &         SentenceV: TVec< char * > & TStrUtil_RemoveHtmlTags(TChA HtmlStr, TChA TextStr)      Parameters:         HtmlStr: TChA const &         TextStr: TChA & TStrUtil_IsLatinStr(TChA Str, double const & MinAlFrac) -> bool      Parameters:         Str: TChA const &         MinAlFrac: double const & TStrUtil_GetWIdV(TStrHash< TInt > const & StrH, char const * CStr, TIntV WIdV)      Parameters:         StrH: TStrHash< TInt > const &         CStr: char const *         WIdV: TIntV & TStrUtil_GetAddWIdV(TStrHash< TInt > & StrH, char const * CStr, TIntV WIdV)      Parameters:         StrH: TStrHash< TInt > &         CStr: char const *         WIdV: TIntV & TStrUtil_GetTmFromStr(char const * TmStr, TSecTm & Tm) -> bool      Parameters:         TmStr: char const *         Tm: TSecTm & TStrUtil_GetStdName(TStr AuthorName) -> TStr      Parameters:         AuthorName: TStr TStrUtil_GetStdNameV(TStr AuthorNames, TStrV StdNameV)      Parameters:         AuthorNames: TStr         StdNameV: TStrV & Proxy of C++ TRnd class __init__(TRnd self, int const & _Seed=1, int const & Steps=0) -> TRnd          Parameters:             _Seed: int const &             Steps: int const &          __init__(TRnd self, int const & _Seed=1) -> TRnd          Parameters:             _Seed: int const &          __init__(TRnd self) -> TRnd         __init__(TRnd self, TSIn SIn) -> TRnd          Parameters:             SIn: TSIn & Save(TRnd self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TRnd self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TRnd self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TRnd self, TRnd arg2) -> bool          Parameters:             arg2: TRnd const & GetUniDev(TRnd self) -> double          Parameters:             self: TRnd * GetUniDevInt(TRnd self, int const & Range=0) -> int          Parameters:             Range: int const &          GetUniDevInt(TRnd self) -> int         GetUniDevInt(TRnd self, int const & MnVal, int const & MxVal) -> int          Parameters:             MnVal: int const &             MxVal: int const & GetUniDevUInt(TRnd self, uint const & Range=0) -> uint          Parameters:             Range: uint const &          GetUniDevUInt(TRnd self) -> uint          Parameters:             self: TRnd * GetUniDevInt64(TRnd self, int64 const & Range=0) -> int64          Parameters:             Range: int64 const &          GetUniDevInt64(TRnd self) -> int64          Parameters:             self: TRnd * GetUniDevUInt64(TRnd self, uint64 const & Range=0) -> uint64          Parameters:             Range: uint64 const &          GetUniDevUInt64(TRnd self) -> uint64          Parameters:             self: TRnd * GetNrmDev(TRnd self) -> double         GetNrmDev(TRnd self, double const & Mean, double const & SDev, double const & Mn, double const & Mx) -> double          Parameters:             Mean: double const &             SDev: double const &             Mn: double const &             Mx: double const & GetExpDev(TRnd self) -> double         GetExpDev(TRnd self, double const & Lambda) -> double          Parameters:             Lambda: double const & GetGammaDev(TRnd self, int const & Order) -> double          Parameters:             Order: int const & GetPoissonDev(TRnd self, double const & Mean) -> double          Parameters:             Mean: double const & GetBinomialDev(TRnd self, double const & Prb, int const & Trials) -> double          Parameters:             Prb: double const &             Trials: int const & GetGeoDev(TRnd self, double const & Prb) -> int          Parameters:             Prb: double const & GetPowerDev(TRnd self, double const & AlphaSlope) -> double          Parameters:             AlphaSlope: double const & GetRayleigh(TRnd self, double const & Sigma) -> double          Parameters:             Sigma: double const & GetWeibull(TRnd self, double const & K, double const & Lambda) -> double          Parameters:             K: double const &             Lambda: double const & PutSeed(TRnd self, int const & _Seed)          Parameters:             _Seed: int const & GetSeed(TRnd self) -> int          Parameters:             self: TRnd const * Randomize(TRnd self)          Parameters:             self: TRnd * Move(TRnd self, int const & Steps)          Parameters:             Steps: int const & Check(TRnd self) -> bool          Parameters:             self: TRnd * GetUniDevStep(int const & Seed, int const & Steps) -> double          Parameters:             Seed: int const &             Steps: int const & GetNrmDevStep(int const & Seed, int const & Steps) -> double          Parameters:             Seed: int const &             Steps: int const & GetExpDevStep(int const & Seed, int const & Steps) -> double          Parameters:             Seed: int const &             Steps: int const & LoadTxt(TILx & Lx) -> TRnd          Parameters:             Lx: TILx & SaveTxt(TRnd self, TOLx & Lx)          Parameters:             Lx: TOLx & TRnd_GetUniDevStep(int const & Seed, int const & Steps) -> double      Parameters:         Seed: int const &         Steps: int const & TRnd_GetNrmDevStep(int const & Seed, int const & Steps) -> double      Parameters:         Seed: int const &         Steps: int const & TRnd_GetExpDevStep(int const & Seed, int const & Steps) -> double      Parameters:         Seed: int const &         Steps: int const & TRnd_LoadTxt(TILx & Lx) -> TRnd      Parameters:         Lx: TILx & Proxy of C++ TMem class New(int const & MxBfL=0) -> PMem          Parameters:             MxBfL: int const &          New() -> PMem         New(void const * Bf, int const & BfL) -> PMem          Parameters:             Bf: void const *             BfL: int const &          New(TMem Mem) -> PMem          Parameters:             Mem: TMem const &          New(PMem const & Mem) -> PMem          Parameters:             Mem: PMem const &          New(TStr Str) -> PMem          Parameters:             Str: TStr const & __init__(TMem self, int const & _MxBfL=0) -> TMem          Parameters:             _MxBfL: int const &          __init__(TMem self) -> TMem         __init__(TMem self, void const * _Bf, int const & _BfL) -> TMem          Parameters:             _Bf: void const *             _BfL: int const &          __init__(TMem self, TMem Mem) -> TMem          Parameters:             Mem: TMem const &          __init__(TMem self, TStr Str) -> TMem          Parameters:             Str: TStr const &          __init__(TMem self, TSIn SIn) -> TMem          Parameters:             SIn: TSIn & Save(TMem self, TSOut SOut)          Parameters:             SOut: TSOut & SaveXml(TMem self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __call__(TMem self) -> char *          Parameters:             self: TMem const * __iadd__(TMem self, char const & Ch) -> TMem          Parameters:             Ch: char const &          __iadd__(TMem self, TMem Mem) -> TMem          Parameters:             Mem: TMem const &          __iadd__(TMem self, TStr Str) -> TMem          Parameters:             Str: TStr const &          __iadd__(TMem self, PSIn const & SIn) -> TMem          Parameters:             SIn: PSIn const & GetMemUsed(TMem self) -> int          Parameters:             self: TMem const * Gen(TMem self, int const & _BfL)          Parameters:             _BfL: int const & GenZeros(TMem self, int const & _BfL)          Parameters:             _BfL: int const & Reserve(TMem self, int const & _MxBfL, bool const & DoClr=True)          Parameters:             _MxBfL: int const &             DoClr: bool const &          Reserve(TMem self, int const & _MxBfL)          Parameters:             _MxBfL: int const & Del(TMem self, int const & BChN, int const & EChN)          Parameters:             BChN: int const &             EChN: int const & Clr(TMem self, bool const & DoDel=True)          Parameters:             DoDel: bool const &          Clr(TMem self)          Parameters:             self: TMem * Len(TMem self) -> int          Parameters:             self: TMem const * Empty(TMem self) -> bool          Parameters:             self: TMem const * Trunc(TMem self, int const & _BfL)          Parameters:             _BfL: int const & Push(TMem self, char const & Ch)          Parameters:             Ch: char const & Pop(TMem self) -> char          Parameters:             self: TMem * DoFitStr(TMem self, TStr Str) -> bool          Parameters:             Str: TStr const & AddBf(TMem self, void const * Bf, int const & BfL)          Parameters:             Bf: void const *             BfL: int const & GetBf(TMem self) -> char *          Parameters:             self: TMem const * GetAsStr(TMem self, char const & NewNullCh='\0') -> TStr          Parameters:             NewNullCh: char const &          GetAsStr(TMem self) -> TStr          Parameters:             self: TMem const * GetSIn(TMem self) -> PSIn          Parameters:             self: TMem const * LoadMem(PSIn const & SIn, TMem Mem)          Parameters:             SIn: PSIn const &             Mem: TMem &          LoadMem(PSIn const & SIn, PMem const & Mem)          Parameters:             SIn: PSIn const &             Mem: PMem const & SaveMem(TMem self, PSOut const & SOut)          Parameters:             SOut: PSOut const & New(int const & MxBfL=0) -> PMem      Parameters:         MxBfL: int const &      New() -> PMem     New(void const * Bf, int const & BfL) -> PMem      Parameters:         Bf: void const *         BfL: int const &      New(TMem Mem) -> PMem      Parameters:         Mem: TMem const &      New(PMem const & Mem) -> PMem      Parameters:         Mem: PMem const &      TMem_New(TStr Str) -> PMem      Parameters:         Str: TStr const & LoadMem(PSIn const & SIn, TMem Mem)      Parameters:         SIn: PSIn const &         Mem: TMem &      TMem_LoadMem(PSIn const & SIn, PMem const & Mem)      Parameters:         SIn: PSIn const &         Mem: PMem const & Proxy of C++ TMemIn class __init__(TMemIn self, TMem _Mem, int const & _BfC=0) -> TMemIn          Parameters:             _Mem: TMem const &             _BfC: int const &          __init__(TMemIn self, TMem _Mem) -> TMemIn          Parameters:             _Mem: TMem const & New(TMem Mem) -> PSIn          Parameters:             Mem: TMem const &          New(PMem const & Mem) -> PSIn          Parameters:             Mem: PMem const & New(TMem Mem) -> PSIn      Parameters:         Mem: TMem const &      TMemIn_New(PMem const & Mem) -> PSIn      Parameters:         Mem: PMem const & Proxy of C++ TMemOut class __init__(TMemOut self, PMem const & _Mem) -> TMemOut          Parameters:             _Mem: PMem const & New(PMem const & Mem) -> PSOut          Parameters:             Mem: PMem const & TMemOut_New(PMem const & Mem) -> PSOut      Parameters:         Mem: PMem const & Proxy of C++ TChA class __init__(TChA self, int const & _MxBfL=256) -> TChA          Parameters:             _MxBfL: int const &          __init__(TChA self) -> TChA         __init__(TChA self, char const * CStr) -> TChA          Parameters:             CStr: char const *          __init__(TChA self, char const * CStr, int const & StrLen) -> TChA          Parameters:             CStr: char const *             StrLen: int const &          __init__(TChA self, TChA ChA) -> TChA          Parameters:             ChA: TChA const &          __init__(TChA self, TStr Str) -> TChA          Parameters:             Str: TStr const &          __init__(TChA self, TMem Mem) -> TChA          Parameters:             Mem: TMem const &          __init__(TChA self, TSIn SIn) -> TChA          Parameters:             SIn: TSIn & Load(TChA self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TChA self, TSOut SOut, bool const & SaveCompact=True)          Parameters:             SOut: TSOut &             SaveCompact: bool const &          Save(TChA self, TSOut SOut)          Parameters:             SOut: TSOut & SaveXml(TChA self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TChA self, TChA ChA) -> bool          Parameters:             ChA: TChA const &          __eq__(TChA self, char const * _CStr) -> bool          Parameters:             _CStr: char const *          __eq__(TChA self, char const & Ch) -> bool          Parameters:             Ch: char const & __ne__(TChA self, TChA ChA) -> bool          Parameters:             ChA: TChA const &          __ne__(TChA self, char const * _CStr) -> bool          Parameters:             _CStr: char const *          __ne__(TChA self, char const & Ch) -> bool          Parameters:             Ch: char const & __lt__(TChA self, TChA ChA) -> bool          Parameters:             ChA: TChA const & __iadd__(TChA self, TMem Mem) -> TChA          Parameters:             Mem: TMem const &          __iadd__(TChA self, TChA ChA) -> TChA          Parameters:             ChA: TChA const &          __iadd__(TChA self, TStr Str) -> TChA          Parameters:             Str: TStr const &          __iadd__(TChA self, char const * CStr) -> TChA          Parameters:             CStr: char const *          __iadd__(TChA self, char const & Ch) -> TChA          Parameters:             Ch: char const & GetMemUsed(TChA self) -> int          Parameters:             self: TChA const * __call__(TChA self) -> char         __call__(TChA self) -> char const *          Parameters:             self: TChA const * CStr(TChA self) -> char         CStr(TChA self) -> char const *          Parameters:             self: TChA const * Clr(TChA self)          Parameters:             self: TChA * Len(TChA self) -> int          Parameters:             self: TChA const * Empty(TChA self) -> bool          Parameters:             self: TChA const * Ins(TChA self, int const & BChN, char const * CStr)          Parameters:             BChN: int const &             CStr: char const * Del(TChA self, int const & ChN)          Parameters:             ChN: int const & DelLastCh(TChA self)          Parameters:             self: TChA * Push(TChA self, char const & Ch)          Parameters:             Ch: char const & Pop(TChA self) -> char          Parameters:             self: TChA * Trunc(TChA self)         Trunc(TChA self, int const & _BfL)          Parameters:             _BfL: int const & Reverse(TChA self)          Parameters:             self: TChA * AddCh(TChA self, char const & Ch, int const & MxLen=-1)          Parameters:             Ch: char const &             MxLen: int const &          AddCh(TChA self, char const & Ch)          Parameters:             Ch: char const & AddChTo(TChA self, char const & Ch, int const & ToChN)          Parameters:             Ch: char const &             ToChN: int const & AddBf(TChA self, char * NewBf, int const & BfS)          Parameters:             NewBf: char *             BfS: int const & PutCh(TChA self, int const & ChN, char const & Ch)          Parameters:             ChN: int const &             Ch: char const & GetCh(TChA self, int const & ChN) -> char          Parameters:             ChN: int const & LastCh(TChA self) -> char          Parameters:             self: TChA const * LastLastCh(TChA self) -> char          Parameters:             self: TChA const * GetSubStr(TChA self, int const & BChN, int const & EChN) -> TChA          Parameters:             BChN: int const &             EChN: int const & CountCh(TChA self, char const & Ch, int const & BChN=0) -> int          Parameters:             Ch: char const &             BChN: int const &          CountCh(TChA self, char const & Ch) -> int          Parameters:             Ch: char const & SearchCh(TChA self, char const & Ch, int const & BChN=0) -> int          Parameters:             Ch: char const &             BChN: int const &          SearchCh(TChA self, char const & Ch) -> int          Parameters:             Ch: char const & SearchChBack(TChA self, char const & Ch, int BChN=-1) -> int          Parameters:             Ch: char const &             BChN: int          SearchChBack(TChA self, char const & Ch) -> int          Parameters:             Ch: char const & SearchStr(TChA self, TChA Str, int const & BChN=0) -> int          Parameters:             Str: TChA const &             BChN: int const &          SearchStr(TChA self, TChA Str) -> int          Parameters:             Str: TChA const &          SearchStr(TChA self, TStr Str, int const & BChN=0) -> int          Parameters:             Str: TStr const &             BChN: int const &          SearchStr(TChA self, TStr Str) -> int          Parameters:             Str: TStr const &          SearchStr(TChA self, char const * CStr, int const & BChN=0) -> int          Parameters:             CStr: char const *             BChN: int const &          SearchStr(TChA self, char const * CStr) -> int          Parameters:             CStr: char const * IsStrIn(TChA self, TStr Str) -> bool          Parameters:             Str: TStr const & IsPrefix(TChA self, char const * CStr, int const & BChN=0) -> bool          Parameters:             CStr: char const *             BChN: int const &          IsPrefix(TChA self, char const * CStr) -> bool          Parameters:             CStr: char const *          IsPrefix(TChA self, TStr Str) -> bool          Parameters:             Str: TStr const &          IsPrefix(TChA self, TChA Str) -> bool          Parameters:             Str: TChA const & IsSuffix(TChA self, char const * CStr) -> bool          Parameters:             CStr: char const *          IsSuffix(TChA self, TStr Str) -> bool          Parameters:             Str: TStr const &          IsSuffix(TChA self, TChA Str) -> bool          Parameters:             Str: TChA const & IsChIn(TChA self, char const & Ch) -> bool          Parameters:             Ch: char const & ChangeCh(TChA self, char const & SrcCh, char const & DstCh)          Parameters:             SrcCh: char const &             DstCh: char const & ToUc(TChA self) -> TChA          Parameters:             self: TChA * ToLc(TChA self) -> TChA          Parameters:             self: TChA * ToTrunc(TChA self) -> TChA          Parameters:             self: TChA * CompressWs(TChA self)          Parameters:             self: TChA * Swap(TChA self, int const & ChN1, int const & ChN2)          Parameters:             ChN1: int const &             ChN2: int const &          Swap(TChA self, TChA ChA)          Parameters:             ChA: TChA & GetPrimHashCd(TChA self) -> int          Parameters:             self: TChA const * GetSecHashCd(TChA self) -> int          Parameters:             self: TChA const * LoadTxt(PSIn const & SIn, TChA ChA)          Parameters:             SIn: PSIn const &             ChA: TChA & SaveTxt(TChA self, PSOut const & SOut)          Parameters:             SOut: PSOut const & TChA_LoadTxt(PSIn const & SIn, TChA ChA)      Parameters:         SIn: PSIn const &         ChA: TChA & Proxy of C++ TChAIn class __init__(TChAIn self, TChA ChA, int const & _BfC=0) -> TChAIn          Parameters:             ChA: TChA const &             _BfC: int const &          __init__(TChAIn self, TChA ChA) -> TChAIn          Parameters:             ChA: TChA const & New(TChA ChA) -> PSIn          Parameters:             ChA: TChA const & TChAIn_New(TChA ChA) -> PSIn      Parameters:         ChA: TChA const & Proxy of C++ TRStr class __init__(TRStr self) -> TRStr         __init__(TRStr self, int const & Len) -> TRStr          Parameters:             Len: int const &          __init__(TRStr self, char const * CStr) -> TRStr          Parameters:             CStr: char const *          __init__(TRStr self, char const * CStr, int const & MxLen) -> TRStr          Parameters:             CStr: char const *             MxLen: int const &          __init__(TRStr self, char const * CStr1, char const * CStr2) -> TRStr          Parameters:             CStr1: char const *             CStr2: char const *          __init__(TRStr self, char const & Ch) -> TRStr          Parameters:             Ch: char const &          __init__(TRStr self, char const & Ch1, char const & Ch2) -> TRStr          Parameters:             Ch1: char const &             Ch2: char const &          __init__(TRStr self, TSIn SIn, bool const & IsSmall) -> TRStr          Parameters:             SIn: TSIn &             IsSmall: bool const & Save(TRStr self, TSOut SOut, bool const & IsSmall)          Parameters:             SOut: TSOut &             IsSmall: bool const & GetMemUsed(TRStr self) -> int          Parameters:             self: TRStr const * MkRef(TRStr self)          Parameters:             self: TRStr * UnRef(TRStr self)          Parameters:             self: TRStr * CStr(TRStr self) -> char const         CStr(TRStr self) -> char *          Parameters:             self: TRStr * Empty(TRStr self) -> bool          Parameters:             self: TRStr const * Len(TRStr self) -> int          Parameters:             self: TRStr const * PutCh(TRStr self, int const & ChN, char const & Ch)          Parameters:             ChN: int const &             Ch: char const & GetCh(TRStr self, int const & ChN) -> char          Parameters:             ChN: int const & IsUc(TRStr self) -> bool          Parameters:             self: TRStr const * ToUc(TRStr self)          Parameters:             self: TRStr * IsLc(TRStr self) -> bool          Parameters:             self: TRStr const * ToLc(TRStr self)          Parameters:             self: TRStr * ToCap(TRStr self)          Parameters:             self: TRStr * ConvUsFromYuAscii(TRStr self)          Parameters:             self: TRStr * CmpI(char const * CStr1, char const * CStr2) -> int          Parameters:             CStr1: char const *             CStr2: char const * GetPrimHashCd(TRStr self) -> int          Parameters:             self: TRStr const * GetSecHashCd(TRStr self) -> int          Parameters:             self: TRStr const * GetNullRStr() -> TRStr TRStr_CmpI(char const * CStr1, char const * CStr2) -> int      Parameters:         CStr1: char const *         CStr2: char const * TRStr_GetNullRStr() -> TRStr Proxy of C++ TStr class __init__(TStr self) -> TStr         __init__(TStr self, TStr Str) -> TStr          Parameters:             Str: TStr const &          __init__(TStr self, TChA ChA) -> TStr          Parameters:             ChA: TChA const &          __init__(TStr self, TSStr SStr) -> TStr          Parameters:             SStr: TSStr const &          __init__(TStr self, char const * CStr) -> TStr          Parameters:             CStr: char const *          __init__(TStr self, char const & Ch) -> TStr          Parameters:             Ch: char const &          __init__(TStr self, TMem Mem) -> TStr          Parameters:             Mem: TMem const &          __init__(TStr self, PSIn const & SIn) -> TStr          Parameters:             SIn: PSIn const &          __init__(TStr self, TSIn SIn, bool const & IsSmall=False) -> TStr          Parameters:             SIn: TSIn &             IsSmall: bool const &          __init__(TStr self, TSIn SIn) -> TStr          Parameters:             SIn: TSIn & Load(TStr self, TSIn SIn, bool const & IsSmall=False)          Parameters:             SIn: TSIn &             IsSmall: bool const &          Load(TStr self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TStr self, TSOut SOut, bool const & IsSmall=False)          Parameters:             SOut: TSOut &             IsSmall: bool const &          Save(TStr self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TStr self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TStr self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __iadd__(TStr self, TStr Str) -> TStr          Parameters:             Str: TStr const &          __iadd__(TStr self, char const * CStr) -> TStr          Parameters:             CStr: char const * __eq__(TStr self, TStr Str) -> bool          Parameters:             Str: TStr const &          __eq__(TStr self, char const * CStr) -> bool          Parameters:             CStr: char const * __ne__(TStr self, char const * CStr) -> bool          Parameters:             CStr: char const * __lt__(TStr self, TStr Str) -> bool          Parameters:             Str: TStr const & GetMemUsed(TStr self) -> int          Parameters:             self: TStr const * CStr(TStr self) -> char         CStr(TStr self) -> char const *          Parameters:             self: TStr const * PutCh(TStr self, int const & ChN, char const & Ch)          Parameters:             ChN: int const &             Ch: char const & GetCh(TStr self, int const & ChN) -> char          Parameters:             ChN: int const & LastCh(TStr self) -> char          Parameters:             self: TStr const * Clr(TStr self)          Parameters:             self: TStr * Len(TStr self) -> int          Parameters:             self: TStr const * Empty(TStr self) -> bool          Parameters:             self: TStr const * IsUc(TStr self) -> bool          Parameters:             self: TStr const * ToUc(TStr self) -> TStr          Parameters:             self: TStr * GetUc(TStr self) -> TStr          Parameters:             self: TStr const * CmpI(TStr self, TStr Str) -> int          Parameters:             Str: TStr const & EqI(TStr self, TStr Str) -> bool          Parameters:             Str: TStr const & IsLc(TStr self) -> bool          Parameters:             self: TStr const * ToLc(TStr self) -> TStr          Parameters:             self: TStr * GetLc(TStr self) -> TStr          Parameters:             self: TStr const * ToCap(TStr self) -> TStr          Parameters:             self: TStr * GetCap(TStr self) -> TStr          Parameters:             self: TStr const * ToTrunc(TStr self) -> TStr          Parameters:             self: TStr * GetTrunc(TStr self) -> TStr          Parameters:             self: TStr const * ConvUsFromYuAscii(TStr self) -> TStr          Parameters:             self: TStr * GetUsFromYuAscii(TStr self) -> TStr          Parameters:             self: TStr const * ToHex(TStr self) -> TStr          Parameters:             self: TStr * GetHex(TStr self) -> TStr          Parameters:             self: TStr const * FromHex(TStr self) -> TStr          Parameters:             self: TStr * GetFromHex(TStr self) -> TStr          Parameters:             self: TStr const * GetSubStr(TStr self, int const & BChN, int const & EChN) -> TStr          Parameters:             BChN: int const &             EChN: int const &          GetSubStr(TStr self, int const & BChN) -> TStr          Parameters:             BChN: int const & InsStr(TStr self, int const & BChN, TStr Str)          Parameters:             BChN: int const &             Str: TStr const & DelChAll(TStr self, char const & Ch)          Parameters:             Ch: char const & DelSubStr(TStr self, int const & BChN, int const & EChN)          Parameters:             BChN: int const &             EChN: int const & DelStr(TStr self, TStr Str) -> bool          Parameters:             Str: TStr const & LeftOf(TStr self, char const & SplitCh) -> TStr          Parameters:             SplitCh: char const & LeftOfLast(TStr self, char const & SplitCh) -> TStr          Parameters:             SplitCh: char const & RightOf(TStr self, char const & SplitCh) -> TStr          Parameters:             SplitCh: char const & RightOfLast(TStr self, char const & SplitCh) -> TStr          Parameters:             SplitCh: char const & SplitOnCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr)          Parameters:             LStr: TStr &             SplitCh: char const &             RStr: TStr & SplitOnLastCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr)          Parameters:             LStr: TStr &             SplitCh: char const &             RStr: TStr & SplitOnAllCh(TStr self, char const & SplitCh, TStrV StrV, bool const & SkipEmpty=True)          Parameters:             SplitCh: char const &             StrV: TStrV &             SkipEmpty: bool const &          SplitOnAllCh(TStr self, char const & SplitCh, TStrV StrV)          Parameters:             SplitCh: char const &             StrV: TStrV & SplitOnAllAnyCh(TStr self, TStr SplitChStr, TStrV StrV, bool const & SkipEmpty=True)          Parameters:             SplitChStr: TStr const &             StrV: TStrV &             SkipEmpty: bool const &          SplitOnAllAnyCh(TStr self, TStr SplitChStr, TStrV StrV)          Parameters:             SplitChStr: TStr const &             StrV: TStrV & SplitOnWs(TStr self, TStrV StrV)          Parameters:             StrV: TStrV & SplitOnNonAlNum(TStr self, TStrV StrV)          Parameters:             StrV: TStrV & SplitOnStr(TStr self, TStr SplitStr, TStrV StrV)          Parameters:             SplitStr: TStr const &             StrV: TStrV &          SplitOnStr(TStr self, TStr LeftStr, TStr MidStr, TStr RightStr)          Parameters:             LeftStr: TStr &             MidStr: TStr const &             RightStr: TStr & Mid(TStr self, int const & BChN, int const & Chs) -> TStr          Parameters:             BChN: int const &             Chs: int const &          Mid(TStr self, int const & BChN) -> TStr          Parameters:             BChN: int const & Left(TStr self, int const & EChN) -> TStr          Parameters:             EChN: int const & Right(TStr self, int const & BChN) -> TStr          Parameters:             BChN: int const & Slice(TStr self, int BChN, int EChNP1) -> TStr          Parameters:             BChN: int             EChNP1: int __call__(TStr self) -> char         __call__(TStr self) -> char const         __call__(TStr self, int const & BChN, int const & EChNP1) -> TStr          Parameters:             BChN: int const &             EChNP1: int const & CountCh(TStr self, char const & Ch, int const & BChN=0) -> int          Parameters:             Ch: char const &             BChN: int const &          CountCh(TStr self, char const & Ch) -> int          Parameters:             Ch: char const & SearchCh(TStr self, char const & Ch, int const & BChN=0) -> int          Parameters:             Ch: char const &             BChN: int const &          SearchCh(TStr self, char const & Ch) -> int          Parameters:             Ch: char const & SearchChBack(TStr self, char const & Ch, int BChN=-1) -> int          Parameters:             Ch: char const &             BChN: int          SearchChBack(TStr self, char const & Ch) -> int          Parameters:             Ch: char const & SearchStr(TStr self, TStr Str, int const & BChN=0) -> int          Parameters:             Str: TStr const &             BChN: int const &          SearchStr(TStr self, TStr Str) -> int          Parameters:             Str: TStr const & IsChIn(TStr self, char const & Ch) -> bool          Parameters:             Ch: char const & IsStrIn(TStr self, TStr Str) -> bool          Parameters:             Str: TStr const & IsPrefix(TStr self, char const * Str) -> bool          Parameters:             Str: char const *          IsPrefix(TStr self, TStr Str) -> bool          Parameters:             Str: TStr const & IsSuffix(TStr self, char const * Str) -> bool          Parameters:             Str: char const *          IsSuffix(TStr self, TStr Str) -> bool          Parameters:             Str: TStr const & ChangeCh(TStr self, char const & SrcCh, char const & DstCh, int const & BChN=0) -> int          Parameters:             SrcCh: char const &             DstCh: char const &             BChN: int const &          ChangeCh(TStr self, char const & SrcCh, char const & DstCh) -> int          Parameters:             SrcCh: char const &             DstCh: char const & ChangeChAll(TStr self, char const & SrcCh, char const & DstCh) -> int          Parameters:             SrcCh: char const &             DstCh: char const & ChangeStr(TStr self, TStr SrcStr, TStr DstStr, int const & BChN=0) -> int          Parameters:             SrcStr: TStr const &             DstStr: TStr const &             BChN: int const &          ChangeStr(TStr self, TStr SrcStr, TStr DstStr) -> int          Parameters:             SrcStr: TStr const &             DstStr: TStr const & ChangeStrAll(TStr self, TStr SrcStr, TStr DstStr, bool const & FromStartP=False) -> int          Parameters:             SrcStr: TStr const &             DstStr: TStr const &             FromStartP: bool const &          ChangeStrAll(TStr self, TStr SrcStr, TStr DstStr) -> int          Parameters:             SrcStr: TStr const &             DstStr: TStr const & Reverse(TStr self) -> TStr          Parameters:             self: TStr const * GetPrimHashCd(TStr self) -> int          Parameters:             self: TStr const * GetSecHashCd(TStr self) -> int          Parameters:             self: TStr const * IsBool(TStr self, bool & Val) -> bool          Parameters:             Val: bool & IsInt(TStr self, bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool          Parameters:             Check: bool const &             MnVal: int const &             MxVal: int const &             Val: int &          IsInt(TStr self, int & Val) -> bool          Parameters:             Val: int &          IsInt(TStr self) -> bool          Parameters:             self: TStr const * GetInt(TStr self) -> int         GetInt(TStr self, int const & DfVal) -> int          Parameters:             DfVal: int const & IsUInt(TStr self, bool const & Check, uint const & MnVal, uint const & MxVal, uint & Val) -> bool          Parameters:             Check: bool const &             MnVal: uint const &             MxVal: uint const &             Val: uint &          IsUInt(TStr self, uint & Val) -> bool          Parameters:             Val: uint &          IsUInt(TStr self) -> bool          Parameters:             self: TStr const * GetUInt(TStr self) -> uint         GetUInt(TStr self, uint const & DfVal) -> uint          Parameters:             DfVal: uint const & IsInt64(TStr self, bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool          Parameters:             Check: bool const &             MnVal: int64 const &             MxVal: int64 const &             Val: int64 &          IsInt64(TStr self, int64 & Val) -> bool          Parameters:             Val: int64 &          IsInt64(TStr self) -> bool          Parameters:             self: TStr const * GetInt64(TStr self) -> int64         GetInt64(TStr self, int64 const & DfVal) -> int64          Parameters:             DfVal: int64 const & IsUInt64(TStr self, bool const & Check, uint64 const & MnVal, uint64 const & MxVal, uint64 & Val) -> bool          Parameters:             Check: bool const &             MnVal: uint64 const &             MxVal: uint64 const &             Val: uint64 &          IsUInt64(TStr self, uint64 & Val) -> bool          Parameters:             Val: uint64 &          IsUInt64(TStr self) -> bool          Parameters:             self: TStr const * GetUInt64(TStr self) -> uint64         GetUInt64(TStr self, uint64 const & DfVal) -> uint64          Parameters:             DfVal: uint64 const & IsHexInt(TStr self, bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool          Parameters:             Check: bool const &             MnVal: int const &             MxVal: int const &             Val: int &          IsHexInt(TStr self, int & Val) -> bool          Parameters:             Val: int &          IsHexInt(TStr self) -> bool          Parameters:             self: TStr const * GetHexInt(TStr self) -> int         GetHexInt(TStr self, int const & DfVal) -> int          Parameters:             DfVal: int const & IsHexInt64(TStr self, bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool          Parameters:             Check: bool const &             MnVal: int64 const &             MxVal: int64 const &             Val: int64 &          IsHexInt64(TStr self, int64 & Val) -> bool          Parameters:             Val: int64 &          IsHexInt64(TStr self) -> bool          Parameters:             self: TStr const * GetHexInt64(TStr self) -> int64         GetHexInt64(TStr self, int64 const & DfVal) -> int64          Parameters:             DfVal: int64 const & IsFlt(TStr self, bool const & Check, double const & MnVal, double const & MxVal, double & Val, char const & DecDelimCh='.') -> bool          Parameters:             Check: bool const &             MnVal: double const &             MxVal: double const &             Val: double &             DecDelimCh: char const &          IsFlt(TStr self, bool const & Check, double const & MnVal, double const & MxVal, double & Val) -> bool          Parameters:             Check: bool const &             MnVal: double const &             MxVal: double const &             Val: double &          IsFlt(TStr self, double & Val) -> bool          Parameters:             Val: double &          IsFlt(TStr self) -> bool          Parameters:             self: TStr const * GetFlt(TStr self) -> double         GetFlt(TStr self, double const & DfVal) -> double          Parameters:             DfVal: double const & IsWord(TStr self, bool const & WsPrefixP=True, bool const & FirstUcAllowedP=True) -> bool          Parameters:             WsPrefixP: bool const &             FirstUcAllowedP: bool const &          IsWord(TStr self, bool const & WsPrefixP=True) -> bool          Parameters:             WsPrefixP: bool const &          IsWord(TStr self) -> bool          Parameters:             self: TStr const * IsWs(TStr self) -> bool          Parameters:             self: TStr const * IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*',              char const & QuestCh='?') -> bool          Parameters:             StrBChN: int const &             WcStr: TStr const &             WcStrBChN: int const &             StarStrV: TStrV &             StarCh: char const &             QuestCh: char const &          IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*') -> bool          Parameters:             StrBChN: int const &             WcStr: TStr const &             WcStrBChN: int const &             StarStrV: TStrV &             StarCh: char const &          IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV) -> bool          Parameters:             StrBChN: int const &             WcStr: TStr const &             WcStrBChN: int const &             StarStrV: TStrV &          IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV, char const & StarCh='*', char const & QuestCh='?') -> bool          Parameters:             WcStr: TStr const &             StarStrV: TStrV &             StarCh: char const &             QuestCh: char const &          IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV, char const & StarCh='*') -> bool          Parameters:             WcStr: TStr const &             StarStrV: TStrV &             StarCh: char const &          IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV) -> bool          Parameters:             WcStr: TStr const &             StarStrV: TStrV &          IsWcMatch(TStr self, TStr WcStr, char const & StarCh, char const & QuestCh) -> bool          Parameters:             WcStr: TStr const &             StarCh: char const &             QuestCh: char const &          IsWcMatch(TStr self, TStr WcStr, int const & StarStrN, TStr StarStr) -> bool          Parameters:             WcStr: TStr const &             StarStrN: int const &             StarStr: TStr &          IsWcMatch(TStr self, TStr WcStr) -> bool          Parameters:             WcStr: TStr const & GetWcMatch(TStr self, TStr WcStr, int const & StarStrN=0) -> TStr          Parameters:             WcStr: TStr const &             StarStrN: int const &          GetWcMatch(TStr self, TStr WcStr) -> TStr          Parameters:             WcStr: TStr const & GetFPath(TStr self) -> TStr          Parameters:             self: TStr const * GetFBase(TStr self) -> TStr          Parameters:             self: TStr const * GetFMid(TStr self) -> TStr          Parameters:             self: TStr const * GetFExt(TStr self) -> TStr          Parameters:             self: TStr const * GetNrFPath(TStr FPath) -> TStr          Parameters:             FPath: TStr const & GetNrFMid(TStr FMid) -> TStr          Parameters:             FMid: TStr const & GetNrFExt(TStr FExt) -> TStr          Parameters:             FExt: TStr const & GetNrNumFExt(int const & FExtN) -> TStr          Parameters:             FExtN: int const & GetNrFNm(TStr FNm) -> TStr          Parameters:             FNm: TStr const & GetNrAbsFPath(TStr FPath, TStr BaseFPath=TStr()) -> TStr          Parameters:             FPath: TStr const &             BaseFPath: TStr const &          GetNrAbsFPath(TStr FPath) -> TStr          Parameters:             FPath: TStr const & IsAbsFPath(TStr FPath) -> bool          Parameters:             FPath: TStr const & PutFExt(TStr FNm, TStr FExt) -> TStr          Parameters:             FNm: TStr const &             FExt: TStr const & PutFExtIfEmpty(TStr FNm, TStr FExt) -> TStr          Parameters:             FNm: TStr const &             FExt: TStr const & PutFBase(TStr FNm, TStr FBase) -> TStr          Parameters:             FNm: TStr const &             FBase: TStr const & PutFBaseIfEmpty(TStr FNm, TStr FBase) -> TStr          Parameters:             FNm: TStr const &             FBase: TStr const & AddToFMid(TStr FNm, TStr ExtFMid) -> TStr          Parameters:             FNm: TStr const &             ExtFMid: TStr const & GetNumFNm(TStr FNm, int const & Num) -> TStr          Parameters:             FNm: TStr const &             Num: int const & GetFNmStr(TStr Str, bool const & AlNumOnlyP=True) -> TStr          Parameters:             Str: TStr const &             AlNumOnlyP: bool const &          GetFNmStr(TStr Str) -> TStr          Parameters:             Str: TStr const & LoadTxt(PSIn const & SIn) -> TStr          Parameters:             SIn: PSIn const &          LoadTxt(TStr FNm) -> TStr          Parameters:             FNm: TStr const & SaveTxt(TStr self, PSOut const & SOut)          Parameters:             SOut: PSOut const &          SaveTxt(TStr self, TStr FNm)          Parameters:             FNm: TStr const & GetChStr(char const & Ch) -> TStr          Parameters:             Ch: char const & GetDChStr(char const & Ch1, char const & Ch2) -> TStr          Parameters:             Ch1: char const &             Ch2: char const & Fmt(char const * FmtStr) -> TStr          Parameters:             FmtStr: char const * GetSpaceStr(int const & Spaces) -> TStr          Parameters:             Spaces: int const & GetCStr(TStr self) -> char *          Parameters:             self: TStr const * MkClone(TStr Str) -> TStr          Parameters:             Str: TStr const & GetNullStr() -> TStr TStr_GetNrFPath(TStr FPath) -> TStr      Parameters:         FPath: TStr const & TStr_GetNrFMid(TStr FMid) -> TStr      Parameters:         FMid: TStr const & TStr_GetNrFExt(TStr FExt) -> TStr      Parameters:         FExt: TStr const & TStr_GetNrNumFExt(int const & FExtN) -> TStr      Parameters:         FExtN: int const & TStr_GetNrFNm(TStr FNm) -> TStr      Parameters:         FNm: TStr const & GetNrAbsFPath(TStr FPath, TStr BaseFPath=TStr()) -> TStr      Parameters:         FPath: TStr const &         BaseFPath: TStr const &      TStr_GetNrAbsFPath(TStr FPath) -> TStr      Parameters:         FPath: TStr const & TStr_IsAbsFPath(TStr FPath) -> bool      Parameters:         FPath: TStr const & TStr_PutFExt(TStr FNm, TStr FExt) -> TStr      Parameters:         FNm: TStr const &         FExt: TStr const & TStr_PutFExtIfEmpty(TStr FNm, TStr FExt) -> TStr      Parameters:         FNm: TStr const &         FExt: TStr const & TStr_PutFBase(TStr FNm, TStr FBase) -> TStr      Parameters:         FNm: TStr const &         FBase: TStr const & TStr_PutFBaseIfEmpty(TStr FNm, TStr FBase) -> TStr      Parameters:         FNm: TStr const &         FBase: TStr const & TStr_AddToFMid(TStr FNm, TStr ExtFMid) -> TStr      Parameters:         FNm: TStr const &         ExtFMid: TStr const & TStr_GetNumFNm(TStr FNm, int const & Num) -> TStr      Parameters:         FNm: TStr const &         Num: int const & GetFNmStr(TStr Str, bool const & AlNumOnlyP=True) -> TStr      Parameters:         Str: TStr const &         AlNumOnlyP: bool const &      TStr_GetFNmStr(TStr Str) -> TStr      Parameters:         Str: TStr const & LoadTxt(PSIn const & SIn) -> TStr      Parameters:         SIn: PSIn const &      TStr_LoadTxt(TStr FNm) -> TStr      Parameters:         FNm: TStr const & TStr_GetChStr(char const & Ch) -> TStr      Parameters:         Ch: char const & TStr_GetDChStr(char const & Ch1, char const & Ch2) -> TStr      Parameters:         Ch1: char const &         Ch2: char const & TStr_Fmt(char const * FmtStr) -> TStr      Parameters:         FmtStr: char const * TStr_GetSpaceStr(int const & Spaces) -> TStr      Parameters:         Spaces: int const & TStr_MkClone(TStr Str) -> TStr      Parameters:         Str: TStr const & TStr_GetNullStr() -> TStr Proxy of C++ TStrIn class __init__(TStrIn self, TStr _Str) -> TStrIn          Parameters:             _Str: TStr const & New(TStr Str) -> PSIn          Parameters:             Str: TStr const & TStrIn_New(TStr Str) -> PSIn      Parameters:         Str: TStr const & Proxy of C++ TDbStr class __init__(TDbStr self) -> TDbStr         __init__(TDbStr self, TDbStr DbStr) -> TDbStr          Parameters:             DbStr: TDbStr const &          __init__(TDbStr self, TStr _Str1) -> TDbStr          Parameters:             _Str1: TStr const &          __init__(TDbStr self, TStr _Str1, TStr _Str2) -> TDbStr          Parameters:             _Str1: TStr const &             _Str2: TStr const &          __init__(TDbStr self, TSIn SIn) -> TDbStr          Parameters:             SIn: TSIn & Save(TDbStr self, TSOut SOut)          Parameters:             SOut: TSOut & __eq__(TDbStr self, TDbStr DbStr) -> bool          Parameters:             DbStr: TDbStr const & __lt__(TDbStr self, TDbStr DbStr) -> bool          Parameters:             DbStr: TDbStr const & GetPrimHashCd(TDbStr self) -> int          Parameters:             self: TDbStr const * GetSecHashCd(TDbStr self) -> int          Parameters:             self: TDbStr const * Empty(TDbStr self) -> bool          Parameters:             self: TDbStr const * Filled(TDbStr self) -> bool          Parameters:             self: TDbStr const * Proxy of C++ TStrPool class __init__(TStrPool self, uint const & MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> TStrPool          Parameters:             MxBfLen: uint const &             _GrowBy: uint const &          __init__(TStrPool self, uint const & MxBfLen=0) -> TStrPool          Parameters:             MxBfLen: uint const &          __init__(TStrPool self) -> TStrPool         __init__(TStrPool self, TSIn SIn, bool LoadCompact=True) -> TStrPool          Parameters:             SIn: TSIn &             LoadCompact: bool          __init__(TStrPool self, TSIn SIn) -> TStrPool          Parameters:             SIn: TSIn &          __init__(TStrPool self, TStrPool Pool) -> TStrPool          Parameters:             Pool: TStrPool const & New(uint const & _MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> PStrPool          Parameters:             _MxBfLen: uint const &             _GrowBy: uint const &          New(uint const & _MxBfLen=0) -> PStrPool          Parameters:             _MxBfLen: uint const &          New() -> PStrPool         New(TSIn SIn) -> PStrPool          Parameters:             SIn: TSIn &          New(TStr fileName) -> PStrPool          Parameters:             fileName: TStr const & Load(TSIn SIn, bool LoadCompacted=True) -> PStrPool          Parameters:             SIn: TSIn &             LoadCompacted: bool          Load(TSIn SIn) -> PStrPool          Parameters:             SIn: TSIn & Save(TStrPool self, TSOut SOut)          Parameters:             SOut: TSOut &          Save(TStrPool self, TStr FNm)          Parameters:             FNm: TStr const & Len(TStrPool self) -> uint          Parameters:             self: TStrPool const * Size(TStrPool self) -> uint          Parameters:             self: TStrPool const * Empty(TStrPool self) -> bool          Parameters:             self: TStrPool const * __call__(TStrPool self) -> char *          Parameters:             self: TStrPool const * AddStr(TStrPool self, char const * Str, uint const & Len) -> uint          Parameters:             Str: char const *             Len: uint const &          AddStr(TStrPool self, char const * Str) -> uint          Parameters:             Str: char const *          AddStr(TStrPool self, TStr Str) -> uint          Parameters:             Str: TStr const & GetCStr(TStrPool self, uint const & Offset) -> char const *          Parameters:             Offset: uint const & Clr(TStrPool self, bool DoDel=False)          Parameters:             DoDel: bool          Clr(TStrPool self)          Parameters:             self: TStrPool * Cmp(TStrPool self, uint const & Offset, char const * Str) -> int          Parameters:             Offset: uint const &             Str: char const * GetPrimHashCd(TStrPool self, char const * CStr) -> int          Parameters:             CStr: char const *          GetPrimHashCd(TStrPool self, uint const & Offset) -> int          Parameters:             Offset: uint const & GetSecHashCd(TStrPool self, char const * CStr) -> int          Parameters:             CStr: char const *          GetSecHashCd(TStrPool self, uint const & Offset) -> int          Parameters:             Offset: uint const & New(uint const & _MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> PStrPool      Parameters:         _MxBfLen: uint const &         _GrowBy: uint const &      New(uint const & _MxBfLen=0) -> PStrPool      Parameters:         _MxBfLen: uint const &      New() -> PStrPool     New(TSIn SIn) -> PStrPool      Parameters:         SIn: TSIn &      TStrPool_New(TStr fileName) -> PStrPool      Parameters:         fileName: TStr const & Load(TSIn SIn, bool LoadCompacted=True) -> PStrPool      Parameters:         SIn: TSIn &         LoadCompacted: bool      TStrPool_Load(TSIn SIn) -> PStrPool      Parameters:         SIn: TSIn & Proxy of C++ TStrPool64 class __init__(TStrPool64 self, ::TSize _MxBfL=0, ::TSize _GrowBy=16*1024*1024) -> TStrPool64          Parameters:             _MxBfL: ::TSize             _GrowBy: ::TSize          __init__(TStrPool64 self, ::TSize _MxBfL=0) -> TStrPool64          Parameters:             _MxBfL: ::TSize          __init__(TStrPool64 self) -> TStrPool64         __init__(TStrPool64 self, TStrPool64 StrPool) -> TStrPool64          Parameters:             StrPool: TStrPool64 const &          __init__(TStrPool64 self, TSIn SIn, bool LoadCompact=True) -> TStrPool64          Parameters:             SIn: TSIn &             LoadCompact: bool          __init__(TStrPool64 self, TSIn SIn) -> TStrPool64          Parameters:             SIn: TSIn & Save(TStrPool64 self, TSOut SOut)          Parameters:             SOut: TSOut & New(::TSize MxBfL=0, ::TSize GrowBy=16*1024*1024) -> PStrPool64          Parameters:             MxBfL: ::TSize             GrowBy: ::TSize          New(::TSize MxBfL=0) -> PStrPool64          Parameters:             MxBfL: ::TSize          New() -> PStrPool64 Load(TSIn SIn, bool LoadCompact=True) -> PStrPool64          Parameters:             SIn: TSIn &             LoadCompact: bool          Load(TSIn SIn) -> PStrPool64          Parameters:             SIn: TSIn & GetMemUsed(TStrPool64 self) -> uint64          Parameters:             self: TStrPool64 const * Empty(TStrPool64 self) -> bool          Parameters:             self: TStrPool64 const * Len(TStrPool64 self) -> uint64          Parameters:             self: TStrPool64 const * Reserved(TStrPool64 self) -> uint64          Parameters:             self: TStrPool64 const * Clr(TStrPool64 self, bool DoDel=False)          Parameters:             DoDel: bool          Clr(TStrPool64 self)          Parameters:             self: TStrPool64 * Cmp(TStrPool64 self, uint64 Offset, char const * Str) -> int          Parameters:             Offset: uint64             Str: char const * AddStr(TStrPool64 self, TStr Str) -> uint64          Parameters:             Str: TStr const & New(::TSize MxBfL=0, ::TSize GrowBy=16*1024*1024) -> PStrPool64      Parameters:         MxBfL: ::TSize         GrowBy: ::TSize      New(::TSize MxBfL=0) -> PStrPool64      Parameters:         MxBfL: ::TSize      TStrPool64_New() -> PStrPool64 Load(TSIn SIn, bool LoadCompact=True) -> PStrPool64      Parameters:         SIn: TSIn &         LoadCompact: bool      TStrPool64_Load(TSIn SIn) -> PStrPool64      Parameters:         SIn: TSIn & Proxy of C++ TVoid class __init__(TVoid self) -> TVoid         __init__(TVoid self, TSIn arg2) -> TVoid          Parameters:             arg2: TSIn & Save(TVoid self, TSOut arg2)          Parameters:             arg2: TSOut & LoadXml(TVoid self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TVoid self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TVoid self, TVoid arg2) -> bool          Parameters:             arg2: TVoid const & __lt__(TVoid self, TVoid arg2) -> bool          Parameters:             arg2: TVoid const & GetMemUsed(TVoid self) -> int          Parameters:             self: TVoid const * Proxy of C++ TBool class __init__(TBool self) -> TBool         __init__(TBool self, bool const & _Val) -> TBool          Parameters:             _Val: bool const &          __init__(TBool self, TSIn SIn) -> TBool          Parameters:             SIn: TSIn & Load(TBool self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TBool self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TBool self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TBool self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TBool self, TBool Bool) -> bool          Parameters:             Bool: TBool const & __lt__(TBool self, TBool Bool) -> bool          Parameters:             Bool: TBool const & __call__(TBool self) -> bool          Parameters:             self: TBool const * GetMemUsed(TBool self) -> int          Parameters:             self: TBool const * GetPrimHashCd(TBool self) -> int          Parameters:             self: TBool const * GetSecHashCd(TBool self) -> int          Parameters:             self: TBool const * GetRnd() -> bool GetYNStr(bool const & Val) -> TStr          Parameters:             Val: bool const & GetYesNoStr(bool const & Val) -> TStr          Parameters:             Val: bool const & Get01Str(bool const & Val) -> TStr          Parameters:             Val: bool const & IsValStr(TStr Str) -> bool          Parameters:             Str: TStr const & GetValFromStr(TStr Str) -> bool          Parameters:             Str: TStr const &          GetValFromStr(TStr Str, bool const & DfVal) -> bool          Parameters:             Str: TStr const &             DfVal: bool const & TBool_GetRnd() -> bool TBool_GetYNStr(bool const & Val) -> TStr      Parameters:         Val: bool const & TBool_GetYesNoStr(bool const & Val) -> TStr      Parameters:         Val: bool const & TBool_Get01Str(bool const & Val) -> TStr      Parameters:         Val: bool const & TBool_IsValStr(TStr Str) -> bool      Parameters:         Str: TStr const & GetValFromStr(TStr Str) -> bool      Parameters:         Str: TStr const &      TBool_GetValFromStr(TStr Str, bool const & DfVal) -> bool      Parameters:         Str: TStr const &         DfVal: bool const & Proxy of C++ TCh class __init__(TCh self) -> TCh         __init__(TCh self, char const & _Val) -> TCh          Parameters:             _Val: char const &          __init__(TCh self, TSIn SIn) -> TCh          Parameters:             SIn: TSIn & Save(TCh self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TCh self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TCh self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TCh self, TCh Ch) -> bool          Parameters:             Ch: TCh const & __lt__(TCh self, TCh Ch) -> bool          Parameters:             Ch: TCh const & __call__(TCh self) -> char          Parameters:             self: TCh const * GetMemUsed(TCh self) -> int          Parameters:             self: TCh const * GetPrimHashCd(TCh self) -> int          Parameters:             self: TCh const * GetSecHashCd(TCh self) -> int          Parameters:             self: TCh const * IsWs(char const & Ch) -> bool          Parameters:             Ch: char const & IsAlpha(char const & Ch) -> bool          Parameters:             Ch: char const & IsNum(char const & Ch) -> bool          Parameters:             Ch: char const & IsAlNum(char const & Ch) -> bool          Parameters:             Ch: char const & GetNum(char const & Ch) -> int          Parameters:             Ch: char const & IsHex(char const & Ch) -> bool          Parameters:             Ch: char const & GetHex(char const & Ch) -> int          Parameters:             Ch: char const & GetHexCh(int const & Val) -> char          Parameters:             Val: int const & IsUc(char const & Ch) -> char          Parameters:             Ch: char const & GetUc(char const & Ch) -> char          Parameters:             Ch: char const & GetUsFromYuAscii(char const & Ch) -> char          Parameters:             Ch: char const & TCh_IsWs(char const & Ch) -> bool      Parameters:         Ch: char const & TCh_IsAlpha(char const & Ch) -> bool      Parameters:         Ch: char const & TCh_IsNum(char const & Ch) -> bool      Parameters:         Ch: char const & TCh_IsAlNum(char const & Ch) -> bool      Parameters:         Ch: char const & TCh_GetNum(char const & Ch) -> int      Parameters:         Ch: char const & TCh_IsHex(char const & Ch) -> bool      Parameters:         Ch: char const & TCh_GetHex(char const & Ch) -> int      Parameters:         Ch: char const & TCh_GetHexCh(int const & Val) -> char      Parameters:         Val: int const & TCh_IsUc(char const & Ch) -> char      Parameters:         Ch: char const & TCh_GetUc(char const & Ch) -> char      Parameters:         Ch: char const & TCh_GetUsFromYuAscii(char const & Ch) -> char      Parameters:         Ch: char const & Proxy of C++ TUCh class __init__(TUCh self) -> TUCh         __init__(TUCh self, uchar const & _Val) -> TUCh          Parameters:             _Val: uchar const &          __init__(TUCh self, TSIn SIn) -> TUCh          Parameters:             SIn: TSIn & Save(TUCh self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TUCh self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TUCh self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TUCh self, TUCh UCh) -> bool          Parameters:             UCh: TUCh const & __lt__(TUCh self, TUCh UCh) -> bool          Parameters:             UCh: TUCh const & __call__(TUCh self) -> uchar          Parameters:             self: TUCh const * GetMemUsed(TUCh self) -> int          Parameters:             self: TUCh const * GetPrimHashCd(TUCh self) -> int          Parameters:             self: TUCh const * GetSecHashCd(TUCh self) -> int          Parameters:             self: TUCh const * Proxy of C++ TSInt class __init__(TSInt self) -> TSInt         __init__(TSInt self, int16 const & _Val) -> TSInt          Parameters:             _Val: int16 const &          __init__(TSInt self, TSIn SIn) -> TSInt          Parameters:             SIn: TSIn & Load(TSInt self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TSInt self, TSOut SOut)          Parameters:             SOut: TSOut & GetPrimHashCd(TSInt self) -> int          Parameters:             self: TSInt const * GetSecHashCd(TSInt self) -> int          Parameters:             self: TSInt const * Proxy of C++ TInt class __init__(TInt self) -> TInt         __init__(TInt self, int const & _Val) -> TInt          Parameters:             _Val: int const &          __init__(TInt self, TSIn SIn) -> TInt          Parameters:             SIn: TSIn & Load(TInt self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TInt self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TInt self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TInt self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TInt self, TInt Int) -> bool          Parameters:             Int: TInt const &          __eq__(TInt self, int const & Int) -> bool          Parameters:             Int: int const & __ne__(TInt self, int const & Int) -> bool          Parameters:             Int: int const & __lt__(TInt self, TInt Int) -> bool          Parameters:             Int: TInt const &          __lt__(TInt self, int const & Int) -> bool          Parameters:             Int: int const & __call__(TInt self) -> int          Parameters:             self: TInt const * __iadd__(TInt self, int const & Int) -> TInt          Parameters:             Int: int const & __isub__(TInt self, int const & Int) -> TInt          Parameters:             Int: int const & GetMemUsed(TInt self) -> int          Parameters:             self: TInt const * GetPrimHashCd(TInt self) -> int          Parameters:             self: TInt const * GetSecHashCd(TInt self) -> int          Parameters:             self: TInt const * Abs(int const & Int) -> int          Parameters:             Int: int const & Sign(int const & Int) -> int          Parameters:             Int: int const & Swap(int & Int1, int & Int2)          Parameters:             Int1: int &             Int2: int & GetRnd(int const & Range=0) -> int          Parameters:             Range: int const &          GetRnd() -> int IsOdd(int const & Int) -> bool          Parameters:             Int: int const & IsEven(int const & Int) -> bool          Parameters:             Int: int const & GetMn(int const & Int1, int const & Int2) -> int          Parameters:             Int1: int const &             Int2: int const &          GetMn(int const & Int1, int const & Int2, int const & Int3) -> int          Parameters:             Int1: int const &             Int2: int const &             Int3: int const &          GetMn(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int          Parameters:             Int1: int const &             Int2: int const &             Int3: int const &             Int4: int const & GetMx(int const & Int1, int const & Int2) -> int          Parameters:             Int1: int const &             Int2: int const &          GetMx(int const & Int1, int const & Int2, int const & Int3) -> int          Parameters:             Int1: int const &             Int2: int const &             Int3: int const &          GetMx(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int          Parameters:             Int1: int const &             Int2: int const &             Int3: int const &             Int4: int const & GetInRng(int const & Val, int const & Mn, int const & Mx) -> int          Parameters:             Val: int const &             Mn: int const &             Mx: int const & GetHexStr(int const & Val) -> TStr          Parameters:             Val: int const &          GetHexStr(TInt Int) -> TStr          Parameters:             Int: TInt const & GetKiloStr(int const & Val) -> TStr          Parameters:             Val: int const & GetMegaStr(int const & Val) -> TStr          Parameters:             Val: int const & SaveFrugalInt(char * pDest, int i) -> char *          Parameters:             pDest: char *             i: int LoadFrugalInt(char * pSrc, int & i) -> char *          Parameters:             pSrc: char *             i: int & TestFrugalInt() SaveFrugalIntV(TSOut SOut, TIntV IntV)          Parameters:             SOut: TSOut &             IntV: TVec< TInt,int > const & LoadFrugalIntV(TSIn SIn, TIntV IntV, bool ClrP=True)          Parameters:             SIn: TSIn &             IntV: TVec< TInt,int > &             ClrP: bool          LoadFrugalIntV(TSIn SIn, TIntV IntV)          Parameters:             SIn: TSIn &             IntV: TVec< TInt,int > & TInt_Abs(int const & Int) -> int      Parameters:         Int: int const & TInt_Sign(int const & Int) -> int      Parameters:         Int: int const & TInt_Swap(int & Int1, int & Int2)      Parameters:         Int1: int &         Int2: int & GetRnd(int const & Range=0) -> int      Parameters:         Range: int const &      TInt_GetRnd() -> int TInt_IsOdd(int const & Int) -> bool      Parameters:         Int: int const & TInt_IsEven(int const & Int) -> bool      Parameters:         Int: int const & GetMn(int const & Int1, int const & Int2) -> int      Parameters:         Int1: int const &         Int2: int const &      GetMn(int const & Int1, int const & Int2, int const & Int3) -> int      Parameters:         Int1: int const &         Int2: int const &         Int3: int const &      TInt_GetMn(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int      Parameters:         Int1: int const &         Int2: int const &         Int3: int const &         Int4: int const & GetMx(int const & Int1, int const & Int2) -> int      Parameters:         Int1: int const &         Int2: int const &      GetMx(int const & Int1, int const & Int2, int const & Int3) -> int      Parameters:         Int1: int const &         Int2: int const &         Int3: int const &      TInt_GetMx(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int      Parameters:         Int1: int const &         Int2: int const &         Int3: int const &         Int4: int const & TInt_GetInRng(int const & Val, int const & Mn, int const & Mx) -> int      Parameters:         Val: int const &         Mn: int const &         Mx: int const & GetHexStr(int const & Val) -> TStr      Parameters:         Val: int const &      TInt_GetHexStr(TInt Int) -> TStr      Parameters:         Int: TInt const & TInt_GetKiloStr(int const & Val) -> TStr      Parameters:         Val: int const & TInt_GetMegaStr(int const & Val) -> TStr      Parameters:         Val: int const & TInt_SaveFrugalInt(char * pDest, int i) -> char *      Parameters:         pDest: char *         i: int TInt_LoadFrugalInt(char * pSrc, int & i) -> char *      Parameters:         pSrc: char *         i: int & TInt_TestFrugalInt() TInt_SaveFrugalIntV(TSOut SOut, TIntV IntV)      Parameters:         SOut: TSOut &         IntV: TVec< TInt,int > const & LoadFrugalIntV(TSIn SIn, TIntV IntV, bool ClrP=True)      Parameters:         SIn: TSIn &         IntV: TVec< TInt,int > &         ClrP: bool      TInt_LoadFrugalIntV(TSIn SIn, TIntV IntV)      Parameters:         SIn: TSIn &         IntV: TVec< TInt,int > & Proxy of C++ TUInt class __init__(TUInt self) -> TUInt         __init__(TUInt self, uint const & _Val) -> TUInt          Parameters:             _Val: uint const &          __init__(TUInt self, TSIn SIn) -> TUInt          Parameters:             SIn: TSIn & Load(TUInt self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TUInt self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TUInt self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TUInt self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __call__(TUInt self) -> uint         __call__(TUInt self) -> uint &          Parameters:             self: TUInt * __invert__(TUInt self) -> TUInt          Parameters:             self: TUInt * __iand__(TUInt self, TUInt UInt) -> TUInt          Parameters:             UInt: TUInt const & __ior__(TUInt self, TUInt UInt) -> TUInt          Parameters:             UInt: TUInt const & __ixor__(TUInt self, TUInt UInt) -> TUInt          Parameters:             UInt: TUInt const & __irshift__(TUInt self, int const & ShiftBits) -> TUInt          Parameters:             ShiftBits: int const & __ilshift__(TUInt self, int const & ShiftBits) -> TUInt          Parameters:             ShiftBits: int const & GetMemUsed(TUInt self) -> int          Parameters:             self: TUInt const * GetPrimHashCd(TUInt self) -> int          Parameters:             self: TUInt const * GetSecHashCd(TUInt self) -> int          Parameters:             self: TUInt const * GetRnd(uint const & Range=0) -> uint          Parameters:             Range: uint const &          GetRnd() -> uint GetKiloStr(uint const & Val) -> TStr          Parameters:             Val: uint const & GetMegaStr(uint const & Val) -> TStr          Parameters:             Val: uint const & JavaUIntToCppUInt(uint const & JavaUInt) -> uint          Parameters:             JavaUInt: uint const & IsIpStr(TStr IpStr, uint & Ip, char const & SplitCh='.') -> bool          Parameters:             IpStr: TStr const &             Ip: uint &             SplitCh: char const &          IsIpStr(TStr IpStr, uint & Ip) -> bool          Parameters:             IpStr: TStr const &             Ip: uint &          IsIpStr(TStr IpStr, char const & SplitCh='.') -> bool          Parameters:             IpStr: TStr const &             SplitCh: char const &          IsIpStr(TStr IpStr) -> bool          Parameters:             IpStr: TStr const & GetUIntFromIpStr(TStr IpStr, char const & SplitCh='.') -> uint          Parameters:             IpStr: TStr const &             SplitCh: char const &          GetUIntFromIpStr(TStr IpStr) -> uint          Parameters:             IpStr: TStr const & GetStrFromIpUInt(uint const & Ip) -> TStr          Parameters:             Ip: uint const & IsIpv6Str(TStr IpStr, char const & SplitCh=':') -> bool          Parameters:             IpStr: TStr const &             SplitCh: char const &          IsIpv6Str(TStr IpStr) -> bool          Parameters:             IpStr: TStr const & GetRnd(uint const & Range=0) -> uint      Parameters:         Range: uint const &      TUInt_GetRnd() -> uint TUInt_GetKiloStr(uint const & Val) -> TStr      Parameters:         Val: uint const & TUInt_GetMegaStr(uint const & Val) -> TStr      Parameters:         Val: uint const & TUInt_JavaUIntToCppUInt(uint const & JavaUInt) -> uint      Parameters:         JavaUInt: uint const & IsIpStr(TStr IpStr, uint & Ip, char const & SplitCh='.') -> bool      Parameters:         IpStr: TStr const &         Ip: uint &         SplitCh: char const &      IsIpStr(TStr IpStr, uint & Ip) -> bool      Parameters:         IpStr: TStr const &         Ip: uint &      IsIpStr(TStr IpStr, char const & SplitCh='.') -> bool      Parameters:         IpStr: TStr const &         SplitCh: char const &      TUInt_IsIpStr(TStr IpStr) -> bool      Parameters:         IpStr: TStr const & GetUIntFromIpStr(TStr IpStr, char const & SplitCh='.') -> uint      Parameters:         IpStr: TStr const &         SplitCh: char const &      TUInt_GetUIntFromIpStr(TStr IpStr) -> uint      Parameters:         IpStr: TStr const & TUInt_GetStrFromIpUInt(uint const & Ip) -> TStr      Parameters:         Ip: uint const & IsIpv6Str(TStr IpStr, char const & SplitCh=':') -> bool      Parameters:         IpStr: TStr const &         SplitCh: char const &      TUInt_IsIpv6Str(TStr IpStr) -> bool      Parameters:         IpStr: TStr const & Proxy of C++ TUInt64 class __init__(TUInt64 self) -> TUInt64         __init__(TUInt64 self, TUInt64 Int) -> TUInt64          Parameters:             Int: TUInt64 const &          __init__(TUInt64 self, uint64 const & Int) -> TUInt64          Parameters:             Int: uint64 const &          __init__(TUInt64 self, uint const & MsVal, uint const & LsVal) -> TUInt64          Parameters:             MsVal: uint const &             LsVal: uint const &          __init__(TUInt64 self, void * Pt) -> TUInt64          Parameters:             Pt: void *          __init__(TUInt64 self, TSIn SIn) -> TUInt64          Parameters:             SIn: TSIn & Load(TUInt64 self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TUInt64 self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TUInt64 self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TUInt64 self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __iadd__(TUInt64 self, TUInt64 Int) -> TUInt64          Parameters:             Int: TUInt64 const & __isub__(TUInt64 self, TUInt64 Int) -> TUInt64          Parameters:             Int: TUInt64 const & GetMemUsed(TUInt64 self) -> int          Parameters:             self: TUInt64 const * GetPrimHashCd(TUInt64 self) -> int          Parameters:             self: TUInt64 const * GetSecHashCd(TUInt64 self) -> int          Parameters:             self: TUInt64 const * GetMsVal(TUInt64 self) -> uint          Parameters:             self: TUInt64 const * GetLsVal(TUInt64 self) -> uint          Parameters:             self: TUInt64 const * GetHexStr(TUInt64 Int) -> TStr          Parameters:             Int: TUInt64 const & GetKiloStr(uint64 const & Val) -> TStr          Parameters:             Val: uint64 const & GetMegaStr(uint64 const & Val) -> TStr          Parameters:             Val: uint64 const & TUInt64_GetHexStr(TUInt64 Int) -> TStr      Parameters:         Int: TUInt64 const & TUInt64_GetKiloStr(uint64 const & Val) -> TStr      Parameters:         Val: uint64 const & TUInt64_GetMegaStr(uint64 const & Val) -> TStr      Parameters:         Val: uint64 const & Proxy of C++ TFlt class __init__(TFlt self) -> TFlt         __init__(TFlt self, double const & _Val) -> TFlt          Parameters:             _Val: double const &          __init__(TFlt self, TSIn SIn) -> TFlt          Parameters:             SIn: TSIn &          __init__(TFlt self, TSIn SIn, bool const & IsTxt) -> TFlt          Parameters:             SIn: TSIn &             IsTxt: bool const & Load(TFlt self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TFlt self, TSOut SOut)          Parameters:             SOut: TSOut &          Save(TFlt self, TSOut SOut, bool const & IsTxt)          Parameters:             SOut: TSOut &             IsTxt: bool const & LoadXml(TFlt self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TFlt self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TFlt self, TFlt Flt) -> bool          Parameters:             Flt: TFlt const &          __eq__(TFlt self, double const & Flt) -> bool          Parameters:             Flt: double const & __ne__(TFlt self, double const & Flt) -> bool          Parameters:             Flt: double const & __call__(TFlt self) -> double          Parameters:             self: TFlt const * __iadd__(TFlt self, double const & Flt) -> TFlt          Parameters:             Flt: double const & __isub__(TFlt self, double const & Flt) -> TFlt          Parameters:             Flt: double const & __imul__(TFlt self, double const & Flt) -> TFlt          Parameters:             Flt: double const & __idiv__(TFlt self, double const & Flt) -> TFlt          Parameters:             Flt: double const & GetMemUsed(TFlt self) -> int          Parameters:             self: TFlt const * GetPrimHashCd(TFlt self) -> int          Parameters:             self: TFlt const * GetSecHashCd(TFlt self) -> int          Parameters:             self: TFlt const * Abs(double const & Flt) -> double          Parameters:             Flt: double const & Sign(double const & Flt) -> int          Parameters:             Flt: double const & Round(double const & Flt) -> int          Parameters:             Flt: double const & GetRnd() -> double Eq6(double const & LFlt, double const & RFlt) -> bool          Parameters:             LFlt: double const &             RFlt: double const & GetMn(double const & Flt1, double const & Flt2) -> double          Parameters:             Flt1: double const &             Flt2: double const &          GetMn(double const & Flt1, double const & Flt2, double const & Flt3) -> double          Parameters:             Flt1: double const &             Flt2: double const &             Flt3: double const &          GetMn(double const & Flt1, double const & Flt2, double const & Flt3, double const & Flt4) -> double          Parameters:             Flt1: double const &             Flt2: double const &             Flt3: double const &             Flt4: double const & GetMx(double const & Flt1, double const & Flt2) -> double          Parameters:             Flt1: double const &             Flt2: double const &          GetMx(double const & Flt1, double const & Flt2, double const Flt3) -> double          Parameters:             Flt1: double const &             Flt2: double const &             Flt3: double const          GetMx(double const & Flt1, double const & Flt2, double const Flt3, double const & Flt4) -> double          Parameters:             Flt1: double const &             Flt2: double const &             Flt3: double const             Flt4: double const & GetInRng(double const & Val, double const & Mn, double const & Mx) -> double          Parameters:             Val: double const &             Mn: double const &             Mx: double const & IsNum(TFlt self, double const & Val) -> bool          Parameters:             Val: double const &          IsNum(TFlt self) -> bool          Parameters:             self: TFlt const * IsNan(TFlt self, double const & Val) -> bool          Parameters:             Val: double const &          IsNan(TFlt self) -> bool          Parameters:             self: TFlt const * GetPrcStr(double const & RelVal, double const & FullVal) -> TStr          Parameters:             RelVal: double const &             FullVal: double const & GetKiloStr(double const & Val) -> TStr          Parameters:             Val: double const & GetMegaStr(double const & Val) -> TStr          Parameters:             Val: double const & GetGigaStr(double const & Val) -> TStr          Parameters:             Val: double const & TFlt_Abs(double const & Flt) -> double      Parameters:         Flt: double const & TFlt_Sign(double const & Flt) -> int      Parameters:         Flt: double const & TFlt_Round(double const & Flt) -> int      Parameters:         Flt: double const & TFlt_GetRnd() -> double TFlt_Eq6(double const & LFlt, double const & RFlt) -> bool      Parameters:         LFlt: double const &         RFlt: double const & GetMn(double const & Flt1, double const & Flt2) -> double      Parameters:         Flt1: double const &         Flt2: double const &      GetMn(double const & Flt1, double const & Flt2, double const & Flt3) -> double      Parameters:         Flt1: double const &         Flt2: double const &         Flt3: double const &      TFlt_GetMn(double const & Flt1, double const & Flt2, double const & Flt3, double const & Flt4) -> double      Parameters:         Flt1: double const &         Flt2: double const &         Flt3: double const &         Flt4: double const & GetMx(double const & Flt1, double const & Flt2) -> double      Parameters:         Flt1: double const &         Flt2: double const &      GetMx(double const & Flt1, double const & Flt2, double const Flt3) -> double      Parameters:         Flt1: double const &         Flt2: double const &         Flt3: double const      TFlt_GetMx(double const & Flt1, double const & Flt2, double const Flt3, double const & Flt4) -> double      Parameters:         Flt1: double const &         Flt2: double const &         Flt3: double const         Flt4: double const & TFlt_GetInRng(double const & Val, double const & Mn, double const & Mx) -> double      Parameters:         Val: double const &         Mn: double const &         Mx: double const & TFlt_GetPrcStr(double const & RelVal, double const & FullVal) -> TStr      Parameters:         RelVal: double const &         FullVal: double const & TFlt_GetKiloStr(double const & Val) -> TStr      Parameters:         Val: double const & TFlt_GetMegaStr(double const & Val) -> TStr      Parameters:         Val: double const & TFlt_GetGigaStr(double const & Val) -> TStr      Parameters:         Val: double const & Proxy of C++ TAscFlt class __init__(TAscFlt self) -> TAscFlt         __init__(TAscFlt self, double const & Val) -> TAscFlt          Parameters:             Val: double const &          __init__(TAscFlt self, TSIn SIn) -> TAscFlt          Parameters:             SIn: TSIn & Save(TAscFlt self, TSOut SOut)          Parameters:             SOut: TSOut & Proxy of C++ TSFlt class __init__(TSFlt self) -> TSFlt         __init__(TSFlt self, sdouble const & _Val) -> TSFlt          Parameters:             _Val: sdouble const &          __init__(TSFlt self, TSIn SIn) -> TSFlt          Parameters:             SIn: TSIn & Save(TSFlt self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TSFlt self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TSFlt self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TSFlt self, TSFlt SFlt) -> bool          Parameters:             SFlt: TSFlt const &          __eq__(TSFlt self, double const & Flt) -> bool          Parameters:             Flt: double const & __ne__(TSFlt self, double const & Flt) -> bool          Parameters:             Flt: double const & __lt__(TSFlt self, TSFlt SFlt) -> bool          Parameters:             SFlt: TSFlt const & __call__(TSFlt self) -> sdouble          Parameters:             self: TSFlt const * __iadd__(TSFlt self, double const & SFlt) -> TSFlt          Parameters:             SFlt: double const & __isub__(TSFlt self, double const & SFlt) -> TSFlt          Parameters:             SFlt: double const & __imul__(TSFlt self, double const & SFlt) -> TSFlt          Parameters:             SFlt: double const & __idiv__(TSFlt self, double const & SFlt) -> TSFlt          Parameters:             SFlt: double const & GetMemUsed(TSFlt self) -> int          Parameters:             self: TSFlt const * GetPrimHashCd(TSFlt self) -> int          Parameters:             self: TSFlt const * GetSecHashCd(TSFlt self) -> int          Parameters:             self: TSFlt const * Proxy of C++ TLFlt class __init__(TLFlt self) -> TLFlt         __init__(TLFlt self, ldouble const & _Val) -> TLFlt          Parameters:             _Val: ldouble const &          __init__(TLFlt self, TSIn SIn) -> TLFlt          Parameters:             SIn: TSIn & Save(TLFlt self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TLFlt self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TLFlt self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TLFlt self, TLFlt LFlt) -> bool          Parameters:             LFlt: TLFlt const &          __eq__(TLFlt self, ldouble const & LFlt) -> bool          Parameters:             LFlt: ldouble const & __ne__(TLFlt self, ldouble const & LFlt) -> bool          Parameters:             LFlt: ldouble const & __lt__(TLFlt self, TLFlt LFlt) -> bool          Parameters:             LFlt: TLFlt const & __call__(TLFlt self) -> ldouble          Parameters:             self: TLFlt const * __iadd__(TLFlt self, ldouble const & LFlt) -> TLFlt          Parameters:             LFlt: ldouble const & __isub__(TLFlt self, ldouble const & LFlt) -> TLFlt          Parameters:             LFlt: ldouble const & GetMemUsed(TLFlt self) -> int          Parameters:             self: TLFlt const * GetPrimHashCd(TLFlt self) -> int          Parameters:             self: TLFlt const * GetSecHashCd(TLFlt self) -> int          Parameters:             self: TLFlt const * Proxy of C++ TFltRect class __init__(TFltRect self) -> TFltRect         __init__(TFltRect self, TFltRect FltRect) -> TFltRect          Parameters:             FltRect: TFltRect const &          __init__(TFltRect self, double const & _MnX, double const & _MnY, double const & _MxX, double const & _MxY) -> TFltRect          Parameters:             _MnX: double const &             _MnY: double const &             _MxX: double const &             _MxY: double const &          __init__(TFltRect self, TSIn SIn) -> TFltRect          Parameters:             SIn: TSIn & Save(TFltRect self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TFltRect self, PXmlTok const & XmlTok, TStr Nm)          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const & SaveXml(TFltRect self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & GetMnX(TFltRect self) -> double          Parameters:             self: TFltRect const * GetMnY(TFltRect self) -> double          Parameters:             self: TFltRect const * GetMxX(TFltRect self) -> double          Parameters:             self: TFltRect const * GetMxY(TFltRect self) -> double          Parameters:             self: TFltRect const * GetXLen(TFltRect self) -> double          Parameters:             self: TFltRect const * GetYLen(TFltRect self) -> double          Parameters:             self: TFltRect const * GetXCenter(TFltRect self) -> double          Parameters:             self: TFltRect const * GetYCenter(TFltRect self) -> double          Parameters:             self: TFltRect const * IsXYIn(TFltRect self, double const & X, double const & Y) -> bool          Parameters:             X: double const &             Y: double const & Intersection(TFltRect Rect1, TFltRect Rect2) -> bool          Parameters:             Rect1: TFltRect const &             Rect2: TFltRect const & TFltRect_Intersection(TFltRect Rect1, TFltRect Rect2) -> bool      Parameters:         Rect1: TFltRect const &         Rect2: TFltRect const & Proxy of C++ TVec<(TInt,int)> class __init__(TVec<(TInt,int)> self) -> TIntV         __init__(TVec<(TInt,int)> self, TIntV Vec) -> TIntV          Parameters:             Vec: TVec< TInt,int > const &          __init__(TVec<(TInt,int)> self, int const & _Vals) -> TIntV          Parameters:             _Vals: int const &          __init__(TVec<(TInt,int)> self, int const & _MxVals, int const & _Vals) -> TIntV          Parameters:             _MxVals: int const &             _Vals: int const &          __init__(TVec<(TInt,int)> self, TInt _ValT, int const & _Vals) -> TIntV          Parameters:             _ValT: TInt *             _Vals: int const &          __init__(TVec<(TInt,int)> self, TSIn SIn) -> TIntV          Parameters:             SIn: TSIn & Load(TIntV self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TIntV self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TIntV self, PXmlTok const & XmlTok, TStr Nm="")          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const &          LoadXml(TIntV self, PXmlTok const & XmlTok)          Parameters:             XmlTok: PXmlTok const & SaveXml(TIntV self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __add__(TIntV self, TInt Val) -> TIntV          Parameters:             Val: TInt const & __eq__(TIntV self, TIntV Vec) -> bool          Parameters:             Vec: TVec< TInt,int > const & __lt__(TIntV self, TIntV Vec) -> bool          Parameters:             Vec: TVec< TInt,int > const & GetMemUsed(TIntV self) -> int          Parameters:             self: TVec< TInt,int > const * GetMemSize(TIntV self) -> int          Parameters:             self: TVec< TInt,int > const * GetPrimHashCd(TIntV self) -> int          Parameters:             self: TVec< TInt,int > const * GetSecHashCd(TIntV self) -> int          Parameters:             self: TVec< TInt,int > const * Gen(TIntV self, int const & _Vals)          Parameters:             _Vals: int const &          Gen(TIntV self, int const & _MxVals, int const & _Vals)          Parameters:             _MxVals: int const &             _Vals: int const & GenExt(TIntV self, TInt _ValT, int const & _Vals)          Parameters:             _ValT: TInt *             _Vals: int const & IsExt(TIntV self) -> bool          Parameters:             self: TVec< TInt,int > const * Reserve(TIntV self, int const & _MxVals)          Parameters:             _MxVals: int const &          Reserve(TIntV self, int const & _MxVals, int const & _Vals)          Parameters:             _MxVals: int const &             _Vals: int const & Clr(TIntV self, bool const & DoDel=True, int const & NoDelLim=-1)          Parameters:             DoDel: bool const &             NoDelLim: int const &          Clr(TIntV self, bool const & DoDel=True)          Parameters:             DoDel: bool const &          Clr(TIntV self)          Parameters:             self: TVec< TInt,int > * Trunc(TIntV self, int const & _Vals=-1)          Parameters:             _Vals: int const &          Trunc(TIntV self)          Parameters:             self: TVec< TInt,int > * Pack(TIntV self)          Parameters:             self: TVec< TInt,int > * MoveFrom(TIntV self, TIntV Vec)          Parameters:             Vec: TVec< TInt,int > & Empty(TIntV self) -> bool          Parameters:             self: TVec< TInt,int > const * Len(TIntV self) -> int          Parameters:             self: TVec< TInt,int > const * Reserved(TIntV self) -> int          Parameters:             self: TVec< TInt,int > const * Last(TIntV self) -> TInt         Last(TIntV self) -> TInt          Parameters:             self: TVec< TInt,int > * LastValN(TIntV self) -> int          Parameters:             self: TVec< TInt,int > const * LastLast(TIntV self) -> TInt         LastLast(TIntV self) -> TInt          Parameters:             self: TVec< TInt,int > * BegI(TIntV self) -> TInt          Parameters:             self: TVec< TInt,int > const * EndI(TIntV self) -> TInt          Parameters:             self: TVec< TInt,int > const * GetI(TIntV self, int const & ValN) -> TInt          Parameters:             ValN: int const & AddV(TIntV self, TIntV ValV) -> int          Parameters:             ValV: TVec< TInt,int > const & AddSorted(TIntV self, TInt Val, bool const & Asc=True, int const & _MxVals=-1) -> int          Parameters:             Val: TInt const &             Asc: bool const &             _MxVals: int const &          AddSorted(TIntV self, TInt Val, bool const & Asc=True) -> int          Parameters:             Val: TInt const &             Asc: bool const &          AddSorted(TIntV self, TInt Val) -> int          Parameters:             Val: TInt const & AddBackSorted(TIntV self, TInt Val, bool const & Asc) -> int          Parameters:             Val: TInt const &             Asc: bool const & AddVMerged(TIntV self, TIntV ValV) -> int          Parameters:             ValV: TVec< TInt,int > const & AddUnique(TIntV self, TInt Val) -> int          Parameters:             Val: TInt const & GetVal(TIntV self, int const & ValN) -> TInt          Parameters:             ValN: int const &          GetVal(TIntV self, int const & ValN) -> TInt          Parameters:             ValN: int const & GetSubValV(TIntV self, int const & BValN, int const & EValN, TIntV ValV)          Parameters:             BValN: int const &             EValN: int const &             ValV: TVec< TInt,int > & Ins(TIntV self, int const & ValN, TInt Val)          Parameters:             ValN: int const &             Val: TInt const & Del(TIntV self, int const & ValN)          Parameters:             ValN: int const &          Del(TIntV self, int const & MnValN, int const & MxValN)          Parameters:             MnValN: int const &             MxValN: int const & DelLast(TIntV self)          Parameters:             self: TVec< TInt,int > * DelIfIn(TIntV self, TInt Val) -> bool          Parameters:             Val: TInt const & DelAll(TIntV self, TInt Val)          Parameters:             Val: TInt const & PutAll(TIntV self, TInt Val)          Parameters:             Val: TInt const & Swap(TIntV self, TIntV Vec)          Parameters:             Vec: TVec< TInt,int > &          Swap(TIntV self, int const & ValN1, int const & ValN2)          Parameters:             ValN1: int const &             ValN2: int const & SwapI(TInt LVal, TInt RVal)          Parameters:             LVal: TVec< TInt,int >::TIter             RVal: TVec< TInt,int >::TIter NextPerm(TIntV self) -> bool          Parameters:             self: TVec< TInt,int > * PrevPerm(TIntV self) -> bool          Parameters:             self: TVec< TInt,int > * GetPivotValN(TIntV self, int const & LValN, int const & RValN) -> int          Parameters:             LValN: int const &             RValN: int const & BSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & ISort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & Partition(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & QSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & Sort(TIntV self, bool const & Asc=True)          Parameters:             Asc: bool const &          Sort(TIntV self)          Parameters:             self: TVec< TInt,int > * IsSorted(TIntV self, bool const & Asc=True) -> bool          Parameters:             Asc: bool const &          IsSorted(TIntV self) -> bool          Parameters:             self: TVec< TInt,int > const * Shuffle(TIntV self, TRnd Rnd)          Parameters:             Rnd: TRnd & Reverse(TIntV self)         Reverse(TIntV self, int LValN, int RValN)          Parameters:             LValN: int             RValN: int Merge(TIntV self)          Parameters:             self: TVec< TInt,int > * Intrs(TIntV self, TIntV ValV)          Parameters:             ValV: TVec< TInt,int > const &          Intrs(TIntV self, TIntV ValV, TIntV DstValV)          Parameters:             ValV: TVec< TInt,int > const &             DstValV: TVec< TInt,int > & Union(TIntV self, TIntV ValV)          Parameters:             ValV: TVec< TInt,int > const &          Union(TIntV self, TIntV ValV, TIntV DstValV)          Parameters:             ValV: TVec< TInt,int > const &             DstValV: TVec< TInt,int > & Diff(TIntV self, TIntV ValV)          Parameters:             ValV: TVec< TInt,int > const &          Diff(TIntV self, TIntV ValV, TIntV DstValV)          Parameters:             ValV: TVec< TInt,int > const &             DstValV: TVec< TInt,int > & IntrsLen(TIntV self, TIntV ValV) -> int          Parameters:             ValV: TVec< TInt,int > const & UnionLen(TIntV self, TIntV ValV) -> int          Parameters:             ValV: TVec< TInt,int > const & Count(TIntV self, TInt Val) -> int          Parameters:             Val: TInt const & SearchBin(TIntV self, TInt Val) -> int          Parameters:             Val: TInt const &          SearchBin(TIntV self, TInt Val, int & InsValN) -> int          Parameters:             Val: TInt const &             InsValN: int & SearchForw(TIntV self, TInt Val, int const & BValN=0) -> int          Parameters:             Val: TInt const &             BValN: int const &          SearchForw(TIntV self, TInt Val) -> int          Parameters:             Val: TInt const & SearchBack(TIntV self, TInt Val) -> int          Parameters:             Val: TInt const & SearchVForw(TIntV self, TIntV ValV, int const & BValN=0) -> int          Parameters:             ValV: TVec< TInt,int > const &             BValN: int const &          SearchVForw(TIntV self, TIntV ValV) -> int          Parameters:             ValV: TVec< TInt,int > const & IsIn(TIntV self, TInt Val) -> bool          Parameters:             Val: TInt const &          IsIn(TIntV self, TInt Val, int & ValN) -> bool          Parameters:             Val: TInt const &             ValN: int & IsInBin(TIntV self, TInt Val) -> bool          Parameters:             Val: TInt const & GetDat(TIntV self, TInt Val) -> TInt          Parameters:             Val: TInt const & GetAddDat(TIntV self, TInt Val) -> TInt          Parameters:             Val: TInt const & GetMxValN(TIntV self) -> int          Parameters:             self: TVec< TInt,int > const * GetV(TInt Val1) -> TIntV          Parameters:             Val1: TInt const &          GetV(TInt Val1, TInt Val2) -> TIntV          Parameters:             Val1: TInt const &             Val2: TInt const &          GetV(TInt Val1, TInt Val2, TInt Val3) -> TIntV          Parameters:             Val1: TInt const &             Val2: TInt const &             Val3: TInt const &          GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4) -> TIntV          Parameters:             Val1: TInt const &             Val2: TInt const &             Val3: TInt const &             Val4: TInt const &          GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5) -> TIntV          Parameters:             Val1: TInt const &             Val2: TInt const &             Val3: TInt const &             Val4: TInt const &             Val5: TInt const &          GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6) -> TIntV          Parameters:             Val1: TInt const &             Val2: TInt const &             Val3: TInt const &             Val4: TInt const &             Val5: TInt const &             Val6: TInt const &          GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7) -> TIntV          Parameters:             Val1: TInt const &             Val2: TInt const &             Val3: TInt const &             Val4: TInt const &             Val5: TInt const &             Val6: TInt const &             Val7: TInt const &          GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8) -> TIntV          Parameters:             Val1: TInt const &             Val2: TInt const &             Val3: TInt const &             Val4: TInt const &             Val5: TInt const &             Val6: TInt const &             Val7: TInt const &             Val8: TInt const &          GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8,              TInt Val9) -> TIntV          Parameters:             Val1: TInt const &             Val2: TInt const &             Val3: TInt const &             Val4: TInt const &             Val5: TInt const &             Val6: TInt const &             Val7: TInt const &             Val8: TInt const &             Val9: TInt const & Add(TIntV self) -> int         Add(TIntV self, TInt Val) -> int          Parameters:             Val: TInt const &          Add(TIntV self, TInt Val, int const & ResizeLen) -> int          Parameters:             Val: TInt const &             ResizeLen: int const &          Add(TIntV self, int Val) -> int          Parameters:             Val: int AddMerged(TIntV self, TInt Val) -> int          Parameters:             Val: TInt const &          AddMerged(TIntV self, int Val) -> int          Parameters:             Val: int TIntV_SwapI(TInt LVal, TInt RVal)      Parameters:         LVal: TVec< TInt,int >::TIter         RVal: TVec< TInt,int >::TIter GetV(TInt Val1) -> TIntV      Parameters:         Val1: TInt const &      GetV(TInt Val1, TInt Val2) -> TIntV      Parameters:         Val1: TInt const &         Val2: TInt const &      GetV(TInt Val1, TInt Val2, TInt Val3) -> TIntV      Parameters:         Val1: TInt const &         Val2: TInt const &         Val3: TInt const &      GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4) -> TIntV      Parameters:         Val1: TInt const &         Val2: TInt const &         Val3: TInt const &         Val4: TInt const &      GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5) -> TIntV      Parameters:         Val1: TInt const &         Val2: TInt const &         Val3: TInt const &         Val4: TInt const &         Val5: TInt const &      GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6) -> TIntV      Parameters:         Val1: TInt const &         Val2: TInt const &         Val3: TInt const &         Val4: TInt const &         Val5: TInt const &         Val6: TInt const &      GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7) -> TIntV      Parameters:         Val1: TInt const &         Val2: TInt const &         Val3: TInt const &         Val4: TInt const &         Val5: TInt const &         Val6: TInt const &         Val7: TInt const &      GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8) -> TIntV      Parameters:         Val1: TInt const &         Val2: TInt const &         Val3: TInt const &         Val4: TInt const &         Val5: TInt const &         Val6: TInt const &         Val7: TInt const &         Val8: TInt const &      TIntV_GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8,          TInt Val9) -> TIntV      Parameters:         Val1: TInt const &         Val2: TInt const &         Val3: TInt const &         Val4: TInt const &         Val5: TInt const &         Val6: TInt const &         Val7: TInt const &         Val8: TInt const &         Val9: TInt const & Proxy of C++ TVec<(TVec<(TInt,int)>,int)> class __init__(TVec<(TVec<(TInt,int)>,int)> self) -> TIntIntVV         __init__(TVec<(TVec<(TInt,int)>,int)> self, TIntIntVV Vec) -> TIntIntVV          Parameters:             Vec: TVec< TVec< TInt,int >,int > const &          __init__(TVec<(TVec<(TInt,int)>,int)> self, int const & _Vals) -> TIntIntVV          Parameters:             _Vals: int const &          __init__(TVec<(TVec<(TInt,int)>,int)> self, int const & _MxVals, int const & _Vals) -> TIntIntVV          Parameters:             _MxVals: int const &             _Vals: int const &          __init__(TVec<(TVec<(TInt,int)>,int)> self, TIntV _ValT, int const & _Vals) -> TIntIntVV          Parameters:             _ValT: TVec< TInt,int > *             _Vals: int const &          __init__(TVec<(TVec<(TInt,int)>,int)> self, TSIn SIn) -> TIntIntVV          Parameters:             SIn: TSIn & Load(TIntIntVV self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TIntIntVV self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TIntIntVV self, PXmlTok const & XmlTok, TStr Nm="")          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const &          LoadXml(TIntIntVV self, PXmlTok const & XmlTok)          Parameters:             XmlTok: PXmlTok const & SaveXml(TIntIntVV self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __add__(TIntIntVV self, TIntV Val) -> TIntIntVV          Parameters:             Val: TVec< TInt,int > const & __eq__(TIntIntVV self, TIntIntVV Vec) -> bool          Parameters:             Vec: TVec< TVec< TInt,int >,int > const & __lt__(TIntIntVV self, TIntIntVV Vec) -> bool          Parameters:             Vec: TVec< TVec< TInt,int >,int > const & GetMemUsed(TIntIntVV self) -> int          Parameters:             self: TVec< TVec< TInt,int >,int > const * GetMemSize(TIntIntVV self) -> int          Parameters:             self: TVec< TVec< TInt,int >,int > const * GetPrimHashCd(TIntIntVV self) -> int          Parameters:             self: TVec< TVec< TInt,int >,int > const * GetSecHashCd(TIntIntVV self) -> int          Parameters:             self: TVec< TVec< TInt,int >,int > const * Gen(TIntIntVV self, int const & _Vals)          Parameters:             _Vals: int const &          Gen(TIntIntVV self, int const & _MxVals, int const & _Vals)          Parameters:             _MxVals: int const &             _Vals: int const & GenExt(TIntIntVV self, TIntV _ValT, int const & _Vals)          Parameters:             _ValT: TVec< TInt,int > *             _Vals: int const & IsExt(TIntIntVV self) -> bool          Parameters:             self: TVec< TVec< TInt,int >,int > const * Reserve(TIntIntVV self, int const & _MxVals)          Parameters:             _MxVals: int const &          Reserve(TIntIntVV self, int const & _MxVals, int const & _Vals)          Parameters:             _MxVals: int const &             _Vals: int const & Clr(TIntIntVV self, bool const & DoDel=True, int const & NoDelLim=-1)          Parameters:             DoDel: bool const &             NoDelLim: int const &          Clr(TIntIntVV self, bool const & DoDel=True)          Parameters:             DoDel: bool const &          Clr(TIntIntVV self)          Parameters:             self: TVec< TVec< TInt,int >,int > * Trunc(TIntIntVV self, int const & _Vals=-1)          Parameters:             _Vals: int const &          Trunc(TIntIntVV self)          Parameters:             self: TVec< TVec< TInt,int >,int > * Pack(TIntIntVV self)          Parameters:             self: TVec< TVec< TInt,int >,int > * MoveFrom(TIntIntVV self, TIntIntVV Vec)          Parameters:             Vec: TVec< TVec< TInt,int >,int > & Empty(TIntIntVV self) -> bool          Parameters:             self: TVec< TVec< TInt,int >,int > const * Len(TIntIntVV self) -> int          Parameters:             self: TVec< TVec< TInt,int >,int > const * Reserved(TIntIntVV self) -> int          Parameters:             self: TVec< TVec< TInt,int >,int > const * Last(TIntIntVV self) -> TIntV         Last(TIntIntVV self) -> TIntV          Parameters:             self: TVec< TVec< TInt,int >,int > * LastValN(TIntIntVV self) -> int          Parameters:             self: TVec< TVec< TInt,int >,int > const * LastLast(TIntIntVV self) -> TIntV         LastLast(TIntIntVV self) -> TIntV          Parameters:             self: TVec< TVec< TInt,int >,int > * BegI(TIntIntVV self) -> TIntV          Parameters:             self: TVec< TVec< TInt,int >,int > const * EndI(TIntIntVV self) -> TIntV          Parameters:             self: TVec< TVec< TInt,int >,int > const * GetI(TIntIntVV self, int const & ValN) -> TIntV          Parameters:             ValN: int const & AddV(TIntIntVV self, TIntIntVV ValV) -> int          Parameters:             ValV: TVec< TVec< TInt,int >,int > const & AddSorted(TIntIntVV self, TIntV Val, bool const & Asc=True, int const & _MxVals=-1) -> int          Parameters:             Val: TVec< TInt,int > const &             Asc: bool const &             _MxVals: int const &          AddSorted(TIntIntVV self, TIntV Val, bool const & Asc=True) -> int          Parameters:             Val: TVec< TInt,int > const &             Asc: bool const &          AddSorted(TIntIntVV self, TIntV Val) -> int          Parameters:             Val: TVec< TInt,int > const & AddBackSorted(TIntIntVV self, TIntV Val, bool const & Asc) -> int          Parameters:             Val: TVec< TInt,int > const &             Asc: bool const & AddVMerged(TIntIntVV self, TIntIntVV ValV) -> int          Parameters:             ValV: TVec< TVec< TInt,int >,int > const & AddUnique(TIntIntVV self, TIntV Val) -> int          Parameters:             Val: TVec< TInt,int > const & GetVal(TIntIntVV self, int const & ValN) -> TIntV          Parameters:             ValN: int const &          GetVal(TIntIntVV self, int const & ValN) -> TIntV          Parameters:             ValN: int const & GetSubValV(TIntIntVV self, int const & BValN, int const & EValN, TIntIntVV ValV)          Parameters:             BValN: int const &             EValN: int const &             ValV: TVec< TVec< TInt,int >,int > & Ins(TIntIntVV self, int const & ValN, TIntV Val)          Parameters:             ValN: int const &             Val: TVec< TInt,int > const & Del(TIntIntVV self, int const & ValN)          Parameters:             ValN: int const &          Del(TIntIntVV self, int const & MnValN, int const & MxValN)          Parameters:             MnValN: int const &             MxValN: int const & DelLast(TIntIntVV self)          Parameters:             self: TVec< TVec< TInt,int >,int > * DelIfIn(TIntIntVV self, TIntV Val) -> bool          Parameters:             Val: TVec< TInt,int > const & DelAll(TIntIntVV self, TIntV Val)          Parameters:             Val: TVec< TInt,int > const & PutAll(TIntIntVV self, TIntV Val)          Parameters:             Val: TVec< TInt,int > const & Swap(TIntIntVV self, TIntIntVV Vec)          Parameters:             Vec: TVec< TVec< TInt,int >,int > &          Swap(TIntIntVV self, int const & ValN1, int const & ValN2)          Parameters:             ValN1: int const &             ValN2: int const & SwapI(TIntV LVal, TIntV RVal)          Parameters:             LVal: TVec< TVec< TInt,int >,int >::TIter             RVal: TVec< TVec< TInt,int >,int >::TIter NextPerm(TIntIntVV self) -> bool          Parameters:             self: TVec< TVec< TInt,int >,int > * PrevPerm(TIntIntVV self) -> bool          Parameters:             self: TVec< TVec< TInt,int >,int > * GetPivotValN(TIntIntVV self, int const & LValN, int const & RValN) -> int          Parameters:             LValN: int const &             RValN: int const & BSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & ISort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & Partition(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & QSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & Sort(TIntIntVV self, bool const & Asc=True)          Parameters:             Asc: bool const &          Sort(TIntIntVV self)          Parameters:             self: TVec< TVec< TInt,int >,int > * IsSorted(TIntIntVV self, bool const & Asc=True) -> bool          Parameters:             Asc: bool const &          IsSorted(TIntIntVV self) -> bool          Parameters:             self: TVec< TVec< TInt,int >,int > const * Shuffle(TIntIntVV self, TRnd Rnd)          Parameters:             Rnd: TRnd & Reverse(TIntIntVV self)         Reverse(TIntIntVV self, int LValN, int RValN)          Parameters:             LValN: int             RValN: int Merge(TIntIntVV self)          Parameters:             self: TVec< TVec< TInt,int >,int > * Intrs(TIntIntVV self, TIntIntVV ValV)          Parameters:             ValV: TVec< TVec< TInt,int >,int > const &          Intrs(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)          Parameters:             ValV: TVec< TVec< TInt,int >,int > const &             DstValV: TVec< TVec< TInt,int >,int > & Union(TIntIntVV self, TIntIntVV ValV)          Parameters:             ValV: TVec< TVec< TInt,int >,int > const &          Union(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)          Parameters:             ValV: TVec< TVec< TInt,int >,int > const &             DstValV: TVec< TVec< TInt,int >,int > & Diff(TIntIntVV self, TIntIntVV ValV)          Parameters:             ValV: TVec< TVec< TInt,int >,int > const &          Diff(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)          Parameters:             ValV: TVec< TVec< TInt,int >,int > const &             DstValV: TVec< TVec< TInt,int >,int > & IntrsLen(TIntIntVV self, TIntIntVV ValV) -> int          Parameters:             ValV: TVec< TVec< TInt,int >,int > const & UnionLen(TIntIntVV self, TIntIntVV ValV) -> int          Parameters:             ValV: TVec< TVec< TInt,int >,int > const & Count(TIntIntVV self, TIntV Val) -> int          Parameters:             Val: TVec< TInt,int > const & SearchBin(TIntIntVV self, TIntV Val) -> int          Parameters:             Val: TVec< TInt,int > const &          SearchBin(TIntIntVV self, TIntV Val, int & InsValN) -> int          Parameters:             Val: TVec< TInt,int > const &             InsValN: int & SearchForw(TIntIntVV self, TIntV Val, int const & BValN=0) -> int          Parameters:             Val: TVec< TInt,int > const &             BValN: int const &          SearchForw(TIntIntVV self, TIntV Val) -> int          Parameters:             Val: TVec< TInt,int > const & SearchBack(TIntIntVV self, TIntV Val) -> int          Parameters:             Val: TVec< TInt,int > const & SearchVForw(TIntIntVV self, TIntIntVV ValV, int const & BValN=0) -> int          Parameters:             ValV: TVec< TVec< TInt,int >,int > const &             BValN: int const &          SearchVForw(TIntIntVV self, TIntIntVV ValV) -> int          Parameters:             ValV: TVec< TVec< TInt,int >,int > const & IsIn(TIntIntVV self, TIntV Val) -> bool          Parameters:             Val: TVec< TInt,int > const &          IsIn(TIntIntVV self, TIntV Val, int & ValN) -> bool          Parameters:             Val: TVec< TInt,int > const &             ValN: int & IsInBin(TIntIntVV self, TIntV Val) -> bool          Parameters:             Val: TVec< TInt,int > const & GetDat(TIntIntVV self, TIntV Val) -> TIntV          Parameters:             Val: TVec< TInt,int > const & GetAddDat(TIntIntVV self, TIntV Val) -> TIntV          Parameters:             Val: TVec< TInt,int > const & GetMxValN(TIntIntVV self) -> int          Parameters:             self: TVec< TVec< TInt,int >,int > const * GetV(TIntV Val1) -> TIntIntVV          Parameters:             Val1: TVec< TInt,int > const &          GetV(TIntV Val1, TIntV Val2) -> TIntIntVV          Parameters:             Val1: TVec< TInt,int > const &             Val2: TVec< TInt,int > const &          GetV(TIntV Val1, TIntV Val2, TIntV Val3) -> TIntIntVV          Parameters:             Val1: TVec< TInt,int > const &             Val2: TVec< TInt,int > const &             Val3: TVec< TInt,int > const &          GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4) -> TIntIntVV          Parameters:             Val1: TVec< TInt,int > const &             Val2: TVec< TInt,int > const &             Val3: TVec< TInt,int > const &             Val4: TVec< TInt,int > const &          GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5) -> TIntIntVV          Parameters:             Val1: TVec< TInt,int > const &             Val2: TVec< TInt,int > const &             Val3: TVec< TInt,int > const &             Val4: TVec< TInt,int > const &             Val5: TVec< TInt,int > const &          GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6) -> TIntIntVV          Parameters:             Val1: TVec< TInt,int > const &             Val2: TVec< TInt,int > const &             Val3: TVec< TInt,int > const &             Val4: TVec< TInt,int > const &             Val5: TVec< TInt,int > const &             Val6: TVec< TInt,int > const &          GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7) -> TIntIntVV          Parameters:             Val1: TVec< TInt,int > const &             Val2: TVec< TInt,int > const &             Val3: TVec< TInt,int > const &             Val4: TVec< TInt,int > const &             Val5: TVec< TInt,int > const &             Val6: TVec< TInt,int > const &             Val7: TVec< TInt,int > const &          GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7,              TIntV Val8) -> TIntIntVV          Parameters:             Val1: TVec< TInt,int > const &             Val2: TVec< TInt,int > const &             Val3: TVec< TInt,int > const &             Val4: TVec< TInt,int > const &             Val5: TVec< TInt,int > const &             Val6: TVec< TInt,int > const &             Val7: TVec< TInt,int > const &             Val8: TVec< TInt,int > const &          GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7,              TIntV Val8, TIntV Val9) -> TIntIntVV          Parameters:             Val1: TVec< TInt,int > const &             Val2: TVec< TInt,int > const &             Val3: TVec< TInt,int > const &             Val4: TVec< TInt,int > const &             Val5: TVec< TInt,int > const &             Val6: TVec< TInt,int > const &             Val7: TVec< TInt,int > const &             Val8: TVec< TInt,int > const &             Val9: TVec< TInt,int > const & TIntIntVV_SwapI(TIntV LVal, TIntV RVal)      Parameters:         LVal: TVec< TVec< TInt,int >,int >::TIter         RVal: TVec< TVec< TInt,int >,int >::TIter GetV(TIntV Val1) -> TIntIntVV      Parameters:         Val1: TVec< TInt,int > const &      GetV(TIntV Val1, TIntV Val2) -> TIntIntVV      Parameters:         Val1: TVec< TInt,int > const &         Val2: TVec< TInt,int > const &      GetV(TIntV Val1, TIntV Val2, TIntV Val3) -> TIntIntVV      Parameters:         Val1: TVec< TInt,int > const &         Val2: TVec< TInt,int > const &         Val3: TVec< TInt,int > const &      GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4) -> TIntIntVV      Parameters:         Val1: TVec< TInt,int > const &         Val2: TVec< TInt,int > const &         Val3: TVec< TInt,int > const &         Val4: TVec< TInt,int > const &      GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5) -> TIntIntVV      Parameters:         Val1: TVec< TInt,int > const &         Val2: TVec< TInt,int > const &         Val3: TVec< TInt,int > const &         Val4: TVec< TInt,int > const &         Val5: TVec< TInt,int > const &      GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6) -> TIntIntVV      Parameters:         Val1: TVec< TInt,int > const &         Val2: TVec< TInt,int > const &         Val3: TVec< TInt,int > const &         Val4: TVec< TInt,int > const &         Val5: TVec< TInt,int > const &         Val6: TVec< TInt,int > const &      GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7) -> TIntIntVV      Parameters:         Val1: TVec< TInt,int > const &         Val2: TVec< TInt,int > const &         Val3: TVec< TInt,int > const &         Val4: TVec< TInt,int > const &         Val5: TVec< TInt,int > const &         Val6: TVec< TInt,int > const &         Val7: TVec< TInt,int > const &      GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7,          TIntV Val8) -> TIntIntVV      Parameters:         Val1: TVec< TInt,int > const &         Val2: TVec< TInt,int > const &         Val3: TVec< TInt,int > const &         Val4: TVec< TInt,int > const &         Val5: TVec< TInt,int > const &         Val6: TVec< TInt,int > const &         Val7: TVec< TInt,int > const &         Val8: TVec< TInt,int > const &      TIntIntVV_GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7,          TIntV Val8, TIntV Val9) -> TIntIntVV      Parameters:         Val1: TVec< TInt,int > const &         Val2: TVec< TInt,int > const &         Val3: TVec< TInt,int > const &         Val4: TVec< TInt,int > const &         Val5: TVec< TInt,int > const &         Val6: TVec< TInt,int > const &         Val7: TVec< TInt,int > const &         Val8: TVec< TInt,int > const &         Val9: TVec< TInt,int > const & Proxy of C++ THash<(TInt,TVec<(TInt,int)>)> class __init__(THash<(TInt,TVec<(TInt,int)>)> self) -> TIntIntVH         __init__(THash<(TInt,TVec<(TInt,int)>)> self, TIntIntVH Hash) -> TIntIntVH          Parameters:             Hash: THash< TInt,TVec< TInt,int > > const &          __init__(THash<(TInt,TVec<(TInt,int)>)> self, int const & ExpectVals, bool const & _AutoSizeP=False) -> TIntIntVH          Parameters:             ExpectVals: int const &             _AutoSizeP: bool const &          __init__(THash<(TInt,TVec<(TInt,int)>)> self, int const & ExpectVals) -> TIntIntVH          Parameters:             ExpectVals: int const &          __init__(THash<(TInt,TVec<(TInt,int)>)> self, TSIn SIn) -> TIntIntVH          Parameters:             SIn: TSIn & Load(TIntIntVH self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TIntIntVH self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TIntIntVH self, PXmlTok const & XmlTok, TStr Nm="")          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const &          LoadXml(TIntIntVH self, PXmlTok const & XmlTok)          Parameters:             XmlTok: PXmlTok const & SaveXml(TIntIntVH self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TIntIntVH self, TIntIntVH Hash) -> bool          Parameters:             Hash: THash< TInt,TVec< TInt,int > > const & __lt__(TIntIntVH self, TIntIntVH Hash) -> bool          Parameters:             Hash: THash< TInt,TVec< TInt,int > > const & __call__(TIntIntVH self, TInt Key) -> TIntV          Parameters:             Key: TInt const & GetMemUsed(TIntIntVH self) -> ::TSize          Parameters:             self: THash< TInt,TVec< TInt,int > > const * BegI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter          Parameters:             self: THash< TInt,TVec< TInt,int > > const * EndI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter          Parameters:             self: THash< TInt,TVec< TInt,int > > const * GetI(TIntIntVH self, TInt Key) -> THash< TInt,TVec< TInt,int > >::TIter          Parameters:             Key: TInt const & Gen(TIntIntVH self, int const & ExpectVals)          Parameters:             ExpectVals: int const & Clr(TIntIntVH self, bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True)          Parameters:             DoDel: bool const &             NoDelLim: int const &             ResetDat: bool const &          Clr(TIntIntVH self, bool const & DoDel=True, int const & NoDelLim=-1)          Parameters:             DoDel: bool const &             NoDelLim: int const &          Clr(TIntIntVH self, bool const & DoDel=True)          Parameters:             DoDel: bool const &          Clr(TIntIntVH self)          Parameters:             self: THash< TInt,TVec< TInt,int > > * Empty(TIntIntVH self) -> bool          Parameters:             self: THash< TInt,TVec< TInt,int > > const * Len(TIntIntVH self) -> int          Parameters:             self: THash< TInt,TVec< TInt,int > > const * GetPorts(TIntIntVH self) -> int          Parameters:             self: THash< TInt,TVec< TInt,int > > const * IsAutoSize(TIntIntVH self) -> bool          Parameters:             self: THash< TInt,TVec< TInt,int > > const * GetMxKeyIds(TIntIntVH self) -> int          Parameters:             self: THash< TInt,TVec< TInt,int > > const * GetReservedKeyIds(TIntIntVH self) -> int          Parameters:             self: THash< TInt,TVec< TInt,int > > const * IsKeyIdEqKeyN(TIntIntVH self) -> bool          Parameters:             self: THash< TInt,TVec< TInt,int > > const * DelKey(TIntIntVH self, TInt Key)          Parameters:             Key: TInt const & DelIfKey(TIntIntVH self, TInt Key) -> bool          Parameters:             Key: TInt const & DelKeyId(TIntIntVH self, int const & KeyId)          Parameters:             KeyId: int const & DelKeyIdV(TIntIntVH self, TIntV KeyIdV)          Parameters:             KeyIdV: TIntV const & MarkDelKey(TIntIntVH self, TInt Key)          Parameters:             Key: TInt const & MarkDelKeyId(TIntIntVH self, int const & KeyId)          Parameters:             KeyId: int const & GetKey(TIntIntVH self, int const & KeyId) -> TInt          Parameters:             KeyId: int const & GetKeyId(TIntIntVH self, TInt Key) -> int          Parameters:             Key: TInt const & GetRndKeyId(TIntIntVH self, TRnd Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndKeyId(TIntIntVH self, TRnd Rnd, double const & EmptyFrac) -> int          Parameters:             Rnd: TRnd &             EmptyFrac: double const & IsKeyId(TIntIntVH self, int const & KeyId) -> bool          Parameters:             KeyId: int const & GetKeyDat(TIntIntVH self, int const & KeyId, TInt Key, TIntV Dat)          Parameters:             KeyId: int const &             Key: TInt &             Dat: TVec< TInt,int > & IsKeyGetDat(TIntIntVH self, TInt Key, TIntV Dat) -> bool          Parameters:             Key: TInt const &             Dat: TVec< TInt,int > & FFirstKeyId(TIntIntVH self) -> int          Parameters:             self: THash< TInt,TVec< TInt,int > > const * FNextKeyId(TIntIntVH self, int & KeyId) -> bool          Parameters:             KeyId: int & GetKeyV(TIntIntVH self, TIntV KeyV)          Parameters:             KeyV: TVec< TInt > & GetDatV(TIntIntVH self, TIntIntVV DatV)          Parameters:             DatV: TVec< TVec< TInt,int > > & GetKeyDatPrV(TIntIntVH self, TVec< TPair< TInt,TVec< TInt,int > > > & KeyDatPrV)          Parameters:             KeyDatPrV: TVec< TPair< TInt,TVec< TInt,int > > > & GetDatKeyPrV(TIntIntVH self, TVec< TPair< TVec< TInt,int >,TInt > > & DatKeyPrV)          Parameters:             DatKeyPrV: TVec< TPair< TVec< TInt,int >,TInt > > & GetKeyDatKdV(TIntIntVH self, TVec< TKeyDat< TInt,TVec< TInt,int > > > & KeyDatKdV)          Parameters:             KeyDatKdV: TVec< TKeyDat< TInt,TVec< TInt,int > > > & GetDatKeyKdV(TIntIntVH self, TVec< TKeyDat< TVec< TInt,int >,TInt > > & DatKeyKdV)          Parameters:             DatKeyKdV: TVec< TKeyDat< TVec< TInt,int >,TInt > > & Swap(TIntIntVH self, TIntIntVH Hash)          Parameters:             Hash: THash< TInt,TVec< TInt,int > > & Defrag(TIntIntVH self)          Parameters:             self: THash< TInt,TVec< TInt,int > > * Pack(TIntIntVH self)          Parameters:             self: THash< TInt,TVec< TInt,int > > * Sort(TIntIntVH self, bool const & CmpKey, bool const & Asc)          Parameters:             CmpKey: bool const &             Asc: bool const & SortByKey(TIntIntVH self, bool const & Asc=True)          Parameters:             Asc: bool const &          SortByKey(TIntIntVH self)          Parameters:             self: THash< TInt,TVec< TInt,int > > * SortByDat(TIntIntVH self, bool const & Asc=True)          Parameters:             Asc: bool const &          SortByDat(TIntIntVH self)          Parameters:             self: THash< TInt,TVec< TInt,int > > * AddKey(TIntIntVH self, TInt Key) -> int          Parameters:             Key: TInt const &          AddKey(TIntIntVH self, int Val) -> int          Parameters:             Val: int IsKey(TIntIntVH self, TInt Key) -> bool          Parameters:             Key: TInt const &          IsKey(TIntIntVH self, TInt Key, int & KeyId) -> bool          Parameters:             Key: TInt const &             KeyId: int &          IsKey(TIntIntVH self, int Val) -> int          Parameters:             Val: int GetDat(TIntIntVH self, TInt Key) -> TIntV          Parameters:             Key: TInt const &          GetDat(TIntIntVH self, TInt Key) -> TIntV          Parameters:             Key: TInt const &          GetDat(TIntIntVH self, int Val) -> TIntV          Parameters:             Val: int Proxy of C++ THash<(TInt,TInt)> class __init__(THash<(TInt,TInt)> self) -> TIntH         __init__(THash<(TInt,TInt)> self, TIntH Hash) -> TIntH          Parameters:             Hash: THash< TInt,TInt > const &          __init__(THash<(TInt,TInt)> self, int const & ExpectVals, bool const & _AutoSizeP=False) -> TIntH          Parameters:             ExpectVals: int const &             _AutoSizeP: bool const &          __init__(THash<(TInt,TInt)> self, int const & ExpectVals) -> TIntH          Parameters:             ExpectVals: int const &          __init__(THash<(TInt,TInt)> self, TSIn SIn) -> TIntH          Parameters:             SIn: TSIn & Load(TIntH self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TIntH self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TIntH self, PXmlTok const & XmlTok, TStr Nm="")          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const &          LoadXml(TIntH self, PXmlTok const & XmlTok)          Parameters:             XmlTok: PXmlTok const & SaveXml(TIntH self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __eq__(TIntH self, TIntH Hash) -> bool          Parameters:             Hash: THash< TInt,TInt > const & __lt__(TIntH self, TIntH Hash) -> bool          Parameters:             Hash: THash< TInt,TInt > const & __call__(TIntH self, TInt Key) -> TInt          Parameters:             Key: TInt const & GetMemUsed(TIntH self) -> ::TSize          Parameters:             self: THash< TInt,TInt > const * BegI(TIntH self) -> TIntHI          Parameters:             self: THash< TInt,TInt > const * EndI(TIntH self) -> TIntHI          Parameters:             self: THash< TInt,TInt > const * GetI(TIntH self, TInt Key) -> TIntHI          Parameters:             Key: TInt const & Gen(TIntH self, int const & ExpectVals)          Parameters:             ExpectVals: int const & Clr(TIntH self, bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True)          Parameters:             DoDel: bool const &             NoDelLim: int const &             ResetDat: bool const &          Clr(TIntH self, bool const & DoDel=True, int const & NoDelLim=-1)          Parameters:             DoDel: bool const &             NoDelLim: int const &          Clr(TIntH self, bool const & DoDel=True)          Parameters:             DoDel: bool const &          Clr(TIntH self)          Parameters:             self: THash< TInt,TInt > * Empty(TIntH self) -> bool          Parameters:             self: THash< TInt,TInt > const * Len(TIntH self) -> int          Parameters:             self: THash< TInt,TInt > const * GetPorts(TIntH self) -> int          Parameters:             self: THash< TInt,TInt > const * IsAutoSize(TIntH self) -> bool          Parameters:             self: THash< TInt,TInt > const * GetMxKeyIds(TIntH self) -> int          Parameters:             self: THash< TInt,TInt > const * GetReservedKeyIds(TIntH self) -> int          Parameters:             self: THash< TInt,TInt > const * IsKeyIdEqKeyN(TIntH self) -> bool          Parameters:             self: THash< TInt,TInt > const * AddDatId(TIntH self, TInt Key) -> TInt          Parameters:             Key: TInt const & DelKey(TIntH self, TInt Key)          Parameters:             Key: TInt const & DelIfKey(TIntH self, TInt Key) -> bool          Parameters:             Key: TInt const & DelKeyId(TIntH self, int const & KeyId)          Parameters:             KeyId: int const & DelKeyIdV(TIntH self, TIntV KeyIdV)          Parameters:             KeyIdV: TIntV const & MarkDelKey(TIntH self, TInt Key)          Parameters:             Key: TInt const & MarkDelKeyId(TIntH self, int const & KeyId)          Parameters:             KeyId: int const & GetKey(TIntH self, int const & KeyId) -> TInt          Parameters:             KeyId: int const & GetKeyId(TIntH self, TInt Key) -> int          Parameters:             Key: TInt const & GetRndKeyId(TIntH self, TRnd Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndKeyId(TIntH self, TRnd Rnd, double const & EmptyFrac) -> int          Parameters:             Rnd: TRnd &             EmptyFrac: double const & IsKeyId(TIntH self, int const & KeyId) -> bool          Parameters:             KeyId: int const & GetKeyDat(TIntH self, int const & KeyId, TInt Key, TInt Dat)          Parameters:             KeyId: int const &             Key: TInt &             Dat: TInt & IsKeyGetDat(TIntH self, TInt Key, TInt Dat) -> bool          Parameters:             Key: TInt const &             Dat: TInt & FFirstKeyId(TIntH self) -> int          Parameters:             self: THash< TInt,TInt > const * FNextKeyId(TIntH self, int & KeyId) -> bool          Parameters:             KeyId: int & GetKeyV(TIntH self, TIntV KeyV)          Parameters:             KeyV: TVec< TInt > & GetDatV(TIntH self, TIntV DatV)          Parameters:             DatV: TVec< TInt > & GetKeyDatPrV(TIntH self, TVec< TPair< TInt,TInt > > & KeyDatPrV)          Parameters:             KeyDatPrV: TVec< TPair< TInt,TInt > > & GetDatKeyPrV(TIntH self, TVec< TPair< TInt,TInt > > & DatKeyPrV)          Parameters:             DatKeyPrV: TVec< TPair< TInt,TInt > > & GetKeyDatKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & KeyDatKdV)          Parameters:             KeyDatKdV: TVec< TKeyDat< TInt,TInt > > & GetDatKeyKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & DatKeyKdV)          Parameters:             DatKeyKdV: TVec< TKeyDat< TInt,TInt > > & Swap(TIntH self, TIntH Hash)          Parameters:             Hash: THash< TInt,TInt > & Defrag(TIntH self)          Parameters:             self: THash< TInt,TInt > * Pack(TIntH self)          Parameters:             self: THash< TInt,TInt > * Sort(TIntH self, bool const & CmpKey, bool const & Asc)          Parameters:             CmpKey: bool const &             Asc: bool const & SortByKey(TIntH self, bool const & Asc=True)          Parameters:             Asc: bool const &          SortByKey(TIntH self)          Parameters:             self: THash< TInt,TInt > * SortByDat(TIntH self, bool const & Asc=True)          Parameters:             Asc: bool const &          SortByDat(TIntH self)          Parameters:             self: THash< TInt,TInt > * AddKey(TIntH self, TInt Key) -> int          Parameters:             Key: TInt const &          AddKey(TIntH self, int Val) -> int          Parameters:             Val: int IsKey(TIntH self, TInt Key) -> bool          Parameters:             Key: TInt const &          IsKey(TIntH self, TInt Key, int & KeyId) -> bool          Parameters:             Key: TInt const &             KeyId: int &          IsKey(TIntH self, int Val) -> int          Parameters:             Val: int GetDat(TIntH self, TInt Key) -> TInt          Parameters:             Key: TInt const &          GetDat(TIntH self, TInt Key) -> TInt          Parameters:             Key: TInt const &          GetDat(TIntH self, int Val) -> TInt          Parameters:             Val: int AddDat(TIntH self, TInt Key) -> TInt          Parameters:             Key: TInt const &          AddDat(TIntH self, TInt Key, TInt Dat) -> TInt          Parameters:             Key: TInt const &             Dat: TInt const &          AddDat(TIntH self, int Key, int Val) -> TInt          Parameters:             Key: int             Val: int Proxy of C++ THashKeyDatI<(TInt,TInt)> class __init__(THashKeyDatI<(TInt,TInt)> self) -> TIntHI         __init__(THashKeyDatI<(TInt,TInt)> self, TIntHI _HashKeyDatI) -> TIntHI          Parameters:             _HashKeyDatI: THashKeyDatI< TInt,TInt > const &          __init__(THashKeyDatI<(TInt,TInt)> self, THashKeyDatI< TInt,TInt >::THKeyDat const * _KeyDatI, THashKeyDatI< TInt,TInt >::THKeyDat const * _EndI) -> TIntHI          Parameters:             _KeyDatI: THashKeyDatI< TInt,TInt >::THKeyDat const *             _EndI: THashKeyDatI< TInt,TInt >::THKeyDat const * __eq__(TIntHI self, TIntHI HashKeyDatI) -> bool          Parameters:             HashKeyDatI: THashKeyDatI< TInt,TInt > const & __lt__(TIntHI self, TIntHI HashKeyDatI) -> bool          Parameters:             HashKeyDatI: THashKeyDatI< TInt,TInt > const & __ref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat &          Parameters:             self: THashKeyDatI< TInt,TInt > const * __call__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat &          Parameters:             self: THashKeyDatI< TInt,TInt > const * __deref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat *          Parameters:             self: THashKeyDatI< TInt,TInt > const * Next(TIntHI self) -> TIntHI          Parameters:             self: THashKeyDatI< TInt,TInt > * IsEmpty(TIntHI self) -> bool          Parameters:             self: THashKeyDatI< TInt,TInt > const * IsEnd(TIntHI self) -> bool          Parameters:             self: THashKeyDatI< TInt,TInt > const * GetKey(TIntHI self) -> TInt          Parameters:             self: THashKeyDatI< TInt,TInt > const * GetDat(TIntHI self) -> TInt         GetDat(TIntHI self) -> TInt          Parameters:             self: THashKeyDatI< TInt,TInt > * Proxy of C++ TVec<(TStr,int)> class __init__(TVec<(TStr,int)> self) -> TStrV         __init__(TVec<(TStr,int)> self, TStrV Vec) -> TStrV          Parameters:             Vec: TVec< TStr,int > const &          __init__(TVec<(TStr,int)> self, int const & _Vals) -> TStrV          Parameters:             _Vals: int const &          __init__(TVec<(TStr,int)> self, int const & _MxVals, int const & _Vals) -> TStrV          Parameters:             _MxVals: int const &             _Vals: int const &          __init__(TVec<(TStr,int)> self, TStr _ValT, int const & _Vals) -> TStrV          Parameters:             _ValT: TStr *             _Vals: int const &          __init__(TVec<(TStr,int)> self, TSIn SIn) -> TStrV          Parameters:             SIn: TSIn & Load(TStrV self, TSIn SIn)          Parameters:             SIn: TSIn & Save(TStrV self, TSOut SOut)          Parameters:             SOut: TSOut & LoadXml(TStrV self, PXmlTok const & XmlTok, TStr Nm="")          Parameters:             XmlTok: PXmlTok const &             Nm: TStr const &          LoadXml(TStrV self, PXmlTok const & XmlTok)          Parameters:             XmlTok: PXmlTok const & SaveXml(TStrV self, TSOut SOut, TStr Nm)          Parameters:             SOut: TSOut &             Nm: TStr const & __add__(TStrV self, TStr Val) -> TStrV          Parameters:             Val: TStr const & __eq__(TStrV self, TStrV Vec) -> bool          Parameters:             Vec: TVec< TStr,int > const & __lt__(TStrV self, TStrV Vec) -> bool          Parameters:             Vec: TVec< TStr,int > const & GetMemUsed(TStrV self) -> int          Parameters:             self: TVec< TStr,int > const * GetMemSize(TStrV self) -> int          Parameters:             self: TVec< TStr,int > const * GetPrimHashCd(TStrV self) -> int          Parameters:             self: TVec< TStr,int > const * GetSecHashCd(TStrV self) -> int          Parameters:             self: TVec< TStr,int > const * Gen(TStrV self, int const & _Vals)          Parameters:             _Vals: int const &          Gen(TStrV self, int const & _MxVals, int const & _Vals)          Parameters:             _MxVals: int const &             _Vals: int const & GenExt(TStrV self, TStr _ValT, int const & _Vals)          Parameters:             _ValT: TStr *             _Vals: int const & IsExt(TStrV self) -> bool          Parameters:             self: TVec< TStr,int > const * Reserve(TStrV self, int const & _MxVals)          Parameters:             _MxVals: int const &          Reserve(TStrV self, int const & _MxVals, int const & _Vals)          Parameters:             _MxVals: int const &             _Vals: int const & Clr(TStrV self, bool const & DoDel=True, int const & NoDelLim=-1)          Parameters:             DoDel: bool const &             NoDelLim: int const &          Clr(TStrV self, bool const & DoDel=True)          Parameters:             DoDel: bool const &          Clr(TStrV self)          Parameters:             self: TVec< TStr,int > * Trunc(TStrV self, int const & _Vals=-1)          Parameters:             _Vals: int const &          Trunc(TStrV self)          Parameters:             self: TVec< TStr,int > * Pack(TStrV self)          Parameters:             self: TVec< TStr,int > * MoveFrom(TStrV self, TStrV Vec)          Parameters:             Vec: TVec< TStr,int > & Empty(TStrV self) -> bool          Parameters:             self: TVec< TStr,int > const * Len(TStrV self) -> int          Parameters:             self: TVec< TStr,int > const * Reserved(TStrV self) -> int          Parameters:             self: TVec< TStr,int > const * Last(TStrV self) -> TStr         Last(TStrV self) -> TStr          Parameters:             self: TVec< TStr,int > * LastValN(TStrV self) -> int          Parameters:             self: TVec< TStr,int > const * LastLast(TStrV self) -> TStr         LastLast(TStrV self) -> TStr          Parameters:             self: TVec< TStr,int > * BegI(TStrV self) -> TStr          Parameters:             self: TVec< TStr,int > const * EndI(TStrV self) -> TStr          Parameters:             self: TVec< TStr,int > const * GetI(TStrV self, int const & ValN) -> TStr          Parameters:             ValN: int const & AddV(TStrV self, TStrV ValV) -> int          Parameters:             ValV: TVec< TStr,int > const & AddSorted(TStrV self, TStr Val, bool const & Asc=True, int const & _MxVals=-1) -> int          Parameters:             Val: TStr const &             Asc: bool const &             _MxVals: int const &          AddSorted(TStrV self, TStr Val, bool const & Asc=True) -> int          Parameters:             Val: TStr const &             Asc: bool const &          AddSorted(TStrV self, TStr Val) -> int          Parameters:             Val: TStr const & AddBackSorted(TStrV self, TStr Val, bool const & Asc) -> int          Parameters:             Val: TStr const &             Asc: bool const & AddVMerged(TStrV self, TStrV ValV) -> int          Parameters:             ValV: TVec< TStr,int > const & AddUnique(TStrV self, TStr Val) -> int          Parameters:             Val: TStr const & GetVal(TStrV self, int const & ValN) -> TStr          Parameters:             ValN: int const &          GetVal(TStrV self, int const & ValN) -> TStr          Parameters:             ValN: int const & GetSubValV(TStrV self, int const & BValN, int const & EValN, TStrV ValV)          Parameters:             BValN: int const &             EValN: int const &             ValV: TVec< TStr,int > & Ins(TStrV self, int const & ValN, TStr Val)          Parameters:             ValN: int const &             Val: TStr const & Del(TStrV self, int const & ValN)          Parameters:             ValN: int const &          Del(TStrV self, int const & MnValN, int const & MxValN)          Parameters:             MnValN: int const &             MxValN: int const & DelLast(TStrV self)          Parameters:             self: TVec< TStr,int > * DelIfIn(TStrV self, TStr Val) -> bool          Parameters:             Val: TStr const & DelAll(TStrV self, TStr Val)          Parameters:             Val: TStr const & PutAll(TStrV self, TStr Val)          Parameters:             Val: TStr const & Swap(TStrV self, TStrV Vec)          Parameters:             Vec: TVec< TStr,int > &          Swap(TStrV self, int const & ValN1, int const & ValN2)          Parameters:             ValN1: int const &             ValN2: int const & SwapI(TStr LVal, TStr RVal)          Parameters:             LVal: TVec< TStr,int >::TIter             RVal: TVec< TStr,int >::TIter NextPerm(TStrV self) -> bool          Parameters:             self: TVec< TStr,int > * PrevPerm(TStrV self) -> bool          Parameters:             self: TVec< TStr,int > * GetPivotValN(TStrV self, int const & LValN, int const & RValN) -> int          Parameters:             LValN: int const &             RValN: int const & BSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & ISort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & Partition(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & QSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)          Parameters:             MnLValN: int const &             MxRValN: int const &             Asc: bool const & Sort(TStrV self, bool const & Asc=True)          Parameters:             Asc: bool const &          Sort(TStrV self)          Parameters:             self: TVec< TStr,int > * IsSorted(TStrV self, bool const & Asc=True) -> bool          Parameters:             Asc: bool const &          IsSorted(TStrV self) -> bool          Parameters:             self: TVec< TStr,int > const * Shuffle(TStrV self, TRnd Rnd)          Parameters:             Rnd: TRnd & Reverse(TStrV self)         Reverse(TStrV self, int LValN, int RValN)          Parameters:             LValN: int             RValN: int Merge(TStrV self)          Parameters:             self: TVec< TStr,int > * Intrs(TStrV self, TStrV ValV)          Parameters:             ValV: TVec< TStr,int > const &          Intrs(TStrV self, TStrV ValV, TStrV DstValV)          Parameters:             ValV: TVec< TStr,int > const &             DstValV: TVec< TStr,int > & Union(TStrV self, TStrV ValV)          Parameters:             ValV: TVec< TStr,int > const &          Union(TStrV self, TStrV ValV, TStrV DstValV)          Parameters:             ValV: TVec< TStr,int > const &             DstValV: TVec< TStr,int > & Diff(TStrV self, TStrV ValV)          Parameters:             ValV: TVec< TStr,int > const &          Diff(TStrV self, TStrV ValV, TStrV DstValV)          Parameters:             ValV: TVec< TStr,int > const &             DstValV: TVec< TStr,int > & IntrsLen(TStrV self, TStrV ValV) -> int          Parameters:             ValV: TVec< TStr,int > const & UnionLen(TStrV self, TStrV ValV) -> int          Parameters:             ValV: TVec< TStr,int > const & Count(TStrV self, TStr Val) -> int          Parameters:             Val: TStr const & SearchBin(TStrV self, TStr Val) -> int          Parameters:             Val: TStr const &          SearchBin(TStrV self, TStr Val, int & InsValN) -> int          Parameters:             Val: TStr const &             InsValN: int & SearchForw(TStrV self, TStr Val, int const & BValN=0) -> int          Parameters:             Val: TStr const &             BValN: int const &          SearchForw(TStrV self, TStr Val) -> int          Parameters:             Val: TStr const & SearchBack(TStrV self, TStr Val) -> int          Parameters:             Val: TStr const & SearchVForw(TStrV self, TStrV ValV, int const & BValN=0) -> int          Parameters:             ValV: TVec< TStr,int > const &             BValN: int const &          SearchVForw(TStrV self, TStrV ValV) -> int          Parameters:             ValV: TVec< TStr,int > const & IsIn(TStrV self, TStr Val) -> bool          Parameters:             Val: TStr const &          IsIn(TStrV self, TStr Val, int & ValN) -> bool          Parameters:             Val: TStr const &             ValN: int & IsInBin(TStrV self, TStr Val) -> bool          Parameters:             Val: TStr const & GetDat(TStrV self, TStr Val) -> TStr          Parameters:             Val: TStr const & GetAddDat(TStrV self, TStr Val) -> TStr          Parameters:             Val: TStr const & GetMxValN(TStrV self) -> int          Parameters:             self: TVec< TStr,int > const * GetV(TStr Val1) -> TStrV          Parameters:             Val1: TStr const &          GetV(TStr Val1, TStr Val2) -> TStrV          Parameters:             Val1: TStr const &             Val2: TStr const &          GetV(TStr Val1, TStr Val2, TStr Val3) -> TStrV          Parameters:             Val1: TStr const &             Val2: TStr const &             Val3: TStr const &          GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4) -> TStrV          Parameters:             Val1: TStr const &             Val2: TStr const &             Val3: TStr const &             Val4: TStr const &          GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5) -> TStrV          Parameters:             Val1: TStr const &             Val2: TStr const &             Val3: TStr const &             Val4: TStr const &             Val5: TStr const &          GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6) -> TStrV          Parameters:             Val1: TStr const &             Val2: TStr const &             Val3: TStr const &             Val4: TStr const &             Val5: TStr const &             Val6: TStr const &          GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7) -> TStrV          Parameters:             Val1: TStr const &             Val2: TStr const &             Val3: TStr const &             Val4: TStr const &             Val5: TStr const &             Val6: TStr const &             Val7: TStr const &          GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8) -> TStrV          Parameters:             Val1: TStr const &             Val2: TStr const &             Val3: TStr const &             Val4: TStr const &             Val5: TStr const &             Val6: TStr const &             Val7: TStr const &             Val8: TStr const &          GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8,              TStr Val9) -> TStrV          Parameters:             Val1: TStr const &             Val2: TStr const &             Val3: TStr const &             Val4: TStr const &             Val5: TStr const &             Val6: TStr const &             Val7: TStr const &             Val8: TStr const &             Val9: TStr const & TStrV_SwapI(TStr LVal, TStr RVal)      Parameters:         LVal: TVec< TStr,int >::TIter         RVal: TVec< TStr,int >::TIter GetV(TStr Val1) -> TStrV      Parameters:         Val1: TStr const &      GetV(TStr Val1, TStr Val2) -> TStrV      Parameters:         Val1: TStr const &         Val2: TStr const &      GetV(TStr Val1, TStr Val2, TStr Val3) -> TStrV      Parameters:         Val1: TStr const &         Val2: TStr const &         Val3: TStr const &      GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4) -> TStrV      Parameters:         Val1: TStr const &         Val2: TStr const &         Val3: TStr const &         Val4: TStr const &      GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5) -> TStrV      Parameters:         Val1: TStr const &         Val2: TStr const &         Val3: TStr const &         Val4: TStr const &         Val5: TStr const &      GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6) -> TStrV      Parameters:         Val1: TStr const &         Val2: TStr const &         Val3: TStr const &         Val4: TStr const &         Val5: TStr const &         Val6: TStr const &      GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7) -> TStrV      Parameters:         Val1: TStr const &         Val2: TStr const &         Val3: TStr const &         Val4: TStr const &         Val5: TStr const &         Val6: TStr const &         Val7: TStr const &      GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8) -> TStrV      Parameters:         Val1: TStr const &         Val2: TStr const &         Val3: TStr const &         Val4: TStr const &         Val5: TStr const &         Val6: TStr const &         Val7: TStr const &         Val8: TStr const &      TStrV_GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8,          TStr Val9) -> TStrV      Parameters:         Val1: TStr const &         Val2: TStr const &         Val3: TStr const &         Val4: TStr const &         Val5: TStr const &         Val6: TStr const &         Val7: TStr const &         Val8: TStr const &         Val9: TStr const & Proxy of C++ TNGraphNodeI class __init__(TNGraphNodeI self) -> TNGraphNodeI         __init__(TNGraphNodeI self, TNGraph::TNodeI const & NodeI) -> TNGraphNodeI          Parameters:             NodeI: TNGraph::TNodeI const & Next(TNGraphNodeI self) -> TNGraphNodeI          Parameters:             self: TNGraphNodeI * __lt__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool          Parameters:             NodeI: TNGraphNodeI const & __eq__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool          Parameters:             NodeI: TNGraphNodeI const & GetId(TNGraphNodeI self) -> int          Parameters:             self: TNGraphNodeI const * GetDeg(TNGraphNodeI self) -> int          Parameters:             self: TNGraphNodeI const * GetInDeg(TNGraphNodeI self) -> int          Parameters:             self: TNGraphNodeI const * GetOutDeg(TNGraphNodeI self) -> int          Parameters:             self: TNGraphNodeI const * GetInNId(TNGraphNodeI self, int const & NodeN) -> int          Parameters:             NodeN: int const & GetOutNId(TNGraphNodeI self, int const & NodeN) -> int          Parameters:             NodeN: int const & GetNbrNId(TNGraphNodeI self, int const & NodeN) -> int          Parameters:             NodeN: int const & IsInNId(TNGraphNodeI self, int const & NId) -> bool          Parameters:             NId: int const & IsOutNId(TNGraphNodeI self, int const & NId) -> bool          Parameters:             NId: int const & IsNbrNId(TNGraphNodeI self, int const & NId) -> bool          Parameters:             NId: int const & Proxy of C++ TNGraphEdgeI class __init__(TNGraphEdgeI self) -> TNGraphEdgeI         __init__(TNGraphEdgeI self, TNGraph::TEdgeI const & EdgeI) -> TNGraphEdgeI          Parameters:             EdgeI: TNGraph::TEdgeI const & Next(TNGraphEdgeI self) -> TNGraphEdgeI          Parameters:             self: TNGraphEdgeI * __lt__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool          Parameters:             EdgeI: TNGraphEdgeI const & __eq__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool          Parameters:             EdgeI: TNGraphEdgeI const & GetId(TNGraphEdgeI self) -> int          Parameters:             self: TNGraphEdgeI const * GetSrcNId(TNGraphEdgeI self) -> int          Parameters:             self: TNGraphEdgeI const * GetDstNId(TNGraphEdgeI self) -> int          Parameters:             self: TNGraphEdgeI const * Proxy of C++ TUNGraphNodeI class __init__(TUNGraphNodeI self) -> TUNGraphNodeI         __init__(TUNGraphNodeI self, TUNGraph::TNodeI const & NodeI) -> TUNGraphNodeI          Parameters:             NodeI: TUNGraph::TNodeI const & Next(TUNGraphNodeI self) -> TUNGraphNodeI          Parameters:             self: TUNGraphNodeI * __lt__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool          Parameters:             NodeI: TUNGraphNodeI const & __eq__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool          Parameters:             NodeI: TUNGraphNodeI const & GetId(TUNGraphNodeI self) -> int          Parameters:             self: TUNGraphNodeI const * GetDeg(TUNGraphNodeI self) -> int          Parameters:             self: TUNGraphNodeI const * GetInDeg(TUNGraphNodeI self) -> int          Parameters:             self: TUNGraphNodeI const * GetOutDeg(TUNGraphNodeI self) -> int          Parameters:             self: TUNGraphNodeI const * GetInNId(TUNGraphNodeI self, int const & NodeN) -> int          Parameters:             NodeN: int const & GetOutNId(TUNGraphNodeI self, int const & NodeN) -> int          Parameters:             NodeN: int const & GetNbrNId(TUNGraphNodeI self, int const & NodeN) -> int          Parameters:             NodeN: int const & IsInNId(TUNGraphNodeI self, int const & NId) -> bool          Parameters:             NId: int const & IsOutNId(TUNGraphNodeI self, int const & NId) -> bool          Parameters:             NId: int const & IsNbrNId(TUNGraphNodeI self, int const & NId) -> bool          Parameters:             NId: int const & Proxy of C++ TUNGraphEdgeI class __init__(TUNGraphEdgeI self) -> TUNGraphEdgeI         __init__(TUNGraphEdgeI self, TUNGraph::TEdgeI const & EdgeI) -> TUNGraphEdgeI          Parameters:             EdgeI: TUNGraph::TEdgeI const & Next(TUNGraphEdgeI self) -> TUNGraphEdgeI          Parameters:             self: TUNGraphEdgeI * __lt__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool          Parameters:             EdgeI: TUNGraphEdgeI const & __eq__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool          Parameters:             EdgeI: TUNGraphEdgeI const & GetId(TUNGraphEdgeI self) -> int          Parameters:             self: TUNGraphEdgeI const * GetSrcNId(TUNGraphEdgeI self) -> int          Parameters:             self: TUNGraphEdgeI const * GetDstNId(TUNGraphEdgeI self) -> int          Parameters:             self: TUNGraphEdgeI const * Proxy of C++ TNEANetNodeI class __init__(TNEANetNodeI self) -> TNEANetNodeI         __init__(TNEANetNodeI self, TNEANet::TNodeI const & NodeI) -> TNEANetNodeI          Parameters:             NodeI: TNEANet::TNodeI const & Next(TNEANetNodeI self) -> TNEANetNodeI          Parameters:             self: TNEANetNodeI * __lt__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool          Parameters:             NodeI: TNEANetNodeI const & __eq__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool          Parameters:             NodeI: TNEANetNodeI const & GetId(TNEANetNodeI self) -> int          Parameters:             self: TNEANetNodeI const * GetDeg(TNEANetNodeI self) -> int          Parameters:             self: TNEANetNodeI const * GetInDeg(TNEANetNodeI self) -> int          Parameters:             self: TNEANetNodeI const * GetOutDeg(TNEANetNodeI self) -> int          Parameters:             self: TNEANetNodeI const * GetInNId(TNEANetNodeI self, int const & NodeN) -> int          Parameters:             NodeN: int const & GetOutNId(TNEANetNodeI self, int const & NodeN) -> int          Parameters:             NodeN: int const & GetNbrNId(TNEANetNodeI self, int const & NodeN) -> int          Parameters:             NodeN: int const & IsInNId(TNEANetNodeI self, int const & NId) -> bool          Parameters:             NId: int const & IsOutNId(TNEANetNodeI self, int const & NId) -> bool          Parameters:             NId: int const & IsNbrNId(TNEANetNodeI self, int const & NId) -> bool          Parameters:             NId: int const & Proxy of C++ TNEANetEdgeI class __init__(TNEANetEdgeI self) -> TNEANetEdgeI         __init__(TNEANetEdgeI self, TNEANet::TEdgeI const & EdgeI) -> TNEANetEdgeI          Parameters:             EdgeI: TNEANet::TEdgeI const & Next(TNEANetEdgeI self) -> TNEANetEdgeI          Parameters:             self: TNEANetEdgeI * __lt__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool          Parameters:             EdgeI: TNEANetEdgeI const & __eq__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool          Parameters:             EdgeI: TNEANetEdgeI const & GetId(TNEANetEdgeI self) -> int          Parameters:             self: TNEANetEdgeI const * GetSrcNId(TNEANetEdgeI self) -> int          Parameters:             self: TNEANetEdgeI const * GetDstNId(TNEANetEdgeI self) -> int          Parameters:             self: TNEANetEdgeI const * Proxy of C++ TNEANetAIntI class __init__(TNEANetAIntI self) -> TNEANetAIntI         __init__(TNEANetAIntI self, TIntVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAIntI          Parameters:             HIter: TIntVecIter const &             attribute: TStr             isEdgeIter: bool             GraphPt: TNEANet const *          __init__(TNEANetAIntI self, TNEANet::TAIntI const & I) -> TNEANetAIntI          Parameters:             I: TNEANet::TAIntI const & Next(TNEANetAIntI self) -> TNEANetAIntI          Parameters:             self: TNEANetAIntI * __lt__(TNEANetAIntI self, TNEANetAIntI I) -> bool          Parameters:             I: TNEANetAIntI const & __eq__(TNEANetAIntI self, TNEANetAIntI I) -> bool          Parameters:             I: TNEANetAIntI const & GetDat(TNEANetAIntI self) -> int          Parameters:             self: TNEANetAIntI const * IsDeleted(TNEANetAIntI self) -> bool          Parameters:             self: TNEANetAIntI const * Proxy of C++ TNEANetAStrI class __init__(TNEANetAStrI self) -> TNEANetAStrI         __init__(TNEANetAStrI self, TStrVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAStrI          Parameters:             HIter: TStrVecIter const &             attribute: TStr             isEdgeIter: bool             GraphPt: TNEANet const *          __init__(TNEANetAStrI self, TNEANet::TAStrI const & I) -> TNEANetAStrI          Parameters:             I: TNEANet::TAStrI const & Next(TNEANetAStrI self) -> TNEANetAStrI          Parameters:             self: TNEANetAStrI * __lt__(TNEANetAStrI self, TNEANetAStrI I) -> bool          Parameters:             I: TNEANetAStrI const & __eq__(TNEANetAStrI self, TNEANetAStrI I) -> bool          Parameters:             I: TNEANetAStrI const & GetDat(TNEANetAStrI self) -> char *          Parameters:             self: TNEANetAStrI const * IsDeleted(TNEANetAStrI self) -> bool          Parameters:             self: TNEANetAStrI const * Proxy of C++ TNEANetAFltI class __init__(TNEANetAFltI self) -> TNEANetAFltI         __init__(TNEANetAFltI self, TFltVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAFltI          Parameters:             HIter: TFltVecIter const &             attribute: TStr             isEdgeIter: bool             GraphPt: TNEANet const *          __init__(TNEANetAFltI self, TNEANet::TAFltI const & I) -> TNEANetAFltI          Parameters:             I: TNEANet::TAFltI const & Next(TNEANetAFltI self) -> TNEANetAFltI          Parameters:             self: TNEANetAFltI * __lt__(TNEANetAFltI self, TNEANetAFltI I) -> bool          Parameters:             I: TNEANetAFltI const & __eq__(TNEANetAFltI self, TNEANetAFltI I) -> bool          Parameters:             I: TNEANetAFltI const & GetDat(TNEANetAFltI self) -> double          Parameters:             self: TNEANetAFltI const * IsDeleted(TNEANetAFltI self) -> bool          Parameters:             self: TNEANetAFltI const * TPrGraph(PUNGraph G) -> TUNGraph      Parameters:         G: PUNGraph accept_array(int [] array) -> int      Parameters:         array: int [] print_array(int * x, int length)      Parameters:         x: int *         length: int PyTFltV(double [10] x) -> TFltV      Parameters:         x: double [10] PyToTIntV(int * array) -> TIntV      Parameters:         array: int * count(char * str, char c) -> int      Parameters:         str: char *         c: char TIntVToPy(TIntV originalList)      Parameters:         originalList: TIntV Proxy of C++ TNEANet class __init__(TNEANet self) -> TNEANet         __init__(TNEANet self, int const & Nodes, int const & Edges) -> TNEANet          Parameters:             Nodes: int const &             Edges: int const &          __init__(TNEANet self, TNEANet Graph) -> TNEANet          Parameters:             Graph: TNEANet const &          __init__(TNEANet self, TSIn SIn) -> TNEANet          Parameters:             SIn: TSIn & Save(TNEANet self, TSOut SOut)          Parameters:             SOut: TSOut & New() -> PNEANet         New(int const & Nodes, int const & Edges) -> PNEANet          Parameters:             Nodes: int const &             Edges: int const & Load(TSIn SIn) -> PNEANet          Parameters:             SIn: TSIn & HasFlag(TNEANet self, TGraphFlag const & Flag) -> bool          Parameters:             Flag: TGraphFlag const & GetNodes(TNEANet self) -> int          Parameters:             self: TNEANet const * AddNode(TNEANet self, int NId=-1) -> int          Parameters:             NId: int          AddNode(TNEANet self) -> int         AddNode(TNEANet self, TNEANet::TNodeI const & NodeId) -> int          Parameters:             NodeId: TNEANet::TNodeI const & DelNode(TNEANet self, int const & NId)          Parameters:             NId: int const &          DelNode(TNEANet self, TNEANet::TNode const & NodeI)          Parameters:             NodeI: TNEANet::TNode const & IsNode(TNEANet self, int const & NId) -> bool          Parameters:             NId: int const & GetNI(TNEANet self, int const & NId) -> TNEANet::TNodeI          Parameters:             NId: int const & GetNAIntI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI          Parameters:             attr: TStr const &             NId: int const & GetNAStrI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI          Parameters:             attr: TStr const &             NId: int const & GetNAFltI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI          Parameters:             attr: TStr const &             NId: int const & AttrNameNI(TNEANet self, TInt NId, TStrV Names)          Parameters:             NId: TInt const &             Names: TStrV &          AttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Names: TStrV & AttrValueNI(TNEANet self, TInt NId, TStrV Values)          Parameters:             NId: TInt const &             Values: TStrV &          AttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Values: TStrV & IntAttrNameNI(TNEANet self, TInt NId, TStrV Names)          Parameters:             NId: TInt const &             Names: TStrV &          IntAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Names: TStrV & IntAttrValueNI(TNEANet self, TInt NId, TIntV Values)          Parameters:             NId: TInt const &             Values: TIntV &          IntAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Values: TIntV & StrAttrNameNI(TNEANet self, TInt NId, TStrV Names)          Parameters:             NId: TInt const &             Names: TStrV &          StrAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Names: TStrV & StrAttrValueNI(TNEANet self, TInt NId, TStrV Values)          Parameters:             NId: TInt const &             Values: TStrV &          StrAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Values: TStrV & FltAttrNameNI(TNEANet self, TInt NId, TStrV Names)          Parameters:             NId: TInt const &             Names: TStrV &          FltAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Names: TStrV & FltAttrValueNI(TNEANet self, TInt NId, TFltV & Values)          Parameters:             NId: TInt const &             Values: TFltV &          FltAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Values: TFltV & AttrNameEI(TNEANet self, TInt EId, TStrV Names)          Parameters:             EId: TInt const &             Names: TStrV &          AttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Names: TStrV & AttrValueEI(TNEANet self, TInt EId, TStrV Values)          Parameters:             EId: TInt const &             Values: TStrV &          AttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Values: TStrV & IntAttrNameEI(TNEANet self, TInt EId, TStrV Names)          Parameters:             EId: TInt const &             Names: TStrV &          IntAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Names: TStrV & IntAttrValueEI(TNEANet self, TInt EId, TIntV Values)          Parameters:             EId: TInt const &             Values: TIntV &          IntAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Values: TIntV & StrAttrNameEI(TNEANet self, TInt EId, TStrV Names)          Parameters:             EId: TInt const &             Names: TStrV &          StrAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Names: TStrV & StrAttrValueEI(TNEANet self, TInt EId, TStrV Values)          Parameters:             EId: TInt const &             Values: TStrV &          StrAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Values: TStrV & FltAttrNameEI(TNEANet self, TInt EId, TStrV Names)          Parameters:             EId: TInt const &             Names: TStrV &          FltAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Names: TStrV & FltAttrValueEI(TNEANet self, TInt EId, TFltV & Values)          Parameters:             EId: TInt const &             Values: TFltV &          FltAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Values: TFltV & GetEAIntI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI          Parameters:             attr: TStr const &             EId: int const & GetEAStrI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI          Parameters:             attr: TStr const &             EId: int const & GetEAFltI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI          Parameters:             attr: TStr const &             EId: int const & GetMxNId(TNEANet self) -> int          Parameters:             self: TNEANet const * GetEdges(TNEANet self) -> int          Parameters:             self: TNEANet const * AddEdge(TNEANet self, int const & SrcNId, int const & DstNId, int EId=-1) -> int          Parameters:             SrcNId: int const &             DstNId: int const &             EId: int          AddEdge(TNEANet self, int const & SrcNId, int const & DstNId) -> int          Parameters:             SrcNId: int const &             DstNId: int const &          AddEdge(TNEANet self, TNEANet::TEdgeI const & EdgeI) -> int          Parameters:             EdgeI: TNEANet::TEdgeI const & DelEdge(TNEANet self, int const & EId)          Parameters:             EId: int const &          DelEdge(TNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)          Parameters:             SrcNId: int const &             DstNId: int const &             IsDir: bool const &          DelEdge(TNEANet self, int const & SrcNId, int const & DstNId)          Parameters:             SrcNId: int const &             DstNId: int const & IsEdge(TNEANet self, int const & EId) -> bool          Parameters:             EId: int const &          IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             IsDir: bool const &          IsEdge(TNEANet self, int const & SrcNId, int const & DstNId) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &          IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             EId: int &             IsDir: bool const &          IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             EId: int & GetEId(TNEANet self, int const & SrcNId, int const & DstNId) -> int          Parameters:             SrcNId: int const &             DstNId: int const & GetEI(TNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI          Parameters:             SrcNId: int const &             DstNId: int const & GetRndNId(TNEANet self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndNId(TNEANet self) -> int          Parameters:             self: TNEANet * GetRndNI(TNEANet self, TRnd Rnd=Rnd) -> TNEANet::TNodeI          Parameters:             Rnd: TRnd &          GetRndNI(TNEANet self) -> TNEANet::TNodeI          Parameters:             self: TNEANet * GetRndEId(TNEANet self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndEId(TNEANet self) -> int          Parameters:             self: TNEANet * GetRndEI(TNEANet self, TRnd Rnd=Rnd) -> TNEANet::TEdgeI          Parameters:             Rnd: TRnd &          GetRndEI(TNEANet self) -> TNEANet::TEdgeI          Parameters:             self: TNEANet * GetNIdV(TNEANet self, TIntV NIdV)          Parameters:             NIdV: TIntV & GetEIdV(TNEANet self, TIntV EIdV)          Parameters:             EIdV: TIntV & Empty(TNEANet self) -> bool          Parameters:             self: TNEANet const * Clr(TNEANet self)          Parameters:             self: TNEANet * Reserve(TNEANet self, int const & Nodes, int const & Edges)          Parameters:             Nodes: int const &             Edges: int const & Defrag(TNEANet self, bool const & OnlyNodeLinks=False)          Parameters:             OnlyNodeLinks: bool const &          Defrag(TNEANet self)          Parameters:             self: TNEANet * IsOk(TNEANet self, bool const & ThrowExcept=True) -> bool          Parameters:             ThrowExcept: bool const &          IsOk(TNEANet self) -> bool          Parameters:             self: TNEANet const * Dump(TNEANet self, FILE * OutF=stdout)          Parameters:             OutF: FILE *          Dump(TNEANet self)          Parameters:             self: TNEANet const * AddIntAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int          Parameters:             NodeId: TNEANet::TNodeI const &             value: TInt const &             attr: TStr const &          AddIntAttrDatN(TNEANet self, int const & NId, TInt value, TStr attr) -> int          Parameters:             NId: int const &             value: TInt const &             attr: TStr const & AddStrAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int          Parameters:             NodeId: TNEANet::TNodeI const &             value: TStr const &             attr: TStr const &          AddStrAttrDatN(TNEANet self, int const & NId, TStr value, TStr attr) -> int          Parameters:             NId: int const &             value: TStr const &             attr: TStr const & AddFltAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int          Parameters:             NodeId: TNEANet::TNodeI const &             value: TFlt const &             attr: TStr const &          AddFltAttrDatN(TNEANet self, int const & NId, TFlt value, TStr attr) -> int          Parameters:             NId: int const &             value: TFlt const &             attr: TStr const & AddIntAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int          Parameters:             EdgeId: TNEANet::TEdgeI const &             value: TInt const &             attr: TStr const &          AddIntAttrDatE(TNEANet self, int const & EId, TInt value, TStr attr) -> int          Parameters:             EId: int const &             value: TInt const &             attr: TStr const & AddStrAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int          Parameters:             EdgeId: TNEANet::TEdgeI const &             value: TStr const &             attr: TStr const &          AddStrAttrDatE(TNEANet self, int const & EId, TStr value, TStr attr) -> int          Parameters:             EId: int const &             value: TStr const &             attr: TStr const & AddFltAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int          Parameters:             EdgeId: TNEANet::TEdgeI const &             value: TFlt const &             attr: TStr const &          AddFltAttrDatE(TNEANet self, int const & EId, TFlt value, TStr attr) -> int          Parameters:             EId: int const &             value: TFlt const &             attr: TStr const & GetIntAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TInt          Parameters:             NodeId: TNEANet::TNodeI const &             attr: TStr const &          GetIntAttrDatN(TNEANet self, int const & NId, TStr attr) -> TInt          Parameters:             NId: int const &             attr: TStr const & GetStrAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TStr          Parameters:             NodeId: TNEANet::TNodeI const &             attr: TStr const &          GetStrAttrDatN(TNEANet self, int const & NId, TStr attr) -> TStr          Parameters:             NId: int const &             attr: TStr const & GetFltAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt          Parameters:             NodeId: TNEANet::TNodeI const &             attr: TStr const &          GetFltAttrDatN(TNEANet self, int const & NId, TStr attr) -> TFlt          Parameters:             NId: int const &             attr: TStr const & GetIntAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt          Parameters:             EdgeId: TNEANet::TEdgeI const &             attr: TStr const &          GetIntAttrDatE(TNEANet self, int const & EId, TStr attr) -> TInt          Parameters:             EId: int const &             attr: TStr const & GetStrAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr          Parameters:             EdgeId: TNEANet::TEdgeI const &             attr: TStr const &          GetStrAttrDatE(TNEANet self, int const & EId, TStr attr) -> TStr          Parameters:             EId: int const &             attr: TStr const & GetFltAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt          Parameters:             EdgeId: TNEANet::TEdgeI const &             attr: TStr const &          GetFltAttrDatE(TNEANet self, int const & EId, TStr attr) -> TFlt          Parameters:             EId: int const &             attr: TStr const & DelAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> int          Parameters:             NodeId: TNEANet::TNodeI const &             attr: TStr const &          DelAttrDatN(TNEANet self, int const & NId, TStr attr) -> int          Parameters:             NId: int const &             attr: TStr const & DelAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> int          Parameters:             EdgeId: TNEANet::TEdgeI const &             attr: TStr const &          DelAttrDatE(TNEANet self, int const & EId, TStr attr) -> int          Parameters:             EId: int const &             attr: TStr const & AddIntAttrN(TNEANet self, TStr attr, TInt defaultValue=Mn) -> int          Parameters:             attr: TStr const &             defaultValue: TInt          AddIntAttrN(TNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddStrAttrN(TNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int          Parameters:             attr: TStr const &             defaultValue: TStr          AddStrAttrN(TNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddFltAttrN(TNEANet self, TStr attr, TFlt defaultValue=Mn) -> int          Parameters:             attr: TStr const &             defaultValue: TFlt          AddFltAttrN(TNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddIntAttrE(TNEANet self, TStr attr, TInt defaultValue=Mn) -> int          Parameters:             attr: TStr const &             defaultValue: TInt          AddIntAttrE(TNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddStrAttrE(TNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int          Parameters:             attr: TStr const &             defaultValue: TStr          AddStrAttrE(TNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddFltAttrE(TNEANet self, TStr attr, TFlt defaultValue=Mn) -> int          Parameters:             attr: TStr const &             defaultValue: TFlt          AddFltAttrE(TNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & DelAttrN(TNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & DelAttrE(TNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & NodeAttrIsDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & NodeAttrIsIntDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & NodeAttrIsStrDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & NodeAttrIsFltDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & EdgeAttrIsDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & EdgeAttrIsIntDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & EdgeAttrIsStrDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & EdgeAttrIsFltDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & GetNodeAttrValue(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & GetEdgeAttrValue(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & BegNI(TNEANet self) -> TNEANet::TNodeI         BegNI(TNEANet self) -> TNEANetNodeI          Parameters:             self: TNEANet * EndNI(TNEANet self) -> TNEANet::TNodeI         EndNI(TNEANet self) -> TNEANetNodeI          Parameters:             self: TNEANet * BegEI(TNEANet self) -> TNEANet::TEdgeI         BegEI(TNEANet self) -> TNEANetEdgeI          Parameters:             self: TNEANet * EndEI(TNEANet self) -> TNEANet::TEdgeI         EndEI(TNEANet self) -> TNEANetEdgeI          Parameters:             self: TNEANet * BegNAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI          Parameters:             attr: TStr const &          BegNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI          Parameters:             attr: TStr const & EndNAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI          Parameters:             attr: TStr const &          EndNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI          Parameters:             attr: TStr const & BegNAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI          Parameters:             attr: TStr const &          BegNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI          Parameters:             attr: TStr const & EndNAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI          Parameters:             attr: TStr const &          EndNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI          Parameters:             attr: TStr const & BegNAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI          Parameters:             attr: TStr const &          BegNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI          Parameters:             attr: TStr const & EndNAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI          Parameters:             attr: TStr const &          EndNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI          Parameters:             attr: TStr const & BegEAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI          Parameters:             attr: TStr const &          BegEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI          Parameters:             attr: TStr const & EndEAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI          Parameters:             attr: TStr const &          EndEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI          Parameters:             attr: TStr const & BegEAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI          Parameters:             attr: TStr const &          BegEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI          Parameters:             attr: TStr const & EndEAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI          Parameters:             attr: TStr const &          EndEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI          Parameters:             attr: TStr const & BegEAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI          Parameters:             attr: TStr const &          BegEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI          Parameters:             attr: TStr const & EndEAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI          Parameters:             attr: TStr const &          EndEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI          Parameters:             attr: TStr const & New() -> PNEANet     TNEANet_New(int const & Nodes, int const & Edges) -> PNEANet      Parameters:         Nodes: int const &         Edges: int const & TNEANet_Load(TSIn SIn) -> PNEANet      Parameters:         SIn: TSIn & PercentDegree(PNEANet Graph, int const Threshold=0) -> double      Parameters:         Graph: TPt< TNEANet > const &         Threshold: int const      PercentDegree(PNEANet Graph) -> double      Parameters:         Graph: TPt< TNEANet > const & PercentMxWcc(PNEANet Graph) -> double      Parameters:         Graph: TPt< TNEANet > const & PercentMxScc(PNEANet Graph) -> double      Parameters:         Graph: TPt< TNEANet > const & LoadEdgeList(TStr InFNm, int const & SrcColId=0, int const & DstColId=1) -> PNEANet      Parameters:         InFNm: TStr const &         SrcColId: int const &         DstColId: int const &      LoadEdgeList(TStr InFNm, int const & SrcColId=0) -> PNEANet      Parameters:         InFNm: TStr const &         SrcColId: int const &      LoadEdgeList(TStr InFNm) -> PNEANet      Parameters:         InFNm: TStr const &      LoadEdgeList(TStr InFNm, int const & SrcColId, int const & DstColId, char const & Separator) -> PNEANet      Parameters:         InFNm: TStr const &         SrcColId: int const &         DstColId: int const &         Separator: char const & PrintGraphStatTable(PNEANet G, TStr OutFNm, TStr Desc="")      Parameters:         G: TPt< TNEANet > const &         OutFNm: TStr         Desc: TStr      PrintGraphStatTable(PNEANet G, TStr OutFNm)      Parameters:         G: TPt< TNEANet > const &         OutFNm: TStr GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True, TRnd Rnd=Rnd) -> PNEANet      Parameters:         Nodes: int const &         Edges: int const &         IsDir: bool const &         Rnd: TRnd &      GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True) -> PNEANet      Parameters:         Nodes: int const &         Edges: int const &         IsDir: bool const &      GenRndGnm(int const & Nodes, int const & Edges) -> PNEANet      Parameters:         Nodes: int const &         Edges: int const & NodesGTEDegree(PNEANet Graph, int const Threshold=0) -> int      Parameters:         Graph: TPt< TNEANet > const &         Threshold: int const      NodesGTEDegree(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & MxDegree(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & MxSccSz(PNEANet Graph) -> PNEANet      Parameters:         Graph: TPt< TNEANet > const & MxWccSz(PNEANet Graph) -> double      Parameters:         Graph: TPt< TNEANet > const & Proxy of C++ TPt<(TNEANet)> class New() -> PNEANet Save(PNEANet self, TSOut SOut)          Parameters:             SOut: TSOut & __deref__(PNEANet self) -> TNEANet          Parameters:             self: TPt< TNEANet > const * __ref__(PNEANet self) -> TNEANet          Parameters:             self: TPt< TNEANet > const * __call__(PNEANet self) -> TNEANet          Parameters:             self: TPt< TNEANet > const * Empty(PNEANet self) -> bool          Parameters:             self: TPt< TNEANet > const * Clr(PNEANet self)          Parameters:             self: TPt< TNEANet > * GetRefs(PNEANet self) -> int          Parameters:             self: TPt< TNEANet > const * Load(PNEANet self, TSIn SIn) -> PNEANet          Parameters:             SIn: TSIn & HasFlag(PNEANet self, TGraphFlag const & Flag) -> bool          Parameters:             Flag: TGraphFlag const & GetNodes(PNEANet self) -> int          Parameters:             self: TPt< TNEANet > const * AddNode(PNEANet self, int NId=-1) -> int          Parameters:             NId: int          AddNode(PNEANet self) -> int         AddNode(PNEANet self, TNEANet::TNodeI const & NodeId) -> int          Parameters:             NodeId: TNEANet::TNodeI const & DelNode(PNEANet self, int const & NId)          Parameters:             NId: int const &          DelNode(PNEANet self, TNEANet::TNode const & NodeI)          Parameters:             NodeI: TNEANet::TNode const & IsNode(PNEANet self, int const & NId) -> bool          Parameters:             NId: int const & BegNI(PNEANet self) -> TNEANet::TNodeI         BegNI(PNEANet self) -> TNEANetNodeI          Parameters:             self: TPt< TNEANet > * EndNI(PNEANet self) -> TNEANet::TNodeI         EndNI(PNEANet self) -> TNEANetNodeI          Parameters:             self: TPt< TNEANet > * GetNI(PNEANet self, int const & NId) -> TNEANet::TNodeI          Parameters:             NId: int const & BegNAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI          Parameters:             attr: TStr const &          BegNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI          Parameters:             attr: TStr const & EndNAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI          Parameters:             attr: TStr const &          EndNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI          Parameters:             attr: TStr const & GetNAIntI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI          Parameters:             attr: TStr const &             NId: int const & BegNAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI          Parameters:             attr: TStr const &          BegNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI          Parameters:             attr: TStr const & EndNAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI          Parameters:             attr: TStr const &          EndNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI          Parameters:             attr: TStr const & GetNAStrI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI          Parameters:             attr: TStr const &             NId: int const & BegNAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI          Parameters:             attr: TStr const &          BegNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI          Parameters:             attr: TStr const & EndNAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI          Parameters:             attr: TStr const &          EndNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI          Parameters:             attr: TStr const & GetNAFltI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI          Parameters:             attr: TStr const &             NId: int const & AttrNameNI(PNEANet self, TInt NId, TStrV Names)          Parameters:             NId: TInt const &             Names: TStrV &          AttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Names: TStrV & AttrValueNI(PNEANet self, TInt NId, TStrV Values)          Parameters:             NId: TInt const &             Values: TStrV &          AttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Values: TStrV & IntAttrNameNI(PNEANet self, TInt NId, TStrV Names)          Parameters:             NId: TInt const &             Names: TStrV &          IntAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Names: TStrV & IntAttrValueNI(PNEANet self, TInt NId, TIntV Values)          Parameters:             NId: TInt const &             Values: TIntV &          IntAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Values: TIntV & StrAttrNameNI(PNEANet self, TInt NId, TStrV Names)          Parameters:             NId: TInt const &             Names: TStrV &          StrAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Names: TStrV & StrAttrValueNI(PNEANet self, TInt NId, TStrV Values)          Parameters:             NId: TInt const &             Values: TStrV &          StrAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Values: TStrV & FltAttrNameNI(PNEANet self, TInt NId, TStrV Names)          Parameters:             NId: TInt const &             Names: TStrV &          FltAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Names: TStrV & FltAttrValueNI(PNEANet self, TInt NId, TFltV & Values)          Parameters:             NId: TInt const &             Values: TFltV &          FltAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values)          Parameters:             NId: TInt const &             NodeHI: TStrIntPrH::TIter             Values: TFltV & AttrNameEI(PNEANet self, TInt EId, TStrV Names)          Parameters:             EId: TInt const &             Names: TStrV &          AttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Names: TStrV & AttrValueEI(PNEANet self, TInt EId, TStrV Values)          Parameters:             EId: TInt const &             Values: TStrV &          AttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Values: TStrV & IntAttrNameEI(PNEANet self, TInt EId, TStrV Names)          Parameters:             EId: TInt const &             Names: TStrV &          IntAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Names: TStrV & IntAttrValueEI(PNEANet self, TInt EId, TIntV Values)          Parameters:             EId: TInt const &             Values: TIntV &          IntAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Values: TIntV & StrAttrNameEI(PNEANet self, TInt EId, TStrV Names)          Parameters:             EId: TInt const &             Names: TStrV &          StrAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Names: TStrV & StrAttrValueEI(PNEANet self, TInt EId, TStrV Values)          Parameters:             EId: TInt const &             Values: TStrV &          StrAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Values: TStrV & FltAttrNameEI(PNEANet self, TInt EId, TStrV Names)          Parameters:             EId: TInt const &             Names: TStrV &          FltAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Names: TStrV & FltAttrValueEI(PNEANet self, TInt EId, TFltV & Values)          Parameters:             EId: TInt const &             Values: TFltV &          FltAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values)          Parameters:             EId: TInt const &             EdgeHI: TStrIntPrH::TIter             Values: TFltV & BegEAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI          Parameters:             attr: TStr const &          BegEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI          Parameters:             attr: TStr const & EndEAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI          Parameters:             attr: TStr const &          EndEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI          Parameters:             attr: TStr const & GetEAIntI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI          Parameters:             attr: TStr const &             EId: int const & BegEAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI          Parameters:             attr: TStr const &          BegEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI          Parameters:             attr: TStr const & EndEAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI          Parameters:             attr: TStr const &          EndEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI          Parameters:             attr: TStr const & GetEAStrI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI          Parameters:             attr: TStr const &             EId: int const & BegEAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI          Parameters:             attr: TStr const &          BegEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI          Parameters:             attr: TStr const & EndEAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI          Parameters:             attr: TStr const &          EndEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI          Parameters:             attr: TStr const & GetEAFltI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI          Parameters:             attr: TStr const &             EId: int const & GetMxNId(PNEANet self) -> int          Parameters:             self: TPt< TNEANet > const * GetEdges(PNEANet self) -> int          Parameters:             self: TPt< TNEANet > const * AddEdge(PNEANet self, int const & SrcNId, int const & DstNId, int EId=-1) -> int          Parameters:             SrcNId: int const &             DstNId: int const &             EId: int          AddEdge(PNEANet self, int const & SrcNId, int const & DstNId) -> int          Parameters:             SrcNId: int const &             DstNId: int const &          AddEdge(PNEANet self, TNEANet::TEdgeI const & EdgeI) -> int          Parameters:             EdgeI: TNEANet::TEdgeI const & DelEdge(PNEANet self, int const & EId)          Parameters:             EId: int const &          DelEdge(PNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True)          Parameters:             SrcNId: int const &             DstNId: int const &             IsDir: bool const &          DelEdge(PNEANet self, int const & SrcNId, int const & DstNId)          Parameters:             SrcNId: int const &             DstNId: int const & IsEdge(PNEANet self, int const & EId) -> bool          Parameters:             EId: int const &          IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             IsDir: bool const &          IsEdge(PNEANet self, int const & SrcNId, int const & DstNId) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &          IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             EId: int &             IsDir: bool const &          IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool          Parameters:             SrcNId: int const &             DstNId: int const &             EId: int & GetEId(PNEANet self, int const & SrcNId, int const & DstNId) -> int          Parameters:             SrcNId: int const &             DstNId: int const & BegEI(PNEANet self) -> TNEANet::TEdgeI         BegEI(PNEANet self) -> TNEANetEdgeI          Parameters:             self: TPt< TNEANet > * EndEI(PNEANet self) -> TNEANet::TEdgeI         EndEI(PNEANet self) -> TNEANetEdgeI          Parameters:             self: TPt< TNEANet > * GetEI(PNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI          Parameters:             SrcNId: int const &             DstNId: int const & GetRndNId(PNEANet self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndNId(PNEANet self) -> int          Parameters:             self: TPt< TNEANet > * GetRndNI(PNEANet self, TRnd Rnd=Rnd) -> TNEANet::TNodeI          Parameters:             Rnd: TRnd &          GetRndNI(PNEANet self) -> TNEANet::TNodeI          Parameters:             self: TPt< TNEANet > * GetRndEId(PNEANet self, TRnd Rnd=Rnd) -> int          Parameters:             Rnd: TRnd &          GetRndEId(PNEANet self) -> int          Parameters:             self: TPt< TNEANet > * GetRndEI(PNEANet self, TRnd Rnd=Rnd) -> TNEANet::TEdgeI          Parameters:             Rnd: TRnd &          GetRndEI(PNEANet self) -> TNEANet::TEdgeI          Parameters:             self: TPt< TNEANet > * GetNIdV(PNEANet self, TIntV NIdV)          Parameters:             NIdV: TIntV & GetEIdV(PNEANet self, TIntV EIdV)          Parameters:             EIdV: TIntV & Reserve(PNEANet self, int const & Nodes, int const & Edges)          Parameters:             Nodes: int const &             Edges: int const & Defrag(PNEANet self, bool const & OnlyNodeLinks=False)          Parameters:             OnlyNodeLinks: bool const &          Defrag(PNEANet self)          Parameters:             self: TPt< TNEANet > * IsOk(PNEANet self, bool const & ThrowExcept=True) -> bool          Parameters:             ThrowExcept: bool const &          IsOk(PNEANet self) -> bool          Parameters:             self: TPt< TNEANet > const * Dump(PNEANet self, FILE * OutF=stdout)          Parameters:             OutF: FILE *          Dump(PNEANet self)          Parameters:             self: TPt< TNEANet > const * AddIntAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int          Parameters:             NodeId: TNEANet::TNodeI const &             value: TInt const &             attr: TStr const &          AddIntAttrDatN(PNEANet self, int const & NId, TInt value, TStr attr) -> int          Parameters:             NId: int const &             value: TInt const &             attr: TStr const & AddStrAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int          Parameters:             NodeId: TNEANet::TNodeI const &             value: TStr const &             attr: TStr const &          AddStrAttrDatN(PNEANet self, int const & NId, TStr value, TStr attr) -> int          Parameters:             NId: int const &             value: TStr const &             attr: TStr const & AddFltAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int          Parameters:             NodeId: TNEANet::TNodeI const &             value: TFlt const &             attr: TStr const &          AddFltAttrDatN(PNEANet self, int const & NId, TFlt value, TStr attr) -> int          Parameters:             NId: int const &             value: TFlt const &             attr: TStr const & AddIntAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int          Parameters:             EdgeId: TNEANet::TEdgeI const &             value: TInt const &             attr: TStr const &          AddIntAttrDatE(PNEANet self, int const & EId, TInt value, TStr attr) -> int          Parameters:             EId: int const &             value: TInt const &             attr: TStr const & AddStrAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int          Parameters:             EdgeId: TNEANet::TEdgeI const &             value: TStr const &             attr: TStr const &          AddStrAttrDatE(PNEANet self, int const & EId, TStr value, TStr attr) -> int          Parameters:             EId: int const &             value: TStr const &             attr: TStr const & AddFltAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int          Parameters:             EdgeId: TNEANet::TEdgeI const &             value: TFlt const &             attr: TStr const &          AddFltAttrDatE(PNEANet self, int const & EId, TFlt value, TStr attr) -> int          Parameters:             EId: int const &             value: TFlt const &             attr: TStr const & GetIntAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TInt          Parameters:             NodeId: TNEANet::TNodeI const &             attr: TStr const &          GetIntAttrDatN(PNEANet self, int const & NId, TStr attr) -> TInt          Parameters:             NId: int const &             attr: TStr const & GetStrAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TStr          Parameters:             NodeId: TNEANet::TNodeI const &             attr: TStr const &          GetStrAttrDatN(PNEANet self, int const & NId, TStr attr) -> TStr          Parameters:             NId: int const &             attr: TStr const & GetFltAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt          Parameters:             NodeId: TNEANet::TNodeI const &             attr: TStr const &          GetFltAttrDatN(PNEANet self, int const & NId, TStr attr) -> TFlt          Parameters:             NId: int const &             attr: TStr const & GetIntAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt          Parameters:             EdgeId: TNEANet::TEdgeI const &             attr: TStr const &          GetIntAttrDatE(PNEANet self, int const & EId, TStr attr) -> TInt          Parameters:             EId: int const &             attr: TStr const & GetStrAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr          Parameters:             EdgeId: TNEANet::TEdgeI const &             attr: TStr const &          GetStrAttrDatE(PNEANet self, int const & EId, TStr attr) -> TStr          Parameters:             EId: int const &             attr: TStr const & GetFltAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt          Parameters:             EdgeId: TNEANet::TEdgeI const &             attr: TStr const &          GetFltAttrDatE(PNEANet self, int const & EId, TStr attr) -> TFlt          Parameters:             EId: int const &             attr: TStr const & DelAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> int          Parameters:             NodeId: TNEANet::TNodeI const &             attr: TStr const &          DelAttrDatN(PNEANet self, int const & NId, TStr attr) -> int          Parameters:             NId: int const &             attr: TStr const & DelAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> int          Parameters:             EdgeId: TNEANet::TEdgeI const &             attr: TStr const &          DelAttrDatE(PNEANet self, int const & EId, TStr attr) -> int          Parameters:             EId: int const &             attr: TStr const & AddIntAttrN(PNEANet self, TStr attr, TInt defaultValue=Mn) -> int          Parameters:             attr: TStr const &             defaultValue: TInt          AddIntAttrN(PNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddStrAttrN(PNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int          Parameters:             attr: TStr const &             defaultValue: TStr          AddStrAttrN(PNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddFltAttrN(PNEANet self, TStr attr, TFlt defaultValue=Mn) -> int          Parameters:             attr: TStr const &             defaultValue: TFlt          AddFltAttrN(PNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddIntAttrE(PNEANet self, TStr attr, TInt defaultValue=Mn) -> int          Parameters:             attr: TStr const &             defaultValue: TInt          AddIntAttrE(PNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddStrAttrE(PNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int          Parameters:             attr: TStr const &             defaultValue: TStr          AddStrAttrE(PNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & AddFltAttrE(PNEANet self, TStr attr, TFlt defaultValue=Mn) -> int          Parameters:             attr: TStr const &             defaultValue: TFlt          AddFltAttrE(PNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & DelAttrN(PNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & DelAttrE(PNEANet self, TStr attr) -> int          Parameters:             attr: TStr const & NodeAttrIsDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & NodeAttrIsIntDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & NodeAttrIsStrDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & NodeAttrIsFltDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & EdgeAttrIsDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & EdgeAttrIsIntDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & EdgeAttrIsStrDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & EdgeAttrIsFltDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & GetNodeAttrValue(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr          Parameters:             NId: int const &             NodeHI: TStrIntPrH::TIter const & GetEdgeAttrValue(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr          Parameters:             EId: int const &             EdgeHI: TStrIntPrH::TIter const & PNEANet_New() -> PNEANet GetNodeWcc(PNEANet Graph, int const & NId, TIntV CnCom)      Parameters:         Graph: TPt< TNEANet > const &         NId: int const &         CnCom: TIntV & IsConnected(PNEANet Graph) -> bool      Parameters:         Graph: TPt< TNEANet > const & IsWeaklyConn(PNEANet Graph) -> bool      Parameters:         Graph: TPt< TNEANet > const & GetWccSzCnt(PNEANet Graph, TIntPrV & WccSzCnt)      Parameters:         Graph: TPt< TNEANet > const &         WccSzCnt: TIntPrV & GetWccs(PNEANet Graph, TCnComV & CnComV)      Parameters:         Graph: TPt< TNEANet > const &         CnComV: TCnComV & GetSccSzCnt(PNEANet Graph, TIntPrV & SccSzCnt)      Parameters:         Graph: TPt< TNEANet > const &         SccSzCnt: TIntPrV & GetSccs(PNEANet Graph, TCnComV & CnComV)      Parameters:         Graph: TPt< TNEANet > const &         CnComV: TCnComV & GetMxWccSz(PNEANet Graph) -> double      Parameters:         Graph: TPt< TNEANet > const & GetMxWcc(PNEANet Graph) -> PNEANet      Parameters:         Graph: TPt< TNEANet > const & GetMxScc(PNEANet Graph) -> PNEANet      Parameters:         Graph: TPt< TNEANet > const & GetMxBiCon(PUNGraph const & Graph, bool const & RenumberNodes=False) -> PUNGraph      Parameters:         Graph: PUNGraph const &         RenumberNodes: bool const &      GetMxBiCon(PUNGraph const & Graph) -> PUNGraph      Parameters:         Graph: PUNGraph const &      GetMxBiCon(PNEANet Graph) -> PNEANet      Parameters:         Graph: TPt< TNEANet > const & CntInDegNodes(PNEANet Graph, int const & NodeInDeg) -> int      Parameters:         Graph: TPt< TNEANet > const &         NodeInDeg: int const & CntOutDegNodes(PNEANet Graph, int const & NodeOutDeg) -> int      Parameters:         Graph: TPt< TNEANet > const &         NodeOutDeg: int const & CntDegNodes(PNEANet Graph, int const & NodeDeg) -> int      Parameters:         Graph: TPt< TNEANet > const &         NodeDeg: int const & CntNonZNodes(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & CntEdgesToSet(PNEANet Graph, int const & NId, TIntSet const & NodeSet) -> int      Parameters:         Graph: TPt< TNEANet > const &         NId: int const &         NodeSet: TIntSet const & GetMxDegNId(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & GetMxInDegNId(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & GetMxOutDegNId(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & GetInDegCnt(PNEANet Graph, TIntPrV & DegToCntV)      Parameters:         Graph: TPt< TNEANet > const &         DegToCntV: TIntPrV &      GetInDegCnt(PNEANet Graph, TFltPrV & DegToCntV)      Parameters:         Graph: TPt< TNEANet > const &         DegToCntV: TFltPrV & GetOutDegCnt(PNEANet Graph, TIntPrV & DegToCntV)      Parameters:         Graph: TPt< TNEANet > const &         DegToCntV: TIntPrV &      GetOutDegCnt(PNEANet Graph, TFltPrV & DegToCntV)      Parameters:         Graph: TPt< TNEANet > const &         DegToCntV: TFltPrV & GetDegCnt(PNEANet Graph, TIntPrV & DegToCntV)      Parameters:         Graph: TPt< TNEANet > const &         DegToCntV: TIntPrV &      GetDegCnt(PNEANet Graph, TFltPrV & DegToCntV)      Parameters:         Graph: TPt< TNEANet > const &         DegToCntV: TFltPrV & GetDegSeqV(PNEANet Graph, TIntV DegV)      Parameters:         Graph: TPt< TNEANet > const &         DegV: TIntV &      GetDegSeqV(PNEANet Graph, TIntV InDegV, TIntV OutDegV)      Parameters:         Graph: TPt< TNEANet > const &         InDegV: TIntV &         OutDegV: TIntV & GetNodeInDegV(PNEANet Graph, TIntPrV & NIdInDegV)      Parameters:         Graph: TPt< TNEANet > const &         NIdInDegV: TIntPrV & GetNodeOutDegV(PNEANet Graph, TIntPrV & NIdOutDegV)      Parameters:         Graph: TPt< TNEANet > const &         NIdOutDegV: TIntPrV & CntUniqUndirEdges(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & CntUniqDirEdges(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & CntUniqBiDirEdges(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & CntSelfEdges(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & GetBfsTree(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn) -> PNGraph      Parameters:         Graph: TPt< TNEANet > const &         StartNId: int const &         FollowOut: bool const &         FollowIn: bool const & GetSubTreeSz(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn,          int & TreeSz, int & TreeDepth) -> int      Parameters:         Graph: TPt< TNEANet > const &         StartNId: int const &         FollowOut: bool const &         FollowIn: bool const &         TreeSz: int &         TreeDepth: int & GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV, bool const & IsDir=False) -> int      Parameters:         Graph: TPt< TNEANet > const &         StartNId: int const &         Hop: int const &         NIdV: TIntV &         IsDir: bool const &      GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV) -> int      Parameters:         Graph: TPt< TNEANet > const &         StartNId: int const &         Hop: int const &         NIdV: TIntV & GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV, bool const & IsDir=False) -> int      Parameters:         Graph: TPt< TNEANet > const &         StartNId: int const &         HopCntV: TIntPrV &         IsDir: bool const &      GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV) -> int      Parameters:         Graph: TPt< TNEANet > const &         StartNId: int const &         HopCntV: TIntPrV & GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId, bool const & IsDir=False) -> int      Parameters:         Graph: TPt< TNEANet > const &         SrcNId: int const &         DstNId: int const &         IsDir: bool const &      GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId) -> int      Parameters:         Graph: TPt< TNEANet > const &         SrcNId: int const &         DstNId: int const &      GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False, int const & MaxDist=Mx) -> int      Parameters:         Graph: TPt< TNEANet > const &         SrcNId: int const &         NIdToDistH: TIntH &         IsDir: bool const &         MaxDist: int const &      GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False) -> int      Parameters:         Graph: TPt< TNEANet > const &         SrcNId: int const &         NIdToDistH: TIntH &         IsDir: bool const &      GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH) -> int      Parameters:         Graph: TPt< TNEANet > const &         SrcNId: int const &         NIdToDistH: TIntH & GetBfsFullDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> int      Parameters:         Graph: TPt< TNEANet > const &         NTestNodes: int const &         IsDir: bool const &      GetBfsFullDiam(PNEANet Graph, int const & NTestNodes) -> int      Parameters:         Graph: TPt< TNEANet > const &         NTestNodes: int const & GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> double      Parameters:         Graph: TPt< TNEANet > const &         NTestNodes: int const &         IsDir: bool const &      GetBfsEffDiam(PNEANet Graph, int const & NTestNodes) -> double      Parameters:         Graph: TPt< TNEANet > const &         NTestNodes: int const &      GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam) -> double      Parameters:         Graph: TPt< TNEANet > const &         NTestNodes: int const &         IsDir: bool const &         EffDiam: double &         FullDiam: int &      GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam,          double & AvgSPL) -> double      Parameters:         Graph: TPt< TNEANet > const &         NTestNodes: int const &         IsDir: bool const &         EffDiam: double &         FullDiam: int &         AvgSPL: double &      GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, TIntV SubGraphNIdV, bool const & IsDir, double & EffDiam,          int & FullDiam) -> double      Parameters:         Graph: TPt< TNEANet > const &         NTestNodes: int const &         SubGraphNIdV: TIntV const &         IsDir: bool const &         EffDiam: double &         FullDiam: int & DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False,          TIntStrH const & NIdColorH=TIntStrH())      Parameters:         Graph: TPt< TNEANet > const &         Layout: TGVizLayout const &         PltFNm: TStr const &         Desc: TStr const &         NodeLabels: bool const &         NIdColorH: TIntStrH const &      DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False)      Parameters:         Graph: TPt< TNEANet > const &         Layout: TGVizLayout const &         PltFNm: TStr const &         Desc: TStr const &         NodeLabels: bool const &      DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr())      Parameters:         Graph: TPt< TNEANet > const &         Layout: TGVizLayout const &         PltFNm: TStr const &         Desc: TStr const &      DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm)      Parameters:         Graph: TPt< TNEANet > const &         Layout: TGVizLayout const &         PltFNm: TStr const &      DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc, TIntStrH const & NodeLabelH)      Parameters:         Graph: TPt< TNEANet > const &         Layout: TGVizLayout const &         PltFNm: TStr const &         Desc: TStr const &         NodeLabelH: TIntStrH const & GetClustCf(PNEANet Graph, int SampleNodes=-1) -> double      Parameters:         Graph: TPt< TNEANet > const &         SampleNodes: int      GetClustCf(PNEANet Graph) -> double      Parameters:         Graph: TPt< TNEANet > const &      GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int SampleNodes=-1) -> double      Parameters:         Graph: TPt< TNEANet > const &         DegToCCfV: TFltPrV &         SampleNodes: int      GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV) -> double      Parameters:         Graph: TPt< TNEANet > const &         DegToCCfV: TFltPrV &      GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes=-1) -> double      Parameters:         Graph: TPt< TNEANet > const &         DegToCCfV: TFltPrV &         ClosedTriads: int64 &         OpenTriads: int64 &         SampleNodes: int      GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads) -> double      Parameters:         Graph: TPt< TNEANet > const &         DegToCCfV: TFltPrV &         ClosedTriads: int64 &         OpenTriads: int64 & GetNodeClustCf(PNEANet Graph, int const & NId) -> double      Parameters:         Graph: TPt< TNEANet > const &         NId: int const &      GetNodeClustCf(PNEANet Graph, TIntFltH & NIdCCfH)      Parameters:         Graph: TPt< TNEANet > const &         NIdCCfH: TIntFltH & GetTriads(PNEANet Graph, int SampleNodes=-1) -> int64      Parameters:         Graph: TPt< TNEANet > const &         SampleNodes: int      GetTriads(PNEANet Graph) -> int64      Parameters:         Graph: TPt< TNEANet > const &      GetTriads(PNEANet Graph, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes) -> int64      Parameters:         Graph: TPt< TNEANet > const &         ClosedTriads: int64 &         OpenTriads: int64 &         SampleNodes: int      GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV, int SampleNodes=-1)      Parameters:         Graph: TPt< TNEANet > const &         NIdCOTriadV: TIntTrV &         SampleNodes: int      GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV)      Parameters:         Graph: TPt< TNEANet > const &         NIdCOTriadV: TIntTrV & GetTriadEdges(PNEANet Graph, int SampleEdges=-1) -> int      Parameters:         Graph: TPt< TNEANet > const &         SampleEdges: int      GetTriadEdges(PNEANet Graph) -> int      Parameters:         Graph: TPt< TNEANet > const & GetTriadParticip(PNEANet Graph, TIntPrV & TriadCntV)      Parameters:         Graph: TPt< TNEANet > const &         TriadCntV: TIntPrV & GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2) -> int      Parameters:         Graph: TPt< TNEANet > const &         NId1: int const &         NId2: int const &      GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2, TIntV NbrV) -> int      Parameters:         Graph: TPt< TNEANet > const &         NId1: int const &         NId2: int const &         NbrV: TIntV & GetModularity(PNEANet G, TIntV NIdV, int GEdges=-1) -> double      Parameters:         G: TPt< TNEANet > const &         NIdV: TIntV const &         GEdges: int      GetModularity(PNEANet G, TIntV NIdV) -> double      Parameters:         G: TPt< TNEANet > const &         NIdV: TIntV const &      GetModularity(PNEANet G, TCnComV const & CmtyV, int GEdges=-1) -> double      Parameters:         G: TPt< TNEANet > const &         CmtyV: TCnComV const &         GEdges: int      GetModularity(PNEANet G, TCnComV const & CmtyV) -> double      Parameters:         G: TPt< TNEANet > const &         CmtyV: TCnComV const & GetEdgesInOut(PNEANet Graph, TIntV NIdV, int & EdgesIn, int & EdgesOut)      Parameters:         Graph: TPt< TNEANet > const &         NIdV: TIntV const &         EdgesIn: int &         EdgesOut: int & GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir,          int const & NApprox=32)      Parameters:         Graph: TPt< TNEANet > const &         SrcNId: int const &         DistNbrsV: TIntFltKdV &         MxDist: int const &         IsDir: bool const &         NApprox: int const &      GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir)      Parameters:         Graph: TPt< TNEANet > const &         SrcNId: int const &         DistNbrsV: TIntFltKdV &         MxDist: int const &         IsDir: bool const &      GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir, int const & NApprox=32)      Parameters:         Graph: TPt< TNEANet > const &         DistNbrsV: TIntFltKdV &         MxDist: int const &         IsDir: bool const &         NApprox: int const &      GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir)      Parameters:         Graph: TPt< TNEANet > const &         DistNbrsV: TIntFltKdV &         MxDist: int const &         IsDir: bool const & GetAnfEffDiam(PNEANet Graph, bool const & IsDir, double const & Percentile, int const & NApprox) -> double      Parameters:         Graph: TPt< TNEANet > const &         IsDir: bool const &         Percentile: double const &         NApprox: int const &      GetAnfEffDiam(PNEANet Graph, int const NRuns=1, int NApprox=-1) -> double      Parameters:         Graph: TPt< TNEANet > const &         NRuns: int const         NApprox: int      GetAnfEffDiam(PNEANet Graph, int const NRuns=1) -> double      Parameters:         Graph: TPt< TNEANet > const &         NRuns: int const      GetAnfEffDiam(PNEANet Graph) -> double      Parameters:         Graph: TPt< TNEANet > const &