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

/* valagsignalmodule.vala
 *
 * Copyright (C) 2006-2010  Jürg Billeter
 * Copyright (C) 2006-2008  Raffaele Sandrini
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library 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
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * Author:
 * 	Jürg Billeter <j@bitron.ch>
 *	Raffaele Sandrini <raffaele@sandrini.ch>
 */

#include <glib.h>
#include <glib-object.h>
#include <vala.h>
#include <valaccode.h>
#include <valagee.h>
#include <stdlib.h>
#include <string.h>


#define VALA_TYPE_CCODE_BASE_MODULE (vala_ccode_base_module_get_type ())
#define VALA_CCODE_BASE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModule))
#define VALA_CCODE_BASE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModuleClass))
#define VALA_IS_CCODE_BASE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_BASE_MODULE))
#define VALA_IS_CCODE_BASE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_BASE_MODULE))
#define VALA_CCODE_BASE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModuleClass))

typedef struct _ValaCCodeBaseModule ValaCCodeBaseModule;
typedef struct _ValaCCodeBaseModuleClass ValaCCodeBaseModuleClass;
typedef struct _ValaCCodeBaseModulePrivate ValaCCodeBaseModulePrivate;

#define VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT (vala_ccode_base_module_emit_context_get_type ())
#define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContext))
#define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass))
#define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT))
#define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT))
#define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass))

typedef struct _ValaCCodeBaseModuleEmitContext ValaCCodeBaseModuleEmitContext;
typedef struct _ValaCCodeBaseModuleEmitContextClass ValaCCodeBaseModuleEmitContextClass;

#define VALA_TYPE_CCODE_STRUCT_MODULE (vala_ccode_struct_module_get_type ())
#define VALA_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModule))
#define VALA_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass))
#define VALA_IS_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_STRUCT_MODULE))
#define VALA_IS_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_STRUCT_MODULE))
#define VALA_CCODE_STRUCT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass))

typedef struct _ValaCCodeStructModule ValaCCodeStructModule;
typedef struct _ValaCCodeStructModuleClass ValaCCodeStructModuleClass;
typedef struct _ValaCCodeStructModulePrivate ValaCCodeStructModulePrivate;

#define VALA_TYPE_CCODE_METHOD_MODULE (vala_ccode_method_module_get_type ())
#define VALA_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModule))
#define VALA_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass))
#define VALA_IS_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_MODULE))
#define VALA_IS_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_MODULE))
#define VALA_CCODE_METHOD_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass))

typedef struct _ValaCCodeMethodModule ValaCCodeMethodModule;
typedef struct _ValaCCodeMethodModuleClass ValaCCodeMethodModuleClass;
typedef struct _ValaCCodeMethodModulePrivate ValaCCodeMethodModulePrivate;

#define VALA_TYPE_CCODE_CONTROL_FLOW_MODULE (vala_ccode_control_flow_module_get_type ())
#define VALA_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModule))
#define VALA_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass))
#define VALA_IS_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE))
#define VALA_IS_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE))
#define VALA_CCODE_CONTROL_FLOW_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass))

typedef struct _ValaCCodeControlFlowModule ValaCCodeControlFlowModule;
typedef struct _ValaCCodeControlFlowModuleClass ValaCCodeControlFlowModuleClass;
typedef struct _ValaCCodeControlFlowModulePrivate ValaCCodeControlFlowModulePrivate;

#define VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE (vala_ccode_member_access_module_get_type ())
#define VALA_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModule))
#define VALA_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass))
#define VALA_IS_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE))
#define VALA_IS_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE))
#define VALA_CCODE_MEMBER_ACCESS_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass))

typedef struct _ValaCCodeMemberAccessModule ValaCCodeMemberAccessModule;
typedef struct _ValaCCodeMemberAccessModuleClass ValaCCodeMemberAccessModuleClass;
typedef struct _ValaCCodeMemberAccessModulePrivate ValaCCodeMemberAccessModulePrivate;

#define VALA_TYPE_CCODE_ASSIGNMENT_MODULE (vala_ccode_assignment_module_get_type ())
#define VALA_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModule))
#define VALA_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass))
#define VALA_IS_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE))
#define VALA_IS_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE))
#define VALA_CCODE_ASSIGNMENT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass))

typedef struct _ValaCCodeAssignmentModule ValaCCodeAssignmentModule;
typedef struct _ValaCCodeAssignmentModuleClass ValaCCodeAssignmentModuleClass;
typedef struct _ValaCCodeAssignmentModulePrivate ValaCCodeAssignmentModulePrivate;

#define VALA_TYPE_CCODE_METHOD_CALL_MODULE (vala_ccode_method_call_module_get_type ())
#define VALA_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModule))
#define VALA_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass))
#define VALA_IS_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE))
#define VALA_IS_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE))
#define VALA_CCODE_METHOD_CALL_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass))

typedef struct _ValaCCodeMethodCallModule ValaCCodeMethodCallModule;
typedef struct _ValaCCodeMethodCallModuleClass ValaCCodeMethodCallModuleClass;
typedef struct _ValaCCodeMethodCallModulePrivate ValaCCodeMethodCallModulePrivate;

#define VALA_TYPE_CCODE_ARRAY_MODULE (vala_ccode_array_module_get_type ())
#define VALA_CCODE_ARRAY_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModule))
#define VALA_CCODE_ARRAY_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModuleClass))
#define VALA_IS_CCODE_ARRAY_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ARRAY_MODULE))
#define VALA_IS_CCODE_ARRAY_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ARRAY_MODULE))
#define VALA_CCODE_ARRAY_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModuleClass))

typedef struct _ValaCCodeArrayModule ValaCCodeArrayModule;
typedef struct _ValaCCodeArrayModuleClass ValaCCodeArrayModuleClass;
typedef struct _ValaCCodeArrayModulePrivate ValaCCodeArrayModulePrivate;

#define VALA_TYPE_CCODE_DELEGATE_MODULE (vala_ccode_delegate_module_get_type ())
#define VALA_CCODE_DELEGATE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModule))
#define VALA_CCODE_DELEGATE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModuleClass))
#define VALA_IS_CCODE_DELEGATE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE))
#define VALA_IS_CCODE_DELEGATE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_DELEGATE_MODULE))
#define VALA_CCODE_DELEGATE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModuleClass))

typedef struct _ValaCCodeDelegateModule ValaCCodeDelegateModule;
typedef struct _ValaCCodeDelegateModuleClass ValaCCodeDelegateModuleClass;
typedef struct _ValaCCodeDelegateModulePrivate ValaCCodeDelegateModulePrivate;

#define VALA_TYPE_GERROR_MODULE (vala_gerror_module_get_type ())
#define VALA_GERROR_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GERROR_MODULE, ValaGErrorModule))
#define VALA_GERROR_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GERROR_MODULE, ValaGErrorModuleClass))
#define VALA_IS_GERROR_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GERROR_MODULE))
#define VALA_IS_GERROR_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GERROR_MODULE))
#define VALA_GERROR_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GERROR_MODULE, ValaGErrorModuleClass))

typedef struct _ValaGErrorModule ValaGErrorModule;
typedef struct _ValaGErrorModuleClass ValaGErrorModuleClass;
typedef struct _ValaGErrorModulePrivate ValaGErrorModulePrivate;

#define VALA_TYPE_GTYPE_MODULE (vala_gtype_module_get_type ())
#define VALA_GTYPE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GTYPE_MODULE, ValaGTypeModule))
#define VALA_GTYPE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GTYPE_MODULE, ValaGTypeModuleClass))
#define VALA_IS_GTYPE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GTYPE_MODULE))
#define VALA_IS_GTYPE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GTYPE_MODULE))
#define VALA_GTYPE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GTYPE_MODULE, ValaGTypeModuleClass))

typedef struct _ValaGTypeModule ValaGTypeModule;
typedef struct _ValaGTypeModuleClass ValaGTypeModuleClass;
typedef struct _ValaGTypeModulePrivate ValaGTypeModulePrivate;

#define VALA_TYPE_GOBJECT_MODULE (vala_gobject_module_get_type ())
#define VALA_GOBJECT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GOBJECT_MODULE, ValaGObjectModule))
#define VALA_GOBJECT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GOBJECT_MODULE, ValaGObjectModuleClass))
#define VALA_IS_GOBJECT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GOBJECT_MODULE))
#define VALA_IS_GOBJECT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GOBJECT_MODULE))
#define VALA_GOBJECT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GOBJECT_MODULE, ValaGObjectModuleClass))

typedef struct _ValaGObjectModule ValaGObjectModule;
typedef struct _ValaGObjectModuleClass ValaGObjectModuleClass;
typedef struct _ValaGObjectModulePrivate ValaGObjectModulePrivate;

#define VALA_TYPE_GSIGNAL_MODULE (vala_gsignal_module_get_type ())
#define VALA_GSIGNAL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GSIGNAL_MODULE, ValaGSignalModule))
#define VALA_GSIGNAL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GSIGNAL_MODULE, ValaGSignalModuleClass))
#define VALA_IS_GSIGNAL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GSIGNAL_MODULE))
#define VALA_IS_GSIGNAL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GSIGNAL_MODULE))
#define VALA_GSIGNAL_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GSIGNAL_MODULE, ValaGSignalModuleClass))

typedef struct _ValaGSignalModule ValaGSignalModule;
typedef struct _ValaGSignalModuleClass ValaGSignalModuleClass;
typedef struct _ValaGSignalModulePrivate ValaGSignalModulePrivate;
#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
#define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL)))
#define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL)))
#define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_unref (var), NULL)))

struct _ValaCCodeBaseModule {
	ValaCodeGenerator parent_instance;
	ValaCCodeBaseModulePrivate * priv;
	ValaSymbol* root_symbol;
	ValaCCodeBaseModuleEmitContext* emit_context;
	ValaCCodeLineDirective* current_line;
	ValaCCodeFile* header_file;
	ValaCCodeFile* internal_header_file;
	ValaCCodeFile* cfile;
	ValaCCodeBaseModuleEmitContext* class_init_context;
	ValaCCodeBaseModuleEmitContext* base_init_context;
	ValaCCodeBaseModuleEmitContext* class_finalize_context;
	ValaCCodeBaseModuleEmitContext* base_finalize_context;
	ValaCCodeBaseModuleEmitContext* instance_init_context;
	ValaCCodeBaseModuleEmitContext* instance_finalize_context;
	ValaCCodeStruct* param_spec_struct;
	ValaCCodeStruct* closure_struct;
	ValaCCodeEnum* prop_enum;
	ValaSet* user_marshal_set;
	ValaSet* predefined_marshal_set;
	gint next_regex_id;
	gint next_coroutine_state;
	ValaDataType* void_type;
	ValaDataType* bool_type;
	ValaDataType* char_type;
	ValaDataType* uchar_type;
	ValaDataType* unichar_type;
	ValaDataType* short_type;
	ValaDataType* ushort_type;
	ValaDataType* int_type;
	ValaDataType* uint_type;
	ValaDataType* long_type;
	ValaDataType* ulong_type;
	ValaDataType* int8_type;
	ValaDataType* uint8_type;
	ValaDataType* int16_type;
	ValaDataType* uint16_type;
	ValaDataType* int32_type;
	ValaDataType* uint32_type;
	ValaDataType* int64_type;
	ValaDataType* uint64_type;
	ValaDataType* string_type;
	ValaDataType* regex_type;
	ValaDataType* float_type;
	ValaDataType* double_type;
	ValaTypeSymbol* gtype_type;
	ValaTypeSymbol* gobject_type;
	ValaErrorType* gerror_type;
	ValaClass* glist_type;
	ValaClass* gslist_type;
	ValaClass* gnode_type;
	ValaClass* gqueue_type;
	ValaClass* gvaluearray_type;
	ValaTypeSymbol* gstringbuilder_type;
	ValaTypeSymbol* garray_type;
	ValaTypeSymbol* gbytearray_type;
	ValaTypeSymbol* gptrarray_type;
	ValaTypeSymbol* gthreadpool_type;
	ValaDataType* gdestroynotify_type;
	ValaDataType* gquark_type;
	ValaStruct* gvalue_type;
	ValaClass* gvariant_type;
	ValaStruct* mutex_type;
	ValaTypeSymbol* type_module_type;
	ValaTypeSymbol* dbus_proxy_type;
	gboolean in_plugin;
	gchar* module_init_param_name;
	gboolean gvaluecollector_h_needed;
	gboolean requires_array_free;
	gboolean requires_array_move;
	gboolean requires_array_length;
	ValaSet* wrappers;
};

struct _ValaCCodeBaseModuleClass {
	ValaCodeGeneratorClass parent_class;
	void (*append_vala_array_free) (ValaCCodeBaseModule* self);
	void (*append_vala_array_move) (ValaCCodeBaseModule* self);
	void (*append_vala_array_length) (ValaCCodeBaseModule* self);
	gboolean (*generate_enum_declaration) (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space);
	void (*generate_class_struct_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
	void (*generate_struct_declaration) (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space);
	void (*generate_delegate_declaration) (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space);
	void (*generate_cparameters) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);
	ValaCCodeExpression* (*get_dup_func_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);
	gchar* (*append_struct_array_free) (ValaCCodeBaseModule* self, ValaStruct* st);
	ValaCCodeExpression* (*destroy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
	void (*append_scope_free) (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);
	ValaTargetValue* (*get_local_cvalue) (ValaCCodeBaseModule* self, ValaLocalVariable* local);
	ValaTargetValue* (*get_parameter_cvalue) (ValaCCodeBaseModule* self, ValaParameter* param);
	ValaTargetValue* (*get_field_cvalue) (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance);
	ValaTargetValue* (*load_variable) (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value);
	ValaTargetValue* (*load_this_parameter) (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
	void (*store_value) (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
	gchar* (*get_delegate_target_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
	ValaCCodeExpression* (*get_delegate_target_cexpression) (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify);
	ValaCCodeExpression* (*get_delegate_target_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
	ValaCCodeExpression* (*get_delegate_target_destroy_notify_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
	gchar* (*get_delegate_target_destroy_notify_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
	ValaTargetValue* (*copy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
	void (*generate_class_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
	void (*generate_interface_declaration) (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space);
	void (*generate_method_declaration) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
	void (*generate_error_domain_declaration) (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);
	ValaCCodeExpression* (*deserialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail);
	ValaCCodeExpression* (*serialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr);
	ValaCCodeExpression* (*get_implicit_cast_expression) (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node);
	void (*create_type_check_statement) (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);
	gboolean (*is_gobject_property) (ValaCCodeBaseModule* self, ValaProperty* prop);
	void (*generate_dynamic_method_wrapper) (ValaCCodeBaseModule* self, ValaDynamicMethod* method);
	gboolean (*method_has_wrapper) (ValaCCodeBaseModule* self, ValaMethod* method);
	ValaCCodeFunctionCall* (*get_param_spec) (ValaCCodeBaseModule* self, ValaProperty* prop);
	ValaCCodeFunctionCall* (*get_signal_creation) (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type);
	void (*register_dbus_info) (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable);
	gchar* (*get_dynamic_property_getter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
	gchar* (*get_dynamic_property_setter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
	gchar* (*get_dynamic_signal_cname) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_dynamic_signal_connect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_dynamic_signal_connect_after_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_dynamic_signal_disconnect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_array_length_cname) (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim);
	gchar* (*get_parameter_array_length_cname) (ValaCCodeBaseModule* self, ValaParameter* param, gint dim);
	ValaCCodeExpression* (*get_array_length_cexpression) (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim);
	ValaCCodeExpression* (*get_array_length_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim);
	gchar* (*get_array_size_cname) (ValaCCodeBaseModule* self, const gchar* array_cname);
	void (*add_simple_check) (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);
	gchar* (*generate_ready_function) (ValaCCodeBaseModule* self, ValaMethod* m);
};

struct _ValaCCodeStructModule {
	ValaCCodeBaseModule parent_instance;
	ValaCCodeStructModulePrivate * priv;
};

struct _ValaCCodeStructModuleClass {
	ValaCCodeBaseModuleClass parent_class;
};

struct _ValaCCodeMethodModule {
	ValaCCodeStructModule parent_instance;
	ValaCCodeMethodModulePrivate * priv;
};

struct _ValaCCodeMethodModuleClass {
	ValaCCodeStructModuleClass parent_class;
	void (*generate_method_result_declaration) (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map);
	ValaCCodeParameter* (*generate_parameter) (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map);
};

struct _ValaCCodeControlFlowModule {
	ValaCCodeMethodModule parent_instance;
	ValaCCodeControlFlowModulePrivate * priv;
};

struct _ValaCCodeControlFlowModuleClass {
	ValaCCodeMethodModuleClass parent_class;
};

struct _ValaCCodeMemberAccessModule {
	ValaCCodeControlFlowModule parent_instance;
	ValaCCodeMemberAccessModulePrivate * priv;
};

struct _ValaCCodeMemberAccessModuleClass {
	ValaCCodeControlFlowModuleClass parent_class;
};

struct _ValaCCodeAssignmentModule {
	ValaCCodeMemberAccessModule parent_instance;
	ValaCCodeAssignmentModulePrivate * priv;
};

struct _ValaCCodeAssignmentModuleClass {
	ValaCCodeMemberAccessModuleClass parent_class;
};

struct _ValaCCodeMethodCallModule {
	ValaCCodeAssignmentModule parent_instance;
	ValaCCodeMethodCallModulePrivate * priv;
};

struct _ValaCCodeMethodCallModuleClass {
	ValaCCodeAssignmentModuleClass parent_class;
};

struct _ValaCCodeArrayModule {
	ValaCCodeMethodCallModule parent_instance;
	ValaCCodeArrayModulePrivate * priv;
};

struct _ValaCCodeArrayModuleClass {
	ValaCCodeMethodCallModuleClass parent_class;
};

struct _ValaCCodeDelegateModule {
	ValaCCodeArrayModule parent_instance;
	ValaCCodeDelegateModulePrivate * priv;
};

struct _ValaCCodeDelegateModuleClass {
	ValaCCodeArrayModuleClass parent_class;
};

struct _ValaGErrorModule {
	ValaCCodeDelegateModule parent_instance;
	ValaGErrorModulePrivate * priv;
};

struct _ValaGErrorModuleClass {
	ValaCCodeDelegateModuleClass parent_class;
	void (*return_with_exception) (ValaGErrorModule* self, ValaCCodeExpression* error_expr);
};

struct _ValaGTypeModule {
	ValaGErrorModule parent_instance;
	ValaGTypeModulePrivate * priv;
};

struct _ValaGTypeModuleClass {
	ValaGErrorModuleClass parent_class;
	void (*generate_virtual_method_declaration) (ValaGTypeModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeStruct* type_struct);
	void (*generate_class_init) (ValaGTypeModule* self, ValaClass* cl);
};

struct _ValaGObjectModule {
	ValaGTypeModule parent_instance;
	ValaGObjectModulePrivate * priv;
};

struct _ValaGObjectModuleClass {
	ValaGTypeModuleClass parent_class;
};

struct _ValaGSignalModule {
	ValaGObjectModule parent_instance;
	ValaGSignalModulePrivate * priv;
};

struct _ValaGSignalModuleClass {
	ValaGObjectModuleClass parent_class;
};


static gpointer vala_gsignal_module_parent_class = NULL;

GType vala_ccode_base_module_get_type (void) G_GNUC_CONST;
gpointer vala_ccode_base_module_emit_context_ref (gpointer instance);
void vala_ccode_base_module_emit_context_unref (gpointer instance);
GParamSpec* vala_ccode_base_module_param_spec_emit_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_ccode_base_module_value_set_emit_context (GValue* value, gpointer v_object);
void vala_ccode_base_module_value_take_emit_context (GValue* value, gpointer v_object);
gpointer vala_ccode_base_module_value_get_emit_context (const GValue* value);
GType vala_ccode_base_module_emit_context_get_type (void) G_GNUC_CONST;
GType vala_ccode_struct_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_method_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_control_flow_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_member_access_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_assignment_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_method_call_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_array_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_delegate_module_get_type (void) G_GNUC_CONST;
GType vala_gerror_module_get_type (void) G_GNUC_CONST;
GType vala_gtype_module_get_type (void) G_GNUC_CONST;
GType vala_gobject_module_get_type (void) G_GNUC_CONST;
GType vala_gsignal_module_get_type (void) G_GNUC_CONST;
enum  {
	VALA_GSIGNAL_MODULE_DUMMY_PROPERTY
};
static gchar* vala_gsignal_module_get_marshaller_function (ValaGSignalModule* self, ValaList* params, ValaDataType* return_type, const gchar* prefix);
static gchar* vala_gsignal_module_get_marshaller_signature (ValaGSignalModule* self, ValaList* params, ValaDataType* return_type);
gchar* vala_ccode_base_module_get_ccode_marshaller_type_name (ValaCodeNode* node);
static gchar* vala_gsignal_module_get_value_type_name_from_type_reference (ValaGSignalModule* self, ValaDataType* t);
gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);
static gchar* vala_gsignal_module_get_value_type_name_from_parameter (ValaGSignalModule* self, ValaParameter* p);
static ValaCCodeExpression* vala_gsignal_module_get_signal_name_cexpression (ValaGSignalModule* self, ValaSignal* sig, ValaExpression* detail_expr, ValaCodeNode* node);
ValaCCodeConstant* vala_ccode_base_module_get_signal_canonical_constant (ValaCCodeBaseModule* self, ValaSignal* sig, const gchar* detail);
ValaTargetValue* vala_ccode_base_module_create_temp_value (ValaCCodeBaseModule* self, ValaDataType* type, gboolean init, ValaCodeNode* node_reference, gboolean* value_owned);
ValaArrayList* vala_ccode_base_module_get_temp_ref_values (ValaCCodeBaseModule* self);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr);
ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value);
static void vala_gsignal_module_real_visit_signal (ValaCodeVisitor* base, ValaSignal* sig);
ValaCCodeParameter* vala_ccode_method_module_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map);
static void vala_gsignal_module_generate_marshaller (ValaGSignalModule* self, ValaList* params, ValaDataType* return_type);
void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func);
gchar* vala_ccode_base_module_get_ccode_get_value_function (ValaCodeNode* sym);
gchar* vala_ccode_base_module_get_ccode_set_value_function (ValaCodeNode* sym);
void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self);
static ValaCCodeFunctionCall* vala_gsignal_module_real_get_signal_creation (ValaCCodeBaseModule* base, ValaSignal* sig, ValaTypeSymbol* type);
gchar* vala_ccode_base_module_get_ccode_type_id (ValaCodeNode* node);
static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value);
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 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 void _vala_array_add6 (gchar*** array, int* length, int* size, gchar* value);
static void _vala_array_add7 (gchar*** array, int* length, int* size, gchar* value);
gchar* vala_ccode_base_module_get_ccode_type_name (ValaInterface* iface);
gchar* vala_ccode_base_module_get_ccode_vfunc_name (ValaMethod* m);
static void vala_gsignal_module_real_visit_element_access (ValaCodeVisitor* base, ValaElementAccess* expr);
void vala_ccode_base_module_set_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* cvalue);
static gboolean vala_gsignal_module_in_gobject_instance (ValaGSignalModule* self, ValaMethod* m);
static void vala_gsignal_module_emit_signal_assignment (ValaGSignalModule* self, ValaAssignment* assignment);
static ValaCCodeExpression* vala_gsignal_module_connect_signal (ValaGSignalModule* self, ValaSignal* sig, ValaExpression* signal_access, ValaExpression* handler, gboolean disconnect, gboolean after, ValaCodeNode* expr);
static void vala_gsignal_module_real_visit_assignment (ValaCodeVisitor* base, ValaAssignment* assignment);
static void vala_gsignal_module_real_visit_member_access (ValaCodeVisitor* base, ValaMemberAccess* expr);
gchar* vala_ccode_base_module_get_ccode_upper_case_name (ValaSymbol* sym, const gchar* infix);
gchar* vala_ccode_base_module_get_ccode_lower_case_name (ValaCodeNode* node, const gchar* infix);
ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self);
gboolean vala_ccode_base_module_get_signal_has_emitter (ValaCCodeBaseModule* self, ValaSignal* sig);
static void vala_gsignal_module_real_visit_method_call (ValaCodeVisitor* base, ValaMethodCall* expr);
gchar* vala_ccode_base_module_get_dynamic_signal_connect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
gchar* vala_ccode_base_module_get_dynamic_signal_connect_after_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
gchar* vala_ccode_base_module_get_dynamic_signal_disconnect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
ValaCCodeExpression* vala_ccode_base_module_get_ccodenode (ValaCCodeBaseModule* self, ValaExpression* node);
ValaCCodeExpression* vala_ccode_base_module_get_result_cexpression (ValaCCodeBaseModule* self, const gchar* cname);
ValaLocalVariable* vala_ccode_base_module_get_temp_variable (ValaCCodeBaseModule* self, ValaDataType* type, gboolean value_owned, ValaCodeNode* node_reference, gboolean init);
void vala_ccode_base_module_emit_temp_var (ValaCCodeBaseModule* self, ValaLocalVariable* local);
ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cexpression (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify);
ValaGSignalModule* vala_gsignal_module_new (void);
ValaGSignalModule* vala_gsignal_module_construct (GType object_type);
ValaGObjectModule* vala_gobject_module_new (void);
ValaGObjectModule* vala_gobject_module_construct (GType object_type);
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 gpointer _vala_iterable_ref0 (gpointer self) {
	return self ? vala_iterable_ref (self) : NULL;
}


static gchar* string_replace (const gchar* self, const gchar* old, const gchar* replacement) {
	gchar* result = NULL;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (old != NULL, NULL);
	g_return_val_if_fail (replacement != NULL, NULL);
	{
		const gchar* _tmp0_;
		gchar* _tmp1_ = NULL;
		gchar* _tmp2_;
		GRegex* _tmp3_;
		GRegex* _tmp4_;
		GRegex* regex;
		GRegex* _tmp5_;
		const gchar* _tmp6_;
		gchar* _tmp7_ = NULL;
		gchar* _tmp8_;
		_tmp0_ = old;
		_tmp1_ = g_regex_escape_string (_tmp0_, -1);
		_tmp2_ = _tmp1_;
		_tmp3_ = g_regex_new (_tmp2_, 0, 0, &_inner_error_);
		_tmp4_ = _tmp3_;
		_g_free0 (_tmp2_);
		regex = _tmp4_;
		if (_inner_error_ != NULL) {
			if (_inner_error_->domain == G_REGEX_ERROR) {
				goto __catch5_g_regex_error;
			}
			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 NULL;
		}
		_tmp5_ = regex;
		_tmp6_ = replacement;
		_tmp7_ = g_regex_replace_literal (_tmp5_, self, (gssize) (-1), 0, _tmp6_, 0, &_inner_error_);
		_tmp8_ = _tmp7_;
		if (_inner_error_ != NULL) {
			_g_regex_unref0 (regex);
			if (_inner_error_->domain == G_REGEX_ERROR) {
				goto __catch5_g_regex_error;
			}
			_g_regex_unref0 (regex);
			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 NULL;
		}
		result = _tmp8_;
		_g_regex_unref0 (regex);
		return result;
	}
	goto __finally5;
	__catch5_g_regex_error:
	{
		GError* e = NULL;
		e = _inner_error_;
		_inner_error_ = NULL;
		g_assert_not_reached ();
		_g_error_free0 (e);
	}
	__finally5:
	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;
	}
}


