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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _dtv_swig0
else:
    import _dtv_swig0

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



def high_res_timer_now() -> "gr::high_res_timer_type":
    r"""high_res_timer_now() -> gr::high_res_timer_type"""
    return _dtv_swig0.high_res_timer_now()

def high_res_timer_now_perfmon() -> "gr::high_res_timer_type":
    r"""high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
    return _dtv_swig0.high_res_timer_now_perfmon()

def high_res_timer_tps() -> "gr::high_res_timer_type":
    r"""high_res_timer_tps() -> gr::high_res_timer_type"""
    return _dtv_swig0.high_res_timer_tps()

def high_res_timer_epoch() -> "gr::high_res_timer_type":
    r"""high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _dtv_swig0.high_res_timer_epoch()
class atsc_deinterleaver(object):
    r"""Proxy of C++ gr::dtv::atsc_deinterleaver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_deinterleaver::sptr":
        r"""make() -> atsc_deinterleaver_sptr"""
        return _dtv_swig0.atsc_deinterleaver_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_deinterleaver

# Register atsc_deinterleaver in _dtv_swig0:
_dtv_swig0.atsc_deinterleaver_swigregister(atsc_deinterleaver)

def atsc_deinterleaver_make() -> "gr::dtv::atsc_deinterleaver::sptr":
    r"""atsc_deinterleaver_make() -> atsc_deinterleaver_sptr"""
    return _dtv_swig0.atsc_deinterleaver_make()

class atsc_depad(object):
    r"""Proxy of C++ gr::dtv::atsc_depad class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_depad::sptr":
        r"""make() -> atsc_depad_sptr"""
        return _dtv_swig0.atsc_depad_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_depad

# Register atsc_depad in _dtv_swig0:
_dtv_swig0.atsc_depad_swigregister(atsc_depad)

def atsc_depad_make() -> "gr::dtv::atsc_depad::sptr":
    r"""atsc_depad_make() -> atsc_depad_sptr"""
    return _dtv_swig0.atsc_depad_make()

