/* main.c generated by valac 0.14.2, the Vala compiler
 * generated from main.vala, do not modify */

/*
 * -- Mickey's DBus Utility V2 --
 *
 * Copyright (C) 2009-2011 Michael 'Mickey' Lauer <mlauer@vanille-media.de>
 *                         Frederik 'playya' Sdun <frederik.sdun@googlemail.com>
 *                         Simon Busch <morphis@gravedo.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <gio/gio.h>
#include <stdio.h>
#include <readline/readline.h>
#include <readline/history.h>


#define TYPE_INTROSPECTABLE (introspectable_get_type ())
#define INTROSPECTABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_INTROSPECTABLE, Introspectable))
#define IS_INTROSPECTABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_INTROSPECTABLE))
#define INTROSPECTABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_INTROSPECTABLE, IntrospectableIface))

typedef struct _Introspectable Introspectable;
typedef struct _IntrospectableIface IntrospectableIface;

#define TYPE_INTROSPECTABLE_PROXY (introspectable_proxy_get_type ())
typedef GDBusProxy IntrospectableProxy;
typedef GDBusProxyClass IntrospectableProxyClass;
#define _g_free0(var) (var = (g_free (var), NULL))

#define TYPE_DBUS_SYNC (dbus_sync_get_type ())
#define DBUS_SYNC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DBUS_SYNC, DBusSync))
#define IS_DBUS_SYNC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DBUS_SYNC))
#define DBUS_SYNC_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_DBUS_SYNC, DBusSyncIface))

typedef struct _DBusSync DBusSync;
typedef struct _DBusSyncIface DBusSyncIface;

#define TYPE_DBUS_SYNC_PROXY (dbus_sync_proxy_get_type ())
typedef GDBusProxy DBusSyncProxy;
typedef GDBusProxyClass DBusSyncProxyClass;
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))

#define TYPE_COMMANDS (commands_get_type ())
#define COMMANDS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_COMMANDS, Commands))
#define COMMANDS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_COMMANDS, CommandsClass))
#define IS_COMMANDS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_COMMANDS))
#define IS_COMMANDS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_COMMANDS))
#define COMMANDS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_COMMANDS, CommandsClass))

typedef struct _Commands Commands;
typedef struct _CommandsClass CommandsClass;
typedef struct _CommandsPrivate CommandsPrivate;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define __g_list_free__g_free0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__g_free0_ (var), NULL)))
#define _g_dbus_node_info_unref0(var) ((var == NULL) ? NULL : (var = (g_dbus_node_info_unref (var), NULL)))
#define _g_dbus_method_info_unref0(var) ((var == NULL) ? NULL : (var = (g_dbus_method_info_unref (var), NULL)))
#define _g_dbus_interface_info_unref0(var) ((var == NULL) ? NULL : (var = (g_dbus_interface_info_unref (var), NULL)))
#define _g_dbus_property_info_unref0(var) ((var == NULL) ? NULL : (var = (g_dbus_property_info_unref (var), NULL)))

#define TYPE_ARGUMENT (argument_get_type ())
#define ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ARGUMENT, Argument))
#define ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ARGUMENT, ArgumentClass))
#define IS_ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ARGUMENT))
#define IS_ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ARGUMENT))
#define ARGUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ARGUMENT, ArgumentClass))

typedef struct _Argument Argument;
typedef struct _ArgumentClass ArgumentClass;
#define _g_dbus_arg_info_unref0(var) ((var == NULL) ? NULL : (var = (g_dbus_arg_info_unref (var), NULL)))
#define _g_variant_type_free0(var) ((var == NULL) ? NULL : (var = (g_variant_type_free (var), NULL)))
#define _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))
#define _g_variant_builder_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_builder_unref (var), NULL)))
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
#define _g_dbus_signal_info_unref0(var) ((var == NULL) ? NULL : (var = (g_dbus_signal_info_unref (var), NULL)))
#define _g_option_context_free0(var) ((var == NULL) ? NULL : (var = (g_option_context_free (var), NULL)))

struct _IntrospectableIface {
	GTypeInterface parent_iface;
	gchar* (*introspect) (Introspectable* self, GError** error);
};

struct _DBusSyncIface {
	GTypeInterface parent_iface;
	gchar* (*hello) (DBusSync* self, GError** error);
	guint (*request_name) (DBusSync* self, const gchar* param0, guint param1, GError** error);
	guint (*release_name) (DBusSync* self, const gchar* param0, GError** error);
	guint (*start_service_by_name) (DBusSync* self, const gchar* param0, guint param1, GError** error);
	void (*update_activation_environment) (DBusSync* self, GHashTable* param0, GError** error);
	gboolean (*name_has_owner) (DBusSync* self, const gchar* param0, GError** error);
	gchar** (*list_names) (DBusSync* self, int* result_length1, GError** error);
	gchar** (*list_activatable_names) (DBusSync* self, int* result_length1, GError** error);
	void (*add_match) (DBusSync* self, const gchar* param0, GError** error);
	void (*remove_match) (DBusSync* self, const gchar* param0, GError** error);
	gchar* (*get_name_owner) (DBusSync* self, const gchar* param0, GError** error);
	guint (*get_connection_unix_user) (DBusSync* self, const gchar* param0, GError** error);
	guint (*get_connection_unix_process_i_d) (DBusSync* self, const gchar* param0, GError** error);
	guint8* (*get_adt_audit_session_data) (DBusSync* self, const gchar* param0, int* result_length1, GError** error);
	void (*reload_config) (DBusSync* self, GError** error);
	gchar* (*get_id) (DBusSync* self, GError** error);
};

struct _Commands {
	GObject parent_instance;
	CommandsPrivate * priv;
};

struct _CommandsClass {
	GObjectClass parent_class;
};

struct _CommandsPrivate {
	GDBusConnection* bus;
	DBusSync* busobj;
};


extern Commands* commands;
Commands* commands = NULL;
extern GList* completions;
GList* completions = NULL;
static gpointer commands_parent_class = NULL;
extern gboolean useSystemBus;
extern gboolean showAnonymous;
extern gboolean interactive;
extern gboolean showPIDs;
extern gboolean annotateTypes;
gboolean showAnonymous = FALSE;
extern gboolean listenerMode;
gboolean listenerMode = FALSE;
gboolean showPIDs = FALSE;
gboolean useSystemBus = FALSE;
gboolean interactive = FALSE;
gboolean annotateTypes = FALSE;

#define DBUS_BUS_NAME "org.freedesktop.DBus"
#define DBUS_OBJ_PATH "/"
#define DBUS_INTERFACE "org.freedesktop.DBus"
#define DBUS_INTERFACE_INTROSPECTABLE "org.freedesktop.DBus.Introspectable"
GType introspectable_proxy_get_type (void) G_GNUC_CONST;
guint introspectable_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType introspectable_get_type (void) G_GNUC_CONST;
gchar* introspectable_introspect (Introspectable* self, GError** error);
static void introspectable_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static gchar* introspectable_proxy_introspect (Introspectable* self, GError** error);
static void introspectable_proxy_introspectable_interface_init (IntrospectableIface* iface);
static void _dbus_introspectable_introspect (Introspectable* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void introspectable_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* introspectable_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean introspectable_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _introspectable_unregister_object (gpointer user_data);
GType dbus_sync_proxy_get_type (void) G_GNUC_CONST;
guint dbus_sync_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType dbus_sync_get_type (void) G_GNUC_CONST;
gchar* dbus_sync_hello (DBusSync* self, GError** error);
guint dbus_sync_request_name (DBusSync* self, const gchar* param0, guint param1, GError** error);
guint dbus_sync_release_name (DBusSync* self, const gchar* param0, GError** error);
guint dbus_sync_start_service_by_name (DBusSync* self, const gchar* param0, guint param1, GError** error);
void dbus_sync_update_activation_environment (DBusSync* self, GHashTable* param0, GError** error);
gboolean dbus_sync_name_has_owner (DBusSync* self, const gchar* param0, GError** error);
gchar** dbus_sync_list_names (DBusSync* self, int* result_length1, GError** error);
gchar** dbus_sync_list_activatable_names (DBusSync* self, int* result_length1, GError** error);
void dbus_sync_add_match (DBusSync* self, const gchar* param0, GError** error);
void dbus_sync_remove_match (DBusSync* self, const gchar* param0, GError** error);
gchar* dbus_sync_get_name_owner (DBusSync* self, const gchar* param0, GError** error);
guint dbus_sync_get_connection_unix_user (DBusSync* self, const gchar* param0, GError** error);
guint dbus_sync_get_connection_unix_process_i_d (DBusSync* self, const gchar* param0, GError** error);
guint8* dbus_sync_get_adt_audit_session_data (DBusSync* self, const gchar* param0, int* result_length1, GError** error);
void dbus_sync_reload_config (DBusSync* self, GError** error);
gchar* dbus_sync_get_id (DBusSync* self, GError** error);
static void g_cclosure_user_marshal_VOID__STRING_STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
static void dbus_sync_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static void _dbus_handle_dbus_sync_name_owner_changed (DBusSync* self, GVariant* parameters);
static void _dbus_handle_dbus_sync_name_lost (DBusSync* self, GVariant* parameters);
static void _dbus_handle_dbus_sync_name_acquired (DBusSync* self, GVariant* parameters);
static gchar* dbus_sync_proxy_hello (DBusSync* self, GError** error);
static guint dbus_sync_proxy_request_name (DBusSync* self, const gchar* param0, guint param1, GError** error);
static guint dbus_sync_proxy_release_name (DBusSync* self, const gchar* param0, GError** error);
static guint dbus_sync_proxy_start_service_by_name (DBusSync* self, const gchar* param0, guint param1, GError** error);
static void dbus_sync_proxy_update_activation_environment (DBusSync* self, GHashTable* param0, GError** error);
static gboolean dbus_sync_proxy_name_has_owner (DBusSync* self, const gchar* param0, GError** error);
static gchar** dbus_sync_proxy_list_names (DBusSync* self, int* result_length1, GError** error);
static gchar** dbus_sync_proxy_list_activatable_names (DBusSync* self, int* result_length1, GError** error);
static void dbus_sync_proxy_add_match (DBusSync* self, const gchar* param0, GError** error);
static void dbus_sync_proxy_remove_match (DBusSync* self, const gchar* param0, GError** error);
static gchar* dbus_sync_proxy_get_name_owner (DBusSync* self, const gchar* param0, GError** error);
static guint dbus_sync_proxy_get_connection_unix_user (DBusSync* self, const gchar* param0, GError** error);
static guint dbus_sync_proxy_get_connection_unix_process_i_d (DBusSync* self, const gchar* param0, GError** error);
static guint8* dbus_sync_proxy_get_adt_audit_session_data (DBusSync* self, const gchar* param0, int* result_length1, GError** error);
static void dbus_sync_proxy_reload_config (DBusSync* self, GError** error);
static gchar* dbus_sync_proxy_get_id (DBusSync* self, GError** error);
static void dbus_sync_proxy_dbus_sync_interface_init (DBusSyncIface* iface);
static void _dbus_dbus_sync_hello (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_request_name (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_release_name (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_start_service_by_name (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_update_activation_environment (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_name_has_owner (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_list_names (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_list_activatable_names (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_add_match (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_remove_match (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_get_name_owner (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_get_connection_unix_user (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_get_connection_unix_process_i_d (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_get_adt_audit_session_data (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_reload_config (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_sync_get_id (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void dbus_sync_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* dbus_sync_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean dbus_sync_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _dbus_dbus_sync_name_owner_changed (GObject* _sender, const gchar* param0, const gchar* param1, const gchar* param2, gpointer* _data);
static void _dbus_dbus_sync_name_lost (GObject* _sender, const gchar* param0, gpointer* _data);
static void _dbus_dbus_sync_name_acquired (GObject* _sender, const gchar* param0, gpointer* _data);
static void _dbus_sync_unregister_object (gpointer user_data);
GType commands_get_type (void) G_GNUC_CONST;
#define COMMANDS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_COMMANDS, CommandsPrivate))
enum  {
	COMMANDS_DUMMY_PROPERTY
};
Commands* commands_new (GBusType bustype);
Commands* commands_construct (GType object_type, GBusType bustype);
gboolean commands_isValidBusName (Commands* self, const gchar* busname);
gboolean commands_isValidObjectPath (Commands* self, const gchar* busname, const gchar* path);
static gchar* commands_appendPidToBusName (Commands* self, const gchar* name);
GList* _commands_listBusNames (Commands* self, const gchar* prefix);
static void _g_free0_ (gpointer var);
static void _g_list_free__g_free0_ (GList* self);
void commands_listBusNames (Commands* self);
void _commands_listObjects (Commands* self, const gchar* busname, const gchar* path, GList** _result_, const gchar* prefix, gboolean with_interfaces);
GDBusNodeInfo* commands_getNodeInfo (Commands* self, const gchar* busname, const gchar* path);
void commands_listObjects (Commands* self, const gchar* busname, const gchar* path);
GList* _commands_listInterfaces (Commands* self, const gchar* busname, const gchar* path, const gchar* prefix, gboolean stripSignals);
gchar* commands_splitInterfaceMethod (Commands* self, const gchar* interface, gchar** method);
static gchar** commands_interfaceDescription (Commands* self, GDBusInterfaceInfo* iface, gboolean stripSignals, int* result_length1);
void commands_listInterfaces (Commands* self, const gchar* busname, const gchar* path);
gboolean commands_callMethod (Commands* self, const gchar* busname, const gchar* path, const gchar* method, gchar** args, int args_length1);
static gchar* commands_buildSignature (Commands* self, GDBusArgInfo** args, int args_length1, gboolean with_names);
Argument* argument_new (const gchar* name, const gchar* type, GVariantBuilder* vbuilder);
Argument* argument_construct (GType object_type, const gchar* name, const gchar* type, GVariantBuilder* vbuilder);
GType argument_get_type (void) G_GNUC_CONST;
gboolean argument_append (Argument* self, const gchar* arg);
void commands_signalHandler (Commands* self, GDBusConnection* conn, const gchar* sender, const gchar* path, const gchar* iface, const gchar* name, GVariant* params);
void commands_listenForSignals (Commands* self, const gchar* busname, const gchar* objectpath, const gchar* iface);
static void _commands_signalHandler_gd_bus_signal_callback (GDBusConnection* connection, const gchar* sender_name, const gchar* object_path, const gchar* interface_name, const gchar* signal_name, GVariant* parameters, gpointer self);
static gboolean commands_parseCmdlineForCallMethod (Commands* self, const gchar* commandline, gchar*** args, int* args_length1);
static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value);
static gchar** _vala_array_dup1 (gchar** self, int length);
static void commands_performCommandFromShell (Commands* self, const gchar* commandline);
static gchar* commands_completion (const gchar* prefix, gint state);
static gchar* commands_methodToString (Commands* self, GDBusMethodInfo* method, const gchar* iface);
static void _vala_array_add2 (gchar*** array, int* length, int* size, gchar* value);
static void _vala_array_add3 (gchar*** array, int* length, int* size, gchar* value);
static gchar* commands_propertyToString (Commands* self, GDBusPropertyInfo* prop, const gchar* iface);
static void _vala_array_add4 (gchar*** array, int* length, int* size, gchar* value);
static void _vala_array_add5 (gchar*** array, int* length, int* size, gchar* value);
static gchar* commands_signalToString (Commands* self, GDBusSignalInfo* signal, const gchar* iface);
static void _vala_array_add6 (gchar*** array, int* length, int* size, gchar* value);
void commands_launchShell (Commands* self);
static gchar* _commands_completion_rl_compentry_func_t (const gchar* str, gint a);
static void commands_finalize (GObject* obj);
gint _vala_main (gchar** args, int args_length1);
static void _vala_array_add7 (gchar*** array, int* length, int* size, gchar* value);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
static gint _vala_array_length (gpointer array);

static const GDBusArgInfo _introspectable_dbus_arg_info_introspect_result = {-1, "result", "s"};
static const GDBusArgInfo * const _introspectable_dbus_arg_info_introspect_in[] = {NULL};
static const GDBusArgInfo * const _introspectable_dbus_arg_info_introspect_out[] = {&_introspectable_dbus_arg_info_introspect_result, NULL};
static const GDBusMethodInfo _introspectable_dbus_method_info_introspect = {-1, "Introspect", (GDBusArgInfo **) (&_introspectable_dbus_arg_info_introspect_in), (GDBusArgInfo **) (&_introspectable_dbus_arg_info_introspect_out)};
static const GDBusMethodInfo * const _introspectable_dbus_method_info[] = {&_introspectable_dbus_method_info_introspect, NULL};
static const GDBusSignalInfo * const _introspectable_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _introspectable_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _introspectable_dbus_interface_info = {-1, "org.freedesktop.DBus.Introspectable", (GDBusMethodInfo **) (&_introspectable_dbus_method_info), (GDBusSignalInfo **) (&_introspectable_dbus_signal_info), (GDBusPropertyInfo **) (&_introspectable_dbus_property_info)};
static const GDBusInterfaceVTable _introspectable_dbus_interface_vtable = {introspectable_dbus_interface_method_call, introspectable_dbus_interface_get_property, introspectable_dbus_interface_set_property};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_hello_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_hello_in[] = {NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_hello_out[] = {&_dbus_sync_dbus_arg_info_hello_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_hello = {-1, "Hello", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_hello_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_hello_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_request_name_param0 = {-1, "param0", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_request_name_param1 = {-1, "param1", "u"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_request_name_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_request_name_in[] = {&_dbus_sync_dbus_arg_info_request_name_param0, &_dbus_sync_dbus_arg_info_request_name_param1, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_request_name_out[] = {&_dbus_sync_dbus_arg_info_request_name_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_request_name = {-1, "RequestName", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_request_name_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_request_name_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_release_name_param0 = {-1, "param0", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_release_name_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_release_name_in[] = {&_dbus_sync_dbus_arg_info_release_name_param0, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_release_name_out[] = {&_dbus_sync_dbus_arg_info_release_name_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_release_name = {-1, "ReleaseName", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_release_name_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_release_name_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_start_service_by_name_param0 = {-1, "param0", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_start_service_by_name_param1 = {-1, "param1", "u"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_start_service_by_name_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_start_service_by_name_in[] = {&_dbus_sync_dbus_arg_info_start_service_by_name_param0, &_dbus_sync_dbus_arg_info_start_service_by_name_param1, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_start_service_by_name_out[] = {&_dbus_sync_dbus_arg_info_start_service_by_name_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_start_service_by_name = {-1, "StartServiceByName", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_start_service_by_name_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_start_service_by_name_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_update_activation_environment_param0 = {-1, "param0", "a{ss}"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_update_activation_environment_in[] = {&_dbus_sync_dbus_arg_info_update_activation_environment_param0, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_update_activation_environment_out[] = {NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_update_activation_environment = {-1, "UpdateActivationEnvironment", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_update_activation_environment_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_update_activation_environment_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_name_has_owner_param0 = {-1, "param0", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_name_has_owner_result = {-1, "result", "b"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_name_has_owner_in[] = {&_dbus_sync_dbus_arg_info_name_has_owner_param0, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_name_has_owner_out[] = {&_dbus_sync_dbus_arg_info_name_has_owner_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_name_has_owner = {-1, "NameHasOwner", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_name_has_owner_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_name_has_owner_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_list_names_result = {-1, "result", "as"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_list_names_in[] = {NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_list_names_out[] = {&_dbus_sync_dbus_arg_info_list_names_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_list_names = {-1, "ListNames", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_list_names_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_list_names_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_list_activatable_names_result = {-1, "result", "as"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_list_activatable_names_in[] = {NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_list_activatable_names_out[] = {&_dbus_sync_dbus_arg_info_list_activatable_names_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_list_activatable_names = {-1, "ListActivatableNames", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_list_activatable_names_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_list_activatable_names_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_add_match_param0 = {-1, "param0", "s"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_add_match_in[] = {&_dbus_sync_dbus_arg_info_add_match_param0, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_add_match_out[] = {NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_add_match = {-1, "AddMatch", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_add_match_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_add_match_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_remove_match_param0 = {-1, "param0", "s"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_remove_match_in[] = {&_dbus_sync_dbus_arg_info_remove_match_param0, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_remove_match_out[] = {NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_remove_match = {-1, "RemoveMatch", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_remove_match_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_remove_match_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_get_name_owner_param0 = {-1, "param0", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_get_name_owner_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_name_owner_in[] = {&_dbus_sync_dbus_arg_info_get_name_owner_param0, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_name_owner_out[] = {&_dbus_sync_dbus_arg_info_get_name_owner_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_get_name_owner = {-1, "GetNameOwner", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_name_owner_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_name_owner_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_get_connection_unix_user_param0 = {-1, "param0", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_get_connection_unix_user_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_connection_unix_user_in[] = {&_dbus_sync_dbus_arg_info_get_connection_unix_user_param0, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_connection_unix_user_out[] = {&_dbus_sync_dbus_arg_info_get_connection_unix_user_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_get_connection_unix_user = {-1, "GetConnectionUnixUser", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_connection_unix_user_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_connection_unix_user_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_get_connection_unix_process_i_d_param0 = {-1, "param0", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_get_connection_unix_process_i_d_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_connection_unix_process_i_d_in[] = {&_dbus_sync_dbus_arg_info_get_connection_unix_process_i_d_param0, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_connection_unix_process_i_d_out[] = {&_dbus_sync_dbus_arg_info_get_connection_unix_process_i_d_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_get_connection_unix_process_i_d = {-1, "GetConnectionUnixProcessID", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_connection_unix_process_i_d_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_connection_unix_process_i_d_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_get_adt_audit_session_data_param0 = {-1, "param0", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_get_adt_audit_session_data_result = {-1, "result", "ay"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_adt_audit_session_data_in[] = {&_dbus_sync_dbus_arg_info_get_adt_audit_session_data_param0, NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_adt_audit_session_data_out[] = {&_dbus_sync_dbus_arg_info_get_adt_audit_session_data_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_get_adt_audit_session_data = {-1, "GetAdtAuditSessionData", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_adt_audit_session_data_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_adt_audit_session_data_out)};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_reload_config_in[] = {NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_reload_config_out[] = {NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_reload_config = {-1, "ReloadConfig", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_reload_config_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_reload_config_out)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_get_id_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_id_in[] = {NULL};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_get_id_out[] = {&_dbus_sync_dbus_arg_info_get_id_result, NULL};
static const GDBusMethodInfo _dbus_sync_dbus_method_info_get_id = {-1, "GetId", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_id_in), (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_get_id_out)};
static const GDBusMethodInfo * const _dbus_sync_dbus_method_info[] = {&_dbus_sync_dbus_method_info_hello, &_dbus_sync_dbus_method_info_request_name, &_dbus_sync_dbus_method_info_release_name, &_dbus_sync_dbus_method_info_start_service_by_name, &_dbus_sync_dbus_method_info_update_activation_environment, &_dbus_sync_dbus_method_info_name_has_owner, &_dbus_sync_dbus_method_info_list_names, &_dbus_sync_dbus_method_info_list_activatable_names, &_dbus_sync_dbus_method_info_add_match, &_dbus_sync_dbus_method_info_remove_match, &_dbus_sync_dbus_method_info_get_name_owner, &_dbus_sync_dbus_method_info_get_connection_unix_user, &_dbus_sync_dbus_method_info_get_connection_unix_process_i_d, &_dbus_sync_dbus_method_info_get_adt_audit_session_data, &_dbus_sync_dbus_method_info_reload_config, &_dbus_sync_dbus_method_info_get_id, NULL};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_name_owner_changed_param0 = {-1, "param0", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_name_owner_changed_param1 = {-1, "param1", "s"};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_name_owner_changed_param2 = {-1, "param2", "s"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_name_owner_changed[] = {&_dbus_sync_dbus_arg_info_name_owner_changed_param0, &_dbus_sync_dbus_arg_info_name_owner_changed_param1, &_dbus_sync_dbus_arg_info_name_owner_changed_param2, NULL};
static const GDBusSignalInfo _dbus_sync_dbus_signal_info_name_owner_changed = {-1, "NameOwnerChanged", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_name_owner_changed)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_name_lost_param0 = {-1, "param0", "s"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_name_lost[] = {&_dbus_sync_dbus_arg_info_name_lost_param0, NULL};
static const GDBusSignalInfo _dbus_sync_dbus_signal_info_name_lost = {-1, "NameLost", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_name_lost)};
static const GDBusArgInfo _dbus_sync_dbus_arg_info_name_acquired_param0 = {-1, "param0", "s"};
static const GDBusArgInfo * const _dbus_sync_dbus_arg_info_name_acquired[] = {&_dbus_sync_dbus_arg_info_name_acquired_param0, NULL};
static const GDBusSignalInfo _dbus_sync_dbus_signal_info_name_acquired = {-1, "NameAcquired", (GDBusArgInfo **) (&_dbus_sync_dbus_arg_info_name_acquired)};
static const GDBusSignalInfo * const _dbus_sync_dbus_signal_info[] = {&_dbus_sync_dbus_signal_info_name_owner_changed, &_dbus_sync_dbus_signal_info_name_lost, &_dbus_sync_dbus_signal_info_name_acquired, NULL};
static const GDBusPropertyInfo * const _dbus_sync_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_sync_dbus_interface_info = {-1, "org.freedesktop.DBus", (GDBusMethodInfo **) (&_dbus_sync_dbus_method_info), (GDBusSignalInfo **) (&_dbus_sync_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_sync_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_sync_dbus_interface_vtable = {dbus_sync_dbus_interface_method_call, dbus_sync_dbus_interface_get_property, dbus_sync_dbus_interface_set_property};
static GRegex* _tmp_regex_0 = NULL;
static GRegex* _tmp_regex_1 = NULL;
const GOptionEntry options[7] = {{"show-anonymous", 'a', 0, G_OPTION_ARG_NONE, &showAnonymous, "Show anonymous names", NULL}, {"show-pids", 'p', 0, G_OPTION_ARG_NONE, &showPIDs, "Show unix process IDs", NULL}, {"listen", 'l', 0, G_OPTION_ARG_NONE, &listenerMode, "Listen for signals", NULL}, {"system", 's', 0, G_OPTION_ARG_NONE, &useSystemBus, "Use System Bus", NULL}, {"interactive", 'i', 0, G_OPTION_ARG_NONE, &interactive, "Enter interactive shell", NULL}, {"annotate-types", 't', 0, G_OPTION_ARG_NONE, &annotateTypes, "Annotate DBus type", NULL}, {NULL}};

gchar* introspectable_introspect (Introspectable* self, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return INTROSPECTABLE_GET_INTERFACE (self)->introspect (self, error);
}


static void introspectable_base_init (IntrospectableIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
	}
}


GType introspectable_get_type (void) {
	static volatile gsize introspectable_type_id__volatile = 0;
	if (g_once_init_enter (&introspectable_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (IntrospectableIface), (GBaseInitFunc) introspectable_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType introspectable_type_id;
		introspectable_type_id = g_type_register_static (G_TYPE_INTERFACE, "Introspectable", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (introspectable_type_id, G_TYPE_OBJECT);
		g_type_set_qdata (introspectable_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) introspectable_proxy_get_type);
		g_type_set_qdata (introspectable_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.freedesktop.DBus.Introspectable");
		g_type_set_qdata (introspectable_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) introspectable_register_object);
		g_once_init_leave (&introspectable_type_id__volatile, introspectable_type_id);
	}
	return introspectable_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (IntrospectableProxy, introspectable_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (TYPE_INTROSPECTABLE, introspectable_proxy_introspectable_interface_init) )
static void introspectable_proxy_class_init (IntrospectableProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = introspectable_proxy_g_signal;
}


static void introspectable_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
}


static void introspectable_proxy_init (IntrospectableProxy* self) {
}


static gchar* introspectable_proxy_introspect (Introspectable* self, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp0_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus.Introspectable", "Introspect");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp0_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp0_, NULL);
	g_variant_unref (_tmp0_);
	g_object_unref (_reply_message);
	return _result;
}


static void introspectable_proxy_introspectable_interface_init (IntrospectableIface* iface) {
	iface->introspect = introspectable_proxy_introspect;
}


static void _dbus_introspectable_introspect (Introspectable* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = introspectable_introspect (self, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void introspectable_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "Introspect") == 0) {
		_dbus_introspectable_introspect (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* introspectable_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean introspectable_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


guint introspectable_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, (GDBusInterfaceInfo *) (&_introspectable_dbus_interface_info), &_introspectable_dbus_interface_vtable, data, _introspectable_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _introspectable_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


gchar* dbus_sync_hello (DBusSync* self, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SYNC_GET_INTERFACE (self)->hello (self, error);
}


guint dbus_sync_request_name (DBusSync* self, const gchar* param0, guint param1, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SYNC_GET_INTERFACE (self)->request_name (self, param0, param1, error);
}


guint dbus_sync_release_name (DBusSync* self, const gchar* param0, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SYNC_GET_INTERFACE (self)->release_name (self, param0, error);
}


guint dbus_sync_start_service_by_name (DBusSync* self, const gchar* param0, guint param1, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SYNC_GET_INTERFACE (self)->start_service_by_name (self, param0, param1, error);
}


void dbus_sync_update_activation_environment (DBusSync* self, GHashTable* param0, GError** error) {
	g_return_if_fail (self != NULL);
	DBUS_SYNC_GET_INTERFACE (self)->update_activation_environment (self, param0, error);
}


gboolean dbus_sync_name_has_owner (DBusSync* self, const gchar* param0, GError** error) {
	g_return_val_if_fail (self != NULL, FALSE);
	return DBUS_SYNC_GET_INTERFACE (self)->name_has_owner (self, param0, error);
}


gchar** dbus_sync_list_names (DBusSync* self, int* result_length1, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SYNC_GET_INTERFACE (self)->list_names (self, result_length1, error);
}


gchar** dbus_sync_list_activatable_names (DBusSync* self, int* result_length1, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SYNC_GET_INTERFACE (self)->list_activatable_names (self, result_length1, error);
}


void dbus_sync_add_match (DBusSync* self, const gchar* param0, GError** error) {
	g_return_if_fail (self != NULL);
	DBUS_SYNC_GET_INTERFACE (self)->add_match (self, param0, error);
}


void dbus_sync_remove_match (DBusSync* self, const gchar* param0, GError** error) {
	g_return_if_fail (self != NULL);
	DBUS_SYNC_GET_INTERFACE (self)->remove_match (self, param0, error);
}


gchar* dbus_sync_get_name_owner (DBusSync* self, const gchar* param0, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SYNC_GET_INTERFACE (self)->get_name_owner (self, param0, error);
}


guint dbus_sync_get_connection_unix_user (DBusSync* self, const gchar* param0, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SYNC_GET_INTERFACE (self)->get_connection_unix_user (self, param0, error);
}


guint dbus_sync_get_connection_unix_process_i_d (DBusSync* self, const gchar* param0, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SYNC_GET_INTERFACE (self)->get_connection_unix_process_i_d (self, param0, error);
}


guint8* dbus_sync_get_adt_audit_session_data (DBusSync* self, const gchar* param0, int* result_length1, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SYNC_GET_INTERFACE (self)->get_adt_audit_session_data (self, param0, result_length1, error);
}


void dbus_sync_reload_config (DBusSync* self, GError** error) {
	g_return_if_fail (self != NULL);
	DBUS_SYNC_GET_INTERFACE (self)->reload_config (self, error);
}


gchar* dbus_sync_get_id (DBusSync* self, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SYNC_GET_INTERFACE (self)->get_id (self, error);
}


static void g_cclosure_user_marshal_VOID__STRING_STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
	typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer data1, const char* arg_1, const char* arg_2, const char* arg_3, gpointer data2);
	register GMarshalFunc_VOID__STRING_STRING_STRING callback;
	register GCClosure * cc;
	register gpointer data1;
	register gpointer data2;
	cc = (GCClosure *) closure;
	g_return_if_fail (n_param_values == 4);
	if (G_CCLOSURE_SWAP_DATA (closure)) {
		data1 = closure->data;
		data2 = param_values->data[0].v_pointer;
	} else {
		data1 = param_values->data[0].v_pointer;
		data2 = closure->data;
	}
	callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
	callback (data1, g_value_get_string (param_values + 1), g_value_get_string (param_values + 2), g_value_get_string (param_values + 3), data2);
}


static void dbus_sync_base_init (DBusSyncIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
		g_signal_new ("name_owner_changed", TYPE_DBUS_SYNC, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING_STRING, G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
		g_signal_new ("name_lost", TYPE_DBUS_SYNC, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
		g_signal_new ("name_acquired", TYPE_DBUS_SYNC, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
	}
}


GType dbus_sync_get_type (void) {
	static volatile gsize dbus_sync_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_sync_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusSyncIface), (GBaseInitFunc) dbus_sync_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType dbus_sync_type_id;
		dbus_sync_type_id = g_type_register_static (G_TYPE_INTERFACE, "DBusSync", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (dbus_sync_type_id, G_TYPE_OBJECT);
		g_type_set_qdata (dbus_sync_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) dbus_sync_proxy_get_type);
		g_type_set_qdata (dbus_sync_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.freedesktop.DBus");
		g_type_set_qdata (dbus_sync_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_sync_register_object);
		g_once_init_leave (&dbus_sync_type_id__volatile, dbus_sync_type_id);
	}
	return dbus_sync_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (DBusSyncProxy, dbus_sync_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (TYPE_DBUS_SYNC, dbus_sync_proxy_dbus_sync_interface_init) )
static void dbus_sync_proxy_class_init (DBusSyncProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = dbus_sync_proxy_g_signal;
}


static void _dbus_handle_dbus_sync_name_owner_changed (DBusSync* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp1_;
	gchar* param1 = NULL;
	GVariant* _tmp2_;
	gchar* param2 = NULL;
	GVariant* _tmp3_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp1_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp1_, NULL);
	g_variant_unref (_tmp1_);
	_tmp2_ = g_variant_iter_next_value (&_arguments_iter);
	param1 = g_variant_dup_string (_tmp2_, NULL);
	g_variant_unref (_tmp2_);
	_tmp3_ = g_variant_iter_next_value (&_arguments_iter);
	param2 = g_variant_dup_string (_tmp3_, NULL);
	g_variant_unref (_tmp3_);
	g_signal_emit_by_name (self, "name-owner-changed", param0, param1, param2);
	_g_free0 (param0);
	_g_free0 (param1);
	_g_free0 (param2);
}


static void _dbus_handle_dbus_sync_name_lost (DBusSync* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp4_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp4_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp4_, NULL);
	g_variant_unref (_tmp4_);
	g_signal_emit_by_name (self, "name-lost", param0);
	_g_free0 (param0);
}


static void _dbus_handle_dbus_sync_name_acquired (DBusSync* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp5_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp5_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp5_, NULL);
	g_variant_unref (_tmp5_);
	g_signal_emit_by_name (self, "name-acquired", param0);
	_g_free0 (param0);
}


static void dbus_sync_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
	if (strcmp (signal_name, "NameOwnerChanged") == 0) {
		_dbus_handle_dbus_sync_name_owner_changed ((DBusSync*) proxy, parameters);
	} else if (strcmp (signal_name, "NameLost") == 0) {
		_dbus_handle_dbus_sync_name_lost ((DBusSync*) proxy, parameters);
	} else if (strcmp (signal_name, "NameAcquired") == 0) {
		_dbus_handle_dbus_sync_name_acquired ((DBusSync*) proxy, parameters);
	}
}


static void dbus_sync_proxy_init (DBusSyncProxy* self) {
}


static gchar* dbus_sync_proxy_hello (DBusSync* self, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp6_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "Hello");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp6_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp6_, NULL);
	g_variant_unref (_tmp6_);
	g_object_unref (_reply_message);
	return _result;
}


static guint dbus_sync_proxy_request_name (DBusSync* self, const gchar* param0, guint param1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint _result;
	GVariant* _tmp7_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "RequestName");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (param1));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp7_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp7_);
	g_variant_unref (_tmp7_);
	g_object_unref (_reply_message);
	return _result;
}


static guint dbus_sync_proxy_release_name (DBusSync* self, const gchar* param0, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint _result;
	GVariant* _tmp8_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ReleaseName");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp8_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp8_);
	g_variant_unref (_tmp8_);
	g_object_unref (_reply_message);
	return _result;
}


static guint dbus_sync_proxy_start_service_by_name (DBusSync* self, const gchar* param0, guint param1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint _result;
	GVariant* _tmp9_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "StartServiceByName");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (param1));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp9_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp9_);
	g_variant_unref (_tmp9_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_sync_proxy_update_activation_environment (DBusSync* self, GHashTable* param0, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GVariantBuilder _tmp10_;
	GHashTableIter _tmp11_;
	gpointer _tmp12_;
	gpointer _tmp13_;
	GDBusMessage *_reply_message;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "UpdateActivationEnvironment");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_hash_table_iter_init (&_tmp11_, param0);
	g_variant_builder_init (&_tmp10_, G_VARIANT_TYPE ("a{ss}"));
	while (g_hash_table_iter_next (&_tmp11_, &_tmp12_, &_tmp13_)) {
		gchar* _key;
		gchar* _value;
		_key = (gchar*) _tmp12_;
		_value = (gchar*) _tmp13_;
		g_variant_builder_add (&_tmp10_, "{?*}", g_variant_new_string (_key), g_variant_new_string (_value));
	}
	g_variant_builder_add_value (&_arguments_builder, g_variant_builder_end (&_tmp10_));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static gboolean dbus_sync_proxy_name_has_owner (DBusSync* self, const gchar* param0, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gboolean _result;
	GVariant* _tmp14_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "NameHasOwner");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return FALSE;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return FALSE;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp14_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_boolean (_tmp14_);
	g_variant_unref (_tmp14_);
	g_object_unref (_reply_message);
	return _result;
}


static gchar** dbus_sync_proxy_list_names (DBusSync* self, int* result_length1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	GVariant* _tmp15_;
	gchar** _tmp16_;
	int _tmp16__length;
	int _tmp16__size;
	int _tmp16__length1;
	GVariantIter _tmp17_;
	GVariant* _tmp18_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ListNames");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp15_ = g_variant_iter_next_value (&_reply_iter);
	_tmp16_ = g_new (gchar*, 5);
	_tmp16__length = 0;
	_tmp16__size = 4;
	_tmp16__length1 = 0;
	g_variant_iter_init (&_tmp17_, _tmp15_);
	for (; (_tmp18_ = g_variant_iter_next_value (&_tmp17_)) != NULL; _tmp16__length1++) {
		if (_tmp16__size == _tmp16__length) {
			_tmp16__size = 2 * _tmp16__size;
			_tmp16_ = g_renew (gchar*, _tmp16_, _tmp16__size + 1);
		}
		_tmp16_[_tmp16__length++] = g_variant_dup_string (_tmp18_, NULL);
		g_variant_unref (_tmp18_);
	}
	_result_length1 = _tmp16__length1;
	_tmp16_[_tmp16__length] = NULL;
	_result = _tmp16_;
	g_variant_unref (_tmp15_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static gchar** dbus_sync_proxy_list_activatable_names (DBusSync* self, int* result_length1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	GVariant* _tmp19_;
	gchar** _tmp20_;
	int _tmp20__length;
	int _tmp20__size;
	int _tmp20__length1;
	GVariantIter _tmp21_;
	GVariant* _tmp22_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ListActivatableNames");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp19_ = g_variant_iter_next_value (&_reply_iter);
	_tmp20_ = g_new (gchar*, 5);
	_tmp20__length = 0;
	_tmp20__size = 4;
	_tmp20__length1 = 0;
	g_variant_iter_init (&_tmp21_, _tmp19_);
	for (; (_tmp22_ = g_variant_iter_next_value (&_tmp21_)) != NULL; _tmp20__length1++) {
		if (_tmp20__size == _tmp20__length) {
			_tmp20__size = 2 * _tmp20__size;
			_tmp20_ = g_renew (gchar*, _tmp20_, _tmp20__size + 1);
		}
		_tmp20_[_tmp20__length++] = g_variant_dup_string (_tmp22_, NULL);
		g_variant_unref (_tmp22_);
	}
	_result_length1 = _tmp20__length1;
	_tmp20_[_tmp20__length] = NULL;
	_result = _tmp20_;
	g_variant_unref (_tmp19_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_sync_proxy_add_match (DBusSync* self, const gchar* param0, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "AddMatch");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void dbus_sync_proxy_remove_match (DBusSync* self, const gchar* param0, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "RemoveMatch");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static gchar* dbus_sync_proxy_get_name_owner (DBusSync* self, const gchar* param0, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp23_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetNameOwner");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp23_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp23_, NULL);
	g_variant_unref (_tmp23_);
	g_object_unref (_reply_message);
	return _result;
}


static guint dbus_sync_proxy_get_connection_unix_user (DBusSync* self, const gchar* param0, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint _result;
	GVariant* _tmp24_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetConnectionUnixUser");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp24_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp24_);
	g_variant_unref (_tmp24_);
	g_object_unref (_reply_message);
	return _result;
}


static guint dbus_sync_proxy_get_connection_unix_process_i_d (DBusSync* self, const gchar* param0, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint _result;
	GVariant* _tmp25_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetConnectionUnixProcessID");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp25_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp25_);
	g_variant_unref (_tmp25_);
	g_object_unref (_reply_message);
	return _result;
}


static guint8* dbus_sync_proxy_get_adt_audit_session_data (DBusSync* self, const gchar* param0, int* result_length1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint8* _result;
	int _result_length1;
	GVariant* _tmp26_;
	guint8* _tmp27_;
	int _tmp27__length;
	int _tmp27__size;
	int _tmp27__length1;
	GVariantIter _tmp28_;
	GVariant* _tmp29_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetAdtAuditSessionData");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp26_ = g_variant_iter_next_value (&_reply_iter);
	_tmp27_ = g_new (guint8, 5);
	_tmp27__length = 0;
	_tmp27__size = 4;
	_tmp27__length1 = 0;
	g_variant_iter_init (&_tmp28_, _tmp26_);
	for (; (_tmp29_ = g_variant_iter_next_value (&_tmp28_)) != NULL; _tmp27__length1++) {
		if (_tmp27__size == _tmp27__length) {
			_tmp27__size = 2 * _tmp27__size;
			_tmp27_ = g_renew (guint8, _tmp27_, _tmp27__size + 1);
		}
		_tmp27_[_tmp27__length++] = g_variant_get_byte (_tmp29_);
		g_variant_unref (_tmp29_);
	}
	_result_length1 = _tmp27__length1;
	_result = _tmp27_;
	g_variant_unref (_tmp26_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_sync_proxy_reload_config (DBusSync* self, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ReloadConfig");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static gchar* dbus_sync_proxy_get_id (DBusSync* self, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp30_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetId");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp30_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp30_, NULL);
	g_variant_unref (_tmp30_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_sync_proxy_dbus_sync_interface_init (DBusSyncIface* iface) {
	iface->hello = dbus_sync_proxy_hello;
	iface->request_name = dbus_sync_proxy_request_name;
	iface->release_name = dbus_sync_proxy_release_name;
	iface->start_service_by_name = dbus_sync_proxy_start_service_by_name;
	iface->update_activation_environment = dbus_sync_proxy_update_activation_environment;
	iface->name_has_owner = dbus_sync_proxy_name_has_owner;
	iface->list_names = dbus_sync_proxy_list_names;
	iface->list_activatable_names = dbus_sync_proxy_list_activatable_names;
	iface->add_match = dbus_sync_proxy_add_match;
	iface->remove_match = dbus_sync_proxy_remove_match;
	iface->get_name_owner = dbus_sync_proxy_get_name_owner;
	iface->get_connection_unix_user = dbus_sync_proxy_get_connection_unix_user;
	iface->get_connection_unix_process_i_d = dbus_sync_proxy_get_connection_unix_process_i_d;
	iface->get_adt_audit_session_data = dbus_sync_proxy_get_adt_audit_session_data;
	iface->reload_config = dbus_sync_proxy_reload_config;
	iface->get_id = dbus_sync_proxy_get_id;
}


static void _dbus_dbus_sync_hello (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = dbus_sync_hello (self, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_request_name (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp31_;
	guint param1 = 0U;
	GVariant* _tmp32_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp31_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp31_, NULL);
	g_variant_unref (_tmp31_);
	_tmp32_ = g_variant_iter_next_value (&_arguments_iter);
	param1 = g_variant_get_uint32 (_tmp32_);
	g_variant_unref (_tmp32_);
	result = dbus_sync_request_name (self, param0, param1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_release_name (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp33_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp33_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp33_, NULL);
	g_variant_unref (_tmp33_);
	result = dbus_sync_release_name (self, param0, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_start_service_by_name (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp34_;
	guint param1 = 0U;
	GVariant* _tmp35_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp34_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp34_, NULL);
	g_variant_unref (_tmp34_);
	_tmp35_ = g_variant_iter_next_value (&_arguments_iter);
	param1 = g_variant_get_uint32 (_tmp35_);
	g_variant_unref (_tmp35_);
	result = dbus_sync_start_service_by_name (self, param0, param1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_update_activation_environment (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GHashTable* param0 = NULL;
	GVariant* _tmp36_;
	GHashTable* _tmp37_;
	GVariantIter _tmp38_;
	GVariant* _tmp39_;
	GVariant* _tmp40_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp36_ = g_variant_iter_next_value (&_arguments_iter);
	_tmp37_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
	g_variant_iter_init (&_tmp38_, _tmp36_);
	while (g_variant_iter_loop (&_tmp38_, "{?*}", &_tmp39_, &_tmp40_)) {
		g_hash_table_insert (_tmp37_, g_variant_dup_string (_tmp39_, NULL), g_variant_dup_string (_tmp40_, NULL));
	}
	param0 = _tmp37_;
	g_variant_unref (_tmp36_);
	dbus_sync_update_activation_environment (self, param0, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_hash_table_unref0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_name_has_owner (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp41_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gboolean result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp41_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp41_, NULL);
	g_variant_unref (_tmp41_);
	result = dbus_sync_name_has_owner (self, param0, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_list_names (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	gchar** _tmp42_;
	GVariantBuilder _tmp43_;
	int _tmp44_;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = dbus_sync_list_names (self, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp42_ = result;
	g_variant_builder_init (&_tmp43_, G_VARIANT_TYPE ("as"));
	for (_tmp44_ = 0; _tmp44_ < result_length1; _tmp44_++) {
		g_variant_builder_add_value (&_tmp43_, g_variant_new_string (*_tmp42_));
		_tmp42_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp43_));
	result = (_vala_array_free (result, result_length1, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_list_activatable_names (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	gchar** _tmp45_;
	GVariantBuilder _tmp46_;
	int _tmp47_;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = dbus_sync_list_activatable_names (self, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp45_ = result;
	g_variant_builder_init (&_tmp46_, G_VARIANT_TYPE ("as"));
	for (_tmp47_ = 0; _tmp47_ < result_length1; _tmp47_++) {
		g_variant_builder_add_value (&_tmp46_, g_variant_new_string (*_tmp45_));
		_tmp45_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp46_));
	result = (_vala_array_free (result, result_length1, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_add_match (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp48_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp48_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp48_, NULL);
	g_variant_unref (_tmp48_);
	dbus_sync_add_match (self, param0, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_remove_match (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp49_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp49_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp49_, NULL);
	g_variant_unref (_tmp49_);
	dbus_sync_remove_match (self, param0, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_get_name_owner (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp50_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp50_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp50_, NULL);
	g_variant_unref (_tmp50_);
	result = dbus_sync_get_name_owner (self, param0, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_get_connection_unix_user (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp51_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp51_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp51_, NULL);
	g_variant_unref (_tmp51_);
	result = dbus_sync_get_connection_unix_user (self, param0, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_get_connection_unix_process_i_d (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp52_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp52_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp52_, NULL);
	g_variant_unref (_tmp52_);
	result = dbus_sync_get_connection_unix_process_i_d (self, param0, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_get_adt_audit_session_data (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* param0 = NULL;
	GVariant* _tmp53_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint8* result;
	int result_length1 = 0;
	guint8* _tmp54_;
	GVariantBuilder _tmp55_;
	int _tmp56_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp53_ = g_variant_iter_next_value (&_arguments_iter);
	param0 = g_variant_dup_string (_tmp53_, NULL);
	g_variant_unref (_tmp53_);
	result = dbus_sync_get_adt_audit_session_data (self, param0, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp54_ = result;
	g_variant_builder_init (&_tmp55_, G_VARIANT_TYPE ("ay"));
	for (_tmp56_ = 0; _tmp56_ < result_length1; _tmp56_++) {
		g_variant_builder_add_value (&_tmp55_, g_variant_new_byte (*_tmp54_));
		_tmp54_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp55_));
	result = (g_free (result), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (param0);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_reload_config (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	g_variant_iter_init (&_arguments_iter, parameters);
	dbus_sync_reload_config (self, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_sync_get_id (DBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = dbus_sync_get_id (self, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void dbus_sync_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "Hello") == 0) {
		_dbus_dbus_sync_hello (object, parameters, invocation);
	} else if (strcmp (method_name, "RequestName") == 0) {
		_dbus_dbus_sync_request_name (object, parameters, invocation);
	} else if (strcmp (method_name, "ReleaseName") == 0) {
		_dbus_dbus_sync_release_name (object, parameters, invocation);
	} else if (strcmp (method_name, "StartServiceByName") == 0) {
		_dbus_dbus_sync_start_service_by_name (object, parameters, invocation);
	} else if (strcmp (method_name, "UpdateActivationEnvironment") == 0) {
		_dbus_dbus_sync_update_activation_environment (object, parameters, invocation);
	} else if (strcmp (method_name, "NameHasOwner") == 0) {
		_dbus_dbus_sync_name_has_owner (object, parameters, invocation);
	} else if (strcmp (method_name, "ListNames") == 0) {
		_dbus_dbus_sync_list_names (object, parameters, invocation);
	} else if (strcmp (method_name, "ListActivatableNames") == 0) {
		_dbus_dbus_sync_list_activatable_names (object, parameters, invocation);
	} else if (strcmp (method_name, "AddMatch") == 0) {
		_dbus_dbus_sync_add_match (object, parameters, invocation);
	} else if (strcmp (method_name, "RemoveMatch") == 0) {
		_dbus_dbus_sync_remove_match (object, parameters, invocation);
	} else if (strcmp (method_name, "GetNameOwner") == 0) {
		_dbus_dbus_sync_get_name_owner (object, parameters, invocation);
	} else if (strcmp (method_name, "GetConnectionUnixUser") == 0) {
		_dbus_dbus_sync_get_connection_unix_user (object, parameters, invocation);
	} else if (strcmp (method_name, "GetConnectionUnixProcessID") == 0) {
		_dbus_dbus_sync_get_connection_unix_process_i_d (object, parameters, invocation);
	} else if (strcmp (method_name, "GetAdtAuditSessionData") == 0) {
		_dbus_dbus_sync_get_adt_audit_session_data (object, parameters, invocation);
	} else if (strcmp (method_name, "ReloadConfig") == 0) {
		_dbus_dbus_sync_reload_config (object, parameters, invocation);
	} else if (strcmp (method_name, "GetId") == 0) {
		_dbus_dbus_sync_get_id (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* dbus_sync_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean dbus_sync_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


static void _dbus_dbus_sync_name_owner_changed (GObject* _sender, const gchar* param0, const gchar* param1, const gchar* param2, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param1));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param2));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameOwnerChanged", _arguments, NULL);
}


static void _dbus_dbus_sync_name_lost (GObject* _sender, const gchar* param0, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameLost", _arguments, NULL);
}


static void _dbus_dbus_sync_name_acquired (GObject* _sender, const gchar* param0, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (param0));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameAcquired", _arguments, NULL);
}


guint dbus_sync_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, (GDBusInterfaceInfo *) (&_dbus_sync_dbus_interface_info), &_dbus_sync_dbus_interface_vtable, data, _dbus_sync_unregister_object, error);
	if (!result) {
		return 0;
	}
	g_signal_connect (object, "name-owner-changed", (GCallback) _dbus_dbus_sync_name_owner_changed, data);
	g_signal_connect (object, "name-lost", (GCallback) _dbus_dbus_sync_name_lost, data);
	g_signal_connect (object, "name-acquired", (GCallback) _dbus_dbus_sync_name_acquired, data);
	return result;
}


static void _dbus_sync_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_sync_name_owner_changed, data);
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_sync_name_lost, data);
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_sync_name_acquired, data);
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


static const gchar* string_to_string (const gchar* self) {
	const gchar* result = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	result = self;
	return result;
}


Commands* commands_construct (GType object_type, GBusType bustype) {
	Commands * self = NULL;
	GError * _inner_error_ = NULL;
	self = (Commands*) g_object_new (object_type, NULL);
	{
		GBusType _tmp0_;
		GDBusConnection* _tmp1_ = NULL;
		GDBusConnection* _tmp2_;
		GDBusConnection* _tmp3_;
		DBusSync* _tmp4_ = NULL;
		DBusSync* _tmp5_;
		_tmp0_ = bustype;
		_tmp1_ = g_bus_get_sync (_tmp0_, NULL, &_inner_error_);
		_tmp2_ = _tmp1_;
		if (_inner_error_ != NULL) {
			goto __catch0_g_error;
		}
		_g_object_unref0 (self->priv->bus);
		self->priv->bus = _tmp2_;
		_tmp3_ = self->priv->bus;
		_tmp4_ = g_initable_new (TYPE_DBUS_SYNC_PROXY, NULL, &_inner_error_, "g-flags", 0, "g-name", DBUS_BUS_NAME, "g-connection", _tmp3_, "g-object-path", DBUS_OBJ_PATH, "g-interface-name", "org.freedesktop.DBus", NULL);
		_tmp5_ = (DBusSync*) _tmp4_;
		if (_inner_error_ != NULL) {
			goto __catch0_g_error;
		}
		_g_object_unref0 (self->priv->busobj);
		self->priv->busobj = _tmp5_;
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		const gchar* _tmp6_ = NULL;
		gboolean _tmp7_;
		FILE* _tmp8_;
		GError* _tmp9_;
		const gchar* _tmp10_;
		const gchar* _tmp11_ = NULL;
		gchar* _tmp12_ = NULL;
		gchar* _tmp13_;
		const gchar* _tmp14_;
		gchar* _tmp15_ = NULL;
		gchar* _tmp16_;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp7_ = useSystemBus;
		if (_tmp7_) {
			_tmp6_ = "system";
		} else {
			_tmp6_ = "session";
		}
		_tmp8_ = stderr;
		_tmp9_ = e;
		_tmp10_ = _tmp9_->message;
		_tmp11_ = string_to_string (_tmp10_);
		_tmp12_ = g_strconcat ("Can't hook to DBus %s bus: ", _tmp11_, "\n", NULL);
		_tmp13_ = _tmp12_;
		_tmp14_ = _tmp6_;
		_tmp15_ = g_strdup_printf (_tmp13_, _tmp14_);
		_tmp16_ = _tmp15_;
		fprintf (_tmp8_, "%s", _tmp16_);
		_g_free0 (_tmp16_);
		_g_free0 (_tmp13_);
		exit (-1);
		_g_error_free0 (e);
	}
	__finally0:
	if (_inner_error_ != NULL) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	return self;
}


Commands* commands_new (GBusType bustype) {
	return commands_construct (TYPE_COMMANDS, bustype);
}


static inline GRegex* _thread_safe_regex_init (GRegex** re, const gchar * pattern, GRegexMatchFlags match_options) {
	if (g_once_init_enter ((volatile gsize*) re)) {
		GRegex* val = g_regex_new (pattern, match_options, 0, NULL);
		g_once_init_leave ((volatile gsize*) re, (gsize) val);
	}
	return *re;
}


static gpointer _g_regex_ref0 (gpointer self) {
	return self ? g_regex_ref (self) : NULL;
}


gboolean commands_isValidBusName (Commands* self, const gchar* busname) {
	gboolean result = FALSE;
	GRegex* _tmp0_;
	GRegex* reUnique;
	GRegex* _tmp1_;
	const gchar* _tmp2_;
	gboolean _tmp3_ = FALSE;
	GRegex* _tmp4_;
	GRegex* reWellKnown;
	GRegex* _tmp5_;
	const gchar* _tmp6_;
	gboolean _tmp7_ = FALSE;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (busname != NULL, FALSE);
	_tmp0_ = _g_regex_ref0 (_thread_safe_regex_init (&_tmp_regex_0, ":[0-9]\\.[0-9]+", 0));
	reUnique = _tmp0_;
	_tmp1_ = reUnique;
	_tmp2_ = busname;
	_tmp3_ = g_regex_match (_tmp1_, _tmp2_, 0, NULL);
	if (_tmp3_) {
		result = TRUE;
		_g_regex_unref0 (reUnique);
		return result;
	}
	_tmp4_ = _g_regex_ref0 (_thread_safe_regex_init (&_tmp_regex_1, "[a-zA-Z0-9]+(\\.[a-zA-Z0-9]+)+", 0));
	reWellKnown = _tmp4_;
	_tmp5_ = reWellKnown;
	_tmp6_ = busname;
	_tmp7_ = g_regex_match (_tmp5_, _tmp6_, 0, NULL);
	if (_tmp7_) {
		result = TRUE;
		_g_regex_unref0 (reWellKnown);
		_g_regex_unref0 (reUnique);
		return result;
	}
	result = FALSE;
	_g_regex_unref0 (reWellKnown);
	_g_regex_unref0 (reUnique);
	return result;
}


gboolean commands_isValidObjectPath (Commands* self, const gchar* busname, const gchar* path) {
	gboolean result = FALSE;
	const gchar* _tmp0_;
	gboolean _tmp1_ = FALSE;
	GRegex* _tmp2_;
	GRegex* reObjPath;
	GRegex* _tmp3_;
	const gchar* _tmp4_;
	gboolean _tmp5_ = FALSE;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (busname != NULL, FALSE);
	g_return_val_if_fail (path != NULL, FALSE);
	_tmp0_ = busname;
	_tmp1_ = commands_isValidBusName (self, _tmp0_);
	if (!_tmp1_) {
		result = FALSE;
		return result;
	}
	_tmp2_ = g_regex_new ("^/([a-zA-Z0-9_]+(/[a-zA-Z0-9_]+)*)?$", 0, 0, &_inner_error_);
	reObjPath = _tmp2_;
	if (_inner_error_ != NULL) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return FALSE;
	}
	_tmp3_ = reObjPath;
	_tmp4_ = path;
	_tmp5_ = g_regex_match (_tmp3_, _tmp4_, 0, NULL);
	if (_tmp5_) {
		result = TRUE;
		_g_regex_unref0 (reObjPath);
		return result;
	}
	result = FALSE;
	_g_regex_unref0 (reObjPath);
	return result;
}


static gchar* commands_appendPidToBusName (Commands* self, const gchar* name) {
	gchar* result = NULL;
	guint pid;
	gchar* _tmp4_ = NULL;
	guint _tmp5_;
	const gchar* _tmp9_;
	const gchar* _tmp10_;
	gchar* _tmp11_ = NULL;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (name != NULL, NULL);
	pid = (guint) 0;
	{
		DBusSync* _tmp0_;
		const gchar* _tmp1_;
		guint _tmp2_ = 0U;
		guint _tmp3_;
		_tmp0_ = self->priv->busobj;
		_tmp1_ = name;
		_tmp2_ = dbus_sync_get_connection_unix_process_i_d (_tmp0_, _tmp1_, &_inner_error_);
		_tmp3_ = _tmp2_;
		if (_inner_error_ != NULL) {
			goto __catch1_g_error;
		}
		pid = _tmp3_;
	}
	goto __finally1;
	__catch1_g_error:
	{
		GError* e = NULL;
		e = _inner_error_;
		_inner_error_ = NULL;
		_g_error_free0 (e);
	}
	__finally1:
	if (_inner_error_ != NULL) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	_tmp5_ = pid;
	if (_tmp5_ > ((guint) 0)) {
		guint _tmp6_;
		gchar* _tmp7_ = NULL;
		_tmp6_ = pid;
		_tmp7_ = g_strdup_printf ("%u", _tmp6_);
		_g_free0 (_tmp4_);
		_tmp4_ = _tmp7_;
	} else {
		gchar* _tmp8_;
		_tmp8_ = g_strdup ("unknown");
		_g_free0 (_tmp4_);
		_tmp4_ = _tmp8_;
	}
	_tmp9_ = name;
	_tmp10_ = _tmp4_;
	_tmp11_ = g_strdup_printf ("%s (%s)", _tmp9_, _tmp10_);
	result = _tmp11_;
	_g_free0 (_tmp4_);
	return result;
}


static void _g_free0_ (gpointer var) {
	var = (g_free (var), NULL);
}


static void _g_list_free__g_free0_ (GList* self) {
	g_list_foreach (self, (GFunc) _g_free0_, NULL);
	g_list_free (self);
}


GList* _commands_listBusNames (Commands* self, const gchar* prefix) {
	GList* result = NULL;
	GList* sortednames;
	gchar** _tmp0_ = NULL;
	gchar** names;
	gint names_length1;
	gint _names_size_;
	gboolean _tmp11_;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (prefix != NULL, NULL);
	sortednames = NULL;
	_tmp0_ = g_new0 (gchar*, 0 + 1);
	names = _tmp0_;
	names_length1 = 0;
	_names_size_ = names_length1;
	{
		DBusSync* _tmp1_;
		gint _tmp2_ = 0;
		gchar** _tmp3_ = NULL;
		gchar** _tmp4_;
		gint _tmp4__length1;
		gint __tmp4__size_;
		_tmp1_ = self->priv->busobj;
		_tmp3_ = dbus_sync_list_names (_tmp1_, &_tmp2_, &_inner_error_);
		_tmp4_ = _tmp3_;
		_tmp4__length1 = _tmp2_;
		__tmp4__size_ = _tmp4__length1;
		if (_inner_error_ != NULL) {
			goto __catch2_g_error;
		}
		names = (_vala_array_free (names, names_length1, (GDestroyNotify) g_free), NULL);
		names = _tmp4_;
		names_length1 = _tmp4__length1;
		_names_size_ = names_length1;
	}
	goto __finally2;
	__catch2_g_error:
	{
		GError* e = NULL;
		FILE* _tmp5_;
		GError* _tmp6_;
		const gchar* _tmp7_;
		const gchar* _tmp8_ = NULL;
		gchar* _tmp9_ = NULL;
		gchar* _tmp10_;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp5_ = stdout;
		_tmp6_ = e;
		_tmp7_ = _tmp6_->message;
		_tmp8_ = string_to_string (_tmp7_);
		_tmp9_ = g_strconcat ("[ERR]: List busnames: ", _tmp8_, NULL);
		_tmp10_ = _tmp9_;
		fprintf (_tmp5_, "%s", _tmp10_);
		_g_free0 (_tmp10_);
		result = sortednames;
		_g_error_free0 (e);
		names = (_vala_array_free (names, names_length1, (GDestroyNotify) g_free), NULL);
		return result;
	}
	__finally2:
	if (_inner_error_ != NULL) {
		names = (_vala_array_free (names, names_length1, (GDestroyNotify) g_free), NULL);
		__g_list_free__g_free0_0 (sortednames);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	_tmp11_ = showAnonymous;
	if (_tmp11_) {
		gchar** _tmp12_;
		gint _tmp12__length1;
		_tmp12_ = names;
		_tmp12__length1 = names_length1;
		{
			gchar** name_collection = NULL;
			gint name_collection_length1 = 0;
			gint _name_collection_size_ = 0;
			gint name_it = 0;
			name_collection = _tmp12_;
			name_collection_length1 = _tmp12__length1;
			for (name_it = 0; name_it < _tmp12__length1; name_it = name_it + 1) {
				gchar* _tmp13_;
				gchar* name = NULL;
				_tmp13_ = g_strdup (name_collection[name_it]);
				name = _tmp13_;
				{
					const gchar* _tmp14_;
					const gchar* _tmp15_;
					gboolean _tmp16_ = FALSE;
					_tmp14_ = name;
					_tmp15_ = prefix;
					_tmp16_ = g_str_has_prefix (_tmp14_, _tmp15_);
					if (_tmp16_) {
						gchar* _tmp17_ = NULL;
						gboolean _tmp18_ = FALSE;
						gboolean _tmp19_;
						gboolean _tmp21_;
						const gchar* _tmp26_;
						gchar* _tmp27_;
						GCompareFunc _tmp28_;
						_tmp19_ = interactive;
						if (!_tmp19_) {
							gboolean _tmp20_;
							_tmp20_ = showPIDs;
							_tmp18_ = _tmp20_;
						} else {
							_tmp18_ = FALSE;
						}
						_tmp21_ = _tmp18_;
						if (_tmp21_) {
							const gchar* _tmp22_;
							gchar* _tmp23_ = NULL;
							_tmp22_ = name;
							_tmp23_ = commands_appendPidToBusName (self, _tmp22_);
							_g_free0 (_tmp17_);
							_tmp17_ = _tmp23_;
						} else {
							const gchar* _tmp24_;
							gchar* _tmp25_;
							_tmp24_ = name;
							_tmp25_ = g_strdup (_tmp24_);
							_g_free0 (_tmp17_);
							_tmp17_ = _tmp25_;
						}
						_tmp26_ = _tmp17_;
						_tmp27_ = g_strdup (_tmp26_);
						_tmp28_ = g_strcmp0;
						sortednames = g_list_insert_sorted (sortednames, _tmp27_, _tmp28_);
						_g_free0 (_tmp17_);
					}
					_g_free0 (name);
				}
			}
		}
	} else {
		gchar** _tmp29_;
		gint _tmp29__length1;
		_tmp29_ = names;
		_tmp29__length1 = names_length1;
		{
			gchar** name_collection = NULL;
			gint name_collection_length1 = 0;
			gint _name_collection_size_ = 0;
			gint name_it = 0;
			name_collection = _tmp29_;
			name_collection_length1 = _tmp29__length1;
			for (name_it = 0; name_it < _tmp29__length1; name_it = name_it + 1) {
				gchar* _tmp30_;
				gchar* name = NULL;
				_tmp30_ = g_strdup (name_collection[name_it]);
				name = _tmp30_;
				{
					gboolean _tmp31_ = FALSE;
					const gchar* _tmp32_;
					gboolean _tmp33_ = FALSE;
					gboolean _tmp37_;
					_tmp32_ = name;
					_tmp33_ = g_str_has_prefix (_tmp32_, ":");
					if (!_tmp33_) {
						const gchar* _tmp34_;
						const gchar* _tmp35_;
						gboolean _tmp36_ = FALSE;
						_tmp34_ = name;
						_tmp35_ = prefix;
						_tmp36_ = g_str_has_prefix (_tmp34_, _tmp35_);
						_tmp31_ = _tmp36_;
					} else {
						_tmp31_ = FALSE;
					}
					_tmp37_ = _tmp31_;
					if (_tmp37_) {
						gchar* _tmp38_ = NULL;
						gboolean _tmp39_ = FALSE;
						gboolean _tmp40_;
						gboolean _tmp42_;
						const gchar* _tmp47_;
						gchar* _tmp48_;
						GCompareFunc _tmp49_;
						_tmp40_ = interactive;
						if (!_tmp40_) {
							gboolean _tmp41_;
							_tmp41_ = showPIDs;
							_tmp39_ = _tmp41_;
						} else {
							_tmp39_ = FALSE;
						}
						_tmp42_ = _tmp39_;
						if (_tmp42_) {
							const gchar* _tmp43_;
							gchar* _tmp44_ = NULL;
							_tmp43_ = name;
							_tmp44_ = commands_appendPidToBusName (self, _tmp43_);
							_g_free0 (_tmp38_);
							_tmp38_ = _tmp44_;
						} else {
							const gchar* _tmp45_;
							gchar* _tmp46_;
							_tmp45_ = name;
							_tmp46_ = g_strdup (_tmp45_);
							_g_free0 (_tmp38_);
							_tmp38_ = _tmp46_;
						}
						_tmp47_ = _tmp38_;
						_tmp48_ = g_strdup (_tmp47_);
						_tmp49_ = g_strcmp0;
						sortednames = g_list_insert_sorted (sortednames, _tmp48_, _tmp49_);
						_g_free0 (_tmp38_);
					}
					_g_free0 (name);
				}
			}
		}
	}
	result = sortednames;
	names = (_vala_array_free (names, names_length1, (GDestroyNotify) g_free), NULL);
	return result;
}


void commands_listBusNames (Commands* self) {
	GList* _tmp0_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = _commands_listBusNames (self, "");
	{
		GList* name_collection = NULL;
		GList* name_it = NULL;
		name_collection = _tmp0_;
		for (name_it = name_collection; name_it != NULL; name_it = name_it->next) {
			gchar* _tmp1_;
			gchar* name = NULL;
			_tmp1_ = g_strdup ((const gchar*) name_it->data);
			name = _tmp1_;
			{
				FILE* _tmp2_;
				const gchar* _tmp3_;
				const gchar* _tmp4_ = NULL;
				gchar* _tmp5_ = NULL;
				gchar* _tmp6_;
				const gchar* _tmp7_;
				_tmp2_ = stdout;
				_tmp3_ = name;
				_tmp4_ = string_to_string (_tmp3_);
				_tmp5_ = g_strconcat (_tmp4_, "\n", NULL);
				_tmp6_ = _tmp5_;
				_tmp7_ = name;
				fprintf (_tmp2_, _tmp6_, _tmp7_);
				_g_free0 (_tmp6_);
				_g_free0 (name);
			}
		}
		__g_list_free__g_free0_0 (name_collection);
	}
}


static gpointer _g_dbus_node_info_ref0 (gpointer self) {
	return self ? g_dbus_node_info_ref (self) : NULL;
}


void _commands_listObjects (Commands* self, const gchar* busname, const gchar* path, GList** _result_, const gchar* prefix, gboolean with_interfaces) {
	GError * _inner_error_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (busname != NULL);
	g_return_if_fail (path != NULL);
	g_return_if_fail (prefix != NULL);
	{
		const gchar* _tmp0_;
		const gchar* _tmp1_;
		GDBusNodeInfo* _tmp2_ = NULL;
		GDBusNodeInfo* nodeinfo;
		gboolean _tmp3_ = FALSE;
		const gchar* _tmp4_;
		const gchar* _tmp5_;
		gboolean _tmp6_ = FALSE;
		gboolean _tmp15_;
		GDBusNodeInfo* _tmp18_;
		GDBusNodeInfo* _tmp19_;
		GDBusNodeInfo** _tmp20_;
		gint _tmp20__length1;
		_tmp0_ = busname;
		_tmp1_ = path;
		_tmp2_ = commands_getNodeInfo (self, _tmp0_, _tmp1_);
		nodeinfo = _tmp2_;
		_tmp4_ = path;
		_tmp5_ = prefix;
		_tmp6_ = g_str_has_prefix (_tmp4_, _tmp5_);
		if (_tmp6_) {
			gboolean _tmp7_ = FALSE;
			gboolean _tmp8_;
			gboolean _tmp14_;
			_tmp8_ = with_interfaces;
			if (!_tmp8_) {
				_tmp7_ = TRUE;
			} else {
				gboolean _tmp9_ = FALSE;
				GDBusNodeInfo* _tmp10_;
				gboolean _tmp13_;
				_tmp10_ = nodeinfo;
				if (_tmp10_ != NULL) {
					GDBusNodeInfo* _tmp11_;
					GDBusInterfaceInfo** _tmp12_;
					gint _tmp12__length1;
					_tmp11_ = nodeinfo;
					_tmp12_ = _tmp11_->interfaces;
					_tmp12__length1 = _vala_array_length (_tmp11_->interfaces);
					_tmp9_ = _tmp12__length1 > 1;
				} else {
					_tmp9_ = FALSE;
				}
				_tmp13_ = _tmp9_;
				_tmp7_ = _tmp13_;
			}
			_tmp14_ = _tmp7_;
			_tmp3_ = _tmp14_;
		} else {
			_tmp3_ = FALSE;
		}
		_tmp15_ = _tmp3_;
		if (_tmp15_) {
			const gchar* _tmp16_;
			gchar* _tmp17_;
			_tmp16_ = path;
			_tmp17_ = g_strdup (_tmp16_);
			*_result_ = g_list_append (*_result_, _tmp17_);
		}
		_tmp18_ = nodeinfo;
		if (_tmp18_ == NULL) {
			_g_dbus_node_info_unref0 (nodeinfo);
			return;
		}
		_tmp19_ = nodeinfo;
		_tmp20_ = _tmp19_->nodes;
		_tmp20__length1 = _vala_array_length (_tmp19_->nodes);
		{
			GDBusNodeInfo** node_collection = NULL;
			gint node_collection_length1 = 0;
			gint _node_collection_size_ = 0;
			gint node_it = 0;
			node_collection = _tmp20_;
			node_collection_length1 = _tmp20__length1;
			for (node_it = 0; node_it < _tmp20__length1; node_it = node_it + 1) {
				GDBusNodeInfo* _tmp21_;
				GDBusNodeInfo* node = NULL;
				_tmp21_ = _g_dbus_node_info_ref0 (node_collection[node_it]);
				node = _tmp21_;
				{
					const gchar* _tmp22_;
					const gchar* _tmp23_;
					GDBusNodeInfo* _tmp24_;
					const gchar* _tmp25_;
					gchar* _tmp26_ = NULL;
					gchar* _tmp27_;
					const gchar* _tmp28_;
					gboolean _tmp29_;
					_tmp22_ = busname;
					_tmp23_ = path;
					_tmp24_ = node;
					_tmp25_ = _tmp24_->path;
					_tmp26_ = g_build_filename (_tmp23_, _tmp25_, NULL);
					_tmp27_ = _tmp26_;
					_tmp28_ = prefix;
					_tmp29_ = with_interfaces;
					_commands_listObjects (self, _tmp22_, _tmp27_, _result_, _tmp28_, _tmp29_);
					_g_free0 (_tmp27_);
					_g_dbus_node_info_unref0 (node);
				}
			}
		}
		_g_dbus_node_info_unref0 (nodeinfo);
	}
	goto __finally3;
	__catch3_g_error:
	{
		GError* e = NULL;
		FILE* _tmp30_;
		GError* _tmp31_;
		const gchar* _tmp32_;
		const gchar* _tmp33_ = NULL;
		gchar* _tmp34_ = NULL;
		gchar* _tmp35_;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp30_ = stderr;
		_tmp31_ = e;
		_tmp32_ = _tmp31_->message;
		_tmp33_ = string_to_string (_tmp32_);
		_tmp34_ = g_strconcat ("[ERR]: ", _tmp33_, "\n", NULL);
		_tmp35_ = _tmp34_;
		fprintf (_tmp30_, "%s", _tmp35_);
		_g_free0 (_tmp35_);
		_g_error_free0 (e);
		return;
	}
	__finally3:
	if (_inner_error_ != NULL) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return;
	}
}


void commands_listObjects (Commands* self, const gchar* busname, const gchar* path) {
	const gchar* _tmp0_;
	gboolean _tmp1_ = FALSE;
	GError * _inner_error_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (busname != NULL);
	g_return_if_fail (path != NULL);
	_tmp0_ = busname;
	_tmp1_ = commands_isValidBusName (self, _tmp0_);
	if (!_tmp1_) {
		FILE* _tmp2_;
		const gchar* _tmp3_;
		const gchar* _tmp4_ = NULL;
		gchar* _tmp5_ = NULL;
		gchar* _tmp6_;
		_tmp2_ = stdout;
		_tmp3_ = busname;
		_tmp4_ = string_to_string (_tmp3_);
		_tmp5_ = g_strconcat ("[ERR]: Unknown busname ", _tmp4_, "\n", NULL);
		_tmp6_ = _tmp5_;
		fprintf (_tmp2_, "%s", _tmp6_);
		_g_free0 (_tmp6_);
		return;
	}
	{
		GList* names;
		const gchar* _tmp7_;
		const gchar* _tmp8_;
		GList* _tmp9_;
		names = NULL;
		_tmp7_ = busname;
		_tmp8_ = path;
		_commands_listObjects (self, _tmp7_, _tmp8_, &names, "", FALSE);
		_tmp9_ = names;
		{
			GList* name_collection = NULL;
			GList* name_it = NULL;
			name_collection = _tmp9_;
			for (name_it = name_collection; name_it != NULL; name_it = name_it->next) {
				gchar* _tmp10_;
				gchar* name = NULL;
				_tmp10_ = g_strdup ((const gchar*) name_it->data);
				name = _tmp10_;
				{
					FILE* _tmp11_;
					const gchar* _tmp12_;
					_tmp11_ = stdout;
					_tmp12_ = name;
					fprintf (_tmp11_, "%s\n", _tmp12_);
					_g_free0 (name);
				}
			}
		}
		__g_list_free__g_free0_0 (names);
	}
	goto __finally4;
	__catch4_g_error:
	{
		GError* e = NULL;
		FILE* _tmp13_;
		const gchar* _tmp14_;
		const gchar* _tmp15_ = NULL;
		const gchar* _tmp16_;
		const gchar* _tmp17_ = NULL;
		GError* _tmp18_;
		const gchar* _tmp19_;
		const gchar* _tmp20_ = NULL;
		gchar* _tmp21_ = NULL;
		gchar* _tmp22_;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp13_ = stdout;
		_tmp14_ = busname;
		_tmp15_ = string_to_string (_tmp14_);
		_tmp16_ = path;
		_tmp17_ = string_to_string (_tmp16_);
		_tmp18_ = e;
		_tmp19_ = _tmp18_->message;
		_tmp20_ = string_to_string (_tmp19_);
		_tmp21_ = g_strconcat ("[ERR]: Intropecting ", _tmp15_, " ", _tmp17_, ": ", _tmp20_, NULL);
		_tmp22_ = _tmp21_;
		fprintf (_tmp13_, "%s", _tmp22_);
		_g_free0 (_tmp22_);
		_g_error_free0 (e);
	}
	__finally4:
	if (_inner_error_ != NULL) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return;
	}
}


static gpointer _g_dbus_interface_info_ref0 (gpointer self) {
	return self ? g_dbus_interface_info_ref (self) : NULL;
}


static gpointer _g_dbus_method_info_ref0 (gpointer self) {
	return self ? g_dbus_method_info_ref (self) : NULL;
}


GList* _commands_listInterfaces (Commands* self, const gchar* busname, const gchar* path, const gchar* prefix, gboolean stripSignals) {
	GList* result = NULL;
	GList* _result_;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (busname != NULL, NULL);
	g_return_val_if_fail (path != NULL, NULL);
	_result_ = NULL;
	{
		const gchar* _tmp0_;
		const gchar* _tmp1_;
		GDBusNodeInfo* _tmp2_ = NULL;
		GDBusNodeInfo* nodeinfo;
		GDBusNodeInfo* _tmp3_;
		const gchar* _tmp4_;
		GDBusNodeInfo* _tmp26_;
		GDBusInterfaceInfo** _tmp27_;
		gint _tmp27__length1;
		_tmp0_ = busname;
		_tmp1_ = path;
		_tmp2_ = commands_getNodeInfo (self, _tmp0_, _tmp1_);
		nodeinfo = _tmp2_;
		_tmp3_ = nodeinfo;
		if (_tmp3_ == NULL) {
			result = _result_;
			_g_dbus_node_info_unref0 (nodeinfo);
			return result;
		}
		_tmp4_ = prefix;
		if (_tmp4_ != NULL) {
			gchar* method_prefix;
			const gchar* _tmp5_;
			gchar* _tmp6_ = NULL;
			gchar* _tmp7_ = NULL;
			gchar* i;
			GDBusNodeInfo* _tmp8_;
			const gchar* _tmp9_;
			GDBusInterfaceInfo* _tmp10_ = NULL;
			GDBusInterfaceInfo* _tmp11_;
			GDBusInterfaceInfo* ifaceinfo;
			GDBusInterfaceInfo* _tmp12_;
			method_prefix = NULL;
			_tmp5_ = prefix;
			_tmp7_ = commands_splitInterfaceMethod (self, _tmp5_, &_tmp6_);
			_g_free0 (method_prefix);
			method_prefix = _tmp6_;
			i = _tmp7_;
			_tmp8_ = nodeinfo;
			_tmp9_ = i;
			_tmp10_ = g_dbus_node_info_lookup_interface (_tmp8_, _tmp9_);
			_tmp11_ = _g_dbus_interface_info_ref0 (_tmp10_);
			ifaceinfo = _tmp11_;
			_tmp12_ = ifaceinfo;
			if (_tmp12_ != NULL) {
				GDBusInterfaceInfo* _tmp13_;
				GDBusMethodInfo** _tmp14_;
				gint _tmp14__length1;
				_tmp13_ = ifaceinfo;
				_tmp14_ = _tmp13_->methods;
				_tmp14__length1 = _vala_array_length (_tmp13_->methods);
				{
					GDBusMethodInfo** m_collection = NULL;
					gint m_collection_length1 = 0;
					gint _m_collection_size_ = 0;
					gint m_it = 0;
					m_collection = _tmp14_;
					m_collection_length1 = _tmp14__length1;
					for (m_it = 0; m_it < _tmp14__length1; m_it = m_it + 1) {
						GDBusMethodInfo* _tmp15_;
						GDBusMethodInfo* m = NULL;
						_tmp15_ = _g_dbus_method_info_ref0 (m_collection[m_it]);
						m = _tmp15_;
						{
							GDBusMethodInfo* _tmp16_;
							const gchar* _tmp17_;
							const gchar* _tmp18_;
							gboolean _tmp19_ = FALSE;
							_tmp16_ = m;
							_tmp17_ = _tmp16_->name;
							_tmp18_ = method_prefix;
							_tmp19_ = g_str_has_prefix (_tmp17_, _tmp18_);
							if (_tmp19_) {
								const gchar* _tmp20_;
								gchar* _tmp21_;
								gchar* _tmp22_;
								GDBusMethodInfo* _tmp23_;
								const gchar* _tmp24_;
								gchar* _tmp25_;
								_tmp20_ = i;
								_tmp21_ = g_strconcat (_tmp20_, ".", NULL);
								_tmp22_ = _tmp21_;
								_tmp23_ = m;
								_tmp24_ = _tmp23_->name;
								_tmp25_ = g_strconcat (_tmp22_, _tmp24_, NULL);
								_result_ = g_list_append (_result_, _tmp25_);
								_g_free0 (_tmp22_);
							}
							_g_dbus_method_info_unref0 (m);
						}
					}
				}
			}
			_g_dbus_interface_info_unref0 (ifaceinfo);
			_g_free0 (i);
			_g_free0 (method_prefix);
		}
		_tmp26_ = nodeinfo;
		_tmp27_ = _tmp26_->interfaces;
		_tmp27__length1 = _vala_array_length (_tmp26_->interfaces);
		{
			GDBusInterfaceInfo** iface_collection = NULL;
			gint iface_collection_length1 = 0;
			gint _iface_collection_size_ = 0;
			gint iface_it = 0;
			iface_collection = _tmp27_;
			iface_collection_length1 = _tmp27__length1;
			for (iface_it = 0; iface_it < _tmp27__length1; iface_it = iface_it + 1) {
				GDBusInterfaceInfo* _tmp28_;
				GDBusInterfaceInfo* iface = NULL;
				_tmp28_ = _g_dbus_interface_info_ref0 (iface_collection[iface_it]);
				iface = _tmp28_;
				{
					const gchar* _tmp29_;
					_tmp29_ = prefix;
					if (_tmp29_ == NULL) {
						GDBusInterfaceInfo* _tmp30_;
						gboolean _tmp31_;
						gint _tmp32_ = 0;
						gchar** _tmp33_ = NULL;
						_tmp30_ = iface;
						_tmp31_ = stripSignals;
						_tmp33_ = commands_interfaceDescription (self, _tmp30_, _tmp31_, &_tmp32_);
						{
							gchar** s_collection = NULL;
							gint s_collection_length1 = 0;
							gint _s_collection_size_ = 0;
							gint s_it = 0;
							s_collection = _tmp33_;
							s_collection_length1 = _tmp32_;
							for (s_it = 0; s_it < _tmp32_; s_it = s_it + 1) {
								gchar* _tmp34_;
								gchar* s = NULL;
								_tmp34_ = g_strdup (s_collection[s_it]);
								s = _tmp34_;
								{
									const gchar* _tmp35_;
									gchar* _tmp36_;
									_tmp35_ = s;
									_tmp36_ = g_strdup (_tmp35_);
									_result_ = g_list_append (_result_, _tmp36_);
									_g_free0 (s);
								}
							}
							s_collection = (_vala_array_free (s_collection, s_collection_length1, (GDestroyNotify) g_free), NULL);
						}
					} else {
						GDBusInterfaceInfo* _tmp37_;
						const gchar* _tmp38_;
						const gchar* _tmp39_;
						gboolean _tmp40_ = FALSE;
						_tmp37_ = iface;
						_tmp38_ = _tmp37_->name;
						_tmp39_ = prefix;
						_tmp40_ = g_str_has_prefix (_tmp38_, _tmp39_);
						if (_tmp40_) {
							GDBusInterfaceInfo* _tmp41_;
							gboolean _tmp42_;
							gint _tmp43_ = 0;
							gchar** _tmp44_ = NULL;
							_tmp41_ = iface;
							_tmp42_ = stripSignals;
							_tmp44_ = commands_interfaceDescription (self, _tmp41_, _tmp42_, &_tmp43_);
							{
								gchar** s_collection = NULL;
								gint s_collection_length1 = 0;
								gint _s_collection_size_ = 0;
								gint s_it = 0;
								s_collection = _tmp44_;
								s_collection_length1 = _tmp43_;
								for (s_it = 0; s_it < _tmp43_; s_it = s_it + 1) {
									gchar* _tmp45_;
									gchar* s = NULL;
									_tmp45_ = g_strdup (s_collection[s_it]);
									s = _tmp45_;
									{
										const gchar* _tmp46_;
										gchar* _tmp47_;
										_tmp46_ = s;
										_tmp47_ = g_strdup (_tmp46_);
										_result_ = g_list_append (_result_, _tmp47_);
										_g_free0 (s);
									}
								}
								s_collection = (_vala_array_free (s_collection, s_collection_length1, (GDestroyNotify) g_free), NULL);
							}
						}
					}
					_g_dbus_interface_info_unref0 (iface);
				}
			}
		}
		_g_dbus_node_info_unref0 (nodeinfo);
	}
	goto __finally5;
	__catch5_g_error:
	{
		GError* e = NULL;
		FILE* _tmp48_;
		GError* _tmp49_;
		const gchar* _tmp50_;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp48_ = stderr;
		_tmp49_ = e;
		_tmp50_ = _tmp49_->message;
		fprintf (_tmp48_, "[ERR]: %s\n", _tmp50_);
		_g_error_free0 (e);
	}
	__finally5:
	if (_inner_error_ != NULL) {
		__g_list_free__g_free0_0 (_result_);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	result = _result_;
	return result;
}


void commands_listInterfaces (Commands* self, const gchar* busname, const gchar* path) {
	const gchar* _tmp0_;
	gboolean _tmp1_ = FALSE;
	const gchar* _tmp7_;
	const gchar* _tmp8_;
	gboolean _tmp9_ = FALSE;
	const gchar* _tmp17_;
	const gchar* _tmp18_;
	GDBusNodeInfo* _tmp19_ = NULL;
	GDBusNodeInfo* nodeinfo;
	GDBusNodeInfo* _tmp20_;
	const gchar* _tmp23_;
	const gchar* _tmp24_;
	GList* _tmp25_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (busname != NULL);
	g_return_if_fail (path != NULL);
	_tmp0_ = busname;
	_tmp1_ = commands_isValidBusName (self, _tmp0_);
	if (!_tmp1_) {
		FILE* _tmp2_;
		const gchar* _tmp3_;
		const gchar* _tmp4_ = NULL;
		gchar* _tmp5_ = NULL;
		gchar* _tmp6_;
		_tmp2_ = stdout;
		_tmp3_ = busname;
		_tmp4_ = string_to_string (_tmp3_);
		_tmp5_ = g_strconcat ("[ERR]: Unknown busname ", _tmp4_, "\n", NULL);
		_tmp6_ = _tmp5_;
		fprintf (_tmp2_, "%s", _tmp6_);
		_g_free0 (_tmp6_);
		return;
	}
	_tmp7_ = busname;
	_tmp8_ = path;
	_tmp9_ = commands_isValidObjectPath (self, _tmp7_, _tmp8_);
	if (!_tmp9_) {
		FILE* _tmp10_;
		const gchar* _tmp11_;
		const gchar* _tmp12_ = NULL;
		const gchar* _tmp13_;
		const gchar* _tmp14_ = NULL;
		gchar* _tmp15_ = NULL;
		gchar* _tmp16_;
		_tmp10_ = stderr;
		_tmp11_ = path;
		_tmp12_ = string_to_string (_tmp11_);
		_tmp13_ = busname;
		_tmp14_ = string_to_string (_tmp13_);
		_tmp15_ = g_strconcat ("[ERR]: Unknown object path ", _tmp12_, " for ", _tmp14_, "\n", NULL);
		_tmp16_ = _tmp15_;
		fprintf (_tmp10_, "%s", _tmp16_);
		_g_free0 (_tmp16_);
		return;
	}
	_tmp17_ = busname;
	_tmp18_ = path;
	_tmp19_ = commands_getNodeInfo (self, _tmp17_, _tmp18_);
	nodeinfo = _tmp19_;
	_tmp20_ = nodeinfo;
	if (_tmp20_ == NULL) {
		FILE* _tmp21_;
		const gchar* _tmp22_;
		_tmp21_ = stderr;
		_tmp22_ = path;
		fprintf (_tmp21_, "[ERR]: No introspection data for object '%s'\n", _tmp22_);
		_g_dbus_node_info_unref0 (nodeinfo);
		return;
	}
	_tmp23_ = busname;
	_tmp24_ = path;
	_tmp25_ = _commands_listInterfaces (self, _tmp23_, _tmp24_, NULL, FALSE);
	{
		GList* name_collection = NULL;
		GList* name_it = NULL;
		name_collection = _tmp25_;
		for (name_it = name_collection; name_it != NULL; name_it = name_it->next) {
			gchar* _tmp26_;
			gchar* name = NULL;
			_tmp26_ = g_strdup ((const gchar*) name_it->data);
			name = _tmp26_;
			{
				FILE* _tmp27_;
				const gchar* _tmp28_;
				_tmp27_ = stdout;
				_tmp28_ = name;
				fprintf (_tmp27_, "%s\n", _tmp28_);
				_g_free0 (name);
			}
		}
		__g_list_free__g_free0_0 (name_collection);
	}
	_g_dbus_node_info_unref0 (nodeinfo);
}


static gpointer _g_dbus_property_info_ref0 (gpointer self) {
	return self ? g_dbus_property_info_ref (self) : NULL;
}


static gpointer _g_dbus_arg_info_ref0 (gpointer self) {
	return self ? g_dbus_arg_info_ref (self) : NULL;
}


gboolean commands_callMethod (Commands* self, const gchar* busname, const gchar* path, const gchar* method, gchar** args, int args_length1) {
	gboolean result = FALSE;
	const gchar* _tmp0_;
	gboolean _tmp1_ = FALSE;
	const gchar* _tmp7_;
	const gchar* _tmp8_;
	gboolean _tmp9_ = FALSE;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (busname != NULL, FALSE);
	g_return_val_if_fail (path != NULL, FALSE);
	g_return_val_if_fail (method != NULL, FALSE);
	_tmp0_ = busname;
	_tmp1_ = commands_isValidBusName (self, _tmp0_);
	if (!_tmp1_) {
		FILE* _tmp2_;
		const gchar* _tmp3_;
		const gchar* _tmp4_ = NULL;
		gchar* _tmp5_ = NULL;
		gchar* _tmp6_;
		_tmp2_ = stdout;
		_tmp3_ = busname;
		_tmp4_ = string_to_string (_tmp3_);
		_tmp5_ = g_strconcat ("[ERR]: Unknown busname ", _tmp4_, "\n", NULL);
		_tmp6_ = _tmp5_;
		fprintf (_tmp2_, "%s", _tmp6_);
		_g_free0 (_tmp6_);
		result = FALSE;
		return result;
	}
	_tmp7_ = busname;
	_tmp8_ = path;
	_tmp9_ = commands_isValidObjectPath (self, _tmp7_, _tmp8_);
	if (!_tmp9_) {
		FILE* _tmp10_;
		const gchar* _tmp11_;
		const gchar* _tmp12_ = NULL;
		const gchar* _tmp13_;
		const gchar* _tmp14_ = NULL;
		gchar* _tmp15_ = NULL;
		gchar* _tmp16_;
		_tmp10_ = stderr;
		_tmp11_ = path;
		_tmp12_ = string_to_string (_tmp11_);
		_tmp13_ = busname;
		_tmp14_ = string_to_string (_tmp13_);
		_tmp15_ = g_strconcat ("[ERR]: Unknown object path ", _tmp12_, " for ", _tmp14_, "\n", NULL);
		_tmp16_ = _tmp15_;
		fprintf (_tmp10_, "%s", _tmp16_);
		_g_free0 (_tmp16_);
		result = FALSE;
		return result;
	}
	{
		gchar* baseMethod;
		const gchar* _tmp17_;
		gchar* _tmp18_ = NULL;
		gchar* _tmp19_ = NULL;
		gchar* iface;
		const gchar* _tmp20_;
		const gchar* _tmp21_;
		GDBusNodeInfo* _tmp22_ = NULL;
		GDBusNodeInfo* nodeinfo;
		GDBusMethodInfo* methodinfo;
		GDBusPropertyInfo* propinfo;
		GDBusNodeInfo* _tmp23_;
		GDBusMethodInfo* _tmp37_;
		gboolean _tmp45_ = FALSE;
		GDBusMethodInfo* _tmp46_;
		gboolean _tmp50_;
		gboolean _tmp59_ = FALSE;
		GDBusPropertyInfo* _tmp60_;
		gboolean _tmp62_;
		const GVariantType* _tmp67_;
		GVariantBuilder* _tmp68_;
		GVariantBuilder* vbuilder;
		GVariantType* _tmp90_ = NULL;
		gboolean _tmp91_ = FALSE;
		GDBusMethodInfo* _tmp92_;
		gboolean _tmp95_;
		const GVariantType* _tmp105_;
		const GVariantType* full_vt;
		GVariantBuilder* _tmp106_;
		GVariant* _tmp107_ = NULL;
		GVariant* _tmp108_;
		GVariant* parameters;
		GDBusConnection* _tmp109_;
		const gchar* _tmp110_;
		const gchar* _tmp111_;
		const gchar* _tmp112_;
		const gchar* _tmp113_;
		GVariant* _tmp114_;
		const GVariantType* _tmp115_;
		GVariant* _tmp116_ = NULL;
		GVariant* _result_;
		FILE* _tmp117_;
		GVariant* _tmp118_;
		gchar* _tmp119_ = NULL;
		gchar* _tmp120_;
		const gchar* _tmp121_ = NULL;
		gchar* _tmp122_ = NULL;
		gchar* _tmp123_;
		baseMethod = NULL;
		_tmp17_ = method;
		_tmp19_ = commands_splitInterfaceMethod (self, _tmp17_, &_tmp18_);
		_g_free0 (baseMethod);
		baseMethod = _tmp18_;
		iface = _tmp19_;
		_tmp20_ = busname;
		_tmp21_ = path;
		_tmp22_ = commands_getNodeInfo (self, _tmp20_, _tmp21_);
		nodeinfo = _tmp22_;
		methodinfo = NULL;
		propinfo = NULL;
		_tmp23_ = nodeinfo;
		if (_tmp23_ != NULL) {
			GDBusNodeInfo* _tmp24_;
			const gchar* _tmp25_;
			GDBusInterfaceInfo* _tmp26_ = NULL;
			GDBusInterfaceInfo* _tmp27_;
			GDBusInterfaceInfo* ifaceinfo;
			GDBusInterfaceInfo* _tmp28_;
			_tmp24_ = nodeinfo;
			_tmp25_ = iface;
			_tmp26_ = g_dbus_node_info_lookup_interface (_tmp24_, _tmp25_);
			_tmp27_ = _g_dbus_interface_info_ref0 (_tmp26_);
			ifaceinfo = _tmp27_;
			_tmp28_ = ifaceinfo;
			if (_tmp28_ != NULL) {
				GDBusInterfaceInfo* _tmp29_;
				const gchar* _tmp30_;
				GDBusMethodInfo* _tmp31_ = NULL;
				GDBusMethodInfo* _tmp32_;
				GDBusInterfaceInfo* _tmp33_;
				const gchar* _tmp34_;
				GDBusPropertyInfo* _tmp35_ = NULL;
				GDBusPropertyInfo* _tmp36_;
				_tmp29_ = ifaceinfo;
				_tmp30_ = baseMethod;
				_tmp31_ = g_dbus_interface_info_lookup_method (_tmp29_, _tmp30_);
				_tmp32_ = _g_dbus_method_info_ref0 (_tmp31_);
				_g_dbus_method_info_unref0 (methodinfo);
				methodinfo = _tmp32_;
				_tmp33_ = ifaceinfo;
				_tmp34_ = baseMethod;
				_tmp35_ = g_dbus_interface_info_lookup_property (_tmp33_, _tmp34_);
				_tmp36_ = _g_dbus_property_info_ref0 (_tmp35_);
				_g_dbus_property_info_unref0 (propinfo);
				propinfo = _tmp36_;
			}
			_g_dbus_interface_info_unref0 (ifaceinfo);
		}
		_tmp37_ = methodinfo;
		if (_tmp37_ == NULL) {
			FILE* _tmp38_;
			const gchar* _tmp39_;
			const gchar* _tmp40_ = NULL;
			const gchar* _tmp41_;
			const gchar* _tmp42_ = NULL;
			gchar* _tmp43_ = NULL;
			gchar* _tmp44_;
			_tmp38_ = stderr;
			_tmp39_ = method;
			_tmp40_ = string_to_string (_tmp39_);
			_tmp41_ = path;
			_tmp42_ = string_to_string (_tmp41_);
			_tmp43_ = g_strconcat ("[ERR]: There is no method with name ", _tmp40_, " on path ", _tmp42_, "!\n", NULL);
			_tmp44_ = _tmp43_;
			fprintf (_tmp38_, "%s", _tmp44_);
			_g_free0 (_tmp44_);
			result = FALSE;
			_g_dbus_property_info_unref0 (propinfo);
			_g_dbus_method_info_unref0 (methodinfo);
			_g_dbus_node_info_unref0 (nodeinfo);
			_g_free0 (iface);
			_g_free0 (baseMethod);
			return result;
		}
		_tmp46_ = methodinfo;
		if (_tmp46_ != NULL) {
			gchar** _tmp47_;
			gint _tmp47__length1;
			GDBusMethodInfo* _tmp48_;
			GDBusArgInfo** _tmp49_;
			gint _tmp49__length1;
			_tmp47_ = args;
			_tmp47__length1 = args_length1;
			_tmp48_ = methodinfo;
			_tmp49_ = _tmp48_->in_args;
			_tmp49__length1 = _vala_array_length (_tmp48_->in_args);
			_tmp45_ = _tmp47__length1 != _tmp49__length1;
		} else {
			_tmp45_ = FALSE;
		}
		_tmp50_ = _tmp45_;
		if (_tmp50_) {
			FILE* _tmp51_;
			GDBusMethodInfo* _tmp52_;
			GDBusArgInfo** _tmp53_;
			gint _tmp53__length1;
			GDBusMethodInfo* _tmp54_;
			GDBusArgInfo** _tmp55_;
			gint _tmp55__length1;
			gchar* _tmp56_ = NULL;
			gchar* _tmp57_;
			gchar** _tmp58_;
			gint _tmp58__length1;
			_tmp51_ = stderr;
			_tmp52_ = methodinfo;
			_tmp53_ = _tmp52_->in_args;
			_tmp53__length1 = _vala_array_length (_tmp52_->in_args);
			_tmp54_ = methodinfo;
			_tmp55_ = _tmp54_->in_args;
			_tmp55__length1 = _vala_array_length (_tmp54_->in_args);
			_tmp56_ = commands_buildSignature (self, _tmp55_, _tmp55__length1, FALSE);
			_tmp57_ = _tmp56_;
			_tmp58_ = args;
			_tmp58__length1 = args_length1;
			fprintf (_tmp51_, "[ERR]: Need %u params for signature '%s', supplied %u\n", (guint) _tmp53__length1, _tmp57_, (guint) _tmp58__length1);
			_g_free0 (_tmp57_);
			result = FALSE;
			_g_dbus_property_info_unref0 (propinfo);
			_g_dbus_method_info_unref0 (methodinfo);
			_g_dbus_node_info_unref0 (nodeinfo);
			_g_free0 (iface);
			_g_free0 (baseMethod);
			return result;
		}
		_tmp60_ = propinfo;
		if (_tmp60_ != NULL) {
			gchar** _tmp61_;
			gint _tmp61__length1;
			_tmp61_ = args;
			_tmp61__length1 = args_length1;
			_tmp59_ = _tmp61__length1 > 1;
		} else {
			_tmp59_ = FALSE;
		}
		_tmp62_ = _tmp59_;
		if (_tmp62_) {
			FILE* _tmp63_;
			GDBusPropertyInfo* _tmp64_;
			const gchar* _tmp65_;
			gchar** _tmp66_;
			gint _tmp66__length1;
			_tmp63_ = stderr;
			_tmp64_ = propinfo;
			_tmp65_ = _tmp64_->signature;
			_tmp66_ = args;
			_tmp66__length1 = args_length1;
			fprintf (_tmp63_, "[ERR]: Need 1 paramter to set or 0 parameter to get a property with si" \
"gnature '%s', supplied %u", _tmp65_, (guint) _tmp66__length1);
			result = FALSE;
			_g_dbus_property_info_unref0 (propinfo);
			_g_dbus_method_info_unref0 (methodinfo);
			_g_dbus_node_info_unref0 (nodeinfo);
			_g_free0 (iface);
			_g_free0 (baseMethod);
			return result;
		}
		_tmp67_ = G_VARIANT_TYPE_TUPLE;
		_tmp68_ = g_variant_builder_new (_tmp67_);
		vbuilder = _tmp68_;
		{
			gint n;
			n = 0;
			{
				gboolean _tmp69_;
				_tmp69_ = TRUE;
				while (TRUE) {
					gboolean _tmp70_;
					gint _tmp72_;
					GDBusMethodInfo* _tmp73_;
					GDBusArgInfo** _tmp74_;
					gint _tmp74__length1;
					GDBusMethodInfo* _tmp75_;
					GDBusArgInfo** _tmp76_;
					gint _tmp76__length1;
					gint _tmp77_;
					GDBusArgInfo* _tmp78_;
					GDBusArgInfo* _tmp79_;
					GDBusArgInfo* method_arg;
					GDBusArgInfo* _tmp80_;
					const gchar* _tmp81_;
					GDBusArgInfo* _tmp82_;
					const gchar* _tmp83_;
					GVariantBuilder* _tmp84_;
					Argument* _tmp85_;
					Argument* argument;
					Argument* _tmp86_;
					gchar** _tmp87_;
					gint _tmp87__length1;
					gint _tmp88_;
					const gchar* _tmp89_;
					_tmp70_ = _tmp69_;
					if (!_tmp70_) {
						gint _tmp71_;
						_tmp71_ = n;
						n = _tmp71_ + 1;
					}
					_tmp69_ = FALSE;
					_tmp72_ = n;
					_tmp73_ = methodinfo;
					_tmp74_ = _tmp73_->in_args;
					_tmp74__length1 = _vala_array_length (_tmp73_->in_args);
					if (!(_tmp72_ < _tmp74__length1)) {
						break;
					}
					_tmp75_ = methodinfo;
					_tmp76_ = _tmp75_->in_args;
					_tmp76__length1 = _vala_array_length (_tmp75_->in_args);
					_tmp77_ = n;
					_tmp78_ = _tmp76_[_tmp77_];
					_tmp79_ = _g_dbus_arg_info_ref0 (_tmp78_);
					method_arg = _tmp79_;
					_tmp80_ = method_arg;
					_tmp81_ = _tmp80_->name;
					_tmp82_ = method_arg;
					_tmp83_ = _tmp82_->signature;
					_tmp84_ = vbuilder;
					_tmp85_ = argument_new (_tmp81_, _tmp83_, _tmp84_);
					argument = _tmp85_;
					_tmp86_ = argument;
					_tmp87_ = args;
					_tmp87__length1 = args_length1;
					_tmp88_ = n;
					_tmp89_ = _tmp87_[_tmp88_];
					argument_append (_tmp86_, _tmp89_);
					_g_object_unref0 (argument);
					_g_dbus_arg_info_unref0 (method_arg);
				}
			}
		}
		_tmp92_ = methodinfo;
		if (_tmp92_ == NULL) {
			_tmp91_ = TRUE;
		} else {
			GDBusMethodInfo* _tmp93_;
			GDBusArgInfo** _tmp94_;
			gint _tmp94__length1;
			_tmp93_ = methodinfo;
			_tmp94_ = _tmp93_->out_args;
			_tmp94__length1 = _vala_array_length (_tmp93_->out_args);
			_tmp91_ = _tmp94__length1 <= 0;
		}
		_tmp95_ = _tmp91_;
		if (_tmp95_) {
			_g_variant_type_free0 (_tmp90_);
			_tmp90_ = NULL;
		} else {
			GDBusMethodInfo* _tmp96_;
			GDBusArgInfo** _tmp97_;
			gint _tmp97__length1;
			gchar* _tmp98_ = NULL;
			gchar* _tmp99_;
			gchar* _tmp100_;
			gchar* _tmp101_;
			gchar* _tmp102_;
			gchar* _tmp103_;
			GVariantType* _tmp104_;
			_tmp96_ = methodinfo;
			_tmp97_ = _tmp96_->out_args;
			_tmp97__length1 = _vala_array_length (_tmp96_->out_args);
			_tmp98_ = commands_buildSignature (self, _tmp97_, _tmp97__length1, FALSE);
			_tmp99_ = _tmp98_;
			_tmp100_ = g_strconcat ("(", _tmp99_, NULL);
			_tmp101_ = _tmp100_;
			_tmp102_ = g_strconcat (_tmp101_, ")", NULL);
			_tmp103_ = _tmp102_;
			_tmp104_ = g_variant_type_new (_tmp103_);
			_g_variant_type_free0 (_tmp90_);
			_tmp90_ = _tmp104_;
			_g_free0 (_tmp103_);
			_g_free0 (_tmp101_);
			_g_free0 (_tmp99_);
		}
		_tmp105_ = _tmp90_;
		full_vt = _tmp105_;
		_tmp106_ = vbuilder;
		_tmp107_ = g_variant_builder_end (_tmp106_);
		_tmp108_ = g_variant_ref_sink (_tmp107_);
		parameters = _tmp108_;
		_tmp109_ = self->priv->bus;
		_tmp110_ = busname;
		_tmp111_ = path;
		_tmp112_ = iface;
		_tmp113_ = baseMethod;
		_tmp114_ = parameters;
		_tmp115_ = full_vt;
		_tmp116_ = g_dbus_connection_call_sync (_tmp109_, _tmp110_, _tmp111_, _tmp112_, _tmp113_, _tmp114_, _tmp115_, G_DBUS_CALL_FLAGS_NONE, 100000, NULL, &_inner_error_);
		_result_ = _tmp116_;
		if (_inner_error_ != NULL) {
			_g_variant_unref0 (parameters);
			_g_variant_type_free0 (_tmp90_);
			_g_variant_builder_unref0 (vbuilder);
			_g_dbus_property_info_unref0 (propinfo);
			_g_dbus_method_info_unref0 (methodinfo);
			_g_dbus_node_info_unref0 (nodeinfo);
			_g_free0 (iface);
			_g_free0 (baseMethod);
			goto __catch6_g_error;
		}
		_tmp117_ = stdout;
		_tmp118_ = _result_;
		_tmp119_ = g_variant_print (_tmp118_, FALSE);
		_tmp120_ = _tmp119_;
		_tmp121_ = string_to_string (_tmp120_);
		_tmp122_ = g_strconcat (_tmp121_, "\n", NULL);
		_tmp123_ = _tmp122_;
		fprintf (_tmp117_, "%s", _tmp123_);
		_g_free0 (_tmp123_);
		_g_free0 (_tmp120_);
		_g_variant_unref0 (_result_);
		_g_variant_unref0 (parameters);
		_g_variant_type_free0 (_tmp90_);
		_g_variant_builder_unref0 (vbuilder);
		_g_dbus_property_info_unref0 (propinfo);
		_g_dbus_method_info_unref0 (methodinfo);
		_g_dbus_node_info_unref0 (nodeinfo);
		_g_free0 (iface);
		_g_free0 (baseMethod);
	}
	goto __finally6;
	__catch6_g_error:
	{
		GError* e = NULL;
		FILE* _tmp124_;
		GError* _tmp125_;
		const gchar* _tmp126_;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp124_ = stderr;
		_tmp125_ = e;
		_tmp126_ = _tmp125_->message;
		fprintf (_tmp124_, "[ERR]: %s\n", _tmp126_);
		result = FALSE;
		_g_error_free0 (e);
		return result;
	}
	__finally6:
	if (_inner_error_ != NULL) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return FALSE;
	}
	result = FALSE;
	return result;
}


void commands_signalHandler (Commands* self, GDBusConnection* conn, const gchar* sender, const gchar* path, const gchar* iface, const gchar* name, GVariant* params) {
	const gchar* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	GVariant* _tmp4_;
	gboolean _tmp5_;
	gchar* _tmp6_ = NULL;
	gchar* _tmp7_;
	gchar* _tmp8_ = NULL;
	gchar* _tmp9_;
	gchar* line;
	FILE* _tmp10_;
	const gchar* _tmp11_ = NULL;
	gchar* _tmp12_ = NULL;
	gchar* _tmp13_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (conn != NULL);
	g_return_if_fail (sender != NULL);
	g_return_if_fail (path != NULL);
	g_return_if_fail (iface != NULL);
	g_return_if_fail (name != NULL);
	g_return_if_fail (params != NULL);
	_tmp0_ = iface;
	_tmp1_ = name;
	_tmp2_ = path;
	_tmp3_ = sender;
	_tmp4_ = params;
	_tmp5_ = annotateTypes;
	_tmp6_ = g_variant_print (_tmp4_, _tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = g_strdup_printf ("[SIGNAL] %s.%s  %s  %s\n%s", _tmp0_, _tmp1_, _tmp2_, _tmp3_, _tmp7_);
	_tmp9_ = _tmp8_;
	_g_free0 (_tmp7_);
	line = _tmp9_;
	_tmp10_ = stdout;
	_tmp11_ = string_to_string (line);
	_tmp12_ = g_strconcat (_tmp11_, "\n", NULL);
	_tmp13_ = _tmp12_;
	fprintf (_tmp10_, "%s", _tmp13_);
	_g_free0 (_tmp13_);
	_g_free0 (line);
}


static gint string_last_index_of_char (const gchar* self, gunichar c, gint start_index) {
	gint result = 0;
	gint _tmp0_;
	gunichar _tmp1_;
	gchar* _tmp2_ = NULL;
	gchar* _result_;
	gchar* _tmp3_;
	g_return_val_if_fail (self != NULL, 0);
	_tmp0_ = start_index;
	_tmp1_ = c;
	_tmp2_ = g_utf8_strrchr (((gchar*) self) + _tmp0_, (gssize) (-1), _tmp1_);
	_result_ = _tmp2_;
	_tmp3_ = _result_;
	if (_tmp3_ != NULL) {
		gchar* _tmp4_;
		_tmp4_ = _result_;
		result = (gint) (_tmp4_ - ((gchar*) self));
		return result;
	} else {
		result = -1;
		return result;
	}
}


static glong string_strnlen (gchar* str, glong maxlen) {
	glong result = 0L;
	gchar* _tmp0_;
	glong _tmp1_;
	gchar* _tmp2_ = NULL;
	gchar* end;
	gchar* _tmp3_;
	_tmp0_ = str;
	_tmp1_ = maxlen;
	_tmp2_ = memchr (_tmp0_, 0, (gsize) _tmp1_);
	end = _tmp2_;
	_tmp3_ = end;
	if (_tmp3_ == NULL) {
		glong _tmp4_;
		_tmp4_ = maxlen;
		result = _tmp4_;
		return result;
	} else {
		gchar* _tmp5_;
		gchar* _tmp6_;
		_tmp5_ = end;
		_tmp6_ = str;
		result = (glong) (_tmp5_ - _tmp6_);
		return result;
	}
}


static gchar* string_substring (const gchar* self, glong offset, glong len) {
	gchar* result = NULL;
	glong string_length = 0L;
	gboolean _tmp0_ = FALSE;
	glong _tmp1_;
	gboolean _tmp3_;
	glong _tmp9_;
	glong _tmp15_;
	glong _tmp18_;
	glong _tmp19_;
	glong _tmp20_;
	glong _tmp21_;
	glong _tmp22_;
	gchar* _tmp23_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp1_ = offset;
	if (_tmp1_ >= ((glong) 0)) {
		glong _tmp2_;
		_tmp2_ = len;
		_tmp0_ = _tmp2_ >= ((glong) 0);
	} else {
		_tmp0_ = FALSE;
	}
	_tmp3_ = _tmp0_;
	if (_tmp3_) {
		glong _tmp4_;
		glong _tmp5_;
		glong _tmp6_ = 0L;
		_tmp4_ = offset;
		_tmp5_ = len;
		_tmp6_ = string_strnlen ((gchar*) self, _tmp4_ + _tmp5_);
		string_length = _tmp6_;
	} else {
		gint _tmp7_;
		gint _tmp8_;
		_tmp7_ = strlen (self);
		_tmp8_ = _tmp7_;
		string_length = (glong) _tmp8_;
	}
	_tmp9_ = offset;
	if (_tmp9_ < ((glong) 0)) {
		glong _tmp10_;
		glong _tmp11_;
		glong _tmp12_;
		_tmp10_ = string_length;
		_tmp11_ = offset;
		offset = _tmp10_ + _tmp11_;
		_tmp12_ = offset;
		g_return_val_if_fail (_tmp12_ >= ((glong) 0), NULL);
	} else {
		glong _tmp13_;
		glong _tmp14_;
		_tmp13_ = offset;
		_tmp14_ = string_length;
		g_return_val_if_fail (_tmp13_ <= _tmp14_, NULL);
	}
	_tmp15_ = len;
	if (_tmp15_ < ((glong) 0)) {
		glong _tmp16_;
		glong _tmp17_;
		_tmp16_ = string_length;
		_tmp17_ = offset;
		len = _tmp16_ - _tmp17_;
	}
	_tmp18_ = offset;
	_tmp19_ = len;
	_tmp20_ = string_length;
	g_return_val_if_fail ((_tmp18_ + _tmp19_) <= _tmp20_, NULL);
	_tmp21_ = offset;
	_tmp22_ = len;
	_tmp23_ = g_strndup (((gchar*) self) + _tmp21_, (gsize) _tmp22_);
	result = _tmp23_;
	return result;
}


static void _commands_signalHandler_gd_bus_signal_callback (GDBusConnection* connection, const gchar* sender_name, const gchar* object_path, const gchar* interface_name, const gchar* signal_name, GVariant* parameters, gpointer self) {
	commands_signalHandler (self, connection, sender_name, object_path, interface_name, signal_name, parameters);
}


void commands_listenForSignals (Commands* self, const gchar* busname, const gchar* objectpath, const gchar* iface) {
	gchar* method;
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* realiface;
	const gchar* _tmp2_;
	GDBusConnection* _tmp22_;
	const gchar* _tmp23_;
	const gchar* _tmp24_;
	const gchar* _tmp25_;
	const gchar* _tmp26_;
	GMainLoop* _tmp27_;
	GMainLoop* mainloop;
	g_return_if_fail (self != NULL);
	method = NULL;
	_tmp0_ = iface;
	_tmp1_ = g_strdup (_tmp0_);
	realiface = _tmp1_;
	_tmp2_ = iface;
	if (_tmp2_ != NULL) {
		const gchar* _tmp3_;
		gint _tmp4_ = 0;
		gint point;
		const gchar* _tmp5_;
		gint _tmp6_;
		gchar* _tmp7_ = NULL;
		gchar* tmpiface;
		const gchar* _tmp8_;
		const gchar* _tmp9_;
		GDBusNodeInfo* _tmp10_ = NULL;
		GDBusNodeInfo* nodeinfo;
		gboolean _tmp11_ = FALSE;
		GDBusNodeInfo* _tmp12_;
		gboolean _tmp16_;
		_tmp3_ = iface;
		_tmp4_ = string_last_index_of_char (_tmp3_, (gunichar) '.', 0);
		point = _tmp4_;
		_tmp5_ = iface;
		_tmp6_ = point;
		_tmp7_ = string_substring (_tmp5_, (glong) 0, (glong) _tmp6_);
		tmpiface = _tmp7_;
		_tmp8_ = busname;
		_tmp9_ = objectpath;
		_tmp10_ = commands_getNodeInfo (self, _tmp8_, _tmp9_);
		nodeinfo = _tmp10_;
		_tmp12_ = nodeinfo;
		if (_tmp12_ != NULL) {
			GDBusNodeInfo* _tmp13_;
			const gchar* _tmp14_;
			GDBusInterfaceInfo* _tmp15_ = NULL;
			_tmp13_ = nodeinfo;
			_tmp14_ = tmpiface;
			_tmp15_ = g_dbus_node_info_lookup_interface (_tmp13_, _tmp14_);
			_tmp11_ = _tmp15_ != NULL;
		} else {
			_tmp11_ = FALSE;
		}
		_tmp16_ = _tmp11_;
		if (_tmp16_) {
			const gchar* _tmp17_;
			gchar* _tmp18_;
			const gchar* _tmp19_;
			gint _tmp20_;
			gchar* _tmp21_ = NULL;
			_tmp17_ = tmpiface;
			_tmp18_ = g_strdup (_tmp17_);
			_g_free0 (realiface);
			realiface = _tmp18_;
			_tmp19_ = iface;
			_tmp20_ = point;
			_tmp21_ = string_substring (_tmp19_, (glong) (_tmp20_ + 1), (glong) (-1));
			_g_free0 (method);
			method = _tmp21_;
		}
		_g_dbus_node_info_unref0 (nodeinfo);
		_g_free0 (tmpiface);
	}
	_tmp22_ = self->priv->bus;
	_tmp23_ = busname;
	_tmp24_ = realiface;
	_tmp25_ = method;
	_tmp26_ = objectpath;
	g_dbus_connection_signal_subscribe (_tmp22_, _tmp23_, _tmp24_, _tmp25_, _tmp26_, NULL, G_DBUS_SIGNAL_FLAGS_NONE, _commands_signalHandler_gd_bus_signal_callback, g_object_ref (self), g_object_unref);
	_tmp27_ = g_main_loop_new (NULL, FALSE);
	mainloop = _tmp27_;
	g_main_loop_run (mainloop);
	_g_main_loop_unref0 (mainloop);
	_g_free0 (realiface);
	_g_free0 (method);
}


static gchar string_get (const gchar* self, glong index) {
	gchar result = '\0';
	glong _tmp0_;
	gchar _tmp1_;
	g_return_val_if_fail (self != NULL, '\0');
	_tmp0_ = index;
	_tmp1_ = ((gchar*) self)[_tmp0_];
	result = _tmp1_;
	return result;
}


static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (gchar*, *array, (*size) + 1);
	}
	(*array)[(*length)++] = value;
	(*array)[*length] = NULL;
}


static gchar** _vala_array_dup1 (gchar** self, int length) {
	gchar** result;
	int i;
	result = g_new0 (gchar*, length + 1);
	for (i = 0; i < length; i++) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (self[i]);
		result[i] = _tmp0_;
	}
	return result;
}


static gboolean commands_parseCmdlineForCallMethod (Commands* self, const gchar* commandline, gchar*** args, int* args_length1) {
	gchar** _vala_args = NULL;
	int _vala_args_length1 = 0;
	gboolean result = FALSE;
	gint n;
	gint depth;
	gboolean depth_changed;
	gboolean in_quote;
	gchar* _tmp0_;
	gchar* current_argument;
	GList* arguments;
	gchar** _tmp1_ = NULL;
	gboolean _tmp63_ = FALSE;
	const gchar* _tmp64_;
	gint _tmp65_;
	gint _tmp66_;
	gboolean _tmp68_;
	gboolean _tmp71_ = FALSE;
	GList* _tmp72_;
	guint _tmp73_ = 0U;
	gboolean _tmp75_;
	gchar** _tmp76_ = NULL;
	gchar** tmpargs;
	gint tmpargs_length1;
	gint _tmpargs_size_;
	GList* _tmp77_;
	gchar** _tmp82_;
	gint _tmp82__length1;
	gchar** _tmp83_;
	gint _tmp83__length1;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (commandline != NULL, FALSE);
	n = 0;
	depth = 0;
	depth_changed = FALSE;
	in_quote = FALSE;
	_tmp0_ = g_strdup ("");
	current_argument = _tmp0_;
	arguments = NULL;
	_tmp1_ = g_new0 (gchar*, 0 + 1);
	_vala_args = (_vala_array_free (_vala_args, _vala_args_length1, (GDestroyNotify) g_free), NULL);
	_vala_args = _tmp1_;
	_vala_args_length1 = 0;
	while (TRUE) {
		gint _tmp2_;
		const gchar* _tmp3_;
		gint _tmp4_;
		gint _tmp5_;
		const gchar* _tmp6_;
		gint _tmp7_;
		gchar _tmp8_ = '\0';
		gint _tmp62_;
		_tmp2_ = n;
		_tmp3_ = commandline;
		_tmp4_ = strlen (_tmp3_);
		_tmp5_ = _tmp4_;
		if (!(_tmp2_ < _tmp5_)) {
			break;
		}
		_tmp6_ = commandline;
		_tmp7_ = n;
		_tmp8_ = string_get (_tmp6_, (glong) _tmp7_);
		switch (_tmp8_) {
			case ' ':
			{
				gboolean _tmp9_ = FALSE;
				gboolean _tmp10_ = FALSE;
				gint _tmp11_;
				gboolean _tmp18_;
				gboolean _tmp20_;
				_tmp11_ = depth;
				if (_tmp11_ == 0) {
					gboolean _tmp12_ = FALSE;
					const gchar* _tmp13_;
					gint _tmp14_;
					gint _tmp15_;
					gboolean _tmp17_;
					_tmp13_ = current_argument;
					_tmp14_ = strlen (_tmp13_);
					_tmp15_ = _tmp14_;
					if (_tmp15_ > 0) {
						_tmp12_ = TRUE;
					} else {
						gboolean _tmp16_;
						_tmp16_ = depth_changed;
						_tmp12_ = _tmp16_;
					}
					_tmp17_ = _tmp12_;
					_tmp10_ = _tmp17_;
				} else {
					_tmp10_ = FALSE;
				}
				_tmp18_ = _tmp10_;
				if (_tmp18_) {
					gboolean _tmp19_;
					_tmp19_ = in_quote;
					_tmp9_ = !_tmp19_;
				} else {
					_tmp9_ = FALSE;
				}
				_tmp20_ = _tmp9_;
				if (_tmp20_) {
					const gchar* _tmp21_;
					gchar* _tmp22_;
					gchar* _tmp23_;
					_tmp21_ = current_argument;
					_tmp22_ = g_strdup (_tmp21_);
					arguments = g_list_append (arguments, _tmp22_);
					_tmp23_ = g_strdup ("");
					_g_free0 (current_argument);
					current_argument = _tmp23_;
					depth_changed = FALSE;
				} else {
					const gchar* _tmp24_;
					gint _tmp25_;
					gint _tmp26_;
					_tmp24_ = current_argument;
					_tmp25_ = strlen (_tmp24_);
					_tmp26_ = _tmp25_;
					if (_tmp26_ > 0) {
						const gchar* _tmp27_;
						const gchar* _tmp28_;
						gint _tmp29_;
						gchar _tmp30_ = '\0';
						gchar* _tmp31_ = NULL;
						gchar* _tmp32_;
						gchar* _tmp33_;
						_tmp27_ = current_argument;
						_tmp28_ = commandline;
						_tmp29_ = n;
						_tmp30_ = string_get (_tmp28_, (glong) _tmp29_);
						_tmp31_ = g_strdup_printf ("%c", _tmp30_);
						_tmp32_ = _tmp31_;
						_tmp33_ = g_strconcat (_tmp27_, _tmp32_, NULL);
						_g_free0 (current_argument);
						current_argument = _tmp33_;
						_g_free0 (_tmp32_);
					}
				}
				break;
			}
			case '\"':
			{
				gboolean _tmp34_;
				const gchar* _tmp35_;
				gchar* _tmp36_;
				_tmp34_ = in_quote;
				in_quote = !_tmp34_;
				_tmp35_ = current_argument;
				_tmp36_ = g_strconcat (_tmp35_, "\"", NULL);
				_g_free0 (current_argument);
				current_argument = _tmp36_;
				break;
			}
			case '{':
			case '[':
			case '(':
			{
				gboolean _tmp37_;
				_tmp37_ = in_quote;
				if (!_tmp37_) {
					const gchar* _tmp38_;
					const gchar* _tmp39_;
					gint _tmp40_;
					gchar _tmp41_ = '\0';
					gchar* _tmp42_ = NULL;
					gchar* _tmp43_;
					gchar* _tmp44_;
					gint _tmp45_;
					_tmp38_ = current_argument;
					_tmp39_ = commandline;
					_tmp40_ = n;
					_tmp41_ = string_get (_tmp39_, (glong) _tmp40_);
					_tmp42_ = g_strdup_printf ("%c", _tmp41_);
					_tmp43_ = _tmp42_;
					_tmp44_ = g_strconcat (_tmp38_, _tmp43_, NULL);
					_g_free0 (current_argument);
					current_argument = _tmp44_;
					_g_free0 (_tmp43_);
					_tmp45_ = depth;
					depth = _tmp45_ + 1;
					depth_changed = TRUE;
				}
				break;
			}
			case '}':
			case ')':
			case ']':
			{
				gboolean _tmp46_;
				_tmp46_ = in_quote;
				if (!_tmp46_) {
					const gchar* _tmp47_;
					const gchar* _tmp48_;
					gint _tmp49_;
					gchar _tmp50_ = '\0';
					gchar* _tmp51_ = NULL;
					gchar* _tmp52_;
					gchar* _tmp53_;
					gint _tmp54_;
					_tmp47_ = current_argument;
					_tmp48_ = commandline;
					_tmp49_ = n;
					_tmp50_ = string_get (_tmp48_, (glong) _tmp49_);
					_tmp51_ = g_strdup_printf ("%c", _tmp50_);
					_tmp52_ = _tmp51_;
					_tmp53_ = g_strconcat (_tmp47_, _tmp52_, NULL);
					_g_free0 (current_argument);
					current_argument = _tmp53_;
					_g_free0 (_tmp52_);
					_tmp54_ = depth;
					depth = _tmp54_ - 1;
				}
				break;
			}
			default:
			{
				const gchar* _tmp55_;
				const gchar* _tmp56_;
				gint _tmp57_;
				gchar _tmp58_ = '\0';
				gchar* _tmp59_ = NULL;
				gchar* _tmp60_;
				gchar* _tmp61_;
				_tmp55_ = current_argument;
				_tmp56_ = commandline;
				_tmp57_ = n;
				_tmp58_ = string_get (_tmp56_, (glong) _tmp57_);
				_tmp59_ = g_strdup_printf ("%c", _tmp58_);
				_tmp60_ = _tmp59_;
				_tmp61_ = g_strconcat (_tmp55_, _tmp60_, NULL);
				_g_free0 (current_argument);
				current_argument = _tmp61_;
				_g_free0 (_tmp60_);
				break;
			}
		}
		_tmp62_ = n;
		n = _tmp62_ + 1;
	}
	_tmp64_ = current_argument;
	_tmp65_ = strlen (_tmp64_);
	_tmp66_ = _tmp65_;
	if (_tmp66_ > 0) {
		_tmp63_ = TRUE;
	} else {
		gboolean _tmp67_;
		_tmp67_ = depth_changed;
		_tmp63_ = _tmp67_;
	}
	_tmp68_ = _tmp63_;
	if (_tmp68_) {
		const gchar* _tmp69_;
		gchar* _tmp70_;
		_tmp69_ = current_argument;
		_tmp70_ = g_strdup (_tmp69_);
		arguments = g_list_append (arguments, _tmp70_);
	}
	_tmp72_ = arguments;
	_tmp73_ = g_list_length (_tmp72_);
	if (_tmp73_ == ((guint) 0)) {
		_tmp71_ = TRUE;
	} else {
		gint _tmp74_;
		_tmp74_ = depth;
		_tmp71_ = _tmp74_ > 0;
	}
	_tmp75_ = _tmp71_;
	if (_tmp75_) {
		result = FALSE;
		__g_list_free__g_free0_0 (arguments);
		_g_free0 (current_argument);
		if (args) {
			*args = _vala_args;
		} else {
			_vala_args = (_vala_array_free (_vala_args, _vala_args_length1, (GDestroyNotify) g_free), NULL);
		}
		if (args_length1) {
			*args_length1 = _vala_args_length1;
		}
		return result;
	}
	_tmp76_ = g_new0 (gchar*, 0 + 1);
	tmpargs = _tmp76_;
	tmpargs_length1 = 0;
	_tmpargs_size_ = tmpargs_length1;
	_tmp77_ = arguments;
	{
		GList* argument_collection = NULL;
		GList* argument_it = NULL;
		argument_collection = _tmp77_;
		for (argument_it = argument_collection; argument_it != NULL; argument_it = argument_it->next) {
			gchar* _tmp78_;
			gchar* argument = NULL;
			_tmp78_ = g_strdup ((const gchar*) argument_it->data);
			argument = _tmp78_;
			{
				gchar** _tmp79_;
				gint _tmp79__length1;
				const gchar* _tmp80_;
				gchar* _tmp81_;
				_tmp79_ = tmpargs;
				_tmp79__length1 = tmpargs_length1;
				_tmp80_ = argument;
				_tmp81_ = g_strdup (_tmp80_);
				_vala_array_add1 (&tmpargs, &tmpargs_length1, &_tmpargs_size_, _tmp81_);
				_g_free0 (argument);
			}
		}
	}
	_tmp82_ = tmpargs;
	_tmp82__length1 = tmpargs_length1;
	_tmp83_ = (_tmp82_ != NULL) ? _vala_array_dup1 (_tmp82_, _tmp82__length1) : ((gpointer) _tmp82_);
	_tmp83__length1 = _tmp82__length1;
	_vala_args = (_vala_array_free (_vala_args, _vala_args_length1, (GDestroyNotify) g_free), NULL);
	_vala_args = _tmp83_;
	_vala_args_length1 = _tmp83__length1;
	result = TRUE;
	tmpargs = (_vala_array_free (tmpargs, tmpargs_length1, (GDestroyNotify) g_free), NULL);
	__g_list_free__g_free0_0 (arguments);
	_g_free0 (current_argument);
	if (args) {
		*args = _vala_args;
	} else {
		_vala_args = (_vala_array_free (_vala_args, _vala_args_length1, (GDestroyNotify) g_free), NULL);
	}
	if (args_length1) {
		*args_length1 = _vala_args_length1;
	}
	return result;
}


static gchar* string_strip (const gchar* self) {
	gchar* result = NULL;
	gchar* _tmp0_ = NULL;
	gchar* _result_;
	const gchar* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = g_strdup (self);
	_result_ = _tmp0_;
	_tmp1_ = _result_;
	g_strstrip (_tmp1_);
	result = _result_;
	return result;
}


static void commands_performCommandFromShell (Commands* self, const gchar* commandline) {
	const gchar* _tmp0_;
	gchar* _tmp1_ = NULL;
	gchar* _tmp2_;
	gboolean _tmp3_;
	gchar** args = NULL;
	gint args_length1 = 0;
	gint _args_size_ = 0;
	const gchar* _tmp4_;
	gchar** _tmp5_ = NULL;
	gint _tmp6_ = 0;
	gboolean _tmp7_ = FALSE;
	gchar** _tmp13_;
	gint _tmp13__length1;
	g_return_if_fail (self != NULL);
	g_return_if_fail (commandline != NULL);
	_tmp0_ = commandline;
	_tmp1_ = string_strip (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = g_strcmp0 (_tmp2_, "") == 0;
	_g_free0 (_tmp2_);
	if (_tmp3_) {
		commands_listBusNames (self);
		return;
	}
	_tmp4_ = commandline;
	_tmp7_ = commands_parseCmdlineForCallMethod (self, _tmp4_, &_tmp5_, &_tmp6_);
	args = (_vala_array_free (args, args_length1, (GDestroyNotify) g_free), NULL);
	args = _tmp5_;
	args_length1 = _tmp6_;
	_args_size_ = args_length1;
	if (!_tmp7_) {
		FILE* _tmp8_;
		const gchar* _tmp9_;
		const gchar* _tmp10_ = NULL;
		gchar* _tmp11_ = NULL;
		gchar* _tmp12_;
		_tmp8_ = stdout;
		_tmp9_ = commandline;
		_tmp10_ = string_to_string (_tmp9_);
		_tmp11_ = g_strconcat ("[ERR] Got unbalanced commadline for method execution:\n", _tmp10_, "\n", NULL);
		_tmp12_ = _tmp11_;
		fprintf (_tmp8_, "%s", _tmp12_);
		_g_free0 (_tmp12_);
		args = (_vala_array_free (args, args_length1, (GDestroyNotify) g_free), NULL);
		return;
	}
	_tmp13_ = args;
	_tmp13__length1 = args_length1;
	switch (_tmp13__length1) {
		case 0:
		{
			FILE* _tmp14_;
			_tmp14_ = stderr;
			fprintf (_tmp14_, "%s", "Oops!");
			break;
		}
		case 1:
		{
			gchar** _tmp15_;
			gint _tmp15__length1;
			const gchar* _tmp16_;
			gchar* _tmp17_ = NULL;
			gchar* _tmp18_;
			_tmp15_ = args;
			_tmp15__length1 = args_length1;
			_tmp16_ = _tmp15_[0];
			_tmp17_ = string_strip (_tmp16_);
			_tmp18_ = _tmp17_;
			commands_listObjects (self, _tmp18_, "/");
			_g_free0 (_tmp18_);
			break;
		}
		case 2:
		{
			gchar** _tmp19_;
			gint _tmp19__length1;
			const gchar* _tmp20_;
			gchar* _tmp21_ = NULL;
			gchar* _tmp22_;
			gchar** _tmp23_;
			gint _tmp23__length1;
			const gchar* _tmp24_;
			gchar* _tmp25_ = NULL;
			gchar* _tmp26_;
			_tmp19_ = args;
			_tmp19__length1 = args_length1;
			_tmp20_ = _tmp19_[0];
			_tmp21_ = string_strip (_tmp20_);
			_tmp22_ = _tmp21_;
			_tmp23_ = args;
			_tmp23__length1 = args_length1;
			_tmp24_ = _tmp23_[1];
			_tmp25_ = string_strip (_tmp24_);
			_tmp26_ = _tmp25_;
			commands_listInterfaces (self, _tmp22_, _tmp26_);
			_g_free0 (_tmp26_);
			_g_free0 (_tmp22_);
			break;
		}
		default:
		{
			Commands* _tmp27_;
			gchar** _tmp28_;
			gint _tmp28__length1;
			const gchar* _tmp29_;
			gchar* _tmp30_ = NULL;
			gchar* _tmp31_;
			gchar** _tmp32_;
			gint _tmp32__length1;
			const gchar* _tmp33_;
			gchar* _tmp34_ = NULL;
			gchar* _tmp35_;
			gchar** _tmp36_;
			gint _tmp36__length1;
			const gchar* _tmp37_;
			gchar* _tmp38_ = NULL;
			gchar* _tmp39_;
			gchar** _tmp40_;
			gint _tmp40__length1;
			gchar** _tmp41_;
			gint _tmp41__length1;
			_tmp27_ = commands;
			_tmp28_ = args;
			_tmp28__length1 = args_length1;
			_tmp29_ = _tmp28_[0];
			_tmp30_ = string_strip (_tmp29_);
			_tmp31_ = _tmp30_;
			_tmp32_ = args;
			_tmp32__length1 = args_length1;
			_tmp33_ = _tmp32_[1];
			_tmp34_ = string_strip (_tmp33_);
			_tmp35_ = _tmp34_;
			_tmp36_ = args;
			_tmp36__length1 = args_length1;
			_tmp37_ = _tmp36_[2];
			_tmp38_ = string_strip (_tmp37_);
			_tmp39_ = _tmp38_;
			_tmp40_ = args;
			_tmp40__length1 = args_length1;
			_tmp41_ = args;
			_tmp41__length1 = args_length1;
			commands_callMethod (_tmp27_, _tmp31_, _tmp35_, _tmp39_, _tmp40_ + 3, _tmp41__length1 - 3);
			_g_free0 (_tmp39_);
			_g_free0 (_tmp35_);
			_g_free0 (_tmp31_);
			break;
		}
	}
	args = (_vala_array_free (args, args_length1, (GDestroyNotify) g_free), NULL);
}


static gchar* commands_completion (const gchar* prefix, gint state) {
	gchar* result = NULL;
	gint _tmp0_;
	GList* _tmp37_;
	gint _tmp38_;
	gconstpointer _tmp39_ = NULL;
	gchar* _tmp40_;
	g_return_val_if_fail (prefix != NULL, NULL);
	_tmp0_ = state;
	if (_tmp0_ == 0) {
		const gchar* _tmp1_;
		gchar** _tmp2_;
		gchar** _tmp3_ = NULL;
		gchar** parts;
		gint parts_length1;
		gint _parts_size_;
		gboolean _tmp4_ = FALSE;
		gchar** _tmp5_;
		gint _tmp5__length1;
		gboolean _tmp10_;
		const gchar* _tmp11_;
		gboolean _tmp12_ = FALSE;
		gchar** _tmp14_;
		gint _tmp14__length1;
		_tmp1_ = rl_line_buffer;
		_tmp3_ = _tmp2_ = g_strsplit (_tmp1_, " ", 0);
		parts = _tmp3_;
		parts_length1 = _vala_array_length (_tmp2_);
		_parts_size_ = parts_length1;
		_tmp5_ = parts;
		_tmp5__length1 = parts_length1;
		if (_tmp5__length1 == 0) {
			_tmp4_ = TRUE;
		} else {
			gchar** _tmp6_;
			gint _tmp6__length1;
			const gchar* _tmp7_;
			gchar* _tmp8_ = NULL;
			gchar* _tmp9_;
			_tmp6_ = parts;
			_tmp6__length1 = parts_length1;
			_tmp7_ = _tmp6_[0];
			_tmp8_ = string_strip (_tmp7_);
			_tmp9_ = _tmp8_;
			_tmp4_ = g_strcmp0 (_tmp9_, "") == 0;
			_g_free0 (_tmp9_);
		}
		_tmp10_ = _tmp4_;
		if (_tmp10_) {
			prefix = "";
		}
		_tmp11_ = prefix;
		_tmp12_ = g_str_has_suffix (_tmp11_, " ");
		if (_tmp12_) {
			gint _tmp13_;
			_tmp13_ = parts_length1;
			parts_length1 = _tmp13_ + 1;
		}
		_tmp14_ = parts;
		_tmp14__length1 = parts_length1;
		switch (_tmp14__length1) {
			case 0:
			case 1:
			{
				Commands* _tmp15_;
				const gchar* _tmp16_;
				gchar* _tmp17_ = NULL;
				gchar* _tmp18_;
				GList* _tmp19_ = NULL;
				_tmp15_ = commands;
				_tmp16_ = prefix;
				_tmp17_ = string_strip (_tmp16_);
				_tmp18_ = _tmp17_;
				_tmp19_ = _commands_listBusNames (_tmp15_, _tmp18_);
				__g_list_free__g_free0_0 (completions);
				completions = _tmp19_;
				_g_free0 (_tmp18_);
				break;
			}
			case 2:
			{
				Commands* _tmp20_;
				gchar** _tmp21_;
				gint _tmp21__length1;
				const gchar* _tmp22_;
				gchar* _tmp23_ = NULL;
				gchar* _tmp24_;
				const gchar* _tmp25_;
				__g_list_free__g_free0_0 (completions);
				completions = NULL;
				_tmp20_ = commands;
				_tmp21_ = parts;
				_tmp21__length1 = parts_length1;
				_tmp22_ = _tmp21_[0];
				_tmp23_ = string_strip (_tmp22_);
				_tmp24_ = _tmp23_;
				_tmp25_ = prefix;
				_commands_listObjects (_tmp20_, _tmp24_, "/", &completions, _tmp25_, TRUE);
				_g_free0 (_tmp24_);
				break;
			}
			case 3:
			{
				Commands* _tmp26_;
				gchar** _tmp27_;
				gint _tmp27__length1;
				const gchar* _tmp28_;
				gchar* _tmp29_ = NULL;
				gchar* _tmp30_;
				gchar** _tmp31_;
				gint _tmp31__length1;
				const gchar* _tmp32_;
				gchar* _tmp33_ = NULL;
				gchar* _tmp34_;
				const gchar* _tmp35_;
				GList* _tmp36_ = NULL;
				_tmp26_ = commands;
				_tmp27_ = parts;
				_tmp27__length1 = parts_length1;
				_tmp28_ = _tmp27_[0];
				_tmp29_ = string_strip (_tmp28_);
				_tmp30_ = _tmp29_;
				_tmp31_ = parts;
				_tmp31__length1 = parts_length1;
				_tmp32_ = _tmp31_[1];
				_tmp33_ = string_strip (_tmp32_);
				_tmp34_ = _tmp33_;
				_tmp35_ = prefix;
				_tmp36_ = _commands_listInterfaces (_tmp26_, _tmp30_, _tmp34_, _tmp35_, TRUE);
				__g_list_free__g_free0_0 (completions);
				completions = _tmp36_;
				_g_free0 (_tmp34_);
				_g_free0 (_tmp30_);
				break;
			}
			default:
			{
				result = NULL;
				parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
				return result;
			}
		}
		parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
	}
	_tmp37_ = completions;
	_tmp38_ = state;
	_tmp39_ = g_list_nth_data (_tmp37_, (guint) _tmp38_);
	_tmp40_ = g_strdup ((const gchar*) _tmp39_);
	result = _tmp40_;
	return result;
}


static gchar* commands_buildSignature (Commands* self, GDBusArgInfo** args, int args_length1, gboolean with_names) {
	gchar* result = NULL;
	gchar* _tmp0_;
	gchar* _result_;
	GDBusArgInfo** _tmp1_;
	gint _tmp1__length1;
	gboolean _tmp18_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = g_strdup ("");
	_result_ = _tmp0_;
	_tmp1_ = args;
	_tmp1__length1 = args_length1;
	{
		GDBusArgInfo** arg_collection = NULL;
		gint arg_collection_length1 = 0;
		gint _arg_collection_size_ = 0;
		gint arg_it = 0;
		arg_collection = _tmp1_;
		arg_collection_length1 = _tmp1__length1;
		for (arg_it = 0; arg_it < _tmp1__length1; arg_it = arg_it + 1) {
			GDBusArgInfo* _tmp2_;
			GDBusArgInfo* arg = NULL;
			_tmp2_ = _g_dbus_arg_info_ref0 (arg_collection[arg_it]);
			arg = _tmp2_;
			{
				gboolean _tmp3_;
				_tmp3_ = with_names;
				if (_tmp3_) {
					const gchar* _tmp4_;
					GDBusArgInfo* _tmp5_;
					const gchar* _tmp6_;
					const gchar* _tmp7_ = NULL;
					GDBusArgInfo* _tmp8_;
					const gchar* _tmp9_;
					const gchar* _tmp10_ = NULL;
					gchar* _tmp11_ = NULL;
					gchar* _tmp12_;
					gchar* _tmp13_;
					_tmp4_ = _result_;
					_tmp5_ = arg;
					_tmp6_ = _tmp5_->signature;
					_tmp7_ = string_to_string (_tmp6_);
					_tmp8_ = arg;
					_tmp9_ = _tmp8_->name;
					_tmp10_ = string_to_string (_tmp9_);
					_tmp11_ = g_strconcat (_tmp7_, ":", _tmp10_, ", ", NULL);
					_tmp12_ = _tmp11_;
					_tmp13_ = g_strconcat (_tmp4_, _tmp12_, NULL);
					_g_free0 (_result_);
					_result_ = _tmp13_;
					_g_free0 (_tmp12_);
				} else {
					const gchar* _tmp14_;
					GDBusArgInfo* _tmp15_;
					const gchar* _tmp16_;
					gchar* _tmp17_;
					_tmp14_ = _result_;
					_tmp15_ = arg;
					_tmp16_ = _tmp15_->signature;
					_tmp17_ = g_strconcat (_tmp14_, _tmp16_, NULL);
					_g_free0 (_result_);
					_result_ = _tmp17_;
				}
				_g_dbus_arg_info_unref0 (arg);
			}
		}
	}
	_tmp18_ = with_names;
	if (_tmp18_) {
		const gchar* _tmp19_;
		const gchar* _tmp20_;
		gint _tmp21_;
		gint _tmp22_;
		gchar* _tmp23_ = NULL;
		_tmp19_ = _result_;
		_tmp20_ = _result_;
		_tmp21_ = strlen (_tmp20_);
		_tmp22_ = _tmp21_;
		_tmp23_ = string_substring (_tmp19_, (glong) 0, (glong) (_tmp22_ - 2));
		_g_free0 (_result_);
		_result_ = _tmp23_;
	}
	result = _result_;
	return result;
}


static void _vala_array_add2 (gchar*** array, int* length, int* size, gchar* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (gchar*, *array, (*size) + 1);
	}
	(*array)[(*length)++] = value;
	(*array)[*length] = NULL;
}


static void _vala_array_add3 (gchar*** array, int* length, int* size, gchar* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (gchar*, *array, (*size) + 1);
	}
	(*array)[(*length)++] = value;
	(*array)[*length] = NULL;
}


static void _vala_array_add4 (gchar*** array, int* length, int* size, gchar* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (gchar*, *array, (*size) + 1);
	}
	(*array)[(*length)++] = value;
	(*array)[*length] = NULL;
}


static void _vala_array_add5 (gchar*** array, int* length, int* size, gchar* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (gchar*, *array, (*size) + 1);
	}
	(*array)[(*length)++] = value;
	(*array)[*length] = NULL;
}


static gpointer _g_dbus_signal_info_ref0 (gpointer self) {
	return self ? g_dbus_signal_info_ref (self) : NULL;
}


static void _vala_array_add6 (gchar*** array, int* length, int* size, gchar* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (gchar*, *array, (*size) + 1);
	}
	(*array)[(*length)++] = value;
	(*array)[*length] = NULL;
}


static gchar** commands_interfaceDescription (Commands* self, GDBusInterfaceInfo* iface, gboolean stripSignals, int* result_length1) {
	gchar** result = NULL;
	gchar** _tmp0_ = NULL;
	gchar** _result_;
	gint _result__length1;
	gint __result__size_;
	GDBusInterfaceInfo* _tmp1_;
	GDBusMethodInfo** _tmp2_;
	gint _tmp2__length1;
	GDBusInterfaceInfo* _tmp18_;
	GDBusPropertyInfo** _tmp19_;
	gint _tmp19__length1;
	gboolean _tmp35_;
	gchar** _tmp44_;
	gint _tmp44__length1;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (iface != NULL, NULL);
	_tmp0_ = g_new0 (gchar*, 0 + 1);
	_result_ = _tmp0_;
	_result__length1 = 0;
	__result__size_ = _result__length1;
	_tmp1_ = iface;
	_tmp2_ = _tmp1_->methods;
	_tmp2__length1 = _vala_array_length (_tmp1_->methods);
	{
		GDBusMethodInfo** m_collection = NULL;
		gint m_collection_length1 = 0;
		gint _m_collection_size_ = 0;
		gint m_it = 0;
		m_collection = _tmp2_;
		m_collection_length1 = _tmp2__length1;
		for (m_it = 0; m_it < _tmp2__length1; m_it = m_it + 1) {
			GDBusMethodInfo* _tmp3_;
			GDBusMethodInfo* m = NULL;
			_tmp3_ = _g_dbus_method_info_ref0 (m_collection[m_it]);
			m = _tmp3_;
			{
				gboolean _tmp4_;
				_tmp4_ = stripSignals;
				if (!_tmp4_) {
					gchar** _tmp5_;
					gint _tmp5__length1;
					GDBusMethodInfo* _tmp6_;
					GDBusInterfaceInfo* _tmp7_;
					const gchar* _tmp8_;
					gchar* _tmp9_ = NULL;
					_tmp5_ = _result_;
					_tmp5__length1 = _result__length1;
					_tmp6_ = m;
					_tmp7_ = iface;
					_tmp8_ = _tmp7_->name;
					_tmp9_ = commands_methodToString (self, _tmp6_, _tmp8_);
					_vala_array_add2 (&_result_, &_result__length1, &__result__size_, _tmp9_);
				} else {
					gchar** _tmp10_;
					gint _tmp10__length1;
					GDBusInterfaceInfo* _tmp11_;
					const gchar* _tmp12_;
					gchar* _tmp13_;
					gchar* _tmp14_;
					GDBusMethodInfo* _tmp15_;
					const gchar* _tmp16_;
					gchar* _tmp17_;
					_tmp10_ = _result_;
					_tmp10__length1 = _result__length1;
					_tmp11_ = iface;
					_tmp12_ = _tmp11_->name;
					_tmp13_ = g_strconcat (_tmp12_, ".", NULL);
					_tmp14_ = _tmp13_;
					_tmp15_ = m;
					_tmp16_ = _tmp15_->name;
					_tmp17_ = g_strconcat (_tmp14_, _tmp16_, NULL);
					_vala_array_add3 (&_result_, &_result__length1, &__result__size_, _tmp17_);
					_g_free0 (_tmp14_);
				}
				_g_dbus_method_info_unref0 (m);
			}
		}
	}
	_tmp18_ = iface;
	_tmp19_ = _tmp18_->properties;
	_tmp19__length1 = _vala_array_length (_tmp18_->properties);
	{
		GDBusPropertyInfo** p_collection = NULL;
		gint p_collection_length1 = 0;
		gint _p_collection_size_ = 0;
		gint p_it = 0;
		p_collection = _tmp19_;
		p_collection_length1 = _tmp19__length1;
		for (p_it = 0; p_it < _tmp19__length1; p_it = p_it + 1) {
			GDBusPropertyInfo* _tmp20_;
			GDBusPropertyInfo* p = NULL;
			_tmp20_ = _g_dbus_property_info_ref0 (p_collection[p_it]);
			p = _tmp20_;
			{
				gboolean _tmp21_;
				_tmp21_ = stripSignals;
				if (!_tmp21_) {
					gchar** _tmp22_;
					gint _tmp22__length1;
					GDBusPropertyInfo* _tmp23_;
					GDBusInterfaceInfo* _tmp24_;
					const gchar* _tmp25_;
					gchar* _tmp26_ = NULL;
					_tmp22_ = _result_;
					_tmp22__length1 = _result__length1;
					_tmp23_ = p;
					_tmp24_ = iface;
					_tmp25_ = _tmp24_->name;
					_tmp26_ = commands_propertyToString (self, _tmp23_, _tmp25_);
					_vala_array_add4 (&_result_, &_result__length1, &__result__size_, _tmp26_);
				} else {
					gchar** _tmp27_;
					gint _tmp27__length1;
					GDBusInterfaceInfo* _tmp28_;
					const gchar* _tmp29_;
					gchar* _tmp30_;
					gchar* _tmp31_;
					GDBusPropertyInfo* _tmp32_;
					const gchar* _tmp33_;
					gchar* _tmp34_;
					_tmp27_ = _result_;
					_tmp27__length1 = _result__length1;
					_tmp28_ = iface;
					_tmp29_ = _tmp28_->name;
					_tmp30_ = g_strconcat (_tmp29_, ".", NULL);
					_tmp31_ = _tmp30_;
					_tmp32_ = p;
					_tmp33_ = _tmp32_->name;
					_tmp34_ = g_strconcat (_tmp31_, _tmp33_, NULL);
					_vala_array_add5 (&_result_, &_result__length1, &__result__size_, _tmp34_);
					_g_free0 (_tmp31_);
				}
				_g_dbus_property_info_unref0 (p);
			}
		}
	}
	_tmp35_ = stripSignals;
	if (!_tmp35_) {
		GDBusInterfaceInfo* _tmp36_;
		GDBusSignalInfo** _tmp37_;
		gint _tmp37__length1;
		_tmp36_ = iface;
		_tmp37_ = _tmp36_->signals;
		_tmp37__length1 = _vala_array_length (_tmp36_->signals);
		{
			GDBusSignalInfo** s_collection = NULL;
			gint s_collection_length1 = 0;
			gint _s_collection_size_ = 0;
			gint s_it = 0;
			s_collection = _tmp37_;
			s_collection_length1 = _tmp37__length1;
			for (s_it = 0; s_it < _tmp37__length1; s_it = s_it + 1) {
				GDBusSignalInfo* _tmp38_;
				GDBusSignalInfo* s = NULL;
				_tmp38_ = _g_dbus_signal_info_ref0 (s_collection[s_it]);
				s = _tmp38_;
				{
					gchar** _tmp39_;
					gint _tmp39__length1;
					GDBusSignalInfo* _tmp40_;
					GDBusInterfaceInfo* _tmp41_;
					const gchar* _tmp42_;
					gchar* _tmp43_ = NULL;
					_tmp39_ = _result_;
					_tmp39__length1 = _result__length1;
					_tmp40_ = s;
					_tmp41_ = iface;
					_tmp42_ = _tmp41_->name;
					_tmp43_ = commands_signalToString (self, _tmp40_, _tmp42_);
					_vala_array_add6 (&_result_, &_result__length1, &__result__size_, _tmp43_);
					_g_dbus_signal_info_unref0 (s);
				}
			}
		}
	}
	_tmp44_ = _result_;
	_tmp44__length1 = _result__length1;
	if (result_length1) {
		*result_length1 = _tmp44__length1;
	}
	result = _tmp44_;
	return result;
}


static gchar* commands_propertyToString (Commands* self, GDBusPropertyInfo* prop, const gchar* iface) {
	gchar* result = NULL;
	const gchar* _tmp0_;
	const gchar* _tmp1_ = NULL;
	GDBusPropertyInfo* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_ = NULL;
	GDBusPropertyInfo* _tmp5_;
	const gchar* _tmp6_;
	const gchar* _tmp7_ = NULL;
	GDBusPropertyInfo* _tmp8_;
	const gchar* _tmp9_;
	const gchar* _tmp10_ = NULL;
	gchar* _tmp11_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (prop != NULL, NULL);
	g_return_val_if_fail (iface != NULL, NULL);
	_tmp0_ = iface;
	_tmp1_ = string_to_string (_tmp0_);
	_tmp2_ = prop;
	_tmp3_ = _tmp2_->name;
	_tmp4_ = string_to_string (_tmp3_);
	_tmp5_ = prop;
	_tmp6_ = _tmp5_->name;
	_tmp7_ = string_to_string (_tmp6_);
	_tmp8_ = prop;
	_tmp9_ = _tmp8_->signature;
	_tmp10_ = string_to_string (_tmp9_);
	_tmp11_ = g_strconcat ("[PROPERTY] ", _tmp1_, ".", _tmp4_, "(", _tmp7_, ":", _tmp10_, ")", NULL);
	result = _tmp11_;
	return result;
}


static gchar* commands_signalToString (Commands* self, GDBusSignalInfo* signal, const gchar* iface) {
	gchar* result = NULL;
	const gchar* _tmp0_;
	const gchar* _tmp1_ = NULL;
	GDBusSignalInfo* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_ = NULL;
	GDBusSignalInfo* _tmp5_;
	GDBusArgInfo** _tmp6_;
	gint _tmp6__length1;
	gchar* _tmp7_ = NULL;
	gchar* _tmp8_;
	const gchar* _tmp9_ = NULL;
	gchar* _tmp10_ = NULL;
	gchar* _tmp11_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (signal != NULL, NULL);
	g_return_val_if_fail (iface != NULL, NULL);
	_tmp0_ = iface;
	_tmp1_ = string_to_string (_tmp0_);
	_tmp2_ = signal;
	_tmp3_ = _tmp2_->name;
	_tmp4_ = string_to_string (_tmp3_);
	_tmp5_ = signal;
	_tmp6_ = _tmp5_->args;
	_tmp6__length1 = _vala_array_length (_tmp5_->args);
	_tmp7_ = commands_buildSignature (self, _tmp6_, _tmp6__length1, TRUE);
	_tmp8_ = _tmp7_;
	_tmp9_ = string_to_string (_tmp8_);
	_tmp10_ = g_strconcat ("[SIGNAL]   ", _tmp1_, ".", _tmp4_, "(", _tmp9_, ")", NULL);
	_tmp11_ = _tmp10_;
	_g_free0 (_tmp8_);
	result = _tmp11_;
	return result;
}


static gchar* commands_methodToString (Commands* self, GDBusMethodInfo* method, const gchar* iface) {
	gchar* result = NULL;
	const gchar* _tmp0_;
	const gchar* _tmp1_ = NULL;
	GDBusMethodInfo* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_ = NULL;
	GDBusMethodInfo* _tmp5_;
	GDBusArgInfo** _tmp6_;
	gint _tmp6__length1;
	gchar* _tmp7_ = NULL;
	gchar* _tmp8_;
	const gchar* _tmp9_ = NULL;
	GDBusMethodInfo* _tmp10_;
	GDBusArgInfo** _tmp11_;
	gint _tmp11__length1;
	gchar* _tmp12_ = NULL;
	gchar* _tmp13_;
	const gchar* _tmp14_ = NULL;
	gchar* _tmp15_ = NULL;
	gchar* _tmp16_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (method != NULL, NULL);
	g_return_val_if_fail (iface != NULL, NULL);
	_tmp0_ = iface;
	_tmp1_ = string_to_string (_tmp0_);
	_tmp2_ = method;
	_tmp3_ = _tmp2_->name;
	_tmp4_ = string_to_string (_tmp3_);
	_tmp5_ = method;
	_tmp6_ = _tmp5_->in_args;
	_tmp6__length1 = _vala_array_length (_tmp5_->in_args);
	_tmp7_ = commands_buildSignature (self, _tmp6_, _tmp6__length1, TRUE);
	_tmp8_ = _tmp7_;
	_tmp9_ = string_to_string (_tmp8_);
	_tmp10_ = method;
	_tmp11_ = _tmp10_->out_args;
	_tmp11__length1 = _vala_array_length (_tmp10_->out_args);
	_tmp12_ = commands_buildSignature (self, _tmp11_, _tmp11__length1, TRUE);
	_tmp13_ = _tmp12_;
	_tmp14_ = string_to_string (_tmp13_);
	_tmp15_ = g_strconcat ("[METHOD]   ", _tmp1_, ".", _tmp4_, "(", _tmp9_, ") -> (", _tmp14_, ")", NULL);
	_tmp16_ = _tmp15_;
	_g_free0 (_tmp13_);
	_g_free0 (_tmp8_);
	result = _tmp16_;
	return result;
}


GDBusNodeInfo* commands_getNodeInfo (Commands* self, const gchar* busname, const gchar* path) {
	GDBusNodeInfo* result = NULL;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (busname != NULL, NULL);
	g_return_val_if_fail (path != NULL, NULL);
	{
		GDBusConnection* _tmp0_;
		const gchar* _tmp1_;
		const gchar* _tmp2_;
		Introspectable* _tmp3_ = NULL;
		Introspectable* o;
		Introspectable* _tmp4_;
		gchar* _tmp5_ = NULL;
		gchar* _tmp6_;
		gchar* _tmp7_;
		GDBusNodeInfo* _tmp8_;
		GDBusNodeInfo* _tmp9_;
		GDBusNodeInfo* _tmp10_;
		_tmp0_ = self->priv->bus;
		_tmp1_ = busname;
		_tmp2_ = path;
		_tmp3_ = g_initable_new (TYPE_INTROSPECTABLE_PROXY, NULL, &_inner_error_, "g-flags", 0, "g-name", _tmp1_, "g-connection", _tmp0_, "g-object-path", _tmp2_, "g-interface-name", "org.freedesktop.DBus.Introspectable", NULL);
		o = (Introspectable*) _tmp3_;
		if (_inner_error_ != NULL) {
			goto __catch7_g_error;
		}
		_tmp4_ = o;
		_tmp5_ = introspectable_introspect (_tmp4_, &_inner_error_);
		_tmp6_ = _tmp5_;
		if (_inner_error_ != NULL) {
			_g_object_unref0 (o);
			goto __catch7_g_error;
		}
		_tmp7_ = _tmp6_;
		_tmp8_ = g_dbus_node_info_new_for_xml (_tmp7_, &_inner_error_);
		_tmp9_ = _tmp8_;
		_g_free0 (_tmp7_);
		_tmp10_ = _tmp9_;
		if (_inner_error_ != NULL) {
			_g_object_unref0 (o);
			goto __catch7_g_error;
		}
		result = _tmp10_;
		_g_object_unref0 (o);
		return result;
	}
	goto __finally7;
	__catch7_g_error:
	{
		GError* e = NULL;
		e = _inner_error_;
		_inner_error_ = NULL;
		result = NULL;
		_g_error_free0 (e);
		return result;
	}
	__finally7:
	g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
	g_clear_error (&_inner_error_);
	return NULL;
}


gchar* commands_splitInterfaceMethod (Commands* self, const gchar* interface, gchar** method) {
	gchar* _vala_method = NULL;
	gchar* result = NULL;
	const gchar* _tmp0_;
	gint _tmp1_ = 0;
	gint point;
	const gchar* _tmp2_;
	gchar* _tmp3_ = NULL;
	const gchar* _tmp4_;
	gchar* _tmp5_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (interface != NULL, NULL);
	_tmp0_ = interface;
	_tmp1_ = string_last_index_of_char (_tmp0_, (gunichar) '.', 0);
	point = _tmp1_;
	_tmp2_ = interface;
	_tmp3_ = string_substring (_tmp2_, (glong) (point + 1), (glong) (-1));
	_g_free0 (_vala_method);
	_vala_method = _tmp3_;
	_tmp4_ = interface;
	_tmp5_ = string_substring (_tmp4_, (glong) 0, (glong) point);
	result = _tmp5_;
	if (method) {
		*method = _vala_method;
	} else {
		_g_free0 (_vala_method);
	}
	return result;
}


static gchar* _commands_completion_rl_compentry_func_t (const gchar* str, gint a) {
	gchar* result;
	result = commands_completion (str, a);
	return result;
}


static gchar* __readline (const gchar* prompt) {
	gchar* result = NULL;
	const gchar* _tmp0_;
	void* _tmp1_ = NULL;
	void* cstr;
	void* _tmp2_;
	void* _tmp3_;
	gchar* _tmp4_ = NULL;
	gchar* str;
	void* _tmp5_;
	_tmp0_ = prompt;
	_tmp1_ = readline (_tmp0_);
	cstr = _tmp1_;
	_tmp2_ = cstr;
	if (_tmp2_ == NULL) {
		result = NULL;
		return result;
	}
	_tmp3_ = cstr;
	_tmp4_ = g_strdup ((const gchar*) _tmp3_);
	str = _tmp4_;
	_tmp5_ = cstr;
	free (_tmp5_);
	result = str;
	return result;
}


void commands_launchShell (Commands* self) {
	const gchar* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gboolean done;
	FILE* _tmp11_;
	const gchar* _tmp12_ = NULL;
	gchar* _tmp13_ = NULL;
	gchar* _tmp14_;
	g_return_if_fail (self != NULL);
	rl_initialize ();
	rl_readline_name = "mdbus2";
	_tmp0_ = g_getenv ("TERM");
	rl_terminal_name = _tmp0_;
	_tmp1_ = g_getenv ("HOME");
	_tmp2_ = g_strdup_printf ("%s/.mdbus2.history", _tmp1_);
	_tmp3_ = _tmp2_;
	read_history (_tmp3_);
	_g_free0 (_tmp3_);
	history_max_entries = 512;
	rl_completion_entry_function = _commands_completion_rl_compentry_func_t;
	_tmp4_ = g_strdup ("tab: complete");
	rl_parse_and_bind (_tmp4_);
	rl_completer_word_break_characters = " ";
	rl_basic_quote_characters = " ";
	rl_completer_word_break_characters = " ";
	rl_filename_quote_characters = " ";
	done = FALSE;
	while (TRUE) {
		gboolean _tmp5_;
		gchar* _tmp6_ = NULL;
		gchar* line;
		const gchar* _tmp7_;
		_tmp5_ = done;
		if (!(!_tmp5_)) {
			break;
		}
		_tmp6_ = __readline ("MDBUS2> ");
		line = _tmp6_;
		_tmp7_ = line;
		if (_tmp7_ == NULL) {
			done = TRUE;
		} else {
			const gchar* _tmp8_;
			const gchar* _tmp10_;
			_tmp8_ = line;
			if (g_strcmp0 (_tmp8_, "") != 0) {
				const gchar* _tmp9_;
				_tmp9_ = line;
				add_history (_tmp9_);
			}
			_tmp10_ = line;
			commands_performCommandFromShell (self, _tmp10_);
		}
		_g_free0 (line);
	}
	_tmp11_ = stderr;
	fprintf (_tmp11_, "Good bye!\n");
	_tmp12_ = g_getenv ("HOME");
	_tmp13_ = g_strdup_printf ("%s/.mdbus2.history", _tmp12_);
	_tmp14_ = _tmp13_;
	write_history (_tmp14_);
	_g_free0 (_tmp14_);
}


static void commands_class_init (CommandsClass * klass) {
	commands_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (CommandsPrivate));
	G_OBJECT_CLASS (klass)->finalize = commands_finalize;
}


static void commands_instance_init (Commands * self) {
	self->priv = COMMANDS_GET_PRIVATE (self);
}


static void commands_finalize (GObject* obj) {
	Commands * self;
	self = COMMANDS (obj);
	_g_object_unref0 (self->priv->bus);
	_g_object_unref0 (self->priv->busobj);
	G_OBJECT_CLASS (commands_parent_class)->finalize (obj);
}


GType commands_get_type (void) {
	static volatile gsize commands_type_id__volatile = 0;
	if (g_once_init_enter (&commands_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (CommandsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) commands_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Commands), 0, (GInstanceInitFunc) commands_instance_init, NULL };
		GType commands_type_id;
		commands_type_id = g_type_register_static (G_TYPE_OBJECT, "Commands", &g_define_type_info, 0);
		g_once_init_leave (&commands_type_id__volatile, commands_type_id);
	}
	return commands_type_id__volatile;
}


static void _vala_array_add7 (gchar*** array, int* length, int* size, gchar* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (gchar*, *array, (*size) + 1);
	}
	(*array)[(*length)++] = value;
	(*array)[*length] = NULL;
}


gint _vala_main (gchar** args, int args_length1) {
	gint result = 0;
	GBusType _tmp12_ = 0;
	gboolean _tmp13_;
	GBusType _tmp14_;
	Commands* _tmp15_;
	gchar** _tmp16_;
	gint _tmp16__length1;
	GError * _inner_error_ = NULL;
	{
		GOptionContext* _tmp0_;
		GOptionContext* opt_context;
		GOptionContext* _tmp1_;
		GOptionContext* _tmp2_;
		GOptionContext* _tmp3_;
		GOptionContext* _tmp4_;
		GOptionContext* _tmp5_;
		_tmp0_ = g_option_context_new ("[ busname [ objectpath [ method [ params... ] ] ] ]");
		opt_context = _tmp0_;
		_tmp1_ = opt_context;
		g_option_context_set_summary (_tmp1_, "Mickey's DBus Introspection and Interaction Utility V2");
		_tmp2_ = opt_context;
		g_option_context_set_description (_tmp2_, "This utility helps you to explore and interact with DBus\n" \
"services on your system bus and session bus. Called without\n" \
"any parameters, it will show the available services on the\n" \
"selected bus. Given a service name, it will show the avail-\n" \
"able objects exported by the service. Given a service name\n" \
"and an object path, it will show the exposed methods, sig-\n" \
"nals, and properties of that object.\n" \
"\n" \
"mdbus2 -i drops you into a shell mode, where you can inter-\n" \
"actively explore services and call methods using readline\n" \
"command line completion and history.\n" \
"\n" \
"mdbus2 -l drops you into the listener mode, where everything\n" \
"that happens on the bus is monitored.\n" \
"\n" \
"NOTE: Mickey's DBus Utility requires well-behaved services,\n" \
"i.e. those which implement the DBus introspection protocol.\n" \
"\n" \
"mdbus2: DBus has never been that much fun!");
		_tmp3_ = opt_context;
		g_option_context_set_help_enabled (_tmp3_, TRUE);
		_tmp4_ = opt_context;
		g_option_context_add_main_entries (_tmp4_, options, NULL);
		_tmp5_ = opt_context;
		g_option_context_parse (_tmp5_, &args_length1, &args, &_inner_error_);
		if (_inner_error_ != NULL) {
			_g_option_context_free0 (opt_context);
			if (_inner_error_->domain == G_OPTION_ERROR) {
				goto __catch8_g_option_error;
			}
			_g_option_context_free0 (opt_context);
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return 0;
		}
		_g_option_context_free0 (opt_context);
	}
	goto __finally8;
	__catch8_g_option_error:
	{
		GError* e = NULL;
		FILE* _tmp6_;
		GError* _tmp7_;
		const gchar* _tmp8_;
		FILE* _tmp9_;
		gchar** _tmp10_;
		gint _tmp10__length1;
		const gchar* _tmp11_;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp6_ = stdout;
		_tmp7_ = e;
		_tmp8_ = _tmp7_->message;
		fprintf (_tmp6_, "%s\n", _tmp8_);
		_tmp9_ = stdout;
		_tmp10_ = args;
		_tmp10__length1 = args_length1;
		_tmp11_ = _tmp10_[0];
		fprintf (_tmp9_, "Run '%s --help' to see a full list of available command line options.\n", _tmp11_);
		result = 1;
		_g_error_free0 (e);
		return result;
	}
	__finally8:
	if (_inner_error_ != NULL) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return 0;
	}
	_tmp13_ = useSystemBus;
	if (_tmp13_) {
		_tmp12_ = G_BUS_TYPE_SYSTEM;
	} else {
		_tmp12_ = G_BUS_TYPE_SESSION;
	}
	_tmp14_ = _tmp12_;
	_tmp15_ = commands_new (_tmp14_);
	_g_object_unref0 (commands);
	commands = _tmp15_;
	_tmp16_ = args;
	_tmp16__length1 = args_length1;
	switch (_tmp16__length1) {
		case 1:
		{
			gboolean _tmp17_;
			gboolean _tmp19_;
			_tmp17_ = interactive;
			if (_tmp17_) {
				Commands* _tmp18_;
				_tmp18_ = commands;
				commands_launchShell (_tmp18_);
				result = 0;
				return result;
			}
			_tmp19_ = listenerMode;
			if (!_tmp19_) {
				Commands* _tmp20_;
				_tmp20_ = commands;
				commands_listBusNames (_tmp20_);
			} else {
				Commands* _tmp21_;
				_tmp21_ = commands;
				commands_listenForSignals (_tmp21_, NULL, NULL, NULL);
			}
			break;
		}
		case 2:
		{
			gboolean _tmp22_;
			_tmp22_ = listenerMode;
			if (!_tmp22_) {
				Commands* _tmp23_;
				gchar** _tmp24_;
				gint _tmp24__length1;
				const gchar* _tmp25_;
				gchar* _tmp26_ = NULL;
				gchar* _tmp27_;
				_tmp23_ = commands;
				_tmp24_ = args;
				_tmp24__length1 = args_length1;
				_tmp25_ = _tmp24_[1];
				_tmp26_ = string_strip (_tmp25_);
				_tmp27_ = _tmp26_;
				commands_listObjects (_tmp23_, _tmp27_, "/");
				_g_free0 (_tmp27_);
			} else {
				Commands* _tmp28_;
				gchar** _tmp29_;
				gint _tmp29__length1;
				const gchar* _tmp30_;
				gchar* _tmp31_ = NULL;
				gchar* _tmp32_;
				_tmp28_ = commands;
				_tmp29_ = args;
				_tmp29__length1 = args_length1;
				_tmp30_ = _tmp29_[1];
				_tmp31_ = string_strip (_tmp30_);
				_tmp32_ = _tmp31_;
				commands_listenForSignals (_tmp28_, _tmp32_, NULL, NULL);
				_g_free0 (_tmp32_);
			}
			break;
		}
		case 3:
		{
			gboolean _tmp33_;
			_tmp33_ = listenerMode;
			if (!_tmp33_) {
				Commands* _tmp34_;
				gchar** _tmp35_;
				gint _tmp35__length1;
				const gchar* _tmp36_;
				gchar* _tmp37_ = NULL;
				gchar* _tmp38_;
				gchar** _tmp39_;
				gint _tmp39__length1;
				const gchar* _tmp40_;
				gchar* _tmp41_ = NULL;
				gchar* _tmp42_;
				_tmp34_ = commands;
				_tmp35_ = args;
				_tmp35__length1 = args_length1;
				_tmp36_ = _tmp35_[1];
				_tmp37_ = string_strip (_tmp36_);
				_tmp38_ = _tmp37_;
				_tmp39_ = args;
				_tmp39__length1 = args_length1;
				_tmp40_ = _tmp39_[2];
				_tmp41_ = string_strip (_tmp40_);
				_tmp42_ = _tmp41_;
				commands_listInterfaces (_tmp34_, _tmp38_, _tmp42_);
				_g_free0 (_tmp42_);
				_g_free0 (_tmp38_);
			} else {
				Commands* _tmp43_;
				gchar** _tmp44_;
				gint _tmp44__length1;
				const gchar* _tmp45_;
				gchar* _tmp46_ = NULL;
				gchar* _tmp47_;
				gchar** _tmp48_;
				gint _tmp48__length1;
				const gchar* _tmp49_;
				gchar* _tmp50_ = NULL;
				gchar* _tmp51_;
				_tmp43_ = commands;
				_tmp44_ = args;
				_tmp44__length1 = args_length1;
				_tmp45_ = _tmp44_[1];
				_tmp46_ = string_strip (_tmp45_);
				_tmp47_ = _tmp46_;
				_tmp48_ = args;
				_tmp48__length1 = args_length1;
				_tmp49_ = _tmp48_[2];
				_tmp50_ = string_strip (_tmp49_);
				_tmp51_ = _tmp50_;
				commands_listenForSignals (_tmp43_, _tmp47_, _tmp51_, NULL);
				_g_free0 (_tmp51_);
				_g_free0 (_tmp47_);
			}
			break;
		}
		default:
		{
			gchar** _tmp52_;
			gint _tmp52__length1;
			gboolean _tmp53_;
			gchar** _tmp61_ = NULL;
			gchar** restargs;
			gint restargs_length1;
			gint _restargs_size_;
			Commands* _tmp72_;
			gchar** _tmp73_;
			gint _tmp73__length1;
			const gchar* _tmp74_;
			gchar* _tmp75_ = NULL;
			gchar* _tmp76_;
			gchar** _tmp77_;
			gint _tmp77__length1;
			const gchar* _tmp78_;
			gchar* _tmp79_ = NULL;
			gchar* _tmp80_;
			gchar** _tmp81_;
			gint _tmp81__length1;
			const gchar* _tmp82_;
			gchar* _tmp83_ = NULL;
			gchar* _tmp84_;
			gchar** _tmp85_;
			gint _tmp85__length1;
			gboolean _tmp86_ = FALSE;
			gboolean _tmp87_;
			gboolean ok;
			gint _tmp88_ = 0;
			gboolean _tmp89_;
			gint _tmp90_;
			_tmp52_ = args;
			_tmp52__length1 = args_length1;
			g_assert (_tmp52__length1 > 3);
			_tmp53_ = listenerMode;
			if (_tmp53_) {
				Commands* _tmp54_;
				gchar** _tmp55_;
				gint _tmp55__length1;
				const gchar* _tmp56_;
				gchar** _tmp57_;
				gint _tmp57__length1;
				const gchar* _tmp58_;
				gchar** _tmp59_;
				gint _tmp59__length1;
				const gchar* _tmp60_;
				_tmp54_ = commands;
				_tmp55_ = args;
				_tmp55__length1 = args_length1;
				_tmp56_ = _tmp55_[1];
				_tmp57_ = args;
				_tmp57__length1 = args_length1;
				_tmp58_ = _tmp57_[2];
				_tmp59_ = args;
				_tmp59__length1 = args_length1;
				_tmp60_ = _tmp59_[3];
				commands_listenForSignals (_tmp54_, _tmp56_, _tmp58_, _tmp60_);
				result = 0;
				return result;
			}
			_tmp61_ = g_new0 (gchar*, 0 + 1);
			restargs = _tmp61_;
			restargs_length1 = 0;
			_restargs_size_ = restargs_length1;
			{
				gint i;
				i = 4;
				{
					gboolean _tmp62_;
					_tmp62_ = TRUE;
					while (TRUE) {
						gboolean _tmp63_;
						gint _tmp65_;
						gchar** _tmp66_;
						gint _tmp66__length1;
						gchar** _tmp67_;
						gint _tmp67__length1;
						gchar** _tmp68_;
						gint _tmp68__length1;
						gint _tmp69_;
						const gchar* _tmp70_;
						gchar* _tmp71_;
						_tmp63_ = _tmp62_;
						if (!_tmp63_) {
							gint _tmp64_;
							_tmp64_ = i;
							i = _tmp64_ + 1;
						}
						_tmp62_ = FALSE;
						_tmp65_ = i;
						_tmp66_ = args;
						_tmp66__length1 = args_length1;
						if (!(_tmp65_ < _tmp66__length1)) {
							break;
						}
						_tmp67_ = restargs;
						_tmp67__length1 = restargs_length1;
						_tmp68_ = args;
						_tmp68__length1 = args_length1;
						_tmp69_ = i;
						_tmp70_ = _tmp68_[_tmp69_];
						_tmp71_ = g_strdup (_tmp70_);
						_vala_array_add7 (&restargs, &restargs_length1, &_restargs_size_, _tmp71_);
					}
				}
			}
			_tmp72_ = commands;
			_tmp73_ = args;
			_tmp73__length1 = args_length1;
			_tmp74_ = _tmp73_[1];
			_tmp75_ = string_strip (_tmp74_);
			_tmp76_ = _tmp75_;
			_tmp77_ = args;
			_tmp77__length1 = args_length1;
			_tmp78_ = _tmp77_[2];
			_tmp79_ = string_strip (_tmp78_);
			_tmp80_ = _tmp79_;
			_tmp81_ = args;
			_tmp81__length1 = args_length1;
			_tmp82_ = _tmp81_[3];
			_tmp83_ = string_strip (_tmp82_);
			_tmp84_ = _tmp83_;
			_tmp85_ = restargs;
			_tmp85__length1 = restargs_length1;
			_tmp86_ = commands_callMethod (_tmp72_, _tmp76_, _tmp80_, _tmp84_, _tmp85_, _tmp85__length1);
			_tmp87_ = _tmp86_;
			_g_free0 (_tmp84_);
			_g_free0 (_tmp80_);
			_g_free0 (_tmp76_);
			ok = _tmp87_;
			_tmp89_ = ok;
			if (_tmp89_) {
				_tmp88_ = 0;
			} else {
				_tmp88_ = -1;
			}
			_tmp90_ = _tmp88_;
			result = _tmp90_;
			restargs = (_vala_array_free (restargs, restargs_length1, (GDestroyNotify) g_free), NULL);
			return result;
		}
	}
	result = 0;
	return result;
}


int main (int argc, char ** argv) {
	g_type_init ();
	return _vala_main (argv, argc);
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	if ((array != NULL) && (destroy_func != NULL)) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}


static gint _vala_array_length (gpointer array) {
	int length;
	length = 0;
	if (array) {
		while (((gpointer*) array)[length]) {
			length++;
		}
	}
	return length;
}