static gchar* vala_gsignal_module_get_marshaller_function (ValaGSignalModule* self, ValaList* params, ValaDataType* return_type, const gchar* prefix) {
	gchar* result = NULL;
	ValaList* _tmp0_;
	ValaDataType* _tmp1_;
	gchar* _tmp2_ = NULL;
	gchar* signature;
	gchar* ret = NULL;
	const gchar* _tmp3_;
	const gchar* _tmp7_;
	ValaDataType* _tmp8_;
	gchar* _tmp9_ = NULL;
	gchar* _tmp10_;
	gchar* _tmp11_ = NULL;
	gboolean _tmp12_ = FALSE;
	ValaList* _tmp13_;
	gboolean _tmp17_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (params != NULL, NULL);
	g_return_val_if_fail (return_type != NULL, NULL);
	_tmp0_ = params;
	_tmp1_ = return_type;
	_tmp2_ = vala_gsignal_module_get_marshaller_signature (self, _tmp0_, _tmp1_);
	signature = _tmp2_;
	_tmp3_ = prefix;
	if (_tmp3_ == NULL) {
		ValaSet* _tmp4_;
		const gchar* _tmp5_;
		gboolean _tmp6_ = FALSE;
		_tmp4_ = ((ValaCCodeBaseModule*) self)->predefined_marshal_set;
		_tmp5_ = signature;
		_tmp6_ = vala_collection_contains ((ValaCollection*) _tmp4_, _tmp5_);
		if (_tmp6_) {
			prefix = "g_cclosure_marshal";
		} else {
			prefix = "g_cclosure_user_marshal";
		}
	}
	_tmp7_ = prefix;
	_tmp8_ = return_type;
	_tmp9_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp8_);
	_tmp10_ = _tmp9_;
	_tmp11_ = g_strdup_printf ("%s_%s_", _tmp7_, _tmp10_);
	_g_free0 (ret);
	ret = _tmp11_;
	_g_free0 (_tmp10_);
	_tmp13_ = params;
	if (_tmp13_ == NULL) {
		_tmp12_ = TRUE;
	} else {
		ValaList* _tmp14_;
		gint _tmp15_;
		gint _tmp16_;
		_tmp14_ = params;
		_tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);
		_tmp16_ = _tmp15_;
		_tmp12_ = _tmp16_ == 0;
	}
	_tmp17_ = _tmp12_;
	if (_tmp17_) {
		const gchar* _tmp18_;
		gchar* _tmp19_;
		_tmp18_ = ret;
		_tmp19_ = g_strconcat (_tmp18_, "_VOID", NULL);
		_g_free0 (ret);
		ret = _tmp19_;
	} else {
		{
			ValaList* _tmp20_;
			ValaList* _tmp21_;
			ValaList* _p_list;
			ValaList* _tmp22_;
			gint _tmp23_;
			gint _tmp24_;
			gint _p_size;
			gint _p_index;
			_tmp20_ = params;
			_tmp21_ = _vala_iterable_ref0 (_tmp20_);
			_p_list = _tmp21_;
			_tmp22_ = _p_list;
			_tmp23_ = vala_collection_get_size ((ValaCollection*) _tmp22_);
			_tmp24_ = _tmp23_;
			_p_size = _tmp24_;
			_p_index = -1;
			while (TRUE) {
				gint _tmp25_;
				gint _tmp26_;
				gint _tmp27_;
				ValaList* _tmp28_;
				gint _tmp29_;
				gpointer _tmp30_ = NULL;
				ValaParameter* p;
				const gchar* _tmp31_;
				ValaParameter* _tmp32_;
				gchar* _tmp33_ = NULL;
				gchar* _tmp34_;
				gchar* _tmp35_ = NULL;
				gchar* _tmp36_;
				gchar* _tmp37_ = NULL;
				_tmp25_ = _p_index;
				_p_index = _tmp25_ + 1;
				_tmp26_ = _p_index;
				_tmp27_ = _p_size;
				if (!(_tmp26_ < _tmp27_)) {
					break;
				}
				_tmp28_ = _p_list;
				_tmp29_ = _p_index;
				_tmp30_ = vala_list_get (_tmp28_, _tmp29_);
				p = (ValaParameter*) _tmp30_;
				_tmp31_ = ret;
				_tmp32_ = p;
				_tmp33_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp32_);
				_tmp34_ = _tmp33_;
				_tmp35_ = string_replace (_tmp34_, ",", "_");
				_tmp36_ = _tmp35_;
				_tmp37_ = g_strdup_printf ("%s_%s", _tmp31_, _tmp36_);
				_g_free0 (ret);
				ret = _tmp37_;
				_g_free0 (_tmp36_);
				_g_free0 (_tmp34_);
				_vala_code_node_unref0 (p);
			}
			_vala_iterable_unref0 (_p_list);
		}
	}
	result = ret;
	_g_free0 (signature);
	return result;
}


static gpointer _vala_code_node_ref0 (gpointer self) {
	return self ? vala_code_node_ref (self) : NULL;
}


static gchar* vala_gsignal_module_get_value_type_name_from_type_reference (ValaGSignalModule* self, ValaDataType* t) {
	gchar* result = NULL;
	gboolean _tmp0_ = FALSE;
	ValaDataType* _tmp1_;
	gboolean _tmp5_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (t != NULL, NULL);
	_tmp1_ = t;
	if (VALA_IS_POINTER_TYPE (_tmp1_)) {
		_tmp0_ = TRUE;
	} else {
		ValaDataType* _tmp2_;
		ValaTypeParameter* _tmp3_;
		ValaTypeParameter* _tmp4_;
		_tmp2_ = t;
		_tmp3_ = vala_data_type_get_type_parameter (_tmp2_);
		_tmp4_ = _tmp3_;
		_tmp0_ = _tmp4_ != NULL;
	}
	_tmp5_ = _tmp0_;
	if (_tmp5_) {
		gchar* _tmp6_;
		_tmp6_ = g_strdup ("gpointer");
		result = _tmp6_;
		return result;
	} else {
		ValaDataType* _tmp7_;
		_tmp7_ = t;
		if (VALA_IS_VOID_TYPE (_tmp7_)) {
			gchar* _tmp8_;
			_tmp8_ = g_strdup ("void");
			result = _tmp8_;
			return result;
		} else {
			ValaDataType* _tmp9_;
			ValaTypeSymbol* _tmp10_;
			ValaTypeSymbol* _tmp11_;
			ValaDataType* _tmp12_;
			ValaTypeSymbol* _tmp13_;
			ValaTypeSymbol* _tmp14_;
			_tmp9_ = t;
			_tmp10_ = vala_data_type_get_data_type (_tmp9_);
			_tmp11_ = _tmp10_;
			_tmp12_ = ((ValaCCodeBaseModule*) self)->string_type;
			_tmp13_ = vala_data_type_get_data_type (_tmp12_);
			_tmp14_ = _tmp13_;
			if (_tmp11_ == _tmp14_) {
				gchar* _tmp15_;
				_tmp15_ = g_strdup ("const char*");
				result = _tmp15_;
				return result;
			} else {
				gboolean _tmp16_ = FALSE;
				ValaDataType* _tmp17_;
				ValaTypeSymbol* _tmp18_;
				ValaTypeSymbol* _tmp19_;
				gboolean _tmp23_;
				_tmp17_ = t;
				_tmp18_ = vala_data_type_get_data_type (_tmp17_);
				_tmp19_ = _tmp18_;
				if (VALA_IS_CLASS (_tmp19_)) {
					_tmp16_ = TRUE;
				} else {
					ValaDataType* _tmp20_;
					ValaTypeSymbol* _tmp21_;
					ValaTypeSymbol* _tmp22_;
					_tmp20_ = t;
					_tmp21_ = vala_data_type_get_data_type (_tmp20_);
					_tmp22_ = _tmp21_;
					_tmp16_ = VALA_IS_INTERFACE (_tmp22_);
				}
				_tmp23_ = _tmp16_;
				if (_tmp23_) {
					gchar* _tmp24_;
					_tmp24_ = g_strdup ("gpointer");
					result = _tmp24_;
					return result;
				} else {
					ValaDataType* _tmp25_;
					ValaTypeSymbol* _tmp26_;
					ValaTypeSymbol* _tmp27_;
					_tmp25_ = t;
					_tmp26_ = vala_data_type_get_data_type (_tmp25_);
					_tmp27_ = _tmp26_;
					if (VALA_IS_STRUCT (_tmp27_)) {
						ValaDataType* _tmp28_;
						ValaTypeSymbol* _tmp29_;
						ValaTypeSymbol* _tmp30_;
						ValaStruct* _tmp31_;
						ValaStruct* st;
						ValaStruct* _tmp32_;
						gboolean _tmp33_ = FALSE;
						_tmp28_ = t;
						_tmp29_ = vala_data_type_get_data_type (_tmp28_);
						_tmp30_ = _tmp29_;
						_tmp31_ = _vala_code_node_ref0 (VALA_STRUCT (_tmp30_));
						st = _tmp31_;
						_tmp32_ = st;
						_tmp33_ = vala_struct_is_simple_type (_tmp32_);
						if (_tmp33_) {
							ValaDataType* _tmp34_;
							ValaTypeSymbol* _tmp35_;
							ValaTypeSymbol* _tmp36_;
							gchar* _tmp37_ = NULL;
							_tmp34_ = t;
							_tmp35_ = vala_data_type_get_data_type (_tmp34_);
							_tmp36_ = _tmp35_;
							_tmp37_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp36_);
							result = _tmp37_;
							_vala_code_node_unref0 (st);
							return result;
						} else {
							gchar* _tmp38_;
							_tmp38_ = g_strdup ("gpointer");
							result = _tmp38_;
							_vala_code_node_unref0 (st);
							return result;
						}
						_vala_code_node_unref0 (st);
					} else {
						ValaDataType* _tmp39_;
						ValaTypeSymbol* _tmp40_;
						ValaTypeSymbol* _tmp41_;
						_tmp39_ = t;
						_tmp40_ = vala_data_type_get_data_type (_tmp39_);
						_tmp41_ = _tmp40_;
						if (VALA_IS_ENUM (_tmp41_)) {
							gchar* _tmp42_;
							_tmp42_ = g_strdup ("gint");
							result = _tmp42_;
							return result;
						} else {
							ValaDataType* _tmp43_;
							_tmp43_ = t;
							if (VALA_IS_ARRAY_TYPE (_tmp43_)) {
								gchar* _tmp44_;
								_tmp44_ = g_strdup ("gpointer");
								result = _tmp44_;
								return result;
							} else {
								ValaDataType* _tmp45_;
								_tmp45_ = t;
								if (VALA_IS_ERROR_TYPE (_tmp45_)) {
									gchar* _tmp46_;
									_tmp46_ = g_strdup ("gpointer");
									result = _tmp46_;
									return result;
								}
							}
						}
					}
				}
			}
		}
	}
	result = NULL;
	return result;
}


static gchar* vala_gsignal_module_get_value_type_name_from_parameter (ValaGSignalModule* self, ValaParameter* p) {
	gchar* result = NULL;
	ValaParameter* _tmp0_;
	ValaParameterDirection _tmp1_;
	ValaParameterDirection _tmp2_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (p != NULL, NULL);
	_tmp0_ = p;
	_tmp1_ = vala_parameter_get_direction (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ != VALA_PARAMETER_DIRECTION_IN) {
		gchar* _tmp3_;
		_tmp3_ = g_strdup ("gpointer");
		result = _tmp3_;
		return result;
	} else {
		ValaParameter* _tmp4_;
		ValaDataType* _tmp5_;
		ValaDataType* _tmp6_;
		gchar* _tmp7_ = NULL;
		_tmp4_ = p;
		_tmp5_ = vala_variable_get_variable_type ((ValaVariable*) _tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = vala_gsignal_module_get_value_type_name_from_type_reference (self, _tmp6_);
		result = _tmp7_;
		return result;
	}
}


static gchar* vala_gsignal_module_get_marshaller_signature (ValaGSignalModule* self, ValaList* params, ValaDataType* return_type) {
	gchar* result = NULL;
	gchar* signature = NULL;
	ValaDataType* _tmp0_;
	gchar* _tmp1_ = NULL;
	gchar* _tmp2_;
	gchar* _tmp3_ = NULL;
	gboolean _tmp4_ = FALSE;
	ValaList* _tmp5_;
	gboolean _tmp9_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (params != NULL, NULL);
	g_return_val_if_fail (return_type != NULL, NULL);
	_tmp0_ = return_type;
	_tmp1_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = g_strdup_printf ("%s:", _tmp2_);
	_g_free0 (signature);
	signature = _tmp3_;
	_g_free0 (_tmp2_);
	_tmp5_ = params;
	if (_tmp5_ == NULL) {
		_tmp4_ = TRUE;
	} else {
		ValaList* _tmp6_;
		gint _tmp7_;
		gint _tmp8_;
		_tmp6_ = params;
		_tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);
		_tmp8_ = _tmp7_;
		_tmp4_ = _tmp8_ == 0;
	}
	_tmp9_ = _tmp4_;
	if (_tmp9_) {
		const gchar* _tmp10_;
		gchar* _tmp11_;
		_tmp10_ = signature;
		_tmp11_ = g_strconcat (_tmp10_, "VOID", NULL);
		_g_free0 (signature);
		signature = _tmp11_;
	} else {
		gboolean first;
		first = TRUE;
		{
			ValaList* _tmp12_;
			ValaList* _tmp13_;
			ValaList* _p_list;
			ValaList* _tmp14_;
			gint _tmp15_;
			gint _tmp16_;
			gint _p_size;
			gint _p_index;
			_tmp12_ = params;
			_tmp13_ = _vala_iterable_ref0 (_tmp12_);
			_p_list = _tmp13_;
			_tmp14_ = _p_list;
			_tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);
			_tmp16_ = _tmp15_;
			_p_size = _tmp16_;
			_p_index = -1;
			while (TRUE) {
				gint _tmp17_;
				gint _tmp18_;
				gint _tmp19_;
				ValaList* _tmp20_;
				gint _tmp21_;
				gpointer _tmp22_ = NULL;
				ValaParameter* p;
				gboolean _tmp23_;
				_tmp17_ = _p_index;
				_p_index = _tmp17_ + 1;
				_tmp18_ = _p_index;
				_tmp19_ = _p_size;
				if (!(_tmp18_ < _tmp19_)) {
					break;
				}
				_tmp20_ = _p_list;
				_tmp21_ = _p_index;
				_tmp22_ = vala_list_get (_tmp20_, _tmp21_);
				p = (ValaParameter*) _tmp22_;
				_tmp23_ = first;
				if (_tmp23_) {
					const gchar* _tmp24_;
					ValaParameter* _tmp25_;
					gchar* _tmp26_ = NULL;
					gchar* _tmp27_;
					gchar* _tmp28_;
					_tmp24_ = signature;
					_tmp25_ = p;
					_tmp26_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp25_);
					_tmp27_ = _tmp26_;
					_tmp28_ = g_strconcat (_tmp24_, _tmp27_, NULL);
					_g_free0 (signature);
					signature = _tmp28_;
					_g_free0 (_tmp27_);
					first = FALSE;
				} else {
					const gchar* _tmp29_;
					ValaParameter* _tmp30_;
					gchar* _tmp31_ = NULL;
					gchar* _tmp32_;
					gchar* _tmp33_ = NULL;
					_tmp29_ = signature;
					_tmp30_ = p;
					_tmp31_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp30_);
					_tmp32_ = _tmp31_;
					_tmp33_ = g_strdup_printf ("%s,%s", _tmp29_, _tmp32_);
					_g_free0 (signature);
					signature = _tmp33_;
					_g_free0 (_tmp32_);
				}
				_vala_code_node_unref0 (p);
			}
			_vala_iterable_unref0 (_p_list);
		}
	}
	result = signature;
	return result;
}


static ValaCCodeExpression* vala_gsignal_module_get_signal_name_cexpression (ValaGSignalModule* self, ValaSignal* sig, ValaExpression* detail_expr, ValaCodeNode* node) {
	ValaCCodeExpression* result = NULL;
	ValaExpression* _tmp0_;
	gboolean _tmp3_ = FALSE;
	ValaExpression* _tmp4_;
	ValaDataType* _tmp5_;
	ValaDataType* _tmp6_;
	gboolean _tmp12_;
	ValaExpression* _tmp17_;
	ValaExpression* _tmp24_;
	ValaDataType* _tmp25_;
	ValaDataType* _tmp26_;
	ValaCodeNode* _tmp27_;
	gboolean _tmp28_;
	ValaTargetValue* _tmp29_ = NULL;
	ValaTargetValue* detail_value;
	ValaArrayList* _tmp30_;
	ValaArrayList* _tmp31_;
	ValaTargetValue* _tmp32_;
	ValaCCodeIdentifier* _tmp33_;
	ValaCCodeIdentifier* _tmp34_;
	ValaCCodeFunctionCall* _tmp35_;
	ValaCCodeFunctionCall* _tmp36_;
	ValaCCodeFunctionCall* ccall;
	ValaCCodeFunctionCall* _tmp37_;
	ValaSignal* _tmp38_;
	ValaCCodeConstant* _tmp39_ = NULL;
	ValaCCodeConstant* _tmp40_;
	ValaCCodeFunctionCall* _tmp41_;
	ValaExpression* _tmp42_;
	ValaCCodeExpression* _tmp43_ = NULL;
	ValaCCodeExpression* _tmp44_;
	ValaCCodeFunctionCall* _tmp45_;
	ValaCCodeConstant* _tmp46_;
	ValaCCodeConstant* _tmp47_;
	ValaCCodeFunction* _tmp48_;
	ValaCCodeFunction* _tmp49_;
	ValaTargetValue* _tmp50_;
	ValaCCodeExpression* _tmp51_ = NULL;
	ValaCCodeExpression* _tmp52_;
	ValaCCodeFunctionCall* _tmp53_;
	ValaTargetValue* _tmp54_;
	ValaCCodeExpression* _tmp55_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (sig != NULL, NULL);
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = detail_expr;
	if (_tmp0_ == NULL) {
		ValaSignal* _tmp1_;
		ValaCCodeConstant* _tmp2_ = NULL;
		_tmp1_ = sig;
		_tmp2_ = vala_ccode_base_module_get_signal_canonical_constant ((ValaCCodeBaseModule*) self, _tmp1_, NULL);
		result = (ValaCCodeExpression*) _tmp2_;
		return result;
	}
	_tmp4_ = detail_expr;
	_tmp5_ = vala_expression_get_value_type (_tmp4_);
	_tmp6_ = _tmp5_;
	if (VALA_IS_NULL_TYPE (_tmp6_)) {
		_tmp3_ = TRUE;
	} else {
		ValaExpression* _tmp7_;
		ValaDataType* _tmp8_;
		ValaDataType* _tmp9_;
		ValaDataType* _tmp10_;
		gboolean _tmp11_ = FALSE;
		_tmp7_ = detail_expr;
		_tmp8_ = vala_expression_get_value_type (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = ((ValaCCodeBaseModule*) self)->string_type;
		_tmp11_ = vala_data_type_compatible (_tmp9_, _tmp10_);
		_tmp3_ = !_tmp11_;
	}
	_tmp12_ = _tmp3_;
	if (_tmp12_) {
		ValaCodeNode* _tmp13_;
		ValaExpression* _tmp14_;
		ValaSourceReference* _tmp15_;
		ValaSourceReference* _tmp16_;
		_tmp13_ = node;
		vala_code_node_set_error (_tmp13_, TRUE);
		_tmp14_ = detail_expr;
		_tmp15_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp14_);
		_tmp16_ = _tmp15_;
		vala_report_error (_tmp16_, "only string details are supported");
		result = NULL;
		return result;
	}
	_tmp17_ = detail_expr;
	if (VALA_IS_STRING_LITERAL (_tmp17_)) {
		ValaSignal* _tmp18_;
		ValaExpression* _tmp19_;
		gchar* _tmp20_ = NULL;
		gchar* _tmp21_;
		ValaCCodeConstant* _tmp22_ = NULL;
		ValaCCodeExpression* _tmp23_;
		_tmp18_ = sig;
		_tmp19_ = detail_expr;
		_tmp20_ = vala_string_literal_eval (VALA_STRING_LITERAL (_tmp19_));
		_tmp21_ = _tmp20_;
		_tmp22_ = vala_ccode_base_module_get_signal_canonical_constant ((ValaCCodeBaseModule*) self, _tmp18_, _tmp21_);
		_tmp23_ = (ValaCCodeExpression*) _tmp22_;
		_g_free0 (_tmp21_);
		result = _tmp23_;
		return result;
	}
	_tmp24_ = detail_expr;
	_tmp25_ = vala_expression_get_value_type (_tmp24_);
	_tmp26_ = _tmp25_;
	_tmp27_ = node;
	_tmp28_ = TRUE;
	_tmp29_ = vala_ccode_base_module_create_temp_value ((ValaCCodeBaseModule*) self, _tmp26_, FALSE, _tmp27_, &_tmp28_);
	detail_value = _tmp29_;
	_tmp30_ = vala_ccode_base_module_get_temp_ref_values ((ValaCCodeBaseModule*) self);
	_tmp31_ = _tmp30_;
	_tmp32_ = detail_value;
	vala_list_insert ((ValaList*) _tmp31_, 0, _tmp32_);
	_tmp33_ = vala_ccode_identifier_new ("g_strconcat");
	_tmp34_ = _tmp33_;
	_tmp35_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp34_);
	_tmp36_ = _tmp35_;
	_vala_ccode_node_unref0 (_tmp34_);
	ccall = _tmp36_;
	_tmp37_ = ccall;
	_tmp38_ = sig;
	_tmp39_ = vala_ccode_base_module_get_signal_canonical_constant ((ValaCCodeBaseModule*) self, _tmp38_, "");
	_tmp40_ = _tmp39_;
	vala_ccode_function_call_add_argument (_tmp37_, (ValaCCodeExpression*) _tmp40_);
	_vala_ccode_node_unref0 (_tmp40_);
	_tmp41_ = ccall;
	_tmp42_ = detail_expr;
	_tmp43_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp42_);
	_tmp44_ = _tmp43_;
	vala_ccode_function_call_add_argument (_tmp41_, _tmp44_);
	_vala_ccode_node_unref0 (_tmp44_);
	_tmp45_ = ccall;
	_tmp46_ = vala_ccode_constant_new ("NULL");
	_tmp47_ = _tmp46_;
	vala_ccode_function_call_add_argument (_tmp45_, (ValaCCodeExpression*) _tmp47_);
	_vala_ccode_node_unref0 (_tmp47_);
	_tmp48_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp49_ = _tmp48_;
	_tmp50_ = detail_value;
	_tmp51_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp50_);
	_tmp52_ = _tmp51_;
	_tmp53_ = ccall;
	vala_ccode_function_add_assignment (_tmp49_, _tmp52_, (ValaCCodeExpression*) _tmp53_);
	_vala_ccode_node_unref0 (_tmp52_);
	_tmp54_ = detail_value;
	_tmp55_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp54_);
	result = _tmp55_;
	_vala_ccode_node_unref0 (ccall);
	_vala_target_value_unref0 (detail_value);
	return result;
}