class atsc_derandomizer(object):
    r"""Proxy of C++ gr::dtv::atsc_derandomizer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_derandomizer::sptr":
        r"""make() -> atsc_derandomizer_sptr"""
        return _dtv_swig0.atsc_derandomizer_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_derandomizer

# Register atsc_derandomizer in _dtv_swig0:
_dtv_swig0.atsc_derandomizer_swigregister(atsc_derandomizer)

def atsc_derandomizer_make() -> "gr::dtv::atsc_derandomizer::sptr":
    r"""atsc_derandomizer_make() -> atsc_derandomizer_sptr"""
    return _dtv_swig0.atsc_derandomizer_make()

class atsc_equalizer(object):
    r"""Proxy of C++ gr::dtv::atsc_equalizer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_equalizer::sptr":
        r"""make() -> atsc_equalizer_sptr"""
        return _dtv_swig0.atsc_equalizer_make()

    def taps(self) -> "std::vector< float,std::allocator< float > >":
        r"""taps(atsc_equalizer self) -> pmt_vector_float"""
        return _dtv_swig0.atsc_equalizer_taps(self)

    def data(self) -> "std::vector< float,std::allocator< float > >":
        r"""data(atsc_equalizer self) -> pmt_vector_float"""
        return _dtv_swig0.atsc_equalizer_data(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_equalizer

# Register atsc_equalizer in _dtv_swig0:
_dtv_swig0.atsc_equalizer_swigregister(atsc_equalizer)

def atsc_equalizer_make() -> "gr::dtv::atsc_equalizer::sptr":
    r"""atsc_equalizer_make() -> atsc_equalizer_sptr"""
    return _dtv_swig0.atsc_equalizer_make()

class atsc_field_sync_mux(object):
    r"""Proxy of C++ gr::dtv::atsc_field_sync_mux class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_field_sync_mux::sptr":
        r"""make() -> atsc_field_sync_mux_sptr"""
        return _dtv_swig0.atsc_field_sync_mux_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_field_sync_mux

# Register atsc_field_sync_mux in _dtv_swig0:
_dtv_swig0.atsc_field_sync_mux_swigregister(atsc_field_sync_mux)

def atsc_field_sync_mux_make() -> "gr::dtv::atsc_field_sync_mux::sptr":
    r"""atsc_field_sync_mux_make() -> atsc_field_sync_mux_sptr"""
    return _dtv_swig0.atsc_field_sync_mux_make()

class atsc_fpll(object):
    r"""Proxy of C++ gr::dtv::atsc_fpll class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(rate: "float") -> "gr::dtv::atsc_fpll::sptr":
        r"""make(float rate) -> atsc_fpll_sptr"""
        return _dtv_swig0.atsc_fpll_make(rate)
    __swig_destroy__ = _dtv_swig0.delete_atsc_fpll

# Register atsc_fpll in _dtv_swig0:
_dtv_swig0.atsc_fpll_swigregister(atsc_fpll)

def atsc_fpll_make(rate: "float") -> "gr::dtv::atsc_fpll::sptr":
    r"""atsc_fpll_make(float rate) -> atsc_fpll_sptr"""
    return _dtv_swig0.atsc_fpll_make(rate)

class atsc_fs_checker(object):
    r"""Proxy of C++ gr::dtv::atsc_fs_checker class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_fs_checker::sptr":
        r"""make() -> atsc_fs_checker_sptr"""
        return _dtv_swig0.atsc_fs_checker_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_fs_checker

# Register atsc_fs_checker in _dtv_swig0:
_dtv_swig0.atsc_fs_checker_swigregister(atsc_fs_checker)

def atsc_fs_checker_make() -> "gr::dtv::atsc_fs_checker::sptr":
    r"""atsc_fs_checker_make() -> atsc_fs_checker_sptr"""
    return _dtv_swig0.atsc_fs_checker_make()

class atsc_interleaver(object):
    r"""Proxy of C++ gr::dtv::atsc_interleaver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_interleaver::sptr":
        r"""make() -> atsc_interleaver_sptr"""
        return _dtv_swig0.atsc_interleaver_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_interleaver

# Register atsc_interleaver in _dtv_swig0:
_dtv_swig0.atsc_interleaver_swigregister(atsc_interleaver)

def atsc_interleaver_make() -> "gr::dtv::atsc_interleaver::sptr":
    r"""atsc_interleaver_make() -> atsc_interleaver_sptr"""
    return _dtv_swig0.atsc_interleaver_make()

class atsc_pad(object):
    r"""Proxy of C++ gr::dtv::atsc_pad class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_pad::sptr":
        r"""make() -> atsc_pad_sptr"""
        return _dtv_swig0.atsc_pad_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_pad

# Register atsc_pad in _dtv_swig0:
_dtv_swig0.atsc_pad_swigregister(atsc_pad)

def atsc_pad_make() -> "gr::dtv::atsc_pad::sptr":
    r"""atsc_pad_make() -> atsc_pad_sptr"""
    return _dtv_swig0.atsc_pad_make()

class atsc_randomizer(object):
    r"""Proxy of C++ gr::dtv::atsc_randomizer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_randomizer::sptr":
        r"""make() -> atsc_randomizer_sptr"""
        return _dtv_swig0.atsc_randomizer_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_randomizer

# Register atsc_randomizer in _dtv_swig0:
_dtv_swig0.atsc_randomizer_swigregister(atsc_randomizer)

def atsc_randomizer_make() -> "gr::dtv::atsc_randomizer::sptr":
    r"""atsc_randomizer_make() -> atsc_randomizer_sptr"""
    return _dtv_swig0.atsc_randomizer_make()

class atsc_rs_decoder(object):
    r"""Proxy of C++ gr::dtv::atsc_rs_decoder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def num_errors_corrected(self) -> "int":
        r"""num_errors_corrected(atsc_rs_decoder self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_num_errors_corrected(self)

    def num_bad_packets(self) -> "int":
        r"""num_bad_packets(atsc_rs_decoder self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_num_bad_packets(self)

    def num_packets(self) -> "int":
        r"""num_packets(atsc_rs_decoder self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_num_packets(self)

    @staticmethod
    def make() -> "gr::dtv::atsc_rs_decoder::sptr":
        r"""make() -> atsc_rs_decoder_sptr"""
        return _dtv_swig0.atsc_rs_decoder_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_rs_decoder

# Register atsc_rs_decoder in _dtv_swig0:
_dtv_swig0.atsc_rs_decoder_swigregister(atsc_rs_decoder)

def atsc_rs_decoder_make() -> "gr::dtv::atsc_rs_decoder::sptr":
    r"""atsc_rs_decoder_make() -> atsc_rs_decoder_sptr"""
    return _dtv_swig0.atsc_rs_decoder_make()

class atsc_rs_encoder(object):
    r"""Proxy of C++ gr::dtv::atsc_rs_encoder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_rs_encoder::sptr":
        r"""make() -> atsc_rs_encoder_sptr"""
        return _dtv_swig0.atsc_rs_encoder_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_rs_encoder

# Register atsc_rs_encoder in _dtv_swig0:
_dtv_swig0.atsc_rs_encoder_swigregister(atsc_rs_encoder)

def atsc_rs_encoder_make() -> "gr::dtv::atsc_rs_encoder::sptr":
    r"""atsc_rs_encoder_make() -> atsc_rs_encoder_sptr"""
    return _dtv_swig0.atsc_rs_encoder_make()

class atsc_sync(object):
    r"""Proxy of C++ gr::dtv::atsc_sync class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(rate: "float") -> "gr::dtv::atsc_sync::sptr":
        r"""make(float rate) -> atsc_sync_sptr"""
        return _dtv_swig0.atsc_sync_make(rate)
    __swig_destroy__ = _dtv_swig0.delete_atsc_sync

# Register atsc_sync in _dtv_swig0:
_dtv_swig0.atsc_sync_swigregister(atsc_sync)

def atsc_sync_make(rate: "float") -> "gr::dtv::atsc_sync::sptr":
    r"""atsc_sync_make(float rate) -> atsc_sync_sptr"""
    return _dtv_swig0.atsc_sync_make(rate)

class atsc_trellis_encoder(object):
    r"""Proxy of C++ gr::dtv::atsc_trellis_encoder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_trellis_encoder::sptr":
        r"""make() -> atsc_trellis_encoder_sptr"""
        return _dtv_swig0.atsc_trellis_encoder_make()
    __swig_destroy__ = _dtv_swig0.delete_atsc_trellis_encoder

# Register atsc_trellis_encoder in _dtv_swig0:
_dtv_swig0.atsc_trellis_encoder_swigregister(atsc_trellis_encoder)

def atsc_trellis_encoder_make() -> "gr::dtv::atsc_trellis_encoder::sptr":
    r"""atsc_trellis_encoder_make() -> atsc_trellis_encoder_sptr"""
    return _dtv_swig0.atsc_trellis_encoder_make()

class atsc_viterbi_decoder(object):
    r"""Proxy of C++ gr::dtv::atsc_viterbi_decoder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::atsc_viterbi_decoder::sptr":
        r"""make() -> atsc_viterbi_decoder_sptr"""
        return _dtv_swig0.atsc_viterbi_decoder_make()

    def decoder_metrics(self) -> "std::vector< float,std::allocator< float > >":
        r"""decoder_metrics(atsc_viterbi_decoder self) -> pmt_vector_float"""
        return _dtv_swig0.atsc_viterbi_decoder_decoder_metrics(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_viterbi_decoder

# Register atsc_viterbi_decoder in _dtv_swig0:
_dtv_swig0.atsc_viterbi_decoder_swigregister(atsc_viterbi_decoder)

def atsc_viterbi_decoder_make() -> "gr::dtv::atsc_viterbi_decoder::sptr":
    r"""atsc_viterbi_decoder_make() -> atsc_viterbi_decoder_sptr"""
    return _dtv_swig0.atsc_viterbi_decoder_make()

CATV_MOD_64QAM = _dtv_swig0.CATV_MOD_64QAM

CATV_MOD_256QAM = _dtv_swig0.CATV_MOD_256QAM

class catv_transport_framing_enc_bb(object):
    r"""Proxy of C++ gr::dtv::catv_transport_framing_enc_bb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::catv_transport_framing_enc_bb::sptr":
        r"""make() -> catv_transport_framing_enc_bb_sptr"""
        return _dtv_swig0.catv_transport_framing_enc_bb_make()
    __swig_destroy__ = _dtv_swig0.delete_catv_transport_framing_enc_bb

# Register catv_transport_framing_enc_bb in _dtv_swig0:
_dtv_swig0.catv_transport_framing_enc_bb_swigregister(catv_transport_framing_enc_bb)

def catv_transport_framing_enc_bb_make() -> "gr::dtv::catv_transport_framing_enc_bb::sptr":
    r"""catv_transport_framing_enc_bb_make() -> catv_transport_framing_enc_bb_sptr"""
    return _dtv_swig0.catv_transport_framing_enc_bb_make()

class catv_reed_solomon_enc_bb(object):
    r"""Proxy of C++ gr::dtv::catv_reed_solomon_enc_bb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::dtv::catv_reed_solomon_enc_bb::sptr":
        r"""make() -> catv_reed_solomon_enc_bb_sptr"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_make()
    __swig_destroy__ = _dtv_swig0.delete_catv_reed_solomon_enc_bb

# Register catv_reed_solomon_enc_bb in _dtv_swig0:
_dtv_swig0.catv_reed_solomon_enc_bb_swigregister(catv_reed_solomon_enc_bb)

def catv_reed_solomon_enc_bb_make() -> "gr::dtv::catv_reed_solomon_enc_bb::sptr":
    r"""catv_reed_solomon_enc_bb_make() -> catv_reed_solomon_enc_bb_sptr"""
    return _dtv_swig0.catv_reed_solomon_enc_bb_make()

class catv_randomizer_bb(object):
    r"""Proxy of C++ gr::dtv::catv_randomizer_bb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(constellation: "gr::dtv::catv_constellation_t") -> "gr::dtv::catv_randomizer_bb::sptr":
        r"""make(gr::dtv::catv_constellation_t constellation) -> catv_randomizer_bb_sptr"""
        return _dtv_swig0.catv_randomizer_bb_make(constellation)
    __swig_destroy__ = _dtv_swig0.delete_catv_randomizer_bb

# Register catv_randomizer_bb in _dtv_swig0:
_dtv_swig0.catv_randomizer_bb_swigregister(catv_randomizer_bb)

def catv_randomizer_bb_make(constellation: "gr::dtv::catv_constellation_t") -> "gr::dtv::catv_randomizer_bb::sptr":
    r"""catv_randomizer_bb_make(gr::dtv::catv_constellation_t constellation) -> catv_randomizer_bb_sptr"""
    return _dtv_swig0.catv_randomizer_bb_make(constellation)

class catv_frame_sync_enc_bb(object):
    r"""Proxy of C++ gr::dtv::catv_frame_sync_enc_bb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(constellation: "gr::dtv::catv_constellation_t", ctrlword: "int") -> "gr::dtv::catv_frame_sync_enc_bb::sptr":
        r"""make(gr::dtv::catv_constellation_t constellation, int ctrlword) -> catv_frame_sync_enc_bb_sptr"""
        return _dtv_swig0.catv_frame_sync_enc_bb_make(constellation, ctrlword)
    __swig_destroy__ = _dtv_swig0.delete_catv_frame_sync_enc_bb

# Register catv_frame_sync_enc_bb in _dtv_swig0:
_dtv_swig0.catv_frame_sync_enc_bb_swigregister(catv_frame_sync_enc_bb)

def catv_frame_sync_enc_bb_make(constellation: "gr::dtv::catv_constellation_t", ctrlword: "int") -> "gr::dtv::catv_frame_sync_enc_bb::sptr":
    r"""catv_frame_sync_enc_bb_make(gr::dtv::catv_constellation_t constellation, int ctrlword) -> catv_frame_sync_enc_bb_sptr"""
    return _dtv_swig0.catv_frame_sync_enc_bb_make(constellation, ctrlword)

class catv_trellis_enc_bb(object):
    r"""Proxy of C++ gr::dtv::catv_trellis_enc_bb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(constellation: "gr::dtv::catv_constellation_t") -> "gr::dtv::catv_trellis_enc_bb::sptr":
        r"""make(gr::dtv::catv_constellation_t constellation) -> catv_trellis_enc_bb_sptr"""
        return _dtv_swig0.catv_trellis_enc_bb_make(constellation)
    __swig_destroy__ = _dtv_swig0.delete_catv_trellis_enc_bb

# Register catv_trellis_enc_bb in _dtv_swig0:
_dtv_swig0.catv_trellis_enc_bb_swigregister(catv_trellis_enc_bb)

def catv_trellis_enc_bb_make(constellation: "gr::dtv::catv_constellation_t") -> "gr::dtv::catv_trellis_enc_bb::sptr":
    r"""catv_trellis_enc_bb_make(gr::dtv::catv_constellation_t constellation) -> catv_trellis_enc_bb_sptr"""
    return _dtv_swig0.catv_trellis_enc_bb_make(constellation)

class atsc_deinterleaver_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_deinterleaver > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_deinterleaver_sptr self) -> atsc_deinterleaver_sptr
        __init__(atsc_deinterleaver_sptr self, atsc_deinterleaver p) -> atsc_deinterleaver_sptr
        """
        _dtv_swig0.atsc_deinterleaver_sptr_swiginit(self, _dtv_swig0.new_atsc_deinterleaver_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_deinterleaver *":
        r"""__deref__(atsc_deinterleaver_sptr self) -> atsc_deinterleaver"""
        return _dtv_swig0.atsc_deinterleaver_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_deinterleaver_sptr

    def make(self) -> "gr::dtv::atsc_deinterleaver::sptr":
        r"""make(atsc_deinterleaver_sptr self) -> atsc_deinterleaver_sptr"""
        return _dtv_swig0.atsc_deinterleaver_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_deinterleaver_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_deinterleaver_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_deinterleaver_sptr self, int which, int delay)
        declare_sample_delay(atsc_deinterleaver_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_deinterleaver_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_deinterleaver_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_deinterleaver_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_deinterleaver_sptr self, int multiple)"""
        return _dtv_swig0.atsc_deinterleaver_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_deinterleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_deinterleaver_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_deinterleaver_sptr self) -> double"""
        return _dtv_swig0.atsc_deinterleaver_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_deinterleaver_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_deinterleaver_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_deinterleaver_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_deinterleaver_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_deinterleaver_sptr self) -> bool"""
        return _dtv_swig0.atsc_deinterleaver_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_deinterleaver_sptr self) -> bool"""
        return _dtv_swig0.atsc_deinterleaver_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_deinterleaver_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_deinterleaver_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_deinterleaver_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_deinterleaver_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_deinterleaver_sptr self, std::string level)"""
        return _dtv_swig0.atsc_deinterleaver_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_deinterleaver_sptr self) -> std::string"""
        return _dtv_swig0.atsc_deinterleaver_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_deinterleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_deinterleaver_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_deinterleaver_sptr self, int m)"""
        return _dtv_swig0.atsc_deinterleaver_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_deinterleaver_sptr self)"""
        return _dtv_swig0.atsc_deinterleaver_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_deinterleaver_sptr self) -> bool"""
        return _dtv_swig0.atsc_deinterleaver_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_deinterleaver_sptr self, int m)"""
        return _dtv_swig0.atsc_deinterleaver_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_deinterleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_deinterleaver_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_deinterleaver_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_deinterleaver_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_deinterleaver_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_deinterleaver_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_deinterleaver_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_deinterleaver_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_deinterleaver_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_deinterleaver_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_deinterleaver_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_deinterleaver_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_deinterleaver_sptr self, int which) -> float
        pc_input_buffers_full(atsc_deinterleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_deinterleaver_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_deinterleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_deinterleaver_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_deinterleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_deinterleaver_sptr self, int which) -> float
        pc_output_buffers_full(atsc_deinterleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_deinterleaver_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_deinterleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_deinterleaver_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_deinterleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_deinterleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_deinterleaver_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_deinterleaver_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_deinterleaver_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_deinterleaver_sptr self)"""
        return _dtv_swig0.atsc_deinterleaver_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_deinterleaver_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_deinterleaver_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_deinterleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_deinterleaver_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_deinterleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_deinterleaver_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_deinterleaver_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_deinterleaver_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_deinterleaver_sptr self) -> std::string"""
        return _dtv_swig0.atsc_deinterleaver_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_deinterleaver_sptr self) -> std::string"""
        return _dtv_swig0.atsc_deinterleaver_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_deinterleaver_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_deinterleaver_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_deinterleaver_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_deinterleaver_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_deinterleaver_sptr self) -> long"""
        return _dtv_swig0.atsc_deinterleaver_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_deinterleaver_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_deinterleaver_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_deinterleaver_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_deinterleaver_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_deinterleaver_sptr self) -> std::string"""
        return _dtv_swig0.atsc_deinterleaver_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_deinterleaver_sptr self, std::string name)"""
        return _dtv_swig0.atsc_deinterleaver_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_deinterleaver_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_deinterleaver_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_deinterleaver_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_deinterleaver_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_deinterleaver_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_deinterleaver_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_deinterleaver_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_deinterleaver_sptr_message_subscribers(self, which_port)

# Register atsc_deinterleaver_sptr in _dtv_swig0:
_dtv_swig0.atsc_deinterleaver_sptr_swigregister(atsc_deinterleaver_sptr)


atsc_deinterleaver_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_deinterleaver = atsc_deinterleaver.make;

class atsc_depad_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_depad > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_depad_sptr self) -> atsc_depad_sptr
        __init__(atsc_depad_sptr self, atsc_depad p) -> atsc_depad_sptr
        """
        _dtv_swig0.atsc_depad_sptr_swiginit(self, _dtv_swig0.new_atsc_depad_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_depad *":
        r"""__deref__(atsc_depad_sptr self) -> atsc_depad"""
        return _dtv_swig0.atsc_depad_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_depad_sptr

    def make(self) -> "gr::dtv::atsc_depad::sptr":
        r"""make(atsc_depad_sptr self) -> atsc_depad_sptr"""
        return _dtv_swig0.atsc_depad_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_depad_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_depad_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_depad_sptr self, int which, int delay)
        declare_sample_delay(atsc_depad_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_depad_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_depad_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_depad_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_depad_sptr self, int multiple)"""
        return _dtv_swig0.atsc_depad_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_depad_sptr self) -> int"""
        return _dtv_swig0.atsc_depad_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_depad_sptr self) -> double"""
        return _dtv_swig0.atsc_depad_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_depad_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_depad_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_depad_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_depad_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_depad_sptr self) -> bool"""
        return _dtv_swig0.atsc_depad_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_depad_sptr self) -> bool"""
        return _dtv_swig0.atsc_depad_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_depad_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_depad_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_depad_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_depad_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_depad_sptr self, std::string level)"""
        return _dtv_swig0.atsc_depad_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_depad_sptr self) -> std::string"""
        return _dtv_swig0.atsc_depad_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_depad_sptr self) -> int"""
        return _dtv_swig0.atsc_depad_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_depad_sptr self, int m)"""
        return _dtv_swig0.atsc_depad_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_depad_sptr self)"""
        return _dtv_swig0.atsc_depad_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_depad_sptr self) -> bool"""
        return _dtv_swig0.atsc_depad_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_depad_sptr self, int m)"""
        return _dtv_swig0.atsc_depad_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_depad_sptr self) -> int"""
        return _dtv_swig0.atsc_depad_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_depad_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_depad_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_depad_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_depad_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_depad_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_depad_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_depad_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_depad_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_depad_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_depad_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_depad_sptr self, int which) -> float
        pc_input_buffers_full(atsc_depad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_depad_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_depad_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_depad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_depad_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_depad_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_depad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_depad_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_depad_sptr self, int which) -> float
        pc_output_buffers_full(atsc_depad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_depad_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_depad_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_depad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_depad_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_depad_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_depad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_depad_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_depad_sptr self) -> float"""
        return _dtv_swig0.atsc_depad_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_depad_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_depad_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_depad_sptr self)"""
        return _dtv_swig0.atsc_depad_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_depad_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_depad_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_depad_sptr self) -> int"""
        return _dtv_swig0.atsc_depad_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_depad_sptr self) -> int"""
        return _dtv_swig0.atsc_depad_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_depad_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_depad_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_depad_sptr self) -> std::string"""
        return _dtv_swig0.atsc_depad_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_depad_sptr self) -> std::string"""
        return _dtv_swig0.atsc_depad_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_depad_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_depad_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_depad_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_depad_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_depad_sptr self) -> long"""
        return _dtv_swig0.atsc_depad_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_depad_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_depad_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_depad_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_depad_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_depad_sptr self) -> std::string"""
        return _dtv_swig0.atsc_depad_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_depad_sptr self, std::string name)"""
        return _dtv_swig0.atsc_depad_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_depad_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_depad_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_depad_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_depad_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_depad_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_depad_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_depad_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_depad_sptr_message_subscribers(self, which_port)

