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

/* valagasyncmodule.vala
 *
 * Copyright (C) 2008-2012  Jürg Billeter
 *
 * 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>
 */

#include <glib.h>
#include <glib-object.h>
#include <vala.h>
#include <valaccode.h>
#include <valagee.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <math.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 VALA_TYPE_GTK_MODULE (vala_gtk_module_get_type ())
#define VALA_GTK_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GTK_MODULE, ValaGtkModule))
#define VALA_GTK_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GTK_MODULE, ValaGtkModuleClass))
#define VALA_IS_GTK_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GTK_MODULE))
#define VALA_IS_GTK_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GTK_MODULE))
#define VALA_GTK_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GTK_MODULE, ValaGtkModuleClass))

typedef struct _ValaGtkModule ValaGtkModule;
typedef struct _ValaGtkModuleClass ValaGtkModuleClass;
typedef struct _ValaGtkModulePrivate ValaGtkModulePrivate;

#define VALA_TYPE_GASYNC_MODULE (vala_gasync_module_get_type ())
#define VALA_GASYNC_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GASYNC_MODULE, ValaGAsyncModule))
#define VALA_GASYNC_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GASYNC_MODULE, ValaGAsyncModuleClass))
#define VALA_IS_GASYNC_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GASYNC_MODULE))
#define VALA_IS_GASYNC_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GASYNC_MODULE))
#define VALA_GASYNC_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GASYNC_MODULE, ValaGAsyncModuleClass))

typedef struct _ValaGAsyncModule ValaGAsyncModule;
typedef struct _ValaGAsyncModuleClass ValaGAsyncModuleClass;
typedef struct _ValaGAsyncModulePrivate ValaGAsyncModulePrivate;
#define _g_free0(var) (var = (g_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_ccode_base_module_emit_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_base_module_emit_context_unref (var), NULL)))

#define VALA_TYPE_GLIB_VALUE (vala_glib_value_get_type ())
#define VALA_GLIB_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GLIB_VALUE, ValaGLibValue))
#define VALA_GLIB_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GLIB_VALUE, ValaGLibValueClass))
#define VALA_IS_GLIB_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GLIB_VALUE))
#define VALA_IS_GLIB_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GLIB_VALUE))
#define VALA_GLIB_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GLIB_VALUE, ValaGLibValueClass))

typedef struct _ValaGLibValue ValaGLibValue;
typedef struct _ValaGLibValueClass ValaGLibValueClass;
typedef struct _ValaGLibValuePrivate ValaGLibValuePrivate;
#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)))
typedef struct _ValaCCodeBaseModuleEmitContextPrivate ValaCCodeBaseModuleEmitContextPrivate;

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;
	ValaCCodeEnum* signal_enum;
	ValaSet* user_marshal_set;
	ValaSet* predefined_marshal_set;
	gint next_regex_id;
	gint next_coroutine_state G_GNUC_DEPRECATED;
	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;
	ValaStruct* gmutex_type;
	ValaStruct* grecmutex_type;
	ValaStruct* grwlock_type;
	ValaStruct* gcond_type;
	ValaClass* gsource_type;
	ValaTypeSymbol* type_module_type;
	ValaTypeSymbol* dbus_proxy_type;
	ValaClass* gtk_widget_type;
	gboolean in_plugin;
	gchar* module_init_param_name;
	gboolean gvaluecollector_h_needed;
	gboolean requires_assert;
	gboolean requires_array_free;
	gboolean requires_array_move;
	gboolean requires_array_length;
	gboolean requires_clear_mutex;
	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);
	ValaCCodeExpression* (*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);
	void (*end_instance_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;
};

struct _ValaGtkModule {
	ValaGSignalModule parent_instance;
	ValaGtkModulePrivate * priv;
};

struct _ValaGtkModuleClass {
	ValaGSignalModuleClass parent_class;
};

struct _ValaGAsyncModule {
	ValaGtkModule parent_instance;
	ValaGAsyncModulePrivate * priv;
};

struct _ValaGAsyncModuleClass {
	ValaGtkModuleClass parent_class;
};

struct _ValaGLibValue {
	ValaTargetValue parent_instance;
	ValaGLibValuePrivate * priv;
	ValaCCodeExpression* cvalue;
	gboolean lvalue;
	gboolean non_null;
	gchar* ctype;
	ValaList* array_length_cvalues;
	ValaCCodeExpression* array_size_cvalue;
	gboolean array_null_terminated;
	ValaCCodeExpression* array_length_cexpr;
	ValaCCodeExpression* delegate_target_cvalue;
	ValaCCodeExpression* delegate_target_destroy_notify_cvalue;
};

struct _ValaGLibValueClass {
	ValaTargetValueClass parent_class;
};

struct _ValaCCodeBaseModuleEmitContext {
	GTypeInstance parent_instance;
	volatile int ref_count;
	ValaCCodeBaseModuleEmitContextPrivate * priv;
	ValaSymbol* current_symbol;
	ValaArrayList* symbol_stack;
	ValaTryStatement* current_try;
	ValaCatchClause* current_catch;
	ValaCCodeFunction* ccode;
	ValaArrayList* ccode_stack;
	ValaArrayList* temp_ref_values;
	gint next_temp_var_id;
	gboolean current_method_inner_error;
	gboolean current_method_return;
	ValaMap* variable_name_map;
	ValaMap* closure_variable_count_map;
	ValaMap* closure_variable_clash_map;
	gint next_coroutine_state;
};

struct _ValaCCodeBaseModuleEmitContextClass {
	GTypeClass parent_class;
	void (*finalize) (ValaCCodeBaseModuleEmitContext *self);
};


static gpointer vala_gasync_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;
GType vala_gtk_module_get_type (void) G_GNUC_CONST;
GType vala_gasync_module_get_type (void) G_GNUC_CONST;
enum  {
	VALA_GASYNC_MODULE_DUMMY_PROPERTY
};
static ValaCCodeStruct* vala_gasync_module_generate_data_struct (ValaGAsyncModule* self, ValaMethod* m);
gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);
ValaCodeContext* vala_ccode_base_module_get_context (ValaCCodeBaseModule* self);
gchar* vala_ccode_base_module_get_variable_cname (ValaCCodeBaseModule* self, const gchar* name);
gboolean vala_ccode_base_module_get_ccode_array_length (ValaCodeNode* node);
gchar* vala_ccode_base_module_get_parameter_array_length_cname (ValaCCodeBaseModule* self, ValaParameter* param, gint dim);
gchar* vala_ccode_base_module_get_ccode_delegate_target_name (ValaVariable* variable);
gchar* vala_ccode_base_module_get_delegate_target_destroy_notify_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname);
gchar* vala_ccode_base_module_get_array_length_cname (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim);
gchar* vala_ccode_base_module_get_delegate_target_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname);
static ValaCCodeFunction* vala_gasync_module_generate_free_function (ValaGAsyncModule* self, ValaMethod* m);
gchar* vala_ccode_base_module_get_ccode_real_name (ValaSymbol* sym);
void vala_ccode_base_module_push_context (ValaCCodeBaseModule* self, ValaCCodeBaseModuleEmitContext* emit_context);
ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_new (ValaSymbol* symbol);
ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_construct (GType object_type, ValaSymbol* symbol);
void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func);
ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);
gboolean vala_ccode_base_module_no_implicit_copy (ValaCCodeBaseModule* self, ValaDataType* type);
gboolean vala_ccode_base_module_requires_destroy (ValaCCodeBaseModule* self, ValaDataType* type);
ValaCCodeExpression* vala_ccode_base_module_destroy_parameter (ValaCCodeBaseModule* self, ValaParameter* param);
ValaCCodeExpression* vala_ccode_base_module_destroy_local (ValaCCodeBaseModule* self, ValaLocalVariable* local);
G_GNUC_INTERNAL GType vala_glib_value_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
gboolean vala_ccode_base_module_get_ccode_array_null_terminated (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self);
static void vala_gasync_module_generate_async_ready_callback_wrapper (ValaGAsyncModule* self, ValaMethod* m, const gchar* function_name);
void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self);
static void vala_gasync_module_generate_async_function (ValaGAsyncModule* self, ValaMethod* m);
gint vala_ccode_base_module_get_param_pos (ValaCCodeBaseModule* self, gdouble param_pos, gboolean ellipsis);
void vala_ccode_base_module_generate_cparameters (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value);
ValaTargetValue* vala_ccode_base_module_transform_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* target_type, ValaCodeNode* node);
gboolean vala_ccode_base_module_requires_copy (ValaCCodeBaseModule* self, ValaDataType* type);
ValaTargetValue* vala_ccode_base_module_copy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
void vala_ccode_base_module_emit_context_push_symbol (ValaCCodeBaseModuleEmitContext* self, ValaSymbol* symbol);
ValaMethod* vala_ccode_base_module_get_current_method (ValaCCodeBaseModule* self);
ValaTargetValue* vala_ccode_base_module_get_parameter_cvalue (ValaCCodeBaseModule* self, ValaParameter* param);
void vala_ccode_base_module_emit_context_pop_symbol (ValaCCodeBaseModuleEmitContext* self);
static void vala_gasync_module_append_struct (ValaGAsyncModule* self, ValaCCodeStruct* structure);
static void vala_gasync_module_real_generate_method_declaration (ValaCCodeBaseModule* base, ValaMethod* m, ValaCCodeFile* decl_space);
gboolean vala_ccode_base_module_add_symbol_declaration (ValaCCodeBaseModule* self, ValaCCodeFile* decl_space, ValaSymbol* sym, const gchar* name);
gchar* vala_ccode_base_module_get_ccode_finish_name (ValaMethod* m);
gchar* vala_ccode_base_module_get_ccode_finish_real_name (ValaMethod* m);
void vala_ccode_base_module_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
static void vala_gasync_module_real_visit_method (ValaCodeVisitor* base, ValaMethod* m);
static void vala_gasync_module_generate_finish_function (ValaGAsyncModule* self, ValaMethod* m);
void vala_ccode_method_module_generate_vfunc (ValaCCodeMethodModule* self, ValaMethod* m, ValaDataType* return_type, ValaMap* cparam_map, ValaMap* carg_map, const gchar* suffix, gint direction);
static void vala_gasync_module_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m);
void vala_ccode_base_module_push_line (ValaCCodeBaseModule* self, ValaSourceReference* source_reference);
ValaTypeSymbol* vala_ccode_base_module_get_current_type_symbol (ValaCCodeBaseModule* self);
ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self);
gchar* vala_ccode_base_module_get_ccode_type_id (ValaCodeNode* node);
void vala_ccode_base_module_pop_line (ValaCCodeBaseModule* self);
void vala_ccode_base_module_return_default_value (ValaCCodeBaseModule* self, ValaDataType* return_type);
void vala_ccode_base_module_return_out_parameter (ValaCCodeBaseModule* self, ValaParameter* param);
static gchar* vala_gasync_module_real_generate_ready_function (ValaCCodeBaseModule* base, ValaMethod* m);
gboolean vala_ccode_base_module_add_wrapper (ValaCCodeBaseModule* self, const gchar* wrapper_name);
static void vala_gasync_module_real_generate_virtual_method_declaration (ValaGTypeModule* base, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeStruct* type_struct);
void vala_gtype_module_generate_virtual_method_declaration (ValaGTypeModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeStruct* type_struct);
gchar* vala_ccode_base_module_get_ccode_vfunc_name (ValaMethod* m);
gchar* vala_ccode_base_module_get_ccode_finish_vfunc_name (ValaMethod* m);
static void vala_gasync_module_real_visit_yield_statement (ValaCodeVisitor* base, ValaYieldStatement* stmt);
gboolean vala_ccode_base_module_is_in_coroutine (ValaCCodeBaseModule* self);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr);
void vala_ccode_base_module_add_simple_check (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);
ValaArrayList* vala_ccode_base_module_get_temp_ref_values (ValaCCodeBaseModule* self);
static void vala_gasync_module_real_return_with_exception (ValaGErrorModule* base, ValaCCodeExpression* error_expr);
void vala_gerror_module_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr);
void vala_ccode_base_module_append_local_free (ValaCCodeBaseModule* self, ValaSymbol* sym, gboolean stop_at_loop, ValaCodeNode* stop_at);
ValaSymbol* vala_ccode_base_module_get_current_symbol (ValaCCodeBaseModule* self);
void vala_ccode_method_module_complete_async (ValaCCodeMethodModule* self);
static void vala_gasync_module_real_visit_return_statement (ValaCodeVisitor* base, ValaReturnStatement* stmt);
static void vala_gasync_module_real_generate_cparameters (ValaCCodeBaseModule* base, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);
gchar* vala_gasync_module_generate_async_callback_wrapper (ValaGAsyncModule* self);
ValaGAsyncModule* vala_gasync_module_new (void);
ValaGAsyncModule* vala_gasync_module_construct (GType object_type);
ValaGtkModule* vala_gtk_module_new (void);
ValaGtkModule* vala_gtk_module_construct (GType object_type);


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


static ValaCCodeStruct* vala_gasync_module_generate_data_struct (ValaGAsyncModule* self, ValaMethod* m) {
	ValaCCodeStruct* result = NULL;
	gchar* dataname = NULL;
	ValaMethod* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	ValaCCodeStruct* data = NULL;
	const gchar* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	ValaCCodeStruct* _tmp10_;
	ValaCCodeStruct* _tmp11_;
	ValaCCodeStruct* _tmp12_;
	ValaCCodeStruct* _tmp13_;
	ValaCCodeStruct* _tmp14_;
	ValaCodeContext* _tmp15_;
	ValaCodeContext* _tmp16_;
	gboolean _tmp17_;
	ValaMethod* _tmp25_;
	ValaMethod* _tmp27_;
	ValaMemberBinding _tmp28_;
	ValaMemberBinding _tmp29_;
	ValaMethod* _tmp159_;
	ValaDataType* _tmp160_;
	ValaDataType* _tmp161_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_symbol_lower_case_to_camel_case (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strconcat (_tmp4_, "Data", NULL);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	_g_free0 (_tmp2_);
	dataname = _tmp6_;
	_tmp7_ = dataname;
	_tmp8_ = g_strconcat ("_", _tmp7_, NULL);
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_ccode_struct_new (_tmp9_);
	_tmp11_ = _tmp10_;
	_g_free0 (_tmp9_);
	data = _tmp11_;
	_tmp12_ = data;
	vala_ccode_struct_add_field (_tmp12_, "int", "_state_", 0, NULL);
	_tmp13_ = data;
	vala_ccode_struct_add_field (_tmp13_, "GObject*", "_source_object_", 0, NULL);
	_tmp14_ = data;
	vala_ccode_struct_add_field (_tmp14_, "GAsyncResult*", "_res_", 0, NULL);
	_tmp15_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp16_ = _tmp15_;
	_tmp17_ = vala_code_context_require_glib_version (_tmp16_, 2, 36);
	if (_tmp17_) {
		ValaCCodeStruct* _tmp18_;
		ValaCodeContext* _tmp19_;
		ValaCodeContext* _tmp20_;
		gboolean _tmp21_;
		_tmp18_ = data;
		vala_ccode_struct_add_field (_tmp18_, "GTask*", "_async_result", 0, NULL);
		_tmp19_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp20_ = _tmp19_;
		_tmp21_ = vala_code_context_require_glib_version (_tmp20_, 2, 44);
		if (!_tmp21_) {
			ValaCCodeStruct* _tmp22_;
			ValaCCodeStruct* _tmp23_;
			_tmp22_ = data;
			vala_ccode_struct_add_field (_tmp22_, "GAsyncReadyCallback", "_callback_", 0, NULL);
			_tmp23_ = data;
			vala_ccode_struct_add_field (_tmp23_, "gboolean", "_task_complete_", 0, NULL);
		}
	} else {
		ValaCCodeStruct* _tmp24_;
		_tmp24_ = data;
		vala_ccode_struct_add_field (_tmp24_, "GSimpleAsyncResult*", "_async_result", 0, NULL);
	}
	_tmp25_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_CREATION_METHOD)) {
		ValaCCodeStruct* _tmp26_;
		_tmp26_ = data;
		vala_ccode_struct_add_field (_tmp26_, "GType", "object_type", 0, NULL);
	}
	_tmp27_ = m;
	_tmp28_ = vala_method_get_binding (_tmp27_);
	_tmp29_ = _tmp28_;
	if (_tmp29_ == VALA_MEMBER_BINDING_INSTANCE) {
		ValaTypeSymbol* type_sym = NULL;
		ValaMethod* _tmp30_;
		ValaSymbol* _tmp31_;
		ValaSymbol* _tmp32_;
		ValaTypeSymbol* _tmp33_;
		ValaTypeSymbol* _tmp34_;
		_tmp30_ = m;
		_tmp31_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp30_);
		_tmp32_ = _tmp31_;
		_tmp33_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp32_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
		type_sym = _tmp33_;
		_tmp34_ = type_sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp34_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) {
			ValaCCodeStruct* _tmp35_;
			ValaTypeSymbol* _tmp36_;
			gchar* _tmp37_;
			gchar* _tmp38_;
			gchar* _tmp39_;
			gchar* _tmp40_;
			_tmp35_ = data;
			_tmp36_ = type_sym;
			_tmp37_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp36_);
			_tmp38_ = _tmp37_;
			_tmp39_ = g_strconcat (_tmp38_, "*", NULL);
			_tmp40_ = _tmp39_;
			vala_ccode_struct_add_field (_tmp35_, _tmp40_, "self", 0, NULL);
			_g_free0 (_tmp40_);
			_g_free0 (_tmp38_);
		} else {
			ValaCCodeStruct* _tmp41_;
			ValaTypeSymbol* _tmp42_;
			gchar* _tmp43_;
			gchar* _tmp44_;
			_tmp41_ = data;
			_tmp42_ = type_sym;
			_tmp43_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp42_);
			_tmp44_ = _tmp43_;
			vala_ccode_struct_add_field (_tmp41_, _tmp44_, "self", 0, NULL);
			_g_free0 (_tmp44_);
		}
		_vala_code_node_unref0 (type_sym);
	}
	{
		ValaList* _param_list = NULL;
		ValaMethod* _tmp45_;
		ValaList* _tmp46_;
		gint _param_size = 0;
		ValaList* _tmp47_;
		gint _tmp48_;
		gint _tmp49_;
		gint _param_index = 0;
		_tmp45_ = m;
		_tmp46_ = vala_callable_get_parameters ((ValaCallable*) _tmp45_);
		_param_list = _tmp46_;
		_tmp47_ = _param_list;
		_tmp48_ = vala_collection_get_size ((ValaCollection*) _tmp47_);
		_tmp49_ = _tmp48_;
		_param_size = _tmp49_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp50_;
			gint _tmp51_;
			gint _tmp52_;
			ValaParameter* param = NULL;
			ValaList* _tmp53_;
			gint _tmp54_;
			gpointer _tmp55_;
			gboolean _tmp56_ = FALSE;
			ValaParameter* _tmp57_;
			ValaDataType* _tmp58_;
			ValaDataType* _tmp59_;
			gboolean is_unowned_delegate = FALSE;
			ValaDataType* param_type = NULL;
			ValaParameter* _tmp65_;
			ValaDataType* _tmp66_;
			ValaDataType* _tmp67_;
			ValaDataType* _tmp68_;
			ValaDataType* _tmp69_;
			ValaCCodeStruct* _tmp70_;
			ValaDataType* _tmp71_;
			gchar* _tmp72_;
			gchar* _tmp73_;
			ValaParameter* _tmp74_;
			const gchar* _tmp75_;
			const gchar* _tmp76_;
			gchar* _tmp77_;
			gchar* _tmp78_;
			ValaParameter* _tmp79_;
			ValaDataType* _tmp80_;
			ValaDataType* _tmp81_;
			_tmp50_ = _param_index;
			_param_index = _tmp50_ + 1;
			_tmp51_ = _param_index;
			_tmp52_ = _param_size;
			if (!(_tmp51_ < _tmp52_)) {
				break;
			}
			_tmp53_ = _param_list;
			_tmp54_ = _param_index;
			_tmp55_ = vala_list_get (_tmp53_, _tmp54_);
			param = (ValaParameter*) _tmp55_;
			_tmp57_ = param;
			_tmp58_ = vala_variable_get_variable_type ((ValaVariable*) _tmp57_);
			_tmp59_ = _tmp58_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp59_, VALA_TYPE_DELEGATE_TYPE)) {
				ValaParameter* _tmp60_;
				ValaDataType* _tmp61_;
				ValaDataType* _tmp62_;
				gboolean _tmp63_;
				gboolean _tmp64_;
				_tmp60_ = param;
				_tmp61_ = vala_variable_get_variable_type ((ValaVariable*) _tmp60_);
				_tmp62_ = _tmp61_;
				_tmp63_ = vala_data_type_get_value_owned (_tmp62_);
				_tmp64_ = _tmp63_;
				_tmp56_ = !_tmp64_;
			} else {
				_tmp56_ = FALSE;
			}
			is_unowned_delegate = _tmp56_;
			_tmp65_ = param;
			_tmp66_ = vala_variable_get_variable_type ((ValaVariable*) _tmp65_);
			_tmp67_ = _tmp66_;
			_tmp68_ = vala_data_type_copy (_tmp67_);
			param_type = _tmp68_;
			_tmp69_ = param_type;
			vala_data_type_set_value_owned (_tmp69_, TRUE);
			_tmp70_ = data;
			_tmp71_ = param_type;
			_tmp72_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp71_);
			_tmp73_ = _tmp72_;
			_tmp74_ = param;
			_tmp75_ = vala_symbol_get_name ((ValaSymbol*) _tmp74_);
			_tmp76_ = _tmp75_;
			_tmp77_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp76_);
			_tmp78_ = _tmp77_;
			vala_ccode_struct_add_field (_tmp70_, _tmp73_, _tmp78_, 0, NULL);
			_g_free0 (_tmp78_);
			_g_free0 (_tmp73_);
			_tmp79_ = param;
			_tmp80_ = vala_variable_get_variable_type ((ValaVariable*) _tmp79_);
			_tmp81_ = _tmp80_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp81_, VALA_TYPE_ARRAY_TYPE)) {
				ValaArrayType* array_type = NULL;
				ValaParameter* _tmp82_;
				ValaDataType* _tmp83_;
				ValaDataType* _tmp84_;
				ValaArrayType* _tmp85_;
				ValaParameter* _tmp86_;
				gboolean _tmp87_;
				_tmp82_ = param;
				_tmp83_ = vala_variable_get_variable_type ((ValaVariable*) _tmp82_);
				_tmp84_ = _tmp83_;
				_tmp85_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp84_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
				array_type = _tmp85_;
				_tmp86_ = param;
				_tmp87_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp86_);
				if (_tmp87_) {
					{
						gint dim = 0;
						dim = 1;
						{
							gboolean _tmp88_ = FALSE;
							_tmp88_ = TRUE;
							while (TRUE) {
								gint _tmp90_;
								ValaArrayType* _tmp91_;
								gint _tmp92_;
								gint _tmp93_;
								ValaCCodeStruct* _tmp94_;
								ValaParameter* _tmp95_;
								gint _tmp96_;
								gchar* _tmp97_;
								gchar* _tmp98_;
								if (!_tmp88_) {
									gint _tmp89_;
									_tmp89_ = dim;
									dim = _tmp89_ + 1;
								}
								_tmp88_ = FALSE;
								_tmp90_ = dim;
								_tmp91_ = array_type;
								_tmp92_ = vala_array_type_get_rank (_tmp91_);
								_tmp93_ = _tmp92_;
								if (!(_tmp90_ <= _tmp93_)) {
									break;
								}
								_tmp94_ = data;
								_tmp95_ = param;
								_tmp96_ = dim;
								_tmp97_ = vala_ccode_base_module_get_parameter_array_length_cname ((ValaCCodeBaseModule*) self, _tmp95_, _tmp96_);
								_tmp98_ = _tmp97_;
								vala_ccode_struct_add_field (_tmp94_, "gint", _tmp98_, 0, NULL);
								_g_free0 (_tmp98_);
							}
						}
					}
				}
				_vala_code_node_unref0 (array_type);
			} else {
				ValaParameter* _tmp99_;
				ValaDataType* _tmp100_;
				ValaDataType* _tmp101_;
				_tmp99_ = param;
				_tmp100_ = vala_variable_get_variable_type ((ValaVariable*) _tmp99_);
				_tmp101_ = _tmp100_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp101_, VALA_TYPE_DELEGATE_TYPE)) {
					ValaDelegateType* deleg_type = NULL;
					ValaParameter* _tmp102_;
					ValaDataType* _tmp103_;
					ValaDataType* _tmp104_;
					ValaDelegateType* _tmp105_;
					ValaDelegateType* _tmp106_;
					ValaDelegate* _tmp107_;
					ValaDelegate* _tmp108_;
					gboolean _tmp109_;
					gboolean _tmp110_;
					_tmp102_ = param;
					_tmp103_ = vala_variable_get_variable_type ((ValaVariable*) _tmp102_);
					_tmp104_ = _tmp103_;
					_tmp105_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp104_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
					deleg_type = _tmp105_;
					_tmp106_ = deleg_type;
					_tmp107_ = vala_delegate_type_get_delegate_symbol (_tmp106_);
					_tmp108_ = _tmp107_;
					_tmp109_ = vala_delegate_get_has_target (_tmp108_);
					_tmp110_ = _tmp109_;
					if (_tmp110_) {
						ValaCCodeStruct* _tmp111_;
						ValaParameter* _tmp112_;
						gchar* _tmp113_;
						gchar* _tmp114_;
						gboolean _tmp115_;
						_tmp111_ = data;
						_tmp112_ = param;
						_tmp113_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp112_);
						_tmp114_ = _tmp113_;
						vala_ccode_struct_add_field (_tmp111_, "gpointer", _tmp114_, 0, NULL);
						_g_free0 (_tmp114_);
						_tmp115_ = is_unowned_delegate;
						if (!_tmp115_) {
							ValaCCodeStruct* _tmp116_;
							ValaParameter* _tmp117_;
							const gchar* _tmp118_;
							const gchar* _tmp119_;
							gchar* _tmp120_;
							gchar* _tmp121_;
							gchar* _tmp122_;
							gchar* _tmp123_;
							_tmp116_ = data;
							_tmp117_ = param;
							_tmp118_ = vala_symbol_get_name ((ValaSymbol*) _tmp117_);
							_tmp119_ = _tmp118_;
							_tmp120_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp119_);
							_tmp121_ = _tmp120_;
							_tmp122_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp121_);
							_tmp123_ = _tmp122_;
							vala_ccode_struct_add_field (_tmp116_, "GDestroyNotify", _tmp123_, 0, NULL);
							_g_free0 (_tmp123_);
							_g_free0 (_tmp121_);
						}
					}
					_vala_code_node_unref0 (deleg_type);
				}
			}
			_vala_code_node_unref0 (param_type);
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
	{
		ValaList* _type_param_list = NULL;
		ValaMethod* _tmp124_;
		ValaList* _tmp125_;
		gint _type_param_size = 0;
		ValaList* _tmp126_;
		gint _tmp127_;
		gint _tmp128_;
		gint _type_param_index = 0;
		_tmp124_ = m;
		_tmp125_ = vala_method_get_type_parameters (_tmp124_);
		_type_param_list = _tmp125_;
		_tmp126_ = _type_param_list;
		_tmp127_ = vala_collection_get_size ((ValaCollection*) _tmp126_);
		_tmp128_ = _tmp127_;
		_type_param_size = _tmp128_;
		_type_param_index = -1;
		while (TRUE) {
			gint _tmp129_;
			gint _tmp130_;
			gint _tmp131_;
			ValaTypeParameter* type_param = NULL;
			ValaList* _tmp132_;
			gint _tmp133_;
			gpointer _tmp134_;
			ValaCCodeStruct* _tmp135_;
			ValaTypeParameter* _tmp136_;
			const gchar* _tmp137_;
			const gchar* _tmp138_;
			gchar* _tmp139_;
			gchar* _tmp140_;
			gchar* _tmp141_;
			gchar* _tmp142_;
			ValaCCodeStruct* _tmp143_;
			ValaTypeParameter* _tmp144_;
			const gchar* _tmp145_;
			const gchar* _tmp146_;
			gchar* _tmp147_;
			gchar* _tmp148_;
			gchar* _tmp149_;
			gchar* _tmp150_;
			ValaCCodeStruct* _tmp151_;
			ValaTypeParameter* _tmp152_;
			const gchar* _tmp153_;
			const gchar* _tmp154_;
			gchar* _tmp155_;
			gchar* _tmp156_;
			gchar* _tmp157_;
			gchar* _tmp158_;
			_tmp129_ = _type_param_index;
			_type_param_index = _tmp129_ + 1;
			_tmp130_ = _type_param_index;
			_tmp131_ = _type_param_size;
			if (!(_tmp130_ < _tmp131_)) {
				break;
			}
			_tmp132_ = _type_param_list;
			_tmp133_ = _type_param_index;
			_tmp134_ = vala_list_get (_tmp132_, _tmp133_);
			type_param = (ValaTypeParameter*) _tmp134_;
			_tmp135_ = data;
			_tmp136_ = type_param;
			_tmp137_ = vala_symbol_get_name ((ValaSymbol*) _tmp136_);
			_tmp138_ = _tmp137_;
			_tmp139_ = g_utf8_strdown (_tmp138_, (gssize) -1);
			_tmp140_ = _tmp139_;
			_tmp141_ = g_strdup_printf ("%s_type", _tmp140_);
			_tmp142_ = _tmp141_;
			vala_ccode_struct_add_field (_tmp135_, "GType", _tmp142_, 0, NULL);
			_g_free0 (_tmp142_);
			_g_free0 (_tmp140_);
			_tmp143_ = data;
			_tmp144_ = type_param;
			_tmp145_ = vala_symbol_get_name ((ValaSymbol*) _tmp144_);
			_tmp146_ = _tmp145_;
			_tmp147_ = g_utf8_strdown (_tmp146_, (gssize) -1);
			_tmp148_ = _tmp147_;
			_tmp149_ = g_strdup_printf ("%s_dup_func", _tmp148_);
			_tmp150_ = _tmp149_;
			vala_ccode_struct_add_field (_tmp143_, "GBoxedCopyFunc", _tmp150_, 0, NULL);
			_g_free0 (_tmp150_);
			_g_free0 (_tmp148_);
			_tmp151_ = data;
			_tmp152_ = type_param;
			_tmp153_ = vala_symbol_get_name ((ValaSymbol*) _tmp152_);
			_tmp154_ = _tmp153_;
			_tmp155_ = g_utf8_strdown (_tmp154_, (gssize) -1);
			_tmp156_ = _tmp155_;
			_tmp157_ = g_strdup_printf ("%s_destroy_func", _tmp156_);
			_tmp158_ = _tmp157_;
			vala_ccode_struct_add_field (_tmp151_, "GDestroyNotify", _tmp158_, 0, NULL);
			_g_free0 (_tmp158_);
			_g_free0 (_tmp156_);
			_vala_code_node_unref0 (type_param);
		}
		_vala_iterable_unref0 (_type_param_list);
	}
	_tmp159_ = m;
	_tmp160_ = vala_callable_get_return_type ((ValaCallable*) _tmp159_);
	_tmp161_ = _tmp160_;
	if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp161_, VALA_TYPE_VOID_TYPE)) {
		ValaCCodeStruct* _tmp162_;
		ValaMethod* _tmp163_;
		ValaDataType* _tmp164_;
		ValaDataType* _tmp165_;
		gchar* _tmp166_;
		gchar* _tmp167_;
		ValaMethod* _tmp168_;
		ValaDataType* _tmp169_;
		ValaDataType* _tmp170_;
		_tmp162_ = data;
		_tmp163_ = m;
		_tmp164_ = vala_callable_get_return_type ((ValaCallable*) _tmp163_);
		_tmp165_ = _tmp164_;
		_tmp166_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp165_);
		_tmp167_ = _tmp166_;
		vala_ccode_struct_add_field (_tmp162_, _tmp167_, "result", 0, NULL);
		_g_free0 (_tmp167_);
		_tmp168_ = m;
		_tmp169_ = vala_callable_get_return_type ((ValaCallable*) _tmp168_);
		_tmp170_ = _tmp169_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp170_, VALA_TYPE_ARRAY_TYPE)) {
			ValaArrayType* array_type = NULL;
			ValaMethod* _tmp171_;
			ValaDataType* _tmp172_;
			ValaDataType* _tmp173_;
			ValaArrayType* _tmp174_;
			ValaMethod* _tmp175_;
			gboolean _tmp176_;
			_tmp171_ = m;
			_tmp172_ = vala_callable_get_return_type ((ValaCallable*) _tmp171_);
			_tmp173_ = _tmp172_;
			_tmp174_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp173_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			array_type = _tmp174_;
			_tmp175_ = m;
			_tmp176_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp175_);
			if (_tmp176_) {
				{
					gint dim = 0;
					dim = 1;
					{
						gboolean _tmp177_ = FALSE;
						_tmp177_ = TRUE;
						while (TRUE) {
							gint _tmp179_;
							ValaArrayType* _tmp180_;
							gint _tmp181_;
							gint _tmp182_;
							ValaCCodeStruct* _tmp183_;
							gint _tmp184_;
							gchar* _tmp185_;
							gchar* _tmp186_;
							if (!_tmp177_) {
								gint _tmp178_;
								_tmp178_ = dim;
								dim = _tmp178_ + 1;
							}
							_tmp177_ = FALSE;
							_tmp179_ = dim;
							_tmp180_ = array_type;
							_tmp181_ = vala_array_type_get_rank (_tmp180_);
							_tmp182_ = _tmp181_;
							if (!(_tmp179_ <= _tmp182_)) {
								break;
							}
							_tmp183_ = data;
							_tmp184_ = dim;
							_tmp185_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", _tmp184_);
							_tmp186_ = _tmp185_;
							vala_ccode_struct_add_field (_tmp183_, "gint", _tmp186_, 0, NULL);
							_g_free0 (_tmp186_);
						}
					}
				}
			}
			_vala_code_node_unref0 (array_type);
		} else {
			ValaMethod* _tmp187_;
			ValaDataType* _tmp188_;
			ValaDataType* _tmp189_;
			_tmp187_ = m;
			_tmp188_ = vala_callable_get_return_type ((ValaCallable*) _tmp187_);
			_tmp189_ = _tmp188_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp189_, VALA_TYPE_DELEGATE_TYPE)) {
				ValaDelegateType* deleg_type = NULL;
				ValaMethod* _tmp190_;
				ValaDataType* _tmp191_;
				ValaDataType* _tmp192_;
				ValaDelegateType* _tmp193_;
				ValaDelegateType* _tmp194_;
				ValaDelegate* _tmp195_;
				ValaDelegate* _tmp196_;
				gboolean _tmp197_;
				gboolean _tmp198_;
				_tmp190_ = m;
				_tmp191_ = vala_callable_get_return_type ((ValaCallable*) _tmp190_);
				_tmp192_ = _tmp191_;
				_tmp193_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp192_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
				deleg_type = _tmp193_;
				_tmp194_ = deleg_type;
				_tmp195_ = vala_delegate_type_get_delegate_symbol (_tmp194_);
				_tmp196_ = _tmp195_;
				_tmp197_ = vala_delegate_get_has_target (_tmp196_);
				_tmp198_ = _tmp197_;
				if (_tmp198_) {
					ValaCCodeStruct* _tmp199_;
					gchar* _tmp200_;
					gchar* _tmp201_;
					ValaCCodeStruct* _tmp202_;
					gchar* _tmp203_;
					gchar* _tmp204_;
					_tmp199_ = data;
					_tmp200_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, "result");
					_tmp201_ = _tmp200_;
					vala_ccode_struct_add_field (_tmp199_, "gpointer", _tmp201_, 0, NULL);
					_g_free0 (_tmp201_);
					_tmp202_ = data;
					_tmp203_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, "result");
					_tmp204_ = _tmp203_;
					vala_ccode_struct_add_field (_tmp202_, "GDestroyNotify", _tmp204_, 0, NULL);
					_g_free0 (_tmp204_);
				}
				_vala_code_node_unref0 (deleg_type);
			}
		}
	}
	result = data;
	_g_free0 (dataname);
	return result;
}


