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





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_sequencer_alsa', [dirname(__file__)])
        except ImportError:
            import _sequencer_alsa
            return _sequencer_alsa
        if fp is not None:
            try:
                _mod = imp.load_module('_sequencer_alsa', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _sequencer_alsa = swig_import_helper()
    del swig_import_helper
else:
    import _sequencer_alsa
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

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



def open_client(name, type, stream, mode):
    return _sequencer_alsa.open_client(name, type, stream, mode)
open_client = _sequencer_alsa.open_client

def new_port_subscribe():
    return _sequencer_alsa.new_port_subscribe()
new_port_subscribe = _sequencer_alsa.new_port_subscribe

def new_queue_status(handle, queue):
    return _sequencer_alsa.new_queue_status(handle, queue)
new_queue_status = _sequencer_alsa.new_queue_status

def free_queue_status(qstatus):
    return _sequencer_alsa.free_queue_status(qstatus)
free_queue_status = _sequencer_alsa.free_queue_status

def new_port_info():
    return _sequencer_alsa.new_port_info()
new_port_info = _sequencer_alsa.new_port_info

def new_client_info():
    return _sequencer_alsa.new_client_info()
new_client_info = _sequencer_alsa.new_client_info

def event_input(handle):
    return _sequencer_alsa.event_input(handle)
event_input = _sequencer_alsa.event_input

def snd_seq_control_queue_eventless(handle, queue, type, value):
    return _sequencer_alsa.snd_seq_control_queue_eventless(handle, queue, type, value)
snd_seq_control_queue_eventless = _sequencer_alsa.snd_seq_control_queue_eventless

def init_queue_tempo(handle, queue, bpm, ppq):
    return _sequencer_alsa.init_queue_tempo(handle, queue, bpm, ppq)
init_queue_tempo = _sequencer_alsa.init_queue_tempo

def client_poll_descriptors(handle):
    return _sequencer_alsa.client_poll_descriptors(handle)
client_poll_descriptors = _sequencer_alsa.client_poll_descriptors

_sequencer_alsa.SND_SEQ_OPEN_OUTPUT_swigconstant(_sequencer_alsa)
SND_SEQ_OPEN_OUTPUT = _sequencer_alsa.SND_SEQ_OPEN_OUTPUT

_sequencer_alsa.SND_SEQ_OPEN_INPUT_swigconstant(_sequencer_alsa)
SND_SEQ_OPEN_INPUT = _sequencer_alsa.SND_SEQ_OPEN_INPUT

_sequencer_alsa.SND_SEQ_OPEN_DUPLEX_swigconstant(_sequencer_alsa)
SND_SEQ_OPEN_DUPLEX = _sequencer_alsa.SND_SEQ_OPEN_DUPLEX

_sequencer_alsa.SND_SEQ_NONBLOCK_swigconstant(_sequencer_alsa)
SND_SEQ_NONBLOCK = _sequencer_alsa.SND_SEQ_NONBLOCK

_sequencer_alsa.SND_SEQ_TYPE_HW_swigconstant(_sequencer_alsa)
SND_SEQ_TYPE_HW = _sequencer_alsa.SND_SEQ_TYPE_HW

_sequencer_alsa.SND_SEQ_TYPE_SHM_swigconstant(_sequencer_alsa)
SND_SEQ_TYPE_SHM = _sequencer_alsa.SND_SEQ_TYPE_SHM

_sequencer_alsa.SND_SEQ_TYPE_INET_swigconstant(_sequencer_alsa)
SND_SEQ_TYPE_INET = _sequencer_alsa.SND_SEQ_TYPE_INET

_sequencer_alsa.SND_SEQ_ADDRESS_UNKNOWN_swigconstant(_sequencer_alsa)
SND_SEQ_ADDRESS_UNKNOWN = _sequencer_alsa.SND_SEQ_ADDRESS_UNKNOWN

_sequencer_alsa.SND_SEQ_ADDRESS_SUBSCRIBERS_swigconstant(_sequencer_alsa)
SND_SEQ_ADDRESS_SUBSCRIBERS = _sequencer_alsa.SND_SEQ_ADDRESS_SUBSCRIBERS

_sequencer_alsa.SND_SEQ_ADDRESS_BROADCAST_swigconstant(_sequencer_alsa)
SND_SEQ_ADDRESS_BROADCAST = _sequencer_alsa.SND_SEQ_ADDRESS_BROADCAST

_sequencer_alsa.SND_SEQ_CLIENT_SYSTEM_swigconstant(_sequencer_alsa)
SND_SEQ_CLIENT_SYSTEM = _sequencer_alsa.SND_SEQ_CLIENT_SYSTEM

def snd_seq_open(handle, name, streams, mode):
    return _sequencer_alsa.snd_seq_open(handle, name, streams, mode)
snd_seq_open = _sequencer_alsa.snd_seq_open

def snd_seq_open_lconf(handle, name, streams, mode, lconf):
    return _sequencer_alsa.snd_seq_open_lconf(handle, name, streams, mode, lconf)
snd_seq_open_lconf = _sequencer_alsa.snd_seq_open_lconf

def snd_seq_name(seq):
    return _sequencer_alsa.snd_seq_name(seq)
snd_seq_name = _sequencer_alsa.snd_seq_name

def snd_seq_type(seq):
    return _sequencer_alsa.snd_seq_type(seq)
snd_seq_type = _sequencer_alsa.snd_seq_type

def snd_seq_close(handle):
    return _sequencer_alsa.snd_seq_close(handle)
snd_seq_close = _sequencer_alsa.snd_seq_close

def snd_seq_poll_descriptors_count(handle, events):
    return _sequencer_alsa.snd_seq_poll_descriptors_count(handle, events)
snd_seq_poll_descriptors_count = _sequencer_alsa.snd_seq_poll_descriptors_count

def snd_seq_poll_descriptors(handle, pfds, space, events):
    return _sequencer_alsa.snd_seq_poll_descriptors(handle, pfds, space, events)
snd_seq_poll_descriptors = _sequencer_alsa.snd_seq_poll_descriptors

def snd_seq_poll_descriptors_revents(seq, pfds, nfds, revents):
    return _sequencer_alsa.snd_seq_poll_descriptors_revents(seq, pfds, nfds, revents)
snd_seq_poll_descriptors_revents = _sequencer_alsa.snd_seq_poll_descriptors_revents

def snd_seq_nonblock(handle, nonblock):
    return _sequencer_alsa.snd_seq_nonblock(handle, nonblock)
snd_seq_nonblock = _sequencer_alsa.snd_seq_nonblock

def snd_seq_client_id(handle):
    return _sequencer_alsa.snd_seq_client_id(handle)
snd_seq_client_id = _sequencer_alsa.snd_seq_client_id

def snd_seq_get_output_buffer_size(handle):
    return _sequencer_alsa.snd_seq_get_output_buffer_size(handle)
snd_seq_get_output_buffer_size = _sequencer_alsa.snd_seq_get_output_buffer_size

def snd_seq_get_input_buffer_size(handle):
    return _sequencer_alsa.snd_seq_get_input_buffer_size(handle)
snd_seq_get_input_buffer_size = _sequencer_alsa.snd_seq_get_input_buffer_size

def snd_seq_set_output_buffer_size(handle, size):
    return _sequencer_alsa.snd_seq_set_output_buffer_size(handle, size)
snd_seq_set_output_buffer_size = _sequencer_alsa.snd_seq_set_output_buffer_size

def snd_seq_set_input_buffer_size(handle, size):
    return _sequencer_alsa.snd_seq_set_input_buffer_size(handle, size)
snd_seq_set_input_buffer_size = _sequencer_alsa.snd_seq_set_input_buffer_size

def snd_seq_system_info_sizeof():
    return _sequencer_alsa.snd_seq_system_info_sizeof()
snd_seq_system_info_sizeof = _sequencer_alsa.snd_seq_system_info_sizeof

def snd_seq_system_info_malloc(ptr):
    return _sequencer_alsa.snd_seq_system_info_malloc(ptr)
snd_seq_system_info_malloc = _sequencer_alsa.snd_seq_system_info_malloc

def snd_seq_system_info_free(ptr):
    return _sequencer_alsa.snd_seq_system_info_free(ptr)
snd_seq_system_info_free = _sequencer_alsa.snd_seq_system_info_free

def snd_seq_system_info_copy(dst, src):
    return _sequencer_alsa.snd_seq_system_info_copy(dst, src)
snd_seq_system_info_copy = _sequencer_alsa.snd_seq_system_info_copy

def snd_seq_system_info_get_queues(info):
    return _sequencer_alsa.snd_seq_system_info_get_queues(info)
snd_seq_system_info_get_queues = _sequencer_alsa.snd_seq_system_info_get_queues

def snd_seq_system_info_get_clients(info):
    return _sequencer_alsa.snd_seq_system_info_get_clients(info)
snd_seq_system_info_get_clients = _sequencer_alsa.snd_seq_system_info_get_clients

def snd_seq_system_info_get_ports(info):
    return _sequencer_alsa.snd_seq_system_info_get_ports(info)
snd_seq_system_info_get_ports = _sequencer_alsa.snd_seq_system_info_get_ports

def snd_seq_system_info_get_channels(info):
    return _sequencer_alsa.snd_seq_system_info_get_channels(info)
snd_seq_system_info_get_channels = _sequencer_alsa.snd_seq_system_info_get_channels

def snd_seq_system_info_get_cur_clients(info):
    return _sequencer_alsa.snd_seq_system_info_get_cur_clients(info)
snd_seq_system_info_get_cur_clients = _sequencer_alsa.snd_seq_system_info_get_cur_clients

def snd_seq_system_info_get_cur_queues(info):
    return _sequencer_alsa.snd_seq_system_info_get_cur_queues(info)
snd_seq_system_info_get_cur_queues = _sequencer_alsa.snd_seq_system_info_get_cur_queues

def snd_seq_system_info(handle, info):
    return _sequencer_alsa.snd_seq_system_info(handle, info)
snd_seq_system_info = _sequencer_alsa.snd_seq_system_info

_sequencer_alsa.SND_SEQ_USER_CLIENT_swigconstant(_sequencer_alsa)
SND_SEQ_USER_CLIENT = _sequencer_alsa.SND_SEQ_USER_CLIENT

_sequencer_alsa.SND_SEQ_KERNEL_CLIENT_swigconstant(_sequencer_alsa)
SND_SEQ_KERNEL_CLIENT = _sequencer_alsa.SND_SEQ_KERNEL_CLIENT

def snd_seq_client_info_sizeof():
    return _sequencer_alsa.snd_seq_client_info_sizeof()
snd_seq_client_info_sizeof = _sequencer_alsa.snd_seq_client_info_sizeof

def snd_seq_client_info_malloc(ptr):
    return _sequencer_alsa.snd_seq_client_info_malloc(ptr)
snd_seq_client_info_malloc = _sequencer_alsa.snd_seq_client_info_malloc

def snd_seq_client_info_free(ptr):
    return _sequencer_alsa.snd_seq_client_info_free(ptr)
snd_seq_client_info_free = _sequencer_alsa.snd_seq_client_info_free

def snd_seq_client_info_copy(dst, src):
    return _sequencer_alsa.snd_seq_client_info_copy(dst, src)
snd_seq_client_info_copy = _sequencer_alsa.snd_seq_client_info_copy

def snd_seq_client_info_get_client(info):
    return _sequencer_alsa.snd_seq_client_info_get_client(info)
snd_seq_client_info_get_client = _sequencer_alsa.snd_seq_client_info_get_client

def snd_seq_client_info_get_type(info):
    return _sequencer_alsa.snd_seq_client_info_get_type(info)
snd_seq_client_info_get_type = _sequencer_alsa.snd_seq_client_info_get_type

def snd_seq_client_info_get_name(info):
    return _sequencer_alsa.snd_seq_client_info_get_name(info)
snd_seq_client_info_get_name = _sequencer_alsa.snd_seq_client_info_get_name

def snd_seq_client_info_get_broadcast_filter(info):
    return _sequencer_alsa.snd_seq_client_info_get_broadcast_filter(info)
snd_seq_client_info_get_broadcast_filter = _sequencer_alsa.snd_seq_client_info_get_broadcast_filter

def snd_seq_client_info_get_error_bounce(info):
    return _sequencer_alsa.snd_seq_client_info_get_error_bounce(info)
snd_seq_client_info_get_error_bounce = _sequencer_alsa.snd_seq_client_info_get_error_bounce

def snd_seq_client_info_get_event_filter(info):
    return _sequencer_alsa.snd_seq_client_info_get_event_filter(info)
snd_seq_client_info_get_event_filter = _sequencer_alsa.snd_seq_client_info_get_event_filter

def snd_seq_client_info_get_num_ports(info):
    return _sequencer_alsa.snd_seq_client_info_get_num_ports(info)
snd_seq_client_info_get_num_ports = _sequencer_alsa.snd_seq_client_info_get_num_ports

def snd_seq_client_info_get_event_lost(info):
    return _sequencer_alsa.snd_seq_client_info_get_event_lost(info)
snd_seq_client_info_get_event_lost = _sequencer_alsa.snd_seq_client_info_get_event_lost

def snd_seq_client_info_set_client(info, client):
    return _sequencer_alsa.snd_seq_client_info_set_client(info, client)
snd_seq_client_info_set_client = _sequencer_alsa.snd_seq_client_info_set_client

def snd_seq_client_info_set_name(info, name):
    return _sequencer_alsa.snd_seq_client_info_set_name(info, name)
snd_seq_client_info_set_name = _sequencer_alsa.snd_seq_client_info_set_name

def snd_seq_client_info_set_broadcast_filter(info, val):
    return _sequencer_alsa.snd_seq_client_info_set_broadcast_filter(info, val)
snd_seq_client_info_set_broadcast_filter = _sequencer_alsa.snd_seq_client_info_set_broadcast_filter

def snd_seq_client_info_set_error_bounce(info, val):
    return _sequencer_alsa.snd_seq_client_info_set_error_bounce(info, val)
snd_seq_client_info_set_error_bounce = _sequencer_alsa.snd_seq_client_info_set_error_bounce

def snd_seq_client_info_set_event_filter(info, filter):
    return _sequencer_alsa.snd_seq_client_info_set_event_filter(info, filter)
snd_seq_client_info_set_event_filter = _sequencer_alsa.snd_seq_client_info_set_event_filter

def snd_seq_client_info_event_filter_clear(info):
    return _sequencer_alsa.snd_seq_client_info_event_filter_clear(info)
snd_seq_client_info_event_filter_clear = _sequencer_alsa.snd_seq_client_info_event_filter_clear

def snd_seq_client_info_event_filter_add(info, event_type):
    return _sequencer_alsa.snd_seq_client_info_event_filter_add(info, event_type)
snd_seq_client_info_event_filter_add = _sequencer_alsa.snd_seq_client_info_event_filter_add

def snd_seq_client_info_event_filter_del(info, event_type):
    return _sequencer_alsa.snd_seq_client_info_event_filter_del(info, event_type)
snd_seq_client_info_event_filter_del = _sequencer_alsa.snd_seq_client_info_event_filter_del

def snd_seq_client_info_event_filter_check(info, event_type):
    return _sequencer_alsa.snd_seq_client_info_event_filter_check(info, event_type)
snd_seq_client_info_event_filter_check = _sequencer_alsa.snd_seq_client_info_event_filter_check

def snd_seq_get_client_info(handle, info):
    return _sequencer_alsa.snd_seq_get_client_info(handle, info)
snd_seq_get_client_info = _sequencer_alsa.snd_seq_get_client_info

def snd_seq_get_any_client_info(handle, client, info):
    return _sequencer_alsa.snd_seq_get_any_client_info(handle, client, info)
snd_seq_get_any_client_info = _sequencer_alsa.snd_seq_get_any_client_info

def snd_seq_set_client_info(handle, info):
    return _sequencer_alsa.snd_seq_set_client_info(handle, info)
snd_seq_set_client_info = _sequencer_alsa.snd_seq_set_client_info

def snd_seq_query_next_client(handle, info):
    return _sequencer_alsa.snd_seq_query_next_client(handle, info)
snd_seq_query_next_client = _sequencer_alsa.snd_seq_query_next_client

def snd_seq_client_pool_sizeof():
    return _sequencer_alsa.snd_seq_client_pool_sizeof()
snd_seq_client_pool_sizeof = _sequencer_alsa.snd_seq_client_pool_sizeof

def snd_seq_client_pool_malloc(ptr):
    return _sequencer_alsa.snd_seq_client_pool_malloc(ptr)
snd_seq_client_pool_malloc = _sequencer_alsa.snd_seq_client_pool_malloc

def snd_seq_client_pool_free(ptr):
    return _sequencer_alsa.snd_seq_client_pool_free(ptr)
snd_seq_client_pool_free = _sequencer_alsa.snd_seq_client_pool_free

def snd_seq_client_pool_copy(dst, src):
    return _sequencer_alsa.snd_seq_client_pool_copy(dst, src)
snd_seq_client_pool_copy = _sequencer_alsa.snd_seq_client_pool_copy

def snd_seq_client_pool_get_client(info):
    return _sequencer_alsa.snd_seq_client_pool_get_client(info)
snd_seq_client_pool_get_client = _sequencer_alsa.snd_seq_client_pool_get_client

def snd_seq_client_pool_get_output_pool(info):
    return _sequencer_alsa.snd_seq_client_pool_get_output_pool(info)
snd_seq_client_pool_get_output_pool = _sequencer_alsa.snd_seq_client_pool_get_output_pool

def snd_seq_client_pool_get_input_pool(info):
    return _sequencer_alsa.snd_seq_client_pool_get_input_pool(info)
snd_seq_client_pool_get_input_pool = _sequencer_alsa.snd_seq_client_pool_get_input_pool

def snd_seq_client_pool_get_output_room(info):
    return _sequencer_alsa.snd_seq_client_pool_get_output_room(info)
snd_seq_client_pool_get_output_room = _sequencer_alsa.snd_seq_client_pool_get_output_room

def snd_seq_client_pool_get_output_free(info):
    return _sequencer_alsa.snd_seq_client_pool_get_output_free(info)
snd_seq_client_pool_get_output_free = _sequencer_alsa.snd_seq_client_pool_get_output_free

def snd_seq_client_pool_get_input_free(info):
    return _sequencer_alsa.snd_seq_client_pool_get_input_free(info)
snd_seq_client_pool_get_input_free = _sequencer_alsa.snd_seq_client_pool_get_input_free

def snd_seq_client_pool_set_output_pool(info, size):
    return _sequencer_alsa.snd_seq_client_pool_set_output_pool(info, size)
snd_seq_client_pool_set_output_pool = _sequencer_alsa.snd_seq_client_pool_set_output_pool

def snd_seq_client_pool_set_input_pool(info, size):
    return _sequencer_alsa.snd_seq_client_pool_set_input_pool(info, size)
snd_seq_client_pool_set_input_pool = _sequencer_alsa.snd_seq_client_pool_set_input_pool

def snd_seq_client_pool_set_output_room(info, size):
    return _sequencer_alsa.snd_seq_client_pool_set_output_room(info, size)
snd_seq_client_pool_set_output_room = _sequencer_alsa.snd_seq_client_pool_set_output_room

def snd_seq_get_client_pool(handle, info):
    return _sequencer_alsa.snd_seq_get_client_pool(handle, info)
snd_seq_get_client_pool = _sequencer_alsa.snd_seq_get_client_pool

def snd_seq_set_client_pool(handle, info):
    return _sequencer_alsa.snd_seq_set_client_pool(handle, info)
snd_seq_set_client_pool = _sequencer_alsa.snd_seq_set_client_pool

_sequencer_alsa.SND_SEQ_PORT_SYSTEM_TIMER_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_SYSTEM_TIMER = _sequencer_alsa.SND_SEQ_PORT_SYSTEM_TIMER

_sequencer_alsa.SND_SEQ_PORT_SYSTEM_ANNOUNCE_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_SYSTEM_ANNOUNCE = _sequencer_alsa.SND_SEQ_PORT_SYSTEM_ANNOUNCE

_sequencer_alsa.SND_SEQ_PORT_CAP_READ_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_CAP_READ = _sequencer_alsa.SND_SEQ_PORT_CAP_READ

_sequencer_alsa.SND_SEQ_PORT_CAP_WRITE_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_CAP_WRITE = _sequencer_alsa.SND_SEQ_PORT_CAP_WRITE

_sequencer_alsa.SND_SEQ_PORT_CAP_SYNC_READ_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_CAP_SYNC_READ = _sequencer_alsa.SND_SEQ_PORT_CAP_SYNC_READ

_sequencer_alsa.SND_SEQ_PORT_CAP_SYNC_WRITE_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_CAP_SYNC_WRITE = _sequencer_alsa.SND_SEQ_PORT_CAP_SYNC_WRITE

_sequencer_alsa.SND_SEQ_PORT_CAP_DUPLEX_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_CAP_DUPLEX = _sequencer_alsa.SND_SEQ_PORT_CAP_DUPLEX

_sequencer_alsa.SND_SEQ_PORT_CAP_SUBS_READ_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_CAP_SUBS_READ = _sequencer_alsa.SND_SEQ_PORT_CAP_SUBS_READ

_sequencer_alsa.SND_SEQ_PORT_CAP_SUBS_WRITE_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_CAP_SUBS_WRITE = _sequencer_alsa.SND_SEQ_PORT_CAP_SUBS_WRITE

_sequencer_alsa.SND_SEQ_PORT_CAP_NO_EXPORT_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_CAP_NO_EXPORT = _sequencer_alsa.SND_SEQ_PORT_CAP_NO_EXPORT

_sequencer_alsa.SND_SEQ_PORT_TYPE_SPECIFIC_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_SPECIFIC = _sequencer_alsa.SND_SEQ_PORT_TYPE_SPECIFIC

_sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_GENERIC_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_MIDI_GENERIC = _sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_GENERIC

_sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_GM_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_MIDI_GM = _sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_GM

_sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_GS_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_MIDI_GS = _sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_GS

_sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_XG_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_MIDI_XG = _sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_XG

_sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_MT32_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_MIDI_MT32 = _sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_MT32

_sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_GM2_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_MIDI_GM2 = _sequencer_alsa.SND_SEQ_PORT_TYPE_MIDI_GM2

_sequencer_alsa.SND_SEQ_PORT_TYPE_SYNTH_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_SYNTH = _sequencer_alsa.SND_SEQ_PORT_TYPE_SYNTH

_sequencer_alsa.SND_SEQ_PORT_TYPE_DIRECT_SAMPLE_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_DIRECT_SAMPLE = _sequencer_alsa.SND_SEQ_PORT_TYPE_DIRECT_SAMPLE

_sequencer_alsa.SND_SEQ_PORT_TYPE_SAMPLE_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_SAMPLE = _sequencer_alsa.SND_SEQ_PORT_TYPE_SAMPLE

_sequencer_alsa.SND_SEQ_PORT_TYPE_HARDWARE_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_HARDWARE = _sequencer_alsa.SND_SEQ_PORT_TYPE_HARDWARE

_sequencer_alsa.SND_SEQ_PORT_TYPE_SOFTWARE_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_SOFTWARE = _sequencer_alsa.SND_SEQ_PORT_TYPE_SOFTWARE

_sequencer_alsa.SND_SEQ_PORT_TYPE_SYNTHESIZER_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_SYNTHESIZER = _sequencer_alsa.SND_SEQ_PORT_TYPE_SYNTHESIZER

_sequencer_alsa.SND_SEQ_PORT_TYPE_PORT_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_PORT = _sequencer_alsa.SND_SEQ_PORT_TYPE_PORT

_sequencer_alsa.SND_SEQ_PORT_TYPE_APPLICATION_swigconstant(_sequencer_alsa)
SND_SEQ_PORT_TYPE_APPLICATION = _sequencer_alsa.SND_SEQ_PORT_TYPE_APPLICATION

def snd_seq_port_info_sizeof():
    return _sequencer_alsa.snd_seq_port_info_sizeof()
snd_seq_port_info_sizeof = _sequencer_alsa.snd_seq_port_info_sizeof

def snd_seq_port_info_malloc(ptr):
    return _sequencer_alsa.snd_seq_port_info_malloc(ptr)
snd_seq_port_info_malloc = _sequencer_alsa.snd_seq_port_info_malloc

def snd_seq_port_info_free(ptr):
    return _sequencer_alsa.snd_seq_port_info_free(ptr)
snd_seq_port_info_free = _sequencer_alsa.snd_seq_port_info_free

def snd_seq_port_info_copy(dst, src):
    return _sequencer_alsa.snd_seq_port_info_copy(dst, src)
snd_seq_port_info_copy = _sequencer_alsa.snd_seq_port_info_copy

def snd_seq_port_info_get_client(info):
    return _sequencer_alsa.snd_seq_port_info_get_client(info)
snd_seq_port_info_get_client = _sequencer_alsa.snd_seq_port_info_get_client

def snd_seq_port_info_get_port(info):
    return _sequencer_alsa.snd_seq_port_info_get_port(info)
snd_seq_port_info_get_port = _sequencer_alsa.snd_seq_port_info_get_port

def snd_seq_port_info_get_addr(info):
    return _sequencer_alsa.snd_seq_port_info_get_addr(info)
snd_seq_port_info_get_addr = _sequencer_alsa.snd_seq_port_info_get_addr

def snd_seq_port_info_get_name(info):
    return _sequencer_alsa.snd_seq_port_info_get_name(info)
snd_seq_port_info_get_name = _sequencer_alsa.snd_seq_port_info_get_name

def snd_seq_port_info_get_capability(info):
    return _sequencer_alsa.snd_seq_port_info_get_capability(info)
snd_seq_port_info_get_capability = _sequencer_alsa.snd_seq_port_info_get_capability

def snd_seq_port_info_get_type(info):
    return _sequencer_alsa.snd_seq_port_info_get_type(info)
snd_seq_port_info_get_type = _sequencer_alsa.snd_seq_port_info_get_type

def snd_seq_port_info_get_midi_channels(info):
    return _sequencer_alsa.snd_seq_port_info_get_midi_channels(info)
snd_seq_port_info_get_midi_channels = _sequencer_alsa.snd_seq_port_info_get_midi_channels

def snd_seq_port_info_get_midi_voices(info):
    return _sequencer_alsa.snd_seq_port_info_get_midi_voices(info)
snd_seq_port_info_get_midi_voices = _sequencer_alsa.snd_seq_port_info_get_midi_voices

def snd_seq_port_info_get_synth_voices(info):
    return _sequencer_alsa.snd_seq_port_info_get_synth_voices(info)
snd_seq_port_info_get_synth_voices = _sequencer_alsa.snd_seq_port_info_get_synth_voices

def snd_seq_port_info_get_read_use(info):
    return _sequencer_alsa.snd_seq_port_info_get_read_use(info)
snd_seq_port_info_get_read_use = _sequencer_alsa.snd_seq_port_info_get_read_use

def snd_seq_port_info_get_write_use(info):
    return _sequencer_alsa.snd_seq_port_info_get_write_use(info)
snd_seq_port_info_get_write_use = _sequencer_alsa.snd_seq_port_info_get_write_use

def snd_seq_port_info_get_port_specified(info):
    return _sequencer_alsa.snd_seq_port_info_get_port_specified(info)
snd_seq_port_info_get_port_specified = _sequencer_alsa.snd_seq_port_info_get_port_specified

def snd_seq_port_info_get_timestamping(info):
    return _sequencer_alsa.snd_seq_port_info_get_timestamping(info)
snd_seq_port_info_get_timestamping = _sequencer_alsa.snd_seq_port_info_get_timestamping

def snd_seq_port_info_get_timestamp_real(info):
    return _sequencer_alsa.snd_seq_port_info_get_timestamp_real(info)
snd_seq_port_info_get_timestamp_real = _sequencer_alsa.snd_seq_port_info_get_timestamp_real

def snd_seq_port_info_get_timestamp_queue(info):
    return _sequencer_alsa.snd_seq_port_info_get_timestamp_queue(info)
snd_seq_port_info_get_timestamp_queue = _sequencer_alsa.snd_seq_port_info_get_timestamp_queue

def snd_seq_port_info_set_client(info, client):
    return _sequencer_alsa.snd_seq_port_info_set_client(info, client)
snd_seq_port_info_set_client = _sequencer_alsa.snd_seq_port_info_set_client

def snd_seq_port_info_set_port(info, port):
    return _sequencer_alsa.snd_seq_port_info_set_port(info, port)
snd_seq_port_info_set_port = _sequencer_alsa.snd_seq_port_info_set_port

def snd_seq_port_info_set_addr(info, addr):
    return _sequencer_alsa.snd_seq_port_info_set_addr(info, addr)
snd_seq_port_info_set_addr = _sequencer_alsa.snd_seq_port_info_set_addr

def snd_seq_port_info_set_name(info, name):
    return _sequencer_alsa.snd_seq_port_info_set_name(info, name)
snd_seq_port_info_set_name = _sequencer_alsa.snd_seq_port_info_set_name

def snd_seq_port_info_set_capability(info, capability):
    return _sequencer_alsa.snd_seq_port_info_set_capability(info, capability)
snd_seq_port_info_set_capability = _sequencer_alsa.snd_seq_port_info_set_capability

def snd_seq_port_info_set_type(info, type):
    return _sequencer_alsa.snd_seq_port_info_set_type(info, type)
snd_seq_port_info_set_type = _sequencer_alsa.snd_seq_port_info_set_type

def snd_seq_port_info_set_midi_channels(info, channels):
    return _sequencer_alsa.snd_seq_port_info_set_midi_channels(info, channels)
snd_seq_port_info_set_midi_channels = _sequencer_alsa.snd_seq_port_info_set_midi_channels

def snd_seq_port_info_set_midi_voices(info, voices):
    return _sequencer_alsa.snd_seq_port_info_set_midi_voices(info, voices)
snd_seq_port_info_set_midi_voices = _sequencer_alsa.snd_seq_port_info_set_midi_voices

def snd_seq_port_info_set_synth_voices(info, voices):
    return _sequencer_alsa.snd_seq_port_info_set_synth_voices(info, voices)
snd_seq_port_info_set_synth_voices = _sequencer_alsa.snd_seq_port_info_set_synth_voices

def snd_seq_port_info_set_port_specified(info, val):
    return _sequencer_alsa.snd_seq_port_info_set_port_specified(info, val)
snd_seq_port_info_set_port_specified = _sequencer_alsa.snd_seq_port_info_set_port_specified

def snd_seq_port_info_set_timestamping(info, enable):
    return _sequencer_alsa.snd_seq_port_info_set_timestamping(info, enable)
snd_seq_port_info_set_timestamping = _sequencer_alsa.snd_seq_port_info_set_timestamping

def snd_seq_port_info_set_timestamp_real(info, realtime):
    return _sequencer_alsa.snd_seq_port_info_set_timestamp_real(info, realtime)
snd_seq_port_info_set_timestamp_real = _sequencer_alsa.snd_seq_port_info_set_timestamp_real

def snd_seq_port_info_set_timestamp_queue(info, queue):
    return _sequencer_alsa.snd_seq_port_info_set_timestamp_queue(info, queue)
snd_seq_port_info_set_timestamp_queue = _sequencer_alsa.snd_seq_port_info_set_timestamp_queue

def snd_seq_create_port(handle, info):
    return _sequencer_alsa.snd_seq_create_port(handle, info)
snd_seq_create_port = _sequencer_alsa.snd_seq_create_port

def snd_seq_delete_port(handle, port):
    return _sequencer_alsa.snd_seq_delete_port(handle, port)
snd_seq_delete_port = _sequencer_alsa.snd_seq_delete_port

def snd_seq_get_port_info(handle, port, info):
    return _sequencer_alsa.snd_seq_get_port_info(handle, port, info)
snd_seq_get_port_info = _sequencer_alsa.snd_seq_get_port_info

def snd_seq_get_any_port_info(handle, client, port, info):
    return _sequencer_alsa.snd_seq_get_any_port_info(handle, client, port, info)
snd_seq_get_any_port_info = _sequencer_alsa.snd_seq_get_any_port_info

def snd_seq_set_port_info(handle, port, info):
    return _sequencer_alsa.snd_seq_set_port_info(handle, port, info)
snd_seq_set_port_info = _sequencer_alsa.snd_seq_set_port_info

def snd_seq_query_next_port(handle, info):
    return _sequencer_alsa.snd_seq_query_next_port(handle, info)
snd_seq_query_next_port = _sequencer_alsa.snd_seq_query_next_port

def snd_seq_port_subscribe_sizeof():
    return _sequencer_alsa.snd_seq_port_subscribe_sizeof()
snd_seq_port_subscribe_sizeof = _sequencer_alsa.snd_seq_port_subscribe_sizeof

def snd_seq_port_subscribe_malloc(ptr):
    return _sequencer_alsa.snd_seq_port_subscribe_malloc(ptr)
snd_seq_port_subscribe_malloc = _sequencer_alsa.snd_seq_port_subscribe_malloc

def snd_seq_port_subscribe_free(ptr):
    return _sequencer_alsa.snd_seq_port_subscribe_free(ptr)
snd_seq_port_subscribe_free = _sequencer_alsa.snd_seq_port_subscribe_free

def snd_seq_port_subscribe_copy(dst, src):
    return _sequencer_alsa.snd_seq_port_subscribe_copy(dst, src)
snd_seq_port_subscribe_copy = _sequencer_alsa.snd_seq_port_subscribe_copy

def snd_seq_port_subscribe_get_sender(info):
    return _sequencer_alsa.snd_seq_port_subscribe_get_sender(info)
snd_seq_port_subscribe_get_sender = _sequencer_alsa.snd_seq_port_subscribe_get_sender

def snd_seq_port_subscribe_get_dest(info):
    return _sequencer_alsa.snd_seq_port_subscribe_get_dest(info)
snd_seq_port_subscribe_get_dest = _sequencer_alsa.snd_seq_port_subscribe_get_dest

def snd_seq_port_subscribe_get_queue(info):
    return _sequencer_alsa.snd_seq_port_subscribe_get_queue(info)
snd_seq_port_subscribe_get_queue = _sequencer_alsa.snd_seq_port_subscribe_get_queue

def snd_seq_port_subscribe_get_exclusive(info):
    return _sequencer_alsa.snd_seq_port_subscribe_get_exclusive(info)
snd_seq_port_subscribe_get_exclusive = _sequencer_alsa.snd_seq_port_subscribe_get_exclusive

def snd_seq_port_subscribe_get_time_update(info):
    return _sequencer_alsa.snd_seq_port_subscribe_get_time_update(info)
snd_seq_port_subscribe_get_time_update = _sequencer_alsa.snd_seq_port_subscribe_get_time_update

def snd_seq_port_subscribe_get_time_real(info):
    return _sequencer_alsa.snd_seq_port_subscribe_get_time_real(info)
snd_seq_port_subscribe_get_time_real = _sequencer_alsa.snd_seq_port_subscribe_get_time_real

def snd_seq_port_subscribe_set_sender(info, addr):
    return _sequencer_alsa.snd_seq_port_subscribe_set_sender(info, addr)
snd_seq_port_subscribe_set_sender = _sequencer_alsa.snd_seq_port_subscribe_set_sender

def snd_seq_port_subscribe_set_dest(info, addr):
    return _sequencer_alsa.snd_seq_port_subscribe_set_dest(info, addr)
snd_seq_port_subscribe_set_dest = _sequencer_alsa.snd_seq_port_subscribe_set_dest

def snd_seq_port_subscribe_set_queue(info, q):
    return _sequencer_alsa.snd_seq_port_subscribe_set_queue(info, q)
snd_seq_port_subscribe_set_queue = _sequencer_alsa.snd_seq_port_subscribe_set_queue

def snd_seq_port_subscribe_set_exclusive(info, val):
    return _sequencer_alsa.snd_seq_port_subscribe_set_exclusive(info, val)
snd_seq_port_subscribe_set_exclusive = _sequencer_alsa.snd_seq_port_subscribe_set_exclusive

def snd_seq_port_subscribe_set_time_update(info, val):
    return _sequencer_alsa.snd_seq_port_subscribe_set_time_update(info, val)
snd_seq_port_subscribe_set_time_update = _sequencer_alsa.snd_seq_port_subscribe_set_time_update

def snd_seq_port_subscribe_set_time_real(info, val):
    return _sequencer_alsa.snd_seq_port_subscribe_set_time_real(info, val)
snd_seq_port_subscribe_set_time_real = _sequencer_alsa.snd_seq_port_subscribe_set_time_real

def snd_seq_get_port_subscription(handle, sub):
    return _sequencer_alsa.snd_seq_get_port_subscription(handle, sub)
snd_seq_get_port_subscription = _sequencer_alsa.snd_seq_get_port_subscription

def snd_seq_subscribe_port(handle, sub):
    return _sequencer_alsa.snd_seq_subscribe_port(handle, sub)
snd_seq_subscribe_port = _sequencer_alsa.snd_seq_subscribe_port

def snd_seq_unsubscribe_port(handle, sub):
    return _sequencer_alsa.snd_seq_unsubscribe_port(handle, sub)
snd_seq_unsubscribe_port = _sequencer_alsa.snd_seq_unsubscribe_port

_sequencer_alsa.SND_SEQ_QUERY_SUBS_READ_swigconstant(_sequencer_alsa)
SND_SEQ_QUERY_SUBS_READ = _sequencer_alsa.SND_SEQ_QUERY_SUBS_READ

_sequencer_alsa.SND_SEQ_QUERY_SUBS_WRITE_swigconstant(_sequencer_alsa)
SND_SEQ_QUERY_SUBS_WRITE = _sequencer_alsa.SND_SEQ_QUERY_SUBS_WRITE

def snd_seq_query_subscribe_sizeof():
    return _sequencer_alsa.snd_seq_query_subscribe_sizeof()
snd_seq_query_subscribe_sizeof = _sequencer_alsa.snd_seq_query_subscribe_sizeof

def snd_seq_query_subscribe_malloc(ptr):
    return _sequencer_alsa.snd_seq_query_subscribe_malloc(ptr)
snd_seq_query_subscribe_malloc = _sequencer_alsa.snd_seq_query_subscribe_malloc

def snd_seq_query_subscribe_free(ptr):
    return _sequencer_alsa.snd_seq_query_subscribe_free(ptr)
snd_seq_query_subscribe_free = _sequencer_alsa.snd_seq_query_subscribe_free

def snd_seq_query_subscribe_copy(dst, src):
    return _sequencer_alsa.snd_seq_query_subscribe_copy(dst, src)
snd_seq_query_subscribe_copy = _sequencer_alsa.snd_seq_query_subscribe_copy

def snd_seq_query_subscribe_get_client(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_client(info)
snd_seq_query_subscribe_get_client = _sequencer_alsa.snd_seq_query_subscribe_get_client

def snd_seq_query_subscribe_get_port(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_port(info)
snd_seq_query_subscribe_get_port = _sequencer_alsa.snd_seq_query_subscribe_get_port

def snd_seq_query_subscribe_get_root(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_root(info)
snd_seq_query_subscribe_get_root = _sequencer_alsa.snd_seq_query_subscribe_get_root

def snd_seq_query_subscribe_get_type(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_type(info)
snd_seq_query_subscribe_get_type = _sequencer_alsa.snd_seq_query_subscribe_get_type

def snd_seq_query_subscribe_get_index(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_index(info)
snd_seq_query_subscribe_get_index = _sequencer_alsa.snd_seq_query_subscribe_get_index

def snd_seq_query_subscribe_get_num_subs(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_num_subs(info)
snd_seq_query_subscribe_get_num_subs = _sequencer_alsa.snd_seq_query_subscribe_get_num_subs

def snd_seq_query_subscribe_get_addr(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_addr(info)
snd_seq_query_subscribe_get_addr = _sequencer_alsa.snd_seq_query_subscribe_get_addr

def snd_seq_query_subscribe_get_queue(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_queue(info)
snd_seq_query_subscribe_get_queue = _sequencer_alsa.snd_seq_query_subscribe_get_queue

def snd_seq_query_subscribe_get_exclusive(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_exclusive(info)
snd_seq_query_subscribe_get_exclusive = _sequencer_alsa.snd_seq_query_subscribe_get_exclusive

def snd_seq_query_subscribe_get_time_update(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_time_update(info)
snd_seq_query_subscribe_get_time_update = _sequencer_alsa.snd_seq_query_subscribe_get_time_update

def snd_seq_query_subscribe_get_time_real(info):
    return _sequencer_alsa.snd_seq_query_subscribe_get_time_real(info)
snd_seq_query_subscribe_get_time_real = _sequencer_alsa.snd_seq_query_subscribe_get_time_real

def snd_seq_query_subscribe_set_client(info, client):
    return _sequencer_alsa.snd_seq_query_subscribe_set_client(info, client)
snd_seq_query_subscribe_set_client = _sequencer_alsa.snd_seq_query_subscribe_set_client

def snd_seq_query_subscribe_set_port(info, port):
    return _sequencer_alsa.snd_seq_query_subscribe_set_port(info, port)
snd_seq_query_subscribe_set_port = _sequencer_alsa.snd_seq_query_subscribe_set_port

def snd_seq_query_subscribe_set_root(info, addr):
    return _sequencer_alsa.snd_seq_query_subscribe_set_root(info, addr)
snd_seq_query_subscribe_set_root = _sequencer_alsa.snd_seq_query_subscribe_set_root

def snd_seq_query_subscribe_set_type(info, type):
    return _sequencer_alsa.snd_seq_query_subscribe_set_type(info, type)
snd_seq_query_subscribe_set_type = _sequencer_alsa.snd_seq_query_subscribe_set_type

def snd_seq_query_subscribe_set_index(info, _index):
    return _sequencer_alsa.snd_seq_query_subscribe_set_index(info, _index)
snd_seq_query_subscribe_set_index = _sequencer_alsa.snd_seq_query_subscribe_set_index

def snd_seq_query_port_subscribers(seq, subs):
    return _sequencer_alsa.snd_seq_query_port_subscribers(seq, subs)
snd_seq_query_port_subscribers = _sequencer_alsa.snd_seq_query_port_subscribers

_sequencer_alsa.SND_SEQ_QUEUE_DIRECT_swigconstant(_sequencer_alsa)
SND_SEQ_QUEUE_DIRECT = _sequencer_alsa.SND_SEQ_QUEUE_DIRECT

def snd_seq_queue_info_sizeof():
    return _sequencer_alsa.snd_seq_queue_info_sizeof()
snd_seq_queue_info_sizeof = _sequencer_alsa.snd_seq_queue_info_sizeof

def snd_seq_queue_info_malloc(ptr):
    return _sequencer_alsa.snd_seq_queue_info_malloc(ptr)
snd_seq_queue_info_malloc = _sequencer_alsa.snd_seq_queue_info_malloc

def snd_seq_queue_info_free(ptr):
    return _sequencer_alsa.snd_seq_queue_info_free(ptr)
snd_seq_queue_info_free = _sequencer_alsa.snd_seq_queue_info_free

def snd_seq_queue_info_copy(dst, src):
    return _sequencer_alsa.snd_seq_queue_info_copy(dst, src)
snd_seq_queue_info_copy = _sequencer_alsa.snd_seq_queue_info_copy

def snd_seq_queue_info_get_queue(info):
    return _sequencer_alsa.snd_seq_queue_info_get_queue(info)
snd_seq_queue_info_get_queue = _sequencer_alsa.snd_seq_queue_info_get_queue

def snd_seq_queue_info_get_name(info):
    return _sequencer_alsa.snd_seq_queue_info_get_name(info)
snd_seq_queue_info_get_name = _sequencer_alsa.snd_seq_queue_info_get_name

def snd_seq_queue_info_get_owner(info):
    return _sequencer_alsa.snd_seq_queue_info_get_owner(info)
snd_seq_queue_info_get_owner = _sequencer_alsa.snd_seq_queue_info_get_owner

def snd_seq_queue_info_get_locked(info):
    return _sequencer_alsa.snd_seq_queue_info_get_locked(info)
snd_seq_queue_info_get_locked = _sequencer_alsa.snd_seq_queue_info_get_locked

def snd_seq_queue_info_get_flags(info):
    return _sequencer_alsa.snd_seq_queue_info_get_flags(info)
snd_seq_queue_info_get_flags = _sequencer_alsa.snd_seq_queue_info_get_flags

def snd_seq_queue_info_set_name(info, name):
    return _sequencer_alsa.snd_seq_queue_info_set_name(info, name)
snd_seq_queue_info_set_name = _sequencer_alsa.snd_seq_queue_info_set_name

def snd_seq_queue_info_set_owner(info, owner):
    return _sequencer_alsa.snd_seq_queue_info_set_owner(info, owner)
snd_seq_queue_info_set_owner = _sequencer_alsa.snd_seq_queue_info_set_owner

def snd_seq_queue_info_set_locked(info, locked):
    return _sequencer_alsa.snd_seq_queue_info_set_locked(info, locked)
snd_seq_queue_info_set_locked = _sequencer_alsa.snd_seq_queue_info_set_locked

def snd_seq_queue_info_set_flags(info, flags):
    return _sequencer_alsa.snd_seq_queue_info_set_flags(info, flags)
snd_seq_queue_info_set_flags = _sequencer_alsa.snd_seq_queue_info_set_flags

def snd_seq_create_queue(seq, info):
    return _sequencer_alsa.snd_seq_create_queue(seq, info)
snd_seq_create_queue = _sequencer_alsa.snd_seq_create_queue

def snd_seq_alloc_named_queue(seq, name):
    return _sequencer_alsa.snd_seq_alloc_named_queue(seq, name)
snd_seq_alloc_named_queue = _sequencer_alsa.snd_seq_alloc_named_queue

def snd_seq_alloc_queue(handle):
    return _sequencer_alsa.snd_seq_alloc_queue(handle)
snd_seq_alloc_queue = _sequencer_alsa.snd_seq_alloc_queue

def snd_seq_free_queue(handle, q):
    return _sequencer_alsa.snd_seq_free_queue(handle, q)
snd_seq_free_queue = _sequencer_alsa.snd_seq_free_queue

def snd_seq_get_queue_info(seq, q, info):
    return _sequencer_alsa.snd_seq_get_queue_info(seq, q, info)
snd_seq_get_queue_info = _sequencer_alsa.snd_seq_get_queue_info

def snd_seq_set_queue_info(seq, q, info):
    return _sequencer_alsa.snd_seq_set_queue_info(seq, q, info)
snd_seq_set_queue_info = _sequencer_alsa.snd_seq_set_queue_info

def snd_seq_query_named_queue(seq, name):
    return _sequencer_alsa.snd_seq_query_named_queue(seq, name)
snd_seq_query_named_queue = _sequencer_alsa.snd_seq_query_named_queue

def snd_seq_get_queue_usage(handle, q):
    return _sequencer_alsa.snd_seq_get_queue_usage(handle, q)
snd_seq_get_queue_usage = _sequencer_alsa.snd_seq_get_queue_usage

def snd_seq_set_queue_usage(handle, q, used):
    return _sequencer_alsa.snd_seq_set_queue_usage(handle, q, used)
snd_seq_set_queue_usage = _sequencer_alsa.snd_seq_set_queue_usage

def snd_seq_queue_status_sizeof():
    return _sequencer_alsa.snd_seq_queue_status_sizeof()
snd_seq_queue_status_sizeof = _sequencer_alsa.snd_seq_queue_status_sizeof

def snd_seq_queue_status_malloc(ptr):
    return _sequencer_alsa.snd_seq_queue_status_malloc(ptr)
snd_seq_queue_status_malloc = _sequencer_alsa.snd_seq_queue_status_malloc

def snd_seq_queue_status_free(ptr):
    return _sequencer_alsa.snd_seq_queue_status_free(ptr)
snd_seq_queue_status_free = _sequencer_alsa.snd_seq_queue_status_free

def snd_seq_queue_status_copy(dst, src):
    return _sequencer_alsa.snd_seq_queue_status_copy(dst, src)
snd_seq_queue_status_copy = _sequencer_alsa.snd_seq_queue_status_copy

def snd_seq_queue_status_get_queue(info):
    return _sequencer_alsa.snd_seq_queue_status_get_queue(info)
snd_seq_queue_status_get_queue = _sequencer_alsa.snd_seq_queue_status_get_queue

def snd_seq_queue_status_get_events(info):
    return _sequencer_alsa.snd_seq_queue_status_get_events(info)
snd_seq_queue_status_get_events = _sequencer_alsa.snd_seq_queue_status_get_events

def snd_seq_queue_status_get_tick_time(info):
    return _sequencer_alsa.snd_seq_queue_status_get_tick_time(info)
snd_seq_queue_status_get_tick_time = _sequencer_alsa.snd_seq_queue_status_get_tick_time

def snd_seq_queue_status_get_real_time(info):
    return _sequencer_alsa.snd_seq_queue_status_get_real_time(info)
snd_seq_queue_status_get_real_time = _sequencer_alsa.snd_seq_queue_status_get_real_time

def snd_seq_queue_status_get_status(info):
    return _sequencer_alsa.snd_seq_queue_status_get_status(info)
snd_seq_queue_status_get_status = _sequencer_alsa.snd_seq_queue_status_get_status

def snd_seq_get_queue_status(handle, q, status):
    return _sequencer_alsa.snd_seq_get_queue_status(handle, q, status)
snd_seq_get_queue_status = _sequencer_alsa.snd_seq_get_queue_status

def snd_seq_queue_tempo_sizeof():
    return _sequencer_alsa.snd_seq_queue_tempo_sizeof()
snd_seq_queue_tempo_sizeof = _sequencer_alsa.snd_seq_queue_tempo_sizeof

def snd_seq_queue_tempo_malloc(ptr):
    return _sequencer_alsa.snd_seq_queue_tempo_malloc(ptr)
snd_seq_queue_tempo_malloc = _sequencer_alsa.snd_seq_queue_tempo_malloc

def snd_seq_queue_tempo_free(ptr):
    return _sequencer_alsa.snd_seq_queue_tempo_free(ptr)
snd_seq_queue_tempo_free = _sequencer_alsa.snd_seq_queue_tempo_free

def snd_seq_queue_tempo_copy(dst, src):
    return _sequencer_alsa.snd_seq_queue_tempo_copy(dst, src)
snd_seq_queue_tempo_copy = _sequencer_alsa.snd_seq_queue_tempo_copy

def snd_seq_queue_tempo_get_queue(info):
    return _sequencer_alsa.snd_seq_queue_tempo_get_queue(info)
snd_seq_queue_tempo_get_queue = _sequencer_alsa.snd_seq_queue_tempo_get_queue

def snd_seq_queue_tempo_get_tempo(info):
    return _sequencer_alsa.snd_seq_queue_tempo_get_tempo(info)
snd_seq_queue_tempo_get_tempo = _sequencer_alsa.snd_seq_queue_tempo_get_tempo

def snd_seq_queue_tempo_get_ppq(info):
    return _sequencer_alsa.snd_seq_queue_tempo_get_ppq(info)
snd_seq_queue_tempo_get_ppq = _sequencer_alsa.snd_seq_queue_tempo_get_ppq

def snd_seq_queue_tempo_get_skew(info):
    return _sequencer_alsa.snd_seq_queue_tempo_get_skew(info)
snd_seq_queue_tempo_get_skew = _sequencer_alsa.snd_seq_queue_tempo_get_skew

def snd_seq_queue_tempo_get_skew_base(info):
    return _sequencer_alsa.snd_seq_queue_tempo_get_skew_base(info)
snd_seq_queue_tempo_get_skew_base = _sequencer_alsa.snd_seq_queue_tempo_get_skew_base

def snd_seq_queue_tempo_set_tempo(info, tempo):
    return _sequencer_alsa.snd_seq_queue_tempo_set_tempo(info, tempo)
snd_seq_queue_tempo_set_tempo = _sequencer_alsa.snd_seq_queue_tempo_set_tempo

def snd_seq_queue_tempo_set_ppq(info, ppq):
    return _sequencer_alsa.snd_seq_queue_tempo_set_ppq(info, ppq)
snd_seq_queue_tempo_set_ppq = _sequencer_alsa.snd_seq_queue_tempo_set_ppq

def snd_seq_queue_tempo_set_skew(info, skew):
    return _sequencer_alsa.snd_seq_queue_tempo_set_skew(info, skew)
snd_seq_queue_tempo_set_skew = _sequencer_alsa.snd_seq_queue_tempo_set_skew

def snd_seq_queue_tempo_set_skew_base(info, base):
    return _sequencer_alsa.snd_seq_queue_tempo_set_skew_base(info, base)
snd_seq_queue_tempo_set_skew_base = _sequencer_alsa.snd_seq_queue_tempo_set_skew_base

def snd_seq_get_queue_tempo(handle, q, tempo):
    return _sequencer_alsa.snd_seq_get_queue_tempo(handle, q, tempo)
snd_seq_get_queue_tempo = _sequencer_alsa.snd_seq_get_queue_tempo

def snd_seq_set_queue_tempo(handle, q, tempo):
    return _sequencer_alsa.snd_seq_set_queue_tempo(handle, q, tempo)
snd_seq_set_queue_tempo = _sequencer_alsa.snd_seq_set_queue_tempo

_sequencer_alsa.SND_SEQ_TIMER_ALSA_swigconstant(_sequencer_alsa)
SND_SEQ_TIMER_ALSA = _sequencer_alsa.SND_SEQ_TIMER_ALSA

_sequencer_alsa.SND_SEQ_TIMER_MIDI_CLOCK_swigconstant(_sequencer_alsa)
SND_SEQ_TIMER_MIDI_CLOCK = _sequencer_alsa.SND_SEQ_TIMER_MIDI_CLOCK

_sequencer_alsa.SND_SEQ_TIMER_MIDI_TICK_swigconstant(_sequencer_alsa)
SND_SEQ_TIMER_MIDI_TICK = _sequencer_alsa.SND_SEQ_TIMER_MIDI_TICK

def snd_seq_queue_timer_sizeof():
    return _sequencer_alsa.snd_seq_queue_timer_sizeof()
snd_seq_queue_timer_sizeof = _sequencer_alsa.snd_seq_queue_timer_sizeof

def snd_seq_queue_timer_malloc(ptr):
    return _sequencer_alsa.snd_seq_queue_timer_malloc(ptr)
snd_seq_queue_timer_malloc = _sequencer_alsa.snd_seq_queue_timer_malloc

def snd_seq_queue_timer_free(ptr):
    return _sequencer_alsa.snd_seq_queue_timer_free(ptr)
snd_seq_queue_timer_free = _sequencer_alsa.snd_seq_queue_timer_free

def snd_seq_queue_timer_copy(dst, src):
    return _sequencer_alsa.snd_seq_queue_timer_copy(dst, src)
snd_seq_queue_timer_copy = _sequencer_alsa.snd_seq_queue_timer_copy

def snd_seq_queue_timer_get_queue(info):
    return _sequencer_alsa.snd_seq_queue_timer_get_queue(info)
snd_seq_queue_timer_get_queue = _sequencer_alsa.snd_seq_queue_timer_get_queue

def snd_seq_queue_timer_get_type(info):
    return _sequencer_alsa.snd_seq_queue_timer_get_type(info)
snd_seq_queue_timer_get_type = _sequencer_alsa.snd_seq_queue_timer_get_type

def snd_seq_queue_timer_get_id(info):
    return _sequencer_alsa.snd_seq_queue_timer_get_id(info)
snd_seq_queue_timer_get_id = _sequencer_alsa.snd_seq_queue_timer_get_id

def snd_seq_queue_timer_get_resolution(info):
    return _sequencer_alsa.snd_seq_queue_timer_get_resolution(info)
snd_seq_queue_timer_get_resolution = _sequencer_alsa.snd_seq_queue_timer_get_resolution

def snd_seq_queue_timer_set_type(info, type):
    return _sequencer_alsa.snd_seq_queue_timer_set_type(info, type)
snd_seq_queue_timer_set_type = _sequencer_alsa.snd_seq_queue_timer_set_type

def snd_seq_queue_timer_set_id(info, id):
    return _sequencer_alsa.snd_seq_queue_timer_set_id(info, id)
snd_seq_queue_timer_set_id = _sequencer_alsa.snd_seq_queue_timer_set_id

def snd_seq_queue_timer_set_resolution(info, resolution):
    return _sequencer_alsa.snd_seq_queue_timer_set_resolution(info, resolution)
snd_seq_queue_timer_set_resolution = _sequencer_alsa.snd_seq_queue_timer_set_resolution

def snd_seq_get_queue_timer(handle, q, timer):
    return _sequencer_alsa.snd_seq_get_queue_timer(handle, q, timer)
snd_seq_get_queue_timer = _sequencer_alsa.snd_seq_get_queue_timer

def snd_seq_set_queue_timer(handle, q, timer):
    return _sequencer_alsa.snd_seq_set_queue_timer(handle, q, timer)
snd_seq_set_queue_timer = _sequencer_alsa.snd_seq_set_queue_timer

def snd_seq_free_event(ev):
    return _sequencer_alsa.snd_seq_free_event(ev)
snd_seq_free_event = _sequencer_alsa.snd_seq_free_event

def snd_seq_event_length(ev):
    return _sequencer_alsa.snd_seq_event_length(ev)
snd_seq_event_length = _sequencer_alsa.snd_seq_event_length

def snd_seq_event_output(handle, ev):
    return _sequencer_alsa.snd_seq_event_output(handle, ev)
snd_seq_event_output = _sequencer_alsa.snd_seq_event_output

def snd_seq_event_output_buffer(handle, ev):
    return _sequencer_alsa.snd_seq_event_output_buffer(handle, ev)
snd_seq_event_output_buffer = _sequencer_alsa.snd_seq_event_output_buffer

def snd_seq_event_output_direct(handle, ev):
    return _sequencer_alsa.snd_seq_event_output_direct(handle, ev)
snd_seq_event_output_direct = _sequencer_alsa.snd_seq_event_output_direct

def snd_seq_event_input(handle, ev):
    return _sequencer_alsa.snd_seq_event_input(handle, ev)
snd_seq_event_input = _sequencer_alsa.snd_seq_event_input

def snd_seq_event_input_pending(seq, fetch_sequencer):
    return _sequencer_alsa.snd_seq_event_input_pending(seq, fetch_sequencer)
snd_seq_event_input_pending = _sequencer_alsa.snd_seq_event_input_pending

def snd_seq_drain_output(handle):
    return _sequencer_alsa.snd_seq_drain_output(handle)
snd_seq_drain_output = _sequencer_alsa.snd_seq_drain_output

def snd_seq_event_output_pending(seq):
    return _sequencer_alsa.snd_seq_event_output_pending(seq)
snd_seq_event_output_pending = _sequencer_alsa.snd_seq_event_output_pending

def snd_seq_extract_output(handle, ev):
    return _sequencer_alsa.snd_seq_extract_output(handle, ev)
snd_seq_extract_output = _sequencer_alsa.snd_seq_extract_output

def snd_seq_drop_output(handle):
    return _sequencer_alsa.snd_seq_drop_output(handle)
snd_seq_drop_output = _sequencer_alsa.snd_seq_drop_output

def snd_seq_drop_output_buffer(handle):
    return _sequencer_alsa.snd_seq_drop_output_buffer(handle)
snd_seq_drop_output_buffer = _sequencer_alsa.snd_seq_drop_output_buffer

def snd_seq_drop_input(handle):
    return _sequencer_alsa.snd_seq_drop_input(handle)
snd_seq_drop_input = _sequencer_alsa.snd_seq_drop_input

def snd_seq_drop_input_buffer(handle):
    return _sequencer_alsa.snd_seq_drop_input_buffer(handle)
snd_seq_drop_input_buffer = _sequencer_alsa.snd_seq_drop_input_buffer

_sequencer_alsa.SND_SEQ_REMOVE_INPUT_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_INPUT = _sequencer_alsa.SND_SEQ_REMOVE_INPUT

_sequencer_alsa.SND_SEQ_REMOVE_OUTPUT_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_OUTPUT = _sequencer_alsa.SND_SEQ_REMOVE_OUTPUT

_sequencer_alsa.SND_SEQ_REMOVE_DEST_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_DEST = _sequencer_alsa.SND_SEQ_REMOVE_DEST

_sequencer_alsa.SND_SEQ_REMOVE_DEST_CHANNEL_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_DEST_CHANNEL = _sequencer_alsa.SND_SEQ_REMOVE_DEST_CHANNEL

_sequencer_alsa.SND_SEQ_REMOVE_TIME_BEFORE_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_TIME_BEFORE = _sequencer_alsa.SND_SEQ_REMOVE_TIME_BEFORE

_sequencer_alsa.SND_SEQ_REMOVE_TIME_AFTER_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_TIME_AFTER = _sequencer_alsa.SND_SEQ_REMOVE_TIME_AFTER

_sequencer_alsa.SND_SEQ_REMOVE_TIME_TICK_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_TIME_TICK = _sequencer_alsa.SND_SEQ_REMOVE_TIME_TICK

_sequencer_alsa.SND_SEQ_REMOVE_EVENT_TYPE_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_EVENT_TYPE = _sequencer_alsa.SND_SEQ_REMOVE_EVENT_TYPE

_sequencer_alsa.SND_SEQ_REMOVE_IGNORE_OFF_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_IGNORE_OFF = _sequencer_alsa.SND_SEQ_REMOVE_IGNORE_OFF

_sequencer_alsa.SND_SEQ_REMOVE_TAG_MATCH_swigconstant(_sequencer_alsa)
SND_SEQ_REMOVE_TAG_MATCH = _sequencer_alsa.SND_SEQ_REMOVE_TAG_MATCH

def snd_seq_remove_events_sizeof():
    return _sequencer_alsa.snd_seq_remove_events_sizeof()
snd_seq_remove_events_sizeof = _sequencer_alsa.snd_seq_remove_events_sizeof

def snd_seq_remove_events_malloc(ptr):
    return _sequencer_alsa.snd_seq_remove_events_malloc(ptr)
snd_seq_remove_events_malloc = _sequencer_alsa.snd_seq_remove_events_malloc

def snd_seq_remove_events_free(ptr):
    return _sequencer_alsa.snd_seq_remove_events_free(ptr)
snd_seq_remove_events_free = _sequencer_alsa.snd_seq_remove_events_free

def snd_seq_remove_events_copy(dst, src):
    return _sequencer_alsa.snd_seq_remove_events_copy(dst, src)
snd_seq_remove_events_copy = _sequencer_alsa.snd_seq_remove_events_copy

def snd_seq_remove_events_get_condition(info):
    return _sequencer_alsa.snd_seq_remove_events_get_condition(info)
snd_seq_remove_events_get_condition = _sequencer_alsa.snd_seq_remove_events_get_condition

def snd_seq_remove_events_get_queue(info):
    return _sequencer_alsa.snd_seq_remove_events_get_queue(info)
snd_seq_remove_events_get_queue = _sequencer_alsa.snd_seq_remove_events_get_queue

def snd_seq_remove_events_get_time(info):
    return _sequencer_alsa.snd_seq_remove_events_get_time(info)
snd_seq_remove_events_get_time = _sequencer_alsa.snd_seq_remove_events_get_time

def snd_seq_remove_events_get_dest(info):
    return _sequencer_alsa.snd_seq_remove_events_get_dest(info)
snd_seq_remove_events_get_dest = _sequencer_alsa.snd_seq_remove_events_get_dest

def snd_seq_remove_events_get_channel(info):
    return _sequencer_alsa.snd_seq_remove_events_get_channel(info)
snd_seq_remove_events_get_channel = _sequencer_alsa.snd_seq_remove_events_get_channel

def snd_seq_remove_events_get_event_type(info):
    return _sequencer_alsa.snd_seq_remove_events_get_event_type(info)
snd_seq_remove_events_get_event_type = _sequencer_alsa.snd_seq_remove_events_get_event_type

def snd_seq_remove_events_get_tag(info):
    return _sequencer_alsa.snd_seq_remove_events_get_tag(info)
snd_seq_remove_events_get_tag = _sequencer_alsa.snd_seq_remove_events_get_tag

def snd_seq_remove_events_set_condition(info, flags):
    return _sequencer_alsa.snd_seq_remove_events_set_condition(info, flags)
snd_seq_remove_events_set_condition = _sequencer_alsa.snd_seq_remove_events_set_condition

def snd_seq_remove_events_set_queue(info, queue):
    return _sequencer_alsa.snd_seq_remove_events_set_queue(info, queue)
snd_seq_remove_events_set_queue = _sequencer_alsa.snd_seq_remove_events_set_queue

def snd_seq_remove_events_set_time(info, time):
    return _sequencer_alsa.snd_seq_remove_events_set_time(info, time)
snd_seq_remove_events_set_time = _sequencer_alsa.snd_seq_remove_events_set_time

def snd_seq_remove_events_set_dest(info, addr):
    return _sequencer_alsa.snd_seq_remove_events_set_dest(info, addr)
snd_seq_remove_events_set_dest = _sequencer_alsa.snd_seq_remove_events_set_dest

def snd_seq_remove_events_set_channel(info, channel):
    return _sequencer_alsa.snd_seq_remove_events_set_channel(info, channel)
snd_seq_remove_events_set_channel = _sequencer_alsa.snd_seq_remove_events_set_channel

def snd_seq_remove_events_set_event_type(info, type):
    return _sequencer_alsa.snd_seq_remove_events_set_event_type(info, type)
snd_seq_remove_events_set_event_type = _sequencer_alsa.snd_seq_remove_events_set_event_type

def snd_seq_remove_events_set_tag(info, tag):
    return _sequencer_alsa.snd_seq_remove_events_set_tag(info, tag)
snd_seq_remove_events_set_tag = _sequencer_alsa.snd_seq_remove_events_set_tag

def snd_seq_remove_events(handle, info):
    return _sequencer_alsa.snd_seq_remove_events(handle, info)
snd_seq_remove_events = _sequencer_alsa.snd_seq_remove_events

def snd_seq_set_bit(nr, array):
    return _sequencer_alsa.snd_seq_set_bit(nr, array)
snd_seq_set_bit = _sequencer_alsa.snd_seq_set_bit

def snd_seq_unset_bit(nr, array):
    return _sequencer_alsa.snd_seq_unset_bit(nr, array)
snd_seq_unset_bit = _sequencer_alsa.snd_seq_unset_bit

def snd_seq_change_bit(nr, array):
    return _sequencer_alsa.snd_seq_change_bit(nr, array)
snd_seq_change_bit = _sequencer_alsa.snd_seq_change_bit

def snd_seq_get_bit(nr, array):
    return _sequencer_alsa.snd_seq_get_bit(nr, array)
snd_seq_get_bit = _sequencer_alsa.snd_seq_get_bit

_sequencer_alsa.SND_SEQ_EVFLG_RESULT_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_RESULT = _sequencer_alsa.SND_SEQ_EVFLG_RESULT

_sequencer_alsa.SND_SEQ_EVFLG_NOTE_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_NOTE = _sequencer_alsa.SND_SEQ_EVFLG_NOTE

_sequencer_alsa.SND_SEQ_EVFLG_CONTROL_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_CONTROL = _sequencer_alsa.SND_SEQ_EVFLG_CONTROL

_sequencer_alsa.SND_SEQ_EVFLG_QUEUE_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_QUEUE = _sequencer_alsa.SND_SEQ_EVFLG_QUEUE

_sequencer_alsa.SND_SEQ_EVFLG_SYSTEM_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_SYSTEM = _sequencer_alsa.SND_SEQ_EVFLG_SYSTEM

_sequencer_alsa.SND_SEQ_EVFLG_MESSAGE_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_MESSAGE = _sequencer_alsa.SND_SEQ_EVFLG_MESSAGE

_sequencer_alsa.SND_SEQ_EVFLG_CONNECTION_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_CONNECTION = _sequencer_alsa.SND_SEQ_EVFLG_CONNECTION

_sequencer_alsa.SND_SEQ_EVFLG_SAMPLE_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_SAMPLE = _sequencer_alsa.SND_SEQ_EVFLG_SAMPLE

_sequencer_alsa.SND_SEQ_EVFLG_USERS_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_USERS = _sequencer_alsa.SND_SEQ_EVFLG_USERS

_sequencer_alsa.SND_SEQ_EVFLG_INSTR_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_INSTR = _sequencer_alsa.SND_SEQ_EVFLG_INSTR

_sequencer_alsa.SND_SEQ_EVFLG_QUOTE_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_QUOTE = _sequencer_alsa.SND_SEQ_EVFLG_QUOTE

_sequencer_alsa.SND_SEQ_EVFLG_NONE_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_NONE = _sequencer_alsa.SND_SEQ_EVFLG_NONE

_sequencer_alsa.SND_SEQ_EVFLG_RAW_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_RAW = _sequencer_alsa.SND_SEQ_EVFLG_RAW

_sequencer_alsa.SND_SEQ_EVFLG_FIXED_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_FIXED = _sequencer_alsa.SND_SEQ_EVFLG_FIXED

_sequencer_alsa.SND_SEQ_EVFLG_VARIABLE_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_VARIABLE = _sequencer_alsa.SND_SEQ_EVFLG_VARIABLE

_sequencer_alsa.SND_SEQ_EVFLG_VARUSR_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_VARUSR = _sequencer_alsa.SND_SEQ_EVFLG_VARUSR

_sequencer_alsa.SND_SEQ_EVFLG_NOTE_ONEARG_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_NOTE_ONEARG = _sequencer_alsa.SND_SEQ_EVFLG_NOTE_ONEARG

_sequencer_alsa.SND_SEQ_EVFLG_NOTE_TWOARG_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_NOTE_TWOARG = _sequencer_alsa.SND_SEQ_EVFLG_NOTE_TWOARG

_sequencer_alsa.SND_SEQ_EVFLG_QUEUE_NOARG_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_QUEUE_NOARG = _sequencer_alsa.SND_SEQ_EVFLG_QUEUE_NOARG

_sequencer_alsa.SND_SEQ_EVFLG_QUEUE_TICK_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_QUEUE_TICK = _sequencer_alsa.SND_SEQ_EVFLG_QUEUE_TICK

_sequencer_alsa.SND_SEQ_EVFLG_QUEUE_TIME_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_QUEUE_TIME = _sequencer_alsa.SND_SEQ_EVFLG_QUEUE_TIME

_sequencer_alsa.SND_SEQ_EVFLG_QUEUE_VALUE_swigconstant(_sequencer_alsa)
SND_SEQ_EVFLG_QUEUE_VALUE = _sequencer_alsa.SND_SEQ_EVFLG_QUEUE_VALUE

def snd_seq_control_queue(seq, q, type, value, ev):
    return _sequencer_alsa.snd_seq_control_queue(seq, q, type, value, ev)
snd_seq_control_queue = _sequencer_alsa.snd_seq_control_queue

def snd_seq_create_simple_port(seq, name, caps, type):
    return _sequencer_alsa.snd_seq_create_simple_port(seq, name, caps, type)
snd_seq_create_simple_port = _sequencer_alsa.snd_seq_create_simple_port

def snd_seq_delete_simple_port(seq, port):
    return _sequencer_alsa.snd_seq_delete_simple_port(seq, port)
snd_seq_delete_simple_port = _sequencer_alsa.snd_seq_delete_simple_port

def snd_seq_connect_from(seq, my_port, src_client, src_port):
    return _sequencer_alsa.snd_seq_connect_from(seq, my_port, src_client, src_port)
snd_seq_connect_from = _sequencer_alsa.snd_seq_connect_from

def snd_seq_connect_to(seq, my_port, dest_client, dest_port):
    return _sequencer_alsa.snd_seq_connect_to(seq, my_port, dest_client, dest_port)
snd_seq_connect_to = _sequencer_alsa.snd_seq_connect_to

def snd_seq_disconnect_from(seq, my_port, src_client, src_port):
    return _sequencer_alsa.snd_seq_disconnect_from(seq, my_port, src_client, src_port)
snd_seq_disconnect_from = _sequencer_alsa.snd_seq_disconnect_from

def snd_seq_disconnect_to(seq, my_port, dest_client, dest_port):
    return _sequencer_alsa.snd_seq_disconnect_to(seq, my_port, dest_client, dest_port)
snd_seq_disconnect_to = _sequencer_alsa.snd_seq_disconnect_to

def snd_seq_set_client_name(seq, name):
    return _sequencer_alsa.snd_seq_set_client_name(seq, name)
snd_seq_set_client_name = _sequencer_alsa.snd_seq_set_client_name

def snd_seq_set_client_event_filter(seq, event_type):
    return _sequencer_alsa.snd_seq_set_client_event_filter(seq, event_type)
snd_seq_set_client_event_filter = _sequencer_alsa.snd_seq_set_client_event_filter

def snd_seq_set_client_pool_output(seq, size):
    return _sequencer_alsa.snd_seq_set_client_pool_output(seq, size)
snd_seq_set_client_pool_output = _sequencer_alsa.snd_seq_set_client_pool_output

def snd_seq_set_client_pool_output_room(seq, size):
    return _sequencer_alsa.snd_seq_set_client_pool_output_room(seq, size)
snd_seq_set_client_pool_output_room = _sequencer_alsa.snd_seq_set_client_pool_output_room

def snd_seq_set_client_pool_input(seq, size):
    return _sequencer_alsa.snd_seq_set_client_pool_input(seq, size)
snd_seq_set_client_pool_input = _sequencer_alsa.snd_seq_set_client_pool_input

def snd_seq_sync_output_queue(seq):
    return _sequencer_alsa.snd_seq_sync_output_queue(seq)
snd_seq_sync_output_queue = _sequencer_alsa.snd_seq_sync_output_queue

def snd_seq_parse_address(seq, addr, str):
    return _sequencer_alsa.snd_seq_parse_address(seq, addr, str)
snd_seq_parse_address = _sequencer_alsa.snd_seq_parse_address

def snd_seq_reset_pool_output(seq):
    return _sequencer_alsa.snd_seq_reset_pool_output(seq)
snd_seq_reset_pool_output = _sequencer_alsa.snd_seq_reset_pool_output

def snd_seq_reset_pool_input(seq):
    return _sequencer_alsa.snd_seq_reset_pool_input(seq)
snd_seq_reset_pool_input = _sequencer_alsa.snd_seq_reset_pool_input

_sequencer_alsa.SND_SEQ_EVENT_SYSTEM_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_SYSTEM = _sequencer_alsa.SND_SEQ_EVENT_SYSTEM

_sequencer_alsa.SND_SEQ_EVENT_RESULT_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_RESULT = _sequencer_alsa.SND_SEQ_EVENT_RESULT

_sequencer_alsa.SND_SEQ_EVENT_NOTE_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_NOTE = _sequencer_alsa.SND_SEQ_EVENT_NOTE

_sequencer_alsa.SND_SEQ_EVENT_NOTEON_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_NOTEON = _sequencer_alsa.SND_SEQ_EVENT_NOTEON

_sequencer_alsa.SND_SEQ_EVENT_NOTEOFF_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_NOTEOFF = _sequencer_alsa.SND_SEQ_EVENT_NOTEOFF

_sequencer_alsa.SND_SEQ_EVENT_KEYPRESS_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_KEYPRESS = _sequencer_alsa.SND_SEQ_EVENT_KEYPRESS

_sequencer_alsa.SND_SEQ_EVENT_CONTROLLER_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_CONTROLLER = _sequencer_alsa.SND_SEQ_EVENT_CONTROLLER

_sequencer_alsa.SND_SEQ_EVENT_PGMCHANGE_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_PGMCHANGE = _sequencer_alsa.SND_SEQ_EVENT_PGMCHANGE

_sequencer_alsa.SND_SEQ_EVENT_CHANPRESS_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_CHANPRESS = _sequencer_alsa.SND_SEQ_EVENT_CHANPRESS

_sequencer_alsa.SND_SEQ_EVENT_PITCHBEND_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_PITCHBEND = _sequencer_alsa.SND_SEQ_EVENT_PITCHBEND

_sequencer_alsa.SND_SEQ_EVENT_CONTROL14_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_CONTROL14 = _sequencer_alsa.SND_SEQ_EVENT_CONTROL14

_sequencer_alsa.SND_SEQ_EVENT_NONREGPARAM_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_NONREGPARAM = _sequencer_alsa.SND_SEQ_EVENT_NONREGPARAM

_sequencer_alsa.SND_SEQ_EVENT_REGPARAM_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_REGPARAM = _sequencer_alsa.SND_SEQ_EVENT_REGPARAM

_sequencer_alsa.SND_SEQ_EVENT_SONGPOS_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_SONGPOS = _sequencer_alsa.SND_SEQ_EVENT_SONGPOS

_sequencer_alsa.SND_SEQ_EVENT_SONGSEL_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_SONGSEL = _sequencer_alsa.SND_SEQ_EVENT_SONGSEL

_sequencer_alsa.SND_SEQ_EVENT_QFRAME_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_QFRAME = _sequencer_alsa.SND_SEQ_EVENT_QFRAME

_sequencer_alsa.SND_SEQ_EVENT_TIMESIGN_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_TIMESIGN = _sequencer_alsa.SND_SEQ_EVENT_TIMESIGN

_sequencer_alsa.SND_SEQ_EVENT_KEYSIGN_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_KEYSIGN = _sequencer_alsa.SND_SEQ_EVENT_KEYSIGN

_sequencer_alsa.SND_SEQ_EVENT_START_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_START = _sequencer_alsa.SND_SEQ_EVENT_START

_sequencer_alsa.SND_SEQ_EVENT_CONTINUE_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_CONTINUE = _sequencer_alsa.SND_SEQ_EVENT_CONTINUE

_sequencer_alsa.SND_SEQ_EVENT_STOP_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_STOP = _sequencer_alsa.SND_SEQ_EVENT_STOP

_sequencer_alsa.SND_SEQ_EVENT_SETPOS_TICK_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_SETPOS_TICK = _sequencer_alsa.SND_SEQ_EVENT_SETPOS_TICK

_sequencer_alsa.SND_SEQ_EVENT_SETPOS_TIME_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_SETPOS_TIME = _sequencer_alsa.SND_SEQ_EVENT_SETPOS_TIME

_sequencer_alsa.SND_SEQ_EVENT_TEMPO_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_TEMPO = _sequencer_alsa.SND_SEQ_EVENT_TEMPO

_sequencer_alsa.SND_SEQ_EVENT_CLOCK_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_CLOCK = _sequencer_alsa.SND_SEQ_EVENT_CLOCK

_sequencer_alsa.SND_SEQ_EVENT_TICK_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_TICK = _sequencer_alsa.SND_SEQ_EVENT_TICK

_sequencer_alsa.SND_SEQ_EVENT_QUEUE_SKEW_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_QUEUE_SKEW = _sequencer_alsa.SND_SEQ_EVENT_QUEUE_SKEW

_sequencer_alsa.SND_SEQ_EVENT_SYNC_POS_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_SYNC_POS = _sequencer_alsa.SND_SEQ_EVENT_SYNC_POS

_sequencer_alsa.SND_SEQ_EVENT_TUNE_REQUEST_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_TUNE_REQUEST = _sequencer_alsa.SND_SEQ_EVENT_TUNE_REQUEST

_sequencer_alsa.SND_SEQ_EVENT_RESET_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_RESET = _sequencer_alsa.SND_SEQ_EVENT_RESET

_sequencer_alsa.SND_SEQ_EVENT_SENSING_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_SENSING = _sequencer_alsa.SND_SEQ_EVENT_SENSING

_sequencer_alsa.SND_SEQ_EVENT_ECHO_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_ECHO = _sequencer_alsa.SND_SEQ_EVENT_ECHO

_sequencer_alsa.SND_SEQ_EVENT_OSS_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_OSS = _sequencer_alsa.SND_SEQ_EVENT_OSS

_sequencer_alsa.SND_SEQ_EVENT_CLIENT_START_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_CLIENT_START = _sequencer_alsa.SND_SEQ_EVENT_CLIENT_START

_sequencer_alsa.SND_SEQ_EVENT_CLIENT_EXIT_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_CLIENT_EXIT = _sequencer_alsa.SND_SEQ_EVENT_CLIENT_EXIT

_sequencer_alsa.SND_SEQ_EVENT_CLIENT_CHANGE_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_CLIENT_CHANGE = _sequencer_alsa.SND_SEQ_EVENT_CLIENT_CHANGE

_sequencer_alsa.SND_SEQ_EVENT_PORT_START_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_PORT_START = _sequencer_alsa.SND_SEQ_EVENT_PORT_START

_sequencer_alsa.SND_SEQ_EVENT_PORT_EXIT_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_PORT_EXIT = _sequencer_alsa.SND_SEQ_EVENT_PORT_EXIT

_sequencer_alsa.SND_SEQ_EVENT_PORT_CHANGE_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_PORT_CHANGE = _sequencer_alsa.SND_SEQ_EVENT_PORT_CHANGE

_sequencer_alsa.SND_SEQ_EVENT_PORT_SUBSCRIBED_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_PORT_SUBSCRIBED = _sequencer_alsa.SND_SEQ_EVENT_PORT_SUBSCRIBED

_sequencer_alsa.SND_SEQ_EVENT_PORT_UNSUBSCRIBED_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_PORT_UNSUBSCRIBED = _sequencer_alsa.SND_SEQ_EVENT_PORT_UNSUBSCRIBED

_sequencer_alsa.SND_SEQ_EVENT_USR0_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR0 = _sequencer_alsa.SND_SEQ_EVENT_USR0

_sequencer_alsa.SND_SEQ_EVENT_USR1_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR1 = _sequencer_alsa.SND_SEQ_EVENT_USR1

_sequencer_alsa.SND_SEQ_EVENT_USR2_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR2 = _sequencer_alsa.SND_SEQ_EVENT_USR2

_sequencer_alsa.SND_SEQ_EVENT_USR3_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR3 = _sequencer_alsa.SND_SEQ_EVENT_USR3

_sequencer_alsa.SND_SEQ_EVENT_USR4_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR4 = _sequencer_alsa.SND_SEQ_EVENT_USR4

_sequencer_alsa.SND_SEQ_EVENT_USR5_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR5 = _sequencer_alsa.SND_SEQ_EVENT_USR5

_sequencer_alsa.SND_SEQ_EVENT_USR6_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR6 = _sequencer_alsa.SND_SEQ_EVENT_USR6

_sequencer_alsa.SND_SEQ_EVENT_USR7_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR7 = _sequencer_alsa.SND_SEQ_EVENT_USR7

_sequencer_alsa.SND_SEQ_EVENT_USR8_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR8 = _sequencer_alsa.SND_SEQ_EVENT_USR8

_sequencer_alsa.SND_SEQ_EVENT_USR9_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR9 = _sequencer_alsa.SND_SEQ_EVENT_USR9

_sequencer_alsa.SND_SEQ_EVENT_SYSEX_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_SYSEX = _sequencer_alsa.SND_SEQ_EVENT_SYSEX

_sequencer_alsa.SND_SEQ_EVENT_BOUNCE_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_BOUNCE = _sequencer_alsa.SND_SEQ_EVENT_BOUNCE

_sequencer_alsa.SND_SEQ_EVENT_USR_VAR0_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR_VAR0 = _sequencer_alsa.SND_SEQ_EVENT_USR_VAR0

_sequencer_alsa.SND_SEQ_EVENT_USR_VAR1_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR_VAR1 = _sequencer_alsa.SND_SEQ_EVENT_USR_VAR1

_sequencer_alsa.SND_SEQ_EVENT_USR_VAR2_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR_VAR2 = _sequencer_alsa.SND_SEQ_EVENT_USR_VAR2

_sequencer_alsa.SND_SEQ_EVENT_USR_VAR3_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR_VAR3 = _sequencer_alsa.SND_SEQ_EVENT_USR_VAR3

_sequencer_alsa.SND_SEQ_EVENT_USR_VAR4_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_USR_VAR4 = _sequencer_alsa.SND_SEQ_EVENT_USR_VAR4

_sequencer_alsa.SND_SEQ_EVENT_NONE_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_NONE = _sequencer_alsa.SND_SEQ_EVENT_NONE
class snd_seq_addr_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_addr_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_addr_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["client"] = _sequencer_alsa.snd_seq_addr_t_client_set
    __swig_getmethods__["client"] = _sequencer_alsa.snd_seq_addr_t_client_get
    if _newclass:
        client = _swig_property(_sequencer_alsa.snd_seq_addr_t_client_get, _sequencer_alsa.snd_seq_addr_t_client_set)
    __swig_setmethods__["port"] = _sequencer_alsa.snd_seq_addr_t_port_set
    __swig_getmethods__["port"] = _sequencer_alsa.snd_seq_addr_t_port_get
    if _newclass:
        port = _swig_property(_sequencer_alsa.snd_seq_addr_t_port_get, _sequencer_alsa.snd_seq_addr_t_port_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_addr_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_addr_t
    __del__ = lambda self: None
snd_seq_addr_t_swigregister = _sequencer_alsa.snd_seq_addr_t_swigregister
snd_seq_addr_t_swigregister(snd_seq_addr_t)
cvar = _sequencer_alsa.cvar
snd_seq_event_types = cvar.snd_seq_event_types

class snd_seq_connect_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_connect_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_connect_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["sender"] = _sequencer_alsa.snd_seq_connect_t_sender_set
    __swig_getmethods__["sender"] = _sequencer_alsa.snd_seq_connect_t_sender_get
    if _newclass:
        sender = _swig_property(_sequencer_alsa.snd_seq_connect_t_sender_get, _sequencer_alsa.snd_seq_connect_t_sender_set)
    __swig_setmethods__["dest"] = _sequencer_alsa.snd_seq_connect_t_dest_set
    __swig_getmethods__["dest"] = _sequencer_alsa.snd_seq_connect_t_dest_get
    if _newclass:
        dest = _swig_property(_sequencer_alsa.snd_seq_connect_t_dest_get, _sequencer_alsa.snd_seq_connect_t_dest_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_connect_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_connect_t
    __del__ = lambda self: None
snd_seq_connect_t_swigregister = _sequencer_alsa.snd_seq_connect_t_swigregister
snd_seq_connect_t_swigregister(snd_seq_connect_t)

class snd_seq_real_time_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_real_time_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_real_time_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tv_sec"] = _sequencer_alsa.snd_seq_real_time_t_tv_sec_set
    __swig_getmethods__["tv_sec"] = _sequencer_alsa.snd_seq_real_time_t_tv_sec_get
    if _newclass:
        tv_sec = _swig_property(_sequencer_alsa.snd_seq_real_time_t_tv_sec_get, _sequencer_alsa.snd_seq_real_time_t_tv_sec_set)
    __swig_setmethods__["tv_nsec"] = _sequencer_alsa.snd_seq_real_time_t_tv_nsec_set
    __swig_getmethods__["tv_nsec"] = _sequencer_alsa.snd_seq_real_time_t_tv_nsec_get
    if _newclass:
        tv_nsec = _swig_property(_sequencer_alsa.snd_seq_real_time_t_tv_nsec_get, _sequencer_alsa.snd_seq_real_time_t_tv_nsec_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_real_time_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_real_time_t
    __del__ = lambda self: None
snd_seq_real_time_t_swigregister = _sequencer_alsa.snd_seq_real_time_t_swigregister
snd_seq_real_time_t_swigregister(snd_seq_real_time_t)

class snd_seq_timestamp_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_timestamp_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_timestamp_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tick"] = _sequencer_alsa.snd_seq_timestamp_t_tick_set
    __swig_getmethods__["tick"] = _sequencer_alsa.snd_seq_timestamp_t_tick_get
    if _newclass:
        tick = _swig_property(_sequencer_alsa.snd_seq_timestamp_t_tick_get, _sequencer_alsa.snd_seq_timestamp_t_tick_set)
    __swig_setmethods__["time"] = _sequencer_alsa.snd_seq_timestamp_t_time_set
    __swig_getmethods__["time"] = _sequencer_alsa.snd_seq_timestamp_t_time_get
    if _newclass:
        time = _swig_property(_sequencer_alsa.snd_seq_timestamp_t_time_get, _sequencer_alsa.snd_seq_timestamp_t_time_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_timestamp_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_timestamp_t
    __del__ = lambda self: None
snd_seq_timestamp_t_swigregister = _sequencer_alsa.snd_seq_timestamp_t_swigregister
snd_seq_timestamp_t_swigregister(snd_seq_timestamp_t)


_sequencer_alsa.SND_SEQ_TIME_STAMP_TICK_swigconstant(_sequencer_alsa)
SND_SEQ_TIME_STAMP_TICK = _sequencer_alsa.SND_SEQ_TIME_STAMP_TICK

_sequencer_alsa.SND_SEQ_TIME_STAMP_REAL_swigconstant(_sequencer_alsa)
SND_SEQ_TIME_STAMP_REAL = _sequencer_alsa.SND_SEQ_TIME_STAMP_REAL

_sequencer_alsa.SND_SEQ_TIME_STAMP_MASK_swigconstant(_sequencer_alsa)
SND_SEQ_TIME_STAMP_MASK = _sequencer_alsa.SND_SEQ_TIME_STAMP_MASK

_sequencer_alsa.SND_SEQ_TIME_MODE_ABS_swigconstant(_sequencer_alsa)
SND_SEQ_TIME_MODE_ABS = _sequencer_alsa.SND_SEQ_TIME_MODE_ABS

_sequencer_alsa.SND_SEQ_TIME_MODE_REL_swigconstant(_sequencer_alsa)
SND_SEQ_TIME_MODE_REL = _sequencer_alsa.SND_SEQ_TIME_MODE_REL

_sequencer_alsa.SND_SEQ_TIME_MODE_MASK_swigconstant(_sequencer_alsa)
SND_SEQ_TIME_MODE_MASK = _sequencer_alsa.SND_SEQ_TIME_MODE_MASK

_sequencer_alsa.SND_SEQ_EVENT_LENGTH_FIXED_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_LENGTH_FIXED = _sequencer_alsa.SND_SEQ_EVENT_LENGTH_FIXED

_sequencer_alsa.SND_SEQ_EVENT_LENGTH_VARIABLE_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_LENGTH_VARIABLE = _sequencer_alsa.SND_SEQ_EVENT_LENGTH_VARIABLE

_sequencer_alsa.SND_SEQ_EVENT_LENGTH_VARUSR_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_LENGTH_VARUSR = _sequencer_alsa.SND_SEQ_EVENT_LENGTH_VARUSR

_sequencer_alsa.SND_SEQ_EVENT_LENGTH_MASK_swigconstant(_sequencer_alsa)
SND_SEQ_EVENT_LENGTH_MASK = _sequencer_alsa.SND_SEQ_EVENT_LENGTH_MASK

_sequencer_alsa.SND_SEQ_PRIORITY_NORMAL_swigconstant(_sequencer_alsa)
SND_SEQ_PRIORITY_NORMAL = _sequencer_alsa.SND_SEQ_PRIORITY_NORMAL

_sequencer_alsa.SND_SEQ_PRIORITY_HIGH_swigconstant(_sequencer_alsa)
SND_SEQ_PRIORITY_HIGH = _sequencer_alsa.SND_SEQ_PRIORITY_HIGH

_sequencer_alsa.SND_SEQ_PRIORITY_MASK_swigconstant(_sequencer_alsa)
SND_SEQ_PRIORITY_MASK = _sequencer_alsa.SND_SEQ_PRIORITY_MASK
class snd_seq_ev_note_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_ev_note_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_ev_note_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["channel"] = _sequencer_alsa.snd_seq_ev_note_t_channel_set
    __swig_getmethods__["channel"] = _sequencer_alsa.snd_seq_ev_note_t_channel_get
    if _newclass:
        channel = _swig_property(_sequencer_alsa.snd_seq_ev_note_t_channel_get, _sequencer_alsa.snd_seq_ev_note_t_channel_set)
    __swig_setmethods__["note"] = _sequencer_alsa.snd_seq_ev_note_t_note_set
    __swig_getmethods__["note"] = _sequencer_alsa.snd_seq_ev_note_t_note_get
    if _newclass:
        note = _swig_property(_sequencer_alsa.snd_seq_ev_note_t_note_get, _sequencer_alsa.snd_seq_ev_note_t_note_set)
    __swig_setmethods__["velocity"] = _sequencer_alsa.snd_seq_ev_note_t_velocity_set
    __swig_getmethods__["velocity"] = _sequencer_alsa.snd_seq_ev_note_t_velocity_get
    if _newclass:
        velocity = _swig_property(_sequencer_alsa.snd_seq_ev_note_t_velocity_get, _sequencer_alsa.snd_seq_ev_note_t_velocity_set)
    __swig_setmethods__["off_velocity"] = _sequencer_alsa.snd_seq_ev_note_t_off_velocity_set
    __swig_getmethods__["off_velocity"] = _sequencer_alsa.snd_seq_ev_note_t_off_velocity_get
    if _newclass:
        off_velocity = _swig_property(_sequencer_alsa.snd_seq_ev_note_t_off_velocity_get, _sequencer_alsa.snd_seq_ev_note_t_off_velocity_set)
    __swig_setmethods__["duration"] = _sequencer_alsa.snd_seq_ev_note_t_duration_set
    __swig_getmethods__["duration"] = _sequencer_alsa.snd_seq_ev_note_t_duration_get
    if _newclass:
        duration = _swig_property(_sequencer_alsa.snd_seq_ev_note_t_duration_get, _sequencer_alsa.snd_seq_ev_note_t_duration_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_ev_note_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_ev_note_t
    __del__ = lambda self: None
snd_seq_ev_note_t_swigregister = _sequencer_alsa.snd_seq_ev_note_t_swigregister
snd_seq_ev_note_t_swigregister(snd_seq_ev_note_t)

class snd_seq_ev_ctrl_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_ev_ctrl_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_ev_ctrl_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["channel"] = _sequencer_alsa.snd_seq_ev_ctrl_t_channel_set
    __swig_getmethods__["channel"] = _sequencer_alsa.snd_seq_ev_ctrl_t_channel_get
    if _newclass:
        channel = _swig_property(_sequencer_alsa.snd_seq_ev_ctrl_t_channel_get, _sequencer_alsa.snd_seq_ev_ctrl_t_channel_set)
    __swig_setmethods__["unused"] = _sequencer_alsa.snd_seq_ev_ctrl_t_unused_set
    __swig_getmethods__["unused"] = _sequencer_alsa.snd_seq_ev_ctrl_t_unused_get
    if _newclass:
        unused = _swig_property(_sequencer_alsa.snd_seq_ev_ctrl_t_unused_get, _sequencer_alsa.snd_seq_ev_ctrl_t_unused_set)
    __swig_setmethods__["param"] = _sequencer_alsa.snd_seq_ev_ctrl_t_param_set
    __swig_getmethods__["param"] = _sequencer_alsa.snd_seq_ev_ctrl_t_param_get
    if _newclass:
        param = _swig_property(_sequencer_alsa.snd_seq_ev_ctrl_t_param_get, _sequencer_alsa.snd_seq_ev_ctrl_t_param_set)
    __swig_setmethods__["value"] = _sequencer_alsa.snd_seq_ev_ctrl_t_value_set
    __swig_getmethods__["value"] = _sequencer_alsa.snd_seq_ev_ctrl_t_value_get
    if _newclass:
        value = _swig_property(_sequencer_alsa.snd_seq_ev_ctrl_t_value_get, _sequencer_alsa.snd_seq_ev_ctrl_t_value_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_ev_ctrl_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_ev_ctrl_t
    __del__ = lambda self: None
snd_seq_ev_ctrl_t_swigregister = _sequencer_alsa.snd_seq_ev_ctrl_t_swigregister
snd_seq_ev_ctrl_t_swigregister(snd_seq_ev_ctrl_t)

class snd_seq_ev_raw8_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_ev_raw8_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_ev_raw8_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["d"] = _sequencer_alsa.snd_seq_ev_raw8_t_d_set
    __swig_getmethods__["d"] = _sequencer_alsa.snd_seq_ev_raw8_t_d_get
    if _newclass:
        d = _swig_property(_sequencer_alsa.snd_seq_ev_raw8_t_d_get, _sequencer_alsa.snd_seq_ev_raw8_t_d_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_ev_raw8_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_ev_raw8_t
    __del__ = lambda self: None
snd_seq_ev_raw8_t_swigregister = _sequencer_alsa.snd_seq_ev_raw8_t_swigregister
snd_seq_ev_raw8_t_swigregister(snd_seq_ev_raw8_t)

class snd_seq_ev_raw32_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_ev_raw32_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_ev_raw32_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["d"] = _sequencer_alsa.snd_seq_ev_raw32_t_d_set
    __swig_getmethods__["d"] = _sequencer_alsa.snd_seq_ev_raw32_t_d_get
    if _newclass:
        d = _swig_property(_sequencer_alsa.snd_seq_ev_raw32_t_d_get, _sequencer_alsa.snd_seq_ev_raw32_t_d_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_ev_raw32_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_ev_raw32_t
    __del__ = lambda self: None
snd_seq_ev_raw32_t_swigregister = _sequencer_alsa.snd_seq_ev_raw32_t_swigregister
snd_seq_ev_raw32_t_swigregister(snd_seq_ev_raw32_t)

class snd_seq_ev_ext(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_ev_ext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_ev_ext, name)
    __repr__ = _swig_repr
    __swig_setmethods__["len"] = _sequencer_alsa.snd_seq_ev_ext_len_set
    __swig_getmethods__["len"] = _sequencer_alsa.snd_seq_ev_ext_len_get
    if _newclass:
        len = _swig_property(_sequencer_alsa.snd_seq_ev_ext_len_get, _sequencer_alsa.snd_seq_ev_ext_len_set)
    __swig_setmethods__["ptr"] = _sequencer_alsa.snd_seq_ev_ext_ptr_set
    __swig_getmethods__["ptr"] = _sequencer_alsa.snd_seq_ev_ext_ptr_get
    if _newclass:
        ptr = _swig_property(_sequencer_alsa.snd_seq_ev_ext_ptr_get, _sequencer_alsa.snd_seq_ev_ext_ptr_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_ev_ext()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_ev_ext
    __del__ = lambda self: None
snd_seq_ev_ext_swigregister = _sequencer_alsa.snd_seq_ev_ext_swigregister
snd_seq_ev_ext_swigregister(snd_seq_ev_ext)

class snd_seq_result_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_result_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_result_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["event"] = _sequencer_alsa.snd_seq_result_t_event_set
    __swig_getmethods__["event"] = _sequencer_alsa.snd_seq_result_t_event_get
    if _newclass:
        event = _swig_property(_sequencer_alsa.snd_seq_result_t_event_get, _sequencer_alsa.snd_seq_result_t_event_set)
    __swig_setmethods__["result"] = _sequencer_alsa.snd_seq_result_t_result_set
    __swig_getmethods__["result"] = _sequencer_alsa.snd_seq_result_t_result_get
    if _newclass:
        result = _swig_property(_sequencer_alsa.snd_seq_result_t_result_get, _sequencer_alsa.snd_seq_result_t_result_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_result_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_result_t
    __del__ = lambda self: None
snd_seq_result_t_swigregister = _sequencer_alsa.snd_seq_result_t_swigregister
snd_seq_result_t_swigregister(snd_seq_result_t)

class snd_seq_queue_skew_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_queue_skew_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_queue_skew_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["value"] = _sequencer_alsa.snd_seq_queue_skew_t_value_set
    __swig_getmethods__["value"] = _sequencer_alsa.snd_seq_queue_skew_t_value_get
    if _newclass:
        value = _swig_property(_sequencer_alsa.snd_seq_queue_skew_t_value_get, _sequencer_alsa.snd_seq_queue_skew_t_value_set)
    __swig_setmethods__["base"] = _sequencer_alsa.snd_seq_queue_skew_t_base_set
    __swig_getmethods__["base"] = _sequencer_alsa.snd_seq_queue_skew_t_base_get
    if _newclass:
        base = _swig_property(_sequencer_alsa.snd_seq_queue_skew_t_base_get, _sequencer_alsa.snd_seq_queue_skew_t_base_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_queue_skew_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_queue_skew_t
    __del__ = lambda self: None
snd_seq_queue_skew_t_swigregister = _sequencer_alsa.snd_seq_queue_skew_t_swigregister
snd_seq_queue_skew_t_swigregister(snd_seq_queue_skew_t)

class snd_seq_ev_queue_control_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_ev_queue_control_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_ev_queue_control_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["queue"] = _sequencer_alsa.snd_seq_ev_queue_control_t_queue_set
    __swig_getmethods__["queue"] = _sequencer_alsa.snd_seq_ev_queue_control_t_queue_get
    if _newclass:
        queue = _swig_property(_sequencer_alsa.snd_seq_ev_queue_control_t_queue_get, _sequencer_alsa.snd_seq_ev_queue_control_t_queue_set)
    __swig_setmethods__["unused"] = _sequencer_alsa.snd_seq_ev_queue_control_t_unused_set
    __swig_getmethods__["unused"] = _sequencer_alsa.snd_seq_ev_queue_control_t_unused_get
    if _newclass:
        unused = _swig_property(_sequencer_alsa.snd_seq_ev_queue_control_t_unused_get, _sequencer_alsa.snd_seq_ev_queue_control_t_unused_set)
    __swig_getmethods__["param"] = _sequencer_alsa.snd_seq_ev_queue_control_t_param_get
    if _newclass:
        param = _swig_property(_sequencer_alsa.snd_seq_ev_queue_control_t_param_get)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_ev_queue_control_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_ev_queue_control_t
    __del__ = lambda self: None
snd_seq_ev_queue_control_t_swigregister = _sequencer_alsa.snd_seq_ev_queue_control_t_swigregister
snd_seq_ev_queue_control_t_swigregister(snd_seq_ev_queue_control_t)

class snd_seq_ev_queue_control_param(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_ev_queue_control_param, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_ev_queue_control_param, name)
    __repr__ = _swig_repr
    __swig_setmethods__["value"] = _sequencer_alsa.snd_seq_ev_queue_control_param_value_set
    __swig_getmethods__["value"] = _sequencer_alsa.snd_seq_ev_queue_control_param_value_get
    if _newclass:
        value = _swig_property(_sequencer_alsa.snd_seq_ev_queue_control_param_value_get, _sequencer_alsa.snd_seq_ev_queue_control_param_value_set)
    __swig_setmethods__["time"] = _sequencer_alsa.snd_seq_ev_queue_control_param_time_set
    __swig_getmethods__["time"] = _sequencer_alsa.snd_seq_ev_queue_control_param_time_get
    if _newclass:
        time = _swig_property(_sequencer_alsa.snd_seq_ev_queue_control_param_time_get, _sequencer_alsa.snd_seq_ev_queue_control_param_time_set)
    __swig_setmethods__["position"] = _sequencer_alsa.snd_seq_ev_queue_control_param_position_set
    __swig_getmethods__["position"] = _sequencer_alsa.snd_seq_ev_queue_control_param_position_get
    if _newclass:
        position = _swig_property(_sequencer_alsa.snd_seq_ev_queue_control_param_position_get, _sequencer_alsa.snd_seq_ev_queue_control_param_position_set)
    __swig_setmethods__["skew"] = _sequencer_alsa.snd_seq_ev_queue_control_param_skew_set
    __swig_getmethods__["skew"] = _sequencer_alsa.snd_seq_ev_queue_control_param_skew_get
    if _newclass:
        skew = _swig_property(_sequencer_alsa.snd_seq_ev_queue_control_param_skew_get, _sequencer_alsa.snd_seq_ev_queue_control_param_skew_set)
    __swig_setmethods__["d32"] = _sequencer_alsa.snd_seq_ev_queue_control_param_d32_set
    __swig_getmethods__["d32"] = _sequencer_alsa.snd_seq_ev_queue_control_param_d32_get
    if _newclass:
        d32 = _swig_property(_sequencer_alsa.snd_seq_ev_queue_control_param_d32_get, _sequencer_alsa.snd_seq_ev_queue_control_param_d32_set)
    __swig_setmethods__["d8"] = _sequencer_alsa.snd_seq_ev_queue_control_param_d8_set
    __swig_getmethods__["d8"] = _sequencer_alsa.snd_seq_ev_queue_control_param_d8_get
    if _newclass:
        d8 = _swig_property(_sequencer_alsa.snd_seq_ev_queue_control_param_d8_get, _sequencer_alsa.snd_seq_ev_queue_control_param_d8_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_ev_queue_control_param()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_ev_queue_control_param
    __del__ = lambda self: None
snd_seq_ev_queue_control_param_swigregister = _sequencer_alsa.snd_seq_ev_queue_control_param_swigregister
snd_seq_ev_queue_control_param_swigregister(snd_seq_ev_queue_control_param)

class snd_seq_event_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_event_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_event_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _sequencer_alsa.snd_seq_event_t_type_set
    __swig_getmethods__["type"] = _sequencer_alsa.snd_seq_event_t_type_get
    if _newclass:
        type = _swig_property(_sequencer_alsa.snd_seq_event_t_type_get, _sequencer_alsa.snd_seq_event_t_type_set)
    __swig_setmethods__["flags"] = _sequencer_alsa.snd_seq_event_t_flags_set
    __swig_getmethods__["flags"] = _sequencer_alsa.snd_seq_event_t_flags_get
    if _newclass:
        flags = _swig_property(_sequencer_alsa.snd_seq_event_t_flags_get, _sequencer_alsa.snd_seq_event_t_flags_set)
    __swig_setmethods__["tag"] = _sequencer_alsa.snd_seq_event_t_tag_set
    __swig_getmethods__["tag"] = _sequencer_alsa.snd_seq_event_t_tag_get
    if _newclass:
        tag = _swig_property(_sequencer_alsa.snd_seq_event_t_tag_get, _sequencer_alsa.snd_seq_event_t_tag_set)
    __swig_setmethods__["queue"] = _sequencer_alsa.snd_seq_event_t_queue_set
    __swig_getmethods__["queue"] = _sequencer_alsa.snd_seq_event_t_queue_get
    if _newclass:
        queue = _swig_property(_sequencer_alsa.snd_seq_event_t_queue_get, _sequencer_alsa.snd_seq_event_t_queue_set)
    __swig_setmethods__["time"] = _sequencer_alsa.snd_seq_event_t_time_set
    __swig_getmethods__["time"] = _sequencer_alsa.snd_seq_event_t_time_get
    if _newclass:
        time = _swig_property(_sequencer_alsa.snd_seq_event_t_time_get, _sequencer_alsa.snd_seq_event_t_time_set)
    __swig_setmethods__["source"] = _sequencer_alsa.snd_seq_event_t_source_set
    __swig_getmethods__["source"] = _sequencer_alsa.snd_seq_event_t_source_get
    if _newclass:
        source = _swig_property(_sequencer_alsa.snd_seq_event_t_source_get, _sequencer_alsa.snd_seq_event_t_source_set)
    __swig_setmethods__["dest"] = _sequencer_alsa.snd_seq_event_t_dest_set
    __swig_getmethods__["dest"] = _sequencer_alsa.snd_seq_event_t_dest_get
    if _newclass:
        dest = _swig_property(_sequencer_alsa.snd_seq_event_t_dest_get, _sequencer_alsa.snd_seq_event_t_dest_set)
    __swig_getmethods__["data"] = _sequencer_alsa.snd_seq_event_t_data_get
    if _newclass:
        data = _swig_property(_sequencer_alsa.snd_seq_event_t_data_get)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_event_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_event_t
    __del__ = lambda self: None
snd_seq_event_t_swigregister = _sequencer_alsa.snd_seq_event_t_swigregister
snd_seq_event_t_swigregister(snd_seq_event_t)

class snd_seq_event_data(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, snd_seq_event_data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, snd_seq_event_data, name)
    __repr__ = _swig_repr
    __swig_setmethods__["note"] = _sequencer_alsa.snd_seq_event_data_note_set
    __swig_getmethods__["note"] = _sequencer_alsa.snd_seq_event_data_note_get
    if _newclass:
        note = _swig_property(_sequencer_alsa.snd_seq_event_data_note_get, _sequencer_alsa.snd_seq_event_data_note_set)
    __swig_setmethods__["control"] = _sequencer_alsa.snd_seq_event_data_control_set
    __swig_getmethods__["control"] = _sequencer_alsa.snd_seq_event_data_control_get
    if _newclass:
        control = _swig_property(_sequencer_alsa.snd_seq_event_data_control_get, _sequencer_alsa.snd_seq_event_data_control_set)
    __swig_setmethods__["raw8"] = _sequencer_alsa.snd_seq_event_data_raw8_set
    __swig_getmethods__["raw8"] = _sequencer_alsa.snd_seq_event_data_raw8_get
    if _newclass:
        raw8 = _swig_property(_sequencer_alsa.snd_seq_event_data_raw8_get, _sequencer_alsa.snd_seq_event_data_raw8_set)
    __swig_setmethods__["raw32"] = _sequencer_alsa.snd_seq_event_data_raw32_set
    __swig_getmethods__["raw32"] = _sequencer_alsa.snd_seq_event_data_raw32_get
    if _newclass:
        raw32 = _swig_property(_sequencer_alsa.snd_seq_event_data_raw32_get, _sequencer_alsa.snd_seq_event_data_raw32_set)
    __swig_setmethods__["ext"] = _sequencer_alsa.snd_seq_event_data_ext_set
    __swig_getmethods__["ext"] = _sequencer_alsa.snd_seq_event_data_ext_get
    if _newclass:
        ext = _swig_property(_sequencer_alsa.snd_seq_event_data_ext_get, _sequencer_alsa.snd_seq_event_data_ext_set)
    __swig_setmethods__["queue"] = _sequencer_alsa.snd_seq_event_data_queue_set
    __swig_getmethods__["queue"] = _sequencer_alsa.snd_seq_event_data_queue_get
    if _newclass:
        queue = _swig_property(_sequencer_alsa.snd_seq_event_data_queue_get, _sequencer_alsa.snd_seq_event_data_queue_set)
    __swig_setmethods__["time"] = _sequencer_alsa.snd_seq_event_data_time_set
    __swig_getmethods__["time"] = _sequencer_alsa.snd_seq_event_data_time_get
    if _newclass:
        time = _swig_property(_sequencer_alsa.snd_seq_event_data_time_get, _sequencer_alsa.snd_seq_event_data_time_set)
    __swig_setmethods__["addr"] = _sequencer_alsa.snd_seq_event_data_addr_set
    __swig_getmethods__["addr"] = _sequencer_alsa.snd_seq_event_data_addr_get
    if _newclass:
        addr = _swig_property(_sequencer_alsa.snd_seq_event_data_addr_get, _sequencer_alsa.snd_seq_event_data_addr_set)
    __swig_setmethods__["connect"] = _sequencer_alsa.snd_seq_event_data_connect_set
    __swig_getmethods__["connect"] = _sequencer_alsa.snd_seq_event_data_connect_get
    if _newclass:
        connect = _swig_property(_sequencer_alsa.snd_seq_event_data_connect_get, _sequencer_alsa.snd_seq_event_data_connect_set)
    __swig_setmethods__["result"] = _sequencer_alsa.snd_seq_event_data_result_set
    __swig_getmethods__["result"] = _sequencer_alsa.snd_seq_event_data_result_get
    if _newclass:
        result = _swig_property(_sequencer_alsa.snd_seq_event_data_result_get, _sequencer_alsa.snd_seq_event_data_result_set)

    def __init__(self):
        this = _sequencer_alsa.new_snd_seq_event_data()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _sequencer_alsa.delete_snd_seq_event_data
    __del__ = lambda self: None
snd_seq_event_data_swigregister = _sequencer_alsa.snd_seq_event_data_swigregister
snd_seq_event_data_swigregister(snd_seq_event_data)


def snd_midi_event_new(bufsize, rdev):
    return _sequencer_alsa.snd_midi_event_new(bufsize, rdev)
snd_midi_event_new = _sequencer_alsa.snd_midi_event_new

def snd_midi_event_resize_buffer(dev, bufsize):
    return _sequencer_alsa.snd_midi_event_resize_buffer(dev, bufsize)
snd_midi_event_resize_buffer = _sequencer_alsa.snd_midi_event_resize_buffer

def snd_midi_event_free(dev):
    return _sequencer_alsa.snd_midi_event_free(dev)
snd_midi_event_free = _sequencer_alsa.snd_midi_event_free

def snd_midi_event_init(dev):
    return _sequencer_alsa.snd_midi_event_init(dev)
snd_midi_event_init = _sequencer_alsa.snd_midi_event_init

def snd_midi_event_reset_encode(dev):
    return _sequencer_alsa.snd_midi_event_reset_encode(dev)
snd_midi_event_reset_encode = _sequencer_alsa.snd_midi_event_reset_encode

def snd_midi_event_reset_decode(dev):
    return _sequencer_alsa.snd_midi_event_reset_decode(dev)
snd_midi_event_reset_decode = _sequencer_alsa.snd_midi_event_reset_decode

def snd_midi_event_no_status(dev, on):
    return _sequencer_alsa.snd_midi_event_no_status(dev, on)
snd_midi_event_no_status = _sequencer_alsa.snd_midi_event_no_status

def snd_midi_event_encode(dev, buf, count, ev):
    return _sequencer_alsa.snd_midi_event_encode(dev, buf, count, ev)
snd_midi_event_encode = _sequencer_alsa.snd_midi_event_encode

def snd_midi_event_encode_byte(dev, c, ev):
    return _sequencer_alsa.snd_midi_event_encode_byte(dev, c, ev)
snd_midi_event_encode_byte = _sequencer_alsa.snd_midi_event_encode_byte

def snd_midi_event_decode(dev, buf, count, ev):
    return _sequencer_alsa.snd_midi_event_decode(dev, buf, count, ev)
snd_midi_event_decode = _sequencer_alsa.snd_midi_event_decode

_sequencer_alsa.SND_ERROR_BEGIN_swigconstant(_sequencer_alsa)
SND_ERROR_BEGIN = _sequencer_alsa.SND_ERROR_BEGIN

_sequencer_alsa.SND_ERROR_INCOMPATIBLE_VERSION_swigconstant(_sequencer_alsa)
SND_ERROR_INCOMPATIBLE_VERSION = _sequencer_alsa.SND_ERROR_INCOMPATIBLE_VERSION

_sequencer_alsa.SND_ERROR_ALISP_NIL_swigconstant(_sequencer_alsa)
SND_ERROR_ALISP_NIL = _sequencer_alsa.SND_ERROR_ALISP_NIL

def snd_strerror(errnum):
    return _sequencer_alsa.snd_strerror(errnum)
snd_strerror = _sequencer_alsa.snd_strerror

def snd_lib_error_set_handler(handler):
    return _sequencer_alsa.snd_lib_error_set_handler(handler)
snd_lib_error_set_handler = _sequencer_alsa.snd_lib_error_set_handler

def snd_lib_error_set_local(func):
    return _sequencer_alsa.snd_lib_error_set_local(func)
snd_lib_error_set_local = _sequencer_alsa.snd_lib_error_set_local
# This file is compatible with both classic and new-style classes.