# Register atsc_depad_sptr in _dtv_swig0:
_dtv_swig0.atsc_depad_sptr_swigregister(atsc_depad_sptr)


atsc_depad_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_depad = atsc_depad.make;

class atsc_derandomizer_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_derandomizer > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_derandomizer_sptr self) -> atsc_derandomizer_sptr
        __init__(atsc_derandomizer_sptr self, atsc_derandomizer p) -> atsc_derandomizer_sptr
        """
        _dtv_swig0.atsc_derandomizer_sptr_swiginit(self, _dtv_swig0.new_atsc_derandomizer_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_derandomizer *":
        r"""__deref__(atsc_derandomizer_sptr self) -> atsc_derandomizer"""
        return _dtv_swig0.atsc_derandomizer_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_derandomizer_sptr

    def make(self) -> "gr::dtv::atsc_derandomizer::sptr":
        r"""make(atsc_derandomizer_sptr self) -> atsc_derandomizer_sptr"""
        return _dtv_swig0.atsc_derandomizer_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_derandomizer_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_derandomizer_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_derandomizer_sptr self, int which, int delay)
        declare_sample_delay(atsc_derandomizer_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_derandomizer_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_derandomizer_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_derandomizer_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_derandomizer_sptr self, int multiple)"""
        return _dtv_swig0.atsc_derandomizer_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_derandomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_derandomizer_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_derandomizer_sptr self) -> double"""
        return _dtv_swig0.atsc_derandomizer_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_derandomizer_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_derandomizer_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_derandomizer_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_derandomizer_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_derandomizer_sptr self) -> bool"""
        return _dtv_swig0.atsc_derandomizer_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_derandomizer_sptr self) -> bool"""
        return _dtv_swig0.atsc_derandomizer_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_derandomizer_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_derandomizer_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_derandomizer_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_derandomizer_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_derandomizer_sptr self, std::string level)"""
        return _dtv_swig0.atsc_derandomizer_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_derandomizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_derandomizer_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_derandomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_derandomizer_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_derandomizer_sptr self, int m)"""
        return _dtv_swig0.atsc_derandomizer_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_derandomizer_sptr self)"""
        return _dtv_swig0.atsc_derandomizer_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_derandomizer_sptr self) -> bool"""
        return _dtv_swig0.atsc_derandomizer_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_derandomizer_sptr self, int m)"""
        return _dtv_swig0.atsc_derandomizer_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_derandomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_derandomizer_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_derandomizer_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_derandomizer_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_derandomizer_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_derandomizer_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_derandomizer_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_derandomizer_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_derandomizer_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_derandomizer_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_derandomizer_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_derandomizer_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_derandomizer_sptr self, int which) -> float
        pc_input_buffers_full(atsc_derandomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_derandomizer_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_derandomizer_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_derandomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_derandomizer_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_derandomizer_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_derandomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_derandomizer_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_derandomizer_sptr self, int which) -> float
        pc_output_buffers_full(atsc_derandomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_derandomizer_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_derandomizer_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_derandomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_derandomizer_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_derandomizer_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_derandomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_derandomizer_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_derandomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_derandomizer_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_derandomizer_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_derandomizer_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_derandomizer_sptr self)"""
        return _dtv_swig0.atsc_derandomizer_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_derandomizer_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_derandomizer_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_derandomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_derandomizer_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_derandomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_derandomizer_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_derandomizer_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_derandomizer_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_derandomizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_derandomizer_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_derandomizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_derandomizer_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_derandomizer_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_derandomizer_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_derandomizer_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_derandomizer_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_derandomizer_sptr self) -> long"""
        return _dtv_swig0.atsc_derandomizer_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_derandomizer_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_derandomizer_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_derandomizer_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_derandomizer_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_derandomizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_derandomizer_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_derandomizer_sptr self, std::string name)"""
        return _dtv_swig0.atsc_derandomizer_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_derandomizer_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_derandomizer_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_derandomizer_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_derandomizer_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_derandomizer_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_derandomizer_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_derandomizer_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_derandomizer_sptr_message_subscribers(self, which_port)

# Register atsc_derandomizer_sptr in _dtv_swig0:
_dtv_swig0.atsc_derandomizer_sptr_swigregister(atsc_derandomizer_sptr)


atsc_derandomizer_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_derandomizer = atsc_derandomizer.make;

class atsc_equalizer_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_equalizer > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_equalizer_sptr self) -> atsc_equalizer_sptr
        __init__(atsc_equalizer_sptr self, atsc_equalizer p) -> atsc_equalizer_sptr
        """
        _dtv_swig0.atsc_equalizer_sptr_swiginit(self, _dtv_swig0.new_atsc_equalizer_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_equalizer *":
        r"""__deref__(atsc_equalizer_sptr self) -> atsc_equalizer"""
        return _dtv_swig0.atsc_equalizer_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_equalizer_sptr

    def make(self) -> "gr::dtv::atsc_equalizer::sptr":
        r"""make(atsc_equalizer_sptr self) -> atsc_equalizer_sptr"""
        return _dtv_swig0.atsc_equalizer_sptr_make(self)

    def taps(self) -> "std::vector< float,std::allocator< float > >":
        r"""taps(atsc_equalizer_sptr self) -> pmt_vector_float"""
        return _dtv_swig0.atsc_equalizer_sptr_taps(self)

    def data(self) -> "std::vector< float,std::allocator< float > >":
        r"""data(atsc_equalizer_sptr self) -> pmt_vector_float"""
        return _dtv_swig0.atsc_equalizer_sptr_data(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_equalizer_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_equalizer_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_equalizer_sptr self, int which, int delay)
        declare_sample_delay(atsc_equalizer_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_equalizer_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_equalizer_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_equalizer_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_equalizer_sptr self, int multiple)"""
        return _dtv_swig0.atsc_equalizer_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_equalizer_sptr self) -> int"""
        return _dtv_swig0.atsc_equalizer_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_equalizer_sptr self) -> double"""
        return _dtv_swig0.atsc_equalizer_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_equalizer_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_equalizer_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_equalizer_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_equalizer_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_equalizer_sptr self) -> bool"""
        return _dtv_swig0.atsc_equalizer_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_equalizer_sptr self) -> bool"""
        return _dtv_swig0.atsc_equalizer_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_equalizer_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_equalizer_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_equalizer_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_equalizer_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_equalizer_sptr self, std::string level)"""
        return _dtv_swig0.atsc_equalizer_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_equalizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_equalizer_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_equalizer_sptr self) -> int"""
        return _dtv_swig0.atsc_equalizer_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_equalizer_sptr self, int m)"""
        return _dtv_swig0.atsc_equalizer_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_equalizer_sptr self)"""
        return _dtv_swig0.atsc_equalizer_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_equalizer_sptr self) -> bool"""
        return _dtv_swig0.atsc_equalizer_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_equalizer_sptr self, int m)"""
        return _dtv_swig0.atsc_equalizer_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_equalizer_sptr self) -> int"""
        return _dtv_swig0.atsc_equalizer_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_equalizer_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_equalizer_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_equalizer_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_equalizer_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_equalizer_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_equalizer_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_equalizer_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_equalizer_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_equalizer_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_equalizer_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_equalizer_sptr self, int which) -> float
        pc_input_buffers_full(atsc_equalizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_equalizer_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_equalizer_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_equalizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_equalizer_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_equalizer_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_equalizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_equalizer_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_equalizer_sptr self, int which) -> float
        pc_output_buffers_full(atsc_equalizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_equalizer_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_equalizer_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_equalizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_equalizer_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_equalizer_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_equalizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_equalizer_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_equalizer_sptr self) -> float"""
        return _dtv_swig0.atsc_equalizer_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_equalizer_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_equalizer_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_equalizer_sptr self)"""
        return _dtv_swig0.atsc_equalizer_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_equalizer_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_equalizer_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_equalizer_sptr self) -> int"""
        return _dtv_swig0.atsc_equalizer_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_equalizer_sptr self) -> int"""
        return _dtv_swig0.atsc_equalizer_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_equalizer_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_equalizer_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_equalizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_equalizer_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_equalizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_equalizer_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_equalizer_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_equalizer_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_equalizer_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_equalizer_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_equalizer_sptr self) -> long"""
        return _dtv_swig0.atsc_equalizer_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_equalizer_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_equalizer_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_equalizer_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_equalizer_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_equalizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_equalizer_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_equalizer_sptr self, std::string name)"""
        return _dtv_swig0.atsc_equalizer_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_equalizer_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_equalizer_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_equalizer_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_equalizer_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_equalizer_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_equalizer_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_equalizer_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_equalizer_sptr_message_subscribers(self, which_port)

# Register atsc_equalizer_sptr in _dtv_swig0:
_dtv_swig0.atsc_equalizer_sptr_swigregister(atsc_equalizer_sptr)


atsc_equalizer_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_equalizer = atsc_equalizer.make;

class atsc_field_sync_mux_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_field_sync_mux > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_field_sync_mux_sptr self) -> atsc_field_sync_mux_sptr
        __init__(atsc_field_sync_mux_sptr self, atsc_field_sync_mux p) -> atsc_field_sync_mux_sptr
        """
        _dtv_swig0.atsc_field_sync_mux_sptr_swiginit(self, _dtv_swig0.new_atsc_field_sync_mux_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_field_sync_mux *":
        r"""__deref__(atsc_field_sync_mux_sptr self) -> atsc_field_sync_mux"""
        return _dtv_swig0.atsc_field_sync_mux_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_field_sync_mux_sptr

    def make(self) -> "gr::dtv::atsc_field_sync_mux::sptr":
        r"""make(atsc_field_sync_mux_sptr self) -> atsc_field_sync_mux_sptr"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_field_sync_mux_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_field_sync_mux_sptr self, int which, int delay)
        declare_sample_delay(atsc_field_sync_mux_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_field_sync_mux_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_field_sync_mux_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_field_sync_mux_sptr self, int multiple)"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_field_sync_mux_sptr self) -> int"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_field_sync_mux_sptr self) -> double"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_field_sync_mux_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_field_sync_mux_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_field_sync_mux_sptr self) -> bool"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_field_sync_mux_sptr self) -> bool"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_field_sync_mux_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_field_sync_mux_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_field_sync_mux_sptr self, std::string level)"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_field_sync_mux_sptr self) -> std::string"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_field_sync_mux_sptr self) -> int"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_field_sync_mux_sptr self, int m)"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_field_sync_mux_sptr self)"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_field_sync_mux_sptr self) -> bool"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_field_sync_mux_sptr self, int m)"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_field_sync_mux_sptr self) -> int"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_field_sync_mux_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_field_sync_mux_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_field_sync_mux_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_field_sync_mux_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_field_sync_mux_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_field_sync_mux_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_field_sync_mux_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_field_sync_mux_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_field_sync_mux_sptr self, int which) -> float
        pc_input_buffers_full(atsc_field_sync_mux_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_field_sync_mux_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_field_sync_mux_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_field_sync_mux_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_field_sync_mux_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_field_sync_mux_sptr self, int which) -> float
        pc_output_buffers_full(atsc_field_sync_mux_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_field_sync_mux_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_field_sync_mux_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_field_sync_mux_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_field_sync_mux_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_field_sync_mux_sptr self) -> float"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_field_sync_mux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_field_sync_mux_sptr self)"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_field_sync_mux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_field_sync_mux_sptr self) -> int"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_field_sync_mux_sptr self) -> int"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_field_sync_mux_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_field_sync_mux_sptr self) -> std::string"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_field_sync_mux_sptr self) -> std::string"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_field_sync_mux_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_field_sync_mux_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_field_sync_mux_sptr self) -> long"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_field_sync_mux_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_field_sync_mux_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_field_sync_mux_sptr self) -> std::string"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_field_sync_mux_sptr self, std::string name)"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_field_sync_mux_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_field_sync_mux_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_field_sync_mux_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_field_sync_mux_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_field_sync_mux_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_field_sync_mux_sptr_message_subscribers(self, which_port)