static ValaCCodeFunction* vala_gasync_module_generate_free_function (ValaGAsyncModule* self, ValaMethod* m) {
	ValaCCodeFunction* result = NULL;
	gchar* dataname = NULL;
	ValaMethod* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	ValaCCodeFunction* freefunc = NULL;
	ValaMethod* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaCCodeFunction* _tmp13_;
	ValaCCodeFunction* _tmp14_;
	ValaCCodeFunction* _tmp15_;
	ValaCCodeParameter* _tmp16_;
	ValaCCodeParameter* _tmp17_;
	ValaMethod* _tmp18_;
	ValaCCodeBaseModuleEmitContext* _tmp19_;
	ValaCCodeBaseModuleEmitContext* _tmp20_;
	ValaCCodeFunction* _tmp21_;
	ValaCCodeFunction* _tmp22_;
	ValaCCodeFunction* _tmp23_;
	const gchar* _tmp24_;
	gchar* _tmp25_;
	gchar* _tmp26_;
	ValaCCodeIdentifier* _tmp27_;
	ValaCCodeIdentifier* _tmp28_;
	ValaCCodeVariableDeclarator* _tmp29_;
	ValaCCodeVariableDeclarator* _tmp30_;
	ValaMethod* _tmp66_;
	ValaDataType* _tmp67_;
	ValaDataType* _tmp68_;
	gboolean _tmp69_;
	ValaMethod* _tmp100_;
	ValaMemberBinding _tmp101_;
	ValaMemberBinding _tmp102_;
	ValaCCodeFunctionCall* freecall = NULL;
	ValaCCodeIdentifier* _tmp119_;
	ValaCCodeIdentifier* _tmp120_;
	ValaCCodeFunctionCall* _tmp121_;
	ValaCCodeFunctionCall* _tmp122_;
	const gchar* _tmp123_;
	ValaCCodeIdentifier* _tmp124_;
	ValaCCodeIdentifier* _tmp125_;
	ValaCCodeIdentifier* _tmp126_;
	ValaCCodeIdentifier* _tmp127_;
	ValaCCodeFunction* _tmp128_;
	ValaCCodeFunction* _tmp129_;
	ValaCCodeFile* _tmp130_;
	ValaCCodeFunction* _tmp131_;
	ValaCCodeFile* _tmp132_;
	ValaCCodeFunction* _tmp133_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_symbol_lower_case_to_camel_case (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strconcat (_tmp4_, "Data", NULL);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	_g_free0 (_tmp2_);
	dataname = _tmp6_;
	_tmp7_ = m;
	_tmp8_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = g_strconcat (_tmp9_, "_data_free", NULL);
	_tmp11_ = _tmp10_;
	_tmp12_ = vala_ccode_function_new (_tmp11_, "void");
	_tmp13_ = _tmp12_;
	_g_free0 (_tmp11_);
	_g_free0 (_tmp9_);
	freefunc = _tmp13_;
	_tmp14_ = freefunc;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp14_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp15_ = freefunc;
	_tmp16_ = vala_ccode_parameter_new ("_data", "gpointer");
	_tmp17_ = _tmp16_;
	vala_ccode_function_add_parameter (_tmp15_, _tmp17_);
	_vala_ccode_node_unref0 (_tmp17_);
	_tmp18_ = m;
	_tmp19_ = vala_ccode_base_module_emit_context_new ((ValaSymbol*) _tmp18_);
	_tmp20_ = _tmp19_;
	vala_ccode_base_module_push_context ((ValaCCodeBaseModule*) self, _tmp20_);
	_vala_ccode_base_module_emit_context_unref0 (_tmp20_);
	_tmp21_ = freefunc;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp21_);
	_tmp22_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp23_ = _tmp22_;
	_tmp24_ = dataname;
	_tmp25_ = g_strconcat (_tmp24_, "*", NULL);
	_tmp26_ = _tmp25_;
	_tmp27_ = vala_ccode_identifier_new ("_data");
	_tmp28_ = _tmp27_;
	_tmp29_ = vala_ccode_variable_declarator_new ("_data_", (ValaCCodeExpression*) _tmp28_, NULL);
	_tmp30_ = _tmp29_;
	vala_ccode_function_add_declaration (_tmp23_, _tmp26_, (ValaCCodeDeclarator*) _tmp30_, 0);
	_vala_ccode_node_unref0 (_tmp30_);
	_vala_ccode_node_unref0 (_tmp28_);
	_g_free0 (_tmp26_);
	{
		ValaList* _param_list = NULL;
		ValaMethod* _tmp31_;
		ValaList* _tmp32_;
		gint _param_size = 0;
		ValaList* _tmp33_;
		gint _tmp34_;
		gint _tmp35_;
		gint _param_index = 0;
		_tmp31_ = m;
		_tmp32_ = vala_callable_get_parameters ((ValaCallable*) _tmp31_);
		_param_list = _tmp32_;
		_tmp33_ = _param_list;
		_tmp34_ = vala_collection_get_size ((ValaCollection*) _tmp33_);
		_tmp35_ = _tmp34_;
		_param_size = _tmp35_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp36_;
			gint _tmp37_;
			gint _tmp38_;
			ValaParameter* param = NULL;
			ValaList* _tmp39_;
			gint _tmp40_;
			gpointer _tmp41_;
			gboolean _tmp42_ = FALSE;
			ValaParameter* _tmp43_;
			gboolean _tmp44_;
			gboolean _tmp45_;
			_tmp36_ = _param_index;
			_param_index = _tmp36_ + 1;
			_tmp37_ = _param_index;
			_tmp38_ = _param_size;
			if (!(_tmp37_ < _tmp38_)) {
				break;
			}
			_tmp39_ = _param_list;
			_tmp40_ = _param_index;
			_tmp41_ = vala_list_get (_tmp39_, _tmp40_);
			param = (ValaParameter*) _tmp41_;
			_tmp43_ = param;
			_tmp44_ = vala_parameter_get_captured (_tmp43_);
			_tmp45_ = _tmp44_;
			if (!_tmp45_) {
				ValaParameter* _tmp46_;
				ValaParameterDirection _tmp47_;
				ValaParameterDirection _tmp48_;
				_tmp46_ = param;
				_tmp47_ = vala_parameter_get_direction (_tmp46_);
				_tmp48_ = _tmp47_;
				_tmp42_ = _tmp48_ != VALA_PARAMETER_DIRECTION_OUT;
			} else {
				_tmp42_ = FALSE;
			}
			if (_tmp42_) {
				ValaDataType* param_type = NULL;
				ValaParameter* _tmp49_;
				ValaDataType* _tmp50_;
				ValaDataType* _tmp51_;
				ValaDataType* _tmp52_;
				ValaDataType* _tmp53_;
				gboolean _tmp54_;
				gboolean _tmp55_;
				ValaDataType* _tmp59_;
				gboolean _tmp60_;
				_tmp49_ = param;
				_tmp50_ = vala_variable_get_variable_type ((ValaVariable*) _tmp49_);
				_tmp51_ = _tmp50_;
				_tmp52_ = vala_data_type_copy (_tmp51_);
				param_type = _tmp52_;
				_tmp53_ = param_type;
				_tmp54_ = vala_data_type_get_value_owned (_tmp53_);
				_tmp55_ = _tmp54_;
				if (!_tmp55_) {
					ValaDataType* _tmp56_;
					ValaDataType* _tmp57_;
					gboolean _tmp58_;
					_tmp56_ = param_type;
					_tmp57_ = param_type;
					_tmp58_ = vala_ccode_base_module_no_implicit_copy ((ValaCCodeBaseModule*) self, _tmp57_);
					vala_data_type_set_value_owned (_tmp56_, !_tmp58_);
				}
				_tmp59_ = param_type;
				_tmp60_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp59_);
				if (_tmp60_) {
					ValaCCodeFunction* _tmp61_;
					ValaCCodeFunction* _tmp62_;
					ValaParameter* _tmp63_;
					ValaCCodeExpression* _tmp64_;
					ValaCCodeExpression* _tmp65_;
					_tmp61_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp62_ = _tmp61_;
					_tmp63_ = param;
					_tmp64_ = vala_ccode_base_module_destroy_parameter ((ValaCCodeBaseModule*) self, _tmp63_);
					_tmp65_ = _tmp64_;
					vala_ccode_function_add_expression (_tmp62_, _tmp65_);
					_vala_ccode_node_unref0 (_tmp65_);
				}
				_vala_code_node_unref0 (param_type);
			}
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
	_tmp66_ = m;
	_tmp67_ = vala_callable_get_return_type ((ValaCallable*) _tmp66_);
	_tmp68_ = _tmp67_;
	_tmp69_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp68_);
	if (_tmp69_) {
		gboolean _tmp70_ = FALSE;
		ValaMethod* _tmp71_;
		gboolean _tmp72_;
		_tmp71_ = m;
		_tmp72_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp71_);
		if (_tmp72_) {
			_tmp70_ = TRUE;
		} else {
			ValaMethod* _tmp73_;
			ValaDataType* _tmp74_;
			ValaDataType* _tmp75_;
			_tmp73_ = m;
			_tmp74_ = vala_callable_get_return_type ((ValaCallable*) _tmp73_);
			_tmp75_ = _tmp74_;
			_tmp70_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp75_, VALA_TYPE_ARRAY_TYPE);
		}
		if (_tmp70_) {
			ValaLocalVariable* v = NULL;
			ValaMethod* _tmp76_;
			ValaDataType* _tmp77_;
			ValaDataType* _tmp78_;
			ValaLocalVariable* _tmp79_;
			ValaCCodeFunction* _tmp80_;
			ValaCCodeFunction* _tmp81_;
			ValaLocalVariable* _tmp82_;
			ValaCCodeExpression* _tmp83_;
			ValaCCodeExpression* _tmp84_;
			_tmp76_ = m;
			_tmp77_ = vala_callable_get_return_type ((ValaCallable*) _tmp76_);
			_tmp78_ = _tmp77_;
			_tmp79_ = vala_local_variable_new (_tmp78_, ".result", NULL, NULL);
			v = _tmp79_;
			_tmp80_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp81_ = _tmp80_;
			_tmp82_ = v;
			_tmp83_ = vala_ccode_base_module_destroy_local ((ValaCCodeBaseModule*) self, _tmp82_);
			_tmp84_ = _tmp83_;
			vala_ccode_function_add_expression (_tmp81_, _tmp84_);
			_vala_ccode_node_unref0 (_tmp84_);
			_vala_code_node_unref0 (v);
		} else {
			ValaGLibValue* v = NULL;
			ValaMethod* _tmp85_;
			ValaDataType* _tmp86_;
			ValaDataType* _tmp87_;
			ValaCCodeIdentifier* _tmp88_;
			ValaCCodeIdentifier* _tmp89_;
			ValaGLibValue* _tmp90_;
			ValaGLibValue* _tmp91_;
			ValaGLibValue* _tmp92_;
			ValaMethod* _tmp93_;
			gboolean _tmp94_;
			ValaCCodeFunction* _tmp95_;
			ValaCCodeFunction* _tmp96_;
			ValaGLibValue* _tmp97_;
			ValaCCodeExpression* _tmp98_;
			ValaCCodeExpression* _tmp99_;
			_tmp85_ = m;
			_tmp86_ = vala_callable_get_return_type ((ValaCallable*) _tmp85_);
			_tmp87_ = _tmp86_;
			_tmp88_ = vala_ccode_identifier_new ("_data_->result");
			_tmp89_ = _tmp88_;
			_tmp90_ = vala_glib_value_new (_tmp87_, (ValaCCodeExpression*) _tmp89_, TRUE);
			_tmp91_ = _tmp90_;
			_vala_ccode_node_unref0 (_tmp89_);
			v = _tmp91_;
			_tmp92_ = v;
			_tmp93_ = m;
			_tmp94_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp93_);
			_tmp92_->array_null_terminated = _tmp94_;
			_tmp95_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp96_ = _tmp95_;
			_tmp97_ = v;
			_tmp98_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp97_, FALSE);
			_tmp99_ = _tmp98_;
			vala_ccode_function_add_expression (_tmp96_, _tmp99_);
			_vala_ccode_node_unref0 (_tmp99_);
			_vala_target_value_unref0 (v);
		}
	}
	_tmp100_ = m;
	_tmp101_ = vala_method_get_binding (_tmp100_);
	_tmp102_ = _tmp101_;
	if (_tmp102_ == VALA_MEMBER_BINDING_INSTANCE) {
		ValaDataType* this_type = NULL;
		ValaMethod* _tmp103_;
		ValaParameter* _tmp104_;
		ValaParameter* _tmp105_;
		ValaDataType* _tmp106_;
		ValaDataType* _tmp107_;
		ValaDataType* _tmp108_;
		ValaDataType* _tmp109_;
		ValaDataType* _tmp110_;
		gboolean _tmp111_;
		_tmp103_ = m;
		_tmp104_ = vala_method_get_this_parameter (_tmp103_);
		_tmp105_ = _tmp104_;
		_tmp106_ = vala_variable_get_variable_type ((ValaVariable*) _tmp105_);
		_tmp107_ = _tmp106_;
		_tmp108_ = vala_data_type_copy (_tmp107_);
		this_type = _tmp108_;
		_tmp109_ = this_type;
		vala_data_type_set_value_owned (_tmp109_, TRUE);
		_tmp110_ = this_type;
		_tmp111_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp110_);
		if (_tmp111_) {
			ValaCCodeFunction* _tmp112_;
			ValaCCodeFunction* _tmp113_;
			ValaMethod* _tmp114_;
			ValaParameter* _tmp115_;
			ValaParameter* _tmp116_;
			ValaCCodeExpression* _tmp117_;
			ValaCCodeExpression* _tmp118_;
			_tmp112_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp113_ = _tmp112_;
			_tmp114_ = m;
			_tmp115_ = vala_method_get_this_parameter (_tmp114_);
			_tmp116_ = _tmp115_;
			_tmp117_ = vala_ccode_base_module_destroy_parameter ((ValaCCodeBaseModule*) self, _tmp116_);
			_tmp118_ = _tmp117_;
			vala_ccode_function_add_expression (_tmp113_, _tmp118_);
			_vala_ccode_node_unref0 (_tmp118_);
		}
		_vala_code_node_unref0 (this_type);
	}
	_tmp119_ = vala_ccode_identifier_new ("g_slice_free");
	_tmp120_ = _tmp119_;
	_tmp121_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp120_);
	_tmp122_ = _tmp121_;
	_vala_ccode_node_unref0 (_tmp120_);
	freecall = _tmp122_;
	_tmp123_ = dataname;
	_tmp124_ = vala_ccode_identifier_new (_tmp123_);
	_tmp125_ = _tmp124_;
	vala_ccode_function_call_add_argument (freecall, (ValaCCodeExpression*) _tmp125_);
	_vala_ccode_node_unref0 (_tmp125_);
	_tmp126_ = vala_ccode_identifier_new ("_data_");
	_tmp127_ = _tmp126_;
	vala_ccode_function_call_add_argument (freecall, (ValaCCodeExpression*) _tmp127_);
	_vala_ccode_node_unref0 (_tmp127_);
	_tmp128_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp129_ = _tmp128_;
	vala_ccode_function_add_expression (_tmp129_, (ValaCCodeExpression*) freecall);
	vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self);
	_tmp130_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp131_ = freefunc;
	vala_ccode_file_add_function_declaration (_tmp130_, _tmp131_);
	_tmp132_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp133_ = freefunc;
	vala_ccode_file_add_function (_tmp132_, _tmp133_);
	result = freefunc;
	_vala_ccode_node_unref0 (freecall);
	_g_free0 (dataname);
	return result;
}


static void vala_gasync_module_generate_async_ready_callback_wrapper (ValaGAsyncModule* self, ValaMethod* m, const gchar* function_name) {
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp0_;
	ValaCCodeFunction* _tmp1_;
	ValaCCodeParameter* _tmp2_;
	ValaCCodeParameter* _tmp3_;
	ValaCCodeParameter* _tmp4_;
	ValaCCodeParameter* _tmp5_;
	ValaCCodeParameter* _tmp6_;
	ValaCCodeParameter* _tmp7_;
	ValaCCodeFunctionCall* async_result_cast = NULL;
	ValaCCodeIdentifier* _tmp8_;
	ValaCCodeIdentifier* _tmp9_;
	ValaCCodeFunctionCall* _tmp10_;
	ValaCCodeFunctionCall* _tmp11_;
	ValaCCodeIdentifier* _tmp12_;
	ValaCCodeIdentifier* _tmp13_;
	gchar* dataname = NULL;
	ValaMethod* _tmp14_;
	gchar* _tmp15_;
	gchar* _tmp16_;
	gchar* _tmp17_;
	gchar* _tmp18_;
	gchar* _tmp19_;
	gchar* _tmp20_;
	ValaCCodeFunction* _tmp21_;
	ValaCCodeFunction* _tmp22_;
	gchar* _tmp23_;
	gchar* _tmp24_;
	ValaCCodeVariableDeclarator* _tmp25_;
	ValaCCodeVariableDeclarator* _tmp26_;
	ValaCCodeFunctionCall* get_data_call = NULL;
	ValaCCodeIdentifier* _tmp27_;
	ValaCCodeIdentifier* _tmp28_;
	ValaCCodeFunctionCall* _tmp29_;
	ValaCCodeFunctionCall* _tmp30_;
	ValaCCodeIdentifier* data_var = NULL;
	ValaCCodeIdentifier* _tmp31_;
	ValaCCodeFunction* _tmp32_;
	ValaCCodeFunction* _tmp33_;
	ValaCCodeMemberAccess* task_inner_callback = NULL;
	ValaCCodeMemberAccess* _tmp34_;
	ValaCCodeBinaryExpression* callback_is_nonnull = NULL;
	ValaCCodeConstant* _tmp35_;
	ValaCCodeConstant* _tmp36_;
	ValaCCodeBinaryExpression* _tmp37_;
	ValaCCodeBinaryExpression* _tmp38_;
	ValaCCodeFunction* _tmp39_;
	ValaCCodeFunction* _tmp40_;
	ValaCCodeFunctionCall* nested_callback = NULL;
	ValaCCodeFunctionCall* _tmp41_;
	ValaCCodeIdentifier* _tmp42_;
	ValaCCodeIdentifier* _tmp43_;
	ValaCCodeIdentifier* _tmp44_;
	ValaCCodeIdentifier* _tmp45_;
	ValaCCodeIdentifier* _tmp46_;
	ValaCCodeIdentifier* _tmp47_;
	ValaCCodeFunction* _tmp48_;
	ValaCCodeFunction* _tmp49_;
	ValaCCodeFunction* _tmp50_;
	ValaCCodeFunction* _tmp51_;
	ValaCCodeFunction* _tmp52_;
	ValaCCodeFunction* _tmp53_;
	ValaCCodeMemberAccess* _tmp54_;
	ValaCCodeMemberAccess* _tmp55_;
	ValaCCodeConstant* _tmp56_;
	ValaCCodeConstant* _tmp57_;
	ValaCCodeFile* _tmp58_;
	ValaCCodeFile* _tmp59_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (m != NULL);
	g_return_if_fail (function_name != NULL);
	_tmp0_ = function_name;
	_tmp1_ = vala_ccode_function_new (_tmp0_, "void");
	function = _tmp1_;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) function, VALA_CCODE_MODIFIERS_STATIC);
	_tmp2_ = vala_ccode_parameter_new ("*source_object", "GObject");
	_tmp3_ = _tmp2_;
	vala_ccode_function_add_parameter (function, _tmp3_);
	_vala_ccode_node_unref0 (_tmp3_);
	_tmp4_ = vala_ccode_parameter_new ("*res", "GAsyncResult");
	_tmp5_ = _tmp4_;
	vala_ccode_function_add_parameter (function, _tmp5_);
	_vala_ccode_node_unref0 (_tmp5_);
	_tmp6_ = vala_ccode_parameter_new ("*user_data", "void");
	_tmp7_ = _tmp6_;
	vala_ccode_function_add_parameter (function, _tmp7_);
	_vala_ccode_node_unref0 (_tmp7_);
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, function);
	_tmp8_ = vala_ccode_identifier_new ("G_TASK");
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp9_);
	_tmp11_ = _tmp10_;
	_vala_ccode_node_unref0 (_tmp9_);
	async_result_cast = _tmp11_;
	_tmp12_ = vala_ccode_identifier_new ("res");
	_tmp13_ = _tmp12_;
	vala_ccode_function_call_add_argument (async_result_cast, (ValaCCodeExpression*) _tmp13_);
	_vala_ccode_node_unref0 (_tmp13_);
	_tmp14_ = m;
	_tmp15_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp14_);
	_tmp16_ = _tmp15_;
	_tmp17_ = vala_symbol_lower_case_to_camel_case (_tmp16_);
	_tmp18_ = _tmp17_;
	_tmp19_ = g_strconcat (_tmp18_, "Data", NULL);
	_tmp20_ = _tmp19_;
	_g_free0 (_tmp18_);
	_g_free0 (_tmp16_);
	dataname = _tmp20_;
	_tmp21_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp22_ = _tmp21_;
	_tmp23_ = g_strconcat (dataname, "*", NULL);
	_tmp24_ = _tmp23_;
	_tmp25_ = vala_ccode_variable_declarator_new ("_task_data_", NULL, NULL);
	_tmp26_ = _tmp25_;
	vala_ccode_function_add_declaration (_tmp22_, _tmp24_, (ValaCCodeDeclarator*) _tmp26_, 0);
	_vala_ccode_node_unref0 (_tmp26_);
	_g_free0 (_tmp24_);
	_tmp27_ = vala_ccode_identifier_new ("g_task_get_task_data");
	_tmp28_ = _tmp27_;
	_tmp29_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp28_);
	_tmp30_ = _tmp29_;
	_vala_ccode_node_unref0 (_tmp28_);
	get_data_call = _tmp30_;
	vala_ccode_function_call_add_argument (get_data_call, (ValaCCodeExpression*) async_result_cast);
	_tmp31_ = vala_ccode_identifier_new ("_task_data_");
	data_var = _tmp31_;
	_tmp32_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp33_ = _tmp32_;
	vala_ccode_function_add_assignment (_tmp33_, (ValaCCodeExpression*) data_var, (ValaCCodeExpression*) get_data_call);
	_tmp34_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) data_var, "_callback_");
	task_inner_callback = _tmp34_;
	_tmp35_ = vala_ccode_constant_new ("NULL");
	_tmp36_ = _tmp35_;
	_tmp37_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) task_inner_callback, (ValaCCodeExpression*) _tmp36_);
	_tmp38_ = _tmp37_;
	_vala_ccode_node_unref0 (_tmp36_);
	callback_is_nonnull = _tmp38_;
	_tmp39_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp40_ = _tmp39_;
	vala_ccode_function_open_if (_tmp40_, (ValaCCodeExpression*) callback_is_nonnull);
	_tmp41_ = vala_ccode_function_call_new ((ValaCCodeExpression*) task_inner_callback);
	nested_callback = _tmp41_;
	_tmp42_ = vala_ccode_identifier_new ("source_object");
	_tmp43_ = _tmp42_;
	vala_ccode_function_call_add_argument (nested_callback, (ValaCCodeExpression*) _tmp43_);
	_vala_ccode_node_unref0 (_tmp43_);
	_tmp44_ = vala_ccode_identifier_new ("res");
	_tmp45_ = _tmp44_;
	vala_ccode_function_call_add_argument (nested_callback, (ValaCCodeExpression*) _tmp45_);
	_vala_ccode_node_unref0 (_tmp45_);
	_tmp46_ = vala_ccode_identifier_new ("user_data");
	_tmp47_ = _tmp46_;
	vala_ccode_function_call_add_argument (nested_callback, (ValaCCodeExpression*) _tmp47_);
	_vala_ccode_node_unref0 (_tmp47_);
	_tmp48_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp49_ = _tmp48_;
	vala_ccode_function_add_expression (_tmp49_, (ValaCCodeExpression*) nested_callback);
	_tmp50_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp51_ = _tmp50_;
	vala_ccode_function_close (_tmp51_);
	_tmp52_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp53_ = _tmp52_;
	_tmp54_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) data_var, "_task_complete_");
	_tmp55_ = _tmp54_;
	_tmp56_ = vala_ccode_constant_new ("TRUE");
	_tmp57_ = _tmp56_;
	vala_ccode_function_add_assignment (_tmp53_, (ValaCCodeExpression*) _tmp55_, (ValaCCodeExpression*) _tmp57_);
	_vala_ccode_node_unref0 (_tmp57_);
	_vala_ccode_node_unref0 (_tmp55_);
	vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
	_tmp58_ = ((ValaCCodeBaseModule*) self)->cfile;
	vala_ccode_file_add_function_declaration (_tmp58_, function);
	_tmp59_ = ((ValaCCodeBaseModule*) self)->cfile;
	vala_ccode_file_add_function (_tmp59_, function);
	_vala_ccode_node_unref0 (nested_callback);
	_vala_ccode_node_unref0 (callback_is_nonnull);
	_vala_ccode_node_unref0 (task_inner_callback);
	_vala_ccode_node_unref0 (data_var);
	_vala_ccode_node_unref0 (get_data_call);
	_g_free0 (dataname);
	_vala_ccode_node_unref0 (async_result_cast);
	_vala_ccode_node_unref0 (function);
}