static void vala_gsignal_module_real_visit_signal (ValaCodeVisitor* base, ValaSignal* sig) {
	ValaGSignalModule * self;
	ValaSignal* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaClass* _tmp3_;
	ValaClass* cl;
	gboolean _tmp4_ = FALSE;
	ValaClass* _tmp5_;
	gboolean _tmp9_;
	ValaClass* _tmp14_;
	ValaSignal* _tmp39_;
	ValaSignal* _tmp60_;
	ValaList* _tmp61_ = NULL;
	ValaList* _tmp62_;
	ValaSignal* _tmp63_;
	ValaDataType* _tmp64_;
	ValaDataType* _tmp65_;
	self = (ValaGSignalModule*) base;
	g_return_if_fail (sig != NULL);
	_tmp0_ = sig;
	_tmp1_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp2_) ? ((ValaClass*) _tmp2_) : NULL);
	cl = _tmp3_;
	_tmp5_ = cl;
	if (_tmp5_ != NULL) {
		ValaClass* _tmp6_;
		gboolean _tmp7_;
		gboolean _tmp8_;
		_tmp6_ = cl;
		_tmp7_ = vala_class_get_is_compact (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp4_ = _tmp8_;
	} else {
		_tmp4_ = FALSE;
	}
	_tmp9_ = _tmp4_;
	if (_tmp9_) {
		ValaSignal* _tmp10_;
		ValaSignal* _tmp11_;
		ValaSourceReference* _tmp12_;
		ValaSourceReference* _tmp13_;
		_tmp10_ = sig;
		vala_code_node_set_error ((ValaCodeNode*) _tmp10_, TRUE);
		_tmp11_ = sig;
		_tmp12_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp11_);
		_tmp13_ = _tmp12_;
		vala_report_error (_tmp13_, "Signals are not supported in compact classes");
		_vala_code_node_unref0 (cl);
		return;
	}
	_tmp14_ = cl;
	if (_tmp14_ != NULL) {
		{
			ValaClass* _tmp15_;
			ValaList* _tmp16_ = NULL;
			ValaList* _base_type_list;
			ValaList* _tmp17_;
			gint _tmp18_;
			gint _tmp19_;
			gint _base_type_size;
			gint _base_type_index;
			_tmp15_ = cl;
			_tmp16_ = vala_class_get_base_types (_tmp15_);
			_base_type_list = _tmp16_;
			_tmp17_ = _base_type_list;
			_tmp18_ = vala_collection_get_size ((ValaCollection*) _tmp17_);
			_tmp19_ = _tmp18_;
			_base_type_size = _tmp19_;
			_base_type_index = -1;
			while (TRUE) {
				gint _tmp20_;
				gint _tmp21_;
				gint _tmp22_;
				ValaList* _tmp23_;
				gint _tmp24_;
				gpointer _tmp25_ = NULL;
				ValaDataType* base_type;
				ValaDataType* _tmp26_;
				ValaTypeSymbol* _tmp27_;
				ValaTypeSymbol* _tmp28_;
				ValaSignal* _tmp29_;
				const gchar* _tmp30_;
				const gchar* _tmp31_;
				ValaSymbol* _tmp32_ = NULL;
				ValaSymbol* _tmp33_;
				gboolean _tmp34_;
				_tmp20_ = _base_type_index;
				_base_type_index = _tmp20_ + 1;
				_tmp21_ = _base_type_index;
				_tmp22_ = _base_type_size;
				if (!(_tmp21_ < _tmp22_)) {
					break;
				}
				_tmp23_ = _base_type_list;
				_tmp24_ = _base_type_index;
				_tmp25_ = vala_list_get (_tmp23_, _tmp24_);
				base_type = (ValaDataType*) _tmp25_;
				_tmp26_ = base_type;
				_tmp27_ = vala_data_type_get_data_type (_tmp26_);
				_tmp28_ = _tmp27_;
				_tmp29_ = sig;
				_tmp30_ = vala_symbol_get_name ((ValaSymbol*) _tmp29_);
				_tmp31_ = _tmp30_;
				_tmp32_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp28_, _tmp31_);
				_tmp33_ = _tmp32_;
				_tmp34_ = VALA_IS_SIGNAL (_tmp33_);
				_vala_code_node_unref0 (_tmp33_);
				if (_tmp34_) {
					ValaSignal* _tmp35_;
					ValaSignal* _tmp36_;
					ValaSourceReference* _tmp37_;
					ValaSourceReference* _tmp38_;
					_tmp35_ = sig;
					vala_code_node_set_error ((ValaCodeNode*) _tmp35_, TRUE);
					_tmp36_ = sig;
					_tmp37_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp36_);
					_tmp38_ = _tmp37_;
					vala_report_error (_tmp38_, "Signals with the same name as a signal in a base type are not supporte" \
"d");
					_vala_code_node_unref0 (base_type);
					_vala_iterable_unref0 (_base_type_list);
					_vala_code_node_unref0 (cl);
					return;
				}
				_vala_code_node_unref0 (base_type);
			}
			_vala_iterable_unref0 (_base_type_list);
		}
	}
	_tmp39_ = sig;
	vala_code_node_accept_children ((ValaCodeNode*) _tmp39_, (ValaCodeVisitor*) self);
	{
		ValaSignal* _tmp40_;
		ValaList* _tmp41_ = NULL;
		ValaList* _p_list;
		ValaList* _tmp42_;
		gint _tmp43_;
		gint _tmp44_;
		gint _p_size;
		gint _p_index;
		_tmp40_ = sig;
		_tmp41_ = vala_signal_get_parameters (_tmp40_);
		_p_list = _tmp41_;
		_tmp42_ = _p_list;
		_tmp43_ = vala_collection_get_size ((ValaCollection*) _tmp42_);
		_tmp44_ = _tmp43_;
		_p_size = _tmp44_;
		_p_index = -1;
		while (TRUE) {
			gint _tmp45_;
			gint _tmp46_;
			gint _tmp47_;
			ValaList* _tmp48_;
			gint _tmp49_;
			gpointer _tmp50_ = NULL;
			ValaParameter* p;
			ValaParameter* _tmp51_;
			ValaCCodeFile* _tmp52_;
			GHashFunc _tmp53_;
			GEqualFunc _tmp54_;
			GEqualFunc _tmp55_;
			ValaHashMap* _tmp56_;
			ValaHashMap* _tmp57_;
			ValaCCodeParameter* _tmp58_ = NULL;
			ValaCCodeParameter* _tmp59_;
			_tmp45_ = _p_index;
			_p_index = _tmp45_ + 1;
			_tmp46_ = _p_index;
			_tmp47_ = _p_size;
			if (!(_tmp46_ < _tmp47_)) {
				break;
			}
			_tmp48_ = _p_list;
			_tmp49_ = _p_index;
			_tmp50_ = vala_list_get (_tmp48_, _tmp49_);
			p = (ValaParameter*) _tmp50_;
			_tmp51_ = p;
			_tmp52_ = ((ValaCCodeBaseModule*) self)->cfile;
			_tmp53_ = g_direct_hash;
			_tmp54_ = g_direct_equal;
			_tmp55_ = g_direct_equal;
			_tmp56_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp53_, _tmp54_, _tmp55_);
			_tmp57_ = _tmp56_;
			_tmp58_ = vala_ccode_method_module_generate_parameter ((ValaCCodeMethodModule*) self, _tmp51_, _tmp52_, (ValaMap*) _tmp57_, NULL);
			_tmp59_ = _tmp58_;
			_vala_ccode_node_unref0 (_tmp59_);
			_vala_map_unref0 (_tmp57_);
			_vala_code_node_unref0 (p);
		}
		_vala_iterable_unref0 (_p_list);
	}
	_tmp60_ = sig;
	_tmp61_ = vala_signal_get_parameters (_tmp60_);
	_tmp62_ = _tmp61_;
	_tmp63_ = sig;
	_tmp64_ = vala_signal_get_return_type (_tmp63_);
	_tmp65_ = _tmp64_;
	vala_gsignal_module_generate_marshaller (self, _tmp62_, _tmp65_);
	_vala_iterable_unref0 (_tmp62_);
	_vala_code_node_unref0 (cl);
}