# Register atsc_field_sync_mux_sptr in _dtv_swig0:
_dtv_swig0.atsc_field_sync_mux_sptr_swigregister(atsc_field_sync_mux_sptr)


atsc_field_sync_mux_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_field_sync_mux = atsc_field_sync_mux.make;

class atsc_fpll_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_fpll > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_fpll_sptr self) -> atsc_fpll_sptr
        __init__(atsc_fpll_sptr self, atsc_fpll p) -> atsc_fpll_sptr
        """
        _dtv_swig0.atsc_fpll_sptr_swiginit(self, _dtv_swig0.new_atsc_fpll_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_fpll *":
        r"""__deref__(atsc_fpll_sptr self) -> atsc_fpll"""
        return _dtv_swig0.atsc_fpll_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_fpll_sptr

    def make(self, rate: "float") -> "gr::dtv::atsc_fpll::sptr":
        r"""make(atsc_fpll_sptr self, float rate) -> atsc_fpll_sptr"""
        return _dtv_swig0.atsc_fpll_sptr_make(self, rate)

    def history(self) -> "unsigned int":
        r"""history(atsc_fpll_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_fpll_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_fpll_sptr self, int which, int delay)
        declare_sample_delay(atsc_fpll_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_fpll_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_fpll_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_fpll_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_fpll_sptr self, int multiple)"""
        return _dtv_swig0.atsc_fpll_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_fpll_sptr self) -> int"""
        return _dtv_swig0.atsc_fpll_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_fpll_sptr self) -> double"""
        return _dtv_swig0.atsc_fpll_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_fpll_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_fpll_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_fpll_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_fpll_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_fpll_sptr self) -> bool"""
        return _dtv_swig0.atsc_fpll_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_fpll_sptr self) -> bool"""
        return _dtv_swig0.atsc_fpll_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_fpll_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_fpll_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_fpll_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_fpll_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_fpll_sptr self, std::string level)"""
        return _dtv_swig0.atsc_fpll_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_fpll_sptr self) -> std::string"""
        return _dtv_swig0.atsc_fpll_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_fpll_sptr self) -> int"""
        return _dtv_swig0.atsc_fpll_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_fpll_sptr self, int m)"""
        return _dtv_swig0.atsc_fpll_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_fpll_sptr self)"""
        return _dtv_swig0.atsc_fpll_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_fpll_sptr self) -> bool"""
        return _dtv_swig0.atsc_fpll_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_fpll_sptr self, int m)"""
        return _dtv_swig0.atsc_fpll_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_fpll_sptr self) -> int"""
        return _dtv_swig0.atsc_fpll_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_fpll_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_fpll_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_fpll_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_fpll_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_fpll_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_fpll_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_fpll_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_fpll_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_fpll_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_fpll_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_fpll_sptr self, int which) -> float
        pc_input_buffers_full(atsc_fpll_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fpll_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_fpll_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_fpll_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fpll_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_fpll_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_fpll_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fpll_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_fpll_sptr self, int which) -> float
        pc_output_buffers_full(atsc_fpll_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fpll_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_fpll_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_fpll_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fpll_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_fpll_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_fpll_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fpll_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_fpll_sptr self) -> float"""
        return _dtv_swig0.atsc_fpll_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_fpll_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_fpll_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_fpll_sptr self)"""
        return _dtv_swig0.atsc_fpll_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_fpll_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_fpll_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_fpll_sptr self) -> int"""
        return _dtv_swig0.atsc_fpll_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_fpll_sptr self) -> int"""
        return _dtv_swig0.atsc_fpll_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_fpll_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_fpll_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_fpll_sptr self) -> std::string"""
        return _dtv_swig0.atsc_fpll_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_fpll_sptr self) -> std::string"""
        return _dtv_swig0.atsc_fpll_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_fpll_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_fpll_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_fpll_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_fpll_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_fpll_sptr self) -> long"""
        return _dtv_swig0.atsc_fpll_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_fpll_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_fpll_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_fpll_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_fpll_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_fpll_sptr self) -> std::string"""
        return _dtv_swig0.atsc_fpll_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_fpll_sptr self, std::string name)"""
        return _dtv_swig0.atsc_fpll_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_fpll_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_fpll_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_fpll_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_fpll_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_fpll_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_fpll_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_fpll_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_fpll_sptr_message_subscribers(self, which_port)

# Register atsc_fpll_sptr in _dtv_swig0:
_dtv_swig0.atsc_fpll_sptr_swigregister(atsc_fpll_sptr)


atsc_fpll_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_fpll = atsc_fpll.make;

class atsc_fs_checker_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_fs_checker > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_fs_checker_sptr self) -> atsc_fs_checker_sptr
        __init__(atsc_fs_checker_sptr self, atsc_fs_checker p) -> atsc_fs_checker_sptr
        """
        _dtv_swig0.atsc_fs_checker_sptr_swiginit(self, _dtv_swig0.new_atsc_fs_checker_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_fs_checker *":
        r"""__deref__(atsc_fs_checker_sptr self) -> atsc_fs_checker"""
        return _dtv_swig0.atsc_fs_checker_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_fs_checker_sptr

    def make(self) -> "gr::dtv::atsc_fs_checker::sptr":
        r"""make(atsc_fs_checker_sptr self) -> atsc_fs_checker_sptr"""
        return _dtv_swig0.atsc_fs_checker_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_fs_checker_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_fs_checker_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_fs_checker_sptr self, int which, int delay)
        declare_sample_delay(atsc_fs_checker_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_fs_checker_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_fs_checker_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_fs_checker_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_fs_checker_sptr self, int multiple)"""
        return _dtv_swig0.atsc_fs_checker_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_fs_checker_sptr self) -> int"""
        return _dtv_swig0.atsc_fs_checker_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_fs_checker_sptr self) -> double"""
        return _dtv_swig0.atsc_fs_checker_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_fs_checker_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_fs_checker_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_fs_checker_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_fs_checker_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_fs_checker_sptr self) -> bool"""
        return _dtv_swig0.atsc_fs_checker_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_fs_checker_sptr self) -> bool"""
        return _dtv_swig0.atsc_fs_checker_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_fs_checker_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_fs_checker_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_fs_checker_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_fs_checker_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_fs_checker_sptr self, std::string level)"""
        return _dtv_swig0.atsc_fs_checker_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_fs_checker_sptr self) -> std::string"""
        return _dtv_swig0.atsc_fs_checker_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_fs_checker_sptr self) -> int"""
        return _dtv_swig0.atsc_fs_checker_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_fs_checker_sptr self, int m)"""
        return _dtv_swig0.atsc_fs_checker_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_fs_checker_sptr self)"""
        return _dtv_swig0.atsc_fs_checker_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_fs_checker_sptr self) -> bool"""
        return _dtv_swig0.atsc_fs_checker_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_fs_checker_sptr self, int m)"""
        return _dtv_swig0.atsc_fs_checker_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_fs_checker_sptr self) -> int"""
        return _dtv_swig0.atsc_fs_checker_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_fs_checker_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_fs_checker_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_fs_checker_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_fs_checker_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_fs_checker_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_fs_checker_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_fs_checker_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_fs_checker_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_fs_checker_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_fs_checker_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_fs_checker_sptr self, int which) -> float
        pc_input_buffers_full(atsc_fs_checker_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fs_checker_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_fs_checker_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_fs_checker_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fs_checker_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_fs_checker_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_fs_checker_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fs_checker_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_fs_checker_sptr self, int which) -> float
        pc_output_buffers_full(atsc_fs_checker_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fs_checker_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_fs_checker_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_fs_checker_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fs_checker_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_fs_checker_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_fs_checker_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_fs_checker_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_fs_checker_sptr self) -> float"""
        return _dtv_swig0.atsc_fs_checker_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_fs_checker_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_fs_checker_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_fs_checker_sptr self)"""
        return _dtv_swig0.atsc_fs_checker_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_fs_checker_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_fs_checker_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_fs_checker_sptr self) -> int"""
        return _dtv_swig0.atsc_fs_checker_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_fs_checker_sptr self) -> int"""
        return _dtv_swig0.atsc_fs_checker_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_fs_checker_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_fs_checker_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_fs_checker_sptr self) -> std::string"""
        return _dtv_swig0.atsc_fs_checker_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_fs_checker_sptr self) -> std::string"""
        return _dtv_swig0.atsc_fs_checker_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_fs_checker_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_fs_checker_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_fs_checker_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_fs_checker_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_fs_checker_sptr self) -> long"""
        return _dtv_swig0.atsc_fs_checker_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_fs_checker_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_fs_checker_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_fs_checker_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_fs_checker_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_fs_checker_sptr self) -> std::string"""
        return _dtv_swig0.atsc_fs_checker_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_fs_checker_sptr self, std::string name)"""
        return _dtv_swig0.atsc_fs_checker_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_fs_checker_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_fs_checker_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_fs_checker_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_fs_checker_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_fs_checker_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_fs_checker_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_fs_checker_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_fs_checker_sptr_message_subscribers(self, which_port)

# Register atsc_fs_checker_sptr in _dtv_swig0:
_dtv_swig0.atsc_fs_checker_sptr_swigregister(atsc_fs_checker_sptr)


atsc_fs_checker_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_fs_checker = atsc_fs_checker.make;

class atsc_interleaver_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_interleaver > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_interleaver_sptr self) -> atsc_interleaver_sptr
        __init__(atsc_interleaver_sptr self, atsc_interleaver p) -> atsc_interleaver_sptr
        """
        _dtv_swig0.atsc_interleaver_sptr_swiginit(self, _dtv_swig0.new_atsc_interleaver_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_interleaver *":
        r"""__deref__(atsc_interleaver_sptr self) -> atsc_interleaver"""
        return _dtv_swig0.atsc_interleaver_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_interleaver_sptr

    def make(self) -> "gr::dtv::atsc_interleaver::sptr":
        r"""make(atsc_interleaver_sptr self) -> atsc_interleaver_sptr"""
        return _dtv_swig0.atsc_interleaver_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_interleaver_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_interleaver_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_interleaver_sptr self, int which, int delay)
        declare_sample_delay(atsc_interleaver_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_interleaver_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_interleaver_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_interleaver_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_interleaver_sptr self, int multiple)"""
        return _dtv_swig0.atsc_interleaver_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_interleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_interleaver_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_interleaver_sptr self) -> double"""
        return _dtv_swig0.atsc_interleaver_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_interleaver_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_interleaver_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_interleaver_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_interleaver_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_interleaver_sptr self) -> bool"""
        return _dtv_swig0.atsc_interleaver_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_interleaver_sptr self) -> bool"""
        return _dtv_swig0.atsc_interleaver_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_interleaver_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_interleaver_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_interleaver_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_interleaver_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_interleaver_sptr self, std::string level)"""
        return _dtv_swig0.atsc_interleaver_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_interleaver_sptr self) -> std::string"""
        return _dtv_swig0.atsc_interleaver_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_interleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_interleaver_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_interleaver_sptr self, int m)"""
        return _dtv_swig0.atsc_interleaver_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_interleaver_sptr self)"""
        return _dtv_swig0.atsc_interleaver_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_interleaver_sptr self) -> bool"""
        return _dtv_swig0.atsc_interleaver_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_interleaver_sptr self, int m)"""
        return _dtv_swig0.atsc_interleaver_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_interleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_interleaver_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_interleaver_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_interleaver_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_interleaver_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_interleaver_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_interleaver_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_interleaver_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_interleaver_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_interleaver_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_interleaver_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_interleaver_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_interleaver_sptr self, int which) -> float
        pc_input_buffers_full(atsc_interleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_interleaver_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_interleaver_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_interleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_interleaver_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_interleaver_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_interleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_interleaver_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_interleaver_sptr self, int which) -> float
        pc_output_buffers_full(atsc_interleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_interleaver_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_interleaver_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_interleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_interleaver_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_interleaver_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_interleaver_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_interleaver_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_interleaver_sptr self) -> float"""
        return _dtv_swig0.atsc_interleaver_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_interleaver_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_interleaver_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_interleaver_sptr self)"""
        return _dtv_swig0.atsc_interleaver_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_interleaver_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_interleaver_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_interleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_interleaver_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_interleaver_sptr self) -> int"""
        return _dtv_swig0.atsc_interleaver_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_interleaver_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_interleaver_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_interleaver_sptr self) -> std::string"""
        return _dtv_swig0.atsc_interleaver_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_interleaver_sptr self) -> std::string"""
        return _dtv_swig0.atsc_interleaver_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_interleaver_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_interleaver_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_interleaver_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_interleaver_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_interleaver_sptr self) -> long"""
        return _dtv_swig0.atsc_interleaver_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_interleaver_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_interleaver_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_interleaver_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_interleaver_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_interleaver_sptr self) -> std::string"""
        return _dtv_swig0.atsc_interleaver_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_interleaver_sptr self, std::string name)"""
        return _dtv_swig0.atsc_interleaver_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_interleaver_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_interleaver_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_interleaver_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_interleaver_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_interleaver_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_interleaver_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_interleaver_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_interleaver_sptr_message_subscribers(self, which_port)