static void vala_gasync_module_generate_async_function (ValaGAsyncModule* self, ValaMethod* m) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaCCodeBaseModuleEmitContext* _tmp1_;
	gchar* callback_wrapper = NULL;
	gboolean _tmp2_ = FALSE;
	ValaCodeContext* _tmp3_;
	ValaCodeContext* _tmp4_;
	gboolean _tmp5_;
	gchar* dataname = NULL;
	ValaMethod* _tmp15_;
	gchar* _tmp16_;
	gchar* _tmp17_;
	gchar* _tmp18_;
	gchar* _tmp19_;
	gchar* _tmp20_;
	gchar* _tmp21_;
	ValaCCodeFunction* asyncfunc = NULL;
	ValaMethod* _tmp22_;
	gchar* _tmp23_;
	gchar* _tmp24_;
	ValaCCodeFunction* _tmp25_;
	ValaCCodeFunction* _tmp26_;
	ValaHashMap* cparam_map = NULL;
	GHashFunc _tmp27_;
	GEqualFunc _tmp28_;
	GEqualFunc _tmp29_;
	ValaHashMap* _tmp30_;
	ValaHashMap* _tmp31_;
	gint _tmp32_;
	ValaCCodeParameter* _tmp33_;
	ValaCCodeParameter* _tmp34_;
	ValaHashMap* _tmp35_;
	gint _tmp36_;
	ValaCCodeParameter* _tmp37_;
	ValaCCodeParameter* _tmp38_;
	ValaMethod* _tmp39_;
	ValaCCodeFile* _tmp40_;
	ValaHashMap* _tmp41_;
	ValaCCodeFunction* _tmp42_;
	gboolean _tmp43_ = FALSE;
	ValaMethod* _tmp44_;
	ValaMethod* _tmp45_;
	ValaMethod* _tmp46_;
	ValaCCodeFunction* _tmp73_;
	gboolean _tmp74_ = FALSE;
	ValaMethod* _tmp75_;
	gboolean _tmp76_;
	gboolean _tmp77_;
	ValaCCodeFunctionCall* dataalloc = NULL;
	ValaCCodeIdentifier* _tmp135_;
	ValaCCodeIdentifier* _tmp136_;
	ValaCCodeFunctionCall* _tmp137_;
	ValaCCodeFunctionCall* _tmp138_;
	ValaCCodeFunctionCall* _tmp139_;
	const gchar* _tmp140_;
	ValaCCodeIdentifier* _tmp141_;
	ValaCCodeIdentifier* _tmp142_;
	ValaCCodeIdentifier* data_var = NULL;
	ValaCCodeIdentifier* _tmp143_;
	ValaCCodeFunction* _tmp144_;
	ValaCCodeFunction* _tmp145_;
	const gchar* _tmp146_;
	gchar* _tmp147_;
	gchar* _tmp148_;
	ValaCCodeVariableDeclarator* _tmp149_;
	ValaCCodeVariableDeclarator* _tmp150_;
	ValaCCodeFunction* _tmp151_;
	ValaCCodeFunction* _tmp152_;
	ValaCCodeIdentifier* _tmp153_;
	ValaCCodeFunctionCall* _tmp154_;
	ValaCCodeFunctionCall* create_result = NULL;
	ValaCodeContext* _tmp155_;
	ValaCodeContext* _tmp156_;
	gboolean _tmp157_;
	ValaTypeSymbol* t = NULL;
	ValaMethod* _tmp174_;
	ValaSymbol* _tmp175_;
	ValaSymbol* _tmp176_;
	ValaTypeSymbol* _tmp177_;
	gboolean _tmp178_ = FALSE;
	gboolean _tmp179_ = FALSE;
	gboolean _tmp180_ = FALSE;
	ValaMethod* _tmp181_;
	ValaCodeContext* _tmp201_;
	ValaCodeContext* _tmp202_;
	gboolean _tmp203_;
	gboolean _tmp240_ = FALSE;
	ValaCodeContext* _tmp241_;
	ValaCodeContext* _tmp242_;
	gboolean _tmp243_;
	ValaCCodeFunctionCall* _tmp254_;
	ValaCCodeIdentifier* _tmp255_;
	ValaCCodeIdentifier* _tmp256_;
	ValaCodeContext* _tmp257_;
	ValaCodeContext* _tmp258_;
	gboolean _tmp259_;
	ValaCCodeFunction* _tmp266_;
	ValaCCodeFunction* _tmp267_;
	ValaCCodeIdentifier* _tmp268_;
	ValaCCodeMemberAccess* _tmp269_;
	ValaCCodeMemberAccess* _tmp270_;
	ValaCCodeFunctionCall* _tmp271_;
	ValaCCodeFunctionCall* attach_data_call = NULL;
	ValaCodeContext* _tmp272_;
	ValaCodeContext* _tmp273_;
	gboolean _tmp274_;
	ValaCCodeFunctionCall* _tmp302_;
	ValaCCodeIdentifier* _tmp303_;
	ValaCCodeMemberAccess* _tmp304_;
	ValaCCodeMemberAccess* _tmp305_;
	ValaCCodeFunctionCall* _tmp306_;
	ValaCCodeIdentifier* _tmp307_;
	ValaCCodeFunctionCall* _tmp308_;
	ValaMethod* _tmp309_;
	gchar* _tmp310_;
	gchar* _tmp311_;
	gchar* _tmp312_;
	gchar* _tmp313_;
	ValaCCodeIdentifier* _tmp314_;
	ValaCCodeIdentifier* _tmp315_;
	ValaCCodeFunction* _tmp316_;
	ValaCCodeFunction* _tmp317_;
	ValaCCodeFunctionCall* _tmp318_;
	ValaMethod* _tmp319_;
	ValaCCodeBaseModuleEmitContext* _tmp364_;
	ValaMethod* _tmp365_;
	ValaCCodeBaseModuleEmitContext* _tmp401_;
	ValaCCodeFunctionCall* ccall = NULL;
	ValaMethod* _tmp461_;
	gchar* _tmp462_;
	gchar* _tmp463_;
	gchar* _tmp464_;
	gchar* _tmp465_;
	ValaCCodeIdentifier* _tmp466_;
	ValaCCodeIdentifier* _tmp467_;
	ValaCCodeFunctionCall* _tmp468_;
	ValaCCodeFunctionCall* _tmp469_;
	ValaCCodeIdentifier* _tmp470_;
	ValaCCodeFunction* _tmp471_;
	ValaCCodeFunction* _tmp472_;
	ValaCCodeFile* _tmp473_;
	ValaCCodeFunction* _tmp474_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (m != NULL);
	_tmp0_ = vala_ccode_base_module_emit_context_new (NULL);
	_tmp1_ = _tmp0_;
	vala_ccode_base_module_push_context ((ValaCCodeBaseModule*) self, _tmp1_);
	_vala_ccode_base_module_emit_context_unref0 (_tmp1_);
	callback_wrapper = NULL;
	_tmp3_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_code_context_require_glib_version (_tmp4_, 2, 36);
	if (_tmp5_) {
		ValaCodeContext* _tmp6_;
		ValaCodeContext* _tmp7_;
		gboolean _tmp8_;
		_tmp6_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_code_context_require_glib_version (_tmp7_, 2, 44);
		_tmp2_ = !_tmp8_;
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		ValaMethod* _tmp9_;
		gchar* _tmp10_;
		gchar* _tmp11_;
		gchar* _tmp12_;
		ValaMethod* _tmp13_;
		const gchar* _tmp14_;
		_tmp9_ = m;
		_tmp10_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp9_);
		_tmp11_ = _tmp10_;
		_tmp12_ = g_strconcat (_tmp11_, "_async_ready_wrapper", NULL);
		_g_free0 (callback_wrapper);
		callback_wrapper = _tmp12_;
		_g_free0 (_tmp11_);
		_tmp13_ = m;
		_tmp14_ = callback_wrapper;
		vala_gasync_module_generate_async_ready_callback_wrapper (self, _tmp13_, _tmp14_);
	}
	_tmp15_ = m;
	_tmp16_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp15_);
	_tmp17_ = _tmp16_;
	_tmp18_ = vala_symbol_lower_case_to_camel_case (_tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = g_strconcat (_tmp19_, "Data", NULL);
	_tmp21_ = _tmp20_;
	_g_free0 (_tmp19_);
	_g_free0 (_tmp17_);
	dataname = _tmp21_;
	_tmp22_ = m;
	_tmp23_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp22_);
	_tmp24_ = _tmp23_;
	_tmp25_ = vala_ccode_function_new (_tmp24_, "void");
	_tmp26_ = _tmp25_;
	_g_free0 (_tmp24_);
	asyncfunc = _tmp26_;
	_tmp27_ = g_direct_hash;
	_tmp28_ = g_direct_equal;
	_tmp29_ = g_direct_equal;
	_tmp30_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp27_, _tmp28_, _tmp29_);
	cparam_map = _tmp30_;
	_tmp31_ = cparam_map;
	_tmp32_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, FALSE);
	_tmp33_ = vala_ccode_parameter_new ("_callback_", "GAsyncReadyCallback");
	_tmp34_ = _tmp33_;
	vala_map_set ((ValaMap*) _tmp31_, (gpointer) ((gintptr) _tmp32_), _tmp34_);
	_vala_ccode_node_unref0 (_tmp34_);
	_tmp35_ = cparam_map;
	_tmp36_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, -0.9, FALSE);
	_tmp37_ = vala_ccode_parameter_new ("_user_data_", "gpointer");
	_tmp38_ = _tmp37_;
	vala_map_set ((ValaMap*) _tmp35_, (gpointer) ((gintptr) _tmp36_), _tmp38_);
	_vala_ccode_node_unref0 (_tmp38_);
	_tmp39_ = m;
	_tmp40_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp41_ = cparam_map;
	_tmp42_ = asyncfunc;
	vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp39_, _tmp40_, (ValaMap*) _tmp41_, _tmp42_, NULL, NULL, NULL, 1);
	_tmp44_ = m;
	_tmp45_ = vala_method_get_base_method (_tmp44_);
	_tmp46_ = _tmp45_;
	if (_tmp46_ != NULL) {
		_tmp43_ = TRUE;
	} else {
		ValaMethod* _tmp47_;
		ValaMethod* _tmp48_;
		ValaMethod* _tmp49_;
		_tmp47_ = m;
		_tmp48_ = vala_method_get_base_interface_method (_tmp47_);
		_tmp49_ = _tmp48_;
		_tmp43_ = _tmp49_ != NULL;
	}
	if (_tmp43_) {
		ValaCCodeFunction* _tmp50_;
		ValaCCodeFunction* _tmp51_;
		ValaCCodeModifiers _tmp52_;
		ValaCCodeModifiers _tmp53_;
		ValaCCodeFile* _tmp54_;
		ValaCCodeFunction* _tmp55_;
		_tmp50_ = asyncfunc;
		_tmp51_ = asyncfunc;
		_tmp52_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp51_);
		_tmp53_ = _tmp52_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp51_, _tmp53_ | VALA_CCODE_MODIFIERS_STATIC);
		_tmp54_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp55_ = asyncfunc;
		vala_ccode_file_add_function_declaration (_tmp54_, _tmp55_);
	} else {
		ValaMethod* _tmp56_;
		gboolean _tmp57_;
		_tmp56_ = m;
		_tmp57_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp56_);
		if (_tmp57_) {
			ValaCCodeFunction* _tmp58_;
			ValaCCodeFunction* _tmp59_;
			ValaCCodeModifiers _tmp60_;
			ValaCCodeModifiers _tmp61_;
			_tmp58_ = asyncfunc;
			_tmp59_ = asyncfunc;
			_tmp60_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp59_);
			_tmp61_ = _tmp60_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp59_, _tmp61_ | VALA_CCODE_MODIFIERS_STATIC);
		} else {
			gboolean _tmp62_ = FALSE;
			ValaCodeContext* _tmp63_;
			ValaCodeContext* _tmp64_;
			gboolean _tmp65_;
			gboolean _tmp66_;
			_tmp63_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
			_tmp64_ = _tmp63_;
			_tmp65_ = vala_code_context_get_hide_internal (_tmp64_);
			_tmp66_ = _tmp65_;
			if (_tmp66_) {
				ValaMethod* _tmp67_;
				gboolean _tmp68_;
				_tmp67_ = m;
				_tmp68_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp67_);
				_tmp62_ = _tmp68_;
			} else {
				_tmp62_ = FALSE;
			}
			if (_tmp62_) {
				ValaCCodeFunction* _tmp69_;
				ValaCCodeFunction* _tmp70_;
				ValaCCodeModifiers _tmp71_;
				ValaCCodeModifiers _tmp72_;
				_tmp69_ = asyncfunc;
				_tmp70_ = asyncfunc;
				_tmp71_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp70_);
				_tmp72_ = _tmp71_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp70_, _tmp72_ | VALA_CCODE_MODIFIERS_INTERNAL);
			}
		}
	}
	_tmp73_ = asyncfunc;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp73_);
	_tmp75_ = m;
	_tmp76_ = vala_method_get_overrides (_tmp75_);
	_tmp77_ = _tmp76_;
	if (_tmp77_) {
		_tmp74_ = TRUE;
	} else {
		gboolean _tmp78_ = FALSE;
		gboolean _tmp79_ = FALSE;
		ValaMethod* _tmp80_;
		ValaMethod* _tmp81_;
		ValaMethod* _tmp82_;
		_tmp80_ = m;
		_tmp81_ = vala_method_get_base_interface_method (_tmp80_);
		_tmp82_ = _tmp81_;
		if (_tmp82_ != NULL) {
			ValaMethod* _tmp83_;
			gboolean _tmp84_;
			gboolean _tmp85_;
			_tmp83_ = m;
			_tmp84_ = vala_method_get_is_abstract (_tmp83_);
			_tmp85_ = _tmp84_;
			_tmp79_ = !_tmp85_;
		} else {
			_tmp79_ = FALSE;
		}
		if (_tmp79_) {
			ValaMethod* _tmp86_;
			gboolean _tmp87_;
			gboolean _tmp88_;
			_tmp86_ = m;
			_tmp87_ = vala_method_get_is_virtual (_tmp86_);
			_tmp88_ = _tmp87_;
			_tmp78_ = !_tmp88_;
		} else {
			_tmp78_ = FALSE;
		}
		_tmp74_ = _tmp78_;
	}
	if (_tmp74_) {
		ValaMethod* base_method = NULL;
		ValaMethod* _tmp89_;
		gboolean _tmp90_;
		gboolean _tmp91_;
		ValaObjectType* base_expression_type = NULL;
		ValaMethod* _tmp100_;
		ValaSymbol* _tmp101_;
		ValaSymbol* _tmp102_;
		ValaObjectType* _tmp103_;
		ValaObjectTypeSymbol* type_symbol = NULL;
		ValaMethod* _tmp104_;
		ValaSymbol* _tmp105_;
		ValaSymbol* _tmp106_;
		ValaObjectTypeSymbol* _tmp107_;
		ValaObjectType* self_target_type = NULL;
		ValaObjectTypeSymbol* _tmp108_;
		ValaObjectType* _tmp109_;
		ValaCCodeExpression* cself = NULL;
		ValaObjectType* _tmp110_;
		ValaCCodeIdentifier* _tmp111_;
		ValaCCodeIdentifier* _tmp112_;
		ValaGLibValue* _tmp113_;
		ValaGLibValue* _tmp114_;
		ValaObjectType* _tmp115_;
		ValaMethod* _tmp116_;
		ValaTargetValue* _tmp117_;
		ValaTargetValue* _tmp118_;
		ValaCCodeExpression* _tmp119_;
		ValaCCodeExpression* _tmp120_;
		ValaCCodeFunction* _tmp121_;
		ValaCCodeFunction* _tmp122_;
		ValaObjectTypeSymbol* _tmp123_;
		gchar* _tmp124_;
		gchar* _tmp125_;
		gchar* _tmp126_;
		gchar* _tmp127_;
		ValaCCodeVariableDeclarator* _tmp128_;
		ValaCCodeVariableDeclarator* _tmp129_;
		ValaCCodeFunction* _tmp130_;
		ValaCCodeFunction* _tmp131_;
		ValaCCodeIdentifier* _tmp132_;
		ValaCCodeIdentifier* _tmp133_;
		ValaCCodeExpression* _tmp134_;
		_tmp89_ = m;
		_tmp90_ = vala_method_get_overrides (_tmp89_);
		_tmp91_ = _tmp90_;
		if (_tmp91_) {
			ValaMethod* _tmp92_;
			ValaMethod* _tmp93_;
			ValaMethod* _tmp94_;
			ValaMethod* _tmp95_;
			_tmp92_ = m;
			_tmp93_ = vala_method_get_base_method (_tmp92_);
			_tmp94_ = _tmp93_;
			_tmp95_ = _vala_code_node_ref0 (_tmp94_);
			_vala_code_node_unref0 (base_method);
			base_method = _tmp95_;
		} else {
			ValaMethod* _tmp96_;
			ValaMethod* _tmp97_;
			ValaMethod* _tmp98_;
			ValaMethod* _tmp99_;
			_tmp96_ = m;
			_tmp97_ = vala_method_get_base_interface_method (_tmp96_);
			_tmp98_ = _tmp97_;
			_tmp99_ = _vala_code_node_ref0 (_tmp98_);
			_vala_code_node_unref0 (base_method);
			base_method = _tmp99_;
		}
		_tmp100_ = base_method;
		_tmp101_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp100_);
		_tmp102_ = _tmp101_;
		_tmp103_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp102_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
		base_expression_type = _tmp103_;
		_tmp104_ = m;
		_tmp105_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp104_);
		_tmp106_ = _tmp105_;
		_tmp107_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp106_, VALA_TYPE_OBJECT_TYPE_SYMBOL) ? ((ValaObjectTypeSymbol*) _tmp106_) : NULL);
		type_symbol = _tmp107_;
		_tmp108_ = type_symbol;
		_tmp109_ = vala_object_type_new (_tmp108_);
		self_target_type = _tmp109_;
		_tmp110_ = base_expression_type;
		_tmp111_ = vala_ccode_identifier_new ("base");
		_tmp112_ = _tmp111_;
		_tmp113_ = vala_glib_value_new ((ValaDataType*) _tmp110_, (ValaCCodeExpression*) _tmp112_, TRUE);
		_tmp114_ = _tmp113_;
		_tmp115_ = self_target_type;
		_tmp116_ = m;
		_tmp117_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp114_, (ValaDataType*) _tmp115_, (ValaCodeNode*) _tmp116_);
		_tmp118_ = _tmp117_;
		_tmp119_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp118_);
		_tmp120_ = _tmp119_;
		_vala_target_value_unref0 (_tmp118_);
		_vala_target_value_unref0 (_tmp114_);
		_vala_ccode_node_unref0 (_tmp112_);
		cself = _tmp120_;
		_tmp121_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp122_ = _tmp121_;
		_tmp123_ = type_symbol;
		_tmp124_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp123_);
		_tmp125_ = _tmp124_;
		_tmp126_ = g_strdup_printf ("%s *", _tmp125_);
		_tmp127_ = _tmp126_;
		_tmp128_ = vala_ccode_variable_declarator_new ("self", NULL, NULL);
		_tmp129_ = _tmp128_;
		vala_ccode_function_add_declaration (_tmp122_, _tmp127_, (ValaCCodeDeclarator*) _tmp129_, 0);
		_vala_ccode_node_unref0 (_tmp129_);
		_g_free0 (_tmp127_);
		_g_free0 (_tmp125_);
		_tmp130_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp131_ = _tmp130_;
		_tmp132_ = vala_ccode_identifier_new ("self");
		_tmp133_ = _tmp132_;
		_tmp134_ = cself;
		vala_ccode_function_add_assignment (_tmp131_, (ValaCCodeExpression*) _tmp133_, _tmp134_);
		_vala_ccode_node_unref0 (_tmp133_);
		_vala_ccode_node_unref0 (cself);
		_vala_code_node_unref0 (self_target_type);
		_vala_code_node_unref0 (type_symbol);
		_vala_code_node_unref0 (base_expression_type);
		_vala_code_node_unref0 (base_method);
	}
	_tmp135_ = vala_ccode_identifier_new ("g_slice_new0");
	_tmp136_ = _tmp135_;
	_tmp137_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp136_);
	_tmp138_ = _tmp137_;
	_vala_ccode_node_unref0 (_tmp136_);
	dataalloc = _tmp138_;
	_tmp139_ = dataalloc;
	_tmp140_ = dataname;
	_tmp141_ = vala_ccode_identifier_new (_tmp140_);
	_tmp142_ = _tmp141_;
	vala_ccode_function_call_add_argument (_tmp139_, (ValaCCodeExpression*) _tmp142_);
	_vala_ccode_node_unref0 (_tmp142_);
	_tmp143_ = vala_ccode_identifier_new ("_data_");
	data_var = _tmp143_;
	_tmp144_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp145_ = _tmp144_;
	_tmp146_ = dataname;
	_tmp147_ = g_strconcat (_tmp146_, "*", NULL);
	_tmp148_ = _tmp147_;
	_tmp149_ = vala_ccode_variable_declarator_new ("_data_", NULL, NULL);
	_tmp150_ = _tmp149_;
	vala_ccode_function_add_declaration (_tmp145_, _tmp148_, (ValaCCodeDeclarator*) _tmp150_, 0);
	_vala_ccode_node_unref0 (_tmp150_);
	_g_free0 (_tmp148_);
	_tmp151_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp152_ = _tmp151_;
	_tmp153_ = data_var;
	_tmp154_ = dataalloc;
	vala_ccode_function_add_assignment (_tmp152_, (ValaCCodeExpression*) _tmp153_, (ValaCCodeExpression*) _tmp154_);
	create_result = NULL;
	_tmp155_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp156_ = _tmp155_;
	_tmp157_ = vala_code_context_require_glib_version (_tmp156_, 2, 36);
	if (_tmp157_) {
		ValaCodeContext* _tmp158_;
		ValaCodeContext* _tmp159_;
		gboolean _tmp160_;
		ValaCCodeIdentifier* _tmp168_;
		ValaCCodeIdentifier* _tmp169_;
		ValaCCodeFunctionCall* _tmp170_;
		_tmp158_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp159_ = _tmp158_;
		_tmp160_ = vala_code_context_require_glib_version (_tmp159_, 2, 44);
		if (!_tmp160_) {
			ValaCCodeFunction* _tmp161_;
			ValaCCodeFunction* _tmp162_;
			ValaCCodeIdentifier* _tmp163_;
			ValaCCodeMemberAccess* _tmp164_;
			ValaCCodeMemberAccess* _tmp165_;
			ValaCCodeConstant* _tmp166_;
			ValaCCodeConstant* _tmp167_;
			_tmp161_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp162_ = _tmp161_;
			_tmp163_ = data_var;
			_tmp164_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp163_, "_callback_");
			_tmp165_ = _tmp164_;
			_tmp166_ = vala_ccode_constant_new ("_callback_");
			_tmp167_ = _tmp166_;
			vala_ccode_function_add_assignment (_tmp162_, (ValaCCodeExpression*) _tmp165_, (ValaCCodeExpression*) _tmp167_);
			_vala_ccode_node_unref0 (_tmp167_);
			_vala_ccode_node_unref0 (_tmp165_);
		}
		_tmp168_ = vala_ccode_identifier_new ("g_task_new");
		_tmp169_ = _tmp168_;
		_tmp170_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp169_);
		_vala_ccode_node_unref0 (create_result);
		create_result = _tmp170_;
		_vala_ccode_node_unref0 (_tmp169_);
	} else {
		ValaCCodeIdentifier* _tmp171_;
		ValaCCodeIdentifier* _tmp172_;
		ValaCCodeFunctionCall* _tmp173_;
		_tmp171_ = vala_ccode_identifier_new ("g_simple_async_result_new");
		_tmp172_ = _tmp171_;
		_tmp173_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp172_);
		_vala_ccode_node_unref0 (create_result);
		create_result = _tmp173_;
		_vala_ccode_node_unref0 (_tmp172_);
	}
	_tmp174_ = m;
	_tmp175_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp174_);
	_tmp176_ = _tmp175_;
	_tmp177_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp176_, VALA_TYPE_TYPESYMBOL) ? ((ValaTypeSymbol*) _tmp176_) : NULL);
	t = _tmp177_;
	_tmp181_ = m;
	if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp181_, VALA_TYPE_CREATION_METHOD)) {
		ValaMethod* _tmp182_;
		ValaMemberBinding _tmp183_;
		ValaMemberBinding _tmp184_;
		_tmp182_ = m;
		_tmp183_ = vala_method_get_binding (_tmp182_);
		_tmp184_ = _tmp183_;
		_tmp180_ = _tmp184_ == VALA_MEMBER_BINDING_INSTANCE;
	} else {
		_tmp180_ = FALSE;
	}
	if (_tmp180_) {
		ValaTypeSymbol* _tmp185_;
		_tmp185_ = t;
		_tmp179_ = _tmp185_ != NULL;
	} else {
		_tmp179_ = FALSE;
	}
	if (_tmp179_) {
		ValaTypeSymbol* _tmp186_;
		ValaTypeSymbol* _tmp187_;
		gboolean _tmp188_;
		_tmp186_ = t;
		_tmp187_ = ((ValaCCodeBaseModule*) self)->gobject_type;
		_tmp188_ = vala_typesymbol_is_subtype_of (_tmp186_, _tmp187_);
		_tmp178_ = _tmp188_;
	} else {
		_tmp178_ = FALSE;
	}
	if (_tmp178_) {
		ValaCCodeFunctionCall* gobject_cast = NULL;
		ValaCCodeIdentifier* _tmp189_;
		ValaCCodeIdentifier* _tmp190_;
		ValaCCodeFunctionCall* _tmp191_;
		ValaCCodeFunctionCall* _tmp192_;
		ValaCCodeFunctionCall* _tmp193_;
		ValaCCodeIdentifier* _tmp194_;
		ValaCCodeIdentifier* _tmp195_;
		ValaCCodeFunctionCall* _tmp196_;
		ValaCCodeFunctionCall* _tmp197_;
		_tmp189_ = vala_ccode_identifier_new ("G_OBJECT");
		_tmp190_ = _tmp189_;
		_tmp191_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp190_);
		_tmp192_ = _tmp191_;
		_vala_ccode_node_unref0 (_tmp190_);
		gobject_cast = _tmp192_;
		_tmp193_ = gobject_cast;
		_tmp194_ = vala_ccode_identifier_new ("self");
		_tmp195_ = _tmp194_;
		vala_ccode_function_call_add_argument (_tmp193_, (ValaCCodeExpression*) _tmp195_);
		_vala_ccode_node_unref0 (_tmp195_);
		_tmp196_ = create_result;
		_tmp197_ = gobject_cast;
		vala_ccode_function_call_add_argument (_tmp196_, (ValaCCodeExpression*) _tmp197_);
		_vala_ccode_node_unref0 (gobject_cast);
	} else {
		ValaCCodeFunctionCall* _tmp198_;
		ValaCCodeConstant* _tmp199_;
		ValaCCodeConstant* _tmp200_;
		_tmp198_ = create_result;
		_tmp199_ = vala_ccode_constant_new ("NULL");
		_tmp200_ = _tmp199_;
		vala_ccode_function_call_add_argument (_tmp198_, (ValaCCodeExpression*) _tmp200_);
		_vala_ccode_node_unref0 (_tmp200_);
	}
	_tmp201_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp202_ = _tmp201_;
	_tmp203_ = vala_code_context_require_glib_version (_tmp202_, 2, 36);
	if (_tmp203_) {
		ValaParameter* cancellable_param = NULL;
		ValaParameter* _tmp228_;
		cancellable_param = NULL;
		{
			ValaList* _param_list = NULL;
			ValaMethod* _tmp204_;
			ValaList* _tmp205_;
			gint _param_size = 0;
			ValaList* _tmp206_;
			gint _tmp207_;
			gint _tmp208_;
			gint _param_index = 0;
			_tmp204_ = m;
			_tmp205_ = vala_callable_get_parameters ((ValaCallable*) _tmp204_);
			_param_list = _tmp205_;
			_tmp206_ = _param_list;
			_tmp207_ = vala_collection_get_size ((ValaCollection*) _tmp206_);
			_tmp208_ = _tmp207_;
			_param_size = _tmp208_;
			_param_index = -1;
			while (TRUE) {
				gint _tmp209_;
				gint _tmp210_;
				gint _tmp211_;
				ValaParameter* param = NULL;
				ValaList* _tmp212_;
				gint _tmp213_;
				gpointer _tmp214_;
				gboolean _tmp215_ = FALSE;
				ValaParameter* _tmp216_;
				ValaDataType* _tmp217_;
				ValaDataType* _tmp218_;
				_tmp209_ = _param_index;
				_param_index = _tmp209_ + 1;
				_tmp210_ = _param_index;
				_tmp211_ = _param_size;
				if (!(_tmp210_ < _tmp211_)) {
					break;
				}
				_tmp212_ = _param_list;
				_tmp213_ = _param_index;
				_tmp214_ = vala_list_get (_tmp212_, _tmp213_);
				param = (ValaParameter*) _tmp214_;
				_tmp216_ = param;
				_tmp217_ = vala_variable_get_variable_type ((ValaVariable*) _tmp216_);
				_tmp218_ = _tmp217_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp218_, VALA_TYPE_OBJECT_TYPE)) {
					ValaParameter* _tmp219_;
					ValaDataType* _tmp220_;
					ValaDataType* _tmp221_;
					ValaTypeSymbol* _tmp222_;
					ValaTypeSymbol* _tmp223_;
					gchar* _tmp224_;
					gchar* _tmp225_;
					_tmp219_ = param;
					_tmp220_ = vala_variable_get_variable_type ((ValaVariable*) _tmp219_);
					_tmp221_ = _tmp220_;
					_tmp222_ = vala_data_type_get_data_type (_tmp221_);
					_tmp223_ = _tmp222_;
					_tmp224_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp223_);
					_tmp225_ = _tmp224_;
					_tmp215_ = g_strcmp0 (_tmp225_, "GLib.Cancellable") == 0;
					_g_free0 (_tmp225_);
				} else {
					_tmp215_ = FALSE;
				}
				if (_tmp215_) {
					ValaParameter* _tmp226_;
					ValaParameter* _tmp227_;
					_tmp226_ = param;
					_tmp227_ = _vala_code_node_ref0 (_tmp226_);
					_vala_code_node_unref0 (cancellable_param);
					cancellable_param = _tmp227_;
					_vala_code_node_unref0 (param);
					break;
				}
				_vala_code_node_unref0 (param);
			}
			_vala_iterable_unref0 (_param_list);
		}
		_tmp228_ = cancellable_param;
		if (_tmp228_ == NULL) {
			ValaCCodeFunctionCall* _tmp229_;
			ValaCCodeConstant* _tmp230_;
			ValaCCodeConstant* _tmp231_;
			_tmp229_ = create_result;
			_tmp230_ = vala_ccode_constant_new ("NULL");
			_tmp231_ = _tmp230_;
			vala_ccode_function_call_add_argument (_tmp229_, (ValaCCodeExpression*) _tmp231_);
			_vala_ccode_node_unref0 (_tmp231_);
		} else {
			ValaCCodeFunctionCall* _tmp232_;
			ValaParameter* _tmp233_;
			const gchar* _tmp234_;
			const gchar* _tmp235_;
			gchar* _tmp236_;
			gchar* _tmp237_;
			ValaCCodeIdentifier* _tmp238_;
			ValaCCodeIdentifier* _tmp239_;
			_tmp232_ = create_result;
			_tmp233_ = cancellable_param;
			_tmp234_ = vala_symbol_get_name ((ValaSymbol*) _tmp233_);
			_tmp235_ = _tmp234_;
			_tmp236_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp235_);
			_tmp237_ = _tmp236_;
			_tmp238_ = vala_ccode_identifier_new (_tmp237_);
			_tmp239_ = _tmp238_;
			vala_ccode_function_call_add_argument (_tmp232_, (ValaCCodeExpression*) _tmp239_);
			_vala_ccode_node_unref0 (_tmp239_);
			_g_free0 (_tmp237_);
		}
		_vala_code_node_unref0 (cancellable_param);
	}
	_tmp241_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp242_ = _tmp241_;
	_tmp243_ = vala_code_context_require_glib_version (_tmp242_, 2, 36);
	if (!_tmp243_) {
		_tmp240_ = TRUE;
	} else {
		ValaCodeContext* _tmp244_;
		ValaCodeContext* _tmp245_;
		gboolean _tmp246_;
		_tmp244_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp245_ = _tmp244_;
		_tmp246_ = vala_code_context_require_glib_version (_tmp245_, 2, 44);
		_tmp240_ = _tmp246_;
	}
	if (_tmp240_) {
		ValaCCodeFunctionCall* _tmp247_;
		ValaCCodeIdentifier* _tmp248_;
		ValaCCodeIdentifier* _tmp249_;
		_tmp247_ = create_result;
		_tmp248_ = vala_ccode_identifier_new ("_callback_");
		_tmp249_ = _tmp248_;
		vala_ccode_function_call_add_argument (_tmp247_, (ValaCCodeExpression*) _tmp249_);
		_vala_ccode_node_unref0 (_tmp249_);
	} else {
		ValaCCodeFunctionCall* _tmp250_;
		const gchar* _tmp251_;
		ValaCCodeIdentifier* _tmp252_;
		ValaCCodeIdentifier* _tmp253_;
		_tmp250_ = create_result;
		_tmp251_ = callback_wrapper;
		_tmp252_ = vala_ccode_identifier_new (_tmp251_);
		_tmp253_ = _tmp252_;
		vala_ccode_function_call_add_argument (_tmp250_, (ValaCCodeExpression*) _tmp253_);
		_vala_ccode_node_unref0 (_tmp253_);
	}
	_tmp254_ = create_result;
	_tmp255_ = vala_ccode_identifier_new ("_user_data_");
	_tmp256_ = _tmp255_;
	vala_ccode_function_call_add_argument (_tmp254_, (ValaCCodeExpression*) _tmp256_);
	_vala_ccode_node_unref0 (_tmp256_);
	_tmp257_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp258_ = _tmp257_;
	_tmp259_ = vala_code_context_require_glib_version (_tmp258_, 2, 36);
	if (!_tmp259_) {
		ValaCCodeFunctionCall* _tmp260_;
		ValaMethod* _tmp261_;
		gchar* _tmp262_;
		gchar* _tmp263_;
		ValaCCodeIdentifier* _tmp264_;
		ValaCCodeIdentifier* _tmp265_;
		_tmp260_ = create_result;
		_tmp261_ = m;
		_tmp262_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp261_);
		_tmp263_ = _tmp262_;
		_tmp264_ = vala_ccode_identifier_new (_tmp263_);
		_tmp265_ = _tmp264_;
		vala_ccode_function_call_add_argument (_tmp260_, (ValaCCodeExpression*) _tmp265_);
		_vala_ccode_node_unref0 (_tmp265_);
		_g_free0 (_tmp263_);
	}
	_tmp266_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp267_ = _tmp266_;
	_tmp268_ = data_var;
	_tmp269_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp268_, "_async_result");
	_tmp270_ = _tmp269_;
	_tmp271_ = create_result;
	vala_ccode_function_add_assignment (_tmp267_, (ValaCCodeExpression*) _tmp270_, (ValaCCodeExpression*) _tmp271_);
	_vala_ccode_node_unref0 (_tmp270_);
	_tmp272_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp273_ = _tmp272_;
	_tmp274_ = vala_code_context_require_glib_version (_tmp273_, 2, 36);
	if (!_tmp274_) {
		ValaCCodeIdentifier* _tmp275_;
		ValaCCodeIdentifier* _tmp276_;
		ValaCCodeFunctionCall* _tmp277_;
		_tmp275_ = vala_ccode_identifier_new ("g_simple_async_result_set_op_res_gpointer");
		_tmp276_ = _tmp275_;
		_tmp277_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp276_);
		_vala_ccode_node_unref0 (attach_data_call);
		attach_data_call = _tmp277_;
		_vala_ccode_node_unref0 (_tmp276_);
	} else {
		ValaCodeContext* _tmp278_;
		ValaCodeContext* _tmp279_;
		gboolean _tmp280_;
		ValaCCodeIdentifier* _tmp299_;
		ValaCCodeIdentifier* _tmp300_;
		ValaCCodeFunctionCall* _tmp301_;
		_tmp278_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp279_ = _tmp278_;
		_tmp280_ = vala_code_context_require_glib_version (_tmp279_, 2, 44);
		if (!_tmp280_) {
			ValaCCodeMemberAccess* task_completed_var = NULL;
			ValaCCodeIdentifier* _tmp281_;
			ValaCCodeMemberAccess* _tmp282_;
			ValaCCodeIdentifier* callback = NULL;
			ValaCCodeIdentifier* _tmp283_;
			ValaCCodeBinaryExpression* callback_is_null = NULL;
			ValaCCodeIdentifier* _tmp284_;
			ValaCCodeConstant* _tmp285_;
			ValaCCodeConstant* _tmp286_;
			ValaCCodeBinaryExpression* _tmp287_;
			ValaCCodeBinaryExpression* _tmp288_;
			ValaCCodeFunction* _tmp289_;
			ValaCCodeFunction* _tmp290_;
			ValaCCodeBinaryExpression* _tmp291_;
			ValaCCodeFunction* _tmp292_;
			ValaCCodeFunction* _tmp293_;
			ValaCCodeMemberAccess* _tmp294_;
			ValaCCodeConstant* _tmp295_;
			ValaCCodeConstant* _tmp296_;
			ValaCCodeFunction* _tmp297_;
			ValaCCodeFunction* _tmp298_;
			_tmp281_ = data_var;
			_tmp282_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp281_, "_task_complete_");
			task_completed_var = _tmp282_;
			_tmp283_ = vala_ccode_identifier_new ("_callback_");
			callback = _tmp283_;
			_tmp284_ = callback;
			_tmp285_ = vala_ccode_constant_new ("NULL");
			_tmp286_ = _tmp285_;
			_tmp287_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp284_, (ValaCCodeExpression*) _tmp286_);
			_tmp288_ = _tmp287_;
			_vala_ccode_node_unref0 (_tmp286_);
			callback_is_null = _tmp288_;
			_tmp289_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp290_ = _tmp289_;
			_tmp291_ = callback_is_null;
			vala_ccode_function_open_if (_tmp290_, (ValaCCodeExpression*) _tmp291_);
			_tmp292_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp293_ = _tmp292_;
			_tmp294_ = task_completed_var;
			_tmp295_ = vala_ccode_constant_new ("TRUE");
			_tmp296_ = _tmp295_;
			vala_ccode_function_add_assignment (_tmp293_, (ValaCCodeExpression*) _tmp294_, (ValaCCodeExpression*) _tmp296_);
			_vala_ccode_node_unref0 (_tmp296_);
			_tmp297_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp298_ = _tmp297_;
			vala_ccode_function_close (_tmp298_);
			_vala_ccode_node_unref0 (callback_is_null);
			_vala_ccode_node_unref0 (callback);
			_vala_ccode_node_unref0 (task_completed_var);
		}
		_tmp299_ = vala_ccode_identifier_new ("g_task_set_task_data");
		_tmp300_ = _tmp299_;
		_tmp301_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp300_);
		_vala_ccode_node_unref0 (attach_data_call);
		attach_data_call = _tmp301_;
		_vala_ccode_node_unref0 (_tmp300_);
	}
	_tmp302_ = attach_data_call;
	_tmp303_ = data_var;
	_tmp304_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp303_, "_async_result");
	_tmp305_ = _tmp304_;
	vala_ccode_function_call_add_argument (_tmp302_, (ValaCCodeExpression*) _tmp305_);
	_vala_ccode_node_unref0 (_tmp305_);
	_tmp306_ = attach_data_call;
	_tmp307_ = data_var;
	vala_ccode_function_call_add_argument (_tmp306_, (ValaCCodeExpression*) _tmp307_);
	_tmp308_ = attach_data_call;
	_tmp309_ = m;
	_tmp310_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp309_);
	_tmp311_ = _tmp310_;
	_tmp312_ = g_strconcat (_tmp311_, "_data_free", NULL);
	_tmp313_ = _tmp312_;
	_tmp314_ = vala_ccode_identifier_new (_tmp313_);
	_tmp315_ = _tmp314_;
	vala_ccode_function_call_add_argument (_tmp308_, (ValaCCodeExpression*) _tmp315_);
	_vala_ccode_node_unref0 (_tmp315_);
	_g_free0 (_tmp313_);
	_g_free0 (_tmp311_);
	_tmp316_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp317_ = _tmp316_;
	_tmp318_ = attach_data_call;
	vala_ccode_function_add_expression (_tmp317_, (ValaCCodeExpression*) _tmp318_);
	_tmp319_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp319_, VALA_TYPE_CREATION_METHOD)) {
		ValaCCodeFunction* _tmp320_;
		ValaCCodeFunction* _tmp321_;
		ValaCCodeIdentifier* _tmp322_;
		ValaCCodeMemberAccess* _tmp323_;
		ValaCCodeMemberAccess* _tmp324_;
		ValaCCodeIdentifier* _tmp325_;
		ValaCCodeIdentifier* _tmp326_;
		_tmp320_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp321_ = _tmp320_;
		_tmp322_ = data_var;
		_tmp323_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp322_, "object_type");
		_tmp324_ = _tmp323_;
		_tmp325_ = vala_ccode_identifier_new ("object_type");
		_tmp326_ = _tmp325_;
		vala_ccode_function_add_assignment (_tmp321_, (ValaCCodeExpression*) _tmp324_, (ValaCCodeExpression*) _tmp326_);
		_vala_ccode_node_unref0 (_tmp326_);
		_vala_ccode_node_unref0 (_tmp324_);
	} else {
		ValaMethod* _tmp327_;
		ValaMemberBinding _tmp328_;
		ValaMemberBinding _tmp329_;
		_tmp327_ = m;
		_tmp328_ = vala_method_get_binding (_tmp327_);
		_tmp329_ = _tmp328_;
		if (_tmp329_ == VALA_MEMBER_BINDING_INSTANCE) {
			ValaDataType* this_type = NULL;
			ValaMethod* _tmp330_;
			ValaParameter* _tmp331_;
			ValaParameter* _tmp332_;
			ValaDataType* _tmp333_;
			ValaDataType* _tmp334_;
			ValaDataType* _tmp335_;
			ValaDataType* _tmp336_;
			ValaCCodeExpression* cself = NULL;
			ValaCCodeIdentifier* _tmp337_;
			ValaDataType* _tmp338_;
			gboolean _tmp339_;
			ValaDataType* _tmp342_;
			gboolean _tmp343_;
			ValaCCodeFunction* _tmp358_;
			ValaCCodeFunction* _tmp359_;
			ValaCCodeIdentifier* _tmp360_;
			ValaCCodeMemberAccess* _tmp361_;
			ValaCCodeMemberAccess* _tmp362_;
			ValaCCodeExpression* _tmp363_;
			_tmp330_ = m;
			_tmp331_ = vala_method_get_this_parameter (_tmp330_);
			_tmp332_ = _tmp331_;
			_tmp333_ = vala_variable_get_variable_type ((ValaVariable*) _tmp332_);
			_tmp334_ = _tmp333_;
			_tmp335_ = vala_data_type_copy (_tmp334_);
			this_type = _tmp335_;
			_tmp336_ = this_type;
			vala_data_type_set_value_owned (_tmp336_, TRUE);
			_tmp337_ = vala_ccode_identifier_new ("self");
			cself = (ValaCCodeExpression*) _tmp337_;
			_tmp338_ = this_type;
			_tmp339_ = vala_data_type_is_real_non_null_struct_type (_tmp338_);
			if (_tmp339_) {
				ValaCCodeExpression* _tmp340_;
				ValaCCodeUnaryExpression* _tmp341_;
				_tmp340_ = cself;
				_tmp341_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp340_);
				_vala_ccode_node_unref0 (cself);
				cself = (ValaCCodeExpression*) _tmp341_;
			}
			_tmp342_ = this_type;
			_tmp343_ = vala_ccode_base_module_requires_copy ((ValaCCodeBaseModule*) self, _tmp342_);
			if (_tmp343_) {
				ValaMethod* _tmp344_;
				ValaParameter* _tmp345_;
				ValaParameter* _tmp346_;
				ValaDataType* _tmp347_;
				ValaDataType* _tmp348_;
				ValaCCodeExpression* _tmp349_;
				ValaGLibValue* _tmp350_;
				ValaGLibValue* _tmp351_;
				ValaMethod* _tmp352_;
				ValaParameter* _tmp353_;
				ValaParameter* _tmp354_;
				ValaTargetValue* _tmp355_;
				ValaTargetValue* _tmp356_;
				ValaCCodeExpression* _tmp357_;
				_tmp344_ = m;
				_tmp345_ = vala_method_get_this_parameter (_tmp344_);
				_tmp346_ = _tmp345_;
				_tmp347_ = vala_variable_get_variable_type ((ValaVariable*) _tmp346_);
				_tmp348_ = _tmp347_;
				_tmp349_ = cself;
				_tmp350_ = vala_glib_value_new (_tmp348_, _tmp349_, TRUE);
				_tmp351_ = _tmp350_;
				_tmp352_ = m;
				_tmp353_ = vala_method_get_this_parameter (_tmp352_);
				_tmp354_ = _tmp353_;
				_tmp355_ = vala_ccode_base_module_copy_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp351_, (ValaCodeNode*) _tmp354_);
				_tmp356_ = _tmp355_;
				_tmp357_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp356_);
				_vala_ccode_node_unref0 (cself);
				cself = _tmp357_;
				_vala_target_value_unref0 (_tmp356_);
				_vala_target_value_unref0 (_tmp351_);
			}
			_tmp358_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp359_ = _tmp358_;
			_tmp360_ = data_var;
			_tmp361_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp360_, "self");
			_tmp362_ = _tmp361_;
			_tmp363_ = cself;
			vala_ccode_function_add_assignment (_tmp359_, (ValaCCodeExpression*) _tmp362_, _tmp363_);
			_vala_ccode_node_unref0 (_tmp362_);
			_vala_ccode_node_unref0 (cself);
			_vala_code_node_unref0 (this_type);
		}
	}
	_tmp364_ = ((ValaCCodeBaseModule*) self)->emit_context;
	_tmp365_ = m;
	vala_ccode_base_module_emit_context_push_symbol (_tmp364_, (ValaSymbol*) _tmp365_);
	{
		ValaList* _param_list = NULL;
		ValaMethod* _tmp366_;
		ValaList* _tmp367_;
		gint _param_size = 0;
		ValaList* _tmp368_;
		gint _tmp369_;
		gint _tmp370_;
		gint _param_index = 0;
		_tmp366_ = m;
		_tmp367_ = vala_callable_get_parameters ((ValaCallable*) _tmp366_);
		_param_list = _tmp367_;
		_tmp368_ = _param_list;
		_tmp369_ = vala_collection_get_size ((ValaCollection*) _tmp368_);
		_tmp370_ = _tmp369_;
		_param_size = _tmp370_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp371_;
			gint _tmp372_;
			gint _tmp373_;
			ValaParameter* param = NULL;
			ValaList* _tmp374_;
			gint _tmp375_;
			gpointer _tmp376_;
			ValaParameter* _tmp377_;
			ValaParameterDirection _tmp378_;
			ValaParameterDirection _tmp379_;
			_tmp371_ = _param_index;
			_param_index = _tmp371_ + 1;
			_tmp372_ = _param_index;
			_tmp373_ = _param_size;
			if (!(_tmp372_ < _tmp373_)) {
				break;
			}
			_tmp374_ = _param_list;
			_tmp375_ = _param_index;
			_tmp376_ = vala_list_get (_tmp374_, _tmp375_);
			param = (ValaParameter*) _tmp376_;
			_tmp377_ = param;
			_tmp378_ = vala_parameter_get_direction (_tmp377_);
			_tmp379_ = _tmp378_;
			if (_tmp379_ != VALA_PARAMETER_DIRECTION_OUT) {
				gboolean old_captured = FALSE;
				ValaParameter* _tmp380_;
				gboolean _tmp381_;
				gboolean _tmp382_;
				ValaParameter* _tmp383_;
				ValaMethod* _tmp384_;
				ValaMethod* _tmp385_;
				ValaTargetValue* value = NULL;
				ValaParameter* _tmp386_;
				ValaDataType* _tmp387_;
				ValaDataType* _tmp388_;
				gboolean _tmp389_;
				gboolean _tmp390_;
				ValaMethod* _tmp395_;
				ValaMethod* _tmp396_;
				ValaParameter* _tmp397_;
				ValaTargetValue* _tmp398_;
				ValaParameter* _tmp399_;
				gboolean _tmp400_;
				_tmp380_ = param;
				_tmp381_ = vala_parameter_get_captured (_tmp380_);
				_tmp382_ = _tmp381_;
				old_captured = _tmp382_;
				_tmp383_ = param;
				vala_parameter_set_captured (_tmp383_, FALSE);
				_tmp384_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
				_tmp385_ = _tmp384_;
				vala_method_set_coroutine (_tmp385_, FALSE);
				_tmp386_ = param;
				_tmp387_ = vala_variable_get_variable_type ((ValaVariable*) _tmp386_);
				_tmp388_ = _tmp387_;
				_tmp389_ = vala_data_type_get_value_owned (_tmp388_);
				_tmp390_ = _tmp389_;
				if (_tmp390_) {
					ValaParameter* _tmp391_;
					ValaTargetValue* _tmp392_;
					_tmp391_ = param;
					_tmp392_ = vala_ccode_base_module_get_parameter_cvalue ((ValaCCodeBaseModule*) self, _tmp391_);
					_vala_target_value_unref0 (value);
					value = _tmp392_;
				} else {
					ValaParameter* _tmp393_;
					ValaTargetValue* _tmp394_;
					_tmp393_ = param;
					_tmp394_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, _tmp393_);
					_vala_target_value_unref0 (value);
					value = _tmp394_;
				}
				_tmp395_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
				_tmp396_ = _tmp395_;
				vala_method_set_coroutine (_tmp396_, TRUE);
				_tmp397_ = param;
				_tmp398_ = value;
				vala_code_generator_store_parameter ((ValaCodeGenerator*) self, _tmp397_, _tmp398_, FALSE);
				_tmp399_ = param;
				_tmp400_ = old_captured;
				vala_parameter_set_captured (_tmp399_, _tmp400_);
				_vala_target_value_unref0 (value);
			}
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
	_tmp401_ = ((ValaCCodeBaseModule*) self)->emit_context;
	vala_ccode_base_module_emit_context_pop_symbol (_tmp401_);
	{
		ValaList* _type_param_list = NULL;
		ValaMethod* _tmp402_;
		ValaList* _tmp403_;
		gint _type_param_size = 0;
		ValaList* _tmp404_;
		gint _tmp405_;
		gint _tmp406_;
		gint _type_param_index = 0;
		_tmp402_ = m;
		_tmp403_ = vala_method_get_type_parameters (_tmp402_);
		_type_param_list = _tmp403_;
		_tmp404_ = _type_param_list;
		_tmp405_ = vala_collection_get_size ((ValaCollection*) _tmp404_);
		_tmp406_ = _tmp405_;
		_type_param_size = _tmp406_;
		_type_param_index = -1;
		while (TRUE) {
			gint _tmp407_;
			gint _tmp408_;
			gint _tmp409_;
			ValaTypeParameter* type_param = NULL;
			ValaList* _tmp410_;
			gint _tmp411_;
			gpointer _tmp412_;
			gchar* type = NULL;
			ValaTypeParameter* _tmp413_;
			const gchar* _tmp414_;
			const gchar* _tmp415_;
			gchar* _tmp416_;
			gchar* _tmp417_;
			gchar* _tmp418_;
			gchar* _tmp419_;
			gchar* dup_func = NULL;
			ValaTypeParameter* _tmp420_;
			const gchar* _tmp421_;
			const gchar* _tmp422_;
			gchar* _tmp423_;
			gchar* _tmp424_;
			gchar* _tmp425_;
			gchar* _tmp426_;
			gchar* destroy_func = NULL;
			ValaTypeParameter* _tmp427_;
			const gchar* _tmp428_;
			const gchar* _tmp429_;
			gchar* _tmp430_;
			gchar* _tmp431_;
			gchar* _tmp432_;
			gchar* _tmp433_;
			ValaCCodeFunction* _tmp434_;
			ValaCCodeFunction* _tmp435_;
			ValaCCodeIdentifier* _tmp436_;
			const gchar* _tmp437_;
			ValaCCodeMemberAccess* _tmp438_;
			ValaCCodeMemberAccess* _tmp439_;
			const gchar* _tmp440_;
			ValaCCodeIdentifier* _tmp441_;
			ValaCCodeIdentifier* _tmp442_;
			ValaCCodeFunction* _tmp443_;
			ValaCCodeFunction* _tmp444_;
			ValaCCodeIdentifier* _tmp445_;
			const gchar* _tmp446_;
			ValaCCodeMemberAccess* _tmp447_;
			ValaCCodeMemberAccess* _tmp448_;
			const gchar* _tmp449_;
			ValaCCodeIdentifier* _tmp450_;
			ValaCCodeIdentifier* _tmp451_;
			ValaCCodeFunction* _tmp452_;
			ValaCCodeFunction* _tmp453_;
			ValaCCodeIdentifier* _tmp454_;
			const gchar* _tmp455_;
			ValaCCodeMemberAccess* _tmp456_;
			ValaCCodeMemberAccess* _tmp457_;
			const gchar* _tmp458_;
			ValaCCodeIdentifier* _tmp459_;
			ValaCCodeIdentifier* _tmp460_;
			_tmp407_ = _type_param_index;
			_type_param_index = _tmp407_ + 1;
			_tmp408_ = _type_param_index;
			_tmp409_ = _type_param_size;
			if (!(_tmp408_ < _tmp409_)) {
				break;
			}
			_tmp410_ = _type_param_list;
			_tmp411_ = _type_param_index;
			_tmp412_ = vala_list_get (_tmp410_, _tmp411_);
			type_param = (ValaTypeParameter*) _tmp412_;
			_tmp413_ = type_param;
			_tmp414_ = vala_symbol_get_name ((ValaSymbol*) _tmp413_);
			_tmp415_ = _tmp414_;
			_tmp416_ = g_utf8_strdown (_tmp415_, (gssize) -1);
			_tmp417_ = _tmp416_;
			_tmp418_ = g_strdup_printf ("%s_type", _tmp417_);
			_tmp419_ = _tmp418_;
			_g_free0 (_tmp417_);
			type = _tmp419_;
			_tmp420_ = type_param;
			_tmp421_ = vala_symbol_get_name ((ValaSymbol*) _tmp420_);
			_tmp422_ = _tmp421_;
			_tmp423_ = g_utf8_strdown (_tmp422_, (gssize) -1);
			_tmp424_ = _tmp423_;
			_tmp425_ = g_strdup_printf ("%s_dup_func", _tmp424_);
			_tmp426_ = _tmp425_;
			_g_free0 (_tmp424_);
			dup_func = _tmp426_;
			_tmp427_ = type_param;
			_tmp428_ = vala_symbol_get_name ((ValaSymbol*) _tmp427_);
			_tmp429_ = _tmp428_;
			_tmp430_ = g_utf8_strdown (_tmp429_, (gssize) -1);
			_tmp431_ = _tmp430_;
			_tmp432_ = g_strdup_printf ("%s_destroy_func", _tmp431_);
			_tmp433_ = _tmp432_;
			_g_free0 (_tmp431_);
			destroy_func = _tmp433_;
			_tmp434_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp435_ = _tmp434_;
			_tmp436_ = data_var;
			_tmp437_ = type;
			_tmp438_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp436_, _tmp437_);
			_tmp439_ = _tmp438_;
			_tmp440_ = type;
			_tmp441_ = vala_ccode_identifier_new (_tmp440_);
			_tmp442_ = _tmp441_;
			vala_ccode_function_add_assignment (_tmp435_, (ValaCCodeExpression*) _tmp439_, (ValaCCodeExpression*) _tmp442_);
			_vala_ccode_node_unref0 (_tmp442_);
			_vala_ccode_node_unref0 (_tmp439_);
			_tmp443_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp444_ = _tmp443_;
			_tmp445_ = data_var;
			_tmp446_ = dup_func;
			_tmp447_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp445_, _tmp446_);
			_tmp448_ = _tmp447_;
			_tmp449_ = dup_func;
			_tmp450_ = vala_ccode_identifier_new (_tmp449_);
			_tmp451_ = _tmp450_;
			vala_ccode_function_add_assignment (_tmp444_, (ValaCCodeExpression*) _tmp448_, (ValaCCodeExpression*) _tmp451_);
			_vala_ccode_node_unref0 (_tmp451_);
			_vala_ccode_node_unref0 (_tmp448_);
			_tmp452_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp453_ = _tmp452_;
			_tmp454_ = data_var;
			_tmp455_ = destroy_func;
			_tmp456_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp454_, _tmp455_);
			_tmp457_ = _tmp456_;
			_tmp458_ = destroy_func;
			_tmp459_ = vala_ccode_identifier_new (_tmp458_);
			_tmp460_ = _tmp459_;
			vala_ccode_function_add_assignment (_tmp453_, (ValaCCodeExpression*) _tmp457_, (ValaCCodeExpression*) _tmp460_);
			_vala_ccode_node_unref0 (_tmp460_);
			_vala_ccode_node_unref0 (_tmp457_);
			_g_free0 (destroy_func);
			_g_free0 (dup_func);
			_g_free0 (type);
			_vala_code_node_unref0 (type_param);
		}
		_vala_iterable_unref0 (_type_param_list);
	}
	_tmp461_ = m;
	_tmp462_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp461_);
	_tmp463_ = _tmp462_;
	_tmp464_ = g_strconcat (_tmp463_, "_co", NULL);
	_tmp465_ = _tmp464_;
	_tmp466_ = vala_ccode_identifier_new (_tmp465_);
	_tmp467_ = _tmp466_;
	_tmp468_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp467_);
	_tmp469_ = _tmp468_;
	_vala_ccode_node_unref0 (_tmp467_);
	_g_free0 (_tmp465_);
	_g_free0 (_tmp463_);
	ccall = _tmp469_;
	_tmp470_ = data_var;
	vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp470_);
	_tmp471_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp472_ = _tmp471_;
	vala_ccode_function_add_expression (_tmp472_, (ValaCCodeExpression*) ccall);
	_tmp473_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp474_ = asyncfunc;
	vala_ccode_file_add_function (_tmp473_, _tmp474_);
	vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self);
	_vala_ccode_node_unref0 (ccall);
	_vala_ccode_node_unref0 (attach_data_call);
	_vala_code_node_unref0 (t);
	_vala_ccode_node_unref0 (create_result);
	_vala_ccode_node_unref0 (data_var);
	_vala_ccode_node_unref0 (dataalloc);
	_vala_map_unref0 (cparam_map);
	_vala_ccode_node_unref0 (asyncfunc);
	_g_free0 (dataname);
	_g_free0 (callback_wrapper);
}


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


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