static void vala_gsignal_module_generate_marshaller (ValaGSignalModule* self, ValaList* params, ValaDataType* return_type) {
	gchar* signature = NULL;
	gint n_params = 0;
	gint i = 0;
	ValaList* _tmp0_;
	ValaDataType* _tmp1_;
	gchar* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	ValaSet* _tmp4_;
	const gchar* _tmp5_;
	gboolean _tmp6_ = FALSE;
	gboolean _tmp10_;
	ValaList* _tmp11_;
	ValaDataType* _tmp12_;
	gchar* _tmp13_ = NULL;
	gchar* _tmp14_;
	ValaCCodeFunction* _tmp15_;
	ValaCCodeFunction* _tmp16_;
	ValaCCodeFunction* signal_marshaller;
	ValaCCodeFunction* _tmp17_;
	ValaCCodeFunction* _tmp18_;
	ValaCCodeParameter* _tmp19_;
	ValaCCodeParameter* _tmp20_;
	ValaCCodeFunction* _tmp21_;
	ValaCCodeParameter* _tmp22_;
	ValaCCodeParameter* _tmp23_;
	ValaCCodeFunction* _tmp24_;
	ValaCCodeParameter* _tmp25_;
	ValaCCodeParameter* _tmp26_;
	ValaCCodeFunction* _tmp27_;
	ValaCCodeParameter* _tmp28_;
	ValaCCodeParameter* _tmp29_;
	ValaCCodeFunction* _tmp30_;
	ValaCCodeParameter* _tmp31_;
	ValaCCodeParameter* _tmp32_;
	ValaCCodeFunction* _tmp33_;
	ValaCCodeParameter* _tmp34_;
	ValaCCodeParameter* _tmp35_;
	ValaCCodeFunction* _tmp36_;
	ValaList* _tmp37_;
	ValaDataType* _tmp38_;
	gchar* _tmp39_ = NULL;
	gchar* _tmp40_;
	ValaCCodeFunctionDeclarator* _tmp41_;
	ValaCCodeFunctionDeclarator* _tmp42_;
	ValaCCodeFunctionDeclarator* callback_decl;
	ValaCCodeFunctionDeclarator* _tmp43_;
	ValaCCodeParameter* _tmp44_;
	ValaCCodeParameter* _tmp45_;
	ValaCCodeFunctionDeclarator* _tmp78_;
	ValaCCodeParameter* _tmp79_;
	ValaCCodeParameter* _tmp80_;
	ValaCCodeFunction* _tmp81_;
	ValaCCodeFunction* _tmp82_;
	ValaDataType* _tmp83_;
	gchar* _tmp84_ = NULL;
	gchar* _tmp85_;
	ValaCCodeFunctionDeclarator* _tmp86_;
	ValaCCodeTypeDefinition* _tmp87_;
	ValaCCodeTypeDefinition* _tmp88_;
	ValaCCodeFunction* _tmp89_;
	ValaCCodeFunction* _tmp90_;
	ValaList* _tmp91_;
	ValaDataType* _tmp92_;
	gchar* _tmp93_ = NULL;
	gchar* _tmp94_;
	ValaCCodeVariableDeclarator* _tmp95_;
	ValaCCodeVariableDeclarator* _tmp96_;
	ValaCCodeFunction* _tmp97_;
	ValaCCodeFunction* _tmp98_;
	ValaCCodeIdentifier* _tmp99_;
	ValaCCodeIdentifier* _tmp100_;
	ValaCCodeCastExpression* _tmp101_;
	ValaCCodeCastExpression* _tmp102_;
	ValaCCodeVariableDeclarator* _tmp103_;
	ValaCCodeVariableDeclarator* _tmp104_;
	ValaCCodeFunction* _tmp105_;
	ValaCCodeFunction* _tmp106_;
	ValaCCodeVariableDeclarator* _tmp107_;
	ValaCCodeVariableDeclarator* _tmp108_;
	ValaCCodeFunction* _tmp109_;
	ValaCCodeFunction* _tmp110_;
	ValaCCodeVariableDeclarator* _tmp111_;
	ValaCCodeVariableDeclarator* _tmp112_;
	ValaCCodeFunctionCall* fc = NULL;
	gboolean _tmp113_ = FALSE;
	ValaDataType* _tmp114_;
	ValaTypeSymbol* _tmp115_;
	ValaTypeSymbol* _tmp116_;
	gboolean _tmp119_;
	ValaCCodeIdentifier* _tmp140_;
	ValaCCodeIdentifier* _tmp141_;
	ValaCCodeFunctionCall* _tmp142_;
	ValaCCodeFunctionCall* _tmp143_;
	ValaCCodeIdentifier* _tmp144_;
	ValaCCodeIdentifier* _tmp145_;
	gint _tmp146_;
	gchar* _tmp147_ = NULL;
	gchar* _tmp148_;
	ValaCCodeConstant* _tmp149_;
	ValaCCodeConstant* _tmp150_;
	ValaCCodeBinaryExpression* _tmp151_;
	ValaCCodeBinaryExpression* _tmp152_;
	ValaCCodeFunction* _tmp153_;
	ValaCCodeFunction* _tmp154_;
	ValaCCodeFunctionCall* _tmp155_;
	ValaCCodeIdentifier* _tmp156_;
	ValaCCodeIdentifier* _tmp157_;
	ValaCCodeMemberAccess* _tmp158_;
	ValaCCodeMemberAccess* _tmp159_;
	ValaCCodeMemberAccess* data;
	ValaCCodeIdentifier* _tmp160_;
	ValaCCodeIdentifier* _tmp161_;
	ValaCCodeMemberAccess* _tmp162_;
	ValaCCodeMemberAccess* _tmp163_;
	ValaCCodeMemberAccess* _tmp164_;
	ValaCCodeMemberAccess* _tmp165_;
	ValaCCodeMemberAccess* param;
	ValaCCodeConstant* _tmp166_;
	ValaCCodeConstant* _tmp167_;
	ValaCCodeFunctionCall* _tmp168_;
	ValaCCodeFunctionCall* _tmp169_;
	ValaCCodeFunctionCall* cond;
	ValaCCodeFunctionCall* _tmp170_;
	ValaCCodeIdentifier* _tmp171_;
	ValaCCodeIdentifier* _tmp172_;
	ValaCCodeFunction* _tmp173_;
	ValaCCodeFunction* _tmp174_;
	ValaCCodeFunctionCall* _tmp175_;
	ValaCCodeFunction* _tmp176_;
	ValaCCodeFunction* _tmp177_;
	ValaCCodeIdentifier* _tmp178_;
	ValaCCodeIdentifier* _tmp179_;
	ValaCCodeMemberAccess* _tmp180_;
	ValaCCodeFunction* _tmp181_;
	ValaCCodeFunction* _tmp182_;
	ValaCCodeIdentifier* _tmp183_;
	ValaCCodeIdentifier* _tmp184_;
	ValaCCodeMemberAccess* _tmp185_;
	ValaCCodeFunction* _tmp186_;
	ValaCCodeFunction* _tmp187_;
	ValaCCodeFunction* _tmp188_;
	ValaCCodeFunction* _tmp189_;
	ValaCCodeIdentifier* _tmp190_;
	ValaCCodeIdentifier* _tmp191_;
	ValaCCodeMemberAccess* _tmp192_;
	ValaCCodeFunction* _tmp193_;
	ValaCCodeFunction* _tmp194_;
	ValaCCodeIdentifier* _tmp195_;
	ValaCCodeIdentifier* _tmp196_;
	ValaCCodeMemberAccess* _tmp197_;
	ValaCCodeFunction* _tmp198_;
	ValaCCodeFunction* _tmp199_;
	ValaCCodeIdentifier* _tmp200_;
	ValaCCodeIdentifier* _tmp201_;
	ValaCCodeIdentifier* _tmp202_;
	ValaCCodeIdentifier* _tmp203_;
	ValaCCodeIdentifier* _tmp204_;
	ValaCCodeIdentifier* _tmp205_;
	ValaCCodeMemberAccess* _tmp206_;
	ValaCCodeMemberAccess* _tmp207_;
	ValaCCodeConditionalExpression* _tmp208_;
	ValaCCodeConditionalExpression* _tmp209_;
	ValaList* _tmp210_;
	ValaDataType* _tmp211_;
	gchar* _tmp212_ = NULL;
	gchar* _tmp213_;
	ValaCCodeCastExpression* _tmp214_;
	ValaCCodeCastExpression* _tmp215_;
	ValaCCodeCastExpression* c_assign_rhs;
	ValaCCodeFunction* _tmp216_;
	ValaCCodeFunction* _tmp217_;
	ValaCCodeIdentifier* _tmp218_;
	ValaCCodeIdentifier* _tmp219_;
	ValaCCodeCastExpression* _tmp220_;
	ValaCCodeIdentifier* _tmp221_;
	ValaCCodeIdentifier* _tmp222_;
	ValaCCodeFunctionCall* _tmp223_;
	ValaCCodeFunctionCall* _tmp224_;
	ValaCCodeIdentifier* _tmp225_;
	ValaCCodeIdentifier* _tmp226_;
	ValaCCodeFunctionCall* _tmp315_;
	ValaCCodeIdentifier* _tmp316_;
	ValaCCodeIdentifier* _tmp317_;
	gboolean _tmp318_ = FALSE;
	ValaDataType* _tmp319_;
	ValaTypeSymbol* _tmp320_;
	ValaTypeSymbol* _tmp321_;
	gboolean _tmp324_;
	ValaCCodeFile* _tmp396_;
	ValaCCodeFunction* _tmp397_;
	ValaCCodeFile* _tmp398_;
	ValaCCodeFunction* _tmp399_;
	ValaSet* _tmp400_;
	const gchar* _tmp401_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (params != NULL);
	g_return_if_fail (return_type != NULL);
	_tmp0_ = params;
	_tmp1_ = return_type;
	_tmp2_ = vala_gsignal_module_get_marshaller_signature (self, _tmp0_, _tmp1_);
	_g_free0 (signature);
	signature = _tmp2_;
	_tmp4_ = ((ValaCCodeBaseModule*) self)->predefined_marshal_set;
	_tmp5_ = signature;
	_tmp6_ = vala_collection_contains ((ValaCollection*) _tmp4_, _tmp5_);
	if (_tmp6_) {
		_tmp3_ = TRUE;
	} else {
		ValaSet* _tmp7_;
		const gchar* _tmp8_;
		gboolean _tmp9_ = FALSE;
		_tmp7_ = ((ValaCCodeBaseModule*) self)->user_marshal_set;
		_tmp8_ = signature;
		_tmp9_ = vala_collection_contains ((ValaCollection*) _tmp7_, _tmp8_);
		_tmp3_ = _tmp9_;
	}
	_tmp10_ = _tmp3_;
	if (_tmp10_) {
		_g_free0 (signature);
		return;
	}
	_tmp11_ = params;
	_tmp12_ = return_type;
	_tmp13_ = vala_gsignal_module_get_marshaller_function (self, _tmp11_, _tmp12_, NULL);
	_tmp14_ = _tmp13_;
	_tmp15_ = vala_ccode_function_new (_tmp14_, "void");
	_tmp16_ = _tmp15_;
	_g_free0 (_tmp14_);
	signal_marshaller = _tmp16_;
	_tmp17_ = signal_marshaller;
	vala_ccode_function_set_modifiers (_tmp17_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp18_ = signal_marshaller;
	_tmp19_ = vala_ccode_parameter_new ("closure", "GClosure *");
	_tmp20_ = _tmp19_;
	vala_ccode_function_add_parameter (_tmp18_, _tmp20_);
	_vala_ccode_node_unref0 (_tmp20_);
	_tmp21_ = signal_marshaller;
	_tmp22_ = vala_ccode_parameter_new ("return_value", "GValue *");
	_tmp23_ = _tmp22_;
	vala_ccode_function_add_parameter (_tmp21_, _tmp23_);
	_vala_ccode_node_unref0 (_tmp23_);
	_tmp24_ = signal_marshaller;
	_tmp25_ = vala_ccode_parameter_new ("n_param_values", "guint");
	_tmp26_ = _tmp25_;
	vala_ccode_function_add_parameter (_tmp24_, _tmp26_);
	_vala_ccode_node_unref0 (_tmp26_);
	_tmp27_ = signal_marshaller;
	_tmp28_ = vala_ccode_parameter_new ("param_values", "const GValue *");
	_tmp29_ = _tmp28_;
	vala_ccode_function_add_parameter (_tmp27_, _tmp29_);
	_vala_ccode_node_unref0 (_tmp29_);
	_tmp30_ = signal_marshaller;
	_tmp31_ = vala_ccode_parameter_new ("invocation_hint", "gpointer");
	_tmp32_ = _tmp31_;
	vala_ccode_function_add_parameter (_tmp30_, _tmp32_);
	_vala_ccode_node_unref0 (_tmp32_);
	_tmp33_ = signal_marshaller;
	_tmp34_ = vala_ccode_parameter_new ("marshal_data", "gpointer");
	_tmp35_ = _tmp34_;
	vala_ccode_function_add_parameter (_tmp33_, _tmp35_);
	_vala_ccode_node_unref0 (_tmp35_);
	_tmp36_ = signal_marshaller;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp36_);
	_tmp37_ = params;
	_tmp38_ = return_type;
	_tmp39_ = vala_gsignal_module_get_marshaller_function (self, _tmp37_, _tmp38_, "GMarshalFunc");
	_tmp40_ = _tmp39_;
	_tmp41_ = vala_ccode_function_declarator_new (_tmp40_);
	_tmp42_ = _tmp41_;
	_g_free0 (_tmp40_);
	callback_decl = _tmp42_;
	_tmp43_ = callback_decl;
	_tmp44_ = vala_ccode_parameter_new ("data1", "gpointer");
	_tmp45_ = _tmp44_;
	vala_ccode_function_declarator_add_parameter (_tmp43_, _tmp45_);
	_vala_ccode_node_unref0 (_tmp45_);
	n_params = 1;
	{
		ValaList* _tmp46_;
		ValaList* _tmp47_;
		ValaList* _p_list;
		ValaList* _tmp48_;
		gint _tmp49_;
		gint _tmp50_;
		gint _p_size;
		gint _p_index;
		_tmp46_ = params;
		_tmp47_ = _vala_iterable_ref0 (_tmp46_);
		_p_list = _tmp47_;
		_tmp48_ = _p_list;
		_tmp49_ = vala_collection_get_size ((ValaCollection*) _tmp48_);
		_tmp50_ = _tmp49_;
		_p_size = _tmp50_;
		_p_index = -1;
		while (TRUE) {
			gint _tmp51_;
			gint _tmp52_;
			gint _tmp53_;
			ValaList* _tmp54_;
			gint _tmp55_;
			gpointer _tmp56_ = NULL;
			ValaParameter* p;
			ValaCCodeFunctionDeclarator* _tmp57_;
			gint _tmp58_;
			gchar* _tmp59_ = NULL;
			gchar* _tmp60_;
			ValaParameter* _tmp61_;
			gchar* _tmp62_ = NULL;
			gchar* _tmp63_;
			ValaCCodeParameter* _tmp64_;
			ValaCCodeParameter* _tmp65_;
			gint _tmp66_;
			ValaParameter* _tmp67_;
			ValaDataType* _tmp68_;
			ValaDataType* _tmp69_;
			gboolean _tmp70_ = FALSE;
			_tmp51_ = _p_index;
			_p_index = _tmp51_ + 1;
			_tmp52_ = _p_index;
			_tmp53_ = _p_size;
			if (!(_tmp52_ < _tmp53_)) {
				break;
			}
			_tmp54_ = _p_list;
			_tmp55_ = _p_index;
			_tmp56_ = vala_list_get (_tmp54_, _tmp55_);
			p = (ValaParameter*) _tmp56_;
			_tmp57_ = callback_decl;
			_tmp58_ = n_params;
			_tmp59_ = g_strdup_printf ("arg_%d", _tmp58_);
			_tmp60_ = _tmp59_;
			_tmp61_ = p;
			_tmp62_ = vala_gsignal_module_get_value_type_name_from_parameter (self, _tmp61_);
			_tmp63_ = _tmp62_;
			_tmp64_ = vala_ccode_parameter_new (_tmp60_, _tmp63_);
			_tmp65_ = _tmp64_;
			vala_ccode_function_declarator_add_parameter (_tmp57_, _tmp65_);
			_vala_ccode_node_unref0 (_tmp65_);
			_g_free0 (_tmp63_);
			_g_free0 (_tmp60_);
			_tmp66_ = n_params;
			n_params = _tmp66_ + 1;
			_tmp67_ = p;
			_tmp68_ = vala_variable_get_variable_type ((ValaVariable*) _tmp67_);
			_tmp69_ = _tmp68_;
			_tmp70_ = vala_data_type_is_array (_tmp69_);
			if (_tmp70_) {
				ValaCCodeFunctionDeclarator* _tmp71_;
				gint _tmp72_;
				gchar* _tmp73_ = NULL;
				gchar* _tmp74_;
				ValaCCodeParameter* _tmp75_;
				ValaCCodeParameter* _tmp76_;
				gint _tmp77_;
				_tmp71_ = callback_decl;
				_tmp72_ = n_params;
				_tmp73_ = g_strdup_printf ("arg_%d", _tmp72_);
				_tmp74_ = _tmp73_;
				_tmp75_ = vala_ccode_parameter_new (_tmp74_, "gint");
				_tmp76_ = _tmp75_;
				vala_ccode_function_declarator_add_parameter (_tmp71_, _tmp76_);
				_vala_ccode_node_unref0 (_tmp76_);
				_g_free0 (_tmp74_);
				_tmp77_ = n_params;
				n_params = _tmp77_ + 1;
			}
			_vala_code_node_unref0 (p);
		}
		_vala_iterable_unref0 (_p_list);
	}
	_tmp78_ = callback_decl;
	_tmp79_ = vala_ccode_parameter_new ("data2", "gpointer");
	_tmp80_ = _tmp79_;
	vala_ccode_function_declarator_add_parameter (_tmp78_, _tmp80_);
	_vala_ccode_node_unref0 (_tmp80_);
	_tmp81_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp82_ = _tmp81_;
	_tmp83_ = return_type;
	_tmp84_ = vala_gsignal_module_get_value_type_name_from_type_reference (self, _tmp83_);
	_tmp85_ = _tmp84_;
	_tmp86_ = callback_decl;
	_tmp87_ = vala_ccode_type_definition_new (_tmp85_, (ValaCCodeDeclarator*) _tmp86_);
	_tmp88_ = _tmp87_;
	vala_ccode_function_add_statement (_tmp82_, (ValaCCodeNode*) _tmp88_);
	_vala_ccode_node_unref0 (_tmp88_);
	_g_free0 (_tmp85_);
	_tmp89_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp90_ = _tmp89_;
	_tmp91_ = params;
	_tmp92_ = return_type;
	_tmp93_ = vala_gsignal_module_get_marshaller_function (self, _tmp91_, _tmp92_, "GMarshalFunc");
	_tmp94_ = _tmp93_;
	_tmp95_ = vala_ccode_variable_declarator_new ("callback", NULL, NULL);
	_tmp96_ = _tmp95_;
	vala_ccode_function_add_declaration (_tmp90_, _tmp94_, (ValaCCodeDeclarator*) _tmp96_, VALA_CCODE_MODIFIERS_REGISTER);
	_vala_ccode_node_unref0 (_tmp96_);
	_g_free0 (_tmp94_);
	_tmp97_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp98_ = _tmp97_;
	_tmp99_ = vala_ccode_identifier_new ("closure");
	_tmp100_ = _tmp99_;
	_tmp101_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp100_, "GCClosure *");
	_tmp102_ = _tmp101_;
	_tmp103_ = vala_ccode_variable_declarator_new ("cc", (ValaCCodeExpression*) _tmp102_, NULL);
	_tmp104_ = _tmp103_;
	vala_ccode_function_add_declaration (_tmp98_, "GCClosure *", (ValaCCodeDeclarator*) _tmp104_, VALA_CCODE_MODIFIERS_REGISTER);
	_vala_ccode_node_unref0 (_tmp104_);
	_vala_ccode_node_unref0 (_tmp102_);
	_vala_ccode_node_unref0 (_tmp100_);
	_tmp105_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp106_ = _tmp105_;
	_tmp107_ = vala_ccode_variable_declarator_new ("data1", NULL, NULL);
	_tmp108_ = _tmp107_;
	vala_ccode_function_add_declaration (_tmp106_, "gpointer", (ValaCCodeDeclarator*) _tmp108_, VALA_CCODE_MODIFIERS_REGISTER);
	_vala_ccode_node_unref0 (_tmp108_);
	_tmp109_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp110_ = _tmp109_;
	_tmp111_ = vala_ccode_variable_declarator_new ("data2", NULL, NULL);
	_tmp112_ = _tmp111_;
	vala_ccode_function_add_declaration (_tmp110_, "gpointer", (ValaCCodeDeclarator*) _tmp112_, VALA_CCODE_MODIFIERS_REGISTER);
	_vala_ccode_node_unref0 (_tmp112_);
	_tmp114_ = return_type;
	_tmp115_ = vala_data_type_get_data_type (_tmp114_);
	_tmp116_ = _tmp115_;
	if (_tmp116_ != NULL) {
		_tmp113_ = TRUE;
	} else {
		ValaDataType* _tmp117_;
		gboolean _tmp118_ = FALSE;
		_tmp117_ = return_type;
		_tmp118_ = vala_data_type_is_array (_tmp117_);
		_tmp113_ = _tmp118_;
	}
	_tmp119_ = _tmp113_;
	if (_tmp119_) {
		ValaCCodeFunction* _tmp120_;
		ValaCCodeFunction* _tmp121_;
		ValaDataType* _tmp122_;
		gchar* _tmp123_ = NULL;
		gchar* _tmp124_;
		ValaCCodeVariableDeclarator* _tmp125_;
		ValaCCodeVariableDeclarator* _tmp126_;
		ValaCCodeIdentifier* _tmp127_;
		ValaCCodeIdentifier* _tmp128_;
		ValaCCodeFunctionCall* _tmp129_;
		ValaCCodeFunctionCall* _tmp130_;
		ValaCCodeIdentifier* _tmp131_;
		ValaCCodeIdentifier* _tmp132_;
		ValaCCodeConstant* _tmp133_;
		ValaCCodeConstant* _tmp134_;
		ValaCCodeBinaryExpression* _tmp135_;
		ValaCCodeBinaryExpression* _tmp136_;
		ValaCCodeFunction* _tmp137_;
		ValaCCodeFunction* _tmp138_;
		ValaCCodeFunctionCall* _tmp139_;
		_tmp120_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp121_ = _tmp120_;
		_tmp122_ = return_type;
		_tmp123_ = vala_gsignal_module_get_value_type_name_from_type_reference (self, _tmp122_);
		_tmp124_ = _tmp123_;
		_tmp125_ = vala_ccode_variable_declarator_new ("v_return", NULL, NULL);
		_tmp126_ = _tmp125_;
		vala_ccode_function_add_declaration (_tmp121_, _tmp124_, (ValaCCodeDeclarator*) _tmp126_, 0);
		_vala_ccode_node_unref0 (_tmp126_);
		_g_free0 (_tmp124_);
		_tmp127_ = vala_ccode_identifier_new ("g_return_if_fail");
		_tmp128_ = _tmp127_;
		_tmp129_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp128_);
		_vala_ccode_node_unref0 (fc);
		fc = _tmp129_;
		_vala_ccode_node_unref0 (_tmp128_);
		_tmp130_ = fc;
		_tmp131_ = vala_ccode_identifier_new ("return_value");
		_tmp132_ = _tmp131_;
		_tmp133_ = vala_ccode_constant_new ("NULL");
		_tmp134_ = _tmp133_;
		_tmp135_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) _tmp132_, (ValaCCodeExpression*) _tmp134_);
		_tmp136_ = _tmp135_;
		vala_ccode_function_call_add_argument (_tmp130_, (ValaCCodeExpression*) _tmp136_);
		_vala_ccode_node_unref0 (_tmp136_);
		_vala_ccode_node_unref0 (_tmp134_);
		_vala_ccode_node_unref0 (_tmp132_);
		_tmp137_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp138_ = _tmp137_;
		_tmp139_ = fc;
		vala_ccode_function_add_expression (_tmp138_, (ValaCCodeExpression*) _tmp139_);
	}
	_tmp140_ = vala_ccode_identifier_new ("g_return_if_fail");
	_tmp141_ = _tmp140_;
	_tmp142_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp141_);
	_vala_ccode_node_unref0 (fc);
	fc = _tmp142_;
	_vala_ccode_node_unref0 (_tmp141_);
	_tmp143_ = fc;
	_tmp144_ = vala_ccode_identifier_new ("n_param_values");
	_tmp145_ = _tmp144_;
	_tmp146_ = n_params;
	_tmp147_ = g_strdup_printf ("%i", _tmp146_);
	_tmp148_ = _tmp147_;
	_tmp149_ = vala_ccode_constant_new (_tmp148_);
	_tmp150_ = _tmp149_;
	_tmp151_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp145_, (ValaCCodeExpression*) _tmp150_);
	_tmp152_ = _tmp151_;
	vala_ccode_function_call_add_argument (_tmp143_, (ValaCCodeExpression*) _tmp152_);
	_vala_ccode_node_unref0 (_tmp152_);
	_vala_ccode_node_unref0 (_tmp150_);
	_g_free0 (_tmp148_);
	_vala_ccode_node_unref0 (_tmp145_);
	_tmp153_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp154_ = _tmp153_;
	_tmp155_ = fc;
	vala_ccode_function_add_expression (_tmp154_, (ValaCCodeExpression*) _tmp155_);
	_tmp156_ = vala_ccode_identifier_new ("closure");
	_tmp157_ = _tmp156_;
	_tmp158_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp157_, "data", TRUE);
	_tmp159_ = _tmp158_;
	_vala_ccode_node_unref0 (_tmp157_);
	data = _tmp159_;
	_tmp160_ = vala_ccode_identifier_new ("param_values");
	_tmp161_ = _tmp160_;
	_tmp162_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp161_, "data[0]", TRUE);
	_tmp163_ = _tmp162_;
	_tmp164_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp163_, "v_pointer", FALSE);
	_tmp165_ = _tmp164_;
	_vala_ccode_node_unref0 (_tmp163_);
	_vala_ccode_node_unref0 (_tmp161_);
	param = _tmp165_;
	_tmp166_ = vala_ccode_constant_new ("G_CCLOSURE_SWAP_DATA");
	_tmp167_ = _tmp166_;
	_tmp168_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp167_);
	_tmp169_ = _tmp168_;
	_vala_ccode_node_unref0 (_tmp167_);
	cond = _tmp169_;
	_tmp170_ = cond;
	_tmp171_ = vala_ccode_identifier_new ("closure");
	_tmp172_ = _tmp171_;
	vala_ccode_function_call_add_argument (_tmp170_, (ValaCCodeExpression*) _tmp172_);
	_vala_ccode_node_unref0 (_tmp172_);
	_tmp173_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp174_ = _tmp173_;
	_tmp175_ = cond;
	vala_ccode_function_open_if (_tmp174_, (ValaCCodeExpression*) _tmp175_);
	_tmp176_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp177_ = _tmp176_;
	_tmp178_ = vala_ccode_identifier_new ("data1");
	_tmp179_ = _tmp178_;
	_tmp180_ = data;
	vala_ccode_function_add_assignment (_tmp177_, (ValaCCodeExpression*) _tmp179_, (ValaCCodeExpression*) _tmp180_);
	_vala_ccode_node_unref0 (_tmp179_);
	_tmp181_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp182_ = _tmp181_;
	_tmp183_ = vala_ccode_identifier_new ("data2");
	_tmp184_ = _tmp183_;
	_tmp185_ = param;
	vala_ccode_function_add_assignment (_tmp182_, (ValaCCodeExpression*) _tmp184_, (ValaCCodeExpression*) _tmp185_);
	_vala_ccode_node_unref0 (_tmp184_);
	_tmp186_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp187_ = _tmp186_;
	vala_ccode_function_add_else (_tmp187_);
	_tmp188_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp189_ = _tmp188_;
	_tmp190_ = vala_ccode_identifier_new ("data1");
	_tmp191_ = _tmp190_;
	_tmp192_ = param;
	vala_ccode_function_add_assignment (_tmp189_, (ValaCCodeExpression*) _tmp191_, (ValaCCodeExpression*) _tmp192_);
	_vala_ccode_node_unref0 (_tmp191_);
	_tmp193_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp194_ = _tmp193_;
	_tmp195_ = vala_ccode_identifier_new ("data2");
	_tmp196_ = _tmp195_;
	_tmp197_ = data;
	vala_ccode_function_add_assignment (_tmp194_, (ValaCCodeExpression*) _tmp196_, (ValaCCodeExpression*) _tmp197_);
	_vala_ccode_node_unref0 (_tmp196_);
	_tmp198_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp199_ = _tmp198_;
	vala_ccode_function_close (_tmp199_);
	_tmp200_ = vala_ccode_identifier_new ("marshal_data");
	_tmp201_ = _tmp200_;
	_tmp202_ = vala_ccode_identifier_new ("marshal_data");
	_tmp203_ = _tmp202_;
	_tmp204_ = vala_ccode_identifier_new ("cc");
	_tmp205_ = _tmp204_;
	_tmp206_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp205_, "callback", TRUE);
	_tmp207_ = _tmp206_;
	_tmp208_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp201_, (ValaCCodeExpression*) _tmp203_, (ValaCCodeExpression*) _tmp207_);
	_tmp209_ = _tmp208_;
	_tmp210_ = params;
	_tmp211_ = return_type;
	_tmp212_ = vala_gsignal_module_get_marshaller_function (self, _tmp210_, _tmp211_, "GMarshalFunc");
	_tmp213_ = _tmp212_;
	_tmp214_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp209_, _tmp213_);
	_tmp215_ = _tmp214_;
	_g_free0 (_tmp213_);
	_vala_ccode_node_unref0 (_tmp209_);
	_vala_ccode_node_unref0 (_tmp207_);
	_vala_ccode_node_unref0 (_tmp205_);
	_vala_ccode_node_unref0 (_tmp203_);
	_vala_ccode_node_unref0 (_tmp201_);
	c_assign_rhs = _tmp215_;
	_tmp216_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp217_ = _tmp216_;
	_tmp218_ = vala_ccode_identifier_new ("callback");
	_tmp219_ = _tmp218_;
	_tmp220_ = c_assign_rhs;
	vala_ccode_function_add_assignment (_tmp217_, (ValaCCodeExpression*) _tmp219_, (ValaCCodeExpression*) _tmp220_);
	_vala_ccode_node_unref0 (_tmp219_);
	_tmp221_ = vala_ccode_identifier_new ("callback");
	_tmp222_ = _tmp221_;
	_tmp223_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp222_);
	_vala_ccode_node_unref0 (fc);
	fc = _tmp223_;
	_vala_ccode_node_unref0 (_tmp222_);
	_tmp224_ = fc;
	_tmp225_ = vala_ccode_identifier_new ("data1");
	_tmp226_ = _tmp225_;
	vala_ccode_function_call_add_argument (_tmp224_, (ValaCCodeExpression*) _tmp226_);
	_vala_ccode_node_unref0 (_tmp226_);
	i = 1;
	{
		ValaList* _tmp227_;
		ValaList* _tmp228_;
		ValaList* _p_list;
		ValaList* _tmp229_;
		gint _tmp230_;
		gint _tmp231_;
		gint _p_size;
		gint _p_index;
		_tmp227_ = params;
		_tmp228_ = _vala_iterable_ref0 (_tmp227_);
		_p_list = _tmp228_;
		_tmp229_ = _p_list;
		_tmp230_ = vala_collection_get_size ((ValaCollection*) _tmp229_);
		_tmp231_ = _tmp230_;
		_p_size = _tmp231_;
		_p_index = -1;
		while (TRUE) {
			gint _tmp232_;
			gint _tmp233_;
			gint _tmp234_;
			ValaList* _tmp235_;
			gint _tmp236_;
			gpointer _tmp237_ = NULL;
			ValaParameter* p;
			gchar* get_value_function = NULL;
			ValaParameter* _tmp238_;
			ValaDataType* _tmp239_;
			ValaDataType* _tmp240_;
			gboolean _tmp241_ = FALSE;
			gboolean is_array;
			ValaParameter* _tmp242_;
			ValaParameterDirection _tmp243_;
			ValaParameterDirection _tmp244_;
			const gchar* _tmp280_;
			ValaCCodeIdentifier* _tmp281_;
			ValaCCodeIdentifier* _tmp282_;
			ValaCCodeFunctionCall* _tmp283_;
			ValaCCodeFunctionCall* _tmp284_;
			ValaCCodeFunctionCall* inner_fc;
			ValaCCodeFunctionCall* _tmp285_;
			ValaCCodeIdentifier* _tmp286_;
			ValaCCodeIdentifier* _tmp287_;
			gint _tmp288_;
			gchar* _tmp289_ = NULL;
			gchar* _tmp290_;
			ValaCCodeIdentifier* _tmp291_;
			ValaCCodeIdentifier* _tmp292_;
			ValaCCodeBinaryExpression* _tmp293_;
			ValaCCodeBinaryExpression* _tmp294_;
			ValaCCodeFunctionCall* _tmp295_;
			ValaCCodeFunctionCall* _tmp296_;
			gint _tmp297_;
			gboolean _tmp298_;
			_tmp232_ = _p_index;
			_p_index = _tmp232_ + 1;
			_tmp233_ = _p_index;
			_tmp234_ = _p_size;
			if (!(_tmp233_ < _tmp234_)) {
				break;
			}
			_tmp235_ = _p_list;
			_tmp236_ = _p_index;
			_tmp237_ = vala_list_get (_tmp235_, _tmp236_);
			p = (ValaParameter*) _tmp237_;
			_tmp238_ = p;
			_tmp239_ = vala_variable_get_variable_type ((ValaVariable*) _tmp238_);
			_tmp240_ = _tmp239_;
			_tmp241_ = vala_data_type_is_array (_tmp240_);
			is_array = _tmp241_;
			_tmp242_ = p;
			_tmp243_ = vala_parameter_get_direction (_tmp242_);
			_tmp244_ = _tmp243_;
			if (_tmp244_ != VALA_PARAMETER_DIRECTION_IN) {
				gchar* _tmp245_;
				_tmp245_ = g_strdup ("g_value_get_pointer");
				_g_free0 (get_value_function);
				get_value_function = _tmp245_;
			} else {
				gboolean _tmp246_;
				_tmp246_ = is_array;
				if (_tmp246_) {
					ValaParameter* _tmp247_;
					ValaDataType* _tmp248_;
					ValaDataType* _tmp249_;
					ValaDataType* _tmp250_;
					ValaDataType* _tmp251_;
					ValaTypeSymbol* _tmp252_;
					ValaTypeSymbol* _tmp253_;
					ValaDataType* _tmp254_;
					ValaTypeSymbol* _tmp255_;
					ValaTypeSymbol* _tmp256_;
					_tmp247_ = p;
					_tmp248_ = vala_variable_get_variable_type ((ValaVariable*) _tmp247_);
					_tmp249_ = _tmp248_;
					_tmp250_ = vala_array_type_get_element_type (VALA_ARRAY_TYPE (_tmp249_));
					_tmp251_ = _tmp250_;
					_tmp252_ = vala_data_type_get_data_type (_tmp251_);
					_tmp253_ = _tmp252_;
					_tmp254_ = ((ValaCCodeBaseModule*) self)->string_type;
					_tmp255_ = vala_data_type_get_data_type (_tmp254_);
					_tmp256_ = _tmp255_;
					if (_tmp253_ == _tmp256_) {
						gchar* _tmp257_;
						_tmp257_ = g_strdup ("g_value_get_boxed");
						_g_free0 (get_value_function);
						get_value_function = _tmp257_;
					} else {
						gchar* _tmp258_;
						_tmp258_ = g_strdup ("g_value_get_pointer");
						_g_free0 (get_value_function);
						get_value_function = _tmp258_;
					}
				} else {
					gboolean _tmp259_ = FALSE;
					ValaParameter* _tmp260_;
					ValaDataType* _tmp261_;
					ValaDataType* _tmp262_;
					gboolean _tmp268_;
					_tmp260_ = p;
					_tmp261_ = vala_variable_get_variable_type ((ValaVariable*) _tmp260_);
					_tmp262_ = _tmp261_;
					if (VALA_IS_POINTER_TYPE (_tmp262_)) {
						_tmp259_ = TRUE;
					} else {
						ValaParameter* _tmp263_;
						ValaDataType* _tmp264_;
						ValaDataType* _tmp265_;
						ValaTypeParameter* _tmp266_;
						ValaTypeParameter* _tmp267_;
						_tmp263_ = p;
						_tmp264_ = vala_variable_get_variable_type ((ValaVariable*) _tmp263_);
						_tmp265_ = _tmp264_;
						_tmp266_ = vala_data_type_get_type_parameter (_tmp265_);
						_tmp267_ = _tmp266_;
						_tmp259_ = _tmp267_ != NULL;
					}
					_tmp268_ = _tmp259_;
					if (_tmp268_) {
						gchar* _tmp269_;
						_tmp269_ = g_strdup ("g_value_get_pointer");
						_g_free0 (get_value_function);
						get_value_function = _tmp269_;
					} else {
						ValaParameter* _tmp270_;
						ValaDataType* _tmp271_;
						ValaDataType* _tmp272_;
						_tmp270_ = p;
						_tmp271_ = vala_variable_get_variable_type ((ValaVariable*) _tmp270_);
						_tmp272_ = _tmp271_;
						if (VALA_IS_ERROR_TYPE (_tmp272_)) {
							gchar* _tmp273_;
							_tmp273_ = g_strdup ("g_value_get_pointer");
							_g_free0 (get_value_function);
							get_value_function = _tmp273_;
						} else {
							ValaParameter* _tmp274_;
							ValaDataType* _tmp275_;
							ValaDataType* _tmp276_;
							ValaTypeSymbol* _tmp277_;
							ValaTypeSymbol* _tmp278_;
							gchar* _tmp279_ = NULL;
							_tmp274_ = p;
							_tmp275_ = vala_variable_get_variable_type ((ValaVariable*) _tmp274_);
							_tmp276_ = _tmp275_;
							_tmp277_ = vala_data_type_get_data_type (_tmp276_);
							_tmp278_ = _tmp277_;
							_tmp279_ = vala_ccode_base_module_get_ccode_get_value_function ((ValaCodeNode*) _tmp278_);
							_g_free0 (get_value_function);
							get_value_function = _tmp279_;
						}
					}
				}
			}
			_tmp280_ = get_value_function;
			_tmp281_ = vala_ccode_identifier_new (_tmp280_);
			_tmp282_ = _tmp281_;
			_tmp283_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp282_);
			_tmp284_ = _tmp283_;
			_vala_ccode_node_unref0 (_tmp282_);
			inner_fc = _tmp284_;
			_tmp285_ = inner_fc;
			_tmp286_ = vala_ccode_identifier_new ("param_values");
			_tmp287_ = _tmp286_;
			_tmp288_ = i;
			_tmp289_ = g_strdup_printf ("%i", _tmp288_);
			_tmp290_ = _tmp289_;
			_tmp291_ = vala_ccode_identifier_new (_tmp290_);
			_tmp292_ = _tmp291_;
			_tmp293_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, (ValaCCodeExpression*) _tmp287_, (ValaCCodeExpression*) _tmp292_);
			_tmp294_ = _tmp293_;
			vala_ccode_function_call_add_argument (_tmp285_, (ValaCCodeExpression*) _tmp294_);
			_vala_ccode_node_unref0 (_tmp294_);
			_vala_ccode_node_unref0 (_tmp292_);
			_g_free0 (_tmp290_);
			_vala_ccode_node_unref0 (_tmp287_);
			_tmp295_ = fc;
			_tmp296_ = inner_fc;
			vala_ccode_function_call_add_argument (_tmp295_, (ValaCCodeExpression*) _tmp296_);
			_tmp297_ = i;
			i = _tmp297_ + 1;
			_tmp298_ = is_array;
			if (_tmp298_) {
				ValaCCodeIdentifier* _tmp299_;
				ValaCCodeIdentifier* _tmp300_;
				ValaCCodeFunctionCall* _tmp301_;
				ValaCCodeFunctionCall* _tmp302_;
				ValaCCodeIdentifier* _tmp303_;
				ValaCCodeIdentifier* _tmp304_;
				gint _tmp305_;
				gchar* _tmp306_ = NULL;
				gchar* _tmp307_;
				ValaCCodeIdentifier* _tmp308_;
				ValaCCodeIdentifier* _tmp309_;
				ValaCCodeBinaryExpression* _tmp310_;
				ValaCCodeBinaryExpression* _tmp311_;
				ValaCCodeFunctionCall* _tmp312_;
				ValaCCodeFunctionCall* _tmp313_;
				gint _tmp314_;
				_tmp299_ = vala_ccode_identifier_new ("g_value_get_int");
				_tmp300_ = _tmp299_;
				_tmp301_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp300_);
				_vala_ccode_node_unref0 (inner_fc);
				inner_fc = _tmp301_;
				_vala_ccode_node_unref0 (_tmp300_);
				_tmp302_ = inner_fc;
				_tmp303_ = vala_ccode_identifier_new ("param_values");
				_tmp304_ = _tmp303_;
				_tmp305_ = i;
				_tmp306_ = g_strdup_printf ("%i", _tmp305_);
				_tmp307_ = _tmp306_;
				_tmp308_ = vala_ccode_identifier_new (_tmp307_);
				_tmp309_ = _tmp308_;
				_tmp310_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, (ValaCCodeExpression*) _tmp304_, (ValaCCodeExpression*) _tmp309_);
				_tmp311_ = _tmp310_;
				vala_ccode_function_call_add_argument (_tmp302_, (ValaCCodeExpression*) _tmp311_);
				_vala_ccode_node_unref0 (_tmp311_);
				_vala_ccode_node_unref0 (_tmp309_);
				_g_free0 (_tmp307_);
				_vala_ccode_node_unref0 (_tmp304_);
				_tmp312_ = fc;
				_tmp313_ = inner_fc;
				vala_ccode_function_call_add_argument (_tmp312_, (ValaCCodeExpression*) _tmp313_);
				_tmp314_ = i;
				i = _tmp314_ + 1;
			}
			_vala_ccode_node_unref0 (inner_fc);
			_g_free0 (get_value_function);
			_vala_code_node_unref0 (p);
		}
		_vala_iterable_unref0 (_p_list);
	}
	_tmp315_ = fc;
	_tmp316_ = vala_ccode_identifier_new ("data2");
	_tmp317_ = _tmp316_;
	vala_ccode_function_call_add_argument (_tmp315_, (ValaCCodeExpression*) _tmp317_);
	_vala_ccode_node_unref0 (_tmp317_);
	_tmp319_ = return_type;
	_tmp320_ = vala_data_type_get_data_type (_tmp319_);
	_tmp321_ = _tmp320_;
	if (_tmp321_ != NULL) {
		_tmp318_ = TRUE;
	} else {
		ValaDataType* _tmp322_;
		gboolean _tmp323_ = FALSE;
		_tmp322_ = return_type;
		_tmp323_ = vala_data_type_is_array (_tmp322_);
		_tmp318_ = _tmp323_;
	}
	_tmp324_ = _tmp318_;
	if (_tmp324_) {
		ValaCCodeFunction* _tmp325_;
		ValaCCodeFunction* _tmp326_;
		ValaCCodeIdentifier* _tmp327_;
		ValaCCodeIdentifier* _tmp328_;
		ValaCCodeFunctionCall* _tmp329_;
		ValaCCodeFunctionCall* set_fc = NULL;
		ValaDataType* _tmp330_;
		gboolean _tmp331_ = FALSE;
		ValaCCodeFunctionCall* _tmp384_;
		ValaCCodeIdentifier* _tmp385_;
		ValaCCodeIdentifier* _tmp386_;
		ValaCCodeFunctionCall* _tmp387_;
		ValaCCodeIdentifier* _tmp388_;
		ValaCCodeIdentifier* _tmp389_;
		ValaCCodeFunction* _tmp390_;
		ValaCCodeFunction* _tmp391_;
		ValaCCodeFunctionCall* _tmp392_;
		_tmp325_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp326_ = _tmp325_;
		_tmp327_ = vala_ccode_identifier_new ("v_return");
		_tmp328_ = _tmp327_;
		_tmp329_ = fc;
		vala_ccode_function_add_assignment (_tmp326_, (ValaCCodeExpression*) _tmp328_, (ValaCCodeExpression*) _tmp329_);
		_vala_ccode_node_unref0 (_tmp328_);
		_tmp330_ = return_type;
		_tmp331_ = vala_data_type_is_array (_tmp330_);
		if (_tmp331_) {
			ValaDataType* _tmp332_;
			ValaDataType* _tmp333_;
			ValaDataType* _tmp334_;
			ValaTypeSymbol* _tmp335_;
			ValaTypeSymbol* _tmp336_;
			ValaDataType* _tmp337_;
			ValaTypeSymbol* _tmp338_;
			ValaTypeSymbol* _tmp339_;
			_tmp332_ = return_type;
			_tmp333_ = vala_array_type_get_element_type (VALA_ARRAY_TYPE (_tmp332_));
			_tmp334_ = _tmp333_;
			_tmp335_ = vala_data_type_get_data_type (_tmp334_);
			_tmp336_ = _tmp335_;
			_tmp337_ = ((ValaCCodeBaseModule*) self)->string_type;
			_tmp338_ = vala_data_type_get_data_type (_tmp337_);
			_tmp339_ = _tmp338_;
			if (_tmp336_ == _tmp339_) {
				ValaCCodeIdentifier* _tmp340_;
				ValaCCodeIdentifier* _tmp341_;
				ValaCCodeFunctionCall* _tmp342_;
				_tmp340_ = vala_ccode_identifier_new ("g_value_take_boxed");
				_tmp341_ = _tmp340_;
				_tmp342_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp341_);
				_vala_ccode_node_unref0 (set_fc);
				set_fc = _tmp342_;
				_vala_ccode_node_unref0 (_tmp341_);
			} else {
				ValaCCodeIdentifier* _tmp343_;
				ValaCCodeIdentifier* _tmp344_;
				ValaCCodeFunctionCall* _tmp345_;
				_tmp343_ = vala_ccode_identifier_new ("g_value_set_pointer");
				_tmp344_ = _tmp343_;
				_tmp345_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp344_);
				_vala_ccode_node_unref0 (set_fc);
				set_fc = _tmp345_;
				_vala_ccode_node_unref0 (_tmp344_);
			}
		} else {
			ValaDataType* _tmp346_;
			ValaTypeParameter* _tmp347_;
			ValaTypeParameter* _tmp348_;
			_tmp346_ = return_type;
			_tmp347_ = vala_data_type_get_type_parameter (_tmp346_);
			_tmp348_ = _tmp347_;
			if (_tmp348_ != NULL) {
				ValaCCodeIdentifier* _tmp349_;
				ValaCCodeIdentifier* _tmp350_;
				ValaCCodeFunctionCall* _tmp351_;
				_tmp349_ = vala_ccode_identifier_new ("g_value_set_pointer");
				_tmp350_ = _tmp349_;
				_tmp351_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp350_);
				_vala_ccode_node_unref0 (set_fc);
				set_fc = _tmp351_;
				_vala_ccode_node_unref0 (_tmp350_);
			} else {
				ValaDataType* _tmp352_;
				_tmp352_ = return_type;
				if (VALA_IS_ERROR_TYPE (_tmp352_)) {
					ValaCCodeIdentifier* _tmp353_;
					ValaCCodeIdentifier* _tmp354_;
					ValaCCodeFunctionCall* _tmp355_;
					_tmp353_ = vala_ccode_identifier_new ("g_value_set_pointer");
					_tmp354_ = _tmp353_;
					_tmp355_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp354_);
					_vala_ccode_node_unref0 (set_fc);
					set_fc = _tmp355_;
					_vala_ccode_node_unref0 (_tmp354_);
				} else {
					ValaDataType* _tmp356_;
					ValaTypeSymbol* _tmp357_;
					ValaTypeSymbol* _tmp358_;
					ValaDataType* _tmp359_;
					ValaTypeSymbol* _tmp360_;
					ValaTypeSymbol* _tmp361_;
					_tmp356_ = return_type;
					_tmp357_ = vala_data_type_get_data_type (_tmp356_);
					_tmp358_ = _tmp357_;
					_tmp359_ = ((ValaCCodeBaseModule*) self)->string_type;
					_tmp360_ = vala_data_type_get_data_type (_tmp359_);
					_tmp361_ = _tmp360_;
					if (_tmp358_ == _tmp361_) {
						ValaCCodeIdentifier* _tmp362_;
						ValaCCodeIdentifier* _tmp363_;
						ValaCCodeFunctionCall* _tmp364_;
						_tmp362_ = vala_ccode_identifier_new ("g_value_take_string");
						_tmp363_ = _tmp362_;
						_tmp364_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp363_);
						_vala_ccode_node_unref0 (set_fc);
						set_fc = _tmp364_;
						_vala_ccode_node_unref0 (_tmp363_);
					} else {
						gboolean _tmp365_ = FALSE;
						ValaDataType* _tmp366_;
						ValaTypeSymbol* _tmp367_;
						ValaTypeSymbol* _tmp368_;
						gboolean _tmp372_;
						_tmp366_ = return_type;
						_tmp367_ = vala_data_type_get_data_type (_tmp366_);
						_tmp368_ = _tmp367_;
						if (VALA_IS_CLASS (_tmp368_)) {
							_tmp365_ = TRUE;
						} else {
							ValaDataType* _tmp369_;
							ValaTypeSymbol* _tmp370_;
							ValaTypeSymbol* _tmp371_;
							_tmp369_ = return_type;
							_tmp370_ = vala_data_type_get_data_type (_tmp369_);
							_tmp371_ = _tmp370_;
							_tmp365_ = VALA_IS_INTERFACE (_tmp371_);
						}
						_tmp372_ = _tmp365_;
						if (_tmp372_) {
							ValaCCodeIdentifier* _tmp373_;
							ValaCCodeIdentifier* _tmp374_;
							ValaCCodeFunctionCall* _tmp375_;
							_tmp373_ = vala_ccode_identifier_new ("g_value_take_object");
							_tmp374_ = _tmp373_;
							_tmp375_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp374_);
							_vala_ccode_node_unref0 (set_fc);
							set_fc = _tmp375_;
							_vala_ccode_node_unref0 (_tmp374_);
						} else {
							ValaDataType* _tmp376_;
							ValaTypeSymbol* _tmp377_;
							ValaTypeSymbol* _tmp378_;
							gchar* _tmp379_ = NULL;
							gchar* _tmp380_;
							ValaCCodeIdentifier* _tmp381_;
							ValaCCodeIdentifier* _tmp382_;
							ValaCCodeFunctionCall* _tmp383_;
							_tmp376_ = return_type;
							_tmp377_ = vala_data_type_get_data_type (_tmp376_);
							_tmp378_ = _tmp377_;
							_tmp379_ = vala_ccode_base_module_get_ccode_set_value_function ((ValaCodeNode*) _tmp378_);
							_tmp380_ = _tmp379_;
							_tmp381_ = vala_ccode_identifier_new (_tmp380_);
							_tmp382_ = _tmp381_;
							_tmp383_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp382_);
							_vala_ccode_node_unref0 (set_fc);
							set_fc = _tmp383_;
							_vala_ccode_node_unref0 (_tmp382_);
							_g_free0 (_tmp380_);
						}
					}
				}
			}
		}
		_tmp384_ = set_fc;
		_tmp385_ = vala_ccode_identifier_new ("return_value");
		_tmp386_ = _tmp385_;
		vala_ccode_function_call_add_argument (_tmp384_, (ValaCCodeExpression*) _tmp386_);
		_vala_ccode_node_unref0 (_tmp386_);
		_tmp387_ = set_fc;
		_tmp388_ = vala_ccode_identifier_new ("v_return");
		_tmp389_ = _tmp388_;
		vala_ccode_function_call_add_argument (_tmp387_, (ValaCCodeExpression*) _tmp389_);
		_vala_ccode_node_unref0 (_tmp389_);
		_tmp390_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp391_ = _tmp390_;
		_tmp392_ = set_fc;
		vala_ccode_function_add_expression (_tmp391_, (ValaCCodeExpression*) _tmp392_);
		_vala_ccode_node_unref0 (set_fc);
	} else {
		ValaCCodeFunction* _tmp393_;
		ValaCCodeFunction* _tmp394_;
		ValaCCodeFunctionCall* _tmp395_;
		_tmp393_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp394_ = _tmp393_;
		_tmp395_ = fc;
		vala_ccode_function_add_expression (_tmp394_, (ValaCCodeExpression*) _tmp395_);
	}
	vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
	_tmp396_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp397_ = signal_marshaller;
	vala_ccode_file_add_function_declaration (_tmp396_, _tmp397_);
	_tmp398_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp399_ = signal_marshaller;
	vala_ccode_file_add_function (_tmp398_, _tmp399_);
	_tmp400_ = ((ValaCCodeBaseModule*) self)->user_marshal_set;
	_tmp401_ = signature;
	vala_collection_add ((ValaCollection*) _tmp400_, _tmp401_);
	_vala_ccode_node_unref0 (c_assign_rhs);
	_vala_ccode_node_unref0 (cond);
	_vala_ccode_node_unref0 (param);
	_vala_ccode_node_unref0 (data);
	_vala_ccode_node_unref0 (fc);
	_vala_ccode_node_unref0 (callback_decl);
	_vala_ccode_node_unref0 (signal_marshaller);
	_g_free0 (signature);
}


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 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 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 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;
}


