# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_pysimulavr', [dirname(__file__)])
        except ImportError:
            import _pysimulavr
            return _pysimulavr
        if fp is not None:
            try:
                _mod = imp.load_module('_pysimulavr', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _pysimulavr = swig_import_helper()
    del swig_import_helper
else:
    import _pysimulavr
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) or hasattr(self,name):
        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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


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

class ios_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ios_base, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    erase_event = _pysimulavr.ios_base_erase_event
    imbue_event = _pysimulavr.ios_base_imbue_event
    copyfmt_event = _pysimulavr.ios_base_copyfmt_event
    def register_callback(self, *args): return _pysimulavr.ios_base_register_callback(self, *args)
    def flags(self, *args): return _pysimulavr.ios_base_flags(self, *args)
    def setf(self, *args): return _pysimulavr.ios_base_setf(self, *args)
    def unsetf(self, *args): return _pysimulavr.ios_base_unsetf(self, *args)
    def precision(self, *args): return _pysimulavr.ios_base_precision(self, *args)
    def width(self, *args): return _pysimulavr.ios_base_width(self, *args)
    __swig_getmethods__["sync_with_stdio"] = lambda x: _pysimulavr.ios_base_sync_with_stdio
    if _newclass:sync_with_stdio = staticmethod(_pysimulavr.ios_base_sync_with_stdio)
    def imbue(self, *args): return _pysimulavr.ios_base_imbue(self, *args)
    def getloc(self): return _pysimulavr.ios_base_getloc(self)
    __swig_getmethods__["xalloc"] = lambda x: _pysimulavr.ios_base_xalloc
    if _newclass:xalloc = staticmethod(_pysimulavr.ios_base_xalloc)
    def iword(self, *args): return _pysimulavr.ios_base_iword(self, *args)
    def pword(self, *args): return _pysimulavr.ios_base_pword(self, *args)
    __swig_destroy__ = _pysimulavr.delete_ios_base
    __del__ = lambda self : None;
ios_base_swigregister = _pysimulavr.ios_base_swigregister
ios_base_swigregister(ios_base)
cvar = _pysimulavr.cvar
ios_base.boolalpha = _pysimulavr.cvar.ios_base_boolalpha
ios_base.dec = _pysimulavr.cvar.ios_base_dec
ios_base.fixed = _pysimulavr.cvar.ios_base_fixed
ios_base.hex = _pysimulavr.cvar.ios_base_hex
ios_base.internal = _pysimulavr.cvar.ios_base_internal
ios_base.left = _pysimulavr.cvar.ios_base_left
ios_base.oct = _pysimulavr.cvar.ios_base_oct
ios_base.right = _pysimulavr.cvar.ios_base_right
ios_base.scientific = _pysimulavr.cvar.ios_base_scientific
ios_base.showbase = _pysimulavr.cvar.ios_base_showbase
ios_base.showpoint = _pysimulavr.cvar.ios_base_showpoint
ios_base.showpos = _pysimulavr.cvar.ios_base_showpos
ios_base.skipws = _pysimulavr.cvar.ios_base_skipws
ios_base.unitbuf = _pysimulavr.cvar.ios_base_unitbuf
ios_base.uppercase = _pysimulavr.cvar.ios_base_uppercase
ios_base.adjustfield = _pysimulavr.cvar.ios_base_adjustfield
ios_base.basefield = _pysimulavr.cvar.ios_base_basefield
ios_base.floatfield = _pysimulavr.cvar.ios_base_floatfield
ios_base.badbit = _pysimulavr.cvar.ios_base_badbit
ios_base.eofbit = _pysimulavr.cvar.ios_base_eofbit
ios_base.failbit = _pysimulavr.cvar.ios_base_failbit
ios_base.goodbit = _pysimulavr.cvar.ios_base_goodbit
ios_base.app = _pysimulavr.cvar.ios_base_app
ios_base.ate = _pysimulavr.cvar.ios_base_ate
ios_base.binary = _pysimulavr.cvar.ios_base_binary
ios_base.ios_base_in = _pysimulavr.cvar.ios_base_ios_base_in
ios_base.out = _pysimulavr.cvar.ios_base_out
ios_base.trunc = _pysimulavr.cvar.ios_base_trunc
ios_base.beg = _pysimulavr.cvar.ios_base_beg
ios_base.cur = _pysimulavr.cvar.ios_base_cur
ios_base.end = _pysimulavr.cvar.ios_base_end

def ios_base_sync_with_stdio(__sync = True):
  return _pysimulavr.ios_base_sync_with_stdio(__sync)
ios_base_sync_with_stdio = _pysimulavr.ios_base_sync_with_stdio

def ios_base_xalloc():
  return _pysimulavr.ios_base_xalloc()
ios_base_xalloc = _pysimulavr.ios_base_xalloc