# Register atsc_interleaver_sptr in _dtv_swig0:
_dtv_swig0.atsc_interleaver_sptr_swigregister(atsc_interleaver_sptr)


atsc_interleaver_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_interleaver = atsc_interleaver.make;

class atsc_pad_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_pad > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_pad_sptr self) -> atsc_pad_sptr
        __init__(atsc_pad_sptr self, atsc_pad p) -> atsc_pad_sptr
        """
        _dtv_swig0.atsc_pad_sptr_swiginit(self, _dtv_swig0.new_atsc_pad_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_pad *":
        r"""__deref__(atsc_pad_sptr self) -> atsc_pad"""
        return _dtv_swig0.atsc_pad_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_pad_sptr

    def make(self) -> "gr::dtv::atsc_pad::sptr":
        r"""make(atsc_pad_sptr self) -> atsc_pad_sptr"""
        return _dtv_swig0.atsc_pad_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_pad_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_pad_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_pad_sptr self, int which, int delay)
        declare_sample_delay(atsc_pad_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_pad_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_pad_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_pad_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_pad_sptr self, int multiple)"""
        return _dtv_swig0.atsc_pad_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_pad_sptr self) -> int"""
        return _dtv_swig0.atsc_pad_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_pad_sptr self) -> double"""
        return _dtv_swig0.atsc_pad_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_pad_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_pad_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_pad_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_pad_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_pad_sptr self) -> bool"""
        return _dtv_swig0.atsc_pad_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_pad_sptr self) -> bool"""
        return _dtv_swig0.atsc_pad_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_pad_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_pad_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_pad_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_pad_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_pad_sptr self, std::string level)"""
        return _dtv_swig0.atsc_pad_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_pad_sptr self) -> std::string"""
        return _dtv_swig0.atsc_pad_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_pad_sptr self) -> int"""
        return _dtv_swig0.atsc_pad_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_pad_sptr self, int m)"""
        return _dtv_swig0.atsc_pad_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_pad_sptr self)"""
        return _dtv_swig0.atsc_pad_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_pad_sptr self) -> bool"""
        return _dtv_swig0.atsc_pad_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_pad_sptr self, int m)"""
        return _dtv_swig0.atsc_pad_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_pad_sptr self) -> int"""
        return _dtv_swig0.atsc_pad_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_pad_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_pad_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_pad_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_pad_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_pad_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_pad_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_pad_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_pad_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_pad_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_pad_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_pad_sptr self, int which) -> float
        pc_input_buffers_full(atsc_pad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_pad_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_pad_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_pad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_pad_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_pad_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_pad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_pad_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_pad_sptr self, int which) -> float
        pc_output_buffers_full(atsc_pad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_pad_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_pad_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_pad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_pad_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_pad_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_pad_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_pad_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_pad_sptr self) -> float"""
        return _dtv_swig0.atsc_pad_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_pad_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_pad_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_pad_sptr self)"""
        return _dtv_swig0.atsc_pad_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_pad_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_pad_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_pad_sptr self) -> int"""
        return _dtv_swig0.atsc_pad_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_pad_sptr self) -> int"""
        return _dtv_swig0.atsc_pad_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_pad_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_pad_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_pad_sptr self) -> std::string"""
        return _dtv_swig0.atsc_pad_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_pad_sptr self) -> std::string"""
        return _dtv_swig0.atsc_pad_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_pad_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_pad_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_pad_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_pad_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_pad_sptr self) -> long"""
        return _dtv_swig0.atsc_pad_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_pad_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_pad_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_pad_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_pad_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_pad_sptr self) -> std::string"""
        return _dtv_swig0.atsc_pad_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_pad_sptr self, std::string name)"""
        return _dtv_swig0.atsc_pad_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_pad_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_pad_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_pad_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_pad_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_pad_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_pad_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_pad_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_pad_sptr_message_subscribers(self, which_port)

# Register atsc_pad_sptr in _dtv_swig0:
_dtv_swig0.atsc_pad_sptr_swigregister(atsc_pad_sptr)


atsc_pad_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_pad = atsc_pad.make;

class atsc_randomizer_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_randomizer > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_randomizer_sptr self) -> atsc_randomizer_sptr
        __init__(atsc_randomizer_sptr self, atsc_randomizer p) -> atsc_randomizer_sptr
        """
        _dtv_swig0.atsc_randomizer_sptr_swiginit(self, _dtv_swig0.new_atsc_randomizer_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_randomizer *":
        r"""__deref__(atsc_randomizer_sptr self) -> atsc_randomizer"""
        return _dtv_swig0.atsc_randomizer_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_randomizer_sptr

    def make(self) -> "gr::dtv::atsc_randomizer::sptr":
        r"""make(atsc_randomizer_sptr self) -> atsc_randomizer_sptr"""
        return _dtv_swig0.atsc_randomizer_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_randomizer_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_randomizer_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_randomizer_sptr self, int which, int delay)
        declare_sample_delay(atsc_randomizer_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_randomizer_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_randomizer_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_randomizer_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_randomizer_sptr self, int multiple)"""
        return _dtv_swig0.atsc_randomizer_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_randomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_randomizer_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_randomizer_sptr self) -> double"""
        return _dtv_swig0.atsc_randomizer_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_randomizer_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_randomizer_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_randomizer_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_randomizer_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_randomizer_sptr self) -> bool"""
        return _dtv_swig0.atsc_randomizer_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_randomizer_sptr self) -> bool"""
        return _dtv_swig0.atsc_randomizer_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_randomizer_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_randomizer_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_randomizer_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_randomizer_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_randomizer_sptr self, std::string level)"""
        return _dtv_swig0.atsc_randomizer_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_randomizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_randomizer_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_randomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_randomizer_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_randomizer_sptr self, int m)"""
        return _dtv_swig0.atsc_randomizer_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_randomizer_sptr self)"""
        return _dtv_swig0.atsc_randomizer_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_randomizer_sptr self) -> bool"""
        return _dtv_swig0.atsc_randomizer_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_randomizer_sptr self, int m)"""
        return _dtv_swig0.atsc_randomizer_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_randomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_randomizer_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_randomizer_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_randomizer_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_randomizer_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_randomizer_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_randomizer_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_randomizer_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_randomizer_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_randomizer_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_randomizer_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_randomizer_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_randomizer_sptr self, int which) -> float
        pc_input_buffers_full(atsc_randomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_randomizer_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_randomizer_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_randomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_randomizer_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_randomizer_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_randomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_randomizer_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_randomizer_sptr self, int which) -> float
        pc_output_buffers_full(atsc_randomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_randomizer_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_randomizer_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_randomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_randomizer_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_randomizer_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_randomizer_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_randomizer_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_randomizer_sptr self) -> float"""
        return _dtv_swig0.atsc_randomizer_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_randomizer_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_randomizer_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_randomizer_sptr self)"""
        return _dtv_swig0.atsc_randomizer_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_randomizer_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_randomizer_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_randomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_randomizer_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_randomizer_sptr self) -> int"""
        return _dtv_swig0.atsc_randomizer_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_randomizer_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_randomizer_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_randomizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_randomizer_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_randomizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_randomizer_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_randomizer_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_randomizer_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_randomizer_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_randomizer_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_randomizer_sptr self) -> long"""
        return _dtv_swig0.atsc_randomizer_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_randomizer_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_randomizer_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_randomizer_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_randomizer_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_randomizer_sptr self) -> std::string"""
        return _dtv_swig0.atsc_randomizer_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_randomizer_sptr self, std::string name)"""
        return _dtv_swig0.atsc_randomizer_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_randomizer_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_randomizer_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_randomizer_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_randomizer_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_randomizer_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_randomizer_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_randomizer_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_randomizer_sptr_message_subscribers(self, which_port)

# Register atsc_randomizer_sptr in _dtv_swig0:
_dtv_swig0.atsc_randomizer_sptr_swigregister(atsc_randomizer_sptr)


atsc_randomizer_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_randomizer = atsc_randomizer.make;

class atsc_rs_decoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_rs_decoder > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_rs_decoder_sptr self) -> atsc_rs_decoder_sptr
        __init__(atsc_rs_decoder_sptr self, atsc_rs_decoder p) -> atsc_rs_decoder_sptr
        """
        _dtv_swig0.atsc_rs_decoder_sptr_swiginit(self, _dtv_swig0.new_atsc_rs_decoder_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_rs_decoder *":
        r"""__deref__(atsc_rs_decoder_sptr self) -> atsc_rs_decoder"""
        return _dtv_swig0.atsc_rs_decoder_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_rs_decoder_sptr

    def num_errors_corrected(self) -> "int":
        r"""num_errors_corrected(atsc_rs_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_num_errors_corrected(self)

    def num_bad_packets(self) -> "int":
        r"""num_bad_packets(atsc_rs_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_num_bad_packets(self)

    def num_packets(self) -> "int":
        r"""num_packets(atsc_rs_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_num_packets(self)

    def make(self) -> "gr::dtv::atsc_rs_decoder::sptr":
        r"""make(atsc_rs_decoder_sptr self) -> atsc_rs_decoder_sptr"""
        return _dtv_swig0.atsc_rs_decoder_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_rs_decoder_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_rs_decoder_sptr self, int which, int delay)
        declare_sample_delay(atsc_rs_decoder_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_rs_decoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_rs_decoder_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_rs_decoder_sptr self, int multiple)"""
        return _dtv_swig0.atsc_rs_decoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_rs_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_rs_decoder_sptr self) -> double"""
        return _dtv_swig0.atsc_rs_decoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_rs_decoder_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_rs_decoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_rs_decoder_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_rs_decoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_rs_decoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_rs_decoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_rs_decoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_rs_decoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_rs_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_rs_decoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_rs_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_rs_decoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_rs_decoder_sptr self, std::string level)"""
        return _dtv_swig0.atsc_rs_decoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_rs_decoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_rs_decoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_rs_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_rs_decoder_sptr self, int m)"""
        return _dtv_swig0.atsc_rs_decoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_rs_decoder_sptr self)"""
        return _dtv_swig0.atsc_rs_decoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_rs_decoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_rs_decoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_rs_decoder_sptr self, int m)"""
        return _dtv_swig0.atsc_rs_decoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_rs_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_rs_decoder_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_rs_decoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_rs_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_rs_decoder_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_rs_decoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_rs_decoder_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_rs_decoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_rs_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_rs_decoder_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_rs_decoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_rs_decoder_sptr self, int which) -> float
        pc_input_buffers_full(atsc_rs_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_rs_decoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_rs_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_rs_decoder_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_rs_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_rs_decoder_sptr self, int which) -> float
        pc_output_buffers_full(atsc_rs_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_rs_decoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_rs_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_rs_decoder_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_rs_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_rs_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_decoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_rs_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_rs_decoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_rs_decoder_sptr self)"""
        return _dtv_swig0.atsc_rs_decoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_rs_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_rs_decoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_rs_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_rs_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_rs_decoder_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_rs_decoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_rs_decoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_rs_decoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_rs_decoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_rs_decoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_rs_decoder_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_rs_decoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_rs_decoder_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_rs_decoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_rs_decoder_sptr self) -> long"""
        return _dtv_swig0.atsc_rs_decoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_rs_decoder_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_rs_decoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_rs_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_rs_decoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_rs_decoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_rs_decoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_rs_decoder_sptr self, std::string name)"""
        return _dtv_swig0.atsc_rs_decoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_rs_decoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_rs_decoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_rs_decoder_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_rs_decoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_rs_decoder_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_rs_decoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_rs_decoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_rs_decoder_sptr_message_subscribers(self, which_port)