static ValaCCodeFunctionCall* vala_gsignal_module_real_get_signal_creation (ValaCCodeBaseModule* base, ValaSignal* sig, ValaTypeSymbol* type) {
	ValaGSignalModule * self;
	ValaCCodeFunctionCall* result = NULL;
	ValaCCodeIdentifier* _tmp0_;
	ValaCCodeIdentifier* _tmp1_;
	ValaCCodeFunctionCall* _tmp2_;
	ValaCCodeFunctionCall* _tmp3_;
	ValaCCodeFunctionCall* csignew;
	ValaCCodeFunctionCall* _tmp4_;
	ValaSignal* _tmp5_;
	gchar* _tmp6_ = NULL;
	gchar* _tmp7_;
	gchar* _tmp8_ = NULL;
	gchar* _tmp9_;
	ValaCCodeConstant* _tmp10_;
	ValaCCodeConstant* _tmp11_;
	ValaCCodeFunctionCall* _tmp12_;
	ValaTypeSymbol* _tmp13_;
	gchar* _tmp14_ = NULL;
	gchar* _tmp15_;
	ValaCCodeIdentifier* _tmp16_;
	ValaCCodeIdentifier* _tmp17_;
	gchar** _tmp18_ = NULL;
	gchar** flags;
	gint flags_length1;
	gint _flags_size_;
	ValaSignal* _tmp19_;
	gchar* _tmp20_ = NULL;
	gchar* run_type;
	const gchar* _tmp21_;
	ValaSignal* _tmp29_;
	gboolean _tmp30_ = FALSE;
	ValaSignal* _tmp33_;
	gboolean _tmp34_ = FALSE;
	ValaSignal* _tmp37_;
	gboolean _tmp38_ = FALSE;
	ValaSignal* _tmp41_;
	gboolean _tmp42_ = FALSE;
	ValaCCodeFunctionCall* _tmp45_;
	gchar** _tmp46_;
	gint _tmp46__length1;
	gchar* _tmp47_ = NULL;
	gchar* _tmp48_;
	ValaCCodeConstant* _tmp49_;
	ValaCCodeConstant* _tmp50_;
	ValaSignal* _tmp51_;
	ValaMethod* _tmp52_;
	ValaMethod* _tmp53_;
	ValaCCodeFunctionCall* _tmp86_;
	ValaCCodeConstant* _tmp87_;
	ValaCCodeConstant* _tmp88_;
	ValaCCodeFunctionCall* _tmp89_;
	ValaCCodeConstant* _tmp90_;
	ValaCCodeConstant* _tmp91_;
	ValaSignal* _tmp92_;
	ValaList* _tmp93_ = NULL;
	ValaList* _tmp94_;
	ValaSignal* _tmp95_;
	ValaDataType* _tmp96_;
	ValaDataType* _tmp97_;
	gchar* _tmp98_ = NULL;
	gchar* _tmp99_;
	gchar* marshaller;
	const gchar* _tmp100_;
	ValaCCodeIdentifier* _tmp101_;
	ValaCCodeIdentifier* marshal_arg;
	ValaCCodeFunctionCall* _tmp102_;
	ValaCCodeIdentifier* _tmp103_;
	ValaSignal* _tmp104_;
	ValaList* _tmp105_ = NULL;
	ValaList* params;
	gboolean _tmp106_ = FALSE;
	ValaSignal* _tmp107_;
	ValaDataType* _tmp108_;
	ValaDataType* _tmp109_;
	gboolean _tmp115_;
	gint params_len;
	ValaCCodeFunctionCall* _tmp160_;
	gint _tmp161_;
	gchar* _tmp162_ = NULL;
	gchar* _tmp163_;
	ValaCCodeConstant* _tmp164_;
	ValaCCodeConstant* _tmp165_;
	ValaCCodeIdentifier* _tmp234_;
	const gchar* _tmp235_;
	self = (ValaGSignalModule*) base;
	g_return_val_if_fail (sig != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = vala_ccode_identifier_new ("g_signal_new");
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1_);
	_tmp3_ = _tmp2_;
	_vala_ccode_node_unref0 (_tmp1_);
	csignew = _tmp3_;
	_tmp4_ = csignew;
	_tmp5_ = sig;
	_tmp6_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = g_strdup_printf ("\"%s\"", _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_ccode_constant_new (_tmp9_);
	_tmp11_ = _tmp10_;
	vala_ccode_function_call_add_argument (_tmp4_, (ValaCCodeExpression*) _tmp11_);
	_vala_ccode_node_unref0 (_tmp11_);
	_g_free0 (_tmp9_);
	_g_free0 (_tmp7_);
	_tmp12_ = csignew;
	_tmp13_ = type;
	_tmp14_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = vala_ccode_identifier_new (_tmp15_);
	_tmp17_ = _tmp16_;
	vala_ccode_function_call_add_argument (_tmp12_, (ValaCCodeExpression*) _tmp17_);
	_vala_ccode_node_unref0 (_tmp17_);
	_g_free0 (_tmp15_);
	_tmp18_ = g_new0 (gchar*, 0 + 1);
	flags = _tmp18_;
	flags_length1 = 0;
	_flags_size_ = flags_length1;
	_tmp19_ = sig;
	_tmp20_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp19_, "Signal", "run");
	run_type = _tmp20_;
	_tmp21_ = run_type;
	if (g_strcmp0 (_tmp21_, "first") == 0) {
		gchar** _tmp22_;
		gint _tmp22__length1;
		gchar* _tmp23_;
		_tmp22_ = flags;
		_tmp22__length1 = flags_length1;
		_tmp23_ = g_strdup ("G_SIGNAL_RUN_FIRST");
		_vala_array_add1 (&flags, &flags_length1, &_flags_size_, _tmp23_);
	} else {
		const gchar* _tmp24_;
		_tmp24_ = run_type;
		if (g_strcmp0 (_tmp24_, "cleanup") == 0) {
			gchar** _tmp25_;
			gint _tmp25__length1;
			gchar* _tmp26_;
			_tmp25_ = flags;
			_tmp25__length1 = flags_length1;
			_tmp26_ = g_strdup ("G_SIGNAL_RUN_CLEANUP");
			_vala_array_add2 (&flags, &flags_length1, &_flags_size_, _tmp26_);
		} else {
			gchar** _tmp27_;
			gint _tmp27__length1;
			gchar* _tmp28_;
			_tmp27_ = flags;
			_tmp27__length1 = flags_length1;
			_tmp28_ = g_strdup ("G_SIGNAL_RUN_LAST");
			_vala_array_add3 (&flags, &flags_length1, &_flags_size_, _tmp28_);
		}
	}
	_tmp29_ = sig;
	_tmp30_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp29_, "Signal", "detailed", FALSE);
	if (_tmp30_) {
		gchar** _tmp31_;
		gint _tmp31__length1;
		gchar* _tmp32_;
		_tmp31_ = flags;
		_tmp31__length1 = flags_length1;
		_tmp32_ = g_strdup ("G_SIGNAL_DETAILED");
		_vala_array_add4 (&flags, &flags_length1, &_flags_size_, _tmp32_);
	}
	_tmp33_ = sig;
	_tmp34_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp33_, "Signal", "no_recurse", FALSE);
	if (_tmp34_) {
		gchar** _tmp35_;
		gint _tmp35__length1;
		gchar* _tmp36_;
		_tmp35_ = flags;
		_tmp35__length1 = flags_length1;
		_tmp36_ = g_strdup ("G_SIGNAL_NO_RECURSE");
		_vala_array_add5 (&flags, &flags_length1, &_flags_size_, _tmp36_);
	}
	_tmp37_ = sig;
	_tmp38_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp37_, "Signal", "action", FALSE);
	if (_tmp38_) {
		gchar** _tmp39_;
		gint _tmp39__length1;
		gchar* _tmp40_;
		_tmp39_ = flags;
		_tmp39__length1 = flags_length1;
		_tmp40_ = g_strdup ("G_SIGNAL_ACTION");
		_vala_array_add6 (&flags, &flags_length1, &_flags_size_, _tmp40_);
	}
	_tmp41_ = sig;
	_tmp42_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp41_, "Signal", "no_hooks", FALSE);
	if (_tmp42_) {
		gchar** _tmp43_;
		gint _tmp43__length1;
		gchar* _tmp44_;
		_tmp43_ = flags;
		_tmp43__length1 = flags_length1;
		_tmp44_ = g_strdup ("G_SIGNAL_NO_HOOKS");
		_vala_array_add7 (&flags, &flags_length1, &_flags_size_, _tmp44_);
	}
	_tmp45_ = csignew;
	_tmp46_ = flags;
	_tmp46__length1 = flags_length1;
	_tmp47_ = g_strjoinv (" | ", _tmp46_);
	_tmp48_ = _tmp47_;
	_tmp49_ = vala_ccode_constant_new (_tmp48_);
	_tmp50_ = _tmp49_;
	vala_ccode_function_call_add_argument (_tmp45_, (ValaCCodeExpression*) _tmp50_);
	_vala_ccode_node_unref0 (_tmp50_);
	_g_free0 (_tmp48_);
	_tmp51_ = sig;
	_tmp52_ = vala_signal_get_default_handler (_tmp51_);
	_tmp53_ = _tmp52_;
	if (_tmp53_ == NULL) {
		ValaCCodeFunctionCall* _tmp54_;
		ValaCCodeConstant* _tmp55_;
		ValaCCodeConstant* _tmp56_;
		_tmp54_ = csignew;
		_tmp55_ = vala_ccode_constant_new ("0");
		_tmp56_ = _tmp55_;
		vala_ccode_function_call_add_argument (_tmp54_, (ValaCCodeExpression*) _tmp56_);
		_vala_ccode_node_unref0 (_tmp56_);
	} else {
		ValaCCodeIdentifier* _tmp57_;
		ValaCCodeIdentifier* _tmp58_;
		ValaCCodeFunctionCall* _tmp59_;
		ValaCCodeFunctionCall* _tmp60_;
		ValaCCodeFunctionCall* struct_offset;
		ValaTypeSymbol* _tmp61_;
		ValaCCodeFunctionCall* _tmp76_;
		ValaSignal* _tmp77_;
		ValaMethod* _tmp78_;
		ValaMethod* _tmp79_;
		gchar* _tmp80_ = NULL;
		gchar* _tmp81_;
		ValaCCodeIdentifier* _tmp82_;
		ValaCCodeIdentifier* _tmp83_;
		ValaCCodeFunctionCall* _tmp84_;
		ValaCCodeFunctionCall* _tmp85_;
		_tmp57_ = vala_ccode_identifier_new ("G_STRUCT_OFFSET");
		_tmp58_ = _tmp57_;
		_tmp59_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp58_);
		_tmp60_ = _tmp59_;
		_vala_ccode_node_unref0 (_tmp58_);
		struct_offset = _tmp60_;
		_tmp61_ = type;
		if (VALA_IS_CLASS (_tmp61_)) {
			ValaCCodeFunctionCall* _tmp62_;
			ValaTypeSymbol* _tmp63_;
			gchar* _tmp64_ = NULL;
			gchar* _tmp65_;
			gchar* _tmp66_ = NULL;
			gchar* _tmp67_;
			ValaCCodeIdentifier* _tmp68_;
			ValaCCodeIdentifier* _tmp69_;
			_tmp62_ = struct_offset;
			_tmp63_ = type;
			_tmp64_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp63_);
			_tmp65_ = _tmp64_;
			_tmp66_ = g_strdup_printf ("%sClass", _tmp65_);
			_tmp67_ = _tmp66_;
			_tmp68_ = vala_ccode_identifier_new (_tmp67_);
			_tmp69_ = _tmp68_;
			vala_ccode_function_call_add_argument (_tmp62_, (ValaCCodeExpression*) _tmp69_);
			_vala_ccode_node_unref0 (_tmp69_);
			_g_free0 (_tmp67_);
			_g_free0 (_tmp65_);
		} else {
			ValaCCodeFunctionCall* _tmp70_;
			ValaTypeSymbol* _tmp71_;
			gchar* _tmp72_ = NULL;
			gchar* _tmp73_;
			ValaCCodeIdentifier* _tmp74_;
			ValaCCodeIdentifier* _tmp75_;
			_tmp70_ = struct_offset;
			_tmp71_ = type;
			_tmp72_ = vala_ccode_base_module_get_ccode_type_name (VALA_INTERFACE (_tmp71_));
			_tmp73_ = _tmp72_;
			_tmp74_ = vala_ccode_identifier_new (_tmp73_);
			_tmp75_ = _tmp74_;
			vala_ccode_function_call_add_argument (_tmp70_, (ValaCCodeExpression*) _tmp75_);
			_vala_ccode_node_unref0 (_tmp75_);
			_g_free0 (_tmp73_);
		}
		_tmp76_ = struct_offset;
		_tmp77_ = sig;
		_tmp78_ = vala_signal_get_default_handler (_tmp77_);
		_tmp79_ = _tmp78_;
		_tmp80_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp79_);
		_tmp81_ = _tmp80_;
		_tmp82_ = vala_ccode_identifier_new (_tmp81_);
		_tmp83_ = _tmp82_;
		vala_ccode_function_call_add_argument (_tmp76_, (ValaCCodeExpression*) _tmp83_);
		_vala_ccode_node_unref0 (_tmp83_);
		_g_free0 (_tmp81_);
		_tmp84_ = csignew;
		_tmp85_ = struct_offset;
		vala_ccode_function_call_add_argument (_tmp84_, (ValaCCodeExpression*) _tmp85_);
		_vala_ccode_node_unref0 (struct_offset);
	}
	_tmp86_ = csignew;
	_tmp87_ = vala_ccode_constant_new ("NULL");
	_tmp88_ = _tmp87_;
	vala_ccode_function_call_add_argument (_tmp86_, (ValaCCodeExpression*) _tmp88_);
	_vala_ccode_node_unref0 (_tmp88_);
	_tmp89_ = csignew;
	_tmp90_ = vala_ccode_constant_new ("NULL");
	_tmp91_ = _tmp90_;
	vala_ccode_function_call_add_argument (_tmp89_, (ValaCCodeExpression*) _tmp91_);
	_vala_ccode_node_unref0 (_tmp91_);
	_tmp92_ = sig;
	_tmp93_ = vala_signal_get_parameters (_tmp92_);
	_tmp94_ = _tmp93_;
	_tmp95_ = sig;
	_tmp96_ = vala_signal_get_return_type (_tmp95_);
	_tmp97_ = _tmp96_;
	_tmp98_ = vala_gsignal_module_get_marshaller_function (self, _tmp94_, _tmp97_, NULL);
	_tmp99_ = _tmp98_;
	_vala_iterable_unref0 (_tmp94_);
	marshaller = _tmp99_;
	_tmp100_ = marshaller;
	_tmp101_ = vala_ccode_identifier_new (_tmp100_);
	marshal_arg = _tmp101_;
	_tmp102_ = csignew;
	_tmp103_ = marshal_arg;
	vala_ccode_function_call_add_argument (_tmp102_, (ValaCCodeExpression*) _tmp103_);
	_tmp104_ = sig;
	_tmp105_ = vala_signal_get_parameters (_tmp104_);
	params = _tmp105_;
	_tmp107_ = sig;
	_tmp108_ = vala_signal_get_return_type (_tmp107_);
	_tmp109_ = _tmp108_;
	if (VALA_IS_POINTER_TYPE (_tmp109_)) {
		_tmp106_ = TRUE;
	} else {
		ValaSignal* _tmp110_;
		ValaDataType* _tmp111_;
		ValaDataType* _tmp112_;
		ValaTypeParameter* _tmp113_;
		ValaTypeParameter* _tmp114_;
		_tmp110_ = sig;
		_tmp111_ = vala_signal_get_return_type (_tmp110_);
		_tmp112_ = _tmp111_;
		_tmp113_ = vala_data_type_get_type_parameter (_tmp112_);
		_tmp114_ = _tmp113_;
		_tmp106_ = _tmp114_ != NULL;
	}
	_tmp115_ = _tmp106_;
	if (_tmp115_) {
		ValaCCodeFunctionCall* _tmp116_;
		ValaCCodeConstant* _tmp117_;
		ValaCCodeConstant* _tmp118_;
		_tmp116_ = csignew;
		_tmp117_ = vala_ccode_constant_new ("G_TYPE_POINTER");
		_tmp118_ = _tmp117_;
		vala_ccode_function_call_add_argument (_tmp116_, (ValaCCodeExpression*) _tmp118_);
		_vala_ccode_node_unref0 (_tmp118_);
	} else {
		ValaSignal* _tmp119_;
		ValaDataType* _tmp120_;
		ValaDataType* _tmp121_;
		_tmp119_ = sig;
		_tmp120_ = vala_signal_get_return_type (_tmp119_);
		_tmp121_ = _tmp120_;
		if (VALA_IS_ERROR_TYPE (_tmp121_)) {
			ValaCCodeFunctionCall* _tmp122_;
			ValaCCodeConstant* _tmp123_;
			ValaCCodeConstant* _tmp124_;
			_tmp122_ = csignew;
			_tmp123_ = vala_ccode_constant_new ("G_TYPE_POINTER");
			_tmp124_ = _tmp123_;
			vala_ccode_function_call_add_argument (_tmp122_, (ValaCCodeExpression*) _tmp124_);
			_vala_ccode_node_unref0 (_tmp124_);
		} else {
			ValaSignal* _tmp125_;
			ValaDataType* _tmp126_;
			ValaDataType* _tmp127_;
			ValaTypeSymbol* _tmp128_;
			ValaTypeSymbol* _tmp129_;
			_tmp125_ = sig;
			_tmp126_ = vala_signal_get_return_type (_tmp125_);
			_tmp127_ = _tmp126_;
			_tmp128_ = vala_data_type_get_data_type (_tmp127_);
			_tmp129_ = _tmp128_;
			if (_tmp129_ == NULL) {
				ValaCCodeFunctionCall* _tmp130_;
				ValaCCodeConstant* _tmp131_;
				ValaCCodeConstant* _tmp132_;
				_tmp130_ = csignew;
				_tmp131_ = vala_ccode_constant_new ("G_TYPE_NONE");
				_tmp132_ = _tmp131_;
				vala_ccode_function_call_add_argument (_tmp130_, (ValaCCodeExpression*) _tmp132_);
				_vala_ccode_node_unref0 (_tmp132_);
			} else {
				ValaCCodeFunctionCall* _tmp133_;
				ValaSignal* _tmp134_;
				ValaDataType* _tmp135_;
				ValaDataType* _tmp136_;
				ValaTypeSymbol* _tmp137_;
				ValaTypeSymbol* _tmp138_;
				gchar* _tmp139_ = NULL;
				gchar* _tmp140_;
				ValaCCodeConstant* _tmp141_;
				ValaCCodeConstant* _tmp142_;
				_tmp133_ = csignew;
				_tmp134_ = sig;
				_tmp135_ = vala_signal_get_return_type (_tmp134_);
				_tmp136_ = _tmp135_;
				_tmp137_ = vala_data_type_get_data_type (_tmp136_);
				_tmp138_ = _tmp137_;
				_tmp139_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp138_);
				_tmp140_ = _tmp139_;
				_tmp141_ = vala_ccode_constant_new (_tmp140_);
				_tmp142_ = _tmp141_;
				vala_ccode_function_call_add_argument (_tmp133_, (ValaCCodeExpression*) _tmp142_);
				_vala_ccode_node_unref0 (_tmp142_);
				_g_free0 (_tmp140_);
			}
		}
	}
	params_len = 0;
	{
		ValaList* _tmp143_;
		ValaList* _tmp144_;
		ValaList* _param_list;
		ValaList* _tmp145_;
		gint _tmp146_;
		gint _tmp147_;
		gint _param_size;
		gint _param_index;
		_tmp143_ = params;
		_tmp144_ = _vala_iterable_ref0 (_tmp143_);
		_param_list = _tmp144_;
		_tmp145_ = _param_list;
		_tmp146_ = vala_collection_get_size ((ValaCollection*) _tmp145_);
		_tmp147_ = _tmp146_;
		_param_size = _tmp147_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp148_;
			gint _tmp149_;
			gint _tmp150_;
			ValaList* _tmp151_;
			gint _tmp152_;
			gpointer _tmp153_ = NULL;
			ValaParameter* param;
			gint _tmp154_;
			ValaParameter* _tmp155_;
			ValaDataType* _tmp156_;
			ValaDataType* _tmp157_;
			gboolean _tmp158_ = FALSE;
			_tmp148_ = _param_index;
			_param_index = _tmp148_ + 1;
			_tmp149_ = _param_index;
			_tmp150_ = _param_size;
			if (!(_tmp149_ < _tmp150_)) {
				break;
			}
			_tmp151_ = _param_list;
			_tmp152_ = _param_index;
			_tmp153_ = vala_list_get (_tmp151_, _tmp152_);
			param = (ValaParameter*) _tmp153_;
			_tmp154_ = params_len;
			params_len = _tmp154_ + 1;
			_tmp155_ = param;
			_tmp156_ = vala_variable_get_variable_type ((ValaVariable*) _tmp155_);
			_tmp157_ = _tmp156_;
			_tmp158_ = vala_data_type_is_array (_tmp157_);
			if (_tmp158_) {
				gint _tmp159_;
				_tmp159_ = params_len;
				params_len = _tmp159_ + 1;
			}
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
	_tmp160_ = csignew;
	_tmp161_ = params_len;
	_tmp162_ = g_strdup_printf ("%d", _tmp161_);
	_tmp163_ = _tmp162_;
	_tmp164_ = vala_ccode_constant_new (_tmp163_);
	_tmp165_ = _tmp164_;
	vala_ccode_function_call_add_argument (_tmp160_, (ValaCCodeExpression*) _tmp165_);
	_vala_ccode_node_unref0 (_tmp165_);
	_g_free0 (_tmp163_);
	{
		ValaList* _tmp166_;
		ValaList* _tmp167_;
		ValaList* _param_list;
		ValaList* _tmp168_;
		gint _tmp169_;
		gint _tmp170_;
		gint _param_size;
		gint _param_index;
		_tmp166_ = params;
		_tmp167_ = _vala_iterable_ref0 (_tmp166_);
		_param_list = _tmp167_;
		_tmp168_ = _param_list;
		_tmp169_ = vala_collection_get_size ((ValaCollection*) _tmp168_);
		_tmp170_ = _tmp169_;
		_param_size = _tmp170_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp171_;
			gint _tmp172_;
			gint _tmp173_;
			ValaList* _tmp174_;
			gint _tmp175_;
			gpointer _tmp176_ = NULL;
			ValaParameter* param;
			ValaParameter* _tmp177_;
			ValaDataType* _tmp178_;
			ValaDataType* _tmp179_;
			gboolean _tmp180_ = FALSE;
			_tmp171_ = _param_index;
			_param_index = _tmp171_ + 1;
			_tmp172_ = _param_index;
			_tmp173_ = _param_size;
			if (!(_tmp172_ < _tmp173_)) {
				break;
			}
			_tmp174_ = _param_list;
			_tmp175_ = _param_index;
			_tmp176_ = vala_list_get (_tmp174_, _tmp175_);
			param = (ValaParameter*) _tmp176_;
			_tmp177_ = param;
			_tmp178_ = vala_variable_get_variable_type ((ValaVariable*) _tmp177_);
			_tmp179_ = _tmp178_;
			_tmp180_ = vala_data_type_is_array (_tmp179_);
			if (_tmp180_) {
				ValaParameter* _tmp181_;
				ValaDataType* _tmp182_;
				ValaDataType* _tmp183_;
				ValaDataType* _tmp184_;
				ValaDataType* _tmp185_;
				ValaTypeSymbol* _tmp186_;
				ValaTypeSymbol* _tmp187_;
				ValaDataType* _tmp188_;
				ValaTypeSymbol* _tmp189_;
				ValaTypeSymbol* _tmp190_;
				ValaCCodeFunctionCall* _tmp197_;
				ValaCCodeConstant* _tmp198_;
				ValaCCodeConstant* _tmp199_;
				_tmp181_ = param;
				_tmp182_ = vala_variable_get_variable_type ((ValaVariable*) _tmp181_);
				_tmp183_ = _tmp182_;
				_tmp184_ = vala_array_type_get_element_type (VALA_ARRAY_TYPE (_tmp183_));
				_tmp185_ = _tmp184_;
				_tmp186_ = vala_data_type_get_data_type (_tmp185_);
				_tmp187_ = _tmp186_;
				_tmp188_ = ((ValaCCodeBaseModule*) self)->string_type;
				_tmp189_ = vala_data_type_get_data_type (_tmp188_);
				_tmp190_ = _tmp189_;
				if (_tmp187_ == _tmp190_) {
					ValaCCodeFunctionCall* _tmp191_;
					ValaCCodeConstant* _tmp192_;
					ValaCCodeConstant* _tmp193_;
					_tmp191_ = csignew;
					_tmp192_ = vala_ccode_constant_new ("G_TYPE_STRV");
					_tmp193_ = _tmp192_;
					vala_ccode_function_call_add_argument (_tmp191_, (ValaCCodeExpression*) _tmp193_);
					_vala_ccode_node_unref0 (_tmp193_);
				} else {
					ValaCCodeFunctionCall* _tmp194_;
					ValaCCodeConstant* _tmp195_;
					ValaCCodeConstant* _tmp196_;
					_tmp194_ = csignew;
					_tmp195_ = vala_ccode_constant_new ("G_TYPE_POINTER");
					_tmp196_ = _tmp195_;
					vala_ccode_function_call_add_argument (_tmp194_, (ValaCCodeExpression*) _tmp196_);
					_vala_ccode_node_unref0 (_tmp196_);
				}
				_tmp197_ = csignew;
				_tmp198_ = vala_ccode_constant_new ("G_TYPE_INT");
				_tmp199_ = _tmp198_;
				vala_ccode_function_call_add_argument (_tmp197_, (ValaCCodeExpression*) _tmp199_);
				_vala_ccode_node_unref0 (_tmp199_);
			} else {
				gboolean _tmp200_ = FALSE;
				gboolean _tmp201_ = FALSE;
				ValaParameter* _tmp202_;
				ValaDataType* _tmp203_;
				ValaDataType* _tmp204_;
				gboolean _tmp210_;
				gboolean _tmp214_;
				_tmp202_ = param;
				_tmp203_ = vala_variable_get_variable_type ((ValaVariable*) _tmp202_);
				_tmp204_ = _tmp203_;
				if (VALA_IS_POINTER_TYPE (_tmp204_)) {
					_tmp201_ = TRUE;
				} else {
					ValaParameter* _tmp205_;
					ValaDataType* _tmp206_;
					ValaDataType* _tmp207_;
					ValaTypeParameter* _tmp208_;
					ValaTypeParameter* _tmp209_;
					_tmp205_ = param;
					_tmp206_ = vala_variable_get_variable_type ((ValaVariable*) _tmp205_);
					_tmp207_ = _tmp206_;
					_tmp208_ = vala_data_type_get_type_parameter (_tmp207_);
					_tmp209_ = _tmp208_;
					_tmp201_ = _tmp209_ != NULL;
				}
				_tmp210_ = _tmp201_;
				if (_tmp210_) {
					_tmp200_ = TRUE;
				} else {
					ValaParameter* _tmp211_;
					ValaParameterDirection _tmp212_;
					ValaParameterDirection _tmp213_;
					_tmp211_ = param;
					_tmp212_ = vala_parameter_get_direction (_tmp211_);
					_tmp213_ = _tmp212_;
					_tmp200_ = _tmp213_ != VALA_PARAMETER_DIRECTION_IN;
				}
				_tmp214_ = _tmp200_;
				if (_tmp214_) {
					ValaCCodeFunctionCall* _tmp215_;
					ValaCCodeConstant* _tmp216_;
					ValaCCodeConstant* _tmp217_;
					_tmp215_ = csignew;
					_tmp216_ = vala_ccode_constant_new ("G_TYPE_POINTER");
					_tmp217_ = _tmp216_;
					vala_ccode_function_call_add_argument (_tmp215_, (ValaCCodeExpression*) _tmp217_);
					_vala_ccode_node_unref0 (_tmp217_);
				} else {
					ValaParameter* _tmp218_;
					ValaDataType* _tmp219_;
					ValaDataType* _tmp220_;
					_tmp218_ = param;
					_tmp219_ = vala_variable_get_variable_type ((ValaVariable*) _tmp218_);
					_tmp220_ = _tmp219_;
					if (VALA_IS_ERROR_TYPE (_tmp220_)) {
						ValaCCodeFunctionCall* _tmp221_;
						ValaCCodeConstant* _tmp222_;
						ValaCCodeConstant* _tmp223_;
						_tmp221_ = csignew;
						_tmp222_ = vala_ccode_constant_new ("G_TYPE_POINTER");
						_tmp223_ = _tmp222_;
						vala_ccode_function_call_add_argument (_tmp221_, (ValaCCodeExpression*) _tmp223_);
						_vala_ccode_node_unref0 (_tmp223_);
					} else {
						ValaCCodeFunctionCall* _tmp224_;
						ValaParameter* _tmp225_;
						ValaDataType* _tmp226_;
						ValaDataType* _tmp227_;
						ValaTypeSymbol* _tmp228_;
						ValaTypeSymbol* _tmp229_;
						gchar* _tmp230_ = NULL;
						gchar* _tmp231_;
						ValaCCodeConstant* _tmp232_;
						ValaCCodeConstant* _tmp233_;
						_tmp224_ = csignew;
						_tmp225_ = param;
						_tmp226_ = vala_variable_get_variable_type ((ValaVariable*) _tmp225_);
						_tmp227_ = _tmp226_;
						_tmp228_ = vala_data_type_get_data_type (_tmp227_);
						_tmp229_ = _tmp228_;
						_tmp230_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp229_);
						_tmp231_ = _tmp230_;
						_tmp232_ = vala_ccode_constant_new (_tmp231_);
						_tmp233_ = _tmp232_;
						vala_ccode_function_call_add_argument (_tmp224_, (ValaCCodeExpression*) _tmp233_);
						_vala_ccode_node_unref0 (_tmp233_);
						_g_free0 (_tmp231_);
					}
				}
			}
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
	_tmp234_ = marshal_arg;
	_tmp235_ = marshaller;
	vala_ccode_identifier_set_name (_tmp234_, _tmp235_);
	result = csignew;
	_vala_iterable_unref0 (params);
	_vala_ccode_node_unref0 (marshal_arg);
	_g_free0 (marshaller);
	_g_free0 (run_type);
	flags = (_vala_array_free (flags, flags_length1, (GDestroyNotify) g_free), NULL);
	return result;
}