class ios(ios_base):
    __swig_setmethods__ = {}
    for _s in [ios_base]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios, name, value)
    __swig_getmethods__ = {}
    for _s in [ios_base]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ios, name)
    __repr__ = _swig_repr
    def rdstate(self): return _pysimulavr.ios_rdstate(self)
    def clear(self, *args): return _pysimulavr.ios_clear(self, *args)
    def setstate(self, *args): return _pysimulavr.ios_setstate(self, *args)
    def good(self): return _pysimulavr.ios_good(self)
    def eof(self): return _pysimulavr.ios_eof(self)
    def fail(self): return _pysimulavr.ios_fail(self)
    def bad(self): return _pysimulavr.ios_bad(self)
    def exceptions(self, *args): return _pysimulavr.ios_exceptions(self, *args)
    def __init__(self, *args): 
        this = _pysimulavr.new_ios(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_ios
    __del__ = lambda self : None;
    def tie(self, *args): return _pysimulavr.ios_tie(self, *args)
    def rdbuf(self, *args): return _pysimulavr.ios_rdbuf(self, *args)
    def copyfmt(self, *args): return _pysimulavr.ios_copyfmt(self, *args)
    def fill(self, *args): return _pysimulavr.ios_fill(self, *args)
    def imbue(self, *args): return _pysimulavr.ios_imbue(self, *args)
    def narrow(self, *args): return _pysimulavr.ios_narrow(self, *args)
    def widen(self, *args): return _pysimulavr.ios_widen(self, *args)
ios_swigregister = _pysimulavr.ios_swigregister
ios_swigregister(ios)

class string(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, string, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, string, name)
    __repr__ = _swig_repr
    def length(self): return _pysimulavr.string_length(self)
    def max_size(self): return _pysimulavr.string_max_size(self)
    def capacity(self): return _pysimulavr.string_capacity(self)
    def reserve(self, __res_arg = 0): return _pysimulavr.string_reserve(self, __res_arg)
    def copy(self, *args): return _pysimulavr.string_copy(self, *args)
    def c_str(self): return _pysimulavr.string_c_str(self)
    def find(self, *args): return _pysimulavr.string_find(self, *args)
    def rfind(self, *args): return _pysimulavr.string_rfind(self, *args)
    def find_first_of(self, *args): return _pysimulavr.string_find_first_of(self, *args)
    def find_last_of(self, *args): return _pysimulavr.string_find_last_of(self, *args)
    def find_first_not_of(self, *args): return _pysimulavr.string_find_first_not_of(self, *args)
    def find_last_not_of(self, *args): return _pysimulavr.string_find_last_not_of(self, *args)
    def substr(self, *args): return _pysimulavr.string_substr(self, *args)
    def empty(self): return _pysimulavr.string_empty(self)
    def size(self): return _pysimulavr.string_size(self)
    def swap(self, *args): return _pysimulavr.string_swap(self, *args)
    def get_allocator(self): return _pysimulavr.string_get_allocator(self)
    def begin(self): return _pysimulavr.string_begin(self)
    def end(self): return _pysimulavr.string_end(self)
    def rbegin(self): return _pysimulavr.string_rbegin(self)
    def rend(self): return _pysimulavr.string_rend(self)
    def erase(self, *args): return _pysimulavr.string_erase(self, *args)
    def __init__(self, *args): 
        this = _pysimulavr.new_string(*args)
        try: self.this.append(this)
        except: self.this = this
    def assign(self, *args): return _pysimulavr.string_assign(self, *args)
    def resize(self, *args): return _pysimulavr.string_resize(self, *args)
    def iterator(self): return _pysimulavr.string_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _pysimulavr.string___nonzero__(self)
    def __bool__(self): return _pysimulavr.string___bool__(self)
    def __len__(self): return _pysimulavr.string___len__(self)
    def __getslice__(self, *args): return _pysimulavr.string___getslice__(self, *args)
    def __setslice__(self, *args): return _pysimulavr.string___setslice__(self, *args)
    def __delslice__(self, *args): return _pysimulavr.string___delslice__(self, *args)
    def __delitem__(self, *args): return _pysimulavr.string___delitem__(self, *args)
    def __getitem__(self, *args): return _pysimulavr.string___getitem__(self, *args)
    def __setitem__(self, *args): return _pysimulavr.string___setitem__(self, *args)
    def insert(self, *args): return _pysimulavr.string_insert(self, *args)
    def replace(self, *args): return _pysimulavr.string_replace(self, *args)
    def __iadd__(self, *args): return _pysimulavr.string___iadd__(self, *args)
    def __add__(self, *args): return _pysimulavr.string___add__(self, *args)
    def __radd__(self, *args): return _pysimulavr.string___radd__(self, *args)
    def __str__(self): return _pysimulavr.string___str__(self)
    def __rlshift__(self, *args): return _pysimulavr.string___rlshift__(self, *args)
    def __eq__(self, *args): return _pysimulavr.string___eq__(self, *args)
    def __ne__(self, *args): return _pysimulavr.string___ne__(self, *args)
    def __gt__(self, *args): return _pysimulavr.string___gt__(self, *args)
    def __lt__(self, *args): return _pysimulavr.string___lt__(self, *args)
    def __ge__(self, *args): return _pysimulavr.string___ge__(self, *args)
    def __le__(self, *args): return _pysimulavr.string___le__(self, *args)
    __swig_destroy__ = _pysimulavr.delete_string
    __del__ = lambda self : None;
string_swigregister = _pysimulavr.string_swigregister
string_swigregister(string)
string.npos = _pysimulavr.cvar.string_npos

class ostream(ios):
    __swig_setmethods__ = {}
    for _s in [ios]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_ostream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_ostream
    __del__ = lambda self : None;
    def __lshift__(self, *args): return _pysimulavr.ostream___lshift__(self, *args)
    def put(self, *args): return _pysimulavr.ostream_put(self, *args)
    def write(self, *args): return _pysimulavr.ostream_write(self, *args)
    def flush(self): return _pysimulavr.ostream_flush(self)
    def tellp(self): return _pysimulavr.ostream_tellp(self)
    def seekp(self, *args): return _pysimulavr.ostream_seekp(self, *args)
ostream_swigregister = _pysimulavr.ostream_swigregister
ostream_swigregister(ostream)
cin = cvar.cin
cout = cvar.cout
cerr = cvar.cerr
clog = cvar.clog

class istream(ios):
    __swig_setmethods__ = {}
    for _s in [ios]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, istream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, istream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_istream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_istream
    __del__ = lambda self : None;
    def __rshift__(self, *args): return _pysimulavr.istream___rshift__(self, *args)
    def gcount(self): return _pysimulavr.istream_gcount(self)
    def get(self, *args): return _pysimulavr.istream_get(self, *args)
    def getline(self, *args): return _pysimulavr.istream_getline(self, *args)
    def ignore(self, *args): return _pysimulavr.istream_ignore(self, *args)
    def peek(self): return _pysimulavr.istream_peek(self)
    def read(self, *args): return _pysimulavr.istream_read(self, *args)
    def readsome(self, *args): return _pysimulavr.istream_readsome(self, *args)
    def putback(self, *args): return _pysimulavr.istream_putback(self, *args)
    def unget(self): return _pysimulavr.istream_unget(self)
    def sync(self): return _pysimulavr.istream_sync(self)
    def tellg(self): return _pysimulavr.istream_tellg(self)
    def seekg(self, *args): return _pysimulavr.istream_seekg(self, *args)
istream_swigregister = _pysimulavr.istream_swigregister
istream_swigregister(istream)

class iostream(istream,ostream):
    __swig_setmethods__ = {}
    for _s in [istream,ostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, iostream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream,ostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, iostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_iostream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_iostream
    __del__ = lambda self : None;
iostream_swigregister = _pysimulavr.iostream_swigregister
iostream_swigregister(iostream)

endl_cb_ptr = _pysimulavr.endl_cb_ptr

def endl(*args):
  return _pysimulavr.endl(*args)
endl = _pysimulavr.endl
ends_cb_ptr = _pysimulavr.ends_cb_ptr

def ends(*args):
  return _pysimulavr.ends(*args)
ends = _pysimulavr.ends
flush_cb_ptr = _pysimulavr.flush_cb_ptr

def flush(*args):
  return _pysimulavr.flush(*args)
flush = _pysimulavr.flush
class streambuf(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, streambuf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, streambuf, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pysimulavr.delete_streambuf
    __del__ = lambda self : None;
    def pubimbue(self, *args): return _pysimulavr.streambuf_pubimbue(self, *args)
    def getloc(self): return _pysimulavr.streambuf_getloc(self)
    def pubsetbuf(self, *args): return _pysimulavr.streambuf_pubsetbuf(self, *args)
    def pubseekoff(self, *args): return _pysimulavr.streambuf_pubseekoff(self, *args)
    def pubseekpos(self, *args): return _pysimulavr.streambuf_pubseekpos(self, *args)
    def pubsync(self): return _pysimulavr.streambuf_pubsync(self)
    def in_avail(self): return _pysimulavr.streambuf_in_avail(self)
    def snextc(self): return _pysimulavr.streambuf_snextc(self)
    def sbumpc(self): return _pysimulavr.streambuf_sbumpc(self)
    def sgetc(self): return _pysimulavr.streambuf_sgetc(self)
    def sgetn(self, *args): return _pysimulavr.streambuf_sgetn(self, *args)
    def sputbackc(self, *args): return _pysimulavr.streambuf_sputbackc(self, *args)
    def sungetc(self): return _pysimulavr.streambuf_sungetc(self)
    def sputc(self, *args): return _pysimulavr.streambuf_sputc(self, *args)
    def sputn(self, *args): return _pysimulavr.streambuf_sputn(self, *args)
streambuf_swigregister = _pysimulavr.streambuf_swigregister
streambuf_swigregister(streambuf)

class istringstream(istream):
    __swig_setmethods__ = {}
    for _s in [istream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, istringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, istringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_istringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_istringstream
    __del__ = lambda self : None;
    def rdbuf(self): return _pysimulavr.istringstream_rdbuf(self)
    def str(self, *args): return _pysimulavr.istringstream_str(self, *args)
istringstream_swigregister = _pysimulavr.istringstream_swigregister
istringstream_swigregister(istringstream)

class ostringstream(ostream):
    __swig_setmethods__ = {}
    for _s in [ostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [ostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ostringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_ostringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_ostringstream
    __del__ = lambda self : None;
    def rdbuf(self): return _pysimulavr.ostringstream_rdbuf(self)
    def str(self): return _pysimulavr.ostringstream_str(self)
ostringstream_swigregister = _pysimulavr.ostringstream_swigregister
ostringstream_swigregister(ostringstream)

class stringstream(iostream):
    __swig_setmethods__ = {}
    for _s in [iostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, stringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [iostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, stringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_stringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_stringstream
    __del__ = lambda self : None;
    def rdbuf(self): return _pysimulavr.stringstream_rdbuf(self)
    def str(self, *args): return _pysimulavr.stringstream_str(self, *args)
stringstream_swigregister = _pysimulavr.stringstream_swigregister
stringstream_swigregister(stringstream)

class DWordVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DWordVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DWordVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _pysimulavr.DWordVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _pysimulavr.DWordVector___nonzero__(self)
    def __bool__(self): return _pysimulavr.DWordVector___bool__(self)
    def __len__(self): return _pysimulavr.DWordVector___len__(self)
    def pop(self): return _pysimulavr.DWordVector_pop(self)
    def __getslice__(self, *args): return _pysimulavr.DWordVector___getslice__(self, *args)
    def __setslice__(self, *args): return _pysimulavr.DWordVector___setslice__(self, *args)
    def __delslice__(self, *args): return _pysimulavr.DWordVector___delslice__(self, *args)
    def __delitem__(self, *args): return _pysimulavr.DWordVector___delitem__(self, *args)
    def __getitem__(self, *args): return _pysimulavr.DWordVector___getitem__(self, *args)
    def __setitem__(self, *args): return _pysimulavr.DWordVector___setitem__(self, *args)
    def append(self, *args): return _pysimulavr.DWordVector_append(self, *args)
    def empty(self): return _pysimulavr.DWordVector_empty(self)
    def size(self): return _pysimulavr.DWordVector_size(self)
    def clear(self): return _pysimulavr.DWordVector_clear(self)
    def swap(self, *args): return _pysimulavr.DWordVector_swap(self, *args)
    def get_allocator(self): return _pysimulavr.DWordVector_get_allocator(self)
    def begin(self): return _pysimulavr.DWordVector_begin(self)
    def end(self): return _pysimulavr.DWordVector_end(self)
    def rbegin(self): return _pysimulavr.DWordVector_rbegin(self)
    def rend(self): return _pysimulavr.DWordVector_rend(self)
    def pop_back(self): return _pysimulavr.DWordVector_pop_back(self)
    def erase(self, *args): return _pysimulavr.DWordVector_erase(self, *args)
    def __init__(self, *args): 
        this = _pysimulavr.new_DWordVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _pysimulavr.DWordVector_push_back(self, *args)
    def front(self): return _pysimulavr.DWordVector_front(self)
    def back(self): return _pysimulavr.DWordVector_back(self)
    def assign(self, *args): return _pysimulavr.DWordVector_assign(self, *args)
    def resize(self, *args): return _pysimulavr.DWordVector_resize(self, *args)
    def insert(self, *args): return _pysimulavr.DWordVector_insert(self, *args)
    def reserve(self, *args): return _pysimulavr.DWordVector_reserve(self, *args)
    def capacity(self): return _pysimulavr.DWordVector_capacity(self)
    __swig_destroy__ = _pysimulavr.delete_DWordVector
    __del__ = lambda self : None;
DWordVector_swigregister = _pysimulavr.DWordVector_swigregister
DWordVector_swigregister(DWordVector)

class SimulationMember(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimulationMember, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SimulationMember, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def Step(self, *args): return _pysimulavr.SimulationMember_Step(self, *args)
    __swig_destroy__ = _pysimulavr.delete_SimulationMember
    __del__ = lambda self : None;
SimulationMember_swigregister = _pysimulavr.SimulationMember_swigregister
SimulationMember_swigregister(SimulationMember)

class PySimulationMember(SimulationMember):
    __swig_setmethods__ = {}
    for _s in [SimulationMember]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PySimulationMember, name, value)
    __swig_getmethods__ = {}
    for _s in [SimulationMember]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PySimulationMember, name)
    __repr__ = _swig_repr
    def Step(self, *args): return _pysimulavr.PySimulationMember_Step(self, *args)
    def DoStep(self, *args): return _pysimulavr.PySimulationMember_DoStep(self, *args)
    def __init__(self): 
        if self.__class__ == PySimulationMember:
            _self = None
        else:
            _self = self
        this = _pysimulavr.new_PySimulationMember(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_PySimulationMember
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _pysimulavr.disown_PySimulationMember(self)
        return weakref_proxy(self)
PySimulationMember_swigregister = _pysimulavr.PySimulationMember_swigregister
PySimulationMember_swigregister(PySimulationMember)

class ExternalType(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExternalType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExternalType, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def SetNewValueFromUi(self, *args): return _pysimulavr.ExternalType_SetNewValueFromUi(self, *args)
    __swig_destroy__ = _pysimulavr.delete_ExternalType
    __del__ = lambda self : None;
ExternalType_swigregister = _pysimulavr.ExternalType_swigregister
ExternalType_swigregister(ExternalType)

class HasPinNotifyFunction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HasPinNotifyFunction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HasPinNotifyFunction, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def PinStateHasChanged(self, *args): return _pysimulavr.HasPinNotifyFunction_PinStateHasChanged(self, *args)
    __swig_destroy__ = _pysimulavr.delete_HasPinNotifyFunction
    __del__ = lambda self : None;
HasPinNotifyFunction_swigregister = _pysimulavr.HasPinNotifyFunction_swigregister
HasPinNotifyFunction_swigregister(HasPinNotifyFunction)

class TraceValue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TraceValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TraceValue, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_TraceValue(*args)
        try: self.this.append(this)
        except: self.this = this
    def bits(self): return _pysimulavr.TraceValue_bits(self)
    def value(self): return _pysimulavr.TraceValue_value(self)
    def name(self): return _pysimulavr.TraceValue_name(self)
    def barename(self): return _pysimulavr.TraceValue_barename(self)
    def index(self): return _pysimulavr.TraceValue_index(self)
    READ = _pysimulavr.TraceValue_READ
    WRITE = _pysimulavr.TraceValue_WRITE
    CHANGE = _pysimulavr.TraceValue_CHANGE
    def enabled(self): return _pysimulavr.TraceValue_enabled(self)
    def enable(self): return _pysimulavr.TraceValue_enable(self)
    def change(self, *args): return _pysimulavr.TraceValue_change(self, *args)
    def write(self, *args): return _pysimulavr.TraceValue_write(self, *args)
    def read(self): return _pysimulavr.TraceValue_read(self)
    def written(self): return _pysimulavr.TraceValue_written(self)
    def set_written(self, *args): return _pysimulavr.TraceValue_set_written(self, *args)
    def flags(self): return _pysimulavr.TraceValue_flags(self)
    def cycle(self): return _pysimulavr.TraceValue_cycle(self)
    def dump(self, *args): return _pysimulavr.TraceValue_dump(self, *args)
    __swig_destroy__ = _pysimulavr.delete_TraceValue
    __del__ = lambda self : None;
TraceValue_swigregister = _pysimulavr.TraceValue_swigregister
TraceValue_swigregister(TraceValue)

class Dumper(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dumper, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Dumper, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def setActiveSignals(self, *args): return _pysimulavr.Dumper_setActiveSignals(self, *args)
    def start(self): return _pysimulavr.Dumper_start(self)
    def stop(self): return _pysimulavr.Dumper_stop(self)
    def cycle(self): return _pysimulavr.Dumper_cycle(self)
    def markRead(self, *args): return _pysimulavr.Dumper_markRead(self, *args)
    def markReadUnknown(self, *args): return _pysimulavr.Dumper_markReadUnknown(self, *args)
    def markWrite(self, *args): return _pysimulavr.Dumper_markWrite(self, *args)
    def markChange(self, *args): return _pysimulavr.Dumper_markChange(self, *args)
    __swig_destroy__ = _pysimulavr.delete_Dumper
    __del__ = lambda self : None;
    def enabled(self, *args): return _pysimulavr.Dumper_enabled(self, *args)
Dumper_swigregister = _pysimulavr.Dumper_swigregister
Dumper_swigregister(Dumper)

class WarnUnknown(Dumper):
    __swig_setmethods__ = {}
    for _s in [Dumper]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WarnUnknown, name, value)
    __swig_getmethods__ = {}
    for _s in [Dumper]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WarnUnknown, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_WarnUnknown(*args)
        try: self.this.append(this)
        except: self.this = this
    def markReadUnknown(self, *args): return _pysimulavr.WarnUnknown_markReadUnknown(self, *args)
    def enabled(self, *args): return _pysimulavr.WarnUnknown_enabled(self, *args)
    __swig_destroy__ = _pysimulavr.delete_WarnUnknown
    __del__ = lambda self : None;
WarnUnknown_swigregister = _pysimulavr.WarnUnknown_swigregister
WarnUnknown_swigregister(WarnUnknown)

class DumpVCD(Dumper):
    __swig_setmethods__ = {}
    for _s in [Dumper]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DumpVCD, name, value)
    __swig_getmethods__ = {}
    for _s in [Dumper]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DumpVCD, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_DumpVCD(*args)
        try: self.this.append(this)
        except: self.this = this
    def setActiveSignals(self, *args): return _pysimulavr.DumpVCD_setActiveSignals(self, *args)
    def start(self): return _pysimulavr.DumpVCD_start(self)
    def stop(self): return _pysimulavr.DumpVCD_stop(self)
    def cycle(self): return _pysimulavr.DumpVCD_cycle(self)
    def markRead(self, *args): return _pysimulavr.DumpVCD_markRead(self, *args)
    def markWrite(self, *args): return _pysimulavr.DumpVCD_markWrite(self, *args)
    def markChange(self, *args): return _pysimulavr.DumpVCD_markChange(self, *args)
    def enabled(self, *args): return _pysimulavr.DumpVCD_enabled(self, *args)
    __swig_destroy__ = _pysimulavr.delete_DumpVCD
    __del__ = lambda self : None;
DumpVCD_swigregister = _pysimulavr.DumpVCD_swigregister
DumpVCD_swigregister(DumpVCD)

class DumpManager(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DumpManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DumpManager, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["Instance"] = lambda x: _pysimulavr.DumpManager_Instance
    if _newclass:Instance = staticmethod(_pysimulavr.DumpManager_Instance)
    def SetSingleDeviceApp(self): return _pysimulavr.DumpManager_SetSingleDeviceApp(self)
    def addDumper(self, *args): return _pysimulavr.DumpManager_addDumper(self, *args)
    def start(self): return _pysimulavr.DumpManager_start(self)
    def stopApplication(self): return _pysimulavr.DumpManager_stopApplication(self)
    def cycle(self): return _pysimulavr.DumpManager_cycle(self)
    __swig_destroy__ = _pysimulavr.delete_DumpManager
    __del__ = lambda self : None;
    def save(self, *args): return _pysimulavr.DumpManager_save(self, *args)
    def load(self, *args): return _pysimulavr.DumpManager_load(self, *args)
    def all(self): return _pysimulavr.DumpManager_all(self)
    def addDumpVCD(self, *args): return _pysimulavr.DumpManager_addDumpVCD(self, *args)
DumpManager_swigregister = _pysimulavr.DumpManager_swigregister
DumpManager_swigregister(DumpManager)

def DumpManager_Instance():
  return _pysimulavr.DumpManager_Instance()
DumpManager_Instance = _pysimulavr.DumpManager_Instance

class TraceValueRegister(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TraceValueRegister, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TraceValueRegister, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_TraceValueRegister(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_TraceValueRegister
    __del__ = lambda self : None;
    def GetTraceValuePrefix(self): return _pysimulavr.TraceValueRegister_GetTraceValuePrefix(self)
    def GetScopeName(self): return _pysimulavr.TraceValueRegister_GetScopeName(self)
    def RegisterTraceValue(self, *args): return _pysimulavr.TraceValueRegister_RegisterTraceValue(self, *args)
    def UnregisterTraceValue(self, *args): return _pysimulavr.TraceValueRegister_UnregisterTraceValue(self, *args)
    def GetScopeGroupByName(self, *args): return _pysimulavr.TraceValueRegister_GetScopeGroupByName(self, *args)
    def GetTraceValueByName(self, *args): return _pysimulavr.TraceValueRegister_GetTraceValueByName(self, *args)
    def FindScopeGroupByName(self, *args): return _pysimulavr.TraceValueRegister_FindScopeGroupByName(self, *args)
    def FindTraceValueByName(self, *args): return _pysimulavr.TraceValueRegister_FindTraceValueByName(self, *args)
    def GetAllTraceValues(self): return _pysimulavr.TraceValueRegister_GetAllTraceValues(self)
    def GetAllTraceValuesRecursive(self): return _pysimulavr.TraceValueRegister_GetAllTraceValuesRecursive(self)
TraceValueRegister_swigregister = _pysimulavr.TraceValueRegister_swigregister
TraceValueRegister_swigregister(TraceValueRegister)

class TraceValueCoreRegister(TraceValueRegister):
    __swig_setmethods__ = {}
    for _s in [TraceValueRegister]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TraceValueCoreRegister, name, value)
    __swig_getmethods__ = {}
    for _s in [TraceValueRegister]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TraceValueCoreRegister, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_TraceValueCoreRegister(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_TraceValueCoreRegister
    __del__ = lambda self : None;
    def RegisterTraceSetValue(self, *args): return _pysimulavr.TraceValueCoreRegister_RegisterTraceSetValue(self, *args)
    def GetTraceValueByName(self, *args): return _pysimulavr.TraceValueCoreRegister_GetTraceValueByName(self, *args)
TraceValueCoreRegister_swigregister = _pysimulavr.TraceValueCoreRegister_swigregister
TraceValueCoreRegister_swigregister(TraceValueCoreRegister)

class HWIrqSystem(TraceValueRegister):
    __swig_setmethods__ = {}
    for _s in [TraceValueRegister]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HWIrqSystem, name, value)
    __swig_getmethods__ = {}
    for _s in [TraceValueRegister]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HWIrqSystem, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_HWIrqSystem(*args)
        try: self.this.append(this)
        except: self.this = this
    def GetNewPc(self, *args): return _pysimulavr.HWIrqSystem_GetNewPc(self, *args)
    def SetIrqFlag(self, *args): return _pysimulavr.HWIrqSystem_SetIrqFlag(self, *args)
    def ClearIrqFlag(self, *args): return _pysimulavr.HWIrqSystem_ClearIrqFlag(self, *args)
    def IrqHandlerStarted(self, *args): return _pysimulavr.HWIrqSystem_IrqHandlerStarted(self, *args)
    def IrqHandlerFinished(self, *args): return _pysimulavr.HWIrqSystem_IrqHandlerFinished(self, *args)
    def DebugVerifyInterruptVector(self, *args): return _pysimulavr.HWIrqSystem_DebugVerifyInterruptVector(self, *args)
    def DebugDumpTable(self): return _pysimulavr.HWIrqSystem_DebugDumpTable(self)
    __swig_destroy__ = _pysimulavr.delete_HWIrqSystem
    __del__ = lambda self : None;
HWIrqSystem_swigregister = _pysimulavr.HWIrqSystem_swigregister
HWIrqSystem_swigregister(HWIrqSystem)

def trace_direct(*args):
  return _pysimulavr.trace_direct(*args)
trace_direct = _pysimulavr.trace_direct

class AvrDevice(SimulationMember,TraceValueRegister):
    __swig_setmethods__ = {}
    for _s in [SimulationMember,TraceValueRegister]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [SimulationMember,TraceValueRegister]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice, name)
    __repr__ = _swig_repr
    __swig_setmethods__["trace_on"] = _pysimulavr.AvrDevice_trace_on_set
    __swig_getmethods__["trace_on"] = _pysimulavr.AvrDevice_trace_on_get
    if _newclass:trace_on = _swig_property(_pysimulavr.AvrDevice_trace_on_get, _pysimulavr.AvrDevice_trace_on_set)
    __swig_setmethods__["BP"] = _pysimulavr.AvrDevice_BP_set
    __swig_getmethods__["BP"] = _pysimulavr.AvrDevice_BP_get
    if _newclass:BP = _swig_property(_pysimulavr.AvrDevice_BP_get, _pysimulavr.AvrDevice_BP_set)
    __swig_setmethods__["EP"] = _pysimulavr.AvrDevice_EP_set
    __swig_getmethods__["EP"] = _pysimulavr.AvrDevice_EP_get
    if _newclass:EP = _swig_property(_pysimulavr.AvrDevice_EP_get, _pysimulavr.AvrDevice_EP_set)
    __swig_setmethods__["PC"] = _pysimulavr.AvrDevice_PC_set
    __swig_getmethods__["PC"] = _pysimulavr.AvrDevice_PC_get
    if _newclass:PC = _swig_property(_pysimulavr.AvrDevice_PC_get, _pysimulavr.AvrDevice_PC_set)
    __swig_setmethods__["cPC"] = _pysimulavr.AvrDevice_cPC_set
    __swig_getmethods__["cPC"] = _pysimulavr.AvrDevice_cPC_get
    if _newclass:cPC = _swig_property(_pysimulavr.AvrDevice_cPC_get, _pysimulavr.AvrDevice_cPC_set)
    __swig_setmethods__["PC_size"] = _pysimulavr.AvrDevice_PC_size_set
    __swig_getmethods__["PC_size"] = _pysimulavr.AvrDevice_PC_size_get
    if _newclass:PC_size = _swig_property(_pysimulavr.AvrDevice_PC_size_get, _pysimulavr.AvrDevice_PC_size_set)
    __swig_setmethods__["Flash"] = _pysimulavr.AvrDevice_Flash_set
    __swig_getmethods__["Flash"] = _pysimulavr.AvrDevice_Flash_get
    if _newclass:Flash = _swig_property(_pysimulavr.AvrDevice_Flash_get, _pysimulavr.AvrDevice_Flash_set)
    __swig_setmethods__["spmRegister"] = _pysimulavr.AvrDevice_spmRegister_set
    __swig_getmethods__["spmRegister"] = _pysimulavr.AvrDevice_spmRegister_get
    if _newclass:spmRegister = _swig_property(_pysimulavr.AvrDevice_spmRegister_get, _pysimulavr.AvrDevice_spmRegister_set)
    __swig_setmethods__["eeprom"] = _pysimulavr.AvrDevice_eeprom_set
    __swig_getmethods__["eeprom"] = _pysimulavr.AvrDevice_eeprom_get
    if _newclass:eeprom = _swig_property(_pysimulavr.AvrDevice_eeprom_get, _pysimulavr.AvrDevice_eeprom_set)
    __swig_setmethods__["data"] = _pysimulavr.AvrDevice_data_set
    __swig_getmethods__["data"] = _pysimulavr.AvrDevice_data_get
    if _newclass:data = _swig_property(_pysimulavr.AvrDevice_data_get, _pysimulavr.AvrDevice_data_set)
    __swig_setmethods__["irqSystem"] = _pysimulavr.AvrDevice_irqSystem_set
    __swig_getmethods__["irqSystem"] = _pysimulavr.AvrDevice_irqSystem_get
    if _newclass:irqSystem = _swig_property(_pysimulavr.AvrDevice_irqSystem_get, _pysimulavr.AvrDevice_irqSystem_set)
    __swig_setmethods__["rampz"] = _pysimulavr.AvrDevice_rampz_set
    __swig_getmethods__["rampz"] = _pysimulavr.AvrDevice_rampz_get
    if _newclass:rampz = _swig_property(_pysimulavr.AvrDevice_rampz_get, _pysimulavr.AvrDevice_rampz_set)
    __swig_setmethods__["eind"] = _pysimulavr.AvrDevice_eind_set
    __swig_getmethods__["eind"] = _pysimulavr.AvrDevice_eind_get
    if _newclass:eind = _swig_property(_pysimulavr.AvrDevice_eind_get, _pysimulavr.AvrDevice_eind_set)
    __swig_setmethods__["abortOnInvalidAccess"] = _pysimulavr.AvrDevice_abortOnInvalidAccess_set
    __swig_getmethods__["abortOnInvalidAccess"] = _pysimulavr.AvrDevice_abortOnInvalidAccess_get
    if _newclass:abortOnInvalidAccess = _swig_property(_pysimulavr.AvrDevice_abortOnInvalidAccess_get, _pysimulavr.AvrDevice_abortOnInvalidAccess_set)
    __swig_setmethods__["coreTraceGroup"] = _pysimulavr.AvrDevice_coreTraceGroup_set
    __swig_getmethods__["coreTraceGroup"] = _pysimulavr.AvrDevice_coreTraceGroup_get
    if _newclass:coreTraceGroup = _swig_property(_pysimulavr.AvrDevice_coreTraceGroup_get, _pysimulavr.AvrDevice_coreTraceGroup_set)
    __swig_setmethods__["instructionSEIJustEnabledInterrupts"] = _pysimulavr.AvrDevice_instructionSEIJustEnabledInterrupts_set
    __swig_getmethods__["instructionSEIJustEnabledInterrupts"] = _pysimulavr.AvrDevice_instructionSEIJustEnabledInterrupts_get
    if _newclass:instructionSEIJustEnabledInterrupts = _swig_property(_pysimulavr.AvrDevice_instructionSEIJustEnabledInterrupts_get, _pysimulavr.AvrDevice_instructionSEIJustEnabledInterrupts_set)
    __swig_setmethods__["flagIWInstructions"] = _pysimulavr.AvrDevice_flagIWInstructions_set
    __swig_getmethods__["flagIWInstructions"] = _pysimulavr.AvrDevice_flagIWInstructions_get
    if _newclass:flagIWInstructions = _swig_property(_pysimulavr.AvrDevice_flagIWInstructions_get, _pysimulavr.AvrDevice_flagIWInstructions_set)
    __swig_setmethods__["flagJMPInstructions"] = _pysimulavr.AvrDevice_flagJMPInstructions_set
    __swig_getmethods__["flagJMPInstructions"] = _pysimulavr.AvrDevice_flagJMPInstructions_get
    if _newclass:flagJMPInstructions = _swig_property(_pysimulavr.AvrDevice_flagJMPInstructions_get, _pysimulavr.AvrDevice_flagJMPInstructions_set)
    __swig_setmethods__["flagIJMPInstructions"] = _pysimulavr.AvrDevice_flagIJMPInstructions_set
    __swig_getmethods__["flagIJMPInstructions"] = _pysimulavr.AvrDevice_flagIJMPInstructions_get
    if _newclass:flagIJMPInstructions = _swig_property(_pysimulavr.AvrDevice_flagIJMPInstructions_get, _pysimulavr.AvrDevice_flagIJMPInstructions_set)
    __swig_setmethods__["flagEIJMPInstructions"] = _pysimulavr.AvrDevice_flagEIJMPInstructions_set
    __swig_getmethods__["flagEIJMPInstructions"] = _pysimulavr.AvrDevice_flagEIJMPInstructions_get
    if _newclass:flagEIJMPInstructions = _swig_property(_pysimulavr.AvrDevice_flagEIJMPInstructions_get, _pysimulavr.AvrDevice_flagEIJMPInstructions_set)
    __swig_setmethods__["flagLPMInstructions"] = _pysimulavr.AvrDevice_flagLPMInstructions_set
    __swig_getmethods__["flagLPMInstructions"] = _pysimulavr.AvrDevice_flagLPMInstructions_get
    if _newclass:flagLPMInstructions = _swig_property(_pysimulavr.AvrDevice_flagLPMInstructions_get, _pysimulavr.AvrDevice_flagLPMInstructions_set)
    __swig_setmethods__["flagELPMInstructions"] = _pysimulavr.AvrDevice_flagELPMInstructions_set
    __swig_getmethods__["flagELPMInstructions"] = _pysimulavr.AvrDevice_flagELPMInstructions_get
    if _newclass:flagELPMInstructions = _swig_property(_pysimulavr.AvrDevice_flagELPMInstructions_get, _pysimulavr.AvrDevice_flagELPMInstructions_set)
    __swig_setmethods__["flagMULInstructions"] = _pysimulavr.AvrDevice_flagMULInstructions_set
    __swig_getmethods__["flagMULInstructions"] = _pysimulavr.AvrDevice_flagMULInstructions_get
    if _newclass:flagMULInstructions = _swig_property(_pysimulavr.AvrDevice_flagMULInstructions_get, _pysimulavr.AvrDevice_flagMULInstructions_set)
    __swig_setmethods__["flagMOVWInstruction"] = _pysimulavr.AvrDevice_flagMOVWInstruction_set
    __swig_getmethods__["flagMOVWInstruction"] = _pysimulavr.AvrDevice_flagMOVWInstruction_get
    if _newclass:flagMOVWInstruction = _swig_property(_pysimulavr.AvrDevice_flagMOVWInstruction_get, _pysimulavr.AvrDevice_flagMOVWInstruction_set)
    __swig_setmethods__["flagTiny10"] = _pysimulavr.AvrDevice_flagTiny10_set
    __swig_getmethods__["flagTiny10"] = _pysimulavr.AvrDevice_flagTiny10_get
    if _newclass:flagTiny10 = _swig_property(_pysimulavr.AvrDevice_flagTiny10_get, _pysimulavr.AvrDevice_flagTiny10_set)
    __swig_setmethods__["flagTiny1x"] = _pysimulavr.AvrDevice_flagTiny1x_set
    __swig_getmethods__["flagTiny1x"] = _pysimulavr.AvrDevice_flagTiny1x_get
    if _newclass:flagTiny1x = _swig_property(_pysimulavr.AvrDevice_flagTiny1x_get, _pysimulavr.AvrDevice_flagTiny1x_set)
    __swig_setmethods__["flagXMega"] = _pysimulavr.AvrDevice_flagXMega_set
    __swig_getmethods__["flagXMega"] = _pysimulavr.AvrDevice_flagXMega_get
    if _newclass:flagXMega = _swig_property(_pysimulavr.AvrDevice_flagXMega_get, _pysimulavr.AvrDevice_flagXMega_set)
    __swig_setmethods__["DebugRecentJumps"] = _pysimulavr.AvrDevice_DebugRecentJumps_set
    __swig_getmethods__["DebugRecentJumps"] = _pysimulavr.AvrDevice_DebugRecentJumps_get
    if _newclass:DebugRecentJumps = _swig_property(_pysimulavr.AvrDevice_DebugRecentJumps_get, _pysimulavr.AvrDevice_DebugRecentJumps_set)
    __swig_setmethods__["DebugRecentJumpsIndex"] = _pysimulavr.AvrDevice_DebugRecentJumpsIndex_set
    __swig_getmethods__["DebugRecentJumpsIndex"] = _pysimulavr.AvrDevice_DebugRecentJumpsIndex_get
    if _newclass:DebugRecentJumpsIndex = _swig_property(_pysimulavr.AvrDevice_DebugRecentJumpsIndex_get, _pysimulavr.AvrDevice_DebugRecentJumpsIndex_set)
    __swig_setmethods__["rw"] = _pysimulavr.AvrDevice_rw_set
    __swig_getmethods__["rw"] = _pysimulavr.AvrDevice_rw_get
    if _newclass:rw = _swig_property(_pysimulavr.AvrDevice_rw_get, _pysimulavr.AvrDevice_rw_set)
    __swig_setmethods__["stack"] = _pysimulavr.AvrDevice_stack_set
    __swig_getmethods__["stack"] = _pysimulavr.AvrDevice_stack_get
    if _newclass:stack = _swig_property(_pysimulavr.AvrDevice_stack_get, _pysimulavr.AvrDevice_stack_set)
    __swig_setmethods__["status"] = _pysimulavr.AvrDevice_status_set
    __swig_getmethods__["status"] = _pysimulavr.AvrDevice_status_get
    if _newclass:status = _swig_property(_pysimulavr.AvrDevice_status_get, _pysimulavr.AvrDevice_status_set)
    __swig_setmethods__["statusRegister"] = _pysimulavr.AvrDevice_statusRegister_set
    __swig_getmethods__["statusRegister"] = _pysimulavr.AvrDevice_statusRegister_get
    if _newclass:statusRegister = _swig_property(_pysimulavr.AvrDevice_statusRegister_get, _pysimulavr.AvrDevice_statusRegister_set)
    __swig_setmethods__["wado"] = _pysimulavr.AvrDevice_wado_set
    __swig_getmethods__["wado"] = _pysimulavr.AvrDevice_wado_get
    if _newclass:wado = _swig_property(_pysimulavr.AvrDevice_wado_get, _pysimulavr.AvrDevice_wado_set)
    __swig_setmethods__["hwResetList"] = _pysimulavr.AvrDevice_hwResetList_set
    __swig_getmethods__["hwResetList"] = _pysimulavr.AvrDevice_hwResetList_get
    if _newclass:hwResetList = _swig_property(_pysimulavr.AvrDevice_hwResetList_get, _pysimulavr.AvrDevice_hwResetList_set)
    __swig_setmethods__["hwCycleList"] = _pysimulavr.AvrDevice_hwCycleList_set
    __swig_getmethods__["hwCycleList"] = _pysimulavr.AvrDevice_hwCycleList_get
    if _newclass:hwCycleList = _swig_property(_pysimulavr.AvrDevice_hwCycleList_get, _pysimulavr.AvrDevice_hwCycleList_set)
    __swig_setmethods__["dump_manager"] = _pysimulavr.AvrDevice_dump_manager_set
    __swig_getmethods__["dump_manager"] = _pysimulavr.AvrDevice_dump_manager_get
    if _newclass:dump_manager = _swig_property(_pysimulavr.AvrDevice_dump_manager_get, _pysimulavr.AvrDevice_dump_manager_set)
    def __init__(self, *args): 
        this = _pysimulavr.new_AvrDevice(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice
    __del__ = lambda self : None;
    def AddToResetList(self, *args): return _pysimulavr.AvrDevice_AddToResetList(self, *args)
    def AddToCycleList(self, *args): return _pysimulavr.AvrDevice_AddToCycleList(self, *args)
    def RemoveFromCycleList(self, *args): return _pysimulavr.AvrDevice_RemoveFromCycleList(self, *args)
    def Load(self, *args): return _pysimulavr.AvrDevice_Load(self, *args)
    def ReplaceIoRegister(self, *args): return _pysimulavr.AvrDevice_ReplaceIoRegister(self, *args)
    def ReplaceMemRegister(self, *args): return _pysimulavr.AvrDevice_ReplaceMemRegister(self, *args)
    def GetMemRegisterInstance(self, *args): return _pysimulavr.AvrDevice_GetMemRegisterInstance(self, *args)
    def RegisterTerminationSymbol(self, *args): return _pysimulavr.AvrDevice_RegisterTerminationSymbol(self, *args)
    def GetPin(self, *args): return _pysimulavr.AvrDevice_GetPin(self, *args)
    def Step(self, *args): return _pysimulavr.AvrDevice_Step(self, *args)
    def Reset(self): return _pysimulavr.AvrDevice_Reset(self)
    def SetClockFreq(self, *args): return _pysimulavr.AvrDevice_SetClockFreq(self, *args)
    def GetClockFreq(self): return _pysimulavr.AvrDevice_GetClockFreq(self)
    def RegisterPin(self, *args): return _pysimulavr.AvrDevice_RegisterPin(self, *args)
    def DeleteAllBreakpoints(self): return _pysimulavr.AvrDevice_DeleteAllBreakpoints(self)
    def GetFname(self): return _pysimulavr.AvrDevice_GetFname(self)
    def GetMemTotalSize(self): return _pysimulavr.AvrDevice_GetMemTotalSize(self)
    def GetMemIOSize(self): return _pysimulavr.AvrDevice_GetMemIOSize(self)
    def GetMemRegisterSize(self): return _pysimulavr.AvrDevice_GetMemRegisterSize(self)
    def GetMemIRamSize(self): return _pysimulavr.AvrDevice_GetMemIRamSize(self)
    def GetMemERamSize(self): return _pysimulavr.AvrDevice_GetMemERamSize(self)
    def GetRWMem(self, *args): return _pysimulavr.AvrDevice_GetRWMem(self, *args)
    def SetRWMem(self, *args): return _pysimulavr.AvrDevice_SetRWMem(self, *args)
    def GetCoreReg(self, *args): return _pysimulavr.AvrDevice_GetCoreReg(self, *args)
    def SetCoreReg(self, *args): return _pysimulavr.AvrDevice_SetCoreReg(self, *args)
    def GetIOReg(self, *args): return _pysimulavr.AvrDevice_GetIOReg(self, *args)
    def SetIOReg(self, *args): return _pysimulavr.AvrDevice_SetIOReg(self, *args)
    def SetIORegBit(self, *args): return _pysimulavr.AvrDevice_SetIORegBit(self, *args)
    def GetRegX(self): return _pysimulavr.AvrDevice_GetRegX(self)
    def GetRegY(self): return _pysimulavr.AvrDevice_GetRegY(self)
    def GetRegZ(self): return _pysimulavr.AvrDevice_GetRegZ(self)
    def DebugOnJump(self): return _pysimulavr.AvrDevice_DebugOnJump(self)
    def getRWMem(self, *args): return _pysimulavr.AvrDevice_getRWMem(self, *args)
    def setRWMem(self, *args): return _pysimulavr.AvrDevice_setRWMem(self, *args)
AvrDevice_swigregister = _pysimulavr.AvrDevice_swigregister
AvrDevice_swigregister(AvrDevice)

class SystemClock(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SystemClock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SystemClock, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def GetCurrentTime(self): return _pysimulavr.SystemClock_GetCurrentTime(self)
    def SetCurrentTime(self, *args): return _pysimulavr.SystemClock_SetCurrentTime(self, *args)
    def IncrTime(self, *args): return _pysimulavr.SystemClock_IncrTime(self, *args)
    def Add(self, *args): return _pysimulavr.SystemClock_Add(self, *args)
    def AddAsyncMember(self, *args): return _pysimulavr.SystemClock_AddAsyncMember(self, *args)
    def Endless(self): return _pysimulavr.SystemClock_Endless(self)
    def Run(self, *args): return _pysimulavr.SystemClock_Run(self, *args)
    def RunTimeRange(self, *args): return _pysimulavr.SystemClock_RunTimeRange(self, *args)
    __swig_getmethods__["Instance"] = lambda x: _pysimulavr.SystemClock_Instance
    if _newclass:Instance = staticmethod(_pysimulavr.SystemClock_Instance)
    def Rescedule(self, *args): return _pysimulavr.SystemClock_Rescedule(self, *args)
    def SetTraceModeForAllMembers(self, *args): return _pysimulavr.SystemClock_SetTraceModeForAllMembers(self, *args)
    def stop(self): return _pysimulavr.SystemClock_stop(self)
    def ResetClock(self): return _pysimulavr.SystemClock_ResetClock(self)
    def Step(self, *args): return _pysimulavr.SystemClock_Step(self, *args)
    __swig_destroy__ = _pysimulavr.delete_SystemClock
    __del__ = lambda self : None;
SystemClock_swigregister = _pysimulavr.SystemClock_swigregister
SystemClock_swigregister(SystemClock)

def SystemClock_Instance():
  return _pysimulavr.SystemClock_Instance()
SystemClock_Instance = _pysimulavr.SystemClock_Instance

class Hardware(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hardware, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hardware, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        if self.__class__ == Hardware:
            _self = None
        else:
            _self = self
        this = _pysimulavr.new_Hardware(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_Hardware
    __del__ = lambda self : None;
    def CpuCycle(self): return _pysimulavr.Hardware_CpuCycle(self)
    def Reset(self): return _pysimulavr.Hardware_Reset(self)
    def ClearIrqFlag(self, *args): return _pysimulavr.Hardware_ClearIrqFlag(self, *args)
    def IsLevelInterrupt(self, *args): return _pysimulavr.Hardware_IsLevelInterrupt(self, *args)
    def LevelInterruptPending(self, *args): return _pysimulavr.Hardware_LevelInterruptPending(self, *args)
    def __disown__(self):
        self.this.disown()
        _pysimulavr.disown_Hardware(self)
        return weakref_proxy(self)
Hardware_swigregister = _pysimulavr.Hardware_swigregister
Hardware_swigregister(Hardware)

class HWPort(Hardware,TraceValueRegister):
    __swig_setmethods__ = {}
    for _s in [Hardware,TraceValueRegister]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HWPort, name, value)
    __swig_getmethods__ = {}
    for _s in [Hardware,TraceValueRegister]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HWPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_HWPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_HWPort
    __del__ = lambda self : None;
    def CalcOutputs(self): return _pysimulavr.HWPort_CalcOutputs(self)
    def GetPortString(self): return _pysimulavr.HWPort_GetPortString(self)
    def Reset(self): return _pysimulavr.HWPort_Reset(self)
    def GetName(self): return _pysimulavr.HWPort_GetName(self)
    def GetPortSize(self): return _pysimulavr.HWPort_GetPortSize(self)
    def SetPort(self, *args): return _pysimulavr.HWPort_SetPort(self, *args)
    def SetDdr(self, *args): return _pysimulavr.HWPort_SetDdr(self, *args)
    def SetPin(self, *args): return _pysimulavr.HWPort_SetPin(self, *args)
    def GetPort(self): return _pysimulavr.HWPort_GetPort(self)
    def GetDdr(self): return _pysimulavr.HWPort_GetDdr(self)
    def GetPin(self, *args): return _pysimulavr.HWPort_GetPin(self, *args)
    __swig_setmethods__["port_reg"] = _pysimulavr.HWPort_port_reg_set
    __swig_getmethods__["port_reg"] = _pysimulavr.HWPort_port_reg_get
    if _newclass:port_reg = _swig_property(_pysimulavr.HWPort_port_reg_get, _pysimulavr.HWPort_port_reg_set)
    __swig_setmethods__["pin_reg"] = _pysimulavr.HWPort_pin_reg_set
    __swig_getmethods__["pin_reg"] = _pysimulavr.HWPort_pin_reg_get
    if _newclass:pin_reg = _swig_property(_pysimulavr.HWPort_pin_reg_get, _pysimulavr.HWPort_pin_reg_set)
    __swig_setmethods__["ddr_reg"] = _pysimulavr.HWPort_ddr_reg_set
    __swig_getmethods__["ddr_reg"] = _pysimulavr.HWPort_ddr_reg_get
    if _newclass:ddr_reg = _swig_property(_pysimulavr.HWPort_ddr_reg_get, _pysimulavr.HWPort_ddr_reg_set)
HWPort_swigregister = _pysimulavr.HWPort_swigregister
HWPort_swigregister(HWPort)

class Thread(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Thread, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Thread, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m_sp"] = _pysimulavr.Thread_m_sp_set
    __swig_getmethods__["m_sp"] = _pysimulavr.Thread_m_sp_get
    if _newclass:m_sp = _swig_property(_pysimulavr.Thread_m_sp_get, _pysimulavr.Thread_m_sp_set)
    __swig_setmethods__["m_ip"] = _pysimulavr.Thread_m_ip_set
    __swig_getmethods__["m_ip"] = _pysimulavr.Thread_m_ip_get
    if _newclass:m_ip = _swig_property(_pysimulavr.Thread_m_ip_get, _pysimulavr.Thread_m_ip_set)
    __swig_setmethods__["m_alive"] = _pysimulavr.Thread_m_alive_set
    __swig_getmethods__["m_alive"] = _pysimulavr.Thread_m_alive_get
    if _newclass:m_alive = _swig_property(_pysimulavr.Thread_m_alive_get, _pysimulavr.Thread_m_alive_set)
    __swig_setmethods__["registers"] = _pysimulavr.Thread_registers_set
    __swig_getmethods__["registers"] = _pysimulavr.Thread_registers_get
    if _newclass:registers = _swig_property(_pysimulavr.Thread_registers_get, _pysimulavr.Thread_registers_set)
    __swig_setmethods__["m_created_by_thread"] = _pysimulavr.Thread_m_created_by_thread_set
    __swig_getmethods__["m_created_by_thread"] = _pysimulavr.Thread_m_created_by_thread_get
    if _newclass:m_created_by_thread = _swig_property(_pysimulavr.Thread_m_created_by_thread_get, _pysimulavr.Thread_m_created_by_thread_set)
    def __init__(self): 
        this = _pysimulavr.new_Thread()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_Thread
    __del__ = lambda self : None;
Thread_swigregister = _pysimulavr.Thread_swigregister
Thread_swigregister(Thread)

class ThreadList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadList, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_ThreadList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_ThreadList
    __del__ = lambda self : None;
    def OnReset(self): return _pysimulavr.ThreadList_OnReset(self)
    def OnCall(self): return _pysimulavr.ThreadList_OnCall(self)
    def OnSPRead(self, *args): return _pysimulavr.ThreadList_OnSPRead(self, *args)
    def OnSPWrite(self, *args): return _pysimulavr.ThreadList_OnSPWrite(self, *args)
    def OnPush(self): return _pysimulavr.ThreadList_OnPush(self)
    def OnPop(self): return _pysimulavr.ThreadList_OnPop(self)
    def GetThreadBySP(self, *args): return _pysimulavr.ThreadList_GetThreadBySP(self, *args)
    def GetCurrentThreadForGDB(self): return _pysimulavr.ThreadList_GetCurrentThreadForGDB(self)
    def GetThreadFromGDB(self, *args): return _pysimulavr.ThreadList_GetThreadFromGDB(self, *args)
    def IsGDBThreadAlive(self, *args): return _pysimulavr.ThreadList_IsGDBThreadAlive(self, *args)
    def GetCount(self): return _pysimulavr.ThreadList_GetCount(self)
ThreadList_swigregister = _pysimulavr.ThreadList_swigregister
ThreadList_swigregister(ThreadList)

class HWStack(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HWStack, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HWStack, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_getmethods__["m_ThreadList"] = _pysimulavr.HWStack_m_ThreadList_get
    if _newclass:m_ThreadList = _swig_property(_pysimulavr.HWStack_m_ThreadList_get)
    __swig_destroy__ = _pysimulavr.delete_HWStack
    __del__ = lambda self : None;
    def Push(self, *args): return _pysimulavr.HWStack_Push(self, *args)
    def Pop(self): return _pysimulavr.HWStack_Pop(self)
    def PushAddr(self, *args): return _pysimulavr.HWStack_PushAddr(self, *args)
    def PopAddr(self): return _pysimulavr.HWStack_PopAddr(self)
    def Reset(self): return _pysimulavr.HWStack_Reset(self)
    def GetStackPointer(self): return _pysimulavr.HWStack_GetStackPointer(self)
    def SetStackPointer(self, *args): return _pysimulavr.HWStack_SetStackPointer(self, *args)
    def SetReturnPoint(self, *args): return _pysimulavr.HWStack_SetReturnPoint(self, *args)
    def ResetLowestStackpointer(self): return _pysimulavr.HWStack_ResetLowestStackpointer(self)
    def GetLowestStackpointer(self): return _pysimulavr.HWStack_GetLowestStackpointer(self)
HWStack_swigregister = _pysimulavr.HWStack_swigregister
HWStack_swigregister(HWStack)

class HWStackSram(HWStack,TraceValueRegister):
    __swig_setmethods__ = {}
    for _s in [HWStack,TraceValueRegister]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HWStackSram, name, value)
    __swig_getmethods__ = {}
    for _s in [HWStack,TraceValueRegister]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HWStackSram, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_HWStackSram(*args)
        try: self.this.append(this)
        except: self.this = this
    def Push(self, *args): return _pysimulavr.HWStackSram_Push(self, *args)
    def Pop(self): return _pysimulavr.HWStackSram_Pop(self)
    def PushAddr(self, *args): return _pysimulavr.HWStackSram_PushAddr(self, *args)
    def PopAddr(self): return _pysimulavr.HWStackSram_PopAddr(self)
    def Reset(self): return _pysimulavr.HWStackSram_Reset(self)
    __swig_setmethods__["sph_reg"] = _pysimulavr.HWStackSram_sph_reg_set
    __swig_getmethods__["sph_reg"] = _pysimulavr.HWStackSram_sph_reg_get
    if _newclass:sph_reg = _swig_property(_pysimulavr.HWStackSram_sph_reg_get, _pysimulavr.HWStackSram_sph_reg_set)
    __swig_setmethods__["spl_reg"] = _pysimulavr.HWStackSram_spl_reg_set
    __swig_getmethods__["spl_reg"] = _pysimulavr.HWStackSram_spl_reg_get
    if _newclass:spl_reg = _swig_property(_pysimulavr.HWStackSram_spl_reg_get, _pysimulavr.HWStackSram_spl_reg_set)
    __swig_destroy__ = _pysimulavr.delete_HWStackSram
    __del__ = lambda self : None;
HWStackSram_swigregister = _pysimulavr.HWStackSram_swigregister
HWStackSram_swigregister(HWStackSram)

class ThreeLevelStack(HWStack,TraceValueRegister):
    __swig_setmethods__ = {}
    for _s in [HWStack,TraceValueRegister]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreeLevelStack, name, value)
    __swig_getmethods__ = {}
    for _s in [HWStack,TraceValueRegister]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ThreeLevelStack, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_ThreeLevelStack(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_ThreeLevelStack
    __del__ = lambda self : None;
    def Push(self, *args): return _pysimulavr.ThreeLevelStack_Push(self, *args)
    def Pop(self): return _pysimulavr.ThreeLevelStack_Pop(self)
    def PushAddr(self, *args): return _pysimulavr.ThreeLevelStack_PushAddr(self, *args)
    def PopAddr(self): return _pysimulavr.ThreeLevelStack_PopAddr(self)
    def Reset(self): return _pysimulavr.ThreeLevelStack_Reset(self)
ThreeLevelStack_swigregister = _pysimulavr.ThreeLevelStack_swigregister
ThreeLevelStack_swigregister(ThreeLevelStack)

DISABLE_OPENDRAIN = _pysimulavr.DISABLE_OPENDRAIN
class Pin(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Pin, name)
    __repr__ = _swig_repr
    LOW = _pysimulavr.Pin_LOW
    HIGH = _pysimulavr.Pin_HIGH
    SHORTED = _pysimulavr.Pin_SHORTED
    PULLUP = _pysimulavr.Pin_PULLUP
    TRISTATE = _pysimulavr.Pin_TRISTATE
    PULLDOWN = _pysimulavr.Pin_PULLDOWN
    ANALOG = _pysimulavr.Pin_ANALOG
    ANALOG_SHORTED = _pysimulavr.Pin_ANALOG_SHORTED
    __swig_setmethods__["outState"] = _pysimulavr.Pin_outState_set
    __swig_getmethods__["outState"] = _pysimulavr.Pin_outState_get
    if _newclass:outState = _swig_property(_pysimulavr.Pin_outState_get, _pysimulavr.Pin_outState_set)
    __swig_setmethods__["notifyList"] = _pysimulavr.Pin_notifyList_set
    __swig_getmethods__["notifyList"] = _pysimulavr.Pin_notifyList_get
    if _newclass:notifyList = _swig_property(_pysimulavr.Pin_notifyList_get, _pysimulavr.Pin_notifyList_set)
    def __init__(self, *args): 
        if self.__class__ == Pin:
            _self = None
        else:
            _self = self
        this = _pysimulavr.new_Pin(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_Pin
    __del__ = lambda self : None;
    def SetInState(self, *args): return _pysimulavr.Pin_SetInState(self, *args)
    def RegisterNet(self, *args): return _pysimulavr.Pin_RegisterNet(self, *args)
    def UnRegisterNet(self, *args): return _pysimulavr.Pin_UnRegisterNet(self, *args)
    def GetPin(self): return _pysimulavr.Pin_GetPin(self)
    def GetAnalog(self): return _pysimulavr.Pin_GetAnalog(self)
    def SetAnalog(self, *args): return _pysimulavr.Pin_SetAnalog(self, *args)
    def RegisterCallback(self, *args): return _pysimulavr.Pin_RegisterCallback(self, *args)
    def CalcPin(self): return _pysimulavr.Pin_CalcPin(self)
    def isPortPin(self): return _pysimulavr.Pin_isPortPin(self)
    def isConnected(self): return _pysimulavr.Pin_isConnected(self)
    def hasListener(self): return _pysimulavr.Pin_hasListener(self)
    def toChar(self): return _pysimulavr.Pin_toChar(self)
    def SetPin(self, *args): return _pysimulavr.Pin_SetPin(self, *args)
    def __disown__(self):
        self.this.disown()
        _pysimulavr.disown_Pin(self)
        return weakref_proxy(self)
Pin_swigregister = _pysimulavr.Pin_swigregister
Pin_swigregister(Pin)

class Net(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Net, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Net, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _pysimulavr.delete_Net
    __del__ = lambda self : None;
    def Add(self, *args): return _pysimulavr.Net_Add(self, *args)
    def Delete(self, *args): return _pysimulavr.Net_Delete(self, *args)
    def CalcNet(self): return _pysimulavr.Net_CalcNet(self)
    def __init__(self): 
        this = _pysimulavr.new_Net()
        try: self.this.append(this)
        except: self.this = this
Net_swigregister = _pysimulavr.Net_swigregister
Net_swigregister(Net)

class RWMemoryMember(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RWMemoryMember, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RWMemoryMember, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        if self.__class__ == RWMemoryMember:
            _self = None
        else:
            _self = self
        this = _pysimulavr.new_RWMemoryMember(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_RWMemoryMember
    __del__ = lambda self : None;
    def set(self, *args): return _pysimulavr.RWMemoryMember_set(self, *args)
    def get(self): return _pysimulavr.RWMemoryMember_get(self)
    def __disown__(self):
        self.this.disown()
        _pysimulavr.disown_RWMemoryMember(self)
        return weakref_proxy(self)
RWMemoryMember_swigregister = _pysimulavr.RWMemoryMember_swigregister
RWMemoryMember_swigregister(RWMemoryMember)

class GPIORegister(RWMemoryMember,Hardware):
    __swig_setmethods__ = {}
    for _s in [RWMemoryMember,Hardware]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPIORegister, name, value)
    __swig_getmethods__ = {}
    for _s in [RWMemoryMember,Hardware]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GPIORegister, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_GPIORegister(*args)
        try: self.this.append(this)
        except: self.this = this
    def Reset(self): return _pysimulavr.GPIORegister_Reset(self)
    __swig_destroy__ = _pysimulavr.delete_GPIORegister
    __del__ = lambda self : None;
GPIORegister_swigregister = _pysimulavr.GPIORegister_swigregister
GPIORegister_swigregister(GPIORegister)

class RAM(RWMemoryMember):
    __swig_setmethods__ = {}
    for _s in [RWMemoryMember]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RAM, name, value)
    __swig_getmethods__ = {}
    for _s in [RWMemoryMember]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RAM, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_RAM(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_RAM
    __del__ = lambda self : None;
RAM_swigregister = _pysimulavr.RAM_swigregister
RAM_swigregister(RAM)

class InvalidMem(RWMemoryMember):
    __swig_setmethods__ = {}
    for _s in [RWMemoryMember]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidMem, name, value)
    __swig_getmethods__ = {}
    for _s in [RWMemoryMember]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidMem, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_InvalidMem(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_InvalidMem
    __del__ = lambda self : None;
InvalidMem_swigregister = _pysimulavr.InvalidMem_swigregister
InvalidMem_swigregister(InvalidMem)

class NotSimulatedRegister(RWMemoryMember):
    __swig_setmethods__ = {}
    for _s in [RWMemoryMember]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotSimulatedRegister, name, value)
    __swig_getmethods__ = {}
    for _s in [RWMemoryMember]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotSimulatedRegister, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_NotSimulatedRegister(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_NotSimulatedRegister
    __del__ = lambda self : None;
NotSimulatedRegister_swigregister = _pysimulavr.NotSimulatedRegister_swigregister
NotSimulatedRegister_swigregister(NotSimulatedRegister)

class IOSpecialRegClient(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IOSpecialRegClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IOSpecialRegClient, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pysimulavr.delete_IOSpecialRegClient
    __del__ = lambda self : None;
IOSpecialRegClient_swigregister = _pysimulavr.IOSpecialRegClient_swigregister
IOSpecialRegClient_swigregister(IOSpecialRegClient)

class IOSpecialReg(RWMemoryMember):
    __swig_setmethods__ = {}
    for _s in [RWMemoryMember]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IOSpecialReg, name, value)
    __swig_getmethods__ = {}
    for _s in [RWMemoryMember]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IOSpecialReg, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_IOSpecialReg(*args)
        try: self.this.append(this)
        except: self.this = this
    def connectSRegClient(self, *args): return _pysimulavr.IOSpecialReg_connectSRegClient(self, *args)
    def Reset(self, *args): return _pysimulavr.IOSpecialReg_Reset(self, *args)
    def hardwareChange(self, *args): return _pysimulavr.IOSpecialReg_hardwareChange(self, *args)
    def hardwareChangeMask(self, *args): return _pysimulavr.IOSpecialReg_hardwareChangeMask(self, *args)
    __swig_destroy__ = _pysimulavr.delete_IOSpecialReg
    __del__ = lambda self : None;
IOSpecialReg_swigregister = _pysimulavr.IOSpecialReg_swigregister
IOSpecialReg_swigregister(IOSpecialReg)

class HWSreg_bool(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HWSreg_bool, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HWSreg_bool, name)
    __repr__ = _swig_repr
    __swig_setmethods__["I"] = _pysimulavr.HWSreg_bool_I_set
    __swig_getmethods__["I"] = _pysimulavr.HWSreg_bool_I_get
    if _newclass:I = _swig_property(_pysimulavr.HWSreg_bool_I_get, _pysimulavr.HWSreg_bool_I_set)
    __swig_setmethods__["T"] = _pysimulavr.HWSreg_bool_T_set
    __swig_getmethods__["T"] = _pysimulavr.HWSreg_bool_T_get
    if _newclass:T = _swig_property(_pysimulavr.HWSreg_bool_T_get, _pysimulavr.HWSreg_bool_T_set)
    __swig_setmethods__["H"] = _pysimulavr.HWSreg_bool_H_set
    __swig_getmethods__["H"] = _pysimulavr.HWSreg_bool_H_get
    if _newclass:H = _swig_property(_pysimulavr.HWSreg_bool_H_get, _pysimulavr.HWSreg_bool_H_set)
    __swig_setmethods__["S"] = _pysimulavr.HWSreg_bool_S_set
    __swig_getmethods__["S"] = _pysimulavr.HWSreg_bool_S_get
    if _newclass:S = _swig_property(_pysimulavr.HWSreg_bool_S_get, _pysimulavr.HWSreg_bool_S_set)
    __swig_setmethods__["V"] = _pysimulavr.HWSreg_bool_V_set
    __swig_getmethods__["V"] = _pysimulavr.HWSreg_bool_V_get
    if _newclass:V = _swig_property(_pysimulavr.HWSreg_bool_V_get, _pysimulavr.HWSreg_bool_V_set)
    __swig_setmethods__["N"] = _pysimulavr.HWSreg_bool_N_set
    __swig_getmethods__["N"] = _pysimulavr.HWSreg_bool_N_get
    if _newclass:N = _swig_property(_pysimulavr.HWSreg_bool_N_get, _pysimulavr.HWSreg_bool_N_set)
    __swig_setmethods__["Z"] = _pysimulavr.HWSreg_bool_Z_set
    __swig_getmethods__["Z"] = _pysimulavr.HWSreg_bool_Z_get
    if _newclass:Z = _swig_property(_pysimulavr.HWSreg_bool_Z_get, _pysimulavr.HWSreg_bool_Z_set)
    __swig_setmethods__["C"] = _pysimulavr.HWSreg_bool_C_set
    __swig_getmethods__["C"] = _pysimulavr.HWSreg_bool_C_get
    if _newclass:C = _swig_property(_pysimulavr.HWSreg_bool_C_get, _pysimulavr.HWSreg_bool_C_set)
    def __init__(self, *args): 
        this = _pysimulavr.new_HWSreg_bool(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_HWSreg_bool
    __del__ = lambda self : None;
HWSreg_bool_swigregister = _pysimulavr.HWSreg_bool_swigregister
HWSreg_bool_swigregister(HWSreg_bool)

class HWSreg(HWSreg_bool):
    __swig_setmethods__ = {}
    for _s in [HWSreg_bool]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HWSreg, name, value)
    __swig_getmethods__ = {}
    for _s in [HWSreg_bool]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HWSreg, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_HWSreg()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_HWSreg
    __del__ = lambda self : None;
HWSreg_swigregister = _pysimulavr.HWSreg_swigregister
HWSreg_swigregister(HWSreg)

class RWSreg(RWMemoryMember):
    __swig_setmethods__ = {}
    for _s in [RWMemoryMember]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RWSreg, name, value)
    __swig_getmethods__ = {}
    for _s in [RWMemoryMember]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RWSreg, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_RWSreg(*args)
        try: self.this.append(this)
        except: self.this = this
    def trigger_change(self): return _pysimulavr.RWSreg_trigger_change(self)
    def GetValue(self, *args): return _pysimulavr.RWSreg_GetValue(self, *args)
    def SetValue(self, *args): return _pysimulavr.RWSreg_SetValue(self, *args)
    __swig_destroy__ = _pysimulavr.delete_RWSreg
    __del__ = lambda self : None;
RWSreg_swigregister = _pysimulavr.RWSreg_swigregister
RWSreg_swigregister(RWSreg)

class AvrFactory(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrFactory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AvrFactory, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def makeDevice(self, *args): return _pysimulavr.AvrFactory_makeDevice(self, *args)
    __swig_getmethods__["instance"] = lambda x: _pysimulavr.AvrFactory_instance
    if _newclass:instance = staticmethod(_pysimulavr.AvrFactory_instance)
    __swig_getmethods__["supportedDevices"] = lambda x: _pysimulavr.AvrFactory_supportedDevices
    if _newclass:supportedDevices = staticmethod(_pysimulavr.AvrFactory_supportedDevices)
    __swig_getmethods__["reg"] = lambda x: _pysimulavr.AvrFactory_reg
    if _newclass:reg = staticmethod(_pysimulavr.AvrFactory_reg)
    __swig_destroy__ = _pysimulavr.delete_AvrFactory
    __del__ = lambda self : None;
AvrFactory_swigregister = _pysimulavr.AvrFactory_swigregister
AvrFactory_swigregister(AvrFactory)

def AvrFactory_instance():
  return _pysimulavr.AvrFactory_instance()
AvrFactory_instance = _pysimulavr.AvrFactory_instance

def AvrFactory_supportedDevices():
  return _pysimulavr.AvrFactory_supportedDevices()
AvrFactory_supportedDevices = _pysimulavr.AvrFactory_supportedDevices

def AvrFactory_reg(*args):
  return _pysimulavr.AvrFactory_reg(*args)
AvrFactory_reg = _pysimulavr.AvrFactory_reg

class Memory(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Memory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Memory, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["myMemory"] = _pysimulavr.Memory_myMemory_set
    __swig_getmethods__["myMemory"] = _pysimulavr.Memory_myMemory_get
    if _newclass:myMemory = _swig_property(_pysimulavr.Memory_myMemory_get, _pysimulavr.Memory_myMemory_set)
    __swig_setmethods__["sym"] = _pysimulavr.Memory_sym_set
    __swig_getmethods__["sym"] = _pysimulavr.Memory_sym_get
    if _newclass:sym = _swig_property(_pysimulavr.Memory_sym_get, _pysimulavr.Memory_sym_set)
    __swig_destroy__ = _pysimulavr.delete_Memory
    __del__ = lambda self : None;
    def GetSymbolAtAddress(self, *args): return _pysimulavr.Memory_GetSymbolAtAddress(self, *args)
    def GetAddressAtSymbol(self, *args): return _pysimulavr.Memory_GetAddressAtSymbol(self, *args)
    def AddSymbol(self, *args): return _pysimulavr.Memory_AddSymbol(self, *args)
    def GetSize(self): return _pysimulavr.Memory_GetSize(self)
    def WriteMem(self, *args): return _pysimulavr.Memory_WriteMem(self, *args)
    def GetMemory(self, *args): return _pysimulavr.Memory_GetMemory(self, *args)
    def PyWriteMem(self, *args): return _pysimulavr.Memory_PyWriteMem(self, *args)
Memory_swigregister = _pysimulavr.Memory_swigregister
Memory_swigregister(Memory)

class Data(Memory):
    __swig_setmethods__ = {}
    for _s in [Memory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Data, name, value)
    __swig_getmethods__ = {}
    for _s in [Memory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Data, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_Data()
        try: self.this.append(this)
        except: self.this = this
    def WriteMem(self, *args): return _pysimulavr.Data_WriteMem(self, *args)
    __swig_destroy__ = _pysimulavr.delete_Data
    __del__ = lambda self : None;
Data_swigregister = _pysimulavr.Data_swigregister
Data_swigregister(Data)

class AvrFlash(Memory):
    __swig_setmethods__ = {}
    for _s in [Memory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrFlash, name, value)
    __swig_getmethods__ = {}
    for _s in [Memory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrFlash, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_AvrFlash(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrFlash
    __del__ = lambda self : None;
    def Decode(self, *args): return _pysimulavr.AvrFlash_Decode(self, *args)
    def WriteMem(self, *args): return _pysimulavr.AvrFlash_WriteMem(self, *args)
    def WriteMemByte(self, *args): return _pysimulavr.AvrFlash_WriteMemByte(self, *args)
    def IsProgramLoaded(self): return _pysimulavr.AvrFlash_IsProgramLoaded(self)
    def IsRWWLock(self, *args): return _pysimulavr.AvrFlash_IsRWWLock(self, *args)
    def SetRWWLock(self, *args): return _pysimulavr.AvrFlash_SetRWWLock(self, *args)
    def GetInstruction(self, *args): return _pysimulavr.AvrFlash_GetInstruction(self, *args)
    def ReadMemRaw(self, *args): return _pysimulavr.AvrFlash_ReadMemRaw(self, *args)
    def ReadMem(self, *args): return _pysimulavr.AvrFlash_ReadMem(self, *args)
    def ReadMemRawWord(self, *args): return _pysimulavr.AvrFlash_ReadMemRawWord(self, *args)
    def ReadMemWord(self, *args): return _pysimulavr.AvrFlash_ReadMemWord(self, *args)
    def LooksLikeContextSwitch(self, *args): return _pysimulavr.AvrFlash_LooksLikeContextSwitch(self, *args)
AvrFlash_swigregister = _pysimulavr.AvrFlash_swigregister
AvrFlash_swigregister(AvrFlash)

class HWEeprom(Hardware,Memory,TraceValueRegister):
    __swig_setmethods__ = {}
    for _s in [Hardware,Memory,TraceValueRegister]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HWEeprom, name, value)
    __swig_getmethods__ = {}
    for _s in [Hardware,Memory,TraceValueRegister]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HWEeprom, name)
    __repr__ = _swig_repr
    DEVMODE_NORMAL = _pysimulavr.HWEeprom_DEVMODE_NORMAL
    DEVMODE_EXTENDED = _pysimulavr.HWEeprom_DEVMODE_EXTENDED
    OPSTATE_READY = _pysimulavr.HWEeprom_OPSTATE_READY
    OPSTATE_ENABLED = _pysimulavr.HWEeprom_OPSTATE_ENABLED
    OPSTATE_WRITE = _pysimulavr.HWEeprom_OPSTATE_WRITE
    CTRL_MODE_ERASEWRITE = _pysimulavr.HWEeprom_CTRL_MODE_ERASEWRITE
    CTRL_READ = _pysimulavr.HWEeprom_CTRL_READ
    CTRL_WRITE = _pysimulavr.HWEeprom_CTRL_WRITE
    CTRL_ENABLE = _pysimulavr.HWEeprom_CTRL_ENABLE
    CTRL_IRQ = _pysimulavr.HWEeprom_CTRL_IRQ
    CTRL_MODE_ERASE = _pysimulavr.HWEeprom_CTRL_MODE_ERASE
    CTRL_MODE_WRITE = _pysimulavr.HWEeprom_CTRL_MODE_WRITE
    CTRL_MODES = _pysimulavr.HWEeprom_CTRL_MODES
    def __init__(self, *args): 
        this = _pysimulavr.new_HWEeprom(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_HWEeprom
    __del__ = lambda self : None;
    def CpuCycle(self): return _pysimulavr.HWEeprom_CpuCycle(self)
    def Reset(self): return _pysimulavr.HWEeprom_Reset(self)
    def ClearIrqFlag(self, *args): return _pysimulavr.HWEeprom_ClearIrqFlag(self, *args)
    def WriteMem(self, *args): return _pysimulavr.HWEeprom_WriteMem(self, *args)
    def WriteAtAddress(self, *args): return _pysimulavr.HWEeprom_WriteAtAddress(self, *args)
    def ReadFromAddress(self, *args): return _pysimulavr.HWEeprom_ReadFromAddress(self, *args)
    def SetEearl(self, *args): return _pysimulavr.HWEeprom_SetEearl(self, *args)
    def SetEearh(self, *args): return _pysimulavr.HWEeprom_SetEearh(self, *args)
    def SetEedr(self, *args): return _pysimulavr.HWEeprom_SetEedr(self, *args)
    def SetEecr(self, *args): return _pysimulavr.HWEeprom_SetEecr(self, *args)
    def GetEearl(self): return _pysimulavr.HWEeprom_GetEearl(self)
    def GetEearh(self): return _pysimulavr.HWEeprom_GetEearh(self)
    def GetEecr(self): return _pysimulavr.HWEeprom_GetEecr(self)
    def GetEedr(self): return _pysimulavr.HWEeprom_GetEedr(self)
    __swig_setmethods__["eearh_reg"] = _pysimulavr.HWEeprom_eearh_reg_set
    __swig_getmethods__["eearh_reg"] = _pysimulavr.HWEeprom_eearh_reg_get
    if _newclass:eearh_reg = _swig_property(_pysimulavr.HWEeprom_eearh_reg_get, _pysimulavr.HWEeprom_eearh_reg_set)
    __swig_setmethods__["eearl_reg"] = _pysimulavr.HWEeprom_eearl_reg_set
    __swig_getmethods__["eearl_reg"] = _pysimulavr.HWEeprom_eearl_reg_get
    if _newclass:eearl_reg = _swig_property(_pysimulavr.HWEeprom_eearl_reg_get, _pysimulavr.HWEeprom_eearl_reg_set)
    __swig_setmethods__["eedr_reg"] = _pysimulavr.HWEeprom_eedr_reg_set
    __swig_getmethods__["eedr_reg"] = _pysimulavr.HWEeprom_eedr_reg_get
    if _newclass:eedr_reg = _swig_property(_pysimulavr.HWEeprom_eedr_reg_get, _pysimulavr.HWEeprom_eedr_reg_set)
    __swig_setmethods__["eecr_reg"] = _pysimulavr.HWEeprom_eecr_reg_set
    __swig_getmethods__["eecr_reg"] = _pysimulavr.HWEeprom_eecr_reg_get
    if _newclass:eecr_reg = _swig_property(_pysimulavr.HWEeprom_eecr_reg_get, _pysimulavr.HWEeprom_eecr_reg_set)
HWEeprom_swigregister = _pysimulavr.HWEeprom_swigregister
HWEeprom_swigregister(HWEeprom)

class Breakpoints(DWordVector):
    __swig_setmethods__ = {}
    for _s in [DWordVector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Breakpoints, name, value)
    __swig_getmethods__ = {}
    for _s in [DWordVector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Breakpoints, name)
    __repr__ = _swig_repr
    def RemoveBreakpoint(self, *args): return _pysimulavr.Breakpoints_RemoveBreakpoint(self, *args)
    def AddBreakpoint(self, *args): return _pysimulavr.Breakpoints_AddBreakpoint(self, *args)
    def __init__(self): 
        this = _pysimulavr.new_Breakpoints()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_Breakpoints
    __del__ = lambda self : None;
Breakpoints_swigregister = _pysimulavr.Breakpoints_swigregister
Breakpoints_swigregister(Breakpoints)

class Exitpoints(DWordVector):
    __swig_setmethods__ = {}
    for _s in [DWordVector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Exitpoints, name, value)
    __swig_getmethods__ = {}
    for _s in [DWordVector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Exitpoints, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_Exitpoints()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_Exitpoints
    __del__ = lambda self : None;
Exitpoints_swigregister = _pysimulavr.Exitpoints_swigregister
Exitpoints_swigregister(Exitpoints)

BREAK_POINT = _pysimulavr.BREAK_POINT
INVALID_OPCODE = _pysimulavr.INVALID_OPCODE
class SystemConsoleHandler(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SystemConsoleHandler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SystemConsoleHandler, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_SystemConsoleHandler()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_SystemConsoleHandler
    __del__ = lambda self : None;
    def SetUseExit(self, useExit = True): return _pysimulavr.SystemConsoleHandler_SetUseExit(self, useExit)
    def SetMessageStream(self, *args): return _pysimulavr.SystemConsoleHandler_SetMessageStream(self, *args)
    def SetWarningStream(self, *args): return _pysimulavr.SystemConsoleHandler_SetWarningStream(self, *args)
    def SetTraceFile(self, *args): return _pysimulavr.SystemConsoleHandler_SetTraceFile(self, *args)
    def SetTraceStream(self, *args): return _pysimulavr.SystemConsoleHandler_SetTraceStream(self, *args)
    def StopTrace(self): return _pysimulavr.SystemConsoleHandler_StopTrace(self)
    def GetTraceState(self): return _pysimulavr.SystemConsoleHandler_GetTraceState(self)
    def traceOutStream(self): return _pysimulavr.SystemConsoleHandler_traceOutStream(self)
    def TraceNextLine(self): return _pysimulavr.SystemConsoleHandler_TraceNextLine(self)
    def vfmessage(self, *args): return _pysimulavr.SystemConsoleHandler_vfmessage(self, *args)
    def vfwarning(self, *args): return _pysimulavr.SystemConsoleHandler_vfwarning(self, *args)
    def vferror(self, *args): return _pysimulavr.SystemConsoleHandler_vferror(self, *args)
    def vffatal(self, *args): return _pysimulavr.SystemConsoleHandler_vffatal(self, *args)
    def AbortApplication(self, *args): return _pysimulavr.SystemConsoleHandler_AbortApplication(self, *args)
    def ExitApplication(self, *args): return _pysimulavr.SystemConsoleHandler_ExitApplication(self, *args)
SystemConsoleHandler_swigregister = _pysimulavr.SystemConsoleHandler_swigregister
SystemConsoleHandler_swigregister(SystemConsoleHandler)


def trioaccess(*args):
  return _pysimulavr.trioaccess(*args)
trioaccess = _pysimulavr.trioaccess
class AvrDevice_atmega128(AvrDevice):
    __swig_setmethods__ = {}
    for _s in [AvrDevice]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_atmega128, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_atmega128, name)
    __repr__ = _swig_repr
    __swig_setmethods__["aref"] = _pysimulavr.AvrDevice_atmega128_aref_set
    __swig_getmethods__["aref"] = _pysimulavr.AvrDevice_atmega128_aref_get
    if _newclass:aref = _swig_property(_pysimulavr.AvrDevice_atmega128_aref_get, _pysimulavr.AvrDevice_atmega128_aref_set)
    __swig_setmethods__["porta"] = _pysimulavr.AvrDevice_atmega128_porta_set
    __swig_getmethods__["porta"] = _pysimulavr.AvrDevice_atmega128_porta_get
    if _newclass:porta = _swig_property(_pysimulavr.AvrDevice_atmega128_porta_get, _pysimulavr.AvrDevice_atmega128_porta_set)
    __swig_setmethods__["portb"] = _pysimulavr.AvrDevice_atmega128_portb_set
    __swig_getmethods__["portb"] = _pysimulavr.AvrDevice_atmega128_portb_get
    if _newclass:portb = _swig_property(_pysimulavr.AvrDevice_atmega128_portb_get, _pysimulavr.AvrDevice_atmega128_portb_set)
    __swig_setmethods__["portc"] = _pysimulavr.AvrDevice_atmega128_portc_set
    __swig_getmethods__["portc"] = _pysimulavr.AvrDevice_atmega128_portc_get
    if _newclass:portc = _swig_property(_pysimulavr.AvrDevice_atmega128_portc_get, _pysimulavr.AvrDevice_atmega128_portc_set)
    __swig_setmethods__["portd"] = _pysimulavr.AvrDevice_atmega128_portd_set
    __swig_getmethods__["portd"] = _pysimulavr.AvrDevice_atmega128_portd_get
    if _newclass:portd = _swig_property(_pysimulavr.AvrDevice_atmega128_portd_get, _pysimulavr.AvrDevice_atmega128_portd_set)
    __swig_setmethods__["porte"] = _pysimulavr.AvrDevice_atmega128_porte_set
    __swig_getmethods__["porte"] = _pysimulavr.AvrDevice_atmega128_porte_get
    if _newclass:porte = _swig_property(_pysimulavr.AvrDevice_atmega128_porte_get, _pysimulavr.AvrDevice_atmega128_porte_set)
    __swig_setmethods__["portf"] = _pysimulavr.AvrDevice_atmega128_portf_set
    __swig_getmethods__["portf"] = _pysimulavr.AvrDevice_atmega128_portf_get
    if _newclass:portf = _swig_property(_pysimulavr.AvrDevice_atmega128_portf_get, _pysimulavr.AvrDevice_atmega128_portf_set)
    __swig_setmethods__["portg"] = _pysimulavr.AvrDevice_atmega128_portg_set
    __swig_getmethods__["portg"] = _pysimulavr.AvrDevice_atmega128_portg_get
    if _newclass:portg = _swig_property(_pysimulavr.AvrDevice_atmega128_portg_get, _pysimulavr.AvrDevice_atmega128_portg_set)
    __swig_setmethods__["extirq"] = _pysimulavr.AvrDevice_atmega128_extirq_set
    __swig_getmethods__["extirq"] = _pysimulavr.AvrDevice_atmega128_extirq_get
    if _newclass:extirq = _swig_property(_pysimulavr.AvrDevice_atmega128_extirq_get, _pysimulavr.AvrDevice_atmega128_extirq_set)
    __swig_setmethods__["eicra_reg"] = _pysimulavr.AvrDevice_atmega128_eicra_reg_set
    __swig_getmethods__["eicra_reg"] = _pysimulavr.AvrDevice_atmega128_eicra_reg_get
    if _newclass:eicra_reg = _swig_property(_pysimulavr.AvrDevice_atmega128_eicra_reg_get, _pysimulavr.AvrDevice_atmega128_eicra_reg_set)
    __swig_setmethods__["eicrb_reg"] = _pysimulavr.AvrDevice_atmega128_eicrb_reg_set
    __swig_getmethods__["eicrb_reg"] = _pysimulavr.AvrDevice_atmega128_eicrb_reg_get
    if _newclass:eicrb_reg = _swig_property(_pysimulavr.AvrDevice_atmega128_eicrb_reg_get, _pysimulavr.AvrDevice_atmega128_eicrb_reg_set)
    __swig_setmethods__["eimsk_reg"] = _pysimulavr.AvrDevice_atmega128_eimsk_reg_set
    __swig_getmethods__["eimsk_reg"] = _pysimulavr.AvrDevice_atmega128_eimsk_reg_get
    if _newclass:eimsk_reg = _swig_property(_pysimulavr.AvrDevice_atmega128_eimsk_reg_get, _pysimulavr.AvrDevice_atmega128_eimsk_reg_set)
    __swig_setmethods__["eifr_reg"] = _pysimulavr.AvrDevice_atmega128_eifr_reg_set
    __swig_getmethods__["eifr_reg"] = _pysimulavr.AvrDevice_atmega128_eifr_reg_get
    if _newclass:eifr_reg = _swig_property(_pysimulavr.AvrDevice_atmega128_eifr_reg_get, _pysimulavr.AvrDevice_atmega128_eifr_reg_set)
    __swig_setmethods__["admux"] = _pysimulavr.AvrDevice_atmega128_admux_set
    __swig_getmethods__["admux"] = _pysimulavr.AvrDevice_atmega128_admux_get
    if _newclass:admux = _swig_property(_pysimulavr.AvrDevice_atmega128_admux_get, _pysimulavr.AvrDevice_atmega128_admux_set)
    __swig_setmethods__["ad"] = _pysimulavr.AvrDevice_atmega128_ad_set
    __swig_getmethods__["ad"] = _pysimulavr.AvrDevice_atmega128_ad_get
    if _newclass:ad = _swig_property(_pysimulavr.AvrDevice_atmega128_ad_get, _pysimulavr.AvrDevice_atmega128_ad_set)
    __swig_setmethods__["assr_reg"] = _pysimulavr.AvrDevice_atmega128_assr_reg_set
    __swig_getmethods__["assr_reg"] = _pysimulavr.AvrDevice_atmega128_assr_reg_get
    if _newclass:assr_reg = _swig_property(_pysimulavr.AvrDevice_atmega128_assr_reg_get, _pysimulavr.AvrDevice_atmega128_assr_reg_set)
    __swig_setmethods__["sfior_reg"] = _pysimulavr.AvrDevice_atmega128_sfior_reg_set
    __swig_getmethods__["sfior_reg"] = _pysimulavr.AvrDevice_atmega128_sfior_reg_get
    if _newclass:sfior_reg = _swig_property(_pysimulavr.AvrDevice_atmega128_sfior_reg_get, _pysimulavr.AvrDevice_atmega128_sfior_reg_set)
    __swig_setmethods__["prescaler0"] = _pysimulavr.AvrDevice_atmega128_prescaler0_set
    __swig_getmethods__["prescaler0"] = _pysimulavr.AvrDevice_atmega128_prescaler0_get
    if _newclass:prescaler0 = _swig_property(_pysimulavr.AvrDevice_atmega128_prescaler0_get, _pysimulavr.AvrDevice_atmega128_prescaler0_set)
    __swig_setmethods__["prescaler123"] = _pysimulavr.AvrDevice_atmega128_prescaler123_set
    __swig_getmethods__["prescaler123"] = _pysimulavr.AvrDevice_atmega128_prescaler123_get
    if _newclass:prescaler123 = _swig_property(_pysimulavr.AvrDevice_atmega128_prescaler123_get, _pysimulavr.AvrDevice_atmega128_prescaler123_set)
    __swig_setmethods__["inputCapture1"] = _pysimulavr.AvrDevice_atmega128_inputCapture1_set
    __swig_getmethods__["inputCapture1"] = _pysimulavr.AvrDevice_atmega128_inputCapture1_get
    if _newclass:inputCapture1 = _swig_property(_pysimulavr.AvrDevice_atmega128_inputCapture1_get, _pysimulavr.AvrDevice_atmega128_inputCapture1_set)
    __swig_setmethods__["inputCapture3"] = _pysimulavr.AvrDevice_atmega128_inputCapture3_set
    __swig_getmethods__["inputCapture3"] = _pysimulavr.AvrDevice_atmega128_inputCapture3_get
    if _newclass:inputCapture3 = _swig_property(_pysimulavr.AvrDevice_atmega128_inputCapture3_get, _pysimulavr.AvrDevice_atmega128_inputCapture3_set)
    __swig_setmethods__["timer0"] = _pysimulavr.AvrDevice_atmega128_timer0_set
    __swig_getmethods__["timer0"] = _pysimulavr.AvrDevice_atmega128_timer0_get
    if _newclass:timer0 = _swig_property(_pysimulavr.AvrDevice_atmega128_timer0_get, _pysimulavr.AvrDevice_atmega128_timer0_set)
    __swig_setmethods__["timer1"] = _pysimulavr.AvrDevice_atmega128_timer1_set
    __swig_getmethods__["timer1"] = _pysimulavr.AvrDevice_atmega128_timer1_get
    if _newclass:timer1 = _swig_property(_pysimulavr.AvrDevice_atmega128_timer1_get, _pysimulavr.AvrDevice_atmega128_timer1_set)
    __swig_setmethods__["timer2"] = _pysimulavr.AvrDevice_atmega128_timer2_set
    __swig_getmethods__["timer2"] = _pysimulavr.AvrDevice_atmega128_timer2_get
    if _newclass:timer2 = _swig_property(_pysimulavr.AvrDevice_atmega128_timer2_get, _pysimulavr.AvrDevice_atmega128_timer2_set)
    __swig_setmethods__["timer3"] = _pysimulavr.AvrDevice_atmega128_timer3_set
    __swig_getmethods__["timer3"] = _pysimulavr.AvrDevice_atmega128_timer3_get
    if _newclass:timer3 = _swig_property(_pysimulavr.AvrDevice_atmega128_timer3_get, _pysimulavr.AvrDevice_atmega128_timer3_set)
    __swig_setmethods__["timer012irq"] = _pysimulavr.AvrDevice_atmega128_timer012irq_set
    __swig_getmethods__["timer012irq"] = _pysimulavr.AvrDevice_atmega128_timer012irq_get
    if _newclass:timer012irq = _swig_property(_pysimulavr.AvrDevice_atmega128_timer012irq_get, _pysimulavr.AvrDevice_atmega128_timer012irq_set)
    __swig_setmethods__["timer3irq"] = _pysimulavr.AvrDevice_atmega128_timer3irq_set
    __swig_getmethods__["timer3irq"] = _pysimulavr.AvrDevice_atmega128_timer3irq_get
    if _newclass:timer3irq = _swig_property(_pysimulavr.AvrDevice_atmega128_timer3irq_get, _pysimulavr.AvrDevice_atmega128_timer3irq_set)
    __swig_setmethods__["spi"] = _pysimulavr.AvrDevice_atmega128_spi_set
    __swig_getmethods__["spi"] = _pysimulavr.AvrDevice_atmega128_spi_get
    if _newclass:spi = _swig_property(_pysimulavr.AvrDevice_atmega128_spi_get, _pysimulavr.AvrDevice_atmega128_spi_set)
    __swig_setmethods__["usart0"] = _pysimulavr.AvrDevice_atmega128_usart0_set
    __swig_getmethods__["usart0"] = _pysimulavr.AvrDevice_atmega128_usart0_get
    if _newclass:usart0 = _swig_property(_pysimulavr.AvrDevice_atmega128_usart0_get, _pysimulavr.AvrDevice_atmega128_usart0_set)
    __swig_setmethods__["usart1"] = _pysimulavr.AvrDevice_atmega128_usart1_set
    __swig_getmethods__["usart1"] = _pysimulavr.AvrDevice_atmega128_usart1_get
    if _newclass:usart1 = _swig_property(_pysimulavr.AvrDevice_atmega128_usart1_get, _pysimulavr.AvrDevice_atmega128_usart1_set)
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_atmega128()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_atmega128
    __del__ = lambda self : None;
AvrDevice_atmega128_swigregister = _pysimulavr.AvrDevice_atmega128_swigregister
AvrDevice_atmega128_swigregister(AvrDevice_atmega128)

class AvrDevice_at90s4433(AvrDevice):
    __swig_setmethods__ = {}
    for _s in [AvrDevice]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_at90s4433, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_at90s4433, name)
    __repr__ = _swig_repr
    __swig_setmethods__["portb"] = _pysimulavr.AvrDevice_at90s4433_portb_set
    __swig_getmethods__["portb"] = _pysimulavr.AvrDevice_at90s4433_portb_get
    if _newclass:portb = _swig_property(_pysimulavr.AvrDevice_at90s4433_portb_get, _pysimulavr.AvrDevice_at90s4433_portb_set)
    __swig_setmethods__["portc"] = _pysimulavr.AvrDevice_at90s4433_portc_set
    __swig_getmethods__["portc"] = _pysimulavr.AvrDevice_at90s4433_portc_get
    if _newclass:portc = _swig_property(_pysimulavr.AvrDevice_at90s4433_portc_get, _pysimulavr.AvrDevice_at90s4433_portc_set)
    __swig_setmethods__["portd"] = _pysimulavr.AvrDevice_at90s4433_portd_set
    __swig_getmethods__["portd"] = _pysimulavr.AvrDevice_at90s4433_portd_get
    if _newclass:portd = _swig_property(_pysimulavr.AvrDevice_at90s4433_portd_get, _pysimulavr.AvrDevice_at90s4433_portd_set)
    __swig_setmethods__["admux"] = _pysimulavr.AvrDevice_at90s4433_admux_set
    __swig_getmethods__["admux"] = _pysimulavr.AvrDevice_at90s4433_admux_get
    if _newclass:admux = _swig_property(_pysimulavr.AvrDevice_at90s4433_admux_get, _pysimulavr.AvrDevice_at90s4433_admux_set)
    __swig_setmethods__["ad"] = _pysimulavr.AvrDevice_at90s4433_ad_set
    __swig_getmethods__["ad"] = _pysimulavr.AvrDevice_at90s4433_ad_get
    if _newclass:ad = _swig_property(_pysimulavr.AvrDevice_at90s4433_ad_get, _pysimulavr.AvrDevice_at90s4433_ad_set)
    __swig_setmethods__["spi"] = _pysimulavr.AvrDevice_at90s4433_spi_set
    __swig_getmethods__["spi"] = _pysimulavr.AvrDevice_at90s4433_spi_get
    if _newclass:spi = _swig_property(_pysimulavr.AvrDevice_at90s4433_spi_get, _pysimulavr.AvrDevice_at90s4433_spi_set)
    __swig_setmethods__["uart"] = _pysimulavr.AvrDevice_at90s4433_uart_set
    __swig_getmethods__["uart"] = _pysimulavr.AvrDevice_at90s4433_uart_get
    if _newclass:uart = _swig_property(_pysimulavr.AvrDevice_at90s4433_uart_get, _pysimulavr.AvrDevice_at90s4433_uart_set)
    __swig_setmethods__["acomp"] = _pysimulavr.AvrDevice_at90s4433_acomp_set
    __swig_getmethods__["acomp"] = _pysimulavr.AvrDevice_at90s4433_acomp_get
    if _newclass:acomp = _swig_property(_pysimulavr.AvrDevice_at90s4433_acomp_get, _pysimulavr.AvrDevice_at90s4433_acomp_set)
    __swig_setmethods__["prescaler"] = _pysimulavr.AvrDevice_at90s4433_prescaler_set
    __swig_getmethods__["prescaler"] = _pysimulavr.AvrDevice_at90s4433_prescaler_get
    if _newclass:prescaler = _swig_property(_pysimulavr.AvrDevice_at90s4433_prescaler_get, _pysimulavr.AvrDevice_at90s4433_prescaler_set)
    __swig_setmethods__["timer01irq"] = _pysimulavr.AvrDevice_at90s4433_timer01irq_set
    __swig_getmethods__["timer01irq"] = _pysimulavr.AvrDevice_at90s4433_timer01irq_get
    if _newclass:timer01irq = _swig_property(_pysimulavr.AvrDevice_at90s4433_timer01irq_get, _pysimulavr.AvrDevice_at90s4433_timer01irq_set)
    __swig_setmethods__["timer0"] = _pysimulavr.AvrDevice_at90s4433_timer0_set
    __swig_getmethods__["timer0"] = _pysimulavr.AvrDevice_at90s4433_timer0_get
    if _newclass:timer0 = _swig_property(_pysimulavr.AvrDevice_at90s4433_timer0_get, _pysimulavr.AvrDevice_at90s4433_timer0_set)
    __swig_setmethods__["inputCapture1"] = _pysimulavr.AvrDevice_at90s4433_inputCapture1_set
    __swig_getmethods__["inputCapture1"] = _pysimulavr.AvrDevice_at90s4433_inputCapture1_get
    if _newclass:inputCapture1 = _swig_property(_pysimulavr.AvrDevice_at90s4433_inputCapture1_get, _pysimulavr.AvrDevice_at90s4433_inputCapture1_set)
    __swig_setmethods__["timer1"] = _pysimulavr.AvrDevice_at90s4433_timer1_set
    __swig_getmethods__["timer1"] = _pysimulavr.AvrDevice_at90s4433_timer1_get
    if _newclass:timer1 = _swig_property(_pysimulavr.AvrDevice_at90s4433_timer1_get, _pysimulavr.AvrDevice_at90s4433_timer1_set)
    __swig_setmethods__["extirq"] = _pysimulavr.AvrDevice_at90s4433_extirq_set
    __swig_getmethods__["extirq"] = _pysimulavr.AvrDevice_at90s4433_extirq_get
    if _newclass:extirq = _swig_property(_pysimulavr.AvrDevice_at90s4433_extirq_get, _pysimulavr.AvrDevice_at90s4433_extirq_set)
    __swig_setmethods__["gimsk_reg"] = _pysimulavr.AvrDevice_at90s4433_gimsk_reg_set
    __swig_getmethods__["gimsk_reg"] = _pysimulavr.AvrDevice_at90s4433_gimsk_reg_get
    if _newclass:gimsk_reg = _swig_property(_pysimulavr.AvrDevice_at90s4433_gimsk_reg_get, _pysimulavr.AvrDevice_at90s4433_gimsk_reg_set)
    __swig_setmethods__["gifr_reg"] = _pysimulavr.AvrDevice_at90s4433_gifr_reg_set
    __swig_getmethods__["gifr_reg"] = _pysimulavr.AvrDevice_at90s4433_gifr_reg_get
    if _newclass:gifr_reg = _swig_property(_pysimulavr.AvrDevice_at90s4433_gifr_reg_get, _pysimulavr.AvrDevice_at90s4433_gifr_reg_set)
    __swig_setmethods__["mcucr_reg"] = _pysimulavr.AvrDevice_at90s4433_mcucr_reg_set
    __swig_getmethods__["mcucr_reg"] = _pysimulavr.AvrDevice_at90s4433_mcucr_reg_get
    if _newclass:mcucr_reg = _swig_property(_pysimulavr.AvrDevice_at90s4433_mcucr_reg_get, _pysimulavr.AvrDevice_at90s4433_mcucr_reg_set)
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_at90s4433()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_at90s4433
    __del__ = lambda self : None;
AvrDevice_at90s4433_swigregister = _pysimulavr.AvrDevice_at90s4433_swigregister
AvrDevice_at90s4433_swigregister(AvrDevice_at90s4433)

class AvrDevice_at90s8515(AvrDevice):
    __swig_setmethods__ = {}
    for _s in [AvrDevice]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_at90s8515, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_at90s8515, name)
    __repr__ = _swig_repr
    __swig_setmethods__["porta"] = _pysimulavr.AvrDevice_at90s8515_porta_set
    __swig_getmethods__["porta"] = _pysimulavr.AvrDevice_at90s8515_porta_get
    if _newclass:porta = _swig_property(_pysimulavr.AvrDevice_at90s8515_porta_get, _pysimulavr.AvrDevice_at90s8515_porta_set)
    __swig_setmethods__["portb"] = _pysimulavr.AvrDevice_at90s8515_portb_set
    __swig_getmethods__["portb"] = _pysimulavr.AvrDevice_at90s8515_portb_get
    if _newclass:portb = _swig_property(_pysimulavr.AvrDevice_at90s8515_portb_get, _pysimulavr.AvrDevice_at90s8515_portb_set)
    __swig_setmethods__["portc"] = _pysimulavr.AvrDevice_at90s8515_portc_set
    __swig_getmethods__["portc"] = _pysimulavr.AvrDevice_at90s8515_portc_get
    if _newclass:portc = _swig_property(_pysimulavr.AvrDevice_at90s8515_portc_get, _pysimulavr.AvrDevice_at90s8515_portc_set)
    __swig_setmethods__["portd"] = _pysimulavr.AvrDevice_at90s8515_portd_set
    __swig_getmethods__["portd"] = _pysimulavr.AvrDevice_at90s8515_portd_get
    if _newclass:portd = _swig_property(_pysimulavr.AvrDevice_at90s8515_portd_get, _pysimulavr.AvrDevice_at90s8515_portd_set)
    __swig_setmethods__["ocr1b"] = _pysimulavr.AvrDevice_at90s8515_ocr1b_set
    __swig_getmethods__["ocr1b"] = _pysimulavr.AvrDevice_at90s8515_ocr1b_get
    if _newclass:ocr1b = _swig_property(_pysimulavr.AvrDevice_at90s8515_ocr1b_get, _pysimulavr.AvrDevice_at90s8515_ocr1b_set)
    __swig_setmethods__["spi"] = _pysimulavr.AvrDevice_at90s8515_spi_set
    __swig_getmethods__["spi"] = _pysimulavr.AvrDevice_at90s8515_spi_get
    if _newclass:spi = _swig_property(_pysimulavr.AvrDevice_at90s8515_spi_get, _pysimulavr.AvrDevice_at90s8515_spi_set)
    __swig_setmethods__["uart"] = _pysimulavr.AvrDevice_at90s8515_uart_set
    __swig_getmethods__["uart"] = _pysimulavr.AvrDevice_at90s8515_uart_get
    if _newclass:uart = _swig_property(_pysimulavr.AvrDevice_at90s8515_uart_get, _pysimulavr.AvrDevice_at90s8515_uart_set)
    __swig_setmethods__["acomp"] = _pysimulavr.AvrDevice_at90s8515_acomp_set
    __swig_getmethods__["acomp"] = _pysimulavr.AvrDevice_at90s8515_acomp_get
    if _newclass:acomp = _swig_property(_pysimulavr.AvrDevice_at90s8515_acomp_get, _pysimulavr.AvrDevice_at90s8515_acomp_set)
    __swig_setmethods__["prescaler"] = _pysimulavr.AvrDevice_at90s8515_prescaler_set
    __swig_getmethods__["prescaler"] = _pysimulavr.AvrDevice_at90s8515_prescaler_get
    if _newclass:prescaler = _swig_property(_pysimulavr.AvrDevice_at90s8515_prescaler_get, _pysimulavr.AvrDevice_at90s8515_prescaler_set)
    __swig_setmethods__["timer01irq"] = _pysimulavr.AvrDevice_at90s8515_timer01irq_set
    __swig_getmethods__["timer01irq"] = _pysimulavr.AvrDevice_at90s8515_timer01irq_get
    if _newclass:timer01irq = _swig_property(_pysimulavr.AvrDevice_at90s8515_timer01irq_get, _pysimulavr.AvrDevice_at90s8515_timer01irq_set)
    __swig_setmethods__["timer0"] = _pysimulavr.AvrDevice_at90s8515_timer0_set
    __swig_getmethods__["timer0"] = _pysimulavr.AvrDevice_at90s8515_timer0_get
    if _newclass:timer0 = _swig_property(_pysimulavr.AvrDevice_at90s8515_timer0_get, _pysimulavr.AvrDevice_at90s8515_timer0_set)
    __swig_setmethods__["inputCapture1"] = _pysimulavr.AvrDevice_at90s8515_inputCapture1_set
    __swig_getmethods__["inputCapture1"] = _pysimulavr.AvrDevice_at90s8515_inputCapture1_get
    if _newclass:inputCapture1 = _swig_property(_pysimulavr.AvrDevice_at90s8515_inputCapture1_get, _pysimulavr.AvrDevice_at90s8515_inputCapture1_set)
    __swig_setmethods__["timer1"] = _pysimulavr.AvrDevice_at90s8515_timer1_set
    __swig_getmethods__["timer1"] = _pysimulavr.AvrDevice_at90s8515_timer1_get
    if _newclass:timer1 = _swig_property(_pysimulavr.AvrDevice_at90s8515_timer1_get, _pysimulavr.AvrDevice_at90s8515_timer1_set)
    __swig_setmethods__["extirq"] = _pysimulavr.AvrDevice_at90s8515_extirq_set
    __swig_getmethods__["extirq"] = _pysimulavr.AvrDevice_at90s8515_extirq_get
    if _newclass:extirq = _swig_property(_pysimulavr.AvrDevice_at90s8515_extirq_get, _pysimulavr.AvrDevice_at90s8515_extirq_set)
    __swig_setmethods__["gimsk_reg"] = _pysimulavr.AvrDevice_at90s8515_gimsk_reg_set
    __swig_getmethods__["gimsk_reg"] = _pysimulavr.AvrDevice_at90s8515_gimsk_reg_get
    if _newclass:gimsk_reg = _swig_property(_pysimulavr.AvrDevice_at90s8515_gimsk_reg_get, _pysimulavr.AvrDevice_at90s8515_gimsk_reg_set)
    __swig_setmethods__["gifr_reg"] = _pysimulavr.AvrDevice_at90s8515_gifr_reg_set
    __swig_getmethods__["gifr_reg"] = _pysimulavr.AvrDevice_at90s8515_gifr_reg_get
    if _newclass:gifr_reg = _swig_property(_pysimulavr.AvrDevice_at90s8515_gifr_reg_get, _pysimulavr.AvrDevice_at90s8515_gifr_reg_set)
    __swig_setmethods__["mcucr_reg"] = _pysimulavr.AvrDevice_at90s8515_mcucr_reg_set
    __swig_getmethods__["mcucr_reg"] = _pysimulavr.AvrDevice_at90s8515_mcucr_reg_get
    if _newclass:mcucr_reg = _swig_property(_pysimulavr.AvrDevice_at90s8515_mcucr_reg_get, _pysimulavr.AvrDevice_at90s8515_mcucr_reg_set)
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_at90s8515()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_at90s8515
    __del__ = lambda self : None;
AvrDevice_at90s8515_swigregister = _pysimulavr.AvrDevice_at90s8515_swigregister
AvrDevice_at90s8515_swigregister(AvrDevice_at90s8515)

class AvrDevice_atmega668base(AvrDevice):
    __swig_setmethods__ = {}
    for _s in [AvrDevice]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_atmega668base, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_atmega668base, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _pysimulavr.new_AvrDevice_atmega668base(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_atmega668base
    __del__ = lambda self : None;
AvrDevice_atmega668base_swigregister = _pysimulavr.AvrDevice_atmega668base_swigregister
AvrDevice_atmega668base_swigregister(AvrDevice_atmega668base)

class AvrDevice_atmega328(AvrDevice_atmega668base):
    __swig_setmethods__ = {}
    for _s in [AvrDevice_atmega668base]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_atmega328, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice_atmega668base]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_atmega328, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_atmega328()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_atmega328
    __del__ = lambda self : None;
AvrDevice_atmega328_swigregister = _pysimulavr.AvrDevice_atmega328_swigregister
AvrDevice_atmega328_swigregister(AvrDevice_atmega328)

class AvrDevice_atmega168(AvrDevice_atmega668base):
    __swig_setmethods__ = {}
    for _s in [AvrDevice_atmega668base]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_atmega168, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice_atmega668base]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_atmega168, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_atmega168()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_atmega168
    __del__ = lambda self : None;
AvrDevice_atmega168_swigregister = _pysimulavr.AvrDevice_atmega168_swigregister
AvrDevice_atmega168_swigregister(AvrDevice_atmega168)

class AvrDevice_atmega88(AvrDevice_atmega668base):
    __swig_setmethods__ = {}
    for _s in [AvrDevice_atmega668base]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_atmega88, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice_atmega668base]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_atmega88, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_atmega88()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_atmega88
    __del__ = lambda self : None;
AvrDevice_atmega88_swigregister = _pysimulavr.AvrDevice_atmega88_swigregister
AvrDevice_atmega88_swigregister(AvrDevice_atmega88)

class AvrDevice_atmega48(AvrDevice_atmega668base):
    __swig_setmethods__ = {}
    for _s in [AvrDevice_atmega668base]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_atmega48, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice_atmega668base]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_atmega48, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_atmega48()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_atmega48
    __del__ = lambda self : None;
AvrDevice_atmega48_swigregister = _pysimulavr.AvrDevice_atmega48_swigregister
AvrDevice_atmega48_swigregister(AvrDevice_atmega48)

class AvrDevice_atmega16_32(AvrDevice):
    __swig_setmethods__ = {}
    for _s in [AvrDevice]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_atmega16_32, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_atmega16_32, name)
    __repr__ = _swig_repr
    __swig_setmethods__["aref"] = _pysimulavr.AvrDevice_atmega16_32_aref_set
    __swig_getmethods__["aref"] = _pysimulavr.AvrDevice_atmega16_32_aref_get
    if _newclass:aref = _swig_property(_pysimulavr.AvrDevice_atmega16_32_aref_get, _pysimulavr.AvrDevice_atmega16_32_aref_set)
    __swig_setmethods__["porta"] = _pysimulavr.AvrDevice_atmega16_32_porta_set
    __swig_getmethods__["porta"] = _pysimulavr.AvrDevice_atmega16_32_porta_get
    if _newclass:porta = _swig_property(_pysimulavr.AvrDevice_atmega16_32_porta_get, _pysimulavr.AvrDevice_atmega16_32_porta_set)
    __swig_setmethods__["portb"] = _pysimulavr.AvrDevice_atmega16_32_portb_set
    __swig_getmethods__["portb"] = _pysimulavr.AvrDevice_atmega16_32_portb_get
    if _newclass:portb = _swig_property(_pysimulavr.AvrDevice_atmega16_32_portb_get, _pysimulavr.AvrDevice_atmega16_32_portb_set)
    __swig_setmethods__["portc"] = _pysimulavr.AvrDevice_atmega16_32_portc_set
    __swig_getmethods__["portc"] = _pysimulavr.AvrDevice_atmega16_32_portc_get
    if _newclass:portc = _swig_property(_pysimulavr.AvrDevice_atmega16_32_portc_get, _pysimulavr.AvrDevice_atmega16_32_portc_set)
    __swig_setmethods__["portd"] = _pysimulavr.AvrDevice_atmega16_32_portd_set
    __swig_getmethods__["portd"] = _pysimulavr.AvrDevice_atmega16_32_portd_get
    if _newclass:portd = _swig_property(_pysimulavr.AvrDevice_atmega16_32_portd_get, _pysimulavr.AvrDevice_atmega16_32_portd_set)
    __swig_setmethods__["extirq"] = _pysimulavr.AvrDevice_atmega16_32_extirq_set
    __swig_getmethods__["extirq"] = _pysimulavr.AvrDevice_atmega16_32_extirq_get
    if _newclass:extirq = _swig_property(_pysimulavr.AvrDevice_atmega16_32_extirq_get, _pysimulavr.AvrDevice_atmega16_32_extirq_set)
    __swig_setmethods__["gicr_reg"] = _pysimulavr.AvrDevice_atmega16_32_gicr_reg_set
    __swig_getmethods__["gicr_reg"] = _pysimulavr.AvrDevice_atmega16_32_gicr_reg_get
    if _newclass:gicr_reg = _swig_property(_pysimulavr.AvrDevice_atmega16_32_gicr_reg_get, _pysimulavr.AvrDevice_atmega16_32_gicr_reg_set)
    __swig_setmethods__["gifr_reg"] = _pysimulavr.AvrDevice_atmega16_32_gifr_reg_set
    __swig_getmethods__["gifr_reg"] = _pysimulavr.AvrDevice_atmega16_32_gifr_reg_get
    if _newclass:gifr_reg = _swig_property(_pysimulavr.AvrDevice_atmega16_32_gifr_reg_get, _pysimulavr.AvrDevice_atmega16_32_gifr_reg_set)
    __swig_setmethods__["mcucr_reg"] = _pysimulavr.AvrDevice_atmega16_32_mcucr_reg_set
    __swig_getmethods__["mcucr_reg"] = _pysimulavr.AvrDevice_atmega16_32_mcucr_reg_get
    if _newclass:mcucr_reg = _swig_property(_pysimulavr.AvrDevice_atmega16_32_mcucr_reg_get, _pysimulavr.AvrDevice_atmega16_32_mcucr_reg_set)
    __swig_setmethods__["mcucsr_reg"] = _pysimulavr.AvrDevice_atmega16_32_mcucsr_reg_set
    __swig_getmethods__["mcucsr_reg"] = _pysimulavr.AvrDevice_atmega16_32_mcucsr_reg_get
    if _newclass:mcucsr_reg = _swig_property(_pysimulavr.AvrDevice_atmega16_32_mcucsr_reg_get, _pysimulavr.AvrDevice_atmega16_32_mcucsr_reg_set)
    __swig_setmethods__["admux"] = _pysimulavr.AvrDevice_atmega16_32_admux_set
    __swig_getmethods__["admux"] = _pysimulavr.AvrDevice_atmega16_32_admux_get
    if _newclass:admux = _swig_property(_pysimulavr.AvrDevice_atmega16_32_admux_get, _pysimulavr.AvrDevice_atmega16_32_admux_set)
    __swig_setmethods__["ad"] = _pysimulavr.AvrDevice_atmega16_32_ad_set
    __swig_getmethods__["ad"] = _pysimulavr.AvrDevice_atmega16_32_ad_get
    if _newclass:ad = _swig_property(_pysimulavr.AvrDevice_atmega16_32_ad_get, _pysimulavr.AvrDevice_atmega16_32_ad_set)
    __swig_setmethods__["assr_reg"] = _pysimulavr.AvrDevice_atmega16_32_assr_reg_set
    __swig_getmethods__["assr_reg"] = _pysimulavr.AvrDevice_atmega16_32_assr_reg_get
    if _newclass:assr_reg = _swig_property(_pysimulavr.AvrDevice_atmega16_32_assr_reg_get, _pysimulavr.AvrDevice_atmega16_32_assr_reg_set)
    __swig_setmethods__["sfior_reg"] = _pysimulavr.AvrDevice_atmega16_32_sfior_reg_set
    __swig_getmethods__["sfior_reg"] = _pysimulavr.AvrDevice_atmega16_32_sfior_reg_get
    if _newclass:sfior_reg = _swig_property(_pysimulavr.AvrDevice_atmega16_32_sfior_reg_get, _pysimulavr.AvrDevice_atmega16_32_sfior_reg_set)
    __swig_setmethods__["prescaler01"] = _pysimulavr.AvrDevice_atmega16_32_prescaler01_set
    __swig_getmethods__["prescaler01"] = _pysimulavr.AvrDevice_atmega16_32_prescaler01_get
    if _newclass:prescaler01 = _swig_property(_pysimulavr.AvrDevice_atmega16_32_prescaler01_get, _pysimulavr.AvrDevice_atmega16_32_prescaler01_set)
    __swig_setmethods__["prescaler2"] = _pysimulavr.AvrDevice_atmega16_32_prescaler2_set
    __swig_getmethods__["prescaler2"] = _pysimulavr.AvrDevice_atmega16_32_prescaler2_get
    if _newclass:prescaler2 = _swig_property(_pysimulavr.AvrDevice_atmega16_32_prescaler2_get, _pysimulavr.AvrDevice_atmega16_32_prescaler2_set)
    __swig_setmethods__["inputCapture1"] = _pysimulavr.AvrDevice_atmega16_32_inputCapture1_set
    __swig_getmethods__["inputCapture1"] = _pysimulavr.AvrDevice_atmega16_32_inputCapture1_get
    if _newclass:inputCapture1 = _swig_property(_pysimulavr.AvrDevice_atmega16_32_inputCapture1_get, _pysimulavr.AvrDevice_atmega16_32_inputCapture1_set)
    __swig_setmethods__["timer0"] = _pysimulavr.AvrDevice_atmega16_32_timer0_set
    __swig_getmethods__["timer0"] = _pysimulavr.AvrDevice_atmega16_32_timer0_get
    if _newclass:timer0 = _swig_property(_pysimulavr.AvrDevice_atmega16_32_timer0_get, _pysimulavr.AvrDevice_atmega16_32_timer0_set)
    __swig_setmethods__["timer1"] = _pysimulavr.AvrDevice_atmega16_32_timer1_set
    __swig_getmethods__["timer1"] = _pysimulavr.AvrDevice_atmega16_32_timer1_get
    if _newclass:timer1 = _swig_property(_pysimulavr.AvrDevice_atmega16_32_timer1_get, _pysimulavr.AvrDevice_atmega16_32_timer1_set)
    __swig_setmethods__["timer2"] = _pysimulavr.AvrDevice_atmega16_32_timer2_set
    __swig_getmethods__["timer2"] = _pysimulavr.AvrDevice_atmega16_32_timer2_get
    if _newclass:timer2 = _swig_property(_pysimulavr.AvrDevice_atmega16_32_timer2_get, _pysimulavr.AvrDevice_atmega16_32_timer2_set)
    __swig_setmethods__["timer012irq"] = _pysimulavr.AvrDevice_atmega16_32_timer012irq_set
    __swig_getmethods__["timer012irq"] = _pysimulavr.AvrDevice_atmega16_32_timer012irq_get
    if _newclass:timer012irq = _swig_property(_pysimulavr.AvrDevice_atmega16_32_timer012irq_get, _pysimulavr.AvrDevice_atmega16_32_timer012irq_set)
    __swig_setmethods__["spi"] = _pysimulavr.AvrDevice_atmega16_32_spi_set
    __swig_getmethods__["spi"] = _pysimulavr.AvrDevice_atmega16_32_spi_get
    if _newclass:spi = _swig_property(_pysimulavr.AvrDevice_atmega16_32_spi_get, _pysimulavr.AvrDevice_atmega16_32_spi_set)
    __swig_setmethods__["usart"] = _pysimulavr.AvrDevice_atmega16_32_usart_set
    __swig_getmethods__["usart"] = _pysimulavr.AvrDevice_atmega16_32_usart_get
    if _newclass:usart = _swig_property(_pysimulavr.AvrDevice_atmega16_32_usart_get, _pysimulavr.AvrDevice_atmega16_32_usart_set)
    def __init__(self, *args): 
        this = _pysimulavr.new_AvrDevice_atmega16_32(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_atmega16_32
    __del__ = lambda self : None;
AvrDevice_atmega16_32_swigregister = _pysimulavr.AvrDevice_atmega16_32_swigregister
AvrDevice_atmega16_32_swigregister(AvrDevice_atmega16_32)

class AvrDevice_atmega16(AvrDevice_atmega16_32):
    __swig_setmethods__ = {}
    for _s in [AvrDevice_atmega16_32]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_atmega16, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice_atmega16_32]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_atmega16, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_atmega16()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_atmega16
    __del__ = lambda self : None;
AvrDevice_atmega16_swigregister = _pysimulavr.AvrDevice_atmega16_swigregister
AvrDevice_atmega16_swigregister(AvrDevice_atmega16)

class AvrDevice_atmega32(AvrDevice_atmega16_32):
    __swig_setmethods__ = {}
    for _s in [AvrDevice_atmega16_32]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_atmega32, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice_atmega16_32]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_atmega32, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_atmega32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_atmega32
    __del__ = lambda self : None;
AvrDevice_atmega32_swigregister = _pysimulavr.AvrDevice_atmega32_swigregister
AvrDevice_atmega32_swigregister(AvrDevice_atmega32)

class AvrDevice_attiny2313(AvrDevice):
    __swig_setmethods__ = {}
    for _s in [AvrDevice]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AvrDevice_attiny2313, name, value)
    __swig_getmethods__ = {}
    for _s in [AvrDevice]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AvrDevice_attiny2313, name)
    __repr__ = _swig_repr
    __swig_setmethods__["porta"] = _pysimulavr.AvrDevice_attiny2313_porta_set
    __swig_getmethods__["porta"] = _pysimulavr.AvrDevice_attiny2313_porta_get
    if _newclass:porta = _swig_property(_pysimulavr.AvrDevice_attiny2313_porta_get, _pysimulavr.AvrDevice_attiny2313_porta_set)
    __swig_setmethods__["portb"] = _pysimulavr.AvrDevice_attiny2313_portb_set
    __swig_getmethods__["portb"] = _pysimulavr.AvrDevice_attiny2313_portb_get
    if _newclass:portb = _swig_property(_pysimulavr.AvrDevice_attiny2313_portb_get, _pysimulavr.AvrDevice_attiny2313_portb_set)
    __swig_setmethods__["portd"] = _pysimulavr.AvrDevice_attiny2313_portd_set
    __swig_getmethods__["portd"] = _pysimulavr.AvrDevice_attiny2313_portd_get
    if _newclass:portd = _swig_property(_pysimulavr.AvrDevice_attiny2313_portd_get, _pysimulavr.AvrDevice_attiny2313_portd_set)
    __swig_setmethods__["gtccr_reg"] = _pysimulavr.AvrDevice_attiny2313_gtccr_reg_set
    __swig_getmethods__["gtccr_reg"] = _pysimulavr.AvrDevice_attiny2313_gtccr_reg_get
    if _newclass:gtccr_reg = _swig_property(_pysimulavr.AvrDevice_attiny2313_gtccr_reg_get, _pysimulavr.AvrDevice_attiny2313_gtccr_reg_set)
    __swig_setmethods__["gpior0_reg"] = _pysimulavr.AvrDevice_attiny2313_gpior0_reg_set
    __swig_getmethods__["gpior0_reg"] = _pysimulavr.AvrDevice_attiny2313_gpior0_reg_get
    if _newclass:gpior0_reg = _swig_property(_pysimulavr.AvrDevice_attiny2313_gpior0_reg_get, _pysimulavr.AvrDevice_attiny2313_gpior0_reg_set)
    __swig_setmethods__["gpior1_reg"] = _pysimulavr.AvrDevice_attiny2313_gpior1_reg_set
    __swig_getmethods__["gpior1_reg"] = _pysimulavr.AvrDevice_attiny2313_gpior1_reg_get
    if _newclass:gpior1_reg = _swig_property(_pysimulavr.AvrDevice_attiny2313_gpior1_reg_get, _pysimulavr.AvrDevice_attiny2313_gpior1_reg_set)
    __swig_setmethods__["gpior2_reg"] = _pysimulavr.AvrDevice_attiny2313_gpior2_reg_set
    __swig_getmethods__["gpior2_reg"] = _pysimulavr.AvrDevice_attiny2313_gpior2_reg_get
    if _newclass:gpior2_reg = _swig_property(_pysimulavr.AvrDevice_attiny2313_gpior2_reg_get, _pysimulavr.AvrDevice_attiny2313_gpior2_reg_set)
    __swig_setmethods__["extirq"] = _pysimulavr.AvrDevice_attiny2313_extirq_set
    __swig_getmethods__["extirq"] = _pysimulavr.AvrDevice_attiny2313_extirq_get
    if _newclass:extirq = _swig_property(_pysimulavr.AvrDevice_attiny2313_extirq_get, _pysimulavr.AvrDevice_attiny2313_extirq_set)
    __swig_setmethods__["gimsk_reg"] = _pysimulavr.AvrDevice_attiny2313_gimsk_reg_set
    __swig_getmethods__["gimsk_reg"] = _pysimulavr.AvrDevice_attiny2313_gimsk_reg_get
    if _newclass:gimsk_reg = _swig_property(_pysimulavr.AvrDevice_attiny2313_gimsk_reg_get, _pysimulavr.AvrDevice_attiny2313_gimsk_reg_set)
    __swig_setmethods__["eifr_reg"] = _pysimulavr.AvrDevice_attiny2313_eifr_reg_set
    __swig_getmethods__["eifr_reg"] = _pysimulavr.AvrDevice_attiny2313_eifr_reg_get
    if _newclass:eifr_reg = _swig_property(_pysimulavr.AvrDevice_attiny2313_eifr_reg_get, _pysimulavr.AvrDevice_attiny2313_eifr_reg_set)
    __swig_setmethods__["mcucr_reg"] = _pysimulavr.AvrDevice_attiny2313_mcucr_reg_set
    __swig_getmethods__["mcucr_reg"] = _pysimulavr.AvrDevice_attiny2313_mcucr_reg_get
    if _newclass:mcucr_reg = _swig_property(_pysimulavr.AvrDevice_attiny2313_mcucr_reg_get, _pysimulavr.AvrDevice_attiny2313_mcucr_reg_set)
    __swig_setmethods__["pcmsk_reg"] = _pysimulavr.AvrDevice_attiny2313_pcmsk_reg_set
    __swig_getmethods__["pcmsk_reg"] = _pysimulavr.AvrDevice_attiny2313_pcmsk_reg_get
    if _newclass:pcmsk_reg = _swig_property(_pysimulavr.AvrDevice_attiny2313_pcmsk_reg_get, _pysimulavr.AvrDevice_attiny2313_pcmsk_reg_set)
    __swig_setmethods__["prescaler01"] = _pysimulavr.AvrDevice_attiny2313_prescaler01_set
    __swig_getmethods__["prescaler01"] = _pysimulavr.AvrDevice_attiny2313_prescaler01_get
    if _newclass:prescaler01 = _swig_property(_pysimulavr.AvrDevice_attiny2313_prescaler01_get, _pysimulavr.AvrDevice_attiny2313_prescaler01_set)
    __swig_setmethods__["inputCapture1"] = _pysimulavr.AvrDevice_attiny2313_inputCapture1_set
    __swig_getmethods__["inputCapture1"] = _pysimulavr.AvrDevice_attiny2313_inputCapture1_get
    if _newclass:inputCapture1 = _swig_property(_pysimulavr.AvrDevice_attiny2313_inputCapture1_get, _pysimulavr.AvrDevice_attiny2313_inputCapture1_set)
    __swig_setmethods__["timer0"] = _pysimulavr.AvrDevice_attiny2313_timer0_set
    __swig_getmethods__["timer0"] = _pysimulavr.AvrDevice_attiny2313_timer0_get
    if _newclass:timer0 = _swig_property(_pysimulavr.AvrDevice_attiny2313_timer0_get, _pysimulavr.AvrDevice_attiny2313_timer0_set)
    __swig_setmethods__["timer1"] = _pysimulavr.AvrDevice_attiny2313_timer1_set
    __swig_getmethods__["timer1"] = _pysimulavr.AvrDevice_attiny2313_timer1_get
    if _newclass:timer1 = _swig_property(_pysimulavr.AvrDevice_attiny2313_timer1_get, _pysimulavr.AvrDevice_attiny2313_timer1_set)
    __swig_setmethods__["timer01irq"] = _pysimulavr.AvrDevice_attiny2313_timer01irq_set
    __swig_getmethods__["timer01irq"] = _pysimulavr.AvrDevice_attiny2313_timer01irq_get
    if _newclass:timer01irq = _swig_property(_pysimulavr.AvrDevice_attiny2313_timer01irq_get, _pysimulavr.AvrDevice_attiny2313_timer01irq_set)
    __swig_setmethods__["usart"] = _pysimulavr.AvrDevice_attiny2313_usart_set
    __swig_getmethods__["usart"] = _pysimulavr.AvrDevice_attiny2313_usart_get
    if _newclass:usart = _swig_property(_pysimulavr.AvrDevice_attiny2313_usart_get, _pysimulavr.AvrDevice_attiny2313_usart_set)
    def __init__(self): 
        this = _pysimulavr.new_AvrDevice_attiny2313()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pysimulavr.delete_AvrDevice_attiny2313
    __del__ = lambda self : None;
AvrDevice_attiny2313_swigregister = _pysimulavr.AvrDevice_attiny2313_swigregister
AvrDevice_attiny2313_swigregister(AvrDevice_attiny2313)