# Register atsc_rs_decoder_sptr in _dtv_swig0:
_dtv_swig0.atsc_rs_decoder_sptr_swigregister(atsc_rs_decoder_sptr)


atsc_rs_decoder_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_rs_decoder = atsc_rs_decoder.make;

class atsc_rs_encoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_rs_encoder > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_rs_encoder_sptr self) -> atsc_rs_encoder_sptr
        __init__(atsc_rs_encoder_sptr self, atsc_rs_encoder p) -> atsc_rs_encoder_sptr
        """
        _dtv_swig0.atsc_rs_encoder_sptr_swiginit(self, _dtv_swig0.new_atsc_rs_encoder_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_rs_encoder *":
        r"""__deref__(atsc_rs_encoder_sptr self) -> atsc_rs_encoder"""
        return _dtv_swig0.atsc_rs_encoder_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_rs_encoder_sptr

    def make(self) -> "gr::dtv::atsc_rs_encoder::sptr":
        r"""make(atsc_rs_encoder_sptr self) -> atsc_rs_encoder_sptr"""
        return _dtv_swig0.atsc_rs_encoder_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_rs_encoder_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_rs_encoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_rs_encoder_sptr self, int which, int delay)
        declare_sample_delay(atsc_rs_encoder_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_rs_encoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_rs_encoder_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_rs_encoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_rs_encoder_sptr self, int multiple)"""
        return _dtv_swig0.atsc_rs_encoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_rs_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_encoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_rs_encoder_sptr self) -> double"""
        return _dtv_swig0.atsc_rs_encoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_rs_encoder_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_rs_encoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_rs_encoder_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_rs_encoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_rs_encoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_rs_encoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_rs_encoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_rs_encoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_rs_encoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_rs_encoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_rs_encoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_rs_encoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_rs_encoder_sptr self, std::string level)"""
        return _dtv_swig0.atsc_rs_encoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_rs_encoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_rs_encoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_rs_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_encoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_rs_encoder_sptr self, int m)"""
        return _dtv_swig0.atsc_rs_encoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_rs_encoder_sptr self)"""
        return _dtv_swig0.atsc_rs_encoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_rs_encoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_rs_encoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_rs_encoder_sptr self, int m)"""
        return _dtv_swig0.atsc_rs_encoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_rs_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_encoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_rs_encoder_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_rs_encoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_rs_encoder_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_rs_encoder_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_rs_encoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_rs_encoder_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_rs_encoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_rs_encoder_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_rs_encoder_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_rs_encoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_rs_encoder_sptr self, int which) -> float
        pc_input_buffers_full(atsc_rs_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_rs_encoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_rs_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_rs_encoder_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_rs_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_rs_encoder_sptr self, int which) -> float
        pc_output_buffers_full(atsc_rs_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_rs_encoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_rs_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_rs_encoder_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_rs_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_rs_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_rs_encoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_rs_encoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_rs_encoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_rs_encoder_sptr self)"""
        return _dtv_swig0.atsc_rs_encoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_rs_encoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_rs_encoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_rs_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_encoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_rs_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_rs_encoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_rs_encoder_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_rs_encoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_rs_encoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_rs_encoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_rs_encoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_rs_encoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_rs_encoder_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_rs_encoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_rs_encoder_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_rs_encoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_rs_encoder_sptr self) -> long"""
        return _dtv_swig0.atsc_rs_encoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_rs_encoder_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_rs_encoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_rs_encoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_rs_encoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_rs_encoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_rs_encoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_rs_encoder_sptr self, std::string name)"""
        return _dtv_swig0.atsc_rs_encoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_rs_encoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_rs_encoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_rs_encoder_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_rs_encoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_rs_encoder_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_rs_encoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_rs_encoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_rs_encoder_sptr_message_subscribers(self, which_port)

# Register atsc_rs_encoder_sptr in _dtv_swig0:
_dtv_swig0.atsc_rs_encoder_sptr_swigregister(atsc_rs_encoder_sptr)


atsc_rs_encoder_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_rs_encoder = atsc_rs_encoder.make;

class atsc_sync_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_sync > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_sync_sptr self) -> atsc_sync_sptr
        __init__(atsc_sync_sptr self, atsc_sync p) -> atsc_sync_sptr
        """
        _dtv_swig0.atsc_sync_sptr_swiginit(self, _dtv_swig0.new_atsc_sync_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_sync *":
        r"""__deref__(atsc_sync_sptr self) -> atsc_sync"""
        return _dtv_swig0.atsc_sync_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_sync_sptr

    def make(self, rate: "float") -> "gr::dtv::atsc_sync::sptr":
        r"""make(atsc_sync_sptr self, float rate) -> atsc_sync_sptr"""
        return _dtv_swig0.atsc_sync_sptr_make(self, rate)

    def history(self) -> "unsigned int":
        r"""history(atsc_sync_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_sync_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_sync_sptr self, int which, int delay)
        declare_sample_delay(atsc_sync_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_sync_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_sync_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_sync_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_sync_sptr self, int multiple)"""
        return _dtv_swig0.atsc_sync_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_sync_sptr self) -> int"""
        return _dtv_swig0.atsc_sync_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_sync_sptr self) -> double"""
        return _dtv_swig0.atsc_sync_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_sync_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_sync_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_sync_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_sync_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_sync_sptr self) -> bool"""
        return _dtv_swig0.atsc_sync_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_sync_sptr self) -> bool"""
        return _dtv_swig0.atsc_sync_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_sync_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_sync_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_sync_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_sync_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_sync_sptr self, std::string level)"""
        return _dtv_swig0.atsc_sync_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_sync_sptr self) -> std::string"""
        return _dtv_swig0.atsc_sync_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_sync_sptr self) -> int"""
        return _dtv_swig0.atsc_sync_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_sync_sptr self, int m)"""
        return _dtv_swig0.atsc_sync_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_sync_sptr self)"""
        return _dtv_swig0.atsc_sync_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_sync_sptr self) -> bool"""
        return _dtv_swig0.atsc_sync_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_sync_sptr self, int m)"""
        return _dtv_swig0.atsc_sync_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_sync_sptr self) -> int"""
        return _dtv_swig0.atsc_sync_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_sync_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_sync_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_sync_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_sync_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_sync_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_sync_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_sync_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_sync_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_sync_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_sync_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_sync_sptr self, int which) -> float
        pc_input_buffers_full(atsc_sync_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_sync_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_sync_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_sync_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_sync_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_sync_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_sync_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_sync_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_sync_sptr self, int which) -> float
        pc_output_buffers_full(atsc_sync_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_sync_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_sync_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_sync_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_sync_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_sync_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_sync_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_sync_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_sync_sptr self) -> float"""
        return _dtv_swig0.atsc_sync_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_sync_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_sync_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_sync_sptr self)"""
        return _dtv_swig0.atsc_sync_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_sync_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_sync_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_sync_sptr self) -> int"""
        return _dtv_swig0.atsc_sync_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_sync_sptr self) -> int"""
        return _dtv_swig0.atsc_sync_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_sync_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_sync_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_sync_sptr self) -> std::string"""
        return _dtv_swig0.atsc_sync_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_sync_sptr self) -> std::string"""
        return _dtv_swig0.atsc_sync_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_sync_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_sync_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_sync_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_sync_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_sync_sptr self) -> long"""
        return _dtv_swig0.atsc_sync_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_sync_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_sync_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_sync_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_sync_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_sync_sptr self) -> std::string"""
        return _dtv_swig0.atsc_sync_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_sync_sptr self, std::string name)"""
        return _dtv_swig0.atsc_sync_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_sync_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_sync_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_sync_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_sync_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_sync_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_sync_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_sync_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_sync_sptr_message_subscribers(self, which_port)

# Register atsc_sync_sptr in _dtv_swig0:
_dtv_swig0.atsc_sync_sptr_swigregister(atsc_sync_sptr)


atsc_sync_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_sync = atsc_sync.make;

class atsc_trellis_encoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_trellis_encoder > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_trellis_encoder_sptr self) -> atsc_trellis_encoder_sptr
        __init__(atsc_trellis_encoder_sptr self, atsc_trellis_encoder p) -> atsc_trellis_encoder_sptr
        """
        _dtv_swig0.atsc_trellis_encoder_sptr_swiginit(self, _dtv_swig0.new_atsc_trellis_encoder_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_trellis_encoder *":
        r"""__deref__(atsc_trellis_encoder_sptr self) -> atsc_trellis_encoder"""
        return _dtv_swig0.atsc_trellis_encoder_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_trellis_encoder_sptr

    def make(self) -> "gr::dtv::atsc_trellis_encoder::sptr":
        r"""make(atsc_trellis_encoder_sptr self) -> atsc_trellis_encoder_sptr"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_trellis_encoder_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_trellis_encoder_sptr self, int which, int delay)
        declare_sample_delay(atsc_trellis_encoder_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_trellis_encoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_trellis_encoder_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_trellis_encoder_sptr self, int multiple)"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_trellis_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_trellis_encoder_sptr self) -> double"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_trellis_encoder_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_trellis_encoder_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_trellis_encoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_trellis_encoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_trellis_encoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_trellis_encoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_trellis_encoder_sptr self, std::string level)"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_trellis_encoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_trellis_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_trellis_encoder_sptr self, int m)"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_trellis_encoder_sptr self)"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_trellis_encoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_trellis_encoder_sptr self, int m)"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_trellis_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_trellis_encoder_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_trellis_encoder_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_trellis_encoder_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_trellis_encoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_trellis_encoder_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_trellis_encoder_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_trellis_encoder_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_trellis_encoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_trellis_encoder_sptr self, int which) -> float
        pc_input_buffers_full(atsc_trellis_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_trellis_encoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_trellis_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_trellis_encoder_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_trellis_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_trellis_encoder_sptr self, int which) -> float
        pc_output_buffers_full(atsc_trellis_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_trellis_encoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_trellis_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_trellis_encoder_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_trellis_encoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_trellis_encoder_sptr self) -> float"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_trellis_encoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_trellis_encoder_sptr self)"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_trellis_encoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_trellis_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_trellis_encoder_sptr self) -> int"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_trellis_encoder_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_trellis_encoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_trellis_encoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_trellis_encoder_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_trellis_encoder_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_trellis_encoder_sptr self) -> long"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_trellis_encoder_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_trellis_encoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_trellis_encoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_trellis_encoder_sptr self, std::string name)"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_trellis_encoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_trellis_encoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_trellis_encoder_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_trellis_encoder_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_trellis_encoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_trellis_encoder_sptr_message_subscribers(self, which_port)

# Register atsc_trellis_encoder_sptr in _dtv_swig0:
_dtv_swig0.atsc_trellis_encoder_sptr_swigregister(atsc_trellis_encoder_sptr)


atsc_trellis_encoder_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_trellis_encoder = atsc_trellis_encoder.make;