static void vala_gsignal_module_real_visit_element_access (ValaCodeVisitor* base, ValaElementAccess* expr) {
	ValaGSignalModule * self;
	gboolean _tmp0_ = FALSE;
	ValaElementAccess* _tmp1_;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	gboolean _tmp9_;
	self = (ValaGSignalModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp1_ = expr;
	_tmp2_ = vala_element_access_get_container (_tmp1_);
	_tmp3_ = _tmp2_;
	if (VALA_IS_MEMBER_ACCESS (_tmp3_)) {
		ValaElementAccess* _tmp4_;
		ValaExpression* _tmp5_;
		ValaExpression* _tmp6_;
		ValaSymbol* _tmp7_;
		ValaSymbol* _tmp8_;
		_tmp4_ = expr;
		_tmp5_ = vala_element_access_get_container (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = vala_expression_get_symbol_reference (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp0_ = VALA_IS_SIGNAL (_tmp8_);
	} else {
		_tmp0_ = FALSE;
	}
	_tmp9_ = _tmp0_;
	if (_tmp9_) {
		ValaElementAccess* _tmp10_;
		ValaCodeNode* _tmp11_;
		ValaCodeNode* _tmp12_;
		_tmp10_ = expr;
		_tmp11_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp10_);
		_tmp12_ = _tmp11_;
		if (VALA_IS_METHOD_CALL (_tmp12_)) {
			ValaElementAccess* _tmp13_;
			ValaSymbol* _tmp14_;
			ValaSymbol* _tmp15_;
			ValaSignal* _tmp16_;
			ValaSignal* sig;
			ValaElementAccess* _tmp17_;
			ValaExpression* _tmp18_;
			ValaExpression* _tmp19_;
			ValaMemberAccess* _tmp20_;
			ValaMemberAccess* ma;
			ValaElementAccess* _tmp21_;
			ValaList* _tmp22_ = NULL;
			ValaList* _tmp23_;
			gpointer _tmp24_ = NULL;
			ValaExpression* _tmp25_;
			ValaExpression* detail_expr;
			ValaSignal* _tmp26_;
			ValaExpression* _tmp27_;
			ValaElementAccess* _tmp28_;
			ValaCCodeExpression* _tmp29_ = NULL;
			ValaCCodeExpression* signal_name_cexpr;
			ValaCCodeIdentifier* _tmp30_;
			ValaCCodeIdentifier* _tmp31_;
			ValaCCodeFunctionCall* _tmp32_;
			ValaCCodeFunctionCall* _tmp33_;
			ValaCCodeFunctionCall* ccall;
			ValaCCodeFunctionCall* _tmp34_;
			ValaMemberAccess* _tmp35_;
			ValaExpression* _tmp36_;
			ValaExpression* _tmp37_;
			ValaCCodeExpression* _tmp38_ = NULL;
			ValaCCodeExpression* _tmp39_;
			ValaCCodeExpression* _tmp40_;
			ValaElementAccess* _tmp43_;
			ValaCCodeFunctionCall* _tmp44_;
			_tmp13_ = expr;
			_tmp14_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp13_);
			_tmp15_ = _tmp14_;
			_tmp16_ = _vala_code_node_ref0 (VALA_SIGNAL (_tmp15_));
			sig = _tmp16_;
			_tmp17_ = expr;
			_tmp18_ = vala_element_access_get_container (_tmp17_);
			_tmp19_ = _tmp18_;
			_tmp20_ = _vala_code_node_ref0 (VALA_MEMBER_ACCESS (_tmp19_));
			ma = _tmp20_;
			_tmp21_ = expr;
			_tmp22_ = vala_element_access_get_indices (_tmp21_);
			_tmp23_ = _tmp22_;
			_tmp24_ = vala_list_get (_tmp23_, 0);
			_tmp25_ = (ValaExpression*) _tmp24_;
			_vala_iterable_unref0 (_tmp23_);
			detail_expr = _tmp25_;
			_tmp26_ = sig;
			_tmp27_ = detail_expr;
			_tmp28_ = expr;
			_tmp29_ = vala_gsignal_module_get_signal_name_cexpression (self, _tmp26_, _tmp27_, (ValaCodeNode*) _tmp28_);
			signal_name_cexpr = _tmp29_;
			_tmp30_ = vala_ccode_identifier_new ("g_signal_emit_by_name");
			_tmp31_ = _tmp30_;
			_tmp32_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp31_);
			_tmp33_ = _tmp32_;
			_vala_ccode_node_unref0 (_tmp31_);
			ccall = _tmp33_;
			_tmp34_ = ccall;
			_tmp35_ = ma;
			_tmp36_ = vala_member_access_get_inner (_tmp35_);
			_tmp37_ = _tmp36_;
			_tmp38_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp37_);
			_tmp39_ = _tmp38_;
			vala_ccode_function_call_add_argument (_tmp34_, _tmp39_);
			_vala_ccode_node_unref0 (_tmp39_);
			_tmp40_ = signal_name_cexpr;
			if (_tmp40_ != NULL) {
				ValaCCodeFunctionCall* _tmp41_;
				ValaCCodeExpression* _tmp42_;
				_tmp41_ = ccall;
				_tmp42_ = signal_name_cexpr;
				vala_ccode_function_call_add_argument (_tmp41_, _tmp42_);
			}
			_tmp43_ = expr;
			_tmp44_ = ccall;
			vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp43_, (ValaCCodeExpression*) _tmp44_);
			_vala_ccode_node_unref0 (ccall);
			_vala_ccode_node_unref0 (signal_name_cexpr);
			_vala_code_node_unref0 (detail_expr);
			_vala_code_node_unref0 (ma);
			_vala_code_node_unref0 (sig);
		} else {
		}
	} else {
		ValaElementAccess* _tmp45_;
		_tmp45_ = expr;
		VALA_CODE_VISITOR_CLASS (vala_gsignal_module_parent_class)->visit_element_access ((ValaCodeVisitor*) VALA_GOBJECT_MODULE (self), _tmp45_);
	}
}