static void vala_gasync_module_append_struct (ValaGAsyncModule* self, ValaCCodeStruct* structure) {
	ValaCCodeVariableDeclarator* typename = NULL;
	ValaCCodeStruct* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	ValaCCodeVariableDeclarator* _tmp5_;
	ValaCCodeVariableDeclarator* _tmp6_;
	ValaCCodeTypeDefinition* _typedef_ = NULL;
	ValaCCodeStruct* _tmp7_;
	const gchar* _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	ValaCCodeTypeDefinition* _tmp12_;
	ValaCCodeTypeDefinition* _tmp13_;
	ValaCCodeFile* _tmp14_;
	ValaCCodeFile* _tmp15_;
	ValaCCodeStruct* _tmp16_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (structure != NULL);
	_tmp0_ = structure;
	_tmp1_ = vala_ccode_struct_get_name (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = string_substring (_tmp2_, (glong) 1, (glong) -1);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_ccode_variable_declarator_new (_tmp4_, NULL, NULL);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	typename = _tmp6_;
	_tmp7_ = structure;
	_tmp8_ = vala_ccode_struct_get_name (_tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = g_strconcat ("struct ", _tmp9_, NULL);
	_tmp11_ = _tmp10_;
	_tmp12_ = vala_ccode_type_definition_new (_tmp11_, (ValaCCodeDeclarator*) typename);
	_tmp13_ = _tmp12_;
	_g_free0 (_tmp11_);
	_typedef_ = _tmp13_;
	_tmp14_ = ((ValaCCodeBaseModule*) self)->cfile;
	vala_ccode_file_add_type_declaration (_tmp14_, (ValaCCodeNode*) _typedef_);
	_tmp15_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp16_ = structure;
	vala_ccode_file_add_type_definition (_tmp15_, (ValaCCodeNode*) _tmp16_);
	_vala_ccode_node_unref0 (_typedef_);
	_vala_ccode_node_unref0 (typename);
}


static void vala_gasync_module_real_generate_method_declaration (ValaCCodeBaseModule* base, ValaMethod* m, ValaCCodeFile* decl_space) {
	ValaGAsyncModule * self;
	ValaMethod* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	self = (ValaGAsyncModule*) base;
	g_return_if_fail (m != NULL);
	g_return_if_fail (decl_space != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_method_get_coroutine (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_) {
		ValaCCodeFile* _tmp3_;
		ValaMethod* _tmp4_;
		ValaMethod* _tmp5_;
		gchar* _tmp6_;
		gchar* _tmp7_;
		gboolean _tmp8_;
		gboolean _tmp9_;
		ValaClass* cl = NULL;
		ValaMethod* _tmp10_;
		ValaSymbol* _tmp11_;
		ValaSymbol* _tmp12_;
		ValaClass* _tmp13_;
		ValaCCodeFunction* asyncfunc = NULL;
		ValaMethod* _tmp14_;
		gchar* _tmp15_;
		gchar* _tmp16_;
		ValaCCodeFunction* _tmp17_;
		ValaCCodeFunction* _tmp18_;
		ValaHashMap* cparam_map = NULL;
		GHashFunc _tmp19_;
		GEqualFunc _tmp20_;
		GEqualFunc _tmp21_;
		ValaHashMap* _tmp22_;
		ValaHashMap* carg_map = NULL;
		GHashFunc _tmp23_;
		GEqualFunc _tmp24_;
		GEqualFunc _tmp25_;
		ValaHashMap* _tmp26_;
		ValaMethod* _tmp27_;
		gboolean _tmp28_;
		gboolean _tmp44_ = FALSE;
		gboolean _tmp45_ = FALSE;
		ValaMethod* _tmp46_;
		ValaCCodeFunction* finishfunc = NULL;
		ValaMethod* _tmp62_;
		gchar* _tmp63_;
		gchar* _tmp64_;
		ValaCCodeFunction* _tmp65_;
		ValaCCodeFunction* _tmp66_;
		GHashFunc _tmp67_;
		GEqualFunc _tmp68_;
		GEqualFunc _tmp69_;
		ValaHashMap* _tmp70_;
		GHashFunc _tmp71_;
		GEqualFunc _tmp72_;
		GEqualFunc _tmp73_;
		ValaHashMap* _tmp74_;
		ValaMethod* _tmp75_;
		gboolean _tmp76_;
		gboolean _tmp92_ = FALSE;
		gboolean _tmp93_ = FALSE;
		ValaMethod* _tmp94_;
		gboolean _tmp110_ = FALSE;
		ValaMethod* _tmp111_;
		_tmp3_ = decl_space;
		_tmp4_ = m;
		_tmp5_ = m;
		_tmp6_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_ccode_base_module_add_symbol_declaration ((ValaCCodeBaseModule*) self, _tmp3_, (ValaSymbol*) _tmp4_, _tmp7_);
		_tmp9_ = _tmp8_;
		_g_free0 (_tmp7_);
		if (_tmp9_) {
			return;
		}
		_tmp10_ = m;
		_tmp11_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp12_) : NULL);
		cl = _tmp13_;
		_tmp14_ = m;
		_tmp15_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = vala_ccode_function_new (_tmp16_, "void");
		_tmp18_ = _tmp17_;
		_g_free0 (_tmp16_);
		asyncfunc = _tmp18_;
		_tmp19_ = g_direct_hash;
		_tmp20_ = g_direct_equal;
		_tmp21_ = g_direct_equal;
		_tmp22_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp19_, _tmp20_, _tmp21_);
		cparam_map = _tmp22_;
		_tmp23_ = g_direct_hash;
		_tmp24_ = g_direct_equal;
		_tmp25_ = g_direct_equal;
		_tmp26_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp23_, _tmp24_, _tmp25_);
		carg_map = _tmp26_;
		_tmp27_ = m;
		_tmp28_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp27_);
		if (_tmp28_) {
			ValaCCodeFunction* _tmp29_;
			ValaCCodeFunction* _tmp30_;
			ValaCCodeModifiers _tmp31_;
			ValaCCodeModifiers _tmp32_;
			_tmp29_ = asyncfunc;
			_tmp30_ = asyncfunc;
			_tmp31_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp30_);
			_tmp32_ = _tmp31_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp30_, _tmp32_ | VALA_CCODE_MODIFIERS_STATIC);
		} else {
			gboolean _tmp33_ = FALSE;
			ValaCodeContext* _tmp34_;
			ValaCodeContext* _tmp35_;
			gboolean _tmp36_;
			gboolean _tmp37_;
			_tmp34_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
			_tmp35_ = _tmp34_;
			_tmp36_ = vala_code_context_get_hide_internal (_tmp35_);
			_tmp37_ = _tmp36_;
			if (_tmp37_) {
				ValaMethod* _tmp38_;
				gboolean _tmp39_;
				_tmp38_ = m;
				_tmp39_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp38_);
				_tmp33_ = _tmp39_;
			} else {
				_tmp33_ = FALSE;
			}
			if (_tmp33_) {
				ValaCCodeFunction* _tmp40_;
				ValaCCodeFunction* _tmp41_;
				ValaCCodeModifiers _tmp42_;
				ValaCCodeModifiers _tmp43_;
				_tmp40_ = asyncfunc;
				_tmp41_ = asyncfunc;
				_tmp42_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp41_);
				_tmp43_ = _tmp42_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp41_, _tmp43_ | VALA_CCODE_MODIFIERS_INTERNAL);
			}
		}
		_tmp46_ = m;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp46_, VALA_TYPE_CREATION_METHOD)) {
			ValaClass* _tmp47_;
			_tmp47_ = cl;
			_tmp45_ = _tmp47_ != NULL;
		} else {
			_tmp45_ = FALSE;
		}
		if (_tmp45_) {
			ValaClass* _tmp48_;
			gboolean _tmp49_;
			gboolean _tmp50_;
			_tmp48_ = cl;
			_tmp49_ = vala_class_get_is_abstract (_tmp48_);
			_tmp50_ = _tmp49_;
			_tmp44_ = _tmp50_;
		} else {
			_tmp44_ = FALSE;
		}
		if (!_tmp44_) {
			ValaMethod* _tmp51_;
			ValaCCodeFile* _tmp52_;
			ValaHashMap* _tmp53_;
			ValaCCodeFunction* _tmp54_;
			ValaHashMap* _tmp55_;
			ValaCCodeIdentifier* _tmp56_;
			ValaCCodeIdentifier* _tmp57_;
			ValaCCodeFunctionCall* _tmp58_;
			ValaCCodeFunctionCall* _tmp59_;
			ValaCCodeFile* _tmp60_;
			ValaCCodeFunction* _tmp61_;
			_tmp51_ = m;
			_tmp52_ = decl_space;
			_tmp53_ = cparam_map;
			_tmp54_ = asyncfunc;
			_tmp55_ = carg_map;
			_tmp56_ = vala_ccode_identifier_new ("fake");
			_tmp57_ = _tmp56_;
			_tmp58_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp57_);
			_tmp59_ = _tmp58_;
			vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp51_, _tmp52_, (ValaMap*) _tmp53_, _tmp54_, NULL, (ValaMap*) _tmp55_, _tmp59_, 1);
			_vala_ccode_node_unref0 (_tmp59_);
			_vala_ccode_node_unref0 (_tmp57_);
			_tmp60_ = decl_space;
			_tmp61_ = asyncfunc;
			vala_ccode_file_add_function_declaration (_tmp60_, _tmp61_);
		}
		_tmp62_ = m;
		_tmp63_ = vala_ccode_base_module_get_ccode_finish_name (_tmp62_);
		_tmp64_ = _tmp63_;
		_tmp65_ = vala_ccode_function_new (_tmp64_, "void");
		_tmp66_ = _tmp65_;
		_g_free0 (_tmp64_);
		finishfunc = _tmp66_;
		_tmp67_ = g_direct_hash;
		_tmp68_ = g_direct_equal;
		_tmp69_ = g_direct_equal;
		_tmp70_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp67_, _tmp68_, _tmp69_);
		_vala_map_unref0 (cparam_map);
		cparam_map = _tmp70_;
		_tmp71_ = g_direct_hash;
		_tmp72_ = g_direct_equal;
		_tmp73_ = g_direct_equal;
		_tmp74_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp71_, _tmp72_, _tmp73_);
		_vala_map_unref0 (carg_map);
		carg_map = _tmp74_;
		_tmp75_ = m;
		_tmp76_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp75_);
		if (_tmp76_) {
			ValaCCodeFunction* _tmp77_;
			ValaCCodeFunction* _tmp78_;
			ValaCCodeModifiers _tmp79_;
			ValaCCodeModifiers _tmp80_;
			_tmp77_ = finishfunc;
			_tmp78_ = finishfunc;
			_tmp79_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp78_);
			_tmp80_ = _tmp79_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp78_, _tmp80_ | VALA_CCODE_MODIFIERS_STATIC);
		} else {
			gboolean _tmp81_ = FALSE;
			ValaCodeContext* _tmp82_;
			ValaCodeContext* _tmp83_;
			gboolean _tmp84_;
			gboolean _tmp85_;
			_tmp82_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
			_tmp83_ = _tmp82_;
			_tmp84_ = vala_code_context_get_hide_internal (_tmp83_);
			_tmp85_ = _tmp84_;
			if (_tmp85_) {
				ValaMethod* _tmp86_;
				gboolean _tmp87_;
				_tmp86_ = m;
				_tmp87_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp86_);
				_tmp81_ = _tmp87_;
			} else {
				_tmp81_ = FALSE;
			}
			if (_tmp81_) {
				ValaCCodeFunction* _tmp88_;
				ValaCCodeFunction* _tmp89_;
				ValaCCodeModifiers _tmp90_;
				ValaCCodeModifiers _tmp91_;
				_tmp88_ = finishfunc;
				_tmp89_ = finishfunc;
				_tmp90_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp89_);
				_tmp91_ = _tmp90_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp89_, _tmp91_ | VALA_CCODE_MODIFIERS_INTERNAL);
			}
		}
		_tmp94_ = m;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp94_, VALA_TYPE_CREATION_METHOD)) {
			ValaClass* _tmp95_;
			_tmp95_ = cl;
			_tmp93_ = _tmp95_ != NULL;
		} else {
			_tmp93_ = FALSE;
		}
		if (_tmp93_) {
			ValaClass* _tmp96_;
			gboolean _tmp97_;
			gboolean _tmp98_;
			_tmp96_ = cl;
			_tmp97_ = vala_class_get_is_abstract (_tmp96_);
			_tmp98_ = _tmp97_;
			_tmp92_ = _tmp98_;
		} else {
			_tmp92_ = FALSE;
		}
		if (!_tmp92_) {
			ValaMethod* _tmp99_;
			ValaCCodeFile* _tmp100_;
			ValaHashMap* _tmp101_;
			ValaCCodeFunction* _tmp102_;
			ValaHashMap* _tmp103_;
			ValaCCodeIdentifier* _tmp104_;
			ValaCCodeIdentifier* _tmp105_;
			ValaCCodeFunctionCall* _tmp106_;
			ValaCCodeFunctionCall* _tmp107_;
			ValaCCodeFile* _tmp108_;
			ValaCCodeFunction* _tmp109_;
			_tmp99_ = m;
			_tmp100_ = decl_space;
			_tmp101_ = cparam_map;
			_tmp102_ = finishfunc;
			_tmp103_ = carg_map;
			_tmp104_ = vala_ccode_identifier_new ("fake");
			_tmp105_ = _tmp104_;
			_tmp106_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp105_);
			_tmp107_ = _tmp106_;
			vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp99_, _tmp100_, (ValaMap*) _tmp101_, _tmp102_, NULL, (ValaMap*) _tmp103_, _tmp107_, 2);
			_vala_ccode_node_unref0 (_tmp107_);
			_vala_ccode_node_unref0 (_tmp105_);
			_tmp108_ = decl_space;
			_tmp109_ = finishfunc;
			vala_ccode_file_add_function_declaration (_tmp108_, _tmp109_);
		}
		_tmp111_ = m;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp111_, VALA_TYPE_CREATION_METHOD)) {
			ValaClass* _tmp112_;
			_tmp112_ = cl;
			_tmp110_ = _tmp112_ != NULL;
		} else {
			_tmp110_ = FALSE;
		}
		if (_tmp110_) {
			ValaCCodeFunction* function = NULL;
			ValaMethod* _tmp113_;
			gchar* _tmp114_;
			gchar* _tmp115_;
			ValaCCodeFunction* _tmp116_;
			ValaCCodeFunction* _tmp117_;
			ValaMethod* _tmp118_;
			gboolean _tmp119_;
			GHashFunc _tmp135_;
			GEqualFunc _tmp136_;
			GEqualFunc _tmp137_;
			ValaHashMap* _tmp138_;
			ValaMethod* _tmp139_;
			ValaCCodeFile* _tmp140_;
			ValaHashMap* _tmp141_;
			ValaCCodeFunction* _tmp142_;
			ValaCCodeFile* _tmp143_;
			ValaCCodeFunction* _tmp144_;
			ValaMethod* _tmp145_;
			gchar* _tmp146_;
			gchar* _tmp147_;
			ValaCCodeFunction* _tmp148_;
			ValaMethod* _tmp149_;
			gboolean _tmp150_;
			GHashFunc _tmp166_;
			GEqualFunc _tmp167_;
			GEqualFunc _tmp168_;
			ValaHashMap* _tmp169_;
			ValaMethod* _tmp170_;
			ValaCCodeFile* _tmp171_;
			ValaHashMap* _tmp172_;
			ValaCCodeFunction* _tmp173_;
			ValaCCodeFile* _tmp174_;
			ValaCCodeFunction* _tmp175_;
			_tmp113_ = m;
			_tmp114_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp113_);
			_tmp115_ = _tmp114_;
			_tmp116_ = vala_ccode_function_new (_tmp115_, "void");
			_tmp117_ = _tmp116_;
			_g_free0 (_tmp115_);
			function = _tmp117_;
			_tmp118_ = m;
			_tmp119_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp118_);
			if (_tmp119_) {
				ValaCCodeFunction* _tmp120_;
				ValaCCodeFunction* _tmp121_;
				ValaCCodeModifiers _tmp122_;
				ValaCCodeModifiers _tmp123_;
				_tmp120_ = function;
				_tmp121_ = function;
				_tmp122_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp121_);
				_tmp123_ = _tmp122_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp121_, _tmp123_ | VALA_CCODE_MODIFIERS_STATIC);
			} else {
				gboolean _tmp124_ = FALSE;
				ValaCodeContext* _tmp125_;
				ValaCodeContext* _tmp126_;
				gboolean _tmp127_;
				gboolean _tmp128_;
				_tmp125_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
				_tmp126_ = _tmp125_;
				_tmp127_ = vala_code_context_get_hide_internal (_tmp126_);
				_tmp128_ = _tmp127_;
				if (_tmp128_) {
					ValaMethod* _tmp129_;
					gboolean _tmp130_;
					_tmp129_ = m;
					_tmp130_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp129_);
					_tmp124_ = _tmp130_;
				} else {
					_tmp124_ = FALSE;
				}
				if (_tmp124_) {
					ValaCCodeFunction* _tmp131_;
					ValaCCodeFunction* _tmp132_;
					ValaCCodeModifiers _tmp133_;
					ValaCCodeModifiers _tmp134_;
					_tmp131_ = function;
					_tmp132_ = function;
					_tmp133_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp132_);
					_tmp134_ = _tmp133_;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp132_, _tmp134_ | VALA_CCODE_MODIFIERS_INTERNAL);
				}
			}
			_tmp135_ = g_direct_hash;
			_tmp136_ = g_direct_equal;
			_tmp137_ = g_direct_equal;
			_tmp138_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp135_, _tmp136_, _tmp137_);
			_vala_map_unref0 (cparam_map);
			cparam_map = _tmp138_;
			_tmp139_ = m;
			_tmp140_ = decl_space;
			_tmp141_ = cparam_map;
			_tmp142_ = function;
			vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp139_, _tmp140_, (ValaMap*) _tmp141_, _tmp142_, NULL, NULL, NULL, 1);
			_tmp143_ = decl_space;
			_tmp144_ = function;
			vala_ccode_file_add_function_declaration (_tmp143_, _tmp144_);
			_tmp145_ = m;
			_tmp146_ = vala_ccode_base_module_get_ccode_finish_real_name (_tmp145_);
			_tmp147_ = _tmp146_;
			_tmp148_ = vala_ccode_function_new (_tmp147_, "void");
			_vala_ccode_node_unref0 (function);
			function = _tmp148_;
			_g_free0 (_tmp147_);
			_tmp149_ = m;
			_tmp150_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp149_);
			if (_tmp150_) {
				ValaCCodeFunction* _tmp151_;
				ValaCCodeFunction* _tmp152_;
				ValaCCodeModifiers _tmp153_;
				ValaCCodeModifiers _tmp154_;
				_tmp151_ = function;
				_tmp152_ = function;
				_tmp153_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp152_);
				_tmp154_ = _tmp153_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp152_, _tmp154_ | VALA_CCODE_MODIFIERS_STATIC);
			} else {
				gboolean _tmp155_ = FALSE;
				ValaCodeContext* _tmp156_;
				ValaCodeContext* _tmp157_;
				gboolean _tmp158_;
				gboolean _tmp159_;
				_tmp156_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
				_tmp157_ = _tmp156_;
				_tmp158_ = vala_code_context_get_hide_internal (_tmp157_);
				_tmp159_ = _tmp158_;
				if (_tmp159_) {
					ValaMethod* _tmp160_;
					gboolean _tmp161_;
					_tmp160_ = m;
					_tmp161_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp160_);
					_tmp155_ = _tmp161_;
				} else {
					_tmp155_ = FALSE;
				}
				if (_tmp155_) {
					ValaCCodeFunction* _tmp162_;
					ValaCCodeFunction* _tmp163_;
					ValaCCodeModifiers _tmp164_;
					ValaCCodeModifiers _tmp165_;
					_tmp162_ = function;
					_tmp163_ = function;
					_tmp164_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp163_);
					_tmp165_ = _tmp164_;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp163_, _tmp165_ | VALA_CCODE_MODIFIERS_INTERNAL);
				}
			}
			_tmp166_ = g_direct_hash;
			_tmp167_ = g_direct_equal;
			_tmp168_ = g_direct_equal;
			_tmp169_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp166_, _tmp167_, _tmp168_);
			_vala_map_unref0 (cparam_map);
			cparam_map = _tmp169_;
			_tmp170_ = m;
			_tmp171_ = decl_space;
			_tmp172_ = cparam_map;
			_tmp173_ = function;
			vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp170_, _tmp171_, (ValaMap*) _tmp172_, _tmp173_, NULL, NULL, NULL, 2);
			_tmp174_ = decl_space;
			_tmp175_ = function;
			vala_ccode_file_add_function_declaration (_tmp174_, _tmp175_);
			_vala_ccode_node_unref0 (function);
		}
		_vala_ccode_node_unref0 (finishfunc);
		_vala_map_unref0 (carg_map);
		_vala_map_unref0 (cparam_map);
		_vala_ccode_node_unref0 (asyncfunc);
		_vala_code_node_unref0 (cl);
	} else {
		ValaMethod* _tmp176_;
		ValaCCodeFile* _tmp177_;
		_tmp176_ = m;
		_tmp177_ = decl_space;
		VALA_CCODE_BASE_MODULE_CLASS (vala_gasync_module_parent_class)->generate_method_declaration ((ValaCCodeBaseModule*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GTK_MODULE, ValaGtkModule), _tmp176_, _tmp177_);
	}
}


static gpointer _vala_ccode_node_ref0 (gpointer self) {
	return self ? vala_ccode_node_ref (self) : NULL;
}


static void vala_gasync_module_real_visit_method (ValaCodeVisitor* base, ValaMethod* m) {
	ValaGAsyncModule * self;
	ValaMethod* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	self = (ValaGAsyncModule*) base;
	g_return_if_fail (m != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_method_get_coroutine (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_) {
		ValaCCodeFile* _tmp3_;
		ValaMethod* _tmp4_;
		gboolean _tmp5_;
		gboolean _tmp7_ = FALSE;
		ValaMethod* _tmp8_;
		gboolean _tmp9_;
		gboolean _tmp10_;
		gboolean _tmp35_ = FALSE;
		ValaMethod* _tmp36_;
		gboolean _tmp37_;
		gboolean _tmp38_;
		_tmp3_ = ((ValaCCodeBaseModule*) self)->cfile;
		vala_ccode_file_add_include (_tmp3_, "gio/gio.h", FALSE);
		_tmp4_ = m;
		_tmp5_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp4_);
		if (!_tmp5_) {
			ValaCCodeFile* _tmp6_;
			_tmp6_ = ((ValaCCodeBaseModule*) self)->header_file;
			vala_ccode_file_add_include (_tmp6_, "gio/gio.h", FALSE);
		}
		_tmp8_ = m;
		_tmp9_ = vala_method_get_is_abstract (_tmp8_);
		_tmp10_ = _tmp9_;
		if (!_tmp10_) {
			ValaMethod* _tmp11_;
			ValaBlock* _tmp12_;
			ValaBlock* _tmp13_;
			_tmp11_ = m;
			_tmp12_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp11_);
			_tmp13_ = _tmp12_;
			_tmp7_ = _tmp13_ != NULL;
		} else {
			_tmp7_ = FALSE;
		}
		if (_tmp7_) {
			ValaCCodeStruct* data = NULL;
			ValaMethod* _tmp14_;
			ValaCCodeStruct* _tmp15_;
			ValaCCodeStruct* _tmp16_;
			ValaCCodeStruct* _tmp17_;
			ValaMethod* _tmp18_;
			ValaCCodeFunction* _tmp19_;
			ValaCCodeFunction* _tmp20_;
			ValaMethod* _tmp21_;
			ValaMethod* _tmp22_;
			ValaMethod* _tmp23_;
			ValaCCodeStruct* _tmp24_;
			_tmp14_ = m;
			_tmp15_ = vala_gasync_module_generate_data_struct (self, _tmp14_);
			data = _tmp15_;
			_tmp16_ = data;
			_tmp17_ = _vala_ccode_node_ref0 (_tmp16_);
			_vala_ccode_node_unref0 (((ValaCCodeBaseModule*) self)->closure_struct);
			((ValaCCodeBaseModule*) self)->closure_struct = _tmp17_;
			_tmp18_ = m;
			_tmp19_ = vala_gasync_module_generate_free_function (self, _tmp18_);
			_tmp20_ = _tmp19_;
			_vala_ccode_node_unref0 (_tmp20_);
			_tmp21_ = m;
			vala_gasync_module_generate_async_function (self, _tmp21_);
			_tmp22_ = m;
			vala_gasync_module_generate_finish_function (self, _tmp22_);
			_tmp23_ = m;
			VALA_CODE_VISITOR_CLASS (vala_gasync_module_parent_class)->visit_method ((ValaCodeVisitor*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GTK_MODULE, ValaGtkModule), _tmp23_);
			_vala_ccode_node_unref0 (((ValaCCodeBaseModule*) self)->closure_struct);
			((ValaCCodeBaseModule*) self)->closure_struct = NULL;
			_tmp24_ = data;
			vala_gasync_module_append_struct (self, _tmp24_);
			_vala_ccode_node_unref0 (data);
		} else {
			ValaMethod* _tmp25_;
			ValaCCodeFile* _tmp26_;
			ValaMethod* _tmp27_;
			gboolean _tmp28_;
			ValaMethod* _tmp31_;
			gboolean _tmp32_;
			_tmp25_ = m;
			_tmp26_ = ((ValaCCodeBaseModule*) self)->cfile;
			vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp25_, _tmp26_);
			_tmp27_ = m;
			_tmp28_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp27_);
			if (!_tmp28_) {
				ValaMethod* _tmp29_;
				ValaCCodeFile* _tmp30_;
				_tmp29_ = m;
				_tmp30_ = ((ValaCCodeBaseModule*) self)->header_file;
				vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp29_, _tmp30_);
			}
			_tmp31_ = m;
			_tmp32_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp31_);
			if (!_tmp32_) {
				ValaMethod* _tmp33_;
				ValaCCodeFile* _tmp34_;
				_tmp33_ = m;
				_tmp34_ = ((ValaCCodeBaseModule*) self)->internal_header_file;
				vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp33_, _tmp34_);
			}
		}
		_tmp36_ = m;
		_tmp37_ = vala_method_get_is_abstract (_tmp36_);
		_tmp38_ = _tmp37_;
		if (_tmp38_) {
			_tmp35_ = TRUE;
		} else {
			ValaMethod* _tmp39_;
			gboolean _tmp40_;
			gboolean _tmp41_;
			_tmp39_ = m;
			_tmp40_ = vala_method_get_is_virtual (_tmp39_);
			_tmp41_ = _tmp40_;
			_tmp35_ = _tmp41_;
		}
		if (_tmp35_) {
			ValaHashMap* cparam_map = NULL;
			GHashFunc _tmp42_;
			GEqualFunc _tmp43_;
			GEqualFunc _tmp44_;
			ValaHashMap* _tmp45_;
			ValaHashMap* carg_map = NULL;
			GHashFunc _tmp46_;
			GEqualFunc _tmp47_;
			GEqualFunc _tmp48_;
			ValaHashMap* _tmp49_;
			ValaMethod* _tmp50_;
			ValaVoidType* _tmp51_;
			ValaVoidType* _tmp52_;
			ValaHashMap* _tmp53_;
			ValaHashMap* _tmp54_;
			GHashFunc _tmp55_;
			GEqualFunc _tmp56_;
			GEqualFunc _tmp57_;
			ValaHashMap* _tmp58_;
			GHashFunc _tmp59_;
			GEqualFunc _tmp60_;
			GEqualFunc _tmp61_;
			ValaHashMap* _tmp62_;
			ValaMethod* _tmp63_;
			ValaMethod* _tmp64_;
			ValaDataType* _tmp65_;
			ValaDataType* _tmp66_;
			ValaHashMap* _tmp67_;
			ValaHashMap* _tmp68_;
			_tmp42_ = g_direct_hash;
			_tmp43_ = g_direct_equal;
			_tmp44_ = g_direct_equal;
			_tmp45_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp42_, _tmp43_, _tmp44_);
			cparam_map = _tmp45_;
			_tmp46_ = g_direct_hash;
			_tmp47_ = g_direct_equal;
			_tmp48_ = g_direct_equal;
			_tmp49_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp46_, _tmp47_, _tmp48_);
			carg_map = _tmp49_;
			_tmp50_ = m;
			_tmp51_ = vala_void_type_new (NULL);
			_tmp52_ = _tmp51_;
			_tmp53_ = cparam_map;
			_tmp54_ = carg_map;
			vala_ccode_method_module_generate_vfunc ((ValaCCodeMethodModule*) self, _tmp50_, (ValaDataType*) _tmp52_, (ValaMap*) _tmp53_, (ValaMap*) _tmp54_, "", 1);
			_vala_code_node_unref0 (_tmp52_);
			_tmp55_ = g_direct_hash;
			_tmp56_ = g_direct_equal;
			_tmp57_ = g_direct_equal;
			_tmp58_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp55_, _tmp56_, _tmp57_);
			_vala_map_unref0 (cparam_map);
			cparam_map = _tmp58_;
			_tmp59_ = g_direct_hash;
			_tmp60_ = g_direct_equal;
			_tmp61_ = g_direct_equal;
			_tmp62_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp59_, _tmp60_, _tmp61_);
			_vala_map_unref0 (carg_map);
			carg_map = _tmp62_;
			_tmp63_ = m;
			_tmp64_ = m;
			_tmp65_ = vala_callable_get_return_type ((ValaCallable*) _tmp64_);
			_tmp66_ = _tmp65_;
			_tmp67_ = cparam_map;
			_tmp68_ = carg_map;
			vala_ccode_method_module_generate_vfunc ((ValaCCodeMethodModule*) self, _tmp63_, _tmp66_, (ValaMap*) _tmp67_, (ValaMap*) _tmp68_, "_finish", 2);
			_vala_map_unref0 (carg_map);
			_vala_map_unref0 (cparam_map);
		}
	} else {
		ValaMethod* _tmp69_;
		_tmp69_ = m;
		VALA_CODE_VISITOR_CLASS (vala_gasync_module_parent_class)->visit_method ((ValaCodeVisitor*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GTK_MODULE, ValaGtkModule), _tmp69_);
	}
}


static void vala_gasync_module_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m) {
	ValaGAsyncModule * self;
	ValaCreationMethod* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	self = (ValaGAsyncModule*) base;
	g_return_if_fail (m != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_method_get_coroutine ((ValaMethod*) _tmp0_);
	_tmp2_ = _tmp1_;
	if (!_tmp2_) {
		ValaCreationMethod* _tmp3_;
		_tmp3_ = m;
		VALA_CODE_VISITOR_CLASS (vala_gasync_module_parent_class)->visit_creation_method ((ValaCodeVisitor*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GTK_MODULE, ValaGtkModule), _tmp3_);
	} else {
		ValaCreationMethod* _tmp4_;
		ValaSourceReference* _tmp5_;
		ValaSourceReference* _tmp6_;
		gboolean visible = FALSE;
		ValaCreationMethod* _tmp7_;
		gboolean _tmp8_;
		ValaCreationMethod* _tmp9_;
		ValaCreationMethod* _tmp10_;
		ValaSourceFileType _tmp11_;
		ValaSourceFileType _tmp12_;
		gboolean _tmp13_ = FALSE;
		gboolean _tmp14_ = FALSE;
		ValaTypeSymbol* _tmp15_;
		ValaTypeSymbol* _tmp16_;
		_tmp4_ = m;
		_tmp5_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp4_);
		_tmp6_ = _tmp5_;
		vala_ccode_base_module_push_line ((ValaCCodeBaseModule*) self, _tmp6_);
		_tmp7_ = m;
		_tmp8_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp7_);
		visible = !_tmp8_;
		_tmp9_ = m;
		vala_code_visitor_visit_method ((ValaCodeVisitor*) self, (ValaMethod*) _tmp9_);
		_tmp10_ = m;
		_tmp11_ = vala_symbol_get_source_type ((ValaSymbol*) _tmp10_);
		_tmp12_ = _tmp11_;
		if (_tmp12_ == VALA_SOURCE_FILE_TYPE_FAST) {
			return;
		}
		_tmp15_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
		_tmp16_ = _tmp15_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_CLASS)) {
			ValaClass* _tmp17_;
			ValaClass* _tmp18_;
			gboolean _tmp19_;
			gboolean _tmp20_;
			_tmp17_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
			_tmp18_ = _tmp17_;
			_tmp19_ = vala_class_get_is_compact (_tmp18_);
			_tmp20_ = _tmp19_;
			_tmp14_ = !_tmp20_;
		} else {
			_tmp14_ = FALSE;
		}
		if (_tmp14_) {
			ValaClass* _tmp21_;
			ValaClass* _tmp22_;
			gboolean _tmp23_;
			gboolean _tmp24_;
			_tmp21_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
			_tmp22_ = _tmp21_;
			_tmp23_ = vala_class_get_is_abstract (_tmp22_);
			_tmp24_ = _tmp23_;
			_tmp13_ = !_tmp24_;
		} else {
			_tmp13_ = FALSE;
		}
		if (_tmp13_) {
			ValaCCodeFunction* vfunc = NULL;
			ValaCreationMethod* _tmp25_;
			gchar* _tmp26_;
			gchar* _tmp27_;
			ValaCCodeFunction* _tmp28_;
			ValaCCodeFunction* _tmp29_;
			ValaHashMap* cparam_map = NULL;
			GHashFunc _tmp30_;
			GEqualFunc _tmp31_;
			GEqualFunc _tmp32_;
			ValaHashMap* _tmp33_;
			ValaHashMap* carg_map = NULL;
			GHashFunc _tmp34_;
			GEqualFunc _tmp35_;
			GEqualFunc _tmp36_;
			ValaHashMap* _tmp37_;
			ValaCCodeFunction* _tmp38_;
			ValaCCodeFunctionCall* vcall = NULL;
			ValaCreationMethod* _tmp39_;
			gchar* _tmp40_;
			gchar* _tmp41_;
			ValaCCodeIdentifier* _tmp42_;
			ValaCCodeIdentifier* _tmp43_;
			ValaCCodeFunctionCall* _tmp44_;
			ValaCCodeFunctionCall* _tmp45_;
			ValaCCodeFunctionCall* _tmp46_;
			ValaClass* _tmp47_;
			ValaClass* _tmp48_;
			gchar* _tmp49_;
			gchar* _tmp50_;
			ValaCCodeIdentifier* _tmp51_;
			ValaCCodeIdentifier* _tmp52_;
			ValaCreationMethod* _tmp53_;
			ValaCCodeFile* _tmp54_;
			ValaHashMap* _tmp55_;
			ValaCCodeFunction* _tmp56_;
			ValaHashMap* _tmp57_;
			ValaCCodeFunctionCall* _tmp58_;
			ValaCCodeFunction* _tmp59_;
			ValaCCodeFunction* _tmp60_;
			ValaCCodeFunctionCall* _tmp61_;
			gboolean _tmp62_;
			ValaCCodeFile* _tmp67_;
			ValaCCodeFunction* _tmp68_;
			ValaCreationMethod* _tmp69_;
			gchar* _tmp70_;
			gchar* _tmp71_;
			ValaCCodeFunction* _tmp72_;
			GHashFunc _tmp73_;
			GEqualFunc _tmp74_;
			GEqualFunc _tmp75_;
			ValaHashMap* _tmp76_;
			GHashFunc _tmp77_;
			GEqualFunc _tmp78_;
			GEqualFunc _tmp79_;
			ValaHashMap* _tmp80_;
			ValaCCodeFunction* _tmp81_;
			ValaCreationMethod* _tmp82_;
			gchar* _tmp83_;
			gchar* _tmp84_;
			ValaCCodeIdentifier* _tmp85_;
			ValaCCodeIdentifier* _tmp86_;
			ValaCCodeFunctionCall* _tmp87_;
			ValaCreationMethod* _tmp88_;
			ValaCCodeFile* _tmp89_;
			ValaHashMap* _tmp90_;
			ValaCCodeFunction* _tmp91_;
			ValaHashMap* _tmp92_;
			ValaCCodeFunctionCall* _tmp93_;
			ValaCCodeFunction* _tmp94_;
			ValaCCodeFunction* _tmp95_;
			ValaCCodeFunctionCall* _tmp96_;
			gboolean _tmp97_;
			ValaCCodeFile* _tmp102_;
			ValaCCodeFunction* _tmp103_;
			_tmp25_ = m;
			_tmp26_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp25_);
			_tmp27_ = _tmp26_;
			_tmp28_ = vala_ccode_function_new (_tmp27_, "void");
			_tmp29_ = _tmp28_;
			_g_free0 (_tmp27_);
			vfunc = _tmp29_;
			_tmp30_ = g_direct_hash;
			_tmp31_ = g_direct_equal;
			_tmp32_ = g_direct_equal;
			_tmp33_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp30_, _tmp31_, _tmp32_);
			cparam_map = _tmp33_;
			_tmp34_ = g_direct_hash;
			_tmp35_ = g_direct_equal;
			_tmp36_ = g_direct_equal;
			_tmp37_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp34_, _tmp35_, _tmp36_);
			carg_map = _tmp37_;
			_tmp38_ = vfunc;
			vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp38_);
			_tmp39_ = m;
			_tmp40_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp39_);
			_tmp41_ = _tmp40_;
			_tmp42_ = vala_ccode_identifier_new (_tmp41_);
			_tmp43_ = _tmp42_;
			_tmp44_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp43_);
			_tmp45_ = _tmp44_;
			_vala_ccode_node_unref0 (_tmp43_);
			_g_free0 (_tmp41_);
			vcall = _tmp45_;
			_tmp46_ = vcall;
			_tmp47_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
			_tmp48_ = _tmp47_;
			_tmp49_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp48_);
			_tmp50_ = _tmp49_;
			_tmp51_ = vala_ccode_identifier_new (_tmp50_);
			_tmp52_ = _tmp51_;
			vala_ccode_function_call_add_argument (_tmp46_, (ValaCCodeExpression*) _tmp52_);
			_vala_ccode_node_unref0 (_tmp52_);
			_g_free0 (_tmp50_);
			_tmp53_ = m;
			_tmp54_ = ((ValaCCodeBaseModule*) self)->cfile;
			_tmp55_ = cparam_map;
			_tmp56_ = vfunc;
			_tmp57_ = carg_map;
			_tmp58_ = vcall;
			vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, (ValaMethod*) _tmp53_, _tmp54_, (ValaMap*) _tmp55_, _tmp56_, NULL, (ValaMap*) _tmp57_, _tmp58_, 1);
			_tmp59_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp60_ = _tmp59_;
			_tmp61_ = vcall;
			vala_ccode_function_add_expression (_tmp60_, (ValaCCodeExpression*) _tmp61_);
			_tmp62_ = visible;
			if (!_tmp62_) {
				ValaCCodeFunction* _tmp63_;
				ValaCCodeFunction* _tmp64_;
				ValaCCodeModifiers _tmp65_;
				ValaCCodeModifiers _tmp66_;
				_tmp63_ = vfunc;
				_tmp64_ = vfunc;
				_tmp65_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp64_);
				_tmp66_ = _tmp65_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp64_, _tmp66_ | VALA_CCODE_MODIFIERS_STATIC);
			}
			vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
			_tmp67_ = ((ValaCCodeBaseModule*) self)->cfile;
			_tmp68_ = vfunc;
			vala_ccode_file_add_function (_tmp67_, _tmp68_);
			_tmp69_ = m;
			_tmp70_ = vala_ccode_base_module_get_ccode_finish_name ((ValaMethod*) _tmp69_);
			_tmp71_ = _tmp70_;
			_tmp72_ = vala_ccode_function_new (_tmp71_, "void");
			_vala_ccode_node_unref0 (vfunc);
			vfunc = _tmp72_;
			_g_free0 (_tmp71_);
			_tmp73_ = g_direct_hash;
			_tmp74_ = g_direct_equal;
			_tmp75_ = g_direct_equal;
			_tmp76_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp73_, _tmp74_, _tmp75_);
			_vala_map_unref0 (cparam_map);
			cparam_map = _tmp76_;
			_tmp77_ = g_direct_hash;
			_tmp78_ = g_direct_equal;
			_tmp79_ = g_direct_equal;
			_tmp80_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp77_, _tmp78_, _tmp79_);
			_vala_map_unref0 (carg_map);
			carg_map = _tmp80_;
			_tmp81_ = vfunc;
			vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp81_);
			_tmp82_ = m;
			_tmp83_ = vala_ccode_base_module_get_ccode_finish_real_name ((ValaMethod*) _tmp82_);
			_tmp84_ = _tmp83_;
			_tmp85_ = vala_ccode_identifier_new (_tmp84_);
			_tmp86_ = _tmp85_;
			_tmp87_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp86_);
			_vala_ccode_node_unref0 (vcall);
			vcall = _tmp87_;
			_vala_ccode_node_unref0 (_tmp86_);
			_g_free0 (_tmp84_);
			_tmp88_ = m;
			_tmp89_ = ((ValaCCodeBaseModule*) self)->cfile;
			_tmp90_ = cparam_map;
			_tmp91_ = vfunc;
			_tmp92_ = carg_map;
			_tmp93_ = vcall;
			vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, (ValaMethod*) _tmp88_, _tmp89_, (ValaMap*) _tmp90_, _tmp91_, NULL, (ValaMap*) _tmp92_, _tmp93_, 2);
			_tmp94_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp95_ = _tmp94_;
			_tmp96_ = vcall;
			vala_ccode_function_add_return (_tmp95_, (ValaCCodeExpression*) _tmp96_);
			_tmp97_ = visible;
			if (!_tmp97_) {
				ValaCCodeFunction* _tmp98_;
				ValaCCodeFunction* _tmp99_;
				ValaCCodeModifiers _tmp100_;
				ValaCCodeModifiers _tmp101_;
				_tmp98_ = vfunc;
				_tmp99_ = vfunc;
				_tmp100_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp99_);
				_tmp101_ = _tmp100_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp99_, _tmp101_ | VALA_CCODE_MODIFIERS_STATIC);
			}
			vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
			_tmp102_ = ((ValaCCodeBaseModule*) self)->cfile;
			_tmp103_ = vfunc;
			vala_ccode_file_add_function (_tmp102_, _tmp103_);
			_vala_ccode_node_unref0 (vcall);
			_vala_map_unref0 (carg_map);
			_vala_map_unref0 (cparam_map);
			_vala_ccode_node_unref0 (vfunc);
		}
		vala_ccode_base_module_pop_line ((ValaCCodeBaseModule*) self);
	}
}


static void vala_gasync_module_generate_finish_function (ValaGAsyncModule* self, ValaMethod* m) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaCCodeBaseModuleEmitContext* _tmp1_;
	gchar* dataname = NULL;
	ValaMethod* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	ValaCCodeFunction* finishfunc = NULL;
	ValaMethod* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaCCodeFunction* _tmp13_;
	ValaHashMap* cparam_map = NULL;
	GHashFunc _tmp14_;
	GEqualFunc _tmp15_;
	GEqualFunc _tmp16_;
	ValaHashMap* _tmp17_;
	ValaHashMap* _tmp18_;
	gint _tmp19_;
	ValaCCodeParameter* _tmp20_;
	ValaCCodeParameter* _tmp21_;
	ValaMethod* _tmp22_;
	ValaCCodeFile* _tmp23_;
	ValaHashMap* _tmp24_;
	ValaCCodeFunction* _tmp25_;
	gboolean _tmp26_ = FALSE;
	gboolean _tmp27_ = FALSE;
	ValaMethod* _tmp28_;
	gboolean _tmp29_;
	ValaCCodeFunction* _tmp51_;
	ValaDataType* return_type = NULL;
	ValaMethod* _tmp52_;
	ValaDataType* _tmp53_;
	ValaDataType* _tmp54_;
	ValaDataType* _tmp55_;
	ValaMethod* _tmp56_;
	ValaCCodeIdentifier* data_var = NULL;
	ValaCCodeIdentifier* _tmp84_;
	ValaCCodeFunction* _tmp85_;
	ValaCCodeFunction* _tmp86_;
	const gchar* _tmp87_;
	gchar* _tmp88_;
	gchar* _tmp89_;
	ValaCCodeVariableDeclarator* _tmp90_;
	ValaCCodeVariableDeclarator* _tmp91_;
	ValaCodeContext* _tmp92_;
	ValaCodeContext* _tmp93_;
	gboolean _tmp94_;
	ValaCCodeBaseModuleEmitContext* _tmp203_;
	ValaMethod* _tmp204_;
	ValaCCodeBaseModuleEmitContext* _tmp241_;
	ValaMethod* _tmp242_;
	ValaCCodeFile* _tmp352_;
	ValaCCodeFunction* _tmp353_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (m != NULL);
	_tmp0_ = vala_ccode_base_module_emit_context_new (NULL);
	_tmp1_ = _tmp0_;
	vala_ccode_base_module_push_context ((ValaCCodeBaseModule*) self, _tmp1_);
	_vala_ccode_base_module_emit_context_unref0 (_tmp1_);
	_tmp2_ = m;
	_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_symbol_lower_case_to_camel_case (_tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = g_strconcat (_tmp6_, "Data", NULL);
	_tmp8_ = _tmp7_;
	_g_free0 (_tmp6_);
	_g_free0 (_tmp4_);
	dataname = _tmp8_;
	_tmp9_ = m;
	_tmp10_ = vala_ccode_base_module_get_ccode_finish_real_name (_tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = vala_ccode_function_new (_tmp11_, "void");
	_tmp13_ = _tmp12_;
	_g_free0 (_tmp11_);
	finishfunc = _tmp13_;
	_tmp14_ = g_direct_hash;
	_tmp15_ = g_direct_equal;
	_tmp16_ = g_direct_equal;
	_tmp17_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp14_, _tmp15_, _tmp16_);
	cparam_map = _tmp17_;
	_tmp18_ = cparam_map;
	_tmp19_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, 0.1, FALSE);
	_tmp20_ = vala_ccode_parameter_new ("_res_", "GAsyncResult*");
	_tmp21_ = _tmp20_;
	vala_map_set ((ValaMap*) _tmp18_, (gpointer) ((gintptr) _tmp19_), _tmp21_);
	_vala_ccode_node_unref0 (_tmp21_);
	_tmp22_ = m;
	_tmp23_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp24_ = cparam_map;
	_tmp25_ = finishfunc;
	vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp22_, _tmp23_, (ValaMap*) _tmp24_, _tmp25_, NULL, NULL, NULL, 2);
	_tmp28_ = m;
	_tmp29_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp28_);
	if (_tmp29_) {
		_tmp27_ = TRUE;
	} else {
		ValaMethod* _tmp30_;
		ValaMethod* _tmp31_;
		ValaMethod* _tmp32_;
		_tmp30_ = m;
		_tmp31_ = vala_method_get_base_method (_tmp30_);
		_tmp32_ = _tmp31_;
		_tmp27_ = _tmp32_ != NULL;
	}
	if (_tmp27_) {
		_tmp26_ = TRUE;
	} else {
		ValaMethod* _tmp33_;
		ValaMethod* _tmp34_;
		ValaMethod* _tmp35_;
		_tmp33_ = m;
		_tmp34_ = vala_method_get_base_interface_method (_tmp33_);
		_tmp35_ = _tmp34_;
		_tmp26_ = _tmp35_ != NULL;
	}
	if (_tmp26_) {
		ValaCCodeFunction* _tmp36_;
		ValaCCodeFunction* _tmp37_;
		ValaCCodeModifiers _tmp38_;
		ValaCCodeModifiers _tmp39_;
		_tmp36_ = finishfunc;
		_tmp37_ = finishfunc;
		_tmp38_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp37_);
		_tmp39_ = _tmp38_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp37_, _tmp39_ | VALA_CCODE_MODIFIERS_STATIC);
	} else {
		gboolean _tmp40_ = FALSE;
		ValaCodeContext* _tmp41_;
		ValaCodeContext* _tmp42_;
		gboolean _tmp43_;
		gboolean _tmp44_;
		_tmp41_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp42_ = _tmp41_;
		_tmp43_ = vala_code_context_get_hide_internal (_tmp42_);
		_tmp44_ = _tmp43_;
		if (_tmp44_) {
			ValaMethod* _tmp45_;
			gboolean _tmp46_;
			_tmp45_ = m;
			_tmp46_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp45_);
			_tmp40_ = _tmp46_;
		} else {
			_tmp40_ = FALSE;
		}
		if (_tmp40_) {
			ValaCCodeFunction* _tmp47_;
			ValaCCodeFunction* _tmp48_;
			ValaCCodeModifiers _tmp49_;
			ValaCCodeModifiers _tmp50_;
			_tmp47_ = finishfunc;
			_tmp48_ = finishfunc;
			_tmp49_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp48_);
			_tmp50_ = _tmp49_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp48_, _tmp50_ | VALA_CCODE_MODIFIERS_INTERNAL);
		}
	}
	_tmp51_ = finishfunc;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp51_);
	_tmp52_ = m;
	_tmp53_ = vala_callable_get_return_type ((ValaCallable*) _tmp52_);
	_tmp54_ = _tmp53_;
	_tmp55_ = _vala_code_node_ref0 (_tmp54_);
	return_type = _tmp55_;
	_tmp56_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp56_, VALA_TYPE_CREATION_METHOD)) {
		ValaTypeSymbol* type_sym = NULL;
		ValaMethod* _tmp57_;
		ValaSymbol* _tmp58_;
		ValaSymbol* _tmp59_;
		ValaTypeSymbol* _tmp60_;
		ValaTypeSymbol* _tmp61_;
		_tmp57_ = m;
		_tmp58_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp57_);
		_tmp59_ = _tmp58_;
		_tmp60_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp59_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
		type_sym = _tmp60_;
		_tmp61_ = type_sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp61_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) {
			ValaCCodeFunction* _tmp62_;
			ValaCCodeFunction* _tmp63_;
			ValaTypeSymbol* _tmp64_;
			gchar* _tmp65_;
			gchar* _tmp66_;
			gchar* _tmp67_;
			gchar* _tmp68_;
			ValaCCodeVariableDeclarator* _tmp69_;
			ValaCCodeVariableDeclarator* _tmp70_;
			_tmp62_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp63_ = _tmp62_;
			_tmp64_ = type_sym;
			_tmp65_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp64_);
			_tmp66_ = _tmp65_;
			_tmp67_ = g_strconcat (_tmp66_, "*", NULL);
			_tmp68_ = _tmp67_;
			_tmp69_ = vala_ccode_variable_declarator_new ("result", NULL, NULL);
			_tmp70_ = _tmp69_;
			vala_ccode_function_add_declaration (_tmp63_, _tmp68_, (ValaCCodeDeclarator*) _tmp70_, 0);
			_vala_ccode_node_unref0 (_tmp70_);
			_g_free0 (_tmp68_);
			_g_free0 (_tmp66_);
		}
		_vala_code_node_unref0 (type_sym);
	} else {
		gboolean _tmp71_ = FALSE;
		ValaDataType* _tmp72_;
		_tmp72_ = return_type;
		if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp72_, VALA_TYPE_VOID_TYPE)) {
			ValaDataType* _tmp73_;
			gboolean _tmp74_;
			_tmp73_ = return_type;
			_tmp74_ = vala_data_type_is_real_non_null_struct_type (_tmp73_);
			_tmp71_ = !_tmp74_;
		} else {
			_tmp71_ = FALSE;
		}
		if (_tmp71_) {
			ValaCCodeFunction* _tmp75_;
			ValaCCodeFunction* _tmp76_;
			ValaMethod* _tmp77_;
			ValaDataType* _tmp78_;
			ValaDataType* _tmp79_;
			gchar* _tmp80_;
			gchar* _tmp81_;
			ValaCCodeVariableDeclarator* _tmp82_;
			ValaCCodeVariableDeclarator* _tmp83_;
			_tmp75_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp76_ = _tmp75_;
			_tmp77_ = m;
			_tmp78_ = vala_callable_get_return_type ((ValaCallable*) _tmp77_);
			_tmp79_ = _tmp78_;
			_tmp80_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp79_);
			_tmp81_ = _tmp80_;
			_tmp82_ = vala_ccode_variable_declarator_new ("result", NULL, NULL);
			_tmp83_ = _tmp82_;
			vala_ccode_function_add_declaration (_tmp76_, _tmp81_, (ValaCCodeDeclarator*) _tmp83_, 0);
			_vala_ccode_node_unref0 (_tmp83_);
			_g_free0 (_tmp81_);
		}
	}
	_tmp84_ = vala_ccode_identifier_new ("_data_");
	data_var = _tmp84_;
	_tmp85_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp86_ = _tmp85_;
	_tmp87_ = dataname;
	_tmp88_ = g_strconcat (_tmp87_, "*", NULL);
	_tmp89_ = _tmp88_;
	_tmp90_ = vala_ccode_variable_declarator_new ("_data_", NULL, NULL);
	_tmp91_ = _tmp90_;
	vala_ccode_function_add_declaration (_tmp86_, _tmp89_, (ValaCCodeDeclarator*) _tmp91_, 0);
	_vala_ccode_node_unref0 (_tmp91_);
	_g_free0 (_tmp89_);
	_tmp92_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp93_ = _tmp92_;
	_tmp94_ = vala_code_context_require_glib_version (_tmp93_, 2, 36);
	if (_tmp94_) {
		ValaCCodeFunctionCall* async_result_cast = NULL;
		ValaCCodeIdentifier* _tmp95_;
		ValaCCodeIdentifier* _tmp96_;
		ValaCCodeFunctionCall* _tmp97_;
		ValaCCodeFunctionCall* _tmp98_;
		ValaCCodeFunctionCall* _tmp99_;
		ValaCCodeIdentifier* _tmp100_;
		ValaCCodeIdentifier* _tmp101_;
		ValaCCodeFunctionCall* ccall = NULL;
		ValaCCodeIdentifier* _tmp102_;
		ValaCCodeIdentifier* _tmp103_;
		ValaCCodeFunctionCall* _tmp104_;
		ValaCCodeFunctionCall* _tmp105_;
		ValaCCodeFunctionCall* _tmp106_;
		ValaCCodeFunctionCall* _tmp107_;
		ValaMethod* _tmp108_;
		ValaList* _tmp109_;
		ValaList* _tmp110_;
		gint _tmp111_;
		gint _tmp112_;
		gboolean _tmp113_;
		ValaCCodeFunction* _tmp120_;
		ValaCCodeFunction* _tmp121_;
		ValaCCodeIdentifier* _tmp122_;
		ValaCCodeFunctionCall* _tmp123_;
		gboolean has_cancellable = FALSE;
		gboolean _tmp146_ = FALSE;
		ValaMethod* _tmp147_;
		ValaList* _tmp148_;
		ValaList* _tmp149_;
		gint _tmp150_;
		gint _tmp151_;
		gboolean _tmp152_;
		_tmp95_ = vala_ccode_identifier_new ("G_TASK");
		_tmp96_ = _tmp95_;
		_tmp97_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp96_);
		_tmp98_ = _tmp97_;
		_vala_ccode_node_unref0 (_tmp96_);
		async_result_cast = _tmp98_;
		_tmp99_ = async_result_cast;
		_tmp100_ = vala_ccode_identifier_new ("_res_");
		_tmp101_ = _tmp100_;
		vala_ccode_function_call_add_argument (_tmp99_, (ValaCCodeExpression*) _tmp101_);
		_vala_ccode_node_unref0 (_tmp101_);
		_tmp102_ = vala_ccode_identifier_new ("g_task_propagate_pointer");
		_tmp103_ = _tmp102_;
		_tmp104_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp103_);
		_tmp105_ = _tmp104_;
		_vala_ccode_node_unref0 (_tmp103_);
		ccall = _tmp105_;
		_tmp106_ = ccall;
		_tmp107_ = async_result_cast;
		vala_ccode_function_call_add_argument (_tmp106_, (ValaCCodeExpression*) _tmp107_);
		_tmp108_ = m;
		_tmp109_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp108_);
		_tmp110_ = _tmp109_;
		_tmp111_ = vala_collection_get_size ((ValaCollection*) _tmp110_);
		_tmp112_ = _tmp111_;
		_tmp113_ = _tmp112_ > 0;
		_vala_iterable_unref0 (_tmp110_);
		if (_tmp113_) {
			ValaCCodeFunctionCall* _tmp114_;
			ValaCCodeIdentifier* _tmp115_;
			ValaCCodeIdentifier* _tmp116_;
			_tmp114_ = ccall;
			_tmp115_ = vala_ccode_identifier_new ("error");
			_tmp116_ = _tmp115_;
			vala_ccode_function_call_add_argument (_tmp114_, (ValaCCodeExpression*) _tmp116_);
			_vala_ccode_node_unref0 (_tmp116_);
		} else {
			ValaCCodeFunctionCall* _tmp117_;
			ValaCCodeConstant* _tmp118_;
			ValaCCodeConstant* _tmp119_;
			_tmp117_ = ccall;
			_tmp118_ = vala_ccode_constant_new ("NULL");
			_tmp119_ = _tmp118_;
			vala_ccode_function_call_add_argument (_tmp117_, (ValaCCodeExpression*) _tmp119_);
			_vala_ccode_node_unref0 (_tmp119_);
		}
		_tmp120_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp121_ = _tmp120_;
		_tmp122_ = data_var;
		_tmp123_ = ccall;
		vala_ccode_function_add_assignment (_tmp121_, (ValaCCodeExpression*) _tmp122_, (ValaCCodeExpression*) _tmp123_);
		has_cancellable = FALSE;
		{
			ValaList* _param_list = NULL;
			ValaMethod* _tmp124_;
			ValaList* _tmp125_;
			gint _param_size = 0;
			ValaList* _tmp126_;
			gint _tmp127_;
			gint _tmp128_;
			gint _param_index = 0;
			_tmp124_ = m;
			_tmp125_ = vala_callable_get_parameters ((ValaCallable*) _tmp124_);
			_param_list = _tmp125_;
			_tmp126_ = _param_list;
			_tmp127_ = vala_collection_get_size ((ValaCollection*) _tmp126_);
			_tmp128_ = _tmp127_;
			_param_size = _tmp128_;
			_param_index = -1;
			while (TRUE) {
				gint _tmp129_;
				gint _tmp130_;
				gint _tmp131_;
				ValaParameter* param = NULL;
				ValaList* _tmp132_;
				gint _tmp133_;
				gpointer _tmp134_;
				gboolean _tmp135_ = FALSE;
				ValaParameter* _tmp136_;
				ValaDataType* _tmp137_;
				ValaDataType* _tmp138_;
				_tmp129_ = _param_index;
				_param_index = _tmp129_ + 1;
				_tmp130_ = _param_index;
				_tmp131_ = _param_size;
				if (!(_tmp130_ < _tmp131_)) {
					break;
				}
				_tmp132_ = _param_list;
				_tmp133_ = _param_index;
				_tmp134_ = vala_list_get (_tmp132_, _tmp133_);
				param = (ValaParameter*) _tmp134_;
				_tmp136_ = param;
				_tmp137_ = vala_variable_get_variable_type ((ValaVariable*) _tmp136_);
				_tmp138_ = _tmp137_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp138_, VALA_TYPE_OBJECT_TYPE)) {
					ValaParameter* _tmp139_;
					ValaDataType* _tmp140_;
					ValaDataType* _tmp141_;
					ValaTypeSymbol* _tmp142_;
					ValaTypeSymbol* _tmp143_;
					gchar* _tmp144_;
					gchar* _tmp145_;
					_tmp139_ = param;
					_tmp140_ = vala_variable_get_variable_type ((ValaVariable*) _tmp139_);
					_tmp141_ = _tmp140_;
					_tmp142_ = vala_data_type_get_data_type (_tmp141_);
					_tmp143_ = _tmp142_;
					_tmp144_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp143_);
					_tmp145_ = _tmp144_;
					_tmp135_ = g_strcmp0 (_tmp145_, "GLib.Cancellable") == 0;
					_g_free0 (_tmp145_);
				} else {
					_tmp135_ = FALSE;
				}
				if (_tmp135_) {
					has_cancellable = TRUE;
					_vala_code_node_unref0 (param);
					break;
				}
				_vala_code_node_unref0 (param);
			}
			_vala_iterable_unref0 (_param_list);
		}
		_tmp147_ = m;
		_tmp148_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp147_);
		_tmp149_ = _tmp148_;
		_tmp150_ = vala_collection_get_size ((ValaCollection*) _tmp149_);
		_tmp151_ = _tmp150_;
		_tmp152_ = _tmp151_ > 0;
		_vala_iterable_unref0 (_tmp149_);
		if (_tmp152_) {
			_tmp146_ = TRUE;
		} else {
			gboolean _tmp153_;
			_tmp153_ = has_cancellable;
			_tmp146_ = _tmp153_;
		}
		if (_tmp146_) {
			ValaCCodeBinaryExpression* is_null = NULL;
			ValaCCodeConstant* _tmp154_;
			ValaCCodeConstant* _tmp155_;
			ValaCCodeIdentifier* _tmp156_;
			ValaCCodeBinaryExpression* _tmp157_;
			ValaCCodeBinaryExpression* _tmp158_;
			ValaCCodeFunction* _tmp159_;
			ValaCCodeFunction* _tmp160_;
			ValaCCodeBinaryExpression* _tmp161_;
			ValaDataType* _tmp162_;
			ValaCCodeFunction* _tmp163_;
			ValaCCodeFunction* _tmp164_;
			_tmp154_ = vala_ccode_constant_new ("NULL");
			_tmp155_ = _tmp154_;
			_tmp156_ = data_var;
			_tmp157_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp155_, (ValaCCodeExpression*) _tmp156_);
			_tmp158_ = _tmp157_;
			_vala_ccode_node_unref0 (_tmp155_);
			is_null = _tmp158_;
			_tmp159_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp160_ = _tmp159_;
			_tmp161_ = is_null;
			vala_ccode_function_open_if (_tmp160_, (ValaCCodeExpression*) _tmp161_);
			_tmp162_ = return_type;
			vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp162_);
			_tmp163_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp164_ = _tmp163_;
			vala_ccode_function_close (_tmp164_);
			_vala_ccode_node_unref0 (is_null);
		}
		_vala_ccode_node_unref0 (ccall);
		_vala_ccode_node_unref0 (async_result_cast);
	} else {
		ValaCCodeFunctionCall* simple_async_result_cast = NULL;
		ValaCCodeIdentifier* _tmp165_;
		ValaCCodeIdentifier* _tmp166_;
		ValaCCodeFunctionCall* _tmp167_;
		ValaCCodeFunctionCall* _tmp168_;
		ValaCCodeFunctionCall* _tmp169_;
		ValaCCodeIdentifier* _tmp170_;
		ValaCCodeIdentifier* _tmp171_;
		ValaMethod* _tmp172_;
		ValaList* _tmp173_;
		ValaList* _tmp174_;
		gint _tmp175_;
		gint _tmp176_;
		gboolean _tmp177_;
		ValaCCodeFunctionCall* ccall = NULL;
		ValaCCodeIdentifier* _tmp193_;
		ValaCCodeIdentifier* _tmp194_;
		ValaCCodeFunctionCall* _tmp195_;
		ValaCCodeFunctionCall* _tmp196_;
		ValaCCodeFunctionCall* _tmp197_;
		ValaCCodeFunctionCall* _tmp198_;
		ValaCCodeFunction* _tmp199_;
		ValaCCodeFunction* _tmp200_;
		ValaCCodeIdentifier* _tmp201_;
		ValaCCodeFunctionCall* _tmp202_;
		_tmp165_ = vala_ccode_identifier_new ("G_SIMPLE_ASYNC_RESULT");
		_tmp166_ = _tmp165_;
		_tmp167_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp166_);
		_tmp168_ = _tmp167_;
		_vala_ccode_node_unref0 (_tmp166_);
		simple_async_result_cast = _tmp168_;
		_tmp169_ = simple_async_result_cast;
		_tmp170_ = vala_ccode_identifier_new ("_res_");
		_tmp171_ = _tmp170_;
		vala_ccode_function_call_add_argument (_tmp169_, (ValaCCodeExpression*) _tmp171_);
		_vala_ccode_node_unref0 (_tmp171_);
		_tmp172_ = m;
		_tmp173_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp172_);
		_tmp174_ = _tmp173_;
		_tmp175_ = vala_collection_get_size ((ValaCollection*) _tmp174_);
		_tmp176_ = _tmp175_;
		_tmp177_ = _tmp176_ > 0;
		_vala_iterable_unref0 (_tmp174_);
		if (_tmp177_) {
			ValaCCodeFunctionCall* propagate_error = NULL;
			ValaCCodeIdentifier* _tmp178_;
			ValaCCodeIdentifier* _tmp179_;
			ValaCCodeFunctionCall* _tmp180_;
			ValaCCodeFunctionCall* _tmp181_;
			ValaCCodeFunctionCall* _tmp182_;
			ValaCCodeFunctionCall* _tmp183_;
			ValaCCodeFunctionCall* _tmp184_;
			ValaCCodeIdentifier* _tmp185_;
			ValaCCodeIdentifier* _tmp186_;
			ValaCCodeFunction* _tmp187_;
			ValaCCodeFunction* _tmp188_;
			ValaCCodeFunctionCall* _tmp189_;
			ValaDataType* _tmp190_;
			ValaCCodeFunction* _tmp191_;
			ValaCCodeFunction* _tmp192_;
			_tmp178_ = vala_ccode_identifier_new ("g_simple_async_result_propagate_error");
			_tmp179_ = _tmp178_;
			_tmp180_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp179_);
			_tmp181_ = _tmp180_;
			_vala_ccode_node_unref0 (_tmp179_);
			propagate_error = _tmp181_;
			_tmp182_ = propagate_error;
			_tmp183_ = simple_async_result_cast;
			vala_ccode_function_call_add_argument (_tmp182_, (ValaCCodeExpression*) _tmp183_);
			_tmp184_ = propagate_error;
			_tmp185_ = vala_ccode_identifier_new ("error");
			_tmp186_ = _tmp185_;
			vala_ccode_function_call_add_argument (_tmp184_, (ValaCCodeExpression*) _tmp186_);
			_vala_ccode_node_unref0 (_tmp186_);
			_tmp187_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp188_ = _tmp187_;
			_tmp189_ = propagate_error;
			vala_ccode_function_open_if (_tmp188_, (ValaCCodeExpression*) _tmp189_);
			_tmp190_ = return_type;
			vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp190_);
			_tmp191_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp192_ = _tmp191_;
			vala_ccode_function_close (_tmp192_);
			_vala_ccode_node_unref0 (propagate_error);
		}
		_tmp193_ = vala_ccode_identifier_new ("g_simple_async_result_get_op_res_gpointer");
		_tmp194_ = _tmp193_;
		_tmp195_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp194_);
		_tmp196_ = _tmp195_;
		_vala_ccode_node_unref0 (_tmp194_);
		ccall = _tmp196_;
		_tmp197_ = ccall;
		_tmp198_ = simple_async_result_cast;
		vala_ccode_function_call_add_argument (_tmp197_, (ValaCCodeExpression*) _tmp198_);
		_tmp199_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp200_ = _tmp199_;
		_tmp201_ = data_var;
		_tmp202_ = ccall;
		vala_ccode_function_add_assignment (_tmp200_, (ValaCCodeExpression*) _tmp201_, (ValaCCodeExpression*) _tmp202_);
		_vala_ccode_node_unref0 (ccall);
		_vala_ccode_node_unref0 (simple_async_result_cast);
	}
	_tmp203_ = ((ValaCCodeBaseModule*) self)->emit_context;
	_tmp204_ = m;
	vala_ccode_base_module_emit_context_push_symbol (_tmp203_, (ValaSymbol*) _tmp204_);
	{
		ValaList* _param_list = NULL;
		ValaMethod* _tmp205_;
		ValaList* _tmp206_;
		gint _param_size = 0;
		ValaList* _tmp207_;
		gint _tmp208_;
		gint _tmp209_;
		gint _param_index = 0;
		_tmp205_ = m;
		_tmp206_ = vala_callable_get_parameters ((ValaCallable*) _tmp205_);
		_param_list = _tmp206_;
		_tmp207_ = _param_list;
		_tmp208_ = vala_collection_get_size ((ValaCollection*) _tmp207_);
		_tmp209_ = _tmp208_;
		_param_size = _tmp209_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp210_;
			gint _tmp211_;
			gint _tmp212_;
			ValaParameter* param = NULL;
			ValaList* _tmp213_;
			gint _tmp214_;
			gpointer _tmp215_;
			ValaParameter* _tmp216_;
			ValaParameterDirection _tmp217_;
			ValaParameterDirection _tmp218_;
			_tmp210_ = _param_index;
			_param_index = _tmp210_ + 1;
			_tmp211_ = _param_index;
			_tmp212_ = _param_size;
			if (!(_tmp211_ < _tmp212_)) {
				break;
			}
			_tmp213_ = _param_list;
			_tmp214_ = _param_index;
			_tmp215_ = vala_list_get (_tmp213_, _tmp214_);
			param = (ValaParameter*) _tmp215_;
			_tmp216_ = param;
			_tmp217_ = vala_parameter_get_direction (_tmp216_);
			_tmp218_ = _tmp217_;
			if (_tmp218_ != VALA_PARAMETER_DIRECTION_IN) {
				ValaParameter* _tmp219_;
				gboolean _tmp220_ = FALSE;
				ValaParameter* _tmp221_;
				ValaDataType* _tmp222_;
				ValaDataType* _tmp223_;
				_tmp219_ = param;
				vala_ccode_base_module_return_out_parameter ((ValaCCodeBaseModule*) self, _tmp219_);
				_tmp221_ = param;
				_tmp222_ = vala_variable_get_variable_type ((ValaVariable*) _tmp221_);
				_tmp223_ = _tmp222_;
				if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp223_, VALA_TYPE_VALUE_TYPE)) {
					_tmp220_ = TRUE;
				} else {
					ValaParameter* _tmp224_;
					ValaDataType* _tmp225_;
					ValaDataType* _tmp226_;
					gboolean _tmp227_;
					gboolean _tmp228_;
					_tmp224_ = param;
					_tmp225_ = vala_variable_get_variable_type ((ValaVariable*) _tmp224_);
					_tmp226_ = _tmp225_;
					_tmp227_ = vala_data_type_get_nullable (_tmp226_);
					_tmp228_ = _tmp227_;
					_tmp220_ = _tmp228_;
				}
				if (_tmp220_) {
					ValaCCodeFunction* _tmp229_;
					ValaCCodeFunction* _tmp230_;
					ValaCCodeIdentifier* _tmp231_;
					ValaParameter* _tmp232_;
					const gchar* _tmp233_;
					const gchar* _tmp234_;
					gchar* _tmp235_;
					gchar* _tmp236_;
					ValaCCodeMemberAccess* _tmp237_;
					ValaCCodeMemberAccess* _tmp238_;
					ValaCCodeConstant* _tmp239_;
					ValaCCodeConstant* _tmp240_;
					_tmp229_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp230_ = _tmp229_;
					_tmp231_ = data_var;
					_tmp232_ = param;
					_tmp233_ = vala_symbol_get_name ((ValaSymbol*) _tmp232_);
					_tmp234_ = _tmp233_;
					_tmp235_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp234_);
					_tmp236_ = _tmp235_;
					_tmp237_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp231_, _tmp236_);
					_tmp238_ = _tmp237_;
					_tmp239_ = vala_ccode_constant_new ("NULL");
					_tmp240_ = _tmp239_;
					vala_ccode_function_add_assignment (_tmp230_, (ValaCCodeExpression*) _tmp238_, (ValaCCodeExpression*) _tmp240_);
					_vala_ccode_node_unref0 (_tmp240_);
					_vala_ccode_node_unref0 (_tmp238_);
					_g_free0 (_tmp236_);
				}
			}
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
	_tmp241_ = ((ValaCCodeBaseModule*) self)->emit_context;
	vala_ccode_base_module_emit_context_pop_symbol (_tmp241_);
	_tmp242_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp242_, VALA_TYPE_CREATION_METHOD)) {
		ValaCCodeFunction* _tmp243_;
		ValaCCodeFunction* _tmp244_;
		ValaCCodeIdentifier* _tmp245_;
		ValaCCodeIdentifier* _tmp246_;
		ValaCCodeIdentifier* _tmp247_;
		ValaCCodeMemberAccess* _tmp248_;
		ValaCCodeMemberAccess* _tmp249_;
		ValaCCodeFunction* _tmp250_;
		ValaCCodeFunction* _tmp251_;
		ValaCCodeIdentifier* _tmp252_;
		ValaCCodeMemberAccess* _tmp253_;
		ValaCCodeMemberAccess* _tmp254_;
		ValaCCodeConstant* _tmp255_;
		ValaCCodeConstant* _tmp256_;
		ValaCCodeFunction* _tmp257_;
		ValaCCodeFunction* _tmp258_;
		ValaCCodeIdentifier* _tmp259_;
		ValaCCodeIdentifier* _tmp260_;
		_tmp243_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp244_ = _tmp243_;
		_tmp245_ = vala_ccode_identifier_new ("result");
		_tmp246_ = _tmp245_;
		_tmp247_ = data_var;
		_tmp248_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp247_, "self");
		_tmp249_ = _tmp248_;
		vala_ccode_function_add_assignment (_tmp244_, (ValaCCodeExpression*) _tmp246_, (ValaCCodeExpression*) _tmp249_);
		_vala_ccode_node_unref0 (_tmp249_);
		_vala_ccode_node_unref0 (_tmp246_);
		_tmp250_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp251_ = _tmp250_;
		_tmp252_ = data_var;
		_tmp253_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp252_, "self");
		_tmp254_ = _tmp253_;
		_tmp255_ = vala_ccode_constant_new ("NULL");
		_tmp256_ = _tmp255_;
		vala_ccode_function_add_assignment (_tmp251_, (ValaCCodeExpression*) _tmp254_, (ValaCCodeExpression*) _tmp256_);
		_vala_ccode_node_unref0 (_tmp256_);
		_vala_ccode_node_unref0 (_tmp254_);
		_tmp257_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp258_ = _tmp257_;
		_tmp259_ = vala_ccode_identifier_new ("result");
		_tmp260_ = _tmp259_;
		vala_ccode_function_add_return (_tmp258_, (ValaCCodeExpression*) _tmp260_);
		_vala_ccode_node_unref0 (_tmp260_);
	} else {
		ValaDataType* _tmp261_;
		gboolean _tmp262_;
		_tmp261_ = return_type;
		_tmp262_ = vala_data_type_is_real_non_null_struct_type (_tmp261_);
		if (_tmp262_) {
			ValaCCodeExpression* cexpr = NULL;
			ValaCCodeIdentifier* _tmp263_;
			ValaCCodeMemberAccess* _tmp264_;
			ValaDataType* _tmp265_;
			gboolean _tmp266_;
			ValaCCodeFunction* _tmp275_;
			ValaCCodeFunction* _tmp276_;
			ValaCCodeIdentifier* _tmp277_;
			ValaCCodeIdentifier* _tmp278_;
			ValaCCodeUnaryExpression* _tmp279_;
			ValaCCodeUnaryExpression* _tmp280_;
			ValaCCodeExpression* _tmp281_;
			_tmp263_ = data_var;
			_tmp264_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp263_, "result");
			cexpr = (ValaCCodeExpression*) _tmp264_;
			_tmp265_ = return_type;
			_tmp266_ = vala_ccode_base_module_requires_copy ((ValaCCodeBaseModule*) self, _tmp265_);
			if (_tmp266_) {
				ValaDataType* _tmp267_;
				ValaCCodeExpression* _tmp268_;
				ValaGLibValue* _tmp269_;
				ValaGLibValue* _tmp270_;
				ValaDataType* _tmp271_;
				ValaTargetValue* _tmp272_;
				ValaTargetValue* _tmp273_;
				ValaCCodeExpression* _tmp274_;
				_tmp267_ = return_type;
				_tmp268_ = cexpr;
				_tmp269_ = vala_glib_value_new (_tmp267_, _tmp268_, TRUE);
				_tmp270_ = _tmp269_;
				_tmp271_ = return_type;
				_tmp272_ = vala_ccode_base_module_copy_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp270_, (ValaCodeNode*) _tmp271_);
				_tmp273_ = _tmp272_;
				_tmp274_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp273_);
				_vala_ccode_node_unref0 (cexpr);
				cexpr = _tmp274_;
				_vala_target_value_unref0 (_tmp273_);
				_vala_target_value_unref0 (_tmp270_);
			}
			_tmp275_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp276_ = _tmp275_;
			_tmp277_ = vala_ccode_identifier_new ("result");
			_tmp278_ = _tmp277_;
			_tmp279_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp278_);
			_tmp280_ = _tmp279_;
			_tmp281_ = cexpr;
			vala_ccode_function_add_assignment (_tmp276_, (ValaCCodeExpression*) _tmp280_, _tmp281_);
			_vala_ccode_node_unref0 (_tmp280_);
			_vala_ccode_node_unref0 (_tmp278_);
			_vala_ccode_node_unref0 (cexpr);
		} else {
			ValaDataType* _tmp282_;
			_tmp282_ = return_type;
			if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp282_, VALA_TYPE_VOID_TYPE)) {
				ValaCCodeFunction* _tmp283_;
				ValaCCodeFunction* _tmp284_;
				ValaCCodeIdentifier* _tmp285_;
				ValaCCodeIdentifier* _tmp286_;
				ValaCCodeIdentifier* _tmp287_;
				ValaCCodeMemberAccess* _tmp288_;
				ValaCCodeMemberAccess* _tmp289_;
				ValaDataType* _tmp290_;
				gboolean _tmp336_ = FALSE;
				ValaDataType* _tmp337_;
				ValaCCodeFunction* _tmp348_;
				ValaCCodeFunction* _tmp349_;
				ValaCCodeIdentifier* _tmp350_;
				ValaCCodeIdentifier* _tmp351_;
				_tmp283_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp284_ = _tmp283_;
				_tmp285_ = vala_ccode_identifier_new ("result");
				_tmp286_ = _tmp285_;
				_tmp287_ = data_var;
				_tmp288_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp287_, "result");
				_tmp289_ = _tmp288_;
				vala_ccode_function_add_assignment (_tmp284_, (ValaCCodeExpression*) _tmp286_, (ValaCCodeExpression*) _tmp289_);
				_vala_ccode_node_unref0 (_tmp289_);
				_vala_ccode_node_unref0 (_tmp286_);
				_tmp290_ = return_type;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp290_, VALA_TYPE_ARRAY_TYPE)) {
					ValaArrayType* array_type = NULL;
					ValaDataType* _tmp291_;
					ValaArrayType* _tmp292_;
					ValaMethod* _tmp293_;
					gboolean _tmp294_;
					_tmp291_ = return_type;
					_tmp292_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp291_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
					array_type = _tmp292_;
					_tmp293_ = m;
					_tmp294_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp293_);
					if (_tmp294_) {
						{
							gint dim = 0;
							dim = 1;
							{
								gboolean _tmp295_ = FALSE;
								_tmp295_ = TRUE;
								while (TRUE) {
									gint _tmp297_;
									ValaArrayType* _tmp298_;
									gint _tmp299_;
									gint _tmp300_;
									ValaCCodeFunction* _tmp301_;
									ValaCCodeFunction* _tmp302_;
									gint _tmp303_;
									gchar* _tmp304_;
									gchar* _tmp305_;
									ValaCCodeIdentifier* _tmp306_;
									ValaCCodeIdentifier* _tmp307_;
									ValaCCodeUnaryExpression* _tmp308_;
									ValaCCodeUnaryExpression* _tmp309_;
									ValaCCodeIdentifier* _tmp310_;
									gint _tmp311_;
									gchar* _tmp312_;
									gchar* _tmp313_;
									ValaCCodeMemberAccess* _tmp314_;
									ValaCCodeMemberAccess* _tmp315_;
									if (!_tmp295_) {
										gint _tmp296_;
										_tmp296_ = dim;
										dim = _tmp296_ + 1;
									}
									_tmp295_ = FALSE;
									_tmp297_ = dim;
									_tmp298_ = array_type;
									_tmp299_ = vala_array_type_get_rank (_tmp298_);
									_tmp300_ = _tmp299_;
									if (!(_tmp297_ <= _tmp300_)) {
										break;
									}
									_tmp301_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
									_tmp302_ = _tmp301_;
									_tmp303_ = dim;
									_tmp304_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", _tmp303_);
									_tmp305_ = _tmp304_;
									_tmp306_ = vala_ccode_identifier_new (_tmp305_);
									_tmp307_ = _tmp306_;
									_tmp308_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp307_);
									_tmp309_ = _tmp308_;
									_tmp310_ = data_var;
									_tmp311_ = dim;
									_tmp312_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", _tmp311_);
									_tmp313_ = _tmp312_;
									_tmp314_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp310_, _tmp313_);
									_tmp315_ = _tmp314_;
									vala_ccode_function_add_assignment (_tmp302_, (ValaCCodeExpression*) _tmp309_, (ValaCCodeExpression*) _tmp315_);
									_vala_ccode_node_unref0 (_tmp315_);
									_g_free0 (_tmp313_);
									_vala_ccode_node_unref0 (_tmp309_);
									_vala_ccode_node_unref0 (_tmp307_);
									_g_free0 (_tmp305_);
								}
							}
						}
					}
					_vala_code_node_unref0 (array_type);
				} else {
					gboolean _tmp316_ = FALSE;
					ValaDataType* _tmp317_;
					_tmp317_ = return_type;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp317_, VALA_TYPE_DELEGATE_TYPE)) {
						ValaDataType* _tmp318_;
						ValaDelegate* _tmp319_;
						ValaDelegate* _tmp320_;
						gboolean _tmp321_;
						gboolean _tmp322_;
						_tmp318_ = return_type;
						_tmp319_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp318_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
						_tmp320_ = _tmp319_;
						_tmp321_ = vala_delegate_get_has_target (_tmp320_);
						_tmp322_ = _tmp321_;
						_tmp316_ = _tmp322_;
					} else {
						_tmp316_ = FALSE;
					}
					if (_tmp316_) {
						ValaCCodeFunction* _tmp323_;
						ValaCCodeFunction* _tmp324_;
						gchar* _tmp325_;
						gchar* _tmp326_;
						ValaCCodeIdentifier* _tmp327_;
						ValaCCodeIdentifier* _tmp328_;
						ValaCCodeUnaryExpression* _tmp329_;
						ValaCCodeUnaryExpression* _tmp330_;
						ValaCCodeIdentifier* _tmp331_;
						gchar* _tmp332_;
						gchar* _tmp333_;
						ValaCCodeMemberAccess* _tmp334_;
						ValaCCodeMemberAccess* _tmp335_;
						_tmp323_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp324_ = _tmp323_;
						_tmp325_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, "result");
						_tmp326_ = _tmp325_;
						_tmp327_ = vala_ccode_identifier_new (_tmp326_);
						_tmp328_ = _tmp327_;
						_tmp329_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp328_);
						_tmp330_ = _tmp329_;
						_tmp331_ = data_var;
						_tmp332_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, "result");
						_tmp333_ = _tmp332_;
						_tmp334_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp331_, _tmp333_);
						_tmp335_ = _tmp334_;
						vala_ccode_function_add_assignment (_tmp324_, (ValaCCodeExpression*) _tmp330_, (ValaCCodeExpression*) _tmp335_);
						_vala_ccode_node_unref0 (_tmp335_);
						_g_free0 (_tmp333_);
						_vala_ccode_node_unref0 (_tmp330_);
						_vala_ccode_node_unref0 (_tmp328_);
						_g_free0 (_tmp326_);
					}
				}
				_tmp337_ = return_type;
				if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp337_, VALA_TYPE_VALUE_TYPE)) {
					_tmp336_ = TRUE;
				} else {
					ValaDataType* _tmp338_;
					gboolean _tmp339_;
					gboolean _tmp340_;
					_tmp338_ = return_type;
					_tmp339_ = vala_data_type_get_nullable (_tmp338_);
					_tmp340_ = _tmp339_;
					_tmp336_ = _tmp340_;
				}
				if (_tmp336_) {
					ValaCCodeFunction* _tmp341_;
					ValaCCodeFunction* _tmp342_;
					ValaCCodeIdentifier* _tmp343_;
					ValaCCodeMemberAccess* _tmp344_;
					ValaCCodeMemberAccess* _tmp345_;
					ValaCCodeConstant* _tmp346_;
					ValaCCodeConstant* _tmp347_;
					_tmp341_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp342_ = _tmp341_;
					_tmp343_ = data_var;
					_tmp344_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp343_, "result");
					_tmp345_ = _tmp344_;
					_tmp346_ = vala_ccode_constant_new ("NULL");
					_tmp347_ = _tmp346_;
					vala_ccode_function_add_assignment (_tmp342_, (ValaCCodeExpression*) _tmp345_, (ValaCCodeExpression*) _tmp347_);
					_vala_ccode_node_unref0 (_tmp347_);
					_vala_ccode_node_unref0 (_tmp345_);
				}
				_tmp348_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp349_ = _tmp348_;
				_tmp350_ = vala_ccode_identifier_new ("result");
				_tmp351_ = _tmp350_;
				vala_ccode_function_add_return (_tmp349_, (ValaCCodeExpression*) _tmp351_);
				_vala_ccode_node_unref0 (_tmp351_);
			}
		}
	}
	vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
	_tmp352_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp353_ = finishfunc;
	vala_ccode_file_add_function (_tmp352_, _tmp353_);
	vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self);
	_vala_ccode_node_unref0 (data_var);
	_vala_code_node_unref0 (return_type);
	_vala_map_unref0 (cparam_map);
	_vala_ccode_node_unref0 (finishfunc);
	_g_free0 (dataname);
}


static gchar* vala_gasync_module_real_generate_ready_function (ValaCCodeBaseModule* base, ValaMethod* m) {
	ValaGAsyncModule * self;
	gchar* result = NULL;
	gchar* dataname = NULL;
	ValaMethod* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	ValaCCodeFunction* readyfunc = NULL;
	ValaMethod* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaCCodeFunction* _tmp13_;
	ValaCCodeFunction* _tmp14_;
	const gchar* _tmp15_;
	const gchar* _tmp16_;
	gboolean _tmp17_;
	ValaCCodeFunction* _tmp22_;
	ValaCCodeParameter* _tmp23_;
	ValaCCodeParameter* _tmp24_;
	ValaCCodeFunction* _tmp25_;
	ValaCCodeParameter* _tmp26_;
	ValaCCodeParameter* _tmp27_;
	ValaCCodeFunction* _tmp28_;
	ValaCCodeParameter* _tmp29_;
	ValaCCodeParameter* _tmp30_;
	ValaCCodeFunction* _tmp31_;
	ValaCCodeIdentifier* data_var = NULL;
	ValaCCodeIdentifier* _tmp32_;
	ValaCCodeFunction* _tmp33_;
	ValaCCodeFunction* _tmp34_;
	const gchar* _tmp35_;
	gchar* _tmp36_;
	gchar* _tmp37_;
	ValaCCodeVariableDeclarator* _tmp38_;
	ValaCCodeVariableDeclarator* _tmp39_;
	ValaCCodeFunction* _tmp40_;
	ValaCCodeFunction* _tmp41_;
	ValaCCodeIdentifier* _tmp42_;
	ValaCCodeIdentifier* _tmp43_;
	ValaCCodeIdentifier* _tmp44_;
	ValaCCodeFunction* _tmp45_;
	ValaCCodeFunction* _tmp46_;
	ValaCCodeIdentifier* _tmp47_;
	ValaCCodeMemberAccess* _tmp48_;
	ValaCCodeMemberAccess* _tmp49_;
	ValaCCodeIdentifier* _tmp50_;
	ValaCCodeIdentifier* _tmp51_;
	ValaCCodeFunction* _tmp52_;
	ValaCCodeFunction* _tmp53_;
	ValaCCodeIdentifier* _tmp54_;
	ValaCCodeMemberAccess* _tmp55_;
	ValaCCodeMemberAccess* _tmp56_;
	ValaCCodeIdentifier* _tmp57_;
	ValaCCodeIdentifier* _tmp58_;
	gboolean _tmp59_ = FALSE;
	ValaCodeContext* _tmp60_;
	ValaCodeContext* _tmp61_;
	gboolean _tmp62_;
	ValaCCodeFunctionCall* ccall = NULL;
	ValaMethod* _tmp73_;
	gchar* _tmp74_;
	gchar* _tmp75_;
	gchar* _tmp76_;
	gchar* _tmp77_;
	ValaCCodeIdentifier* _tmp78_;
	ValaCCodeIdentifier* _tmp79_;
	ValaCCodeFunctionCall* _tmp80_;
	ValaCCodeFunctionCall* _tmp81_;
	ValaCCodeFunctionCall* _tmp82_;
	ValaCCodeIdentifier* _tmp83_;
	ValaCCodeFunction* _tmp84_;
	ValaCCodeFunction* _tmp85_;
	ValaCCodeFunctionCall* _tmp86_;
	ValaCCodeFunction* _tmp87_;
	ValaCCodeFunction* _tmp88_;
	ValaCCodeModifiers _tmp89_;
	ValaCCodeModifiers _tmp90_;
	ValaCCodeFile* _tmp91_;
	ValaCCodeFunction* _tmp92_;
	ValaCCodeFile* _tmp93_;
	ValaCCodeFunction* _tmp94_;
	ValaCCodeFunction* _tmp95_;
	const gchar* _tmp96_;
	const gchar* _tmp97_;
	gchar* _tmp98_;
	self = (ValaGAsyncModule*) base;
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_symbol_lower_case_to_camel_case (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strconcat (_tmp4_, "Data", NULL);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	_g_free0 (_tmp2_);
	dataname = _tmp6_;
	_tmp7_ = m;
	_tmp8_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = g_strconcat (_tmp9_, "_ready", NULL);
	_tmp11_ = _tmp10_;
	_tmp12_ = vala_ccode_function_new (_tmp11_, "void");
	_tmp13_ = _tmp12_;
	_g_free0 (_tmp11_);
	_g_free0 (_tmp9_);
	readyfunc = _tmp13_;
	_tmp14_ = readyfunc;
	_tmp15_ = vala_ccode_function_get_name (_tmp14_);
	_tmp16_ = _tmp15_;
	_tmp17_ = vala_ccode_base_module_add_wrapper ((ValaCCodeBaseModule*) self, _tmp16_);
	if (!_tmp17_) {
		ValaCCodeFunction* _tmp18_;
		const gchar* _tmp19_;
		const gchar* _tmp20_;
		gchar* _tmp21_;
		_tmp18_ = readyfunc;
		_tmp19_ = vala_ccode_function_get_name (_tmp18_);
		_tmp20_ = _tmp19_;
		_tmp21_ = g_strdup (_tmp20_);
		result = _tmp21_;
		_vala_ccode_node_unref0 (readyfunc);
		_g_free0 (dataname);
		return result;
	}
	_tmp22_ = readyfunc;
	_tmp23_ = vala_ccode_parameter_new ("source_object", "GObject*");
	_tmp24_ = _tmp23_;
	vala_ccode_function_add_parameter (_tmp22_, _tmp24_);
	_vala_ccode_node_unref0 (_tmp24_);
	_tmp25_ = readyfunc;
	_tmp26_ = vala_ccode_parameter_new ("_res_", "GAsyncResult*");
	_tmp27_ = _tmp26_;
	vala_ccode_function_add_parameter (_tmp25_, _tmp27_);
	_vala_ccode_node_unref0 (_tmp27_);
	_tmp28_ = readyfunc;
	_tmp29_ = vala_ccode_parameter_new ("_user_data_", "gpointer");
	_tmp30_ = _tmp29_;
	vala_ccode_function_add_parameter (_tmp28_, _tmp30_);
	_vala_ccode_node_unref0 (_tmp30_);
	_tmp31_ = readyfunc;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp31_);
	_tmp32_ = vala_ccode_identifier_new ("_data_");
	data_var = _tmp32_;
	_tmp33_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp34_ = _tmp33_;
	_tmp35_ = dataname;
	_tmp36_ = g_strconcat (_tmp35_, "*", NULL);
	_tmp37_ = _tmp36_;
	_tmp38_ = vala_ccode_variable_declarator_new ("_data_", NULL, NULL);
	_tmp39_ = _tmp38_;
	vala_ccode_function_add_declaration (_tmp34_, _tmp37_, (ValaCCodeDeclarator*) _tmp39_, 0);
	_vala_ccode_node_unref0 (_tmp39_);
	_g_free0 (_tmp37_);
	_tmp40_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp41_ = _tmp40_;
	_tmp42_ = data_var;
	_tmp43_ = vala_ccode_identifier_new ("_user_data_");
	_tmp44_ = _tmp43_;
	vala_ccode_function_add_assignment (_tmp41_, (ValaCCodeExpression*) _tmp42_, (ValaCCodeExpression*) _tmp44_);
	_vala_ccode_node_unref0 (_tmp44_);
	_tmp45_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp46_ = _tmp45_;
	_tmp47_ = data_var;
	_tmp48_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp47_, "_source_object_");
	_tmp49_ = _tmp48_;
	_tmp50_ = vala_ccode_identifier_new ("source_object");
	_tmp51_ = _tmp50_;
	vala_ccode_function_add_assignment (_tmp46_, (ValaCCodeExpression*) _tmp49_, (ValaCCodeExpression*) _tmp51_);
	_vala_ccode_node_unref0 (_tmp51_);
	_vala_ccode_node_unref0 (_tmp49_);
	_tmp52_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp53_ = _tmp52_;
	_tmp54_ = data_var;
	_tmp55_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp54_, "_res_");
	_tmp56_ = _tmp55_;
	_tmp57_ = vala_ccode_identifier_new ("_res_");
	_tmp58_ = _tmp57_;
	vala_ccode_function_add_assignment (_tmp53_, (ValaCCodeExpression*) _tmp56_, (ValaCCodeExpression*) _tmp58_);
	_vala_ccode_node_unref0 (_tmp58_);
	_vala_ccode_node_unref0 (_tmp56_);
	_tmp60_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp61_ = _tmp60_;
	_tmp62_ = vala_code_context_require_glib_version (_tmp61_, 2, 36);
	if (_tmp62_) {
		ValaCodeContext* _tmp63_;
		ValaCodeContext* _tmp64_;
		gboolean _tmp65_;
		_tmp63_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp64_ = _tmp63_;
		_tmp65_ = vala_code_context_require_glib_version (_tmp64_, 2, 44);
		_tmp59_ = !_tmp65_;
	} else {
		_tmp59_ = FALSE;
	}
	if (_tmp59_) {
		ValaCCodeFunction* _tmp66_;
		ValaCCodeFunction* _tmp67_;
		ValaCCodeIdentifier* _tmp68_;
		ValaCCodeMemberAccess* _tmp69_;
		ValaCCodeMemberAccess* _tmp70_;
		ValaCCodeConstant* _tmp71_;
		ValaCCodeConstant* _tmp72_;
		_tmp66_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp67_ = _tmp66_;
		_tmp68_ = data_var;
		_tmp69_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp68_, "_task_complete_");
		_tmp70_ = _tmp69_;
		_tmp71_ = vala_ccode_constant_new ("TRUE");
		_tmp72_ = _tmp71_;
		vala_ccode_function_add_assignment (_tmp67_, (ValaCCodeExpression*) _tmp70_, (ValaCCodeExpression*) _tmp72_);
		_vala_ccode_node_unref0 (_tmp72_);
		_vala_ccode_node_unref0 (_tmp70_);
	}
	_tmp73_ = m;
	_tmp74_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp73_);
	_tmp75_ = _tmp74_;
	_tmp76_ = g_strconcat (_tmp75_, "_co", NULL);
	_tmp77_ = _tmp76_;
	_tmp78_ = vala_ccode_identifier_new (_tmp77_);
	_tmp79_ = _tmp78_;
	_tmp80_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp79_);
	_tmp81_ = _tmp80_;
	_vala_ccode_node_unref0 (_tmp79_);
	_g_free0 (_tmp77_);
	_g_free0 (_tmp75_);
	ccall = _tmp81_;
	_tmp82_ = ccall;
	_tmp83_ = data_var;
	vala_ccode_function_call_add_argument (_tmp82_, (ValaCCodeExpression*) _tmp83_);
	_tmp84_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp85_ = _tmp84_;
	_tmp86_ = ccall;
	vala_ccode_function_add_expression (_tmp85_, (ValaCCodeExpression*) _tmp86_);
	_tmp87_ = readyfunc;
	_tmp88_ = readyfunc;
	_tmp89_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp88_);
	_tmp90_ = _tmp89_;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp88_, _tmp90_ | VALA_CCODE_MODIFIERS_STATIC);
	vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
	_tmp91_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp92_ = readyfunc;
	vala_ccode_file_add_function_declaration (_tmp91_, _tmp92_);
	_tmp93_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp94_ = readyfunc;
	vala_ccode_file_add_function (_tmp93_, _tmp94_);
	_tmp95_ = readyfunc;
	_tmp96_ = vala_ccode_function_get_name (_tmp95_);
	_tmp97_ = _tmp96_;
	_tmp98_ = g_strdup (_tmp97_);
	result = _tmp98_;
	_vala_ccode_node_unref0 (ccall);
	_vala_ccode_node_unref0 (data_var);
	_vala_ccode_node_unref0 (readyfunc);
	_g_free0 (dataname);
	return result;
}


static void vala_gasync_module_real_generate_virtual_method_declaration (ValaGTypeModule* base, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeStruct* type_struct) {
	ValaGAsyncModule * self;
	ValaMethod* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	gboolean _tmp6_ = FALSE;
	ValaMethod* _tmp7_;
	gboolean _tmp8_;
	gboolean _tmp9_;
	ValaDataType* creturn_type = NULL;
	ValaMethod* _tmp13_;
	ValaDataType* _tmp14_;
	ValaDataType* _tmp15_;
	ValaDataType* _tmp16_;
	ValaMethod* _tmp17_;
	ValaDataType* _tmp18_;
	ValaDataType* _tmp19_;
	gboolean _tmp20_;
	ValaCCodeFunctionDeclarator* vdeclarator = NULL;
	ValaMethod* _tmp22_;
	gchar* _tmp23_;
	gchar* _tmp24_;
	ValaCCodeFunctionDeclarator* _tmp25_;
	ValaCCodeFunctionDeclarator* _tmp26_;
	ValaHashMap* cparam_map = NULL;
	GHashFunc _tmp27_;
	GEqualFunc _tmp28_;
	GEqualFunc _tmp29_;
	ValaHashMap* _tmp30_;
	ValaMethod* _tmp31_;
	ValaCCodeFile* _tmp32_;
	ValaHashMap* _tmp33_;
	ValaCCodeFunction* _tmp34_;
	ValaCCodeFunction* _tmp35_;
	ValaCCodeFunctionDeclarator* _tmp36_;
	ValaCCodeDeclaration* vdecl = NULL;
	ValaCCodeDeclaration* _tmp37_;
	ValaCCodeDeclaration* _tmp38_;
	ValaCCodeFunctionDeclarator* _tmp39_;
	ValaCCodeStruct* _tmp40_;
	ValaCCodeDeclaration* _tmp41_;
	ValaMethod* _tmp42_;
	gchar* _tmp43_;
	gchar* _tmp44_;
	ValaCCodeFunctionDeclarator* _tmp45_;
	GHashFunc _tmp46_;
	GEqualFunc _tmp47_;
	GEqualFunc _tmp48_;
	ValaHashMap* _tmp49_;
	ValaMethod* _tmp50_;
	ValaCCodeFile* _tmp51_;
	ValaHashMap* _tmp52_;
	ValaCCodeFunction* _tmp53_;
	ValaCCodeFunction* _tmp54_;
	ValaCCodeFunctionDeclarator* _tmp55_;
	ValaDataType* _tmp56_;
	gchar* _tmp57_;
	gchar* _tmp58_;
	ValaCCodeDeclaration* _tmp59_;
	ValaCCodeDeclaration* _tmp60_;
	ValaCCodeFunctionDeclarator* _tmp61_;
	ValaCCodeStruct* _tmp62_;
	ValaCCodeDeclaration* _tmp63_;
	self = (ValaGAsyncModule*) base;
	g_return_if_fail (m != NULL);
	g_return_if_fail (decl_space != NULL);
	g_return_if_fail (type_struct != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_method_get_coroutine (_tmp0_);
	_tmp2_ = _tmp1_;
	if (!_tmp2_) {
		ValaMethod* _tmp3_;
		ValaCCodeFile* _tmp4_;
		ValaCCodeStruct* _tmp5_;
		_tmp3_ = m;
		_tmp4_ = decl_space;
		_tmp5_ = type_struct;
		VALA_GTYPE_MODULE_CLASS (vala_gasync_module_parent_class)->generate_virtual_method_declaration ((ValaGTypeModule*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GTK_MODULE, ValaGtkModule), _tmp3_, _tmp4_, _tmp5_);
		return;
	}
	_tmp7_ = m;
	_tmp8_ = vala_method_get_is_abstract (_tmp7_);
	_tmp9_ = _tmp8_;
	if (!_tmp9_) {
		ValaMethod* _tmp10_;
		gboolean _tmp11_;
		gboolean _tmp12_;
		_tmp10_ = m;
		_tmp11_ = vala_method_get_is_virtual (_tmp10_);
		_tmp12_ = _tmp11_;
		_tmp6_ = !_tmp12_;
	} else {
		_tmp6_ = FALSE;
	}
	if (_tmp6_) {
		return;
	}
	_tmp13_ = m;
	_tmp14_ = vala_callable_get_return_type ((ValaCallable*) _tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = _vala_code_node_ref0 (_tmp15_);
	creturn_type = _tmp16_;
	_tmp17_ = m;
	_tmp18_ = vala_callable_get_return_type ((ValaCallable*) _tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = vala_data_type_is_real_non_null_struct_type (_tmp19_);
	if (_tmp20_) {
		ValaVoidType* _tmp21_;
		_tmp21_ = vala_void_type_new (NULL);
		_vala_code_node_unref0 (creturn_type);
		creturn_type = (ValaDataType*) _tmp21_;
	}
	_tmp22_ = m;
	_tmp23_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp22_);
	_tmp24_ = _tmp23_;
	_tmp25_ = vala_ccode_function_declarator_new (_tmp24_);
	_tmp26_ = _tmp25_;
	_g_free0 (_tmp24_);
	vdeclarator = _tmp26_;
	_tmp27_ = g_direct_hash;
	_tmp28_ = g_direct_equal;
	_tmp29_ = g_direct_equal;
	_tmp30_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp27_, _tmp28_, _tmp29_);
	cparam_map = _tmp30_;
	_tmp31_ = m;
	_tmp32_ = decl_space;
	_tmp33_ = cparam_map;
	_tmp34_ = vala_ccode_function_new ("fake", "void");
	_tmp35_ = _tmp34_;
	_tmp36_ = vdeclarator;
	vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp31_, _tmp32_, (ValaMap*) _tmp33_, _tmp35_, _tmp36_, NULL, NULL, 1);
	_vala_ccode_node_unref0 (_tmp35_);
	_tmp37_ = vala_ccode_declaration_new ("void");
	vdecl = _tmp37_;
	_tmp38_ = vdecl;
	_tmp39_ = vdeclarator;
	vala_ccode_declaration_add_declarator (_tmp38_, (ValaCCodeDeclarator*) _tmp39_);
	_tmp40_ = type_struct;
	_tmp41_ = vdecl;
	vala_ccode_struct_add_declaration (_tmp40_, _tmp41_);
	_tmp42_ = m;
	_tmp43_ = vala_ccode_base_module_get_ccode_finish_vfunc_name (_tmp42_);
	_tmp44_ = _tmp43_;
	_tmp45_ = vala_ccode_function_declarator_new (_tmp44_);
	_vala_ccode_node_unref0 (vdeclarator);
	vdeclarator = _tmp45_;
	_g_free0 (_tmp44_);
	_tmp46_ = g_direct_hash;
	_tmp47_ = g_direct_equal;
	_tmp48_ = g_direct_equal;
	_tmp49_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp46_, _tmp47_, _tmp48_);
	_vala_map_unref0 (cparam_map);
	cparam_map = _tmp49_;
	_tmp50_ = m;
	_tmp51_ = decl_space;
	_tmp52_ = cparam_map;
	_tmp53_ = vala_ccode_function_new ("fake", "void");
	_tmp54_ = _tmp53_;
	_tmp55_ = vdeclarator;
	vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp50_, _tmp51_, (ValaMap*) _tmp52_, _tmp54_, _tmp55_, NULL, NULL, 2);
	_vala_ccode_node_unref0 (_tmp54_);
	_tmp56_ = creturn_type;
	_tmp57_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp56_);
	_tmp58_ = _tmp57_;
	_tmp59_ = vala_ccode_declaration_new (_tmp58_);
	_vala_ccode_node_unref0 (vdecl);
	vdecl = _tmp59_;
	_g_free0 (_tmp58_);
	_tmp60_ = vdecl;
	_tmp61_ = vdeclarator;
	vala_ccode_declaration_add_declarator (_tmp60_, (ValaCCodeDeclarator*) _tmp61_);
	_tmp62_ = type_struct;
	_tmp63_ = vdecl;
	vala_ccode_struct_add_declaration (_tmp62_, _tmp63_);
	_vala_ccode_node_unref0 (vdecl);
	_vala_map_unref0 (cparam_map);
	_vala_ccode_node_unref0 (vdeclarator);
	_vala_code_node_unref0 (creturn_type);
}


static gpointer _vala_iterable_ref0 (gpointer self) {
	return self ? vala_iterable_ref (self) : NULL;
}


static void vala_gasync_module_real_visit_yield_statement (ValaCodeVisitor* base, ValaYieldStatement* stmt) {
	ValaGAsyncModule * self;
	gboolean _tmp0_;
	ValaYieldStatement* _tmp1_;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	ValaYieldStatement* _tmp30_;
	ValaExpression* _tmp31_;
	ValaExpression* _tmp32_;
	gboolean _tmp33_;
	gboolean _tmp34_;
	ValaCCodeFunction* _tmp36_;
	ValaCCodeFunction* _tmp37_;
	ValaYieldStatement* _tmp38_;
	ValaExpression* _tmp39_;
	ValaExpression* _tmp40_;
	ValaCCodeExpression* _tmp41_;
	ValaCCodeExpression* _tmp42_;
	gboolean _tmp43_ = FALSE;
	ValaYieldStatement* _tmp44_;
	gboolean _tmp45_;
	gboolean _tmp46_;
	ValaArrayList* _tmp72_;
	ValaArrayList* _tmp73_;
	self = (ValaGAsyncModule*) base;
	g_return_if_fail (stmt != NULL);
	_tmp0_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);
	if (!_tmp0_) {
		return;
	}
	_tmp1_ = stmt;
	_tmp2_ = vala_yield_statement_get_yield_expression (_tmp1_);
	_tmp3_ = _tmp2_;
	if (_tmp3_ == NULL) {
		gint state = 0;
		ValaCCodeBaseModuleEmitContext* _tmp4_;
		gint _tmp5_;
		ValaCCodeFunction* _tmp6_;
		ValaCCodeFunction* _tmp7_;
		ValaCCodeIdentifier* _tmp8_;
		ValaCCodeIdentifier* _tmp9_;
		ValaCCodeMemberAccess* _tmp10_;
		ValaCCodeMemberAccess* _tmp11_;
		gint _tmp12_;
		gchar* _tmp13_;
		gchar* _tmp14_;
		ValaCCodeConstant* _tmp15_;
		ValaCCodeConstant* _tmp16_;
		ValaCCodeFunction* _tmp17_;
		ValaCCodeFunction* _tmp18_;
		ValaCCodeConstant* _tmp19_;
		ValaCCodeConstant* _tmp20_;
		ValaCCodeFunction* _tmp21_;
		ValaCCodeFunction* _tmp22_;
		gint _tmp23_;
		gchar* _tmp24_;
		gchar* _tmp25_;
		ValaCCodeFunction* _tmp26_;
		ValaCCodeFunction* _tmp27_;
		ValaCCodeEmptyStatement* _tmp28_;
		ValaCCodeEmptyStatement* _tmp29_;
		_tmp4_ = ((ValaCCodeBaseModule*) self)->emit_context;
		_tmp5_ = _tmp4_->next_coroutine_state;
		_tmp4_->next_coroutine_state = _tmp5_ + 1;
		state = _tmp5_;
		_tmp6_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_ccode_identifier_new ("_data_");
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp9_, "_state_");
		_tmp11_ = _tmp10_;
		_tmp12_ = state;
		_tmp13_ = g_strdup_printf ("%i", _tmp12_);
		_tmp14_ = _tmp13_;
		_tmp15_ = vala_ccode_constant_new (_tmp14_);
		_tmp16_ = _tmp15_;
		vala_ccode_function_add_assignment (_tmp7_, (ValaCCodeExpression*) _tmp11_, (ValaCCodeExpression*) _tmp16_);
		_vala_ccode_node_unref0 (_tmp16_);
		_g_free0 (_tmp14_);
		_vala_ccode_node_unref0 (_tmp11_);
		_vala_ccode_node_unref0 (_tmp9_);
		_tmp17_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp18_ = _tmp17_;
		_tmp19_ = vala_ccode_constant_new ("FALSE");
		_tmp20_ = _tmp19_;
		vala_ccode_function_add_return (_tmp18_, (ValaCCodeExpression*) _tmp20_);
		_vala_ccode_node_unref0 (_tmp20_);
		_tmp21_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp22_ = _tmp21_;
		_tmp23_ = state;
		_tmp24_ = g_strdup_printf ("_state_%d", _tmp23_);
		_tmp25_ = _tmp24_;
		vala_ccode_function_add_label (_tmp22_, _tmp25_);
		_g_free0 (_tmp25_);
		_tmp26_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp27_ = _tmp26_;
		_tmp28_ = vala_ccode_empty_statement_new ();
		_tmp29_ = _tmp28_;
		vala_ccode_function_add_statement (_tmp27_, (ValaCCodeNode*) _tmp29_);
		_vala_ccode_node_unref0 (_tmp29_);
		return;
	}
	_tmp30_ = stmt;
	_tmp31_ = vala_yield_statement_get_yield_expression (_tmp30_);
	_tmp32_ = _tmp31_;
	_tmp33_ = vala_code_node_get_error ((ValaCodeNode*) _tmp32_);
	_tmp34_ = _tmp33_;
	if (_tmp34_) {
		ValaYieldStatement* _tmp35_;
		_tmp35_ = stmt;
		vala_code_node_set_error ((ValaCodeNode*) _tmp35_, TRUE);
		return;
	}
	_tmp36_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp37_ = _tmp36_;
	_tmp38_ = stmt;
	_tmp39_ = vala_yield_statement_get_yield_expression (_tmp38_);
	_tmp40_ = _tmp39_;
	_tmp41_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp40_);
	_tmp42_ = _tmp41_;
	vala_ccode_function_add_expression (_tmp37_, _tmp42_);
	_vala_ccode_node_unref0 (_tmp42_);
	_tmp44_ = stmt;
	_tmp45_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp44_);
	_tmp46_ = _tmp45_;
	if (_tmp46_) {
		ValaYieldStatement* _tmp47_;
		ValaExpression* _tmp48_;
		ValaExpression* _tmp49_;
		gboolean _tmp50_;
		gboolean _tmp51_;
		_tmp47_ = stmt;
		_tmp48_ = vala_yield_statement_get_yield_expression (_tmp47_);
		_tmp49_ = _tmp48_;
		_tmp50_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp49_);
		_tmp51_ = _tmp50_;
		_tmp43_ = _tmp51_;
	} else {
		_tmp43_ = FALSE;
	}
	if (_tmp43_) {
		ValaYieldStatement* _tmp52_;
		ValaExpression* _tmp53_;
		ValaExpression* _tmp54_;
		_tmp52_ = stmt;
		_tmp53_ = vala_yield_statement_get_yield_expression (_tmp52_);
		_tmp54_ = _tmp53_;
		vala_ccode_base_module_add_simple_check ((ValaCCodeBaseModule*) self, (ValaCodeNode*) _tmp54_, FALSE);
	}
	{
		ValaArrayList* _value_list = NULL;
		ValaArrayList* _tmp55_;
		ValaArrayList* _tmp56_;
		ValaArrayList* _tmp57_;
		gint _value_size = 0;
		ValaArrayList* _tmp58_;
		gint _tmp59_;
		gint _tmp60_;
		gint _value_index = 0;
		_tmp55_ = vala_ccode_base_module_get_temp_ref_values ((ValaCCodeBaseModule*) self);
		_tmp56_ = _tmp55_;
		_tmp57_ = _vala_iterable_ref0 (_tmp56_);
		_value_list = _tmp57_;
		_tmp58_ = _value_list;
		_tmp59_ = vala_collection_get_size ((ValaCollection*) _tmp58_);
		_tmp60_ = _tmp59_;
		_value_size = _tmp60_;
		_value_index = -1;
		while (TRUE) {
			gint _tmp61_;
			gint _tmp62_;
			gint _tmp63_;
			ValaTargetValue* value = NULL;
			ValaArrayList* _tmp64_;
			gint _tmp65_;
			gpointer _tmp66_;
			ValaCCodeFunction* _tmp67_;
			ValaCCodeFunction* _tmp68_;
			ValaTargetValue* _tmp69_;
			ValaCCodeExpression* _tmp70_;
			ValaCCodeExpression* _tmp71_;
			_tmp61_ = _value_index;
			_value_index = _tmp61_ + 1;
			_tmp62_ = _value_index;
			_tmp63_ = _value_size;
			if (!(_tmp62_ < _tmp63_)) {
				break;
			}
			_tmp64_ = _value_list;
			_tmp65_ = _value_index;
			_tmp66_ = vala_list_get ((ValaList*) _tmp64_, _tmp65_);
			value = (ValaTargetValue*) _tmp66_;
			_tmp67_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp68_ = _tmp67_;
			_tmp69_ = value;
			_tmp70_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, _tmp69_, FALSE);
			_tmp71_ = _tmp70_;
			vala_ccode_function_add_expression (_tmp68_, _tmp71_);
			_vala_ccode_node_unref0 (_tmp71_);
			_vala_target_value_unref0 (value);
		}
		_vala_iterable_unref0 (_value_list);
	}
	_tmp72_ = vala_ccode_base_module_get_temp_ref_values ((ValaCCodeBaseModule*) self);
	_tmp73_ = _tmp72_;
	vala_collection_clear ((ValaCollection*) _tmp73_);
}


static void vala_gasync_module_real_return_with_exception (ValaGErrorModule* base, ValaCCodeExpression* error_expr) {
	ValaGAsyncModule * self;
	gboolean _tmp0_;
	ValaCCodeMemberAccess* async_result_expr = NULL;
	ValaCCodeIdentifier* _tmp2_;
	ValaCCodeIdentifier* _tmp3_;
	ValaCCodeMemberAccess* _tmp4_;
	ValaCCodeMemberAccess* _tmp5_;
	ValaCCodeFunctionCall* set_error = NULL;
	ValaCodeContext* _tmp6_;
	ValaCodeContext* _tmp7_;
	gboolean _tmp8_;
	ValaCCodeFunctionCall* _tmp15_;
	ValaCCodeMemberAccess* _tmp16_;
	ValaCCodeFunctionCall* _tmp17_;
	ValaCCodeExpression* _tmp18_;
	ValaCCodeFunction* _tmp19_;
	ValaCCodeFunction* _tmp20_;
	ValaCCodeFunctionCall* _tmp21_;
	ValaSymbol* _tmp22_;
	ValaSymbol* _tmp23_;
	ValaCodeContext* _tmp24_;
	ValaCodeContext* _tmp25_;
	gboolean _tmp26_;
	self = (ValaGAsyncModule*) base;
	g_return_if_fail (error_expr != NULL);
	_tmp0_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);
	if (!_tmp0_) {
		ValaCCodeExpression* _tmp1_;
		_tmp1_ = error_expr;
		VALA_GERROR_MODULE_CLASS (vala_gasync_module_parent_class)->return_with_exception ((ValaGErrorModule*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GTK_MODULE, ValaGtkModule), _tmp1_);
		return;
	}
	_tmp2_ = vala_ccode_identifier_new ("_data_");
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp3_, "_async_result");
	_tmp5_ = _tmp4_;
	_vala_ccode_node_unref0 (_tmp3_);
	async_result_expr = _tmp5_;
	set_error = NULL;
	_tmp6_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp7_ = _tmp6_;
	_tmp8_ = vala_code_context_require_glib_version (_tmp7_, 2, 36);
	if (_tmp8_) {
		ValaCCodeIdentifier* _tmp9_;
		ValaCCodeIdentifier* _tmp10_;
		ValaCCodeFunctionCall* _tmp11_;
		_tmp9_ = vala_ccode_identifier_new ("g_task_return_error");
		_tmp10_ = _tmp9_;
		_tmp11_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp10_);
		_vala_ccode_node_unref0 (set_error);
		set_error = _tmp11_;
		_vala_ccode_node_unref0 (_tmp10_);
	} else {
		ValaCCodeIdentifier* _tmp12_;
		ValaCCodeIdentifier* _tmp13_;
		ValaCCodeFunctionCall* _tmp14_;
		_tmp12_ = vala_ccode_identifier_new ("g_simple_async_result_take_error");
		_tmp13_ = _tmp12_;
		_tmp14_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp13_);
		_vala_ccode_node_unref0 (set_error);
		set_error = _tmp14_;
		_vala_ccode_node_unref0 (_tmp13_);
	}
	_tmp15_ = set_error;
	_tmp16_ = async_result_expr;
	vala_ccode_function_call_add_argument (_tmp15_, (ValaCCodeExpression*) _tmp16_);
	_tmp17_ = set_error;
	_tmp18_ = error_expr;
	vala_ccode_function_call_add_argument (_tmp17_, _tmp18_);
	_tmp19_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp20_ = _tmp19_;
	_tmp21_ = set_error;
	vala_ccode_function_add_expression (_tmp20_, (ValaCCodeExpression*) _tmp21_);
	_tmp22_ = vala_ccode_base_module_get_current_symbol ((ValaCCodeBaseModule*) self);
	_tmp23_ = _tmp22_;
	vala_ccode_base_module_append_local_free ((ValaCCodeBaseModule*) self, _tmp23_, FALSE, NULL);
	_tmp24_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp25_ = _tmp24_;
	_tmp26_ = vala_code_context_require_glib_version (_tmp25_, 2, 36);
	if (_tmp26_) {
		ValaCCodeFunctionCall* unref = NULL;
		ValaCCodeIdentifier* _tmp27_;
		ValaCCodeIdentifier* _tmp28_;
		ValaCCodeFunctionCall* _tmp29_;
		ValaCCodeFunctionCall* _tmp30_;
		ValaCCodeFunctionCall* _tmp31_;
		ValaCCodeMemberAccess* _tmp32_;
		ValaCCodeFunction* _tmp33_;
		ValaCCodeFunction* _tmp34_;
		ValaCCodeFunctionCall* _tmp35_;
		ValaCCodeFunction* _tmp36_;
		ValaCCodeFunction* _tmp37_;
		ValaCCodeConstant* _tmp38_;
		ValaCCodeConstant* _tmp39_;
		_tmp27_ = vala_ccode_identifier_new ("g_object_unref");
		_tmp28_ = _tmp27_;
		_tmp29_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp28_);
		_tmp30_ = _tmp29_;
		_vala_ccode_node_unref0 (_tmp28_);
		unref = _tmp30_;
		_tmp31_ = unref;
		_tmp32_ = async_result_expr;
		vala_ccode_function_call_add_argument (_tmp31_, (ValaCCodeExpression*) _tmp32_);
		_tmp33_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp34_ = _tmp33_;
		_tmp35_ = unref;
		vala_ccode_function_add_expression (_tmp34_, (ValaCCodeExpression*) _tmp35_);
		_tmp36_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp37_ = _tmp36_;
		_tmp38_ = vala_ccode_constant_new ("FALSE");
		_tmp39_ = _tmp38_;
		vala_ccode_function_add_return (_tmp37_, (ValaCCodeExpression*) _tmp39_);
		_vala_ccode_node_unref0 (_tmp39_);
		_vala_ccode_node_unref0 (unref);
	} else {
		vala_ccode_method_module_complete_async ((ValaCCodeMethodModule*) self);
	}
	_vala_ccode_node_unref0 (set_error);
	_vala_ccode_node_unref0 (async_result_expr);
}


static void vala_gasync_module_real_visit_return_statement (ValaCodeVisitor* base, ValaReturnStatement* stmt) {
	ValaGAsyncModule * self;
	ValaReturnStatement* _tmp0_;
	gboolean _tmp1_;
	self = (ValaGAsyncModule*) base;
	g_return_if_fail (stmt != NULL);
	_tmp0_ = stmt;
	VALA_CODE_VISITOR_CLASS (vala_gasync_module_parent_class)->visit_return_statement ((ValaCodeVisitor*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GTK_MODULE, ValaGtkModule), _tmp0_);
	_tmp1_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);
	if (!_tmp1_) {
		return;
	}
	vala_ccode_method_module_complete_async ((ValaCCodeMethodModule*) self);
}


static void vala_gasync_module_real_generate_cparameters (ValaCCodeBaseModule* base, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction) {
	ValaGAsyncModule * self;
	ValaMethod* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	ValaMethod* _tmp32_;
	ValaCCodeFile* _tmp33_;
	ValaMap* _tmp34_;
	ValaCCodeFunction* _tmp35_;
	ValaCCodeFunctionDeclarator* _tmp36_;
	ValaMap* _tmp37_;
	ValaCCodeFunctionCall* _tmp38_;
	gint _tmp39_;
	self = (ValaGAsyncModule*) base;
	g_return_if_fail (m != NULL);
	g_return_if_fail (decl_space != NULL);
	g_return_if_fail (cparam_map != NULL);
	g_return_if_fail (func != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_method_get_coroutine (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_) {
		ValaCCodeFile* _tmp3_;
		gint _tmp4_;
		_tmp3_ = decl_space;
		vala_ccode_file_add_include (_tmp3_, "gio/gio.h", FALSE);
		_tmp4_ = direction;
		if (_tmp4_ == 1) {
			ValaMap* _tmp5_;
			gint _tmp6_;
			ValaCCodeParameter* _tmp7_;
			ValaCCodeParameter* _tmp8_;
			ValaMap* _tmp9_;
			gint _tmp10_;
			ValaCCodeParameter* _tmp11_;
			ValaCCodeParameter* _tmp12_;
			ValaMap* _tmp13_;
			_tmp5_ = cparam_map;
			_tmp6_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, FALSE);
			_tmp7_ = vala_ccode_parameter_new ("_callback_", "GAsyncReadyCallback");
			_tmp8_ = _tmp7_;
			vala_map_set (_tmp5_, (gpointer) ((gintptr) _tmp6_), _tmp8_);
			_vala_ccode_node_unref0 (_tmp8_);
			_tmp9_ = cparam_map;
			_tmp10_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, -0.9, FALSE);
			_tmp11_ = vala_ccode_parameter_new ("_user_data_", "gpointer");
			_tmp12_ = _tmp11_;
			vala_map_set (_tmp9_, (gpointer) ((gintptr) _tmp10_), _tmp12_);
			_vala_ccode_node_unref0 (_tmp12_);
			_tmp13_ = carg_map;
			if (_tmp13_ != NULL) {
				ValaMap* _tmp14_;
				gint _tmp15_;
				ValaCCodeIdentifier* _tmp16_;
				ValaCCodeIdentifier* _tmp17_;
				ValaMap* _tmp18_;
				gint _tmp19_;
				ValaCCodeIdentifier* _tmp20_;
				ValaCCodeIdentifier* _tmp21_;
				_tmp14_ = carg_map;
				_tmp15_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, FALSE);
				_tmp16_ = vala_ccode_identifier_new ("_callback_");
				_tmp17_ = _tmp16_;
				vala_map_set (_tmp14_, (gpointer) ((gintptr) _tmp15_), (ValaCCodeExpression*) _tmp17_);
				_vala_ccode_node_unref0 (_tmp17_);
				_tmp18_ = carg_map;
				_tmp19_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, -0.9, FALSE);
				_tmp20_ = vala_ccode_identifier_new ("_user_data_");
				_tmp21_ = _tmp20_;
				vala_map_set (_tmp18_, (gpointer) ((gintptr) _tmp19_), (ValaCCodeExpression*) _tmp21_);
				_vala_ccode_node_unref0 (_tmp21_);
			}
		} else {
			gint _tmp22_;
			_tmp22_ = direction;
			if (_tmp22_ == 2) {
				ValaMap* _tmp23_;
				gint _tmp24_;
				ValaCCodeParameter* _tmp25_;
				ValaCCodeParameter* _tmp26_;
				ValaMap* _tmp27_;
				_tmp23_ = cparam_map;
				_tmp24_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, 0.1, FALSE);
				_tmp25_ = vala_ccode_parameter_new ("_res_", "GAsyncResult*");
				_tmp26_ = _tmp25_;
				vala_map_set (_tmp23_, (gpointer) ((gintptr) _tmp24_), _tmp26_);
				_vala_ccode_node_unref0 (_tmp26_);
				_tmp27_ = carg_map;
				if (_tmp27_ != NULL) {
					ValaMap* _tmp28_;
					gint _tmp29_;
					ValaCCodeIdentifier* _tmp30_;
					ValaCCodeIdentifier* _tmp31_;
					_tmp28_ = carg_map;
					_tmp29_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, 0.1, FALSE);
					_tmp30_ = vala_ccode_identifier_new ("_res_");
					_tmp31_ = _tmp30_;
					vala_map_set (_tmp28_, (gpointer) ((gintptr) _tmp29_), (ValaCCodeExpression*) _tmp31_);
					_vala_ccode_node_unref0 (_tmp31_);
				}
			}
		}
	}
	_tmp32_ = m;
	_tmp33_ = decl_space;
	_tmp34_ = cparam_map;
	_tmp35_ = func;
	_tmp36_ = vdeclarator;
	_tmp37_ = carg_map;
	_tmp38_ = vcall;
	_tmp39_ = direction;
	VALA_CCODE_BASE_MODULE_CLASS (vala_gasync_module_parent_class)->generate_cparameters ((ValaCCodeBaseModule*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GTK_MODULE, ValaGtkModule), _tmp32_, _tmp33_, _tmp34_, _tmp35_, _tmp36_, _tmp37_, _tmp38_, _tmp39_);
}


gchar* vala_gasync_module_generate_async_callback_wrapper (ValaGAsyncModule* self) {
	gchar* result = NULL;
	gchar* async_callback_wrapper_func = NULL;
	gchar* _tmp0_;
	const gchar* _tmp1_;
	gboolean _tmp2_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp3_;
	ValaCCodeFunction* _tmp4_;
	ValaCCodeFunction* _tmp5_;
	ValaCCodeFunction* _tmp6_;
	ValaCCodeParameter* _tmp7_;
	ValaCCodeParameter* _tmp8_;
	ValaCCodeFunction* _tmp9_;
	ValaCCodeParameter* _tmp10_;
	ValaCCodeParameter* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaCCodeParameter* _tmp13_;
	ValaCCodeParameter* _tmp14_;
	ValaCCodeFunction* _tmp15_;
	ValaCCodeFunctionCall* res_ref = NULL;
	ValaCCodeIdentifier* _tmp16_;
	ValaCCodeIdentifier* _tmp17_;
	ValaCCodeFunctionCall* _tmp18_;
	ValaCCodeFunctionCall* _tmp19_;
	ValaCCodeFunctionCall* _tmp20_;
	ValaCCodeIdentifier* _tmp21_;
	ValaCCodeIdentifier* _tmp22_;
	ValaCCodeFunctionCall* ccall = NULL;
	ValaCodeContext* _tmp23_;
	ValaCodeContext* _tmp24_;
	gboolean _tmp25_;
	ValaCCodeFunctionCall* _tmp32_;
	ValaCCodeIdentifier* _tmp33_;
	ValaCCodeIdentifier* _tmp34_;
	ValaCCodeFunctionCall* _tmp35_;
	ValaCCodeFunctionCall* _tmp36_;
	ValaCCodeFunctionCall* _tmp37_;
	ValaCCodeIdentifier* _tmp38_;
	ValaCCodeIdentifier* _tmp39_;
	ValaCCodeFunction* _tmp40_;
	ValaCCodeFunction* _tmp41_;
	ValaCCodeFunctionCall* _tmp42_;
	ValaCodeContext* _tmp43_;
	ValaCodeContext* _tmp44_;
	gboolean _tmp45_;
	ValaCCodeIdentifier* _tmp55_;
	ValaCCodeIdentifier* _tmp56_;
	ValaCCodeFunctionCall* _tmp57_;
	ValaCCodeFunctionCall* _tmp58_;
	ValaCCodeIdentifier* _tmp59_;
	ValaCCodeIdentifier* _tmp60_;
	ValaCCodeFunction* _tmp61_;
	ValaCCodeFunction* _tmp62_;
	ValaCCodeFunctionCall* _tmp63_;
	ValaCCodeFile* _tmp64_;
	ValaCCodeFunction* _tmp65_;
	ValaCCodeFile* _tmp66_;
	ValaCCodeFunction* _tmp67_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = g_strdup ("_vala_g_async_ready_callback");
	async_callback_wrapper_func = _tmp0_;
	_tmp1_ = async_callback_wrapper_func;
	_tmp2_ = vala_ccode_base_module_add_wrapper ((ValaCCodeBaseModule*) self, _tmp1_);
	if (!_tmp2_) {
		result = async_callback_wrapper_func;
		return result;
	}
	_tmp3_ = async_callback_wrapper_func;
	_tmp4_ = vala_ccode_function_new (_tmp3_, "void");
	function = _tmp4_;
	_tmp5_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp5_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp6_ = function;
	_tmp7_ = vala_ccode_parameter_new ("*source_object", "GObject");
	_tmp8_ = _tmp7_;
	vala_ccode_function_add_parameter (_tmp6_, _tmp8_);
	_vala_ccode_node_unref0 (_tmp8_);
	_tmp9_ = function;
	_tmp10_ = vala_ccode_parameter_new ("*res", "GAsyncResult");
	_tmp11_ = _tmp10_;
	vala_ccode_function_add_parameter (_tmp9_, _tmp11_);
	_vala_ccode_node_unref0 (_tmp11_);
	_tmp12_ = function;
	_tmp13_ = vala_ccode_parameter_new ("*user_data", "void");
	_tmp14_ = _tmp13_;
	vala_ccode_function_add_parameter (_tmp12_, _tmp14_);
	_vala_ccode_node_unref0 (_tmp14_);
	_tmp15_ = function;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp15_);
	_tmp16_ = vala_ccode_identifier_new ("g_object_ref");
	_tmp17_ = _tmp16_;
	_tmp18_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp17_);
	_tmp19_ = _tmp18_;
	_vala_ccode_node_unref0 (_tmp17_);
	res_ref = _tmp19_;
	_tmp20_ = res_ref;
	_tmp21_ = vala_ccode_identifier_new ("res");
	_tmp22_ = _tmp21_;
	vala_ccode_function_call_add_argument (_tmp20_, (ValaCCodeExpression*) _tmp22_);
	_vala_ccode_node_unref0 (_tmp22_);
	ccall = NULL;
	_tmp23_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp24_ = _tmp23_;
	_tmp25_ = vala_code_context_require_glib_version (_tmp24_, 2, 36);
	if (_tmp25_) {
		ValaCCodeIdentifier* _tmp26_;
		ValaCCodeIdentifier* _tmp27_;
		ValaCCodeFunctionCall* _tmp28_;
		_tmp26_ = vala_ccode_identifier_new ("g_task_return_pointer");
		_tmp27_ = _tmp26_;
		_tmp28_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp27_);
		_vala_ccode_node_unref0 (ccall);
		ccall = _tmp28_;
		_vala_ccode_node_unref0 (_tmp27_);
	} else {
		ValaCCodeIdentifier* _tmp29_;
		ValaCCodeIdentifier* _tmp30_;
		ValaCCodeFunctionCall* _tmp31_;
		_tmp29_ = vala_ccode_identifier_new ("g_simple_async_result_set_op_res_gpointer");
		_tmp30_ = _tmp29_;
		_tmp31_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp30_);
		_vala_ccode_node_unref0 (ccall);
		ccall = _tmp31_;
		_vala_ccode_node_unref0 (_tmp30_);
	}
	_tmp32_ = ccall;
	_tmp33_ = vala_ccode_identifier_new ("user_data");
	_tmp34_ = _tmp33_;
	vala_ccode_function_call_add_argument (_tmp32_, (ValaCCodeExpression*) _tmp34_);
	_vala_ccode_node_unref0 (_tmp34_);
	_tmp35_ = ccall;
	_tmp36_ = res_ref;
	vala_ccode_function_call_add_argument (_tmp35_, (ValaCCodeExpression*) _tmp36_);
	_tmp37_ = ccall;
	_tmp38_ = vala_ccode_identifier_new ("g_object_unref");
	_tmp39_ = _tmp38_;
	vala_ccode_function_call_add_argument (_tmp37_, (ValaCCodeExpression*) _tmp39_);
	_vala_ccode_node_unref0 (_tmp39_);
	_tmp40_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp41_ = _tmp40_;
	_tmp42_ = ccall;
	vala_ccode_function_add_expression (_tmp41_, (ValaCCodeExpression*) _tmp42_);
	_tmp43_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp44_ = _tmp43_;
	_tmp45_ = vala_code_context_require_glib_version (_tmp44_, 2, 36);
	if (!_tmp45_) {
		ValaCCodeIdentifier* _tmp46_;
		ValaCCodeIdentifier* _tmp47_;
		ValaCCodeFunctionCall* _tmp48_;
		ValaCCodeFunctionCall* _tmp49_;
		ValaCCodeIdentifier* _tmp50_;
		ValaCCodeIdentifier* _tmp51_;
		ValaCCodeFunction* _tmp52_;
		ValaCCodeFunction* _tmp53_;
		ValaCCodeFunctionCall* _tmp54_;
		_tmp46_ = vala_ccode_identifier_new ("g_simple_async_result_complete");
		_tmp47_ = _tmp46_;
		_tmp48_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp47_);
		_vala_ccode_node_unref0 (ccall);
		ccall = _tmp48_;
		_vala_ccode_node_unref0 (_tmp47_);
		_tmp49_ = ccall;
		_tmp50_ = vala_ccode_identifier_new ("user_data");
		_tmp51_ = _tmp50_;
		vala_ccode_function_call_add_argument (_tmp49_, (ValaCCodeExpression*) _tmp51_);
		_vala_ccode_node_unref0 (_tmp51_);
		_tmp52_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp53_ = _tmp52_;
		_tmp54_ = ccall;
		vala_ccode_function_add_expression (_tmp53_, (ValaCCodeExpression*) _tmp54_);
	}
	_tmp55_ = vala_ccode_identifier_new ("g_object_unref");
	_tmp56_ = _tmp55_;
	_tmp57_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp56_);
	_vala_ccode_node_unref0 (ccall);
	ccall = _tmp57_;
	_vala_ccode_node_unref0 (_tmp56_);
	_tmp58_ = ccall;
	_tmp59_ = vala_ccode_identifier_new ("user_data");
	_tmp60_ = _tmp59_;
	vala_ccode_function_call_add_argument (_tmp58_, (ValaCCodeExpression*) _tmp60_);
	_vala_ccode_node_unref0 (_tmp60_);
	_tmp61_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp62_ = _tmp61_;
	_tmp63_ = ccall;
	vala_ccode_function_add_expression (_tmp62_, (ValaCCodeExpression*) _tmp63_);
	vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
	_tmp64_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp65_ = function;
	vala_ccode_file_add_function_declaration (_tmp64_, _tmp65_);
	_tmp66_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp67_ = function;
	vala_ccode_file_add_function (_tmp66_, _tmp67_);
	result = async_callback_wrapper_func;
	_vala_ccode_node_unref0 (ccall);
	_vala_ccode_node_unref0 (res_ref);
	_vala_ccode_node_unref0 (function);
	return result;
}


ValaGAsyncModule* vala_gasync_module_construct (GType object_type) {
	ValaGAsyncModule* self = NULL;
	self = (ValaGAsyncModule*) vala_gtk_module_construct (object_type);
	return self;
}


ValaGAsyncModule* vala_gasync_module_new (void) {
	return vala_gasync_module_construct (VALA_TYPE_GASYNC_MODULE);
}


static void vala_gasync_module_class_init (ValaGAsyncModuleClass * klass) {
	vala_gasync_module_parent_class = g_type_class_peek_parent (klass);
	((ValaCCodeBaseModuleClass *) klass)->generate_method_declaration = (void (*) (ValaCCodeBaseModule *, ValaMethod*, ValaCCodeFile*)) vala_gasync_module_real_generate_method_declaration;
	((ValaCodeVisitorClass *) klass)->visit_method = (void (*) (ValaCodeVisitor *, ValaMethod*)) vala_gasync_module_real_visit_method;
	((ValaCodeVisitorClass *) klass)->visit_creation_method = (void (*) (ValaCodeVisitor *, ValaCreationMethod*)) vala_gasync_module_real_visit_creation_method;
	((ValaCCodeBaseModuleClass *) klass)->generate_ready_function = (gchar* (*) (ValaCCodeBaseModule *, ValaMethod*)) vala_gasync_module_real_generate_ready_function;
	((ValaGTypeModuleClass *) klass)->generate_virtual_method_declaration = (void (*) (ValaGTypeModule *, ValaMethod*, ValaCCodeFile*, ValaCCodeStruct*)) vala_gasync_module_real_generate_virtual_method_declaration;
	((ValaCodeVisitorClass *) klass)->visit_yield_statement = (void (*) (ValaCodeVisitor *, ValaYieldStatement*)) vala_gasync_module_real_visit_yield_statement;
	((ValaGErrorModuleClass *) klass)->return_with_exception = (void (*) (ValaGErrorModule *, ValaCCodeExpression*)) vala_gasync_module_real_return_with_exception;
	((ValaCodeVisitorClass *) klass)->visit_return_statement = (void (*) (ValaCodeVisitor *, ValaReturnStatement*)) vala_gasync_module_real_visit_return_statement;
	((ValaCCodeBaseModuleClass *) klass)->generate_cparameters = (void (*) (ValaCCodeBaseModule *, ValaMethod*, ValaCCodeFile*, ValaMap*, ValaCCodeFunction*, ValaCCodeFunctionDeclarator*, ValaMap*, ValaCCodeFunctionCall*, gint)) vala_gasync_module_real_generate_cparameters;
}


static void vala_gasync_module_instance_init (ValaGAsyncModule * self) {
}


GType vala_gasync_module_get_type (void) {
	static volatile gsize vala_gasync_module_type_id__volatile = 0;
	if (g_once_init_enter (&vala_gasync_module_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ValaGAsyncModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gasync_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGAsyncModule), 0, (GInstanceInitFunc) vala_gasync_module_instance_init, NULL };
		GType vala_gasync_module_type_id;
		vala_gasync_module_type_id = g_type_register_static (VALA_TYPE_GTK_MODULE, "ValaGAsyncModule", &g_define_type_info, 0);
		g_once_init_leave (&vala_gasync_module_type_id__volatile, vala_gasync_module_type_id);
	}
	return vala_gasync_module_type_id__volatile;
}