class atsc_viterbi_decoder_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::atsc_viterbi_decoder > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(atsc_viterbi_decoder_sptr self) -> atsc_viterbi_decoder_sptr
        __init__(atsc_viterbi_decoder_sptr self, atsc_viterbi_decoder p) -> atsc_viterbi_decoder_sptr
        """
        _dtv_swig0.atsc_viterbi_decoder_sptr_swiginit(self, _dtv_swig0.new_atsc_viterbi_decoder_sptr(*args))

    def __deref__(self) -> "gr::dtv::atsc_viterbi_decoder *":
        r"""__deref__(atsc_viterbi_decoder_sptr self) -> atsc_viterbi_decoder"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_atsc_viterbi_decoder_sptr

    def make(self) -> "gr::dtv::atsc_viterbi_decoder::sptr":
        r"""make(atsc_viterbi_decoder_sptr self) -> atsc_viterbi_decoder_sptr"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_make(self)

    def decoder_metrics(self) -> "std::vector< float,std::allocator< float > >":
        r"""decoder_metrics(atsc_viterbi_decoder_sptr self) -> pmt_vector_float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_decoder_metrics(self)

    def history(self) -> "unsigned int":
        r"""history(atsc_viterbi_decoder_sptr self) -> unsigned int"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(atsc_viterbi_decoder_sptr self, int which, int delay)
        declare_sample_delay(atsc_viterbi_decoder_sptr self, unsigned int delay)
        """
        return _dtv_swig0.atsc_viterbi_decoder_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(atsc_viterbi_decoder_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(atsc_viterbi_decoder_sptr self, int multiple)"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(atsc_viterbi_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(atsc_viterbi_decoder_sptr self) -> double"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(atsc_viterbi_decoder_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(atsc_viterbi_decoder_sptr self) -> uint64_t"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(atsc_viterbi_decoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(atsc_viterbi_decoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(atsc_viterbi_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(atsc_viterbi_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(atsc_viterbi_decoder_sptr self, std::string level)"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(atsc_viterbi_decoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(atsc_viterbi_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(atsc_viterbi_decoder_sptr self, int m)"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(atsc_viterbi_decoder_sptr self)"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(atsc_viterbi_decoder_sptr self) -> bool"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(atsc_viterbi_decoder_sptr self, int m)"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(atsc_viterbi_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(atsc_viterbi_decoder_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(atsc_viterbi_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(atsc_viterbi_decoder_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.atsc_viterbi_decoder_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(atsc_viterbi_decoder_sptr self, int i) -> long"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(atsc_viterbi_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(atsc_viterbi_decoder_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.atsc_viterbi_decoder_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(atsc_viterbi_decoder_sptr self, int which) -> float
        pc_input_buffers_full(atsc_viterbi_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(atsc_viterbi_decoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(atsc_viterbi_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(atsc_viterbi_decoder_sptr self, int which) -> float
        pc_input_buffers_full_var(atsc_viterbi_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(atsc_viterbi_decoder_sptr self, int which) -> float
        pc_output_buffers_full(atsc_viterbi_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(atsc_viterbi_decoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(atsc_viterbi_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(atsc_viterbi_decoder_sptr self, int which) -> float
        pc_output_buffers_full_var(atsc_viterbi_decoder_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(atsc_viterbi_decoder_sptr self) -> float"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(atsc_viterbi_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(atsc_viterbi_decoder_sptr self)"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(atsc_viterbi_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(atsc_viterbi_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(atsc_viterbi_decoder_sptr self) -> int"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(atsc_viterbi_decoder_sptr self, int priority) -> int"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(atsc_viterbi_decoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(atsc_viterbi_decoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(atsc_viterbi_decoder_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(atsc_viterbi_decoder_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(atsc_viterbi_decoder_sptr self) -> long"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(atsc_viterbi_decoder_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(atsc_viterbi_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(atsc_viterbi_decoder_sptr self) -> std::string"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(atsc_viterbi_decoder_sptr self, std::string name)"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(atsc_viterbi_decoder_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(atsc_viterbi_decoder_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(atsc_viterbi_decoder_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(atsc_viterbi_decoder_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.atsc_viterbi_decoder_sptr_message_subscribers(self, which_port)

# Register atsc_viterbi_decoder_sptr in _dtv_swig0:
_dtv_swig0.atsc_viterbi_decoder_sptr_swigregister(atsc_viterbi_decoder_sptr)


atsc_viterbi_decoder_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
atsc_viterbi_decoder = atsc_viterbi_decoder.make;

class catv_transport_framing_enc_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::catv_transport_framing_enc_bb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(catv_transport_framing_enc_bb_sptr self) -> catv_transport_framing_enc_bb_sptr
        __init__(catv_transport_framing_enc_bb_sptr self, catv_transport_framing_enc_bb p) -> catv_transport_framing_enc_bb_sptr
        """
        _dtv_swig0.catv_transport_framing_enc_bb_sptr_swiginit(self, _dtv_swig0.new_catv_transport_framing_enc_bb_sptr(*args))

    def __deref__(self) -> "gr::dtv::catv_transport_framing_enc_bb *":
        r"""__deref__(catv_transport_framing_enc_bb_sptr self) -> catv_transport_framing_enc_bb"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_catv_transport_framing_enc_bb_sptr

    def make(self) -> "gr::dtv::catv_transport_framing_enc_bb::sptr":
        r"""make(catv_transport_framing_enc_bb_sptr self) -> catv_transport_framing_enc_bb_sptr"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(catv_transport_framing_enc_bb_sptr self) -> unsigned int"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(catv_transport_framing_enc_bb_sptr self, int which, int delay)
        declare_sample_delay(catv_transport_framing_enc_bb_sptr self, unsigned int delay)
        """
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(catv_transport_framing_enc_bb_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(catv_transport_framing_enc_bb_sptr self, int multiple)"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(catv_transport_framing_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(catv_transport_framing_enc_bb_sptr self) -> double"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(catv_transport_framing_enc_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(catv_transport_framing_enc_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(catv_transport_framing_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(catv_transport_framing_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(catv_transport_framing_enc_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(catv_transport_framing_enc_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(catv_transport_framing_enc_bb_sptr self, std::string level)"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(catv_transport_framing_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(catv_transport_framing_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(catv_transport_framing_enc_bb_sptr self, int m)"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(catv_transport_framing_enc_bb_sptr self)"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(catv_transport_framing_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(catv_transport_framing_enc_bb_sptr self, int m)"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(catv_transport_framing_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(catv_transport_framing_enc_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(catv_transport_framing_enc_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(catv_transport_framing_enc_bb_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(catv_transport_framing_enc_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(catv_transport_framing_enc_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(catv_transport_framing_enc_bb_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(catv_transport_framing_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full(catv_transport_framing_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(catv_transport_framing_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(catv_transport_framing_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(catv_transport_framing_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(catv_transport_framing_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(catv_transport_framing_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full(catv_transport_framing_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(catv_transport_framing_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(catv_transport_framing_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(catv_transport_framing_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(catv_transport_framing_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(catv_transport_framing_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(catv_transport_framing_enc_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(catv_transport_framing_enc_bb_sptr self)"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(catv_transport_framing_enc_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(catv_transport_framing_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(catv_transport_framing_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(catv_transport_framing_enc_bb_sptr self, int priority) -> int"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(catv_transport_framing_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(catv_transport_framing_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(catv_transport_framing_enc_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(catv_transport_framing_enc_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(catv_transport_framing_enc_bb_sptr self) -> long"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(catv_transport_framing_enc_bb_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(catv_transport_framing_enc_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(catv_transport_framing_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(catv_transport_framing_enc_bb_sptr self, std::string name)"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(catv_transport_framing_enc_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(catv_transport_framing_enc_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(catv_transport_framing_enc_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(catv_transport_framing_enc_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_transport_framing_enc_bb_sptr_message_subscribers(self, which_port)

# Register catv_transport_framing_enc_bb_sptr in _dtv_swig0:
_dtv_swig0.catv_transport_framing_enc_bb_sptr_swigregister(catv_transport_framing_enc_bb_sptr)


catv_transport_framing_enc_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
catv_transport_framing_enc_bb = catv_transport_framing_enc_bb.make;

class catv_reed_solomon_enc_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::catv_reed_solomon_enc_bb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(catv_reed_solomon_enc_bb_sptr self) -> catv_reed_solomon_enc_bb_sptr
        __init__(catv_reed_solomon_enc_bb_sptr self, catv_reed_solomon_enc_bb p) -> catv_reed_solomon_enc_bb_sptr
        """
        _dtv_swig0.catv_reed_solomon_enc_bb_sptr_swiginit(self, _dtv_swig0.new_catv_reed_solomon_enc_bb_sptr(*args))

    def __deref__(self) -> "gr::dtv::catv_reed_solomon_enc_bb *":
        r"""__deref__(catv_reed_solomon_enc_bb_sptr self) -> catv_reed_solomon_enc_bb"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_catv_reed_solomon_enc_bb_sptr

    def make(self) -> "gr::dtv::catv_reed_solomon_enc_bb::sptr":
        r"""make(catv_reed_solomon_enc_bb_sptr self) -> catv_reed_solomon_enc_bb_sptr"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(catv_reed_solomon_enc_bb_sptr self) -> unsigned int"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(catv_reed_solomon_enc_bb_sptr self, int which, int delay)
        declare_sample_delay(catv_reed_solomon_enc_bb_sptr self, unsigned int delay)
        """
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(catv_reed_solomon_enc_bb_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(catv_reed_solomon_enc_bb_sptr self, int multiple)"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(catv_reed_solomon_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(catv_reed_solomon_enc_bb_sptr self) -> double"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(catv_reed_solomon_enc_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(catv_reed_solomon_enc_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(catv_reed_solomon_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(catv_reed_solomon_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(catv_reed_solomon_enc_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(catv_reed_solomon_enc_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(catv_reed_solomon_enc_bb_sptr self, std::string level)"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(catv_reed_solomon_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(catv_reed_solomon_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(catv_reed_solomon_enc_bb_sptr self, int m)"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(catv_reed_solomon_enc_bb_sptr self)"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(catv_reed_solomon_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(catv_reed_solomon_enc_bb_sptr self, int m)"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(catv_reed_solomon_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(catv_reed_solomon_enc_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(catv_reed_solomon_enc_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(catv_reed_solomon_enc_bb_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(catv_reed_solomon_enc_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(catv_reed_solomon_enc_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(catv_reed_solomon_enc_bb_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(catv_reed_solomon_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full(catv_reed_solomon_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(catv_reed_solomon_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(catv_reed_solomon_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(catv_reed_solomon_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(catv_reed_solomon_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(catv_reed_solomon_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full(catv_reed_solomon_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(catv_reed_solomon_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(catv_reed_solomon_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(catv_reed_solomon_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(catv_reed_solomon_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(catv_reed_solomon_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(catv_reed_solomon_enc_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(catv_reed_solomon_enc_bb_sptr self)"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(catv_reed_solomon_enc_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(catv_reed_solomon_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(catv_reed_solomon_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(catv_reed_solomon_enc_bb_sptr self, int priority) -> int"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(catv_reed_solomon_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(catv_reed_solomon_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(catv_reed_solomon_enc_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(catv_reed_solomon_enc_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(catv_reed_solomon_enc_bb_sptr self) -> long"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(catv_reed_solomon_enc_bb_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(catv_reed_solomon_enc_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(catv_reed_solomon_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(catv_reed_solomon_enc_bb_sptr self, std::string name)"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(catv_reed_solomon_enc_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(catv_reed_solomon_enc_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(catv_reed_solomon_enc_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(catv_reed_solomon_enc_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_reed_solomon_enc_bb_sptr_message_subscribers(self, which_port)

# Register catv_reed_solomon_enc_bb_sptr in _dtv_swig0:
_dtv_swig0.catv_reed_solomon_enc_bb_sptr_swigregister(catv_reed_solomon_enc_bb_sptr)


catv_reed_solomon_enc_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
catv_reed_solomon_enc_bb = catv_reed_solomon_enc_bb.make;

class catv_randomizer_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::catv_randomizer_bb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(catv_randomizer_bb_sptr self) -> catv_randomizer_bb_sptr
        __init__(catv_randomizer_bb_sptr self, catv_randomizer_bb p) -> catv_randomizer_bb_sptr
        """
        _dtv_swig0.catv_randomizer_bb_sptr_swiginit(self, _dtv_swig0.new_catv_randomizer_bb_sptr(*args))

    def __deref__(self) -> "gr::dtv::catv_randomizer_bb *":
        r"""__deref__(catv_randomizer_bb_sptr self) -> catv_randomizer_bb"""
        return _dtv_swig0.catv_randomizer_bb_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_catv_randomizer_bb_sptr

    def make(self, constellation: "gr::dtv::catv_constellation_t") -> "gr::dtv::catv_randomizer_bb::sptr":
        r"""make(catv_randomizer_bb_sptr self, gr::dtv::catv_constellation_t constellation) -> catv_randomizer_bb_sptr"""
        return _dtv_swig0.catv_randomizer_bb_sptr_make(self, constellation)

    def history(self) -> "unsigned int":
        r"""history(catv_randomizer_bb_sptr self) -> unsigned int"""
        return _dtv_swig0.catv_randomizer_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(catv_randomizer_bb_sptr self, int which, int delay)
        declare_sample_delay(catv_randomizer_bb_sptr self, unsigned int delay)
        """
        return _dtv_swig0.catv_randomizer_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(catv_randomizer_bb_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.catv_randomizer_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(catv_randomizer_bb_sptr self, int multiple)"""
        return _dtv_swig0.catv_randomizer_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(catv_randomizer_bb_sptr self) -> int"""
        return _dtv_swig0.catv_randomizer_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(catv_randomizer_bb_sptr self) -> double"""
        return _dtv_swig0.catv_randomizer_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(catv_randomizer_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_randomizer_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(catv_randomizer_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_randomizer_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(catv_randomizer_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_randomizer_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(catv_randomizer_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_randomizer_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(catv_randomizer_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.catv_randomizer_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(catv_randomizer_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.catv_randomizer_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(catv_randomizer_bb_sptr self, std::string level)"""
        return _dtv_swig0.catv_randomizer_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(catv_randomizer_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_randomizer_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(catv_randomizer_bb_sptr self) -> int"""
        return _dtv_swig0.catv_randomizer_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(catv_randomizer_bb_sptr self, int m)"""
        return _dtv_swig0.catv_randomizer_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(catv_randomizer_bb_sptr self)"""
        return _dtv_swig0.catv_randomizer_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(catv_randomizer_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_randomizer_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(catv_randomizer_bb_sptr self, int m)"""
        return _dtv_swig0.catv_randomizer_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(catv_randomizer_bb_sptr self) -> int"""
        return _dtv_swig0.catv_randomizer_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(catv_randomizer_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_randomizer_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(catv_randomizer_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(catv_randomizer_bb_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.catv_randomizer_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(catv_randomizer_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_randomizer_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(catv_randomizer_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(catv_randomizer_bb_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.catv_randomizer_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(catv_randomizer_bb_sptr self, int which) -> float
        pc_input_buffers_full(catv_randomizer_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(catv_randomizer_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(catv_randomizer_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(catv_randomizer_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(catv_randomizer_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(catv_randomizer_bb_sptr self, int which) -> float
        pc_output_buffers_full(catv_randomizer_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(catv_randomizer_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(catv_randomizer_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(catv_randomizer_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(catv_randomizer_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(catv_randomizer_bb_sptr self) -> float"""
        return _dtv_swig0.catv_randomizer_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(catv_randomizer_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.catv_randomizer_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(catv_randomizer_bb_sptr self)"""
        return _dtv_swig0.catv_randomizer_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(catv_randomizer_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.catv_randomizer_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(catv_randomizer_bb_sptr self) -> int"""
        return _dtv_swig0.catv_randomizer_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(catv_randomizer_bb_sptr self) -> int"""
        return _dtv_swig0.catv_randomizer_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(catv_randomizer_bb_sptr self, int priority) -> int"""
        return _dtv_swig0.catv_randomizer_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(catv_randomizer_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_randomizer_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(catv_randomizer_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_randomizer_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(catv_randomizer_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_randomizer_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(catv_randomizer_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_randomizer_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(catv_randomizer_bb_sptr self) -> long"""
        return _dtv_swig0.catv_randomizer_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(catv_randomizer_bb_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.catv_randomizer_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(catv_randomizer_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.catv_randomizer_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(catv_randomizer_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_randomizer_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(catv_randomizer_bb_sptr self, std::string name)"""
        return _dtv_swig0.catv_randomizer_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(catv_randomizer_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.catv_randomizer_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(catv_randomizer_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_randomizer_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(catv_randomizer_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_randomizer_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(catv_randomizer_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_randomizer_bb_sptr_message_subscribers(self, which_port)

# Register catv_randomizer_bb_sptr in _dtv_swig0:
_dtv_swig0.catv_randomizer_bb_sptr_swigregister(catv_randomizer_bb_sptr)


catv_randomizer_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
catv_randomizer_bb = catv_randomizer_bb.make;

class catv_frame_sync_enc_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::catv_frame_sync_enc_bb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(catv_frame_sync_enc_bb_sptr self) -> catv_frame_sync_enc_bb_sptr
        __init__(catv_frame_sync_enc_bb_sptr self, catv_frame_sync_enc_bb p) -> catv_frame_sync_enc_bb_sptr
        """
        _dtv_swig0.catv_frame_sync_enc_bb_sptr_swiginit(self, _dtv_swig0.new_catv_frame_sync_enc_bb_sptr(*args))

    def __deref__(self) -> "gr::dtv::catv_frame_sync_enc_bb *":
        r"""__deref__(catv_frame_sync_enc_bb_sptr self) -> catv_frame_sync_enc_bb"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_catv_frame_sync_enc_bb_sptr

    def make(self, constellation: "gr::dtv::catv_constellation_t", ctrlword: "int") -> "gr::dtv::catv_frame_sync_enc_bb::sptr":
        r"""make(catv_frame_sync_enc_bb_sptr self, gr::dtv::catv_constellation_t constellation, int ctrlword) -> catv_frame_sync_enc_bb_sptr"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_make(self, constellation, ctrlword)

    def history(self) -> "unsigned int":
        r"""history(catv_frame_sync_enc_bb_sptr self) -> unsigned int"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(catv_frame_sync_enc_bb_sptr self, int which, int delay)
        declare_sample_delay(catv_frame_sync_enc_bb_sptr self, unsigned int delay)
        """
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(catv_frame_sync_enc_bb_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(catv_frame_sync_enc_bb_sptr self, int multiple)"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(catv_frame_sync_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(catv_frame_sync_enc_bb_sptr self) -> double"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(catv_frame_sync_enc_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(catv_frame_sync_enc_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(catv_frame_sync_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(catv_frame_sync_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(catv_frame_sync_enc_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(catv_frame_sync_enc_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(catv_frame_sync_enc_bb_sptr self, std::string level)"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(catv_frame_sync_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(catv_frame_sync_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(catv_frame_sync_enc_bb_sptr self, int m)"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(catv_frame_sync_enc_bb_sptr self)"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(catv_frame_sync_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(catv_frame_sync_enc_bb_sptr self, int m)"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(catv_frame_sync_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(catv_frame_sync_enc_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(catv_frame_sync_enc_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(catv_frame_sync_enc_bb_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(catv_frame_sync_enc_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(catv_frame_sync_enc_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(catv_frame_sync_enc_bb_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(catv_frame_sync_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full(catv_frame_sync_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(catv_frame_sync_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(catv_frame_sync_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(catv_frame_sync_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(catv_frame_sync_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(catv_frame_sync_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full(catv_frame_sync_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(catv_frame_sync_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(catv_frame_sync_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(catv_frame_sync_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(catv_frame_sync_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(catv_frame_sync_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(catv_frame_sync_enc_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(catv_frame_sync_enc_bb_sptr self)"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(catv_frame_sync_enc_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(catv_frame_sync_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(catv_frame_sync_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(catv_frame_sync_enc_bb_sptr self, int priority) -> int"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(catv_frame_sync_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(catv_frame_sync_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(catv_frame_sync_enc_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(catv_frame_sync_enc_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(catv_frame_sync_enc_bb_sptr self) -> long"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(catv_frame_sync_enc_bb_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(catv_frame_sync_enc_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(catv_frame_sync_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(catv_frame_sync_enc_bb_sptr self, std::string name)"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(catv_frame_sync_enc_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(catv_frame_sync_enc_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(catv_frame_sync_enc_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(catv_frame_sync_enc_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_frame_sync_enc_bb_sptr_message_subscribers(self, which_port)

# Register catv_frame_sync_enc_bb_sptr in _dtv_swig0:
_dtv_swig0.catv_frame_sync_enc_bb_sptr_swigregister(catv_frame_sync_enc_bb_sptr)


catv_frame_sync_enc_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
catv_frame_sync_enc_bb = catv_frame_sync_enc_bb.make;

class catv_trellis_enc_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::dtv::catv_trellis_enc_bb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(catv_trellis_enc_bb_sptr self) -> catv_trellis_enc_bb_sptr
        __init__(catv_trellis_enc_bb_sptr self, catv_trellis_enc_bb p) -> catv_trellis_enc_bb_sptr
        """
        _dtv_swig0.catv_trellis_enc_bb_sptr_swiginit(self, _dtv_swig0.new_catv_trellis_enc_bb_sptr(*args))

    def __deref__(self) -> "gr::dtv::catv_trellis_enc_bb *":
        r"""__deref__(catv_trellis_enc_bb_sptr self) -> catv_trellis_enc_bb"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr___deref__(self)
    __swig_destroy__ = _dtv_swig0.delete_catv_trellis_enc_bb_sptr

    def make(self, constellation: "gr::dtv::catv_constellation_t") -> "gr::dtv::catv_trellis_enc_bb::sptr":
        r"""make(catv_trellis_enc_bb_sptr self, gr::dtv::catv_constellation_t constellation) -> catv_trellis_enc_bb_sptr"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_make(self, constellation)

    def history(self) -> "unsigned int":
        r"""history(catv_trellis_enc_bb_sptr self) -> unsigned int"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(catv_trellis_enc_bb_sptr self, int which, int delay)
        declare_sample_delay(catv_trellis_enc_bb_sptr self, unsigned int delay)
        """
        return _dtv_swig0.catv_trellis_enc_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(catv_trellis_enc_bb_sptr self, int which) -> unsigned int"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(catv_trellis_enc_bb_sptr self, int multiple)"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(catv_trellis_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(catv_trellis_enc_bb_sptr self) -> double"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(catv_trellis_enc_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(catv_trellis_enc_bb_sptr self) -> uint64_t"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(catv_trellis_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(catv_trellis_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(catv_trellis_enc_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(catv_trellis_enc_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(catv_trellis_enc_bb_sptr self, std::string level)"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(catv_trellis_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(catv_trellis_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(catv_trellis_enc_bb_sptr self, int m)"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(catv_trellis_enc_bb_sptr self)"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(catv_trellis_enc_bb_sptr self) -> bool"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(catv_trellis_enc_bb_sptr self, int m)"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(catv_trellis_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(catv_trellis_enc_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(catv_trellis_enc_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(catv_trellis_enc_bb_sptr self, int port, long max_output_buffer)
        """
        return _dtv_swig0.catv_trellis_enc_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(catv_trellis_enc_bb_sptr self, int i) -> long"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(catv_trellis_enc_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(catv_trellis_enc_bb_sptr self, int port, long min_output_buffer)
        """
        return _dtv_swig0.catv_trellis_enc_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(catv_trellis_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full(catv_trellis_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(catv_trellis_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(catv_trellis_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(catv_trellis_enc_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(catv_trellis_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(catv_trellis_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full(catv_trellis_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(catv_trellis_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(catv_trellis_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(catv_trellis_enc_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(catv_trellis_enc_bb_sptr self) -> pmt_vector_float
        """
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(catv_trellis_enc_bb_sptr self) -> float"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(catv_trellis_enc_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(catv_trellis_enc_bb_sptr self)"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(catv_trellis_enc_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(catv_trellis_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(catv_trellis_enc_bb_sptr self) -> int"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(catv_trellis_enc_bb_sptr self, int priority) -> int"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(catv_trellis_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(catv_trellis_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(catv_trellis_enc_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(catv_trellis_enc_bb_sptr self) -> io_signature_sptr"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(catv_trellis_enc_bb_sptr self) -> long"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(catv_trellis_enc_bb_sptr self) -> basic_block_sptr"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(catv_trellis_enc_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(catv_trellis_enc_bb_sptr self) -> std::string"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(catv_trellis_enc_bb_sptr self, std::string name)"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(catv_trellis_enc_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(catv_trellis_enc_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(catv_trellis_enc_bb_sptr self) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(catv_trellis_enc_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _dtv_swig0.catv_trellis_enc_bb_sptr_message_subscribers(self, which_port)

# Register catv_trellis_enc_bb_sptr in _dtv_swig0:
_dtv_swig0.catv_trellis_enc_bb_sptr_swigregister(catv_trellis_enc_bb_sptr)


catv_trellis_enc_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
catv_trellis_enc_bb = catv_trellis_enc_bb.make;