static gboolean vala_gsignal_module_in_gobject_instance (ValaGSignalModule* self, ValaMethod* m) {
	gboolean result = FALSE;
	gboolean _result_;
	ValaMethod* _tmp0_;
	ValaMemberBinding _tmp1_;
	ValaMemberBinding _tmp2_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (m != NULL, FALSE);
	_result_ = FALSE;
	_tmp0_ = m;
	_tmp1_ = vala_method_get_binding (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ == VALA_MEMBER_BINDING_INSTANCE) {
		ValaMethod* _tmp3_;
		ValaParameter* _tmp4_;
		ValaParameter* _tmp5_;
		ValaDataType* _tmp6_;
		ValaDataType* _tmp7_;
		ValaTypeSymbol* _tmp8_;
		ValaTypeSymbol* _tmp9_;
		ValaTypeSymbol* _tmp10_;
		gboolean _tmp11_ = FALSE;
		_tmp3_ = m;
		_tmp4_ = vala_method_get_this_parameter (_tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = vala_variable_get_variable_type ((ValaVariable*) _tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_data_type_get_data_type (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = ((ValaCCodeBaseModule*) self)->gobject_type;
		_tmp11_ = vala_typesymbol_is_subtype_of (_tmp9_, _tmp10_);
		_result_ = _tmp11_;
	}
	result = _result_;
	return result;
}


static void vala_gsignal_module_emit_signal_assignment (ValaGSignalModule* self, ValaAssignment* assignment) {
	ValaAssignment* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	ValaSymbol* _tmp3_;
	ValaSymbol* _tmp4_;
	ValaSignal* _tmp5_;
	ValaSignal* sig;
	gboolean disconnect;
	ValaAssignment* _tmp6_;
	ValaAssignmentOperator _tmp7_;
	ValaAssignmentOperator _tmp8_;
	ValaSignal* _tmp16_;
	ValaAssignment* _tmp17_;
	ValaExpression* _tmp18_;
	ValaExpression* _tmp19_;
	ValaAssignment* _tmp20_;
	ValaExpression* _tmp21_;
	ValaExpression* _tmp22_;
	gboolean _tmp23_;
	ValaAssignment* _tmp24_;
	ValaCCodeExpression* _tmp25_ = NULL;
	ValaCCodeExpression* _tmp26_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (assignment != NULL);
	_tmp0_ = assignment;
	_tmp1_ = vala_assignment_get_left (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_expression_get_symbol_reference (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _vala_code_node_ref0 (VALA_SIGNAL (_tmp4_));
	sig = _tmp5_;
	disconnect = FALSE;
	_tmp6_ = assignment;
	_tmp7_ = vala_assignment_get_operator (_tmp6_);
	_tmp8_ = _tmp7_;
	if (_tmp8_ == VALA_ASSIGNMENT_OPERATOR_ADD) {
	} else {
		ValaAssignment* _tmp9_;
		ValaAssignmentOperator _tmp10_;
		ValaAssignmentOperator _tmp11_;
		_tmp9_ = assignment;
		_tmp10_ = vala_assignment_get_operator (_tmp9_);
		_tmp11_ = _tmp10_;
		if (_tmp11_ == VALA_ASSIGNMENT_OPERATOR_SUB) {
			disconnect = TRUE;
		} else {
			ValaAssignment* _tmp12_;
			ValaAssignment* _tmp13_;
			ValaSourceReference* _tmp14_;
			ValaSourceReference* _tmp15_;
			_tmp12_ = assignment;
			vala_code_node_set_error ((ValaCodeNode*) _tmp12_, TRUE);
			_tmp13_ = assignment;
			_tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp13_);
			_tmp15_ = _tmp14_;
			vala_report_error (_tmp15_, "Specified compound assignment type for signals not supported.");
			_vala_code_node_unref0 (sig);
			return;
		}
	}
	_tmp16_ = sig;
	_tmp17_ = assignment;
	_tmp18_ = vala_assignment_get_left (_tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = assignment;
	_tmp21_ = vala_assignment_get_right (_tmp20_);
	_tmp22_ = _tmp21_;
	_tmp23_ = disconnect;
	_tmp24_ = assignment;
	_tmp25_ = vala_gsignal_module_connect_signal (self, _tmp16_, _tmp19_, _tmp22_, _tmp23_, FALSE, (ValaCodeNode*) _tmp24_);
	_tmp26_ = _tmp25_;
	_vala_ccode_node_unref0 (_tmp26_);
	_vala_code_node_unref0 (sig);
}


static void vala_gsignal_module_real_visit_assignment (ValaCodeVisitor* base, ValaAssignment* assignment) {
	ValaGSignalModule * self;
	ValaAssignment* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	ValaSymbol* _tmp3_;
	ValaSymbol* _tmp4_;
	self = (ValaGSignalModule*) base;
	g_return_if_fail (assignment != NULL);
	_tmp0_ = assignment;
	_tmp1_ = vala_assignment_get_left (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_expression_get_symbol_reference (_tmp2_);
	_tmp4_ = _tmp3_;
	if (VALA_IS_SIGNAL (_tmp4_)) {
		gboolean _tmp5_ = FALSE;
		ValaAssignment* _tmp6_;
		ValaExpression* _tmp7_;
		ValaExpression* _tmp8_;
		gboolean _tmp9_;
		gboolean _tmp10_;
		gboolean _tmp16_;
		ValaAssignment* _tmp18_;
		_tmp6_ = assignment;
		_tmp7_ = vala_assignment_get_left (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = vala_code_node_get_error ((ValaCodeNode*) _tmp8_);
		_tmp10_ = _tmp9_;
		if (_tmp10_) {
			_tmp5_ = TRUE;
		} else {
			ValaAssignment* _tmp11_;
			ValaExpression* _tmp12_;
			ValaExpression* _tmp13_;
			gboolean _tmp14_;
			gboolean _tmp15_;
			_tmp11_ = assignment;
			_tmp12_ = vala_assignment_get_right (_tmp11_);
			_tmp13_ = _tmp12_;
			_tmp14_ = vala_code_node_get_error ((ValaCodeNode*) _tmp13_);
			_tmp15_ = _tmp14_;
			_tmp5_ = _tmp15_;
		}
		_tmp16_ = _tmp5_;
		if (_tmp16_) {
			ValaAssignment* _tmp17_;
			_tmp17_ = assignment;
			vala_code_node_set_error ((ValaCodeNode*) _tmp17_, TRUE);
			return;
		}
		_tmp18_ = assignment;
		vala_gsignal_module_emit_signal_assignment (self, _tmp18_);
	} else {
		ValaAssignment* _tmp19_;
		_tmp19_ = assignment;
		VALA_CODE_VISITOR_CLASS (vala_gsignal_module_parent_class)->visit_assignment ((ValaCodeVisitor*) VALA_GOBJECT_MODULE (self), _tmp19_);
	}
}


static void vala_gsignal_module_real_visit_member_access (ValaCodeVisitor* base, ValaMemberAccess* expr) {
	ValaGSignalModule * self;
	ValaMemberAccess* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	self = (ValaGSignalModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp0_);
	_tmp2_ = _tmp1_;
	if (VALA_IS_SIGNAL (_tmp2_)) {
		ValaCCodeExpression* pub_inst;
		ValaMemberAccess* _tmp3_;
		ValaExpression* _tmp4_;
		ValaExpression* _tmp5_;
		ValaMemberAccess* _tmp10_;
		ValaSymbol* _tmp11_;
		ValaSymbol* _tmp12_;
		ValaSignal* _tmp13_;
		ValaSignal* sig;
		ValaSignal* _tmp14_;
		ValaSymbol* _tmp15_;
		ValaSymbol* _tmp16_;
		ValaTypeSymbol* _tmp17_;
		ValaTypeSymbol* cl;
		gboolean _tmp18_ = FALSE;
		ValaMemberAccess* _tmp19_;
		ValaExpression* _tmp20_;
		ValaExpression* _tmp21_;
		gboolean _tmp25_;
		ValaSignal* _tmp59_;
		gboolean _tmp60_ = FALSE;
		pub_inst = NULL;
		_tmp3_ = expr;
		_tmp4_ = vala_member_access_get_inner (_tmp3_);
		_tmp5_ = _tmp4_;
		if (_tmp5_ != NULL) {
			ValaMemberAccess* _tmp6_;
			ValaExpression* _tmp7_;
			ValaExpression* _tmp8_;
			ValaCCodeExpression* _tmp9_ = NULL;
			_tmp6_ = expr;
			_tmp7_ = vala_member_access_get_inner (_tmp6_);
			_tmp8_ = _tmp7_;
			_tmp9_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp8_);
			_vala_ccode_node_unref0 (pub_inst);
			pub_inst = _tmp9_;
		}
		_tmp10_ = expr;
		_tmp11_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = _vala_code_node_ref0 (VALA_SIGNAL (_tmp12_));
		sig = _tmp13_;
		_tmp14_ = sig;
		_tmp15_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = _vala_code_node_ref0 (VALA_TYPESYMBOL (_tmp16_));
		cl = _tmp17_;
		_tmp19_ = expr;
		_tmp20_ = vala_member_access_get_inner (_tmp19_);
		_tmp21_ = _tmp20_;
		if (VALA_IS_BASE_ACCESS (_tmp21_)) {
			ValaSignal* _tmp22_;
			gboolean _tmp23_;
			gboolean _tmp24_;
			_tmp22_ = sig;
			_tmp23_ = vala_signal_get_is_virtual (_tmp22_);
			_tmp24_ = _tmp23_;
			_tmp18_ = _tmp24_;
		} else {
			_tmp18_ = FALSE;
		}
		_tmp25_ = _tmp18_;
		if (_tmp25_) {
			ValaSignal* _tmp26_;
			ValaMethod* _tmp27_;
			ValaMethod* _tmp28_;
			ValaMethod* _tmp29_;
			ValaMethod* m;
			ValaMethod* _tmp30_;
			ValaSymbol* _tmp31_;
			ValaSymbol* _tmp32_;
			ValaClass* _tmp33_;
			ValaClass* base_class;
			ValaClass* _tmp34_;
			gchar* _tmp35_ = NULL;
			gchar* _tmp36_;
			gchar* _tmp37_ = NULL;
			gchar* _tmp38_;
			ValaCCodeIdentifier* _tmp39_;
			ValaCCodeIdentifier* _tmp40_;
			ValaCCodeFunctionCall* _tmp41_;
			ValaCCodeFunctionCall* _tmp42_;
			ValaCCodeFunctionCall* vcast;
			ValaCCodeFunctionCall* _tmp43_;
			ValaClass* _tmp44_;
			ValaClass* _tmp45_;
			gchar* _tmp46_ = NULL;
			gchar* _tmp47_;
			gchar* _tmp48_ = NULL;
			gchar* _tmp49_;
			ValaCCodeIdentifier* _tmp50_;
			ValaCCodeIdentifier* _tmp51_;
			ValaMemberAccess* _tmp52_;
			ValaCCodeFunctionCall* _tmp53_;
			ValaMethod* _tmp54_;
			const gchar* _tmp55_;
			const gchar* _tmp56_;
			ValaCCodeMemberAccess* _tmp57_;
			ValaCCodeMemberAccess* _tmp58_;
			_tmp26_ = sig;
			_tmp27_ = vala_signal_get_default_handler (_tmp26_);
			_tmp28_ = _tmp27_;
			_tmp29_ = _vala_code_node_ref0 (_tmp28_);
			m = _tmp29_;
			_tmp30_ = m;
			_tmp31_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp30_);
			_tmp32_ = _tmp31_;
			_tmp33_ = _vala_code_node_ref0 (VALA_CLASS (_tmp32_));
			base_class = _tmp33_;
			_tmp34_ = base_class;
			_tmp35_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp34_, NULL);
			_tmp36_ = _tmp35_;
			_tmp37_ = g_strdup_printf ("%s_CLASS", _tmp36_);
			_tmp38_ = _tmp37_;
			_tmp39_ = vala_ccode_identifier_new (_tmp38_);
			_tmp40_ = _tmp39_;
			_tmp41_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp40_);
			_tmp42_ = _tmp41_;
			_vala_ccode_node_unref0 (_tmp40_);
			_g_free0 (_tmp38_);
			_g_free0 (_tmp36_);
			vcast = _tmp42_;
			_tmp43_ = vcast;
			_tmp44_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
			_tmp45_ = _tmp44_;
			_tmp46_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp45_, NULL);
			_tmp47_ = _tmp46_;
			_tmp48_ = g_strdup_printf ("%s_parent_class", _tmp47_);
			_tmp49_ = _tmp48_;
			_tmp50_ = vala_ccode_identifier_new (_tmp49_);
			_tmp51_ = _tmp50_;
			vala_ccode_function_call_add_argument (_tmp43_, (ValaCCodeExpression*) _tmp51_);
			_vala_ccode_node_unref0 (_tmp51_);
			_g_free0 (_tmp49_);
			_g_free0 (_tmp47_);
			_tmp52_ = expr;
			_tmp53_ = vcast;
			_tmp54_ = m;
			_tmp55_ = vala_symbol_get_name ((ValaSymbol*) _tmp54_);
			_tmp56_ = _tmp55_;
			_tmp57_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp53_, _tmp56_);
			_tmp58_ = _tmp57_;
			vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp52_, (ValaCCodeExpression*) _tmp58_);
			_vala_ccode_node_unref0 (_tmp58_);
			_vala_ccode_node_unref0 (vcast);
			_vala_code_node_unref0 (base_class);
			_vala_code_node_unref0 (m);
			_vala_code_node_unref0 (cl);
			_vala_code_node_unref0 (sig);
			_vala_ccode_node_unref0 (pub_inst);
			return;
		}
		_tmp59_ = sig;
		_tmp60_ = vala_ccode_base_module_get_signal_has_emitter ((ValaCCodeBaseModule*) self, _tmp59_);
		if (_tmp60_) {
			ValaTypeSymbol* _tmp61_;
			gchar* _tmp62_ = NULL;
			gchar* _tmp63_;
			ValaSignal* _tmp64_;
			const gchar* _tmp65_;
			const gchar* _tmp66_;
			gchar* _tmp67_ = NULL;
			gchar* _tmp68_;
			ValaCCodeIdentifier* _tmp69_;
			ValaCCodeIdentifier* _tmp70_;
			ValaCCodeFunctionCall* _tmp71_;
			ValaCCodeFunctionCall* _tmp72_;
			ValaCCodeFunctionCall* ccall;
			ValaCCodeFunctionCall* _tmp73_;
			ValaCCodeExpression* _tmp74_;
			ValaMemberAccess* _tmp75_;
			ValaCCodeFunctionCall* _tmp76_;
			_tmp61_ = cl;
			_tmp62_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp61_, NULL);
			_tmp63_ = _tmp62_;
			_tmp64_ = sig;
			_tmp65_ = vala_symbol_get_name ((ValaSymbol*) _tmp64_);
			_tmp66_ = _tmp65_;
			_tmp67_ = g_strdup_printf ("%s_%s", _tmp63_, _tmp66_);
			_tmp68_ = _tmp67_;
			_tmp69_ = vala_ccode_identifier_new (_tmp68_);
			_tmp70_ = _tmp69_;
			_tmp71_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp70_);
			_tmp72_ = _tmp71_;
			_vala_ccode_node_unref0 (_tmp70_);
			_g_free0 (_tmp68_);
			_g_free0 (_tmp63_);
			ccall = _tmp72_;
			_tmp73_ = ccall;
			_tmp74_ = pub_inst;
			vala_ccode_function_call_add_argument (_tmp73_, _tmp74_);
			_tmp75_ = expr;
			_tmp76_ = ccall;
			vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp75_, (ValaCCodeExpression*) _tmp76_);
			_vala_ccode_node_unref0 (ccall);
		} else {
			ValaCCodeIdentifier* _tmp77_;
			ValaCCodeIdentifier* _tmp78_;
			ValaCCodeFunctionCall* _tmp79_;
			ValaCCodeFunctionCall* _tmp80_;
			ValaCCodeFunctionCall* ccall;
			ValaCCodeFunctionCall* _tmp81_;
			ValaCCodeExpression* _tmp82_;
			ValaCCodeFunctionCall* _tmp83_;
			ValaSignal* _tmp84_;
			ValaCCodeConstant* _tmp85_ = NULL;
			ValaCCodeConstant* _tmp86_;
			ValaMemberAccess* _tmp87_;
			ValaCCodeFunctionCall* _tmp88_;
			_tmp77_ = vala_ccode_identifier_new ("g_signal_emit_by_name");
			_tmp78_ = _tmp77_;
			_tmp79_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp78_);
			_tmp80_ = _tmp79_;
			_vala_ccode_node_unref0 (_tmp78_);
			ccall = _tmp80_;
			_tmp81_ = ccall;
			_tmp82_ = pub_inst;
			vala_ccode_function_call_add_argument (_tmp81_, _tmp82_);
			_tmp83_ = ccall;
			_tmp84_ = sig;
			_tmp85_ = vala_ccode_base_module_get_signal_canonical_constant ((ValaCCodeBaseModule*) self, _tmp84_, NULL);
			_tmp86_ = _tmp85_;
			vala_ccode_function_call_add_argument (_tmp83_, (ValaCCodeExpression*) _tmp86_);
			_vala_ccode_node_unref0 (_tmp86_);
			_tmp87_ = expr;
			_tmp88_ = ccall;
			vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp87_, (ValaCCodeExpression*) _tmp88_);
			_vala_ccode_node_unref0 (ccall);
		}
		_vala_code_node_unref0 (cl);
		_vala_code_node_unref0 (sig);
		_vala_ccode_node_unref0 (pub_inst);
	} else {
		ValaMemberAccess* _tmp89_;
		_tmp89_ = expr;
		VALA_CODE_VISITOR_CLASS (vala_gsignal_module_parent_class)->visit_member_access ((ValaCodeVisitor*) VALA_GOBJECT_MODULE (self), _tmp89_);
	}
}


static void vala_gsignal_module_real_visit_method_call (ValaCodeVisitor* base, ValaMethodCall* expr) {
	ValaGSignalModule * self;
	ValaMethodCall* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	ValaDataType* _tmp3_;
	ValaDataType* _tmp4_;
	ValaMethodType* _tmp5_;
	ValaMethodType* method_type;
	gboolean _tmp6_ = FALSE;
	ValaMethodType* _tmp7_;
	gboolean _tmp13_;
	ValaMethodType* _tmp15_;
	ValaMethod* _tmp16_;
	ValaMethod* _tmp17_;
	ValaSymbol* _tmp18_;
	ValaSymbol* _tmp19_;
	ValaSignal* _tmp20_;
	ValaSignal* sig;
	ValaMethodCall* _tmp21_;
	ValaExpression* _tmp22_;
	ValaExpression* _tmp23_;
	ValaExpression* _tmp24_;
	ValaExpression* _tmp25_;
	ValaExpression* _tmp26_;
	ValaExpression* signal_access;
	ValaMethodCall* _tmp27_;
	ValaList* _tmp28_ = NULL;
	ValaList* _tmp29_;
	gpointer _tmp30_ = NULL;
	ValaExpression* _tmp31_;
	ValaExpression* handler;
	ValaMethodType* _tmp32_;
	ValaMethod* _tmp33_;
	ValaMethod* _tmp34_;
	const gchar* _tmp35_;
	const gchar* _tmp36_;
	gboolean disconnect;
	ValaMethodType* _tmp37_;
	ValaMethod* _tmp38_;
	ValaMethod* _tmp39_;
	const gchar* _tmp40_;
	const gchar* _tmp41_;
	gboolean after;
	ValaSignal* _tmp42_;
	ValaExpression* _tmp43_;
	ValaExpression* _tmp44_;
	gboolean _tmp45_;
	gboolean _tmp46_;
	ValaMethodCall* _tmp47_;
	ValaCCodeExpression* _tmp48_ = NULL;
	ValaCCodeExpression* cexpr;
	ValaMethodCall* _tmp49_;
	ValaCCodeExpression* _tmp50_;
	self = (ValaGSignalModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_method_call_get_call (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_expression_get_value_type (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _vala_code_node_ref0 (VALA_IS_METHOD_TYPE (_tmp4_) ? ((ValaMethodType*) _tmp4_) : NULL);
	method_type = _tmp5_;
	_tmp7_ = method_type;
	if (_tmp7_ == NULL) {
		_tmp6_ = TRUE;
	} else {
		ValaMethodType* _tmp8_;
		ValaMethod* _tmp9_;
		ValaMethod* _tmp10_;
		ValaSymbol* _tmp11_;
		ValaSymbol* _tmp12_;
		_tmp8_ = method_type;
		_tmp9_ = vala_method_type_get_method_symbol (_tmp8_);
		_tmp10_ = _tmp9_;
		_tmp11_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp10_);
		_tmp12_ = _tmp11_;
		_tmp6_ = !VALA_IS_SIGNAL (_tmp12_);
	}
	_tmp13_ = _tmp6_;
	if (_tmp13_) {
		ValaMethodCall* _tmp14_;
		_tmp14_ = expr;
		VALA_CODE_VISITOR_CLASS (vala_gsignal_module_parent_class)->visit_method_call ((ValaCodeVisitor*) VALA_GOBJECT_MODULE (self), _tmp14_);
		_vala_code_node_unref0 (method_type);
		return;
	}
	_tmp15_ = method_type;
	_tmp16_ = vala_method_type_get_method_symbol (_tmp15_);
	_tmp17_ = _tmp16_;
	_tmp18_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = _vala_code_node_ref0 (VALA_SIGNAL (_tmp19_));
	sig = _tmp20_;
	_tmp21_ = expr;
	_tmp22_ = vala_method_call_get_call (_tmp21_);
	_tmp23_ = _tmp22_;
	_tmp24_ = vala_member_access_get_inner (VALA_MEMBER_ACCESS (_tmp23_));
	_tmp25_ = _tmp24_;
	_tmp26_ = _vala_code_node_ref0 (_tmp25_);
	signal_access = _tmp26_;
	_tmp27_ = expr;
	_tmp28_ = vala_method_call_get_argument_list (_tmp27_);
	_tmp29_ = _tmp28_;
	_tmp30_ = vala_list_get (_tmp29_, 0);
	_tmp31_ = (ValaExpression*) _tmp30_;
	_vala_iterable_unref0 (_tmp29_);
	handler = _tmp31_;
	_tmp32_ = method_type;
	_tmp33_ = vala_method_type_get_method_symbol (_tmp32_);
	_tmp34_ = _tmp33_;
	_tmp35_ = vala_symbol_get_name ((ValaSymbol*) _tmp34_);
	_tmp36_ = _tmp35_;
	disconnect = g_strcmp0 (_tmp36_, "disconnect") == 0;
	_tmp37_ = method_type;
	_tmp38_ = vala_method_type_get_method_symbol (_tmp37_);
	_tmp39_ = _tmp38_;
	_tmp40_ = vala_symbol_get_name ((ValaSymbol*) _tmp39_);
	_tmp41_ = _tmp40_;
	after = g_strcmp0 (_tmp41_, "connect_after") == 0;
	_tmp42_ = sig;
	_tmp43_ = signal_access;
	_tmp44_ = handler;
	_tmp45_ = disconnect;
	_tmp46_ = after;
	_tmp47_ = expr;
	_tmp48_ = vala_gsignal_module_connect_signal (self, _tmp42_, _tmp43_, _tmp44_, _tmp45_, _tmp46_, (ValaCodeNode*) _tmp47_);
	cexpr = _tmp48_;
	_tmp49_ = expr;
	_tmp50_ = cexpr;
	vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp49_, _tmp50_);
	_vala_ccode_node_unref0 (cexpr);
	_vala_code_node_unref0 (handler);
	_vala_code_node_unref0 (signal_access);
	_vala_code_node_unref0 (sig);
	_vala_code_node_unref0 (method_type);
}


static ValaCCodeExpression* vala_gsignal_module_connect_signal (ValaGSignalModule* self, ValaSignal* sig, ValaExpression* signal_access, ValaExpression* handler, gboolean disconnect, gboolean after, ValaCodeNode* expr) {
	ValaCCodeExpression* result = NULL;
	gchar* connect_func = NULL;
	ValaExpression* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaMethod* _tmp3_;
	ValaMethod* m;
	gboolean _tmp4_;
	const gchar* _tmp29_;
	ValaCCodeIdentifier* _tmp30_;
	ValaCCodeIdentifier* _tmp31_;
	ValaCCodeFunctionCall* _tmp32_;
	ValaCCodeFunctionCall* _tmp33_;
	ValaCCodeFunctionCall* ccall;
	ValaCCodeExpression* signal_name_cexpr;
	ValaMemberAccess* ma = NULL;
	ValaExpression* _tmp34_;
	ValaMemberAccess* _tmp56_;
	ValaExpression* _tmp57_;
	ValaExpression* _tmp58_;
	ValaSignal* _tmp68_;
	ValaCCodeFunctionCall* _tmp157_;
	ValaExpression* _tmp158_;
	ValaCCodeExpression* _tmp159_ = NULL;
	ValaCCodeExpression* _tmp160_;
	ValaCCodeCastExpression* _tmp161_;
	ValaCCodeCastExpression* _tmp162_;
	ValaMethod* _tmp163_;
	gboolean _tmp164_;
	gboolean _tmp165_;
	gboolean _tmp222_ = FALSE;
	gboolean _tmp223_;
	gboolean _tmp227_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (sig != NULL, NULL);
	g_return_val_if_fail (signal_access != NULL, NULL);
	g_return_val_if_fail (handler != NULL, NULL);
	g_return_val_if_fail (expr != NULL, NULL);
	_tmp0_ = handler;
	_tmp1_ = vala_expression_get_symbol_reference (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (VALA_METHOD (_tmp2_));
	m = _tmp3_;
	_tmp4_ = disconnect;
	if (!_tmp4_) {
		ValaSignal* _tmp5_;
		_tmp5_ = sig;
		if (VALA_IS_DYNAMIC_SIGNAL (_tmp5_)) {
			gboolean _tmp6_;
			_tmp6_ = after;
			if (!_tmp6_) {
				ValaSignal* _tmp7_;
				gchar* _tmp8_ = NULL;
				_tmp7_ = sig;
				_tmp8_ = vala_ccode_base_module_get_dynamic_signal_connect_wrapper_name ((ValaCCodeBaseModule*) self, VALA_DYNAMIC_SIGNAL (_tmp7_));
				_g_free0 (connect_func);
				connect_func = _tmp8_;
			} else {
				ValaSignal* _tmp9_;
				gchar* _tmp10_ = NULL;
				_tmp9_ = sig;
				_tmp10_ = vala_ccode_base_module_get_dynamic_signal_connect_after_wrapper_name ((ValaCCodeBaseModule*) self, VALA_DYNAMIC_SIGNAL (_tmp9_));
				_g_free0 (connect_func);
				connect_func = _tmp10_;
			}
		} else {
			ValaMethod* _tmp11_;
			gboolean _tmp12_;
			gboolean _tmp13_;
			_tmp11_ = m;
			_tmp12_ = vala_method_get_closure (_tmp11_);
			_tmp13_ = _tmp12_;
			if (_tmp13_) {
				gchar* _tmp14_;
				_tmp14_ = g_strdup ("g_signal_connect_data");
				_g_free0 (connect_func);
				connect_func = _tmp14_;
			} else {
				ValaMethod* _tmp15_;
				gboolean _tmp16_ = FALSE;
				_tmp15_ = m;
				_tmp16_ = vala_gsignal_module_in_gobject_instance (self, _tmp15_);
				if (_tmp16_) {
					gchar* _tmp17_;
					_tmp17_ = g_strdup ("g_signal_connect_object");
					_g_free0 (connect_func);
					connect_func = _tmp17_;
				} else {
					gboolean _tmp18_;
					_tmp18_ = after;
					if (!_tmp18_) {
						gchar* _tmp19_;
						_tmp19_ = g_strdup ("g_signal_connect");
						_g_free0 (connect_func);
						connect_func = _tmp19_;
					} else {
						gchar* _tmp20_;
						_tmp20_ = g_strdup ("g_signal_connect_after");
						_g_free0 (connect_func);
						connect_func = _tmp20_;
					}
				}
			}
		}
	} else {
		ValaExpression* _tmp21_;
		ValaSignal* _tmp25_;
		_tmp21_ = handler;
		if (VALA_IS_LAMBDA_EXPRESSION (_tmp21_)) {
			ValaExpression* _tmp22_;
			ValaSourceReference* _tmp23_;
			ValaSourceReference* _tmp24_;
			_tmp22_ = handler;
			_tmp23_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp22_);
			_tmp24_ = _tmp23_;
			vala_report_error (_tmp24_, "Cannot disconnect lambda expression from signal. Use Object.disconnect" \
".");
		}
		_tmp25_ = sig;
		if (VALA_IS_DYNAMIC_SIGNAL (_tmp25_)) {
			ValaSignal* _tmp26_;
			gchar* _tmp27_ = NULL;
			_tmp26_ = sig;
			_tmp27_ = vala_ccode_base_module_get_dynamic_signal_disconnect_wrapper_name ((ValaCCodeBaseModule*) self, VALA_DYNAMIC_SIGNAL (_tmp26_));
			_g_free0 (connect_func);
			connect_func = _tmp27_;
		} else {
			gchar* _tmp28_;
			_tmp28_ = g_strdup ("g_signal_handlers_disconnect_matched");
			_g_free0 (connect_func);
			connect_func = _tmp28_;
		}
	}
	_tmp29_ = connect_func;
	_tmp30_ = vala_ccode_identifier_new (_tmp29_);
	_tmp31_ = _tmp30_;
	_tmp32_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp31_);
	_tmp33_ = _tmp32_;
	_vala_ccode_node_unref0 (_tmp31_);
	ccall = _tmp33_;
	signal_name_cexpr = NULL;
	_tmp34_ = signal_access;
	if (VALA_IS_ELEMENT_ACCESS (_tmp34_)) {
		ValaExpression* _tmp35_;
		ValaElementAccess* _tmp36_;
		ValaElementAccess* ea;
		ValaElementAccess* _tmp37_;
		ValaExpression* _tmp38_;
		ValaExpression* _tmp39_;
		ValaMemberAccess* _tmp40_;
		ValaElementAccess* _tmp41_;
		ValaList* _tmp42_ = NULL;
		ValaList* _tmp43_;
		gpointer _tmp44_ = NULL;
		ValaExpression* _tmp45_;
		ValaExpression* detail_expr;
		ValaSignal* _tmp46_;
		ValaExpression* _tmp47_;
		ValaCodeNode* _tmp48_;
		ValaCCodeExpression* _tmp49_ = NULL;
		ValaCCodeExpression* _tmp50_;
		_tmp35_ = signal_access;
		_tmp36_ = _vala_code_node_ref0 (VALA_ELEMENT_ACCESS (_tmp35_));
		ea = _tmp36_;
		_tmp37_ = ea;
		_tmp38_ = vala_element_access_get_container (_tmp37_);
		_tmp39_ = _tmp38_;
		_tmp40_ = _vala_code_node_ref0 (VALA_MEMBER_ACCESS (_tmp39_));
		_vala_code_node_unref0 (ma);
		ma = _tmp40_;
		_tmp41_ = ea;
		_tmp42_ = vala_element_access_get_indices (_tmp41_);
		_tmp43_ = _tmp42_;
		_tmp44_ = vala_list_get (_tmp43_, 0);
		_tmp45_ = (ValaExpression*) _tmp44_;
		_vala_iterable_unref0 (_tmp43_);
		detail_expr = _tmp45_;
		_tmp46_ = sig;
		_tmp47_ = detail_expr;
		_tmp48_ = expr;
		_tmp49_ = vala_gsignal_module_get_signal_name_cexpression (self, _tmp46_, _tmp47_, _tmp48_);
		_vala_ccode_node_unref0 (signal_name_cexpr);
		signal_name_cexpr = _tmp49_;
		_tmp50_ = signal_name_cexpr;
		if (_tmp50_ == NULL) {
			result = NULL;
			_vala_code_node_unref0 (detail_expr);
			_vala_code_node_unref0 (ea);
			_vala_code_node_unref0 (ma);
			_vala_ccode_node_unref0 (signal_name_cexpr);
			_vala_ccode_node_unref0 (ccall);
			_vala_code_node_unref0 (m);
			_g_free0 (connect_func);
			return result;
		}
		_vala_code_node_unref0 (detail_expr);
		_vala_code_node_unref0 (ea);
	} else {
		ValaExpression* _tmp51_;
		ValaMemberAccess* _tmp52_;
		ValaSignal* _tmp53_;
		ValaCodeNode* _tmp54_;
		ValaCCodeExpression* _tmp55_ = NULL;
		_tmp51_ = signal_access;
		_tmp52_ = _vala_code_node_ref0 (VALA_MEMBER_ACCESS (_tmp51_));
		_vala_code_node_unref0 (ma);
		ma = _tmp52_;
		_tmp53_ = sig;
		_tmp54_ = expr;
		_tmp55_ = vala_gsignal_module_get_signal_name_cexpression (self, _tmp53_, NULL, _tmp54_);
		_vala_ccode_node_unref0 (signal_name_cexpr);
		signal_name_cexpr = _tmp55_;
	}
	_tmp56_ = ma;
	_tmp57_ = vala_member_access_get_inner (_tmp56_);
	_tmp58_ = _tmp57_;
	if (_tmp58_ != NULL) {
		ValaCCodeFunctionCall* _tmp59_;
		ValaMemberAccess* _tmp60_;
		ValaExpression* _tmp61_;
		ValaExpression* _tmp62_;
		ValaCCodeExpression* _tmp63_ = NULL;
		ValaCCodeExpression* _tmp64_;
		_tmp59_ = ccall;
		_tmp60_ = ma;
		_tmp61_ = vala_member_access_get_inner (_tmp60_);
		_tmp62_ = _tmp61_;
		_tmp63_ = vala_ccode_base_module_get_ccodenode ((ValaCCodeBaseModule*) self, _tmp62_);
		_tmp64_ = VALA_CCODE_EXPRESSION (_tmp63_);
		vala_ccode_function_call_add_argument (_tmp59_, _tmp64_);
		_vala_ccode_node_unref0 (_tmp64_);
	} else {
		ValaCCodeFunctionCall* _tmp65_;
		ValaCCodeExpression* _tmp66_ = NULL;
		ValaCCodeExpression* _tmp67_;
		_tmp65_ = ccall;
		_tmp66_ = vala_ccode_base_module_get_result_cexpression ((ValaCCodeBaseModule*) self, "self");
		_tmp67_ = _tmp66_;
		vala_ccode_function_call_add_argument (_tmp65_, _tmp67_);
		_vala_ccode_node_unref0 (_tmp67_);
	}
	_tmp68_ = sig;
	if (VALA_IS_DYNAMIC_SIGNAL (_tmp68_)) {
		ValaCCodeFunctionCall* _tmp69_;
		ValaSignal* _tmp70_;
		const gchar* _tmp71_;
		const gchar* _tmp72_;
		gchar* _tmp73_ = NULL;
		gchar* _tmp74_;
		ValaCCodeConstant* _tmp75_;
		ValaCCodeConstant* _tmp76_;
		_tmp69_ = ccall;
		_tmp70_ = sig;
		_tmp71_ = vala_symbol_get_name ((ValaSymbol*) _tmp70_);
		_tmp72_ = _tmp71_;
		_tmp73_ = g_strdup_printf ("\"%s\"", _tmp72_);
		_tmp74_ = _tmp73_;
		_tmp75_ = vala_ccode_constant_new (_tmp74_);
		_tmp76_ = _tmp75_;
		vala_ccode_function_call_add_argument (_tmp69_, (ValaCCodeExpression*) _tmp76_);
		_vala_ccode_node_unref0 (_tmp76_);
		_g_free0 (_tmp74_);
	} else {
		gboolean _tmp77_;
		_tmp77_ = disconnect;
		if (!_tmp77_) {
			ValaCCodeFunctionCall* _tmp78_;
			ValaCCodeExpression* _tmp79_;
			_tmp78_ = ccall;
			_tmp79_ = signal_name_cexpr;
			vala_ccode_function_call_add_argument (_tmp78_, _tmp79_);
		} else {
			ValaExpression* _tmp80_;
			ValaDataType* _tmp87_;
			ValaLocalVariable* _tmp88_ = NULL;
			ValaLocalVariable* temp_decl;
			ValaLocalVariable* _tmp89_;
			ValaCCodeIdentifier* _tmp90_;
			ValaCCodeIdentifier* _tmp91_;
			ValaCCodeFunctionCall* _tmp92_;
			ValaCCodeFunctionCall* _tmp93_;
			ValaCCodeFunctionCall* parse_call;
			ValaCCodeFunctionCall* _tmp94_;
			ValaCCodeExpression* _tmp95_;
			ValaSignal* _tmp96_;
			ValaSymbol* _tmp97_;
			ValaSymbol* _tmp98_;
			ValaTypeSymbol* _tmp99_;
			ValaTypeSymbol* decl_type;
			ValaCCodeFunctionCall* _tmp100_;
			ValaTypeSymbol* _tmp101_;
			gchar* _tmp102_ = NULL;
			gchar* _tmp103_;
			ValaCCodeIdentifier* _tmp104_;
			ValaCCodeIdentifier* _tmp105_;
			ValaCCodeFunctionCall* _tmp106_;
			ValaLocalVariable* _tmp107_;
			const gchar* _tmp108_;
			const gchar* _tmp109_;
			ValaCCodeExpression* _tmp110_ = NULL;
			ValaCCodeExpression* _tmp111_;
			ValaCCodeUnaryExpression* _tmp112_;
			ValaCCodeUnaryExpression* _tmp113_;
			ValaLocalVariable* detail_temp_decl;
			ValaExpression* _tmp114_;
			ValaCCodeFunction* _tmp135_;
			ValaCCodeFunction* _tmp136_;
			ValaCCodeFunctionCall* _tmp137_;
			ValaCCodeFunctionCall* _tmp138_;
			ValaLocalVariable* _tmp139_;
			const gchar* _tmp140_;
			const gchar* _tmp141_;
			ValaCCodeExpression* _tmp142_ = NULL;
			ValaCCodeExpression* _tmp143_;
			ValaLocalVariable* _tmp144_;
			ValaCCodeFunctionCall* _tmp154_;
			ValaCCodeConstant* _tmp155_;
			ValaCCodeConstant* _tmp156_;
			_tmp80_ = signal_access;
			if (!VALA_IS_ELEMENT_ACCESS (_tmp80_)) {
				ValaCCodeFunctionCall* _tmp81_;
				ValaCCodeConstant* _tmp82_;
				ValaCCodeConstant* _tmp83_;
				_tmp81_ = ccall;
				_tmp82_ = vala_ccode_constant_new ("G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA");
				_tmp83_ = _tmp82_;
				vala_ccode_function_call_add_argument (_tmp81_, (ValaCCodeExpression*) _tmp83_);
				_vala_ccode_node_unref0 (_tmp83_);
			} else {
				ValaCCodeFunctionCall* _tmp84_;
				ValaCCodeConstant* _tmp85_;
				ValaCCodeConstant* _tmp86_;
				_tmp84_ = ccall;
				_tmp85_ = vala_ccode_constant_new ("G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SI" \
"GNAL_MATCH_DATA");
				_tmp86_ = _tmp85_;
				vala_ccode_function_call_add_argument (_tmp84_, (ValaCCodeExpression*) _tmp86_);
				_vala_ccode_node_unref0 (_tmp86_);
			}
			_tmp87_ = ((ValaCCodeBaseModule*) self)->uint_type;
			_tmp88_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp87_, TRUE, NULL, TRUE);
			temp_decl = _tmp88_;
			_tmp89_ = temp_decl;
			vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp89_);
			_tmp90_ = vala_ccode_identifier_new ("g_signal_parse_name");
			_tmp91_ = _tmp90_;
			_tmp92_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp91_);
			_tmp93_ = _tmp92_;
			_vala_ccode_node_unref0 (_tmp91_);
			parse_call = _tmp93_;
			_tmp94_ = parse_call;
			_tmp95_ = signal_name_cexpr;
			vala_ccode_function_call_add_argument (_tmp94_, _tmp95_);
			_tmp96_ = sig;
			_tmp97_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp96_);
			_tmp98_ = _tmp97_;
			_tmp99_ = _vala_code_node_ref0 (VALA_TYPESYMBOL (_tmp98_));
			decl_type = _tmp99_;
			_tmp100_ = parse_call;
			_tmp101_ = decl_type;
			_tmp102_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp101_);
			_tmp103_ = _tmp102_;
			_tmp104_ = vala_ccode_identifier_new (_tmp103_);
			_tmp105_ = _tmp104_;
			vala_ccode_function_call_add_argument (_tmp100_, (ValaCCodeExpression*) _tmp105_);
			_vala_ccode_node_unref0 (_tmp105_);
			_g_free0 (_tmp103_);
			_tmp106_ = parse_call;
			_tmp107_ = temp_decl;
			_tmp108_ = vala_symbol_get_name ((ValaSymbol*) _tmp107_);
			_tmp109_ = _tmp108_;
			_tmp110_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp109_);
			_tmp111_ = _tmp110_;
			_tmp112_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp111_);
			_tmp113_ = _tmp112_;
			vala_ccode_function_call_add_argument (_tmp106_, (ValaCCodeExpression*) _tmp113_);
			_vala_ccode_node_unref0 (_tmp113_);
			_vala_ccode_node_unref0 (_tmp111_);
			detail_temp_decl = NULL;
			_tmp114_ = signal_access;
			if (!VALA_IS_ELEMENT_ACCESS (_tmp114_)) {
				ValaCCodeFunctionCall* _tmp115_;
				ValaCCodeConstant* _tmp116_;
				ValaCCodeConstant* _tmp117_;
				ValaCCodeFunctionCall* _tmp118_;
				ValaCCodeConstant* _tmp119_;
				ValaCCodeConstant* _tmp120_;
				_tmp115_ = parse_call;
				_tmp116_ = vala_ccode_constant_new ("NULL");
				_tmp117_ = _tmp116_;
				vala_ccode_function_call_add_argument (_tmp115_, (ValaCCodeExpression*) _tmp117_);
				_vala_ccode_node_unref0 (_tmp117_);
				_tmp118_ = parse_call;
				_tmp119_ = vala_ccode_constant_new ("FALSE");
				_tmp120_ = _tmp119_;
				vala_ccode_function_call_add_argument (_tmp118_, (ValaCCodeExpression*) _tmp120_);
				_vala_ccode_node_unref0 (_tmp120_);
			} else {
				ValaDataType* _tmp121_;
				ValaLocalVariable* _tmp122_ = NULL;
				ValaLocalVariable* _tmp123_;
				ValaCCodeFunctionCall* _tmp124_;
				ValaLocalVariable* _tmp125_;
				const gchar* _tmp126_;
				const gchar* _tmp127_;
				ValaCCodeIdentifier* _tmp128_;
				ValaCCodeIdentifier* _tmp129_;
				ValaCCodeUnaryExpression* _tmp130_;
				ValaCCodeUnaryExpression* _tmp131_;
				ValaCCodeFunctionCall* _tmp132_;
				ValaCCodeConstant* _tmp133_;
				ValaCCodeConstant* _tmp134_;
				_tmp121_ = ((ValaCCodeBaseModule*) self)->gquark_type;
				_tmp122_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp121_, TRUE, NULL, TRUE);
				_vala_code_node_unref0 (detail_temp_decl);
				detail_temp_decl = _tmp122_;
				_tmp123_ = detail_temp_decl;
				vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp123_);
				_tmp124_ = parse_call;
				_tmp125_ = detail_temp_decl;
				_tmp126_ = vala_symbol_get_name ((ValaSymbol*) _tmp125_);
				_tmp127_ = _tmp126_;
				_tmp128_ = vala_ccode_identifier_new (_tmp127_);
				_tmp129_ = _tmp128_;
				_tmp130_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp129_);
				_tmp131_ = _tmp130_;
				vala_ccode_function_call_add_argument (_tmp124_, (ValaCCodeExpression*) _tmp131_);
				_vala_ccode_node_unref0 (_tmp131_);
				_vala_ccode_node_unref0 (_tmp129_);
				_tmp132_ = parse_call;
				_tmp133_ = vala_ccode_constant_new ("TRUE");
				_tmp134_ = _tmp133_;
				vala_ccode_function_call_add_argument (_tmp132_, (ValaCCodeExpression*) _tmp134_);
				_vala_ccode_node_unref0 (_tmp134_);
			}
			_tmp135_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp136_ = _tmp135_;
			_tmp137_ = parse_call;
			vala_ccode_function_add_expression (_tmp136_, (ValaCCodeExpression*) _tmp137_);
			_tmp138_ = ccall;
			_tmp139_ = temp_decl;
			_tmp140_ = vala_symbol_get_name ((ValaSymbol*) _tmp139_);
			_tmp141_ = _tmp140_;
			_tmp142_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp141_);
			_tmp143_ = _tmp142_;
			vala_ccode_function_call_add_argument (_tmp138_, _tmp143_);
			_vala_ccode_node_unref0 (_tmp143_);
			_tmp144_ = detail_temp_decl;
			if (_tmp144_ == NULL) {
				ValaCCodeFunctionCall* _tmp145_;
				ValaCCodeConstant* _tmp146_;
				ValaCCodeConstant* _tmp147_;
				_tmp145_ = ccall;
				_tmp146_ = vala_ccode_constant_new ("0");
				_tmp147_ = _tmp146_;
				vala_ccode_function_call_add_argument (_tmp145_, (ValaCCodeExpression*) _tmp147_);
				_vala_ccode_node_unref0 (_tmp147_);
			} else {
				ValaCCodeFunctionCall* _tmp148_;
				ValaLocalVariable* _tmp149_;
				const gchar* _tmp150_;
				const gchar* _tmp151_;
				ValaCCodeExpression* _tmp152_ = NULL;
				ValaCCodeExpression* _tmp153_;
				_tmp148_ = ccall;
				_tmp149_ = detail_temp_decl;
				_tmp150_ = vala_symbol_get_name ((ValaSymbol*) _tmp149_);
				_tmp151_ = _tmp150_;
				_tmp152_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp151_);
				_tmp153_ = _tmp152_;
				vala_ccode_function_call_add_argument (_tmp148_, _tmp153_);
				_vala_ccode_node_unref0 (_tmp153_);
			}
			_tmp154_ = ccall;
			_tmp155_ = vala_ccode_constant_new ("NULL");
			_tmp156_ = _tmp155_;
			vala_ccode_function_call_add_argument (_tmp154_, (ValaCCodeExpression*) _tmp156_);
			_vala_ccode_node_unref0 (_tmp156_);
			_vala_code_node_unref0 (detail_temp_decl);
			_vala_code_node_unref0 (decl_type);
			_vala_ccode_node_unref0 (parse_call);
			_vala_code_node_unref0 (temp_decl);
		}
	}
	_tmp157_ = ccall;
	_tmp158_ = handler;
	_tmp159_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp158_);
	_tmp160_ = _tmp159_;
	_tmp161_ = vala_ccode_cast_expression_new (_tmp160_, "GCallback");
	_tmp162_ = _tmp161_;
	vala_ccode_function_call_add_argument (_tmp157_, (ValaCCodeExpression*) _tmp162_);
	_vala_ccode_node_unref0 (_tmp162_);
	_vala_ccode_node_unref0 (_tmp160_);
	_tmp163_ = m;
	_tmp164_ = vala_method_get_closure (_tmp163_);
	_tmp165_ = _tmp164_;
	if (_tmp165_) {
		ValaCCodeExpression* handler_destroy_notify = NULL;
		ValaCCodeFunctionCall* _tmp166_;
		ValaExpression* _tmp167_;
		ValaCCodeExpression* _tmp168_ = NULL;
		ValaCCodeExpression* _tmp169_ = NULL;
		ValaCCodeExpression* _tmp170_;
		ValaCCodeFunctionCall* _tmp171_;
		ValaCCodeExpression* _tmp172_;
		ValaCCodeCastExpression* _tmp173_;
		ValaCCodeCastExpression* _tmp174_;
		gboolean _tmp175_;
		_tmp166_ = ccall;
		_tmp167_ = handler;
		_tmp169_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp167_, &_tmp168_);
		_vala_ccode_node_unref0 (handler_destroy_notify);
		handler_destroy_notify = _tmp168_;
		_tmp170_ = _tmp169_;
		vala_ccode_function_call_add_argument (_tmp166_, _tmp170_);
		_vala_ccode_node_unref0 (_tmp170_);
		_tmp171_ = ccall;
		_tmp172_ = handler_destroy_notify;
		_tmp173_ = vala_ccode_cast_expression_new (_tmp172_, "GClosureNotify");
		_tmp174_ = _tmp173_;
		vala_ccode_function_call_add_argument (_tmp171_, (ValaCCodeExpression*) _tmp174_);
		_vala_ccode_node_unref0 (_tmp174_);
		_tmp175_ = after;
		if (!_tmp175_) {
			ValaCCodeFunctionCall* _tmp176_;
			ValaCCodeConstant* _tmp177_;
			ValaCCodeConstant* _tmp178_;
			_tmp176_ = ccall;
			_tmp177_ = vala_ccode_constant_new ("0");
			_tmp178_ = _tmp177_;
			vala_ccode_function_call_add_argument (_tmp176_, (ValaCCodeExpression*) _tmp178_);
			_vala_ccode_node_unref0 (_tmp178_);
		} else {
			ValaCCodeFunctionCall* _tmp179_;
			ValaCCodeConstant* _tmp180_;
			ValaCCodeConstant* _tmp181_;
			_tmp179_ = ccall;
			_tmp180_ = vala_ccode_constant_new ("G_CONNECT_AFTER");
			_tmp181_ = _tmp180_;
			vala_ccode_function_call_add_argument (_tmp179_, (ValaCCodeExpression*) _tmp181_);
			_vala_ccode_node_unref0 (_tmp181_);
		}
		_vala_ccode_node_unref0 (handler_destroy_notify);
	} else {
		ValaMethod* _tmp182_;
		ValaMemberBinding _tmp183_;
		ValaMemberBinding _tmp184_;
		_tmp182_ = m;
		_tmp183_ = vala_method_get_binding (_tmp182_);
		_tmp184_ = _tmp183_;
		if (_tmp184_ == VALA_MEMBER_BINDING_INSTANCE) {
			ValaExpression* _tmp185_;
			gboolean _tmp204_ = FALSE;
			gboolean _tmp205_ = FALSE;
			gboolean _tmp206_;
			gboolean _tmp208_;
			gboolean _tmp211_;
			_tmp185_ = handler;
			if (VALA_IS_MEMBER_ACCESS (_tmp185_)) {
				ValaExpression* _tmp186_;
				ValaMemberAccess* _tmp187_;
				ValaMemberAccess* right_ma;
				ValaMemberAccess* _tmp188_;
				ValaExpression* _tmp189_;
				ValaExpression* _tmp190_;
				_tmp186_ = handler;
				_tmp187_ = _vala_code_node_ref0 (VALA_MEMBER_ACCESS (_tmp186_));
				right_ma = _tmp187_;
				_tmp188_ = right_ma;
				_tmp189_ = vala_member_access_get_inner (_tmp188_);
				_tmp190_ = _tmp189_;
				if (_tmp190_ != NULL) {
					ValaCCodeFunctionCall* _tmp191_;
					ValaMemberAccess* _tmp192_;
					ValaExpression* _tmp193_;
					ValaExpression* _tmp194_;
					ValaCCodeExpression* _tmp195_ = NULL;
					ValaCCodeExpression* _tmp196_;
					_tmp191_ = ccall;
					_tmp192_ = right_ma;
					_tmp193_ = vala_member_access_get_inner (_tmp192_);
					_tmp194_ = _tmp193_;
					_tmp195_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp194_);
					_tmp196_ = _tmp195_;
					vala_ccode_function_call_add_argument (_tmp191_, _tmp196_);
					_vala_ccode_node_unref0 (_tmp196_);
				} else {
					ValaCCodeFunctionCall* _tmp197_;
					ValaCCodeExpression* _tmp198_ = NULL;
					ValaCCodeExpression* _tmp199_;
					_tmp197_ = ccall;
					_tmp198_ = vala_ccode_base_module_get_result_cexpression ((ValaCCodeBaseModule*) self, "self");
					_tmp199_ = _tmp198_;
					vala_ccode_function_call_add_argument (_tmp197_, _tmp199_);
					_vala_ccode_node_unref0 (_tmp199_);
				}
				_vala_code_node_unref0 (right_ma);
			} else {
				ValaExpression* _tmp200_;
				_tmp200_ = handler;
				if (VALA_IS_LAMBDA_EXPRESSION (_tmp200_)) {
					ValaCCodeFunctionCall* _tmp201_;
					ValaCCodeExpression* _tmp202_ = NULL;
					ValaCCodeExpression* _tmp203_;
					_tmp201_ = ccall;
					_tmp202_ = vala_ccode_base_module_get_result_cexpression ((ValaCCodeBaseModule*) self, "self");
					_tmp203_ = _tmp202_;
					vala_ccode_function_call_add_argument (_tmp201_, _tmp203_);
					_vala_ccode_node_unref0 (_tmp203_);
				}
			}
			_tmp206_ = disconnect;
			if (!_tmp206_) {
				ValaSignal* _tmp207_;
				_tmp207_ = sig;
				_tmp205_ = !VALA_IS_DYNAMIC_SIGNAL (_tmp207_);
			} else {
				_tmp205_ = FALSE;
			}
			_tmp208_ = _tmp205_;
			if (_tmp208_) {
				ValaMethod* _tmp209_;
				gboolean _tmp210_ = FALSE;
				_tmp209_ = m;
				_tmp210_ = vala_gsignal_module_in_gobject_instance (self, _tmp209_);
				_tmp204_ = _tmp210_;
			} else {
				_tmp204_ = FALSE;
			}
			_tmp211_ = _tmp204_;
			if (_tmp211_) {
				gboolean _tmp212_;
				_tmp212_ = after;
				if (!_tmp212_) {
					ValaCCodeFunctionCall* _tmp213_;
					ValaCCodeConstant* _tmp214_;
					ValaCCodeConstant* _tmp215_;
					_tmp213_ = ccall;
					_tmp214_ = vala_ccode_constant_new ("0");
					_tmp215_ = _tmp214_;
					vala_ccode_function_call_add_argument (_tmp213_, (ValaCCodeExpression*) _tmp215_);
					_vala_ccode_node_unref0 (_tmp215_);
				} else {
					ValaCCodeFunctionCall* _tmp216_;
					ValaCCodeConstant* _tmp217_;
					ValaCCodeConstant* _tmp218_;
					_tmp216_ = ccall;
					_tmp217_ = vala_ccode_constant_new ("G_CONNECT_AFTER");
					_tmp218_ = _tmp217_;
					vala_ccode_function_call_add_argument (_tmp216_, (ValaCCodeExpression*) _tmp218_);
					_vala_ccode_node_unref0 (_tmp218_);
				}
			}
		} else {
			ValaCCodeFunctionCall* _tmp219_;
			ValaCCodeConstant* _tmp220_;
			ValaCCodeConstant* _tmp221_;
			_tmp219_ = ccall;
			_tmp220_ = vala_ccode_constant_new ("NULL");
			_tmp221_ = _tmp220_;
			vala_ccode_function_call_add_argument (_tmp219_, (ValaCCodeExpression*) _tmp221_);
			_vala_ccode_node_unref0 (_tmp221_);
		}
	}
	_tmp223_ = disconnect;
	if (_tmp223_) {
		_tmp222_ = TRUE;
	} else {
		ValaCodeNode* _tmp224_;
		ValaCodeNode* _tmp225_;
		ValaCodeNode* _tmp226_;
		_tmp224_ = expr;
		_tmp225_ = vala_code_node_get_parent_node (_tmp224_);
		_tmp226_ = _tmp225_;
		_tmp222_ = VALA_IS_EXPRESSION_STATEMENT (_tmp226_);
	}
	_tmp227_ = _tmp222_;
	if (_tmp227_) {
		ValaCCodeFunction* _tmp228_;
		ValaCCodeFunction* _tmp229_;
		ValaCCodeFunctionCall* _tmp230_;
		_tmp228_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp229_ = _tmp228_;
		_tmp230_ = ccall;
		vala_ccode_function_add_expression (_tmp229_, (ValaCCodeExpression*) _tmp230_);
		result = NULL;
		_vala_code_node_unref0 (ma);
		_vala_ccode_node_unref0 (signal_name_cexpr);
		_vala_ccode_node_unref0 (ccall);
		_vala_code_node_unref0 (m);
		_g_free0 (connect_func);
		return result;
	} else {
		ValaDataType* _tmp231_;
		ValaLocalVariable* _tmp232_ = NULL;
		ValaLocalVariable* temp_var;
		ValaLocalVariable* _tmp233_;
		const gchar* _tmp234_;
		const gchar* _tmp235_;
		ValaCCodeExpression* _tmp236_ = NULL;
		ValaCCodeExpression* temp_ref;
		ValaLocalVariable* _tmp237_;
		ValaCCodeFunction* _tmp238_;
		ValaCCodeFunction* _tmp239_;
		ValaCCodeExpression* _tmp240_;
		ValaCCodeFunctionCall* _tmp241_;
		_tmp231_ = ((ValaCCodeBaseModule*) self)->ulong_type;
		_tmp232_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp231_, TRUE, NULL, TRUE);
		temp_var = _tmp232_;
		_tmp233_ = temp_var;
		_tmp234_ = vala_symbol_get_name ((ValaSymbol*) _tmp233_);
		_tmp235_ = _tmp234_;
		_tmp236_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp235_);
		temp_ref = _tmp236_;
		_tmp237_ = temp_var;
		vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp237_);
		_tmp238_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp239_ = _tmp238_;
		_tmp240_ = temp_ref;
		_tmp241_ = ccall;
		vala_ccode_function_add_assignment (_tmp239_, _tmp240_, (ValaCCodeExpression*) _tmp241_);
		result = temp_ref;
		_vala_code_node_unref0 (temp_var);
		_vala_code_node_unref0 (ma);
		_vala_ccode_node_unref0 (signal_name_cexpr);
		_vala_ccode_node_unref0 (ccall);
		_vala_code_node_unref0 (m);
		_g_free0 (connect_func);
		return result;
	}
	_vala_code_node_unref0 (ma);
	_vala_ccode_node_unref0 (signal_name_cexpr);
	_vala_ccode_node_unref0 (ccall);
	_vala_code_node_unref0 (m);
	_g_free0 (connect_func);
}


ValaGSignalModule* vala_gsignal_module_construct (GType object_type) {
	ValaGSignalModule* self = NULL;
	self = (ValaGSignalModule*) vala_gobject_module_construct (object_type);
	return self;
}


ValaGSignalModule* vala_gsignal_module_new (void) {
	return vala_gsignal_module_construct (VALA_TYPE_GSIGNAL_MODULE);
}


static void vala_gsignal_module_class_init (ValaGSignalModuleClass * klass) {
	vala_gsignal_module_parent_class = g_type_class_peek_parent (klass);
	VALA_CODE_VISITOR_CLASS (klass)->visit_signal = vala_gsignal_module_real_visit_signal;
	VALA_CCODE_BASE_MODULE_CLASS (klass)->get_signal_creation = vala_gsignal_module_real_get_signal_creation;
	VALA_CODE_VISITOR_CLASS (klass)->visit_element_access = vala_gsignal_module_real_visit_element_access;
	VALA_CODE_VISITOR_CLASS (klass)->visit_assignment = vala_gsignal_module_real_visit_assignment;
	VALA_CODE_VISITOR_CLASS (klass)->visit_member_access = vala_gsignal_module_real_visit_member_access;
	VALA_CODE_VISITOR_CLASS (klass)->visit_method_call = vala_gsignal_module_real_visit_method_call;
}


static void vala_gsignal_module_instance_init (ValaGSignalModule * self) {
}


GType vala_gsignal_module_get_type (void) {
	static volatile gsize vala_gsignal_module_type_id__volatile = 0;
	if (g_once_init_enter (&vala_gsignal_module_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ValaGSignalModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gsignal_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGSignalModule), 0, (GInstanceInitFunc) vala_gsignal_module_instance_init, NULL };
		GType vala_gsignal_module_type_id;
		vala_gsignal_module_type_id = g_type_register_static (VALA_TYPE_GOBJECT_MODULE, "ValaGSignalModule", &g_define_type_info, 0);
		g_once_init_leave (&vala_gsignal_module_type_id__volatile, vala_gsignal_module_type_id);
	}
	return vala_gsignal_module_type_id__volatile;
}


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);
}