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

/* valaccodemethodmodule.vala
 *
 * Copyright (C) 2007-2010  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>
 *	Raffaele Sandrini <raffaele@sandrini.ch>
 */

#include <glib.h>
#include <glib-object.h>
#include <vala.h>
#include <valaccode.h>
#include <valagee.h>
#include <stdlib.h>
#include <string.h>
#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_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
#define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_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;
#define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL)))
typedef struct _ValaCCodeBaseModuleEmitContextPrivate ValaCCodeBaseModuleEmitContextPrivate;
#define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

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 _ValaCCodeMethodModulePrivate {
	gboolean ellipses_to_valist;
};

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_ccode_method_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;
#define VALA_CCODE_METHOD_MODULE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModulePrivate))
enum  {
	VALA_CCODE_METHOD_MODULE_DUMMY_PROPERTY
};
static gboolean vala_ccode_method_module_real_method_has_wrapper (ValaCCodeBaseModule* base, ValaMethod* method);
static gchar* vala_ccode_method_module_get_creturn_type (ValaCCodeMethodModule* self, ValaMethod* m, const gchar* default_value);
gchar* vala_ccode_base_module_get_ccode_type (ValaCodeNode* node);
static gboolean vala_ccode_method_module_is_gtypeinstance_creation_method (ValaCCodeMethodModule* self, ValaMethod* m);
void vala_ccode_method_module_generate_method_result_declaration (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map);
static void vala_ccode_method_module_real_generate_method_result_declaration (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map);
gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);
void vala_ccode_base_module_generate_type_declaration (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeFile* decl_space);
gint vala_ccode_base_module_get_param_pos (ValaCCodeBaseModule* self, gdouble param_pos, gboolean ellipsis);
ValaCCodeExpression* vala_ccode_base_module_get_result_cexpression (ValaCCodeBaseModule* self, const gchar* cname);
gboolean vala_ccode_base_module_get_ccode_array_length (ValaCodeNode* node);
gchar* vala_ccode_base_module_get_ccode_array_length_type (ValaCodeNode* node);
gchar* vala_ccode_base_module_get_array_length_cname (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim);
gdouble vala_ccode_base_module_get_ccode_array_length_pos (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name);
gchar* vala_ccode_base_module_get_delegate_target_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname);
gdouble vala_ccode_base_module_get_ccode_delegate_target_pos (ValaCodeNode* node);
gchar* vala_ccode_base_module_get_delegate_target_destroy_notify_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname);
void vala_ccode_method_module_complete_async (ValaCCodeMethodModule* self);
ValaCodeContext* vala_ccode_base_module_get_context (ValaCCodeBaseModule* self);
ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);
static void vala_ccode_method_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);
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);
gchar* vala_ccode_base_module_get_ccode_real_name (ValaSymbol* sym);
gchar* vala_ccode_base_module_get_ccode_constructv_name (ValaCreationMethod* m);
static void vala_ccode_method_module_register_plugin_types (ValaCCodeMethodModule* self, ValaSymbol* sym, ValaSet* registered_types);
static void vala_ccode_method_module_register_plugin_type (ValaCCodeMethodModule* self, ValaObjectTypeSymbol* type_symbol, ValaSet* registered_types);
gchar* vala_ccode_base_module_get_ccode_lower_case_name (ValaCodeNode* node, const gchar* infix);
gchar* vala_gd_bus_module_get_dbus_name (ValaTypeSymbol* symbol);
gchar* vala_ccode_base_module_get_ccode_lower_case_prefix (ValaSymbol* sym);
static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base, ValaMethod* m);
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_line (ValaCCodeBaseModule* self, ValaSourceReference* source_reference);
void vala_ccode_base_module_check_type (ValaCCodeBaseModule* self, ValaDataType* type);
ValaTypeSymbol* vala_ccode_base_module_get_current_type_symbol (ValaCCodeBaseModule* self);
void vala_ccode_base_module_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func);
void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self);
gchar* vala_ccode_base_module_get_ccode_const_name (ValaCodeNode* node);
ValaBlock* vala_ccode_base_module_get_current_closure_block (ValaCCodeBaseModule* self);
gint vala_ccode_base_module_get_block_id (ValaCCodeBaseModule* self, ValaBlock* b);
ValaBlock* vala_ccode_base_module_next_closure_block (ValaCCodeBaseModule* self, ValaSymbol* sym);
ValaDataType* vala_ccode_base_module_get_data_type_for_symbol (ValaTypeSymbol* sym);
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);
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);
G_GNUC_INTERNAL GType vala_glib_value_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
static void vala_ccode_method_module_create_method_type_check_statement (ValaCCodeMethodModule* self, ValaMethod* m, ValaDataType* return_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);
gchar* vala_ccode_base_module_get_variable_cname (ValaCCodeBaseModule* self, const gchar* name);
ValaCCodeExpression* vala_ccode_base_module_default_value_for_type (ValaCCodeBaseModule* self, ValaDataType* type, gboolean initializer_expression);
gchar* vala_ccode_base_module_get_ccode_delegate_target_name (ValaVariable* variable);
ValaCCodeExpression* vala_ccode_base_module_get_this_cexpression (ValaCCodeBaseModule* self);
ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self);
static void vala_ccode_method_module_create_precondition_statement (ValaCCodeMethodModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaExpression* precondition);
gboolean vala_ccode_base_module_get_current_method_inner_error (ValaCCodeBaseModule* self);
void vala_ccode_base_module_return_default_value (ValaCCodeBaseModule* self, ValaDataType* return_type);
void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self);
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);
void vala_ccode_base_module_pop_line (ValaCCodeBaseModule* self);
ValaCCodeParameter* vala_ccode_method_module_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map);
static ValaCCodeParameter* vala_ccode_method_module_real_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map);
gdouble vala_ccode_base_module_get_ccode_pos (ValaParameter* param);
static void vala_ccode_method_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);
gdouble vala_ccode_base_module_get_ccode_instance_pos (ValaCodeNode* node);
gboolean vala_ccode_base_module_get_ccode_finish_instance (ValaCodeNode* node);
static ValaTypeSymbol* vala_ccode_method_module_find_parent_type (ValaCCodeMethodModule* self, ValaSymbol* sym);
gchar* vala_ccode_base_module_get_ccode_upper_case_name (ValaSymbol* sym, const gchar* infix);
gchar* vala_ccode_base_module_get_ccode_vfunc_name (ValaMethod* m);
void vala_ccode_base_module_create_postcondition_statement (ValaCCodeBaseModule* self, ValaExpression* postcondition);
void vala_ccode_base_module_create_type_check_statement (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr);
static void vala_ccode_method_module_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m);
static void vala_ccode_method_module_create_aux_constructor (ValaCCodeMethodModule* self, ValaCreationMethod* m, const gchar* func_name, gboolean self_as_first_parameter);
gchar* vala_ccode_base_module_get_ccode_type_id (ValaCodeNode* node);
ValaCCodeMethodModule* vala_ccode_method_module_construct (GType object_type);
ValaCCodeStructModule* vala_ccode_struct_module_construct (GType object_type);
static void vala_ccode_method_module_finalize (ValaCodeVisitor * obj);


static gboolean vala_ccode_method_module_real_method_has_wrapper (ValaCCodeBaseModule* base, ValaMethod* method) {
	ValaCCodeMethodModule * self;
	gboolean result = FALSE;
	ValaMethod* _tmp0_;
	ValaAttribute* _tmp1_;
	ValaAttribute* _tmp2_;
	gboolean _tmp3_;
	self = (ValaCCodeMethodModule*) base;
	g_return_val_if_fail (method != NULL, FALSE);
	_tmp0_ = method;
	_tmp1_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp0_, "NoWrapper");
	_tmp2_ = _tmp1_;
	_tmp3_ = _tmp2_ == NULL;
	_vala_code_node_unref0 (_tmp2_);
	result = _tmp3_;
	return result;
}


static gchar* vala_ccode_method_module_get_creturn_type (ValaCCodeMethodModule* self, ValaMethod* m, const gchar* default_value) {
	gchar* result = NULL;
	gchar* type = NULL;
	ValaMethod* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (m != NULL, NULL);
	g_return_val_if_fail (default_value != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp0_);
	type = _tmp1_;
	_tmp2_ = type;
	if (_tmp2_ == NULL) {
		const gchar* _tmp3_;
		gchar* _tmp4_;
		_tmp3_ = default_value;
		_tmp4_ = g_strdup (_tmp3_);
		result = _tmp4_;
		_g_free0 (type);
		return result;
	}
	result = type;
	return result;
}


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


static gboolean vala_ccode_method_module_is_gtypeinstance_creation_method (ValaCCodeMethodModule* self, ValaMethod* m) {
	gboolean result = FALSE;
	gboolean _result_ = FALSE;
	ValaClass* cl = NULL;
	ValaMethod* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaClass* _tmp3_;
	gboolean _tmp4_ = FALSE;
	gboolean _tmp5_ = FALSE;
	ValaMethod* _tmp6_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (m != NULL, FALSE);
	_result_ = FALSE;
	_tmp0_ = m;
	_tmp1_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp2_) : NULL);
	cl = _tmp3_;
	_tmp6_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_CREATION_METHOD)) {
		ValaClass* _tmp7_;
		_tmp7_ = cl;
		_tmp5_ = _tmp7_ != NULL;
	} else {
		_tmp5_ = FALSE;
	}
	if (_tmp5_) {
		ValaClass* _tmp8_;
		gboolean _tmp9_;
		gboolean _tmp10_;
		_tmp8_ = cl;
		_tmp9_ = vala_class_get_is_compact (_tmp8_);
		_tmp10_ = _tmp9_;
		_tmp4_ = !_tmp10_;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		_result_ = TRUE;
	}
	result = _result_;
	_vala_code_node_unref0 (cl);
	return result;
}


static void vala_ccode_method_module_real_generate_method_result_declaration (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map) {
	ValaDataType* creturn_type = NULL;
	ValaMethod* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaDataType* _tmp3_;
	ValaMethod* _tmp4_;
	ValaCCodeFunction* _tmp17_;
	ValaMethod* _tmp18_;
	ValaDataType* _tmp19_;
	gchar* _tmp20_;
	gchar* _tmp21_;
	gchar* _tmp22_;
	gchar* _tmp23_;
	ValaMethod* _tmp24_;
	ValaDataType* _tmp25_;
	ValaDataType* _tmp26_;
	ValaCCodeFile* _tmp27_;
	ValaMethod* _tmp28_;
	ValaDataType* _tmp29_;
	ValaDataType* _tmp30_;
	gboolean _tmp31_;
	gboolean _tmp152_ = FALSE;
	gboolean _tmp153_ = FALSE;
	ValaMethod* _tmp154_;
	ValaList* _tmp155_;
	ValaList* _tmp156_;
	gint _tmp157_;
	gint _tmp158_;
	gboolean _tmp159_;
	g_return_if_fail (m != NULL);
	g_return_if_fail (decl_space != NULL);
	g_return_if_fail (cfunc != NULL);
	g_return_if_fail (cparam_map != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_callable_get_return_type ((ValaCallable*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (_tmp2_);
	creturn_type = _tmp3_;
	_tmp4_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_CREATION_METHOD)) {
		ValaClass* cl = NULL;
		ValaMethod* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		ValaClass* _tmp8_;
		ValaClass* _tmp9_;
		_tmp5_ = m;
		_tmp6_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp7_) : NULL);
		cl = _tmp8_;
		_tmp9_ = cl;
		if (_tmp9_ != NULL) {
			ValaClass* _tmp10_;
			ValaObjectType* _tmp11_;
			_tmp10_ = cl;
			_tmp11_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp10_);
			_vala_code_node_unref0 (creturn_type);
			creturn_type = (ValaDataType*) _tmp11_;
		}
		_vala_code_node_unref0 (cl);
	} else {
		ValaMethod* _tmp12_;
		ValaDataType* _tmp13_;
		ValaDataType* _tmp14_;
		gboolean _tmp15_;
		_tmp12_ = m;
		_tmp13_ = vala_callable_get_return_type ((ValaCallable*) _tmp12_);
		_tmp14_ = _tmp13_;
		_tmp15_ = vala_data_type_is_real_non_null_struct_type (_tmp14_);
		if (_tmp15_) {
			ValaVoidType* _tmp16_;
			_tmp16_ = vala_void_type_new (NULL);
			_vala_code_node_unref0 (creturn_type);
			creturn_type = (ValaDataType*) _tmp16_;
		}
	}
	_tmp17_ = cfunc;
	_tmp18_ = m;
	_tmp19_ = creturn_type;
	_tmp20_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp19_);
	_tmp21_ = _tmp20_;
	_tmp22_ = vala_ccode_method_module_get_creturn_type (self, _tmp18_, _tmp21_);
	_tmp23_ = _tmp22_;
	vala_ccode_function_set_return_type (_tmp17_, _tmp23_);
	_g_free0 (_tmp23_);
	_g_free0 (_tmp21_);
	_tmp24_ = m;
	_tmp25_ = vala_callable_get_return_type ((ValaCallable*) _tmp24_);
	_tmp26_ = _tmp25_;
	_tmp27_ = decl_space;
	vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp26_, _tmp27_);
	_tmp28_ = m;
	_tmp29_ = vala_callable_get_return_type ((ValaCallable*) _tmp28_);
	_tmp30_ = _tmp29_;
	_tmp31_ = vala_data_type_is_real_non_null_struct_type (_tmp30_);
	if (_tmp31_) {
		ValaCCodeParameter* cparam = NULL;
		ValaMethod* _tmp32_;
		ValaDataType* _tmp33_;
		ValaDataType* _tmp34_;
		gchar* _tmp35_;
		gchar* _tmp36_;
		gchar* _tmp37_;
		gchar* _tmp38_;
		ValaCCodeParameter* _tmp39_;
		ValaCCodeParameter* _tmp40_;
		ValaMap* _tmp41_;
		gint _tmp42_;
		ValaCCodeParameter* _tmp43_;
		ValaMap* _tmp44_;
		_tmp32_ = m;
		_tmp33_ = vala_callable_get_return_type ((ValaCallable*) _tmp32_);
		_tmp34_ = _tmp33_;
		_tmp35_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp34_);
		_tmp36_ = _tmp35_;
		_tmp37_ = g_strconcat (_tmp36_, "*", NULL);
		_tmp38_ = _tmp37_;
		_tmp39_ = vala_ccode_parameter_new ("result", _tmp38_);
		_tmp40_ = _tmp39_;
		_g_free0 (_tmp38_);
		_g_free0 (_tmp36_);
		cparam = _tmp40_;
		_tmp41_ = cparam_map;
		_tmp42_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE);
		_tmp43_ = cparam;
		vala_map_set (_tmp41_, (gpointer) ((gintptr) _tmp42_), _tmp43_);
		_tmp44_ = carg_map;
		if (_tmp44_ != NULL) {
			ValaMap* _tmp45_;
			gint _tmp46_;
			ValaCCodeExpression* _tmp47_;
			ValaCCodeExpression* _tmp48_;
			_tmp45_ = carg_map;
			_tmp46_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE);
			_tmp47_ = vala_ccode_base_module_get_result_cexpression ((ValaCCodeBaseModule*) self, "result");
			_tmp48_ = _tmp47_;
			vala_map_set (_tmp45_, (gpointer) ((gintptr) _tmp46_), _tmp48_);
			_vala_ccode_node_unref0 (_tmp48_);
		}
		_vala_ccode_node_unref0 (cparam);
	} else {
		gboolean _tmp49_ = FALSE;
		ValaMethod* _tmp50_;
		gboolean _tmp51_;
		_tmp50_ = m;
		_tmp51_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp50_);
		if (_tmp51_) {
			ValaMethod* _tmp52_;
			ValaDataType* _tmp53_;
			ValaDataType* _tmp54_;
			_tmp52_ = m;
			_tmp53_ = vala_callable_get_return_type ((ValaCallable*) _tmp52_);
			_tmp54_ = _tmp53_;
			_tmp49_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp54_, VALA_TYPE_ARRAY_TYPE);
		} else {
			_tmp49_ = FALSE;
		}
		if (_tmp49_) {
			ValaArrayType* array_type = NULL;
			ValaMethod* _tmp55_;
			ValaDataType* _tmp56_;
			ValaDataType* _tmp57_;
			ValaArrayType* _tmp58_;
			gchar* _tmp59_ = NULL;
			ValaMethod* _tmp60_;
			gchar* _tmp61_;
			gchar* _tmp62_;
			gboolean _tmp63_;
			gchar* array_length_type = NULL;
			gchar* _tmp67_;
			const gchar* _tmp68_;
			gchar* _tmp69_;
			_tmp55_ = m;
			_tmp56_ = vala_callable_get_return_type ((ValaCallable*) _tmp55_);
			_tmp57_ = _tmp56_;
			_tmp58_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp57_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			array_type = _tmp58_;
			_tmp60_ = m;
			_tmp61_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp60_);
			_tmp62_ = _tmp61_;
			_tmp63_ = _tmp62_ != NULL;
			_g_free0 (_tmp62_);
			if (_tmp63_) {
				ValaMethod* _tmp64_;
				gchar* _tmp65_;
				_tmp64_ = m;
				_tmp65_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp64_);
				_g_free0 (_tmp59_);
				_tmp59_ = _tmp65_;
			} else {
				gchar* _tmp66_;
				_tmp66_ = g_strdup ("int");
				_g_free0 (_tmp59_);
				_tmp59_ = _tmp66_;
			}
			_tmp67_ = g_strdup (_tmp59_);
			array_length_type = _tmp67_;
			_tmp68_ = array_length_type;
			_tmp69_ = g_strconcat (_tmp68_, "*", NULL);
			_g_free0 (array_length_type);
			array_length_type = _tmp69_;
			{
				gint dim = 0;
				dim = 1;
				{
					gboolean _tmp70_ = FALSE;
					_tmp70_ = TRUE;
					while (TRUE) {
						gint _tmp72_;
						ValaArrayType* _tmp73_;
						gint _tmp74_;
						gint _tmp75_;
						ValaCCodeParameter* cparam = NULL;
						gint _tmp76_;
						gchar* _tmp77_;
						gchar* _tmp78_;
						const gchar* _tmp79_;
						ValaCCodeParameter* _tmp80_;
						ValaCCodeParameter* _tmp81_;
						ValaMap* _tmp82_;
						ValaMethod* _tmp83_;
						gdouble _tmp84_;
						gint _tmp85_;
						gint _tmp86_;
						ValaCCodeParameter* _tmp87_;
						ValaMap* _tmp88_;
						if (!_tmp70_) {
							gint _tmp71_;
							_tmp71_ = dim;
							dim = _tmp71_ + 1;
						}
						_tmp70_ = FALSE;
						_tmp72_ = dim;
						_tmp73_ = array_type;
						_tmp74_ = vala_array_type_get_rank (_tmp73_);
						_tmp75_ = _tmp74_;
						if (!(_tmp72_ <= _tmp75_)) {
							break;
						}
						_tmp76_ = dim;
						_tmp77_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", _tmp76_);
						_tmp78_ = _tmp77_;
						_tmp79_ = array_length_type;
						_tmp80_ = vala_ccode_parameter_new (_tmp78_, _tmp79_);
						_tmp81_ = _tmp80_;
						_g_free0 (_tmp78_);
						cparam = _tmp81_;
						_tmp82_ = cparam_map;
						_tmp83_ = m;
						_tmp84_ = vala_ccode_base_module_get_ccode_array_length_pos ((ValaCodeNode*) _tmp83_);
						_tmp85_ = dim;
						_tmp86_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp84_ + (0.01 * _tmp85_), FALSE);
						_tmp87_ = cparam;
						vala_map_set (_tmp82_, (gpointer) ((gintptr) _tmp86_), _tmp87_);
						_tmp88_ = carg_map;
						if (_tmp88_ != NULL) {
							ValaMap* _tmp89_;
							ValaMethod* _tmp90_;
							gdouble _tmp91_;
							gint _tmp92_;
							gint _tmp93_;
							ValaCCodeParameter* _tmp94_;
							const gchar* _tmp95_;
							const gchar* _tmp96_;
							ValaCCodeExpression* _tmp97_;
							ValaCCodeExpression* _tmp98_;
							_tmp89_ = carg_map;
							_tmp90_ = m;
							_tmp91_ = vala_ccode_base_module_get_ccode_array_length_pos ((ValaCodeNode*) _tmp90_);
							_tmp92_ = dim;
							_tmp93_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp91_ + (0.01 * _tmp92_), FALSE);
							_tmp94_ = cparam;
							_tmp95_ = vala_ccode_parameter_get_name (_tmp94_);
							_tmp96_ = _tmp95_;
							_tmp97_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp96_);
							_tmp98_ = _tmp97_;
							vala_map_set (_tmp89_, (gpointer) ((gintptr) _tmp93_), _tmp98_);
							_vala_ccode_node_unref0 (_tmp98_);
						}
						_vala_ccode_node_unref0 (cparam);
					}
				}
			}
			_g_free0 (array_length_type);
			_g_free0 (_tmp59_);
			_vala_code_node_unref0 (array_type);
		} else {
			ValaMethod* _tmp99_;
			ValaDataType* _tmp100_;
			ValaDataType* _tmp101_;
			_tmp99_ = m;
			_tmp100_ = vala_callable_get_return_type ((ValaCallable*) _tmp99_);
			_tmp101_ = _tmp100_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp101_, VALA_TYPE_DELEGATE_TYPE)) {
				ValaDelegateType* deleg_type = NULL;
				ValaMethod* _tmp102_;
				ValaDataType* _tmp103_;
				ValaDataType* _tmp104_;
				ValaDelegateType* _tmp105_;
				ValaDelegate* d = NULL;
				ValaDelegateType* _tmp106_;
				ValaDelegate* _tmp107_;
				ValaDelegate* _tmp108_;
				ValaDelegate* _tmp109_;
				ValaDelegate* _tmp110_;
				gboolean _tmp111_;
				gboolean _tmp112_;
				_tmp102_ = m;
				_tmp103_ = vala_callable_get_return_type ((ValaCallable*) _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_code_node_ref0 (_tmp108_);
				d = _tmp109_;
				_tmp110_ = d;
				_tmp111_ = vala_delegate_get_has_target (_tmp110_);
				_tmp112_ = _tmp111_;
				if (_tmp112_) {
					ValaCCodeParameter* cparam = NULL;
					gchar* _tmp113_;
					gchar* _tmp114_;
					ValaCCodeParameter* _tmp115_;
					ValaCCodeParameter* _tmp116_;
					ValaMap* _tmp117_;
					ValaMethod* _tmp118_;
					gdouble _tmp119_;
					gint _tmp120_;
					ValaCCodeParameter* _tmp121_;
					ValaMap* _tmp122_;
					ValaDelegateType* _tmp132_;
					gboolean _tmp133_;
					_tmp113_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, "result");
					_tmp114_ = _tmp113_;
					_tmp115_ = vala_ccode_parameter_new (_tmp114_, "void**");
					_tmp116_ = _tmp115_;
					_g_free0 (_tmp114_);
					cparam = _tmp116_;
					_tmp117_ = cparam_map;
					_tmp118_ = m;
					_tmp119_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp118_);
					_tmp120_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp119_, FALSE);
					_tmp121_ = cparam;
					vala_map_set (_tmp117_, (gpointer) ((gintptr) _tmp120_), _tmp121_);
					_tmp122_ = carg_map;
					if (_tmp122_ != NULL) {
						ValaMap* _tmp123_;
						ValaMethod* _tmp124_;
						gdouble _tmp125_;
						gint _tmp126_;
						ValaCCodeParameter* _tmp127_;
						const gchar* _tmp128_;
						const gchar* _tmp129_;
						ValaCCodeExpression* _tmp130_;
						ValaCCodeExpression* _tmp131_;
						_tmp123_ = carg_map;
						_tmp124_ = m;
						_tmp125_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp124_);
						_tmp126_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp125_, FALSE);
						_tmp127_ = cparam;
						_tmp128_ = vala_ccode_parameter_get_name (_tmp127_);
						_tmp129_ = _tmp128_;
						_tmp130_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp129_);
						_tmp131_ = _tmp130_;
						vala_map_set (_tmp123_, (gpointer) ((gintptr) _tmp126_), _tmp131_);
						_vala_ccode_node_unref0 (_tmp131_);
					}
					_tmp132_ = deleg_type;
					_tmp133_ = vala_data_type_is_disposable ((ValaDataType*) _tmp132_);
					if (_tmp133_) {
						gchar* _tmp134_;
						gchar* _tmp135_;
						ValaCCodeParameter* _tmp136_;
						ValaMap* _tmp137_;
						ValaMethod* _tmp138_;
						gdouble _tmp139_;
						gint _tmp140_;
						ValaCCodeParameter* _tmp141_;
						ValaMap* _tmp142_;
						_tmp134_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, "result");
						_tmp135_ = _tmp134_;
						_tmp136_ = vala_ccode_parameter_new (_tmp135_, "GDestroyNotify*");
						_vala_ccode_node_unref0 (cparam);
						cparam = _tmp136_;
						_g_free0 (_tmp135_);
						_tmp137_ = cparam_map;
						_tmp138_ = m;
						_tmp139_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp138_);
						_tmp140_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp139_ + 0.01, FALSE);
						_tmp141_ = cparam;
						vala_map_set (_tmp137_, (gpointer) ((gintptr) _tmp140_), _tmp141_);
						_tmp142_ = carg_map;
						if (_tmp142_ != NULL) {
							ValaMap* _tmp143_;
							ValaMethod* _tmp144_;
							gdouble _tmp145_;
							gint _tmp146_;
							ValaCCodeParameter* _tmp147_;
							const gchar* _tmp148_;
							const gchar* _tmp149_;
							ValaCCodeExpression* _tmp150_;
							ValaCCodeExpression* _tmp151_;
							_tmp143_ = carg_map;
							_tmp144_ = m;
							_tmp145_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp144_);
							_tmp146_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp145_ + 0.01, FALSE);
							_tmp147_ = cparam;
							_tmp148_ = vala_ccode_parameter_get_name (_tmp147_);
							_tmp149_ = _tmp148_;
							_tmp150_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp149_);
							_tmp151_ = _tmp150_;
							vala_map_set (_tmp143_, (gpointer) ((gintptr) _tmp146_), _tmp151_);
							_vala_ccode_node_unref0 (_tmp151_);
						}
					}
					_vala_ccode_node_unref0 (cparam);
				}
				_vala_code_node_unref0 (d);
				_vala_code_node_unref0 (deleg_type);
			}
		}
	}
	_tmp154_ = m;
	_tmp155_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp154_);
	_tmp156_ = _tmp155_;
	_tmp157_ = vala_collection_get_size ((ValaCollection*) _tmp156_);
	_tmp158_ = _tmp157_;
	_tmp159_ = _tmp158_ > 0;
	_vala_iterable_unref0 (_tmp156_);
	if (_tmp159_) {
		_tmp153_ = TRUE;
	} else {
		gboolean _tmp160_ = FALSE;
		ValaMethod* _tmp161_;
		ValaMethod* _tmp162_;
		ValaMethod* _tmp163_;
		_tmp161_ = m;
		_tmp162_ = vala_method_get_base_method (_tmp161_);
		_tmp163_ = _tmp162_;
		if (_tmp163_ != NULL) {
			ValaMethod* _tmp164_;
			ValaMethod* _tmp165_;
			ValaMethod* _tmp166_;
			ValaList* _tmp167_;
			ValaList* _tmp168_;
			gint _tmp169_;
			gint _tmp170_;
			_tmp164_ = m;
			_tmp165_ = vala_method_get_base_method (_tmp164_);
			_tmp166_ = _tmp165_;
			_tmp167_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp166_);
			_tmp168_ = _tmp167_;
			_tmp169_ = vala_collection_get_size ((ValaCollection*) _tmp168_);
			_tmp170_ = _tmp169_;
			_tmp160_ = _tmp170_ > 0;
			_vala_iterable_unref0 (_tmp168_);
		} else {
			_tmp160_ = FALSE;
		}
		_tmp153_ = _tmp160_;
	}
	if (_tmp153_) {
		_tmp152_ = TRUE;
	} else {
		gboolean _tmp171_ = FALSE;
		ValaMethod* _tmp172_;
		ValaMethod* _tmp173_;
		ValaMethod* _tmp174_;
		_tmp172_ = m;
		_tmp173_ = vala_method_get_base_interface_method (_tmp172_);
		_tmp174_ = _tmp173_;
		if (_tmp174_ != NULL) {
			ValaMethod* _tmp175_;
			ValaMethod* _tmp176_;
			ValaMethod* _tmp177_;
			ValaList* _tmp178_;
			ValaList* _tmp179_;
			gint _tmp180_;
			gint _tmp181_;
			_tmp175_ = m;
			_tmp176_ = vala_method_get_base_interface_method (_tmp175_);
			_tmp177_ = _tmp176_;
			_tmp178_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp177_);
			_tmp179_ = _tmp178_;
			_tmp180_ = vala_collection_get_size ((ValaCollection*) _tmp179_);
			_tmp181_ = _tmp180_;
			_tmp171_ = _tmp181_ > 0;
			_vala_iterable_unref0 (_tmp179_);
		} else {
			_tmp171_ = FALSE;
		}
		_tmp152_ = _tmp171_;
	}
	if (_tmp152_) {
		ValaCCodeParameter* cparam = NULL;
		ValaCCodeParameter* _tmp195_;
		ValaMap* _tmp196_;
		gint _tmp197_;
		ValaCCodeParameter* _tmp198_;
		ValaMap* _tmp199_;
		{
			ValaList* _error_type_list = NULL;
			ValaMethod* _tmp182_;
			ValaList* _tmp183_;
			gint _error_type_size = 0;
			ValaList* _tmp184_;
			gint _tmp185_;
			gint _tmp186_;
			gint _error_type_index = 0;
			_tmp182_ = m;
			_tmp183_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp182_);
			_error_type_list = _tmp183_;
			_tmp184_ = _error_type_list;
			_tmp185_ = vala_collection_get_size ((ValaCollection*) _tmp184_);
			_tmp186_ = _tmp185_;
			_error_type_size = _tmp186_;
			_error_type_index = -1;
			while (TRUE) {
				gint _tmp187_;
				gint _tmp188_;
				gint _tmp189_;
				ValaDataType* error_type = NULL;
				ValaList* _tmp190_;
				gint _tmp191_;
				gpointer _tmp192_;
				ValaDataType* _tmp193_;
				ValaCCodeFile* _tmp194_;
				_tmp187_ = _error_type_index;
				_error_type_index = _tmp187_ + 1;
				_tmp188_ = _error_type_index;
				_tmp189_ = _error_type_size;
				if (!(_tmp188_ < _tmp189_)) {
					break;
				}
				_tmp190_ = _error_type_list;
				_tmp191_ = _error_type_index;
				_tmp192_ = vala_list_get (_tmp190_, _tmp191_);
				error_type = (ValaDataType*) _tmp192_;
				_tmp193_ = error_type;
				_tmp194_ = decl_space;
				vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp193_, _tmp194_);
				_vala_code_node_unref0 (error_type);
			}
			_vala_iterable_unref0 (_error_type_list);
		}
		_tmp195_ = vala_ccode_parameter_new ("error", "GError**");
		cparam = _tmp195_;
		_tmp196_ = cparam_map;
		_tmp197_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, FALSE);
		_tmp198_ = cparam;
		vala_map_set (_tmp196_, (gpointer) ((gintptr) _tmp197_), _tmp198_);
		_tmp199_ = carg_map;
		if (_tmp199_ != NULL) {
			ValaMap* _tmp200_;
			gint _tmp201_;
			ValaCCodeParameter* _tmp202_;
			const gchar* _tmp203_;
			const gchar* _tmp204_;
			ValaCCodeIdentifier* _tmp205_;
			ValaCCodeIdentifier* _tmp206_;
			_tmp200_ = carg_map;
			_tmp201_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, FALSE);
			_tmp202_ = cparam;
			_tmp203_ = vala_ccode_parameter_get_name (_tmp202_);
			_tmp204_ = _tmp203_;
			_tmp205_ = vala_ccode_identifier_new (_tmp204_);
			_tmp206_ = _tmp205_;
			vala_map_set (_tmp200_, (gpointer) ((gintptr) _tmp201_), (ValaCCodeExpression*) _tmp206_);
			_vala_ccode_node_unref0 (_tmp206_);
		}
		_vala_ccode_node_unref0 (cparam);
	}
	_vala_code_node_unref0 (creturn_type);
}


void vala_ccode_method_module_generate_method_result_declaration (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_METHOD_MODULE_GET_CLASS (self)->generate_method_result_declaration (self, m, decl_space, cfunc, cparam_map, carg_map);
}


void vala_ccode_method_module_complete_async (ValaCCodeMethodModule* self) {
	ValaCCodeIdentifier* data_var = NULL;
	ValaCCodeIdentifier* _tmp0_;
	ValaCCodeMemberAccess* async_result_expr = NULL;
	ValaCCodeIdentifier* _tmp1_;
	ValaCCodeMemberAccess* _tmp2_;
	ValaCodeContext* _tmp3_;
	ValaCodeContext* _tmp4_;
	gboolean _tmp5_;
	ValaCCodeFunctionCall* unref = NULL;
	ValaCCodeIdentifier* _tmp104_;
	ValaCCodeIdentifier* _tmp105_;
	ValaCCodeFunctionCall* _tmp106_;
	ValaCCodeFunctionCall* _tmp107_;
	ValaCCodeMemberAccess* _tmp108_;
	ValaCCodeFunction* _tmp109_;
	ValaCCodeFunction* _tmp110_;
	ValaCCodeFunction* _tmp111_;
	ValaCCodeFunction* _tmp112_;
	ValaCCodeConstant* _tmp113_;
	ValaCCodeConstant* _tmp114_;
	g_return_if_fail (self != NULL);
	_tmp0_ = vala_ccode_identifier_new ("_data_");
	data_var = _tmp0_;
	_tmp1_ = data_var;
	_tmp2_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp1_, "_async_result");
	async_result_expr = _tmp2_;
	_tmp3_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_code_context_require_glib_version (_tmp4_, 2, 36);
	if (_tmp5_) {
		ValaCCodeFunctionCall* finish_call = NULL;
		ValaCCodeIdentifier* _tmp6_;
		ValaCCodeIdentifier* _tmp7_;
		ValaCCodeFunctionCall* _tmp8_;
		ValaCCodeFunctionCall* _tmp9_;
		ValaCCodeFunctionCall* _tmp10_;
		ValaCCodeMemberAccess* _tmp11_;
		ValaCCodeFunctionCall* _tmp12_;
		ValaCCodeIdentifier* _tmp13_;
		ValaCCodeFunctionCall* _tmp14_;
		ValaCCodeConstant* _tmp15_;
		ValaCCodeConstant* _tmp16_;
		ValaCCodeFunction* _tmp17_;
		ValaCCodeFunction* _tmp18_;
		ValaCCodeFunctionCall* _tmp19_;
		ValaCCodeMemberAccess* state = NULL;
		ValaCCodeIdentifier* _tmp20_;
		ValaCCodeMemberAccess* _tmp21_;
		ValaCCodeConstant* zero = NULL;
		ValaCCodeConstant* _tmp22_;
		ValaCCodeBinaryExpression* state_is_not_zero = NULL;
		ValaCCodeMemberAccess* _tmp23_;
		ValaCCodeConstant* _tmp24_;
		ValaCCodeBinaryExpression* _tmp25_;
		ValaCCodeFunction* _tmp26_;
		ValaCCodeFunction* _tmp27_;
		ValaCCodeBinaryExpression* _tmp28_;
		ValaCCodeBinaryExpression* task_is_complete = NULL;
		ValaCodeContext* _tmp29_;
		ValaCodeContext* _tmp30_;
		gboolean _tmp31_;
		ValaCCodeFunction* _tmp48_;
		ValaCCodeFunction* _tmp49_;
		ValaCCodeBinaryExpression* _tmp50_;
		ValaCCodeFunctionCall* task_context = NULL;
		ValaCCodeIdentifier* _tmp51_;
		ValaCCodeIdentifier* _tmp52_;
		ValaCCodeFunctionCall* _tmp53_;
		ValaCCodeFunctionCall* _tmp54_;
		ValaCCodeFunctionCall* _tmp55_;
		ValaCCodeMemberAccess* _tmp56_;
		ValaCCodeFunctionCall* iterate_context = NULL;
		ValaCCodeIdentifier* _tmp57_;
		ValaCCodeIdentifier* _tmp58_;
		ValaCCodeFunctionCall* _tmp59_;
		ValaCCodeFunctionCall* _tmp60_;
		ValaCCodeFunctionCall* _tmp61_;
		ValaCCodeFunctionCall* _tmp62_;
		ValaCCodeFunctionCall* _tmp63_;
		ValaCCodeConstant* _tmp64_;
		ValaCCodeConstant* _tmp65_;
		ValaCCodeFunction* _tmp66_;
		ValaCCodeFunction* _tmp67_;
		ValaCCodeFunctionCall* _tmp68_;
		ValaCCodeFunction* _tmp69_;
		ValaCCodeFunction* _tmp70_;
		ValaCCodeFunction* _tmp71_;
		ValaCCodeFunction* _tmp72_;
		_tmp6_ = vala_ccode_identifier_new ("g_task_return_pointer");
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp7_);
		_tmp9_ = _tmp8_;
		_vala_ccode_node_unref0 (_tmp7_);
		finish_call = _tmp9_;
		_tmp10_ = finish_call;
		_tmp11_ = async_result_expr;
		vala_ccode_function_call_add_argument (_tmp10_, (ValaCCodeExpression*) _tmp11_);
		_tmp12_ = finish_call;
		_tmp13_ = data_var;
		vala_ccode_function_call_add_argument (_tmp12_, (ValaCCodeExpression*) _tmp13_);
		_tmp14_ = finish_call;
		_tmp15_ = vala_ccode_constant_new ("NULL");
		_tmp16_ = _tmp15_;
		vala_ccode_function_call_add_argument (_tmp14_, (ValaCCodeExpression*) _tmp16_);
		_vala_ccode_node_unref0 (_tmp16_);
		_tmp17_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp18_ = _tmp17_;
		_tmp19_ = finish_call;
		vala_ccode_function_add_expression (_tmp18_, (ValaCCodeExpression*) _tmp19_);
		_tmp20_ = data_var;
		_tmp21_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp20_, "_state_");
		state = _tmp21_;
		_tmp22_ = vala_ccode_constant_new ("0");
		zero = _tmp22_;
		_tmp23_ = state;
		_tmp24_ = zero;
		_tmp25_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) _tmp23_, (ValaCCodeExpression*) _tmp24_);
		state_is_not_zero = _tmp25_;
		_tmp26_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp27_ = _tmp26_;
		_tmp28_ = state_is_not_zero;
		vala_ccode_function_open_if (_tmp27_, (ValaCCodeExpression*) _tmp28_);
		_tmp29_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp30_ = _tmp29_;
		_tmp31_ = vala_code_context_require_glib_version (_tmp30_, 2, 44);
		if (_tmp31_) {
			ValaCCodeFunctionCall* task_complete = NULL;
			ValaCCodeIdentifier* _tmp32_;
			ValaCCodeIdentifier* _tmp33_;
			ValaCCodeFunctionCall* _tmp34_;
			ValaCCodeFunctionCall* _tmp35_;
			ValaCCodeFunctionCall* _tmp36_;
			ValaCCodeMemberAccess* _tmp37_;
			ValaCCodeFunctionCall* _tmp38_;
			ValaCCodeConstant* _tmp39_;
			ValaCCodeConstant* _tmp40_;
			ValaCCodeBinaryExpression* _tmp41_;
			_tmp32_ = vala_ccode_identifier_new ("g_task_get_completed");
			_tmp33_ = _tmp32_;
			_tmp34_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp33_);
			_tmp35_ = _tmp34_;
			_vala_ccode_node_unref0 (_tmp33_);
			task_complete = _tmp35_;
			_tmp36_ = task_complete;
			_tmp37_ = async_result_expr;
			vala_ccode_function_call_add_argument (_tmp36_, (ValaCCodeExpression*) _tmp37_);
			_tmp38_ = task_complete;
			_tmp39_ = vala_ccode_constant_new ("TRUE");
			_tmp40_ = _tmp39_;
			_tmp41_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) _tmp38_, (ValaCCodeExpression*) _tmp40_);
			_vala_ccode_node_unref0 (task_is_complete);
			task_is_complete = _tmp41_;
			_vala_ccode_node_unref0 (_tmp40_);
			_vala_ccode_node_unref0 (task_complete);
		} else {
			ValaCCodeMemberAccess* task_complete = NULL;
			ValaCCodeIdentifier* _tmp42_;
			ValaCCodeMemberAccess* _tmp43_;
			ValaCCodeMemberAccess* _tmp44_;
			ValaCCodeConstant* _tmp45_;
			ValaCCodeConstant* _tmp46_;
			ValaCCodeBinaryExpression* _tmp47_;
			_tmp42_ = data_var;
			_tmp43_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp42_, "_task_complete_");
			task_complete = _tmp43_;
			_tmp44_ = task_complete;
			_tmp45_ = vala_ccode_constant_new ("TRUE");
			_tmp46_ = _tmp45_;
			_tmp47_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) _tmp44_, (ValaCCodeExpression*) _tmp46_);
			_vala_ccode_node_unref0 (task_is_complete);
			task_is_complete = _tmp47_;
			_vala_ccode_node_unref0 (_tmp46_);
			_vala_ccode_node_unref0 (task_complete);
		}
		_tmp48_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp49_ = _tmp48_;
		_tmp50_ = task_is_complete;
		vala_ccode_function_open_while (_tmp49_, (ValaCCodeExpression*) _tmp50_);
		_tmp51_ = vala_ccode_identifier_new ("g_task_get_context");
		_tmp52_ = _tmp51_;
		_tmp53_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp52_);
		_tmp54_ = _tmp53_;
		_vala_ccode_node_unref0 (_tmp52_);
		task_context = _tmp54_;
		_tmp55_ = task_context;
		_tmp56_ = async_result_expr;
		vala_ccode_function_call_add_argument (_tmp55_, (ValaCCodeExpression*) _tmp56_);
		_tmp57_ = vala_ccode_identifier_new ("g_main_context_iteration");
		_tmp58_ = _tmp57_;
		_tmp59_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp58_);
		_tmp60_ = _tmp59_;
		_vala_ccode_node_unref0 (_tmp58_);
		iterate_context = _tmp60_;
		_tmp61_ = iterate_context;
		_tmp62_ = task_context;
		vala_ccode_function_call_add_argument (_tmp61_, (ValaCCodeExpression*) _tmp62_);
		_tmp63_ = iterate_context;
		_tmp64_ = vala_ccode_constant_new ("TRUE");
		_tmp65_ = _tmp64_;
		vala_ccode_function_call_add_argument (_tmp63_, (ValaCCodeExpression*) _tmp65_);
		_vala_ccode_node_unref0 (_tmp65_);
		_tmp66_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp67_ = _tmp66_;
		_tmp68_ = iterate_context;
		vala_ccode_function_add_expression (_tmp67_, (ValaCCodeExpression*) _tmp68_);
		_tmp69_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp70_ = _tmp69_;
		vala_ccode_function_close (_tmp70_);
		_tmp71_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp72_ = _tmp71_;
		vala_ccode_function_close (_tmp72_);
		_vala_ccode_node_unref0 (iterate_context);
		_vala_ccode_node_unref0 (task_context);
		_vala_ccode_node_unref0 (task_is_complete);
		_vala_ccode_node_unref0 (state_is_not_zero);
		_vala_ccode_node_unref0 (zero);
		_vala_ccode_node_unref0 (state);
		_vala_ccode_node_unref0 (finish_call);
	} else {
		ValaCCodeMemberAccess* state = NULL;
		ValaCCodeIdentifier* _tmp73_;
		ValaCCodeMemberAccess* _tmp74_;
		ValaCCodeConstant* zero = NULL;
		ValaCCodeConstant* _tmp75_;
		ValaCCodeBinaryExpression* state_is_zero = NULL;
		ValaCCodeMemberAccess* _tmp76_;
		ValaCCodeConstant* _tmp77_;
		ValaCCodeBinaryExpression* _tmp78_;
		ValaCCodeFunction* _tmp79_;
		ValaCCodeFunction* _tmp80_;
		ValaCCodeBinaryExpression* _tmp81_;
		ValaCCodeFunctionCall* idle_call = NULL;
		ValaCCodeIdentifier* _tmp82_;
		ValaCCodeIdentifier* _tmp83_;
		ValaCCodeFunctionCall* _tmp84_;
		ValaCCodeFunctionCall* _tmp85_;
		ValaCCodeFunctionCall* _tmp86_;
		ValaCCodeMemberAccess* _tmp87_;
		ValaCCodeFunction* _tmp88_;
		ValaCCodeFunction* _tmp89_;
		ValaCCodeFunctionCall* _tmp90_;
		ValaCCodeFunction* _tmp91_;
		ValaCCodeFunction* _tmp92_;
		ValaCCodeFunctionCall* direct_call = NULL;
		ValaCCodeIdentifier* _tmp93_;
		ValaCCodeIdentifier* _tmp94_;
		ValaCCodeFunctionCall* _tmp95_;
		ValaCCodeFunctionCall* _tmp96_;
		ValaCCodeFunctionCall* _tmp97_;
		ValaCCodeMemberAccess* _tmp98_;
		ValaCCodeFunction* _tmp99_;
		ValaCCodeFunction* _tmp100_;
		ValaCCodeFunctionCall* _tmp101_;
		ValaCCodeFunction* _tmp102_;
		ValaCCodeFunction* _tmp103_;
		_tmp73_ = data_var;
		_tmp74_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp73_, "_state_");
		state = _tmp74_;
		_tmp75_ = vala_ccode_constant_new ("0");
		zero = _tmp75_;
		_tmp76_ = state;
		_tmp77_ = zero;
		_tmp78_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp76_, (ValaCCodeExpression*) _tmp77_);
		state_is_zero = _tmp78_;
		_tmp79_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp80_ = _tmp79_;
		_tmp81_ = state_is_zero;
		vala_ccode_function_open_if (_tmp80_, (ValaCCodeExpression*) _tmp81_);
		_tmp82_ = vala_ccode_identifier_new ("g_simple_async_result_complete_in_idle");
		_tmp83_ = _tmp82_;
		_tmp84_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp83_);
		_tmp85_ = _tmp84_;
		_vala_ccode_node_unref0 (_tmp83_);
		idle_call = _tmp85_;
		_tmp86_ = idle_call;
		_tmp87_ = async_result_expr;
		vala_ccode_function_call_add_argument (_tmp86_, (ValaCCodeExpression*) _tmp87_);
		_tmp88_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp89_ = _tmp88_;
		_tmp90_ = idle_call;
		vala_ccode_function_add_expression (_tmp89_, (ValaCCodeExpression*) _tmp90_);
		_tmp91_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp92_ = _tmp91_;
		vala_ccode_function_add_else (_tmp92_);
		_tmp93_ = vala_ccode_identifier_new ("g_simple_async_result_complete");
		_tmp94_ = _tmp93_;
		_tmp95_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp94_);
		_tmp96_ = _tmp95_;
		_vala_ccode_node_unref0 (_tmp94_);
		direct_call = _tmp96_;
		_tmp97_ = direct_call;
		_tmp98_ = async_result_expr;
		vala_ccode_function_call_add_argument (_tmp97_, (ValaCCodeExpression*) _tmp98_);
		_tmp99_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp100_ = _tmp99_;
		_tmp101_ = direct_call;
		vala_ccode_function_add_expression (_tmp100_, (ValaCCodeExpression*) _tmp101_);
		_tmp102_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp103_ = _tmp102_;
		vala_ccode_function_close (_tmp103_);
		_vala_ccode_node_unref0 (direct_call);
		_vala_ccode_node_unref0 (idle_call);
		_vala_ccode_node_unref0 (state_is_zero);
		_vala_ccode_node_unref0 (zero);
		_vala_ccode_node_unref0 (state);
	}
	_tmp104_ = vala_ccode_identifier_new ("g_object_unref");
	_tmp105_ = _tmp104_;
	_tmp106_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp105_);
	_tmp107_ = _tmp106_;
	_vala_ccode_node_unref0 (_tmp105_);
	unref = _tmp107_;
	_tmp108_ = async_result_expr;
	vala_ccode_function_call_add_argument (unref, (ValaCCodeExpression*) _tmp108_);
	_tmp109_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp110_ = _tmp109_;
	vala_ccode_function_add_expression (_tmp110_, (ValaCCodeExpression*) unref);
	_tmp111_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp112_ = _tmp111_;
	_tmp113_ = vala_ccode_constant_new ("FALSE");
	_tmp114_ = _tmp113_;
	vala_ccode_function_add_return (_tmp112_, (ValaCCodeExpression*) _tmp114_);
	_vala_ccode_node_unref0 (_tmp114_);
	_vala_ccode_node_unref0 (unref);
	_vala_ccode_node_unref0 (async_result_expr);
	_vala_ccode_node_unref0 (data_var);
}


static void vala_ccode_method_module_real_generate_method_declaration (ValaCCodeBaseModule* base, ValaMethod* m, ValaCCodeFile* decl_space) {
	ValaCCodeMethodModule * self;
	ValaMethod* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	ValaCCodeFile* _tmp3_;
	ValaMethod* _tmp4_;
	ValaMethod* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gboolean _tmp8_;
	gboolean _tmp9_;
	ValaCCodeFunction* function = NULL;
	ValaMethod* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	ValaCCodeFunction* _tmp13_;
	ValaCCodeFunction* _tmp14_;
	gboolean _tmp15_ = FALSE;
	ValaMethod* _tmp16_;
	gboolean _tmp17_;
	ValaMethod* _tmp47_;
	ValaVersionAttribute* _tmp48_;
	ValaVersionAttribute* _tmp49_;
	gboolean _tmp50_;
	gboolean _tmp51_;
	ValaHashMap* cparam_map = NULL;
	GHashFunc _tmp56_;
	GEqualFunc _tmp57_;
	GEqualFunc _tmp58_;
	ValaHashMap* _tmp59_;
	ValaHashMap* carg_map = NULL;
	GHashFunc _tmp60_;
	GEqualFunc _tmp61_;
	GEqualFunc _tmp62_;
	ValaHashMap* _tmp63_;
	ValaClass* cl = NULL;
	ValaMethod* _tmp64_;
	ValaSymbol* _tmp65_;
	ValaSymbol* _tmp66_;
	ValaClass* _tmp67_;
	gboolean _tmp68_ = FALSE;
	gboolean _tmp69_ = FALSE;
	ValaMethod* _tmp70_;
	ValaMethod* _tmp88_;
	gboolean _tmp89_;
	self = (ValaCCodeMethodModule*) base;
	g_return_if_fail (m != NULL);
	g_return_if_fail (decl_space != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_method_get_is_async_callback (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_) {
		return;
	}
	_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_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp10_);
	_tmp12_ = _tmp11_;
	_tmp13_ = vala_ccode_function_new (_tmp12_, "void");
	_tmp14_ = _tmp13_;
	_g_free0 (_tmp12_);
	function = _tmp14_;
	_tmp16_ = m;
	_tmp17_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp16_);
	if (_tmp17_) {
		ValaMethod* _tmp18_;
		gboolean _tmp19_;
		gboolean _tmp20_;
		_tmp18_ = m;
		_tmp19_ = vala_symbol_get_external ((ValaSymbol*) _tmp18_);
		_tmp20_ = _tmp19_;
		_tmp15_ = !_tmp20_;
	} else {
		_tmp15_ = FALSE;
	}
	if (_tmp15_) {
		ValaCCodeFunction* _tmp21_;
		ValaCCodeFunction* _tmp22_;
		ValaCCodeModifiers _tmp23_;
		ValaCCodeModifiers _tmp24_;
		ValaMethod* _tmp25_;
		gboolean _tmp26_;
		gboolean _tmp27_;
		_tmp21_ = function;
		_tmp22_ = function;
		_tmp23_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp22_);
		_tmp24_ = _tmp23_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp22_, _tmp24_ | VALA_CCODE_MODIFIERS_STATIC);
		_tmp25_ = m;
		_tmp26_ = vala_method_get_is_inline (_tmp25_);
		_tmp27_ = _tmp26_;
		if (_tmp27_) {
			ValaCCodeFunction* _tmp28_;
			ValaCCodeFunction* _tmp29_;
			ValaCCodeModifiers _tmp30_;
			ValaCCodeModifiers _tmp31_;
			_tmp28_ = function;
			_tmp29_ = function;
			_tmp30_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp29_);
			_tmp31_ = _tmp30_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp29_, _tmp31_ | VALA_CCODE_MODIFIERS_INLINE);
		}
	} else {
		gboolean _tmp32_ = FALSE;
		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_) {
			ValaMethod* _tmp40_;
			gboolean _tmp41_;
			gboolean _tmp42_;
			_tmp40_ = m;
			_tmp41_ = vala_symbol_get_external ((ValaSymbol*) _tmp40_);
			_tmp42_ = _tmp41_;
			_tmp32_ = !_tmp42_;
		} else {
			_tmp32_ = FALSE;
		}
		if (_tmp32_) {
			ValaCCodeFunction* _tmp43_;
			ValaCCodeFunction* _tmp44_;
			ValaCCodeModifiers _tmp45_;
			ValaCCodeModifiers _tmp46_;
			_tmp43_ = function;
			_tmp44_ = function;
			_tmp45_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp44_);
			_tmp46_ = _tmp45_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp44_, _tmp46_ | VALA_CCODE_MODIFIERS_INTERNAL);
		}
	}
	_tmp47_ = m;
	_tmp48_ = vala_symbol_get_version ((ValaSymbol*) _tmp47_);
	_tmp49_ = _tmp48_;
	_tmp50_ = vala_version_attribute_get_deprecated (_tmp49_);
	_tmp51_ = _tmp50_;
	if (_tmp51_) {
		ValaCCodeFunction* _tmp52_;
		ValaCCodeFunction* _tmp53_;
		ValaCCodeModifiers _tmp54_;
		ValaCCodeModifiers _tmp55_;
		_tmp52_ = function;
		_tmp53_ = function;
		_tmp54_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp53_);
		_tmp55_ = _tmp54_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp53_, _tmp55_ | VALA_CCODE_MODIFIERS_DEPRECATED);
	}
	_tmp56_ = g_direct_hash;
	_tmp57_ = g_direct_equal;
	_tmp58_ = g_direct_equal;
	_tmp59_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp56_, _tmp57_, _tmp58_);
	cparam_map = _tmp59_;
	_tmp60_ = g_direct_hash;
	_tmp61_ = g_direct_equal;
	_tmp62_ = g_direct_equal;
	_tmp63_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp60_, _tmp61_, _tmp62_);
	carg_map = _tmp63_;
	_tmp64_ = m;
	_tmp65_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp64_);
	_tmp66_ = _tmp65_;
	_tmp67_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp66_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp66_) : NULL);
	cl = _tmp67_;
	_tmp70_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp70_, VALA_TYPE_CREATION_METHOD)) {
		ValaClass* _tmp71_;
		_tmp71_ = cl;
		_tmp69_ = _tmp71_ != NULL;
	} else {
		_tmp69_ = FALSE;
	}
	if (_tmp69_) {
		ValaClass* _tmp72_;
		gboolean _tmp73_;
		gboolean _tmp74_;
		_tmp72_ = cl;
		_tmp73_ = vala_class_get_is_abstract (_tmp72_);
		_tmp74_ = _tmp73_;
		_tmp68_ = _tmp74_;
	} else {
		_tmp68_ = FALSE;
	}
	if (!_tmp68_) {
		gboolean etv_tmp = FALSE;
		gboolean _tmp75_;
		ValaMethod* _tmp76_;
		ValaCCodeFile* _tmp77_;
		ValaHashMap* _tmp78_;
		ValaCCodeFunction* _tmp79_;
		ValaHashMap* _tmp80_;
		ValaCCodeIdentifier* _tmp81_;
		ValaCCodeIdentifier* _tmp82_;
		ValaCCodeFunctionCall* _tmp83_;
		ValaCCodeFunctionCall* _tmp84_;
		gboolean _tmp85_;
		ValaCCodeFile* _tmp86_;
		ValaCCodeFunction* _tmp87_;
		_tmp75_ = self->priv->ellipses_to_valist;
		etv_tmp = _tmp75_;
		self->priv->ellipses_to_valist = FALSE;
		_tmp76_ = m;
		_tmp77_ = decl_space;
		_tmp78_ = cparam_map;
		_tmp79_ = function;
		_tmp80_ = carg_map;
		_tmp81_ = vala_ccode_identifier_new ("fake");
		_tmp82_ = _tmp81_;
		_tmp83_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp82_);
		_tmp84_ = _tmp83_;
		vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp76_, _tmp77_, (ValaMap*) _tmp78_, _tmp79_, NULL, (ValaMap*) _tmp80_, _tmp84_, 3);
		_vala_ccode_node_unref0 (_tmp84_);
		_vala_ccode_node_unref0 (_tmp82_);
		_tmp85_ = etv_tmp;
		self->priv->ellipses_to_valist = _tmp85_;
		_tmp86_ = decl_space;
		_tmp87_ = function;
		vala_ccode_file_add_function_declaration (_tmp86_, _tmp87_);
	}
	_tmp88_ = m;
	_tmp89_ = vala_ccode_method_module_is_gtypeinstance_creation_method (self, _tmp88_);
	if (_tmp89_) {
		ValaMethod* _tmp90_;
		gchar* _tmp91_;
		gchar* _tmp92_;
		ValaCCodeFunction* _tmp93_;
		ValaMethod* _tmp94_;
		gboolean _tmp95_;
		GHashFunc _tmp111_;
		GEqualFunc _tmp112_;
		GEqualFunc _tmp113_;
		ValaHashMap* _tmp114_;
		gboolean etv_tmp = FALSE;
		gboolean _tmp115_;
		ValaMethod* _tmp116_;
		ValaCCodeFile* _tmp117_;
		ValaHashMap* _tmp118_;
		ValaCCodeFunction* _tmp119_;
		gboolean _tmp120_;
		ValaCCodeFile* _tmp121_;
		ValaCCodeFunction* _tmp122_;
		ValaMethod* _tmp123_;
		gboolean _tmp124_;
		_tmp90_ = m;
		_tmp91_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp90_);
		_tmp92_ = _tmp91_;
		_tmp93_ = vala_ccode_function_new (_tmp92_, "void");
		_vala_ccode_node_unref0 (function);
		function = _tmp93_;
		_g_free0 (_tmp92_);
		_tmp94_ = m;
		_tmp95_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp94_);
		if (_tmp95_) {
			ValaCCodeFunction* _tmp96_;
			ValaCCodeFunction* _tmp97_;
			ValaCCodeModifiers _tmp98_;
			ValaCCodeModifiers _tmp99_;
			_tmp96_ = function;
			_tmp97_ = function;
			_tmp98_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp97_);
			_tmp99_ = _tmp98_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp97_, _tmp99_ | VALA_CCODE_MODIFIERS_STATIC);
		} else {
			gboolean _tmp100_ = FALSE;
			ValaCodeContext* _tmp101_;
			ValaCodeContext* _tmp102_;
			gboolean _tmp103_;
			gboolean _tmp104_;
			_tmp101_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
			_tmp102_ = _tmp101_;
			_tmp103_ = vala_code_context_get_hide_internal (_tmp102_);
			_tmp104_ = _tmp103_;
			if (_tmp104_) {
				ValaMethod* _tmp105_;
				gboolean _tmp106_;
				_tmp105_ = m;
				_tmp106_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp105_);
				_tmp100_ = _tmp106_;
			} else {
				_tmp100_ = FALSE;
			}
			if (_tmp100_) {
				ValaCCodeFunction* _tmp107_;
				ValaCCodeFunction* _tmp108_;
				ValaCCodeModifiers _tmp109_;
				ValaCCodeModifiers _tmp110_;
				_tmp107_ = function;
				_tmp108_ = function;
				_tmp109_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp108_);
				_tmp110_ = _tmp109_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp108_, _tmp110_ | VALA_CCODE_MODIFIERS_INTERNAL);
			}
		}
		_tmp111_ = g_direct_hash;
		_tmp112_ = g_direct_equal;
		_tmp113_ = g_direct_equal;
		_tmp114_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp111_, _tmp112_, _tmp113_);
		_vala_map_unref0 (cparam_map);
		cparam_map = _tmp114_;
		_tmp115_ = self->priv->ellipses_to_valist;
		etv_tmp = _tmp115_;
		self->priv->ellipses_to_valist = FALSE;
		_tmp116_ = m;
		_tmp117_ = decl_space;
		_tmp118_ = cparam_map;
		_tmp119_ = function;
		vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp116_, _tmp117_, (ValaMap*) _tmp118_, _tmp119_, NULL, NULL, NULL, 3);
		_tmp120_ = etv_tmp;
		self->priv->ellipses_to_valist = _tmp120_;
		_tmp121_ = decl_space;
		_tmp122_ = function;
		vala_ccode_file_add_function_declaration (_tmp121_, _tmp122_);
		_tmp123_ = m;
		_tmp124_ = vala_method_is_variadic (_tmp123_);
		if (_tmp124_) {
			ValaMethod* _tmp125_;
			gchar* _tmp126_;
			gchar* _tmp127_;
			ValaCCodeFunction* _tmp128_;
			GHashFunc _tmp129_;
			GEqualFunc _tmp130_;
			GEqualFunc _tmp131_;
			ValaHashMap* _tmp132_;
			ValaMethod* _tmp133_;
			ValaCCodeFile* _tmp134_;
			ValaHashMap* _tmp135_;
			ValaCCodeFunction* _tmp136_;
			ValaCCodeFile* _tmp137_;
			ValaCCodeFunction* _tmp138_;
			_tmp125_ = m;
			_tmp126_ = vala_ccode_base_module_get_ccode_constructv_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp125_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
			_tmp127_ = _tmp126_;
			_tmp128_ = vala_ccode_function_new (_tmp127_, "void");
			_vala_ccode_node_unref0 (function);
			function = _tmp128_;
			_g_free0 (_tmp127_);
			_tmp129_ = g_direct_hash;
			_tmp130_ = g_direct_equal;
			_tmp131_ = g_direct_equal;
			_tmp132_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp129_, _tmp130_, _tmp131_);
			_vala_map_unref0 (cparam_map);
			cparam_map = _tmp132_;
			_tmp133_ = m;
			_tmp134_ = decl_space;
			_tmp135_ = cparam_map;
			_tmp136_ = function;
			vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp133_, _tmp134_, (ValaMap*) _tmp135_, _tmp136_, NULL, NULL, NULL, 3);
			_tmp137_ = decl_space;
			_tmp138_ = function;
			vala_ccode_file_add_function_declaration (_tmp137_, _tmp138_);
		}
	}
	_vala_code_node_unref0 (cl);
	_vala_map_unref0 (carg_map);
	_vala_map_unref0 (cparam_map);
	_vala_ccode_node_unref0 (function);
}


static void vala_ccode_method_module_register_plugin_types (ValaCCodeMethodModule* self, ValaSymbol* sym, ValaSet* registered_types) {
	ValaNamespace* ns = NULL;
	ValaSymbol* _tmp0_;
	ValaNamespace* _tmp1_;
	ValaClass* cl = NULL;
	ValaSymbol* _tmp2_;
	ValaClass* _tmp3_;
	ValaInterface* iface = NULL;
	ValaSymbol* _tmp4_;
	ValaInterface* _tmp5_;
	ValaNamespace* _tmp6_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (sym != NULL);
	g_return_if_fail (registered_types != NULL);
	_tmp0_ = sym;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_NAMESPACE) ? ((ValaNamespace*) _tmp0_) : NULL);
	ns = _tmp1_;
	_tmp2_ = sym;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp2_) : NULL);
	cl = _tmp3_;
	_tmp4_ = sym;
	_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_INTERFACE) ? ((ValaInterface*) _tmp4_) : NULL);
	iface = _tmp5_;
	_tmp6_ = ns;
	if (_tmp6_ != NULL) {
		{
			ValaList* _ns_ns_list = NULL;
			ValaNamespace* _tmp7_;
			ValaList* _tmp8_;
			gint _ns_ns_size = 0;
			ValaList* _tmp9_;
			gint _tmp10_;
			gint _tmp11_;
			gint _ns_ns_index = 0;
			_tmp7_ = ns;
			_tmp8_ = vala_namespace_get_namespaces (_tmp7_);
			_ns_ns_list = _tmp8_;
			_tmp9_ = _ns_ns_list;
			_tmp10_ = vala_collection_get_size ((ValaCollection*) _tmp9_);
			_tmp11_ = _tmp10_;
			_ns_ns_size = _tmp11_;
			_ns_ns_index = -1;
			while (TRUE) {
				gint _tmp12_;
				gint _tmp13_;
				gint _tmp14_;
				ValaNamespace* ns_ns = NULL;
				ValaList* _tmp15_;
				gint _tmp16_;
				gpointer _tmp17_;
				ValaNamespace* _tmp18_;
				ValaSet* _tmp19_;
				_tmp12_ = _ns_ns_index;
				_ns_ns_index = _tmp12_ + 1;
				_tmp13_ = _ns_ns_index;
				_tmp14_ = _ns_ns_size;
				if (!(_tmp13_ < _tmp14_)) {
					break;
				}
				_tmp15_ = _ns_ns_list;
				_tmp16_ = _ns_ns_index;
				_tmp17_ = vala_list_get (_tmp15_, _tmp16_);
				ns_ns = (ValaNamespace*) _tmp17_;
				_tmp18_ = ns_ns;
				_tmp19_ = registered_types;
				vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp18_, _tmp19_);
				_vala_code_node_unref0 (ns_ns);
			}
			_vala_iterable_unref0 (_ns_ns_list);
		}
		{
			ValaList* _ns_cl_list = NULL;
			ValaNamespace* _tmp20_;
			ValaList* _tmp21_;
			gint _ns_cl_size = 0;
			ValaList* _tmp22_;
			gint _tmp23_;
			gint _tmp24_;
			gint _ns_cl_index = 0;
			_tmp20_ = ns;
			_tmp21_ = vala_namespace_get_classes (_tmp20_);
			_ns_cl_list = _tmp21_;
			_tmp22_ = _ns_cl_list;
			_tmp23_ = vala_collection_get_size ((ValaCollection*) _tmp22_);
			_tmp24_ = _tmp23_;
			_ns_cl_size = _tmp24_;
			_ns_cl_index = -1;
			while (TRUE) {
				gint _tmp25_;
				gint _tmp26_;
				gint _tmp27_;
				ValaClass* ns_cl = NULL;
				ValaList* _tmp28_;
				gint _tmp29_;
				gpointer _tmp30_;
				ValaClass* _tmp31_;
				ValaSet* _tmp32_;
				_tmp25_ = _ns_cl_index;
				_ns_cl_index = _tmp25_ + 1;
				_tmp26_ = _ns_cl_index;
				_tmp27_ = _ns_cl_size;
				if (!(_tmp26_ < _tmp27_)) {
					break;
				}
				_tmp28_ = _ns_cl_list;
				_tmp29_ = _ns_cl_index;
				_tmp30_ = vala_list_get (_tmp28_, _tmp29_);
				ns_cl = (ValaClass*) _tmp30_;
				_tmp31_ = ns_cl;
				_tmp32_ = registered_types;
				vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp31_, _tmp32_);
				_vala_code_node_unref0 (ns_cl);
			}
			_vala_iterable_unref0 (_ns_cl_list);
		}
		{
			ValaList* _ns_iface_list = NULL;
			ValaNamespace* _tmp33_;
			ValaList* _tmp34_;
			gint _ns_iface_size = 0;
			ValaList* _tmp35_;
			gint _tmp36_;
			gint _tmp37_;
			gint _ns_iface_index = 0;
			_tmp33_ = ns;
			_tmp34_ = vala_namespace_get_interfaces (_tmp33_);
			_ns_iface_list = _tmp34_;
			_tmp35_ = _ns_iface_list;
			_tmp36_ = vala_collection_get_size ((ValaCollection*) _tmp35_);
			_tmp37_ = _tmp36_;
			_ns_iface_size = _tmp37_;
			_ns_iface_index = -1;
			while (TRUE) {
				gint _tmp38_;
				gint _tmp39_;
				gint _tmp40_;
				ValaInterface* ns_iface = NULL;
				ValaList* _tmp41_;
				gint _tmp42_;
				gpointer _tmp43_;
				ValaInterface* _tmp44_;
				ValaSet* _tmp45_;
				_tmp38_ = _ns_iface_index;
				_ns_iface_index = _tmp38_ + 1;
				_tmp39_ = _ns_iface_index;
				_tmp40_ = _ns_iface_size;
				if (!(_tmp39_ < _tmp40_)) {
					break;
				}
				_tmp41_ = _ns_iface_list;
				_tmp42_ = _ns_iface_index;
				_tmp43_ = vala_list_get (_tmp41_, _tmp42_);
				ns_iface = (ValaInterface*) _tmp43_;
				_tmp44_ = ns_iface;
				_tmp45_ = registered_types;
				vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp44_, _tmp45_);
				_vala_code_node_unref0 (ns_iface);
			}
			_vala_iterable_unref0 (_ns_iface_list);
		}
	} else {
		ValaClass* _tmp46_;
		_tmp46_ = cl;
		if (_tmp46_ != NULL) {
			ValaClass* _tmp47_;
			ValaSet* _tmp48_;
			_tmp47_ = cl;
			_tmp48_ = registered_types;
			vala_ccode_method_module_register_plugin_type (self, (ValaObjectTypeSymbol*) _tmp47_, _tmp48_);
			{
				ValaList* _cl_cl_list = NULL;
				ValaClass* _tmp49_;
				ValaList* _tmp50_;
				gint _cl_cl_size = 0;
				ValaList* _tmp51_;
				gint _tmp52_;
				gint _tmp53_;
				gint _cl_cl_index = 0;
				_tmp49_ = cl;
				_tmp50_ = vala_class_get_classes (_tmp49_);
				_cl_cl_list = _tmp50_;
				_tmp51_ = _cl_cl_list;
				_tmp52_ = vala_collection_get_size ((ValaCollection*) _tmp51_);
				_tmp53_ = _tmp52_;
				_cl_cl_size = _tmp53_;
				_cl_cl_index = -1;
				while (TRUE) {
					gint _tmp54_;
					gint _tmp55_;
					gint _tmp56_;
					ValaClass* cl_cl = NULL;
					ValaList* _tmp57_;
					gint _tmp58_;
					gpointer _tmp59_;
					ValaClass* _tmp60_;
					ValaSet* _tmp61_;
					_tmp54_ = _cl_cl_index;
					_cl_cl_index = _tmp54_ + 1;
					_tmp55_ = _cl_cl_index;
					_tmp56_ = _cl_cl_size;
					if (!(_tmp55_ < _tmp56_)) {
						break;
					}
					_tmp57_ = _cl_cl_list;
					_tmp58_ = _cl_cl_index;
					_tmp59_ = vala_list_get (_tmp57_, _tmp58_);
					cl_cl = (ValaClass*) _tmp59_;
					_tmp60_ = cl_cl;
					_tmp61_ = registered_types;
					vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp60_, _tmp61_);
					_vala_code_node_unref0 (cl_cl);
				}
				_vala_iterable_unref0 (_cl_cl_list);
			}
		} else {
			ValaInterface* _tmp62_;
			_tmp62_ = iface;
			if (_tmp62_ != NULL) {
				ValaInterface* _tmp63_;
				ValaSet* _tmp64_;
				_tmp63_ = iface;
				_tmp64_ = registered_types;
				vala_ccode_method_module_register_plugin_type (self, (ValaObjectTypeSymbol*) _tmp63_, _tmp64_);
				{
					ValaList* _iface_cl_list = NULL;
					ValaInterface* _tmp65_;
					ValaList* _tmp66_;
					gint _iface_cl_size = 0;
					ValaList* _tmp67_;
					gint _tmp68_;
					gint _tmp69_;
					gint _iface_cl_index = 0;
					_tmp65_ = iface;
					_tmp66_ = vala_interface_get_classes (_tmp65_);
					_iface_cl_list = _tmp66_;
					_tmp67_ = _iface_cl_list;
					_tmp68_ = vala_collection_get_size ((ValaCollection*) _tmp67_);
					_tmp69_ = _tmp68_;
					_iface_cl_size = _tmp69_;
					_iface_cl_index = -1;
					while (TRUE) {
						gint _tmp70_;
						gint _tmp71_;
						gint _tmp72_;
						ValaClass* iface_cl = NULL;
						ValaList* _tmp73_;
						gint _tmp74_;
						gpointer _tmp75_;
						ValaClass* _tmp76_;
						ValaSet* _tmp77_;
						_tmp70_ = _iface_cl_index;
						_iface_cl_index = _tmp70_ + 1;
						_tmp71_ = _iface_cl_index;
						_tmp72_ = _iface_cl_size;
						if (!(_tmp71_ < _tmp72_)) {
							break;
						}
						_tmp73_ = _iface_cl_list;
						_tmp74_ = _iface_cl_index;
						_tmp75_ = vala_list_get (_tmp73_, _tmp74_);
						iface_cl = (ValaClass*) _tmp75_;
						_tmp76_ = iface_cl;
						_tmp77_ = registered_types;
						vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp76_, _tmp77_);
						_vala_code_node_unref0 (iface_cl);
					}
					_vala_iterable_unref0 (_iface_cl_list);
				}
			}
		}
	}
	_vala_code_node_unref0 (iface);
	_vala_code_node_unref0 (cl);
	_vala_code_node_unref0 (ns);
}


static void vala_ccode_method_module_register_plugin_type (ValaCCodeMethodModule* self, ValaObjectTypeSymbol* type_symbol, ValaSet* registered_types) {
	ValaObjectTypeSymbol* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	ValaSet* _tmp3_;
	ValaObjectTypeSymbol* _tmp4_;
	gboolean _tmp5_;
	ValaClass* cl = NULL;
	ValaObjectTypeSymbol* _tmp6_;
	ValaClass* _tmp7_;
	ValaClass* _tmp8_;
	ValaCCodeFunction* register_func = NULL;
	ValaObjectTypeSymbol* _tmp27_;
	gchar* _tmp28_;
	gchar* _tmp29_;
	gchar* _tmp30_;
	gchar* _tmp31_;
	ValaCCodeFunction* _tmp32_;
	ValaCCodeFunction* _tmp33_;
	ValaCCodeFunction* _tmp34_;
	ValaCCodeParameter* _tmp35_;
	ValaCCodeParameter* _tmp36_;
	ValaCCodeFunction* _tmp37_;
	ValaCCodeFile* _tmp38_;
	ValaCCodeFunction* _tmp39_;
	ValaCCodeFunctionCall* register_call = NULL;
	ValaObjectTypeSymbol* _tmp40_;
	gchar* _tmp41_;
	gchar* _tmp42_;
	gchar* _tmp43_;
	gchar* _tmp44_;
	ValaCCodeIdentifier* _tmp45_;
	ValaCCodeIdentifier* _tmp46_;
	ValaCCodeFunctionCall* _tmp47_;
	ValaCCodeFunctionCall* _tmp48_;
	ValaCCodeFunctionCall* _tmp49_;
	const gchar* _tmp50_;
	ValaCCodeIdentifier* _tmp51_;
	ValaCCodeIdentifier* _tmp52_;
	ValaCCodeFunction* _tmp53_;
	ValaCCodeFunction* _tmp54_;
	ValaCCodeFunctionCall* _tmp55_;
	ValaInterface* iface = NULL;
	ValaObjectTypeSymbol* _tmp56_;
	ValaInterface* _tmp57_;
	ValaInterface* _tmp58_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (type_symbol != NULL);
	g_return_if_fail (registered_types != NULL);
	_tmp0_ = type_symbol;
	_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_) {
		return;
	}
	_tmp3_ = registered_types;
	_tmp4_ = type_symbol;
	_tmp5_ = vala_collection_add ((ValaCollection*) _tmp3_, (ValaSymbol*) _tmp4_);
	if (!_tmp5_) {
		return;
	}
	_tmp6_ = type_symbol;
	_tmp7_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp6_) : NULL);
	cl = _tmp7_;
	_tmp8_ = cl;
	if (_tmp8_ != NULL) {
		ValaClass* _tmp9_;
		gboolean _tmp10_;
		gboolean _tmp11_;
		_tmp9_ = cl;
		_tmp10_ = vala_class_get_is_compact (_tmp9_);
		_tmp11_ = _tmp10_;
		if (_tmp11_) {
			_vala_code_node_unref0 (cl);
			return;
		}
		{
			ValaList* _base_type_list = NULL;
			ValaClass* _tmp12_;
			ValaList* _tmp13_;
			gint _base_type_size = 0;
			ValaList* _tmp14_;
			gint _tmp15_;
			gint _tmp16_;
			gint _base_type_index = 0;
			_tmp12_ = cl;
			_tmp13_ = vala_class_get_base_types (_tmp12_);
			_base_type_list = _tmp13_;
			_tmp14_ = _base_type_list;
			_tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);
			_tmp16_ = _tmp15_;
			_base_type_size = _tmp16_;
			_base_type_index = -1;
			while (TRUE) {
				gint _tmp17_;
				gint _tmp18_;
				gint _tmp19_;
				ValaDataType* base_type = NULL;
				ValaList* _tmp20_;
				gint _tmp21_;
				gpointer _tmp22_;
				ValaDataType* _tmp23_;
				ValaTypeSymbol* _tmp24_;
				ValaTypeSymbol* _tmp25_;
				ValaSet* _tmp26_;
				_tmp17_ = _base_type_index;
				_base_type_index = _tmp17_ + 1;
				_tmp18_ = _base_type_index;
				_tmp19_ = _base_type_size;
				if (!(_tmp18_ < _tmp19_)) {
					break;
				}
				_tmp20_ = _base_type_list;
				_tmp21_ = _base_type_index;
				_tmp22_ = vala_list_get (_tmp20_, _tmp21_);
				base_type = (ValaDataType*) _tmp22_;
				_tmp23_ = base_type;
				_tmp24_ = vala_data_type_get_data_type (_tmp23_);
				_tmp25_ = _tmp24_;
				_tmp26_ = registered_types;
				vala_ccode_method_module_register_plugin_type (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol), _tmp26_);
				_vala_code_node_unref0 (base_type);
			}
			_vala_iterable_unref0 (_base_type_list);
		}
	}
	_tmp27_ = type_symbol;
	_tmp28_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp27_, NULL);
	_tmp29_ = _tmp28_;
	_tmp30_ = g_strdup_printf ("%s_register_type", _tmp29_);
	_tmp31_ = _tmp30_;
	_tmp32_ = vala_ccode_function_new (_tmp31_, "GType");
	_tmp33_ = _tmp32_;
	_g_free0 (_tmp31_);
	_g_free0 (_tmp29_);
	register_func = _tmp33_;
	_tmp34_ = register_func;
	_tmp35_ = vala_ccode_parameter_new ("module", "GTypeModule *");
	_tmp36_ = _tmp35_;
	vala_ccode_function_add_parameter (_tmp34_, _tmp36_);
	_vala_ccode_node_unref0 (_tmp36_);
	_tmp37_ = register_func;
	vala_ccode_function_set_is_declaration (_tmp37_, TRUE);
	_tmp38_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp39_ = register_func;
	vala_ccode_file_add_function_declaration (_tmp38_, _tmp39_);
	_tmp40_ = type_symbol;
	_tmp41_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp40_, NULL);
	_tmp42_ = _tmp41_;
	_tmp43_ = g_strdup_printf ("%s_register_type", _tmp42_);
	_tmp44_ = _tmp43_;
	_tmp45_ = vala_ccode_identifier_new (_tmp44_);
	_tmp46_ = _tmp45_;
	_tmp47_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp46_);
	_tmp48_ = _tmp47_;
	_vala_ccode_node_unref0 (_tmp46_);
	_g_free0 (_tmp44_);
	_g_free0 (_tmp42_);
	register_call = _tmp48_;
	_tmp49_ = register_call;
	_tmp50_ = ((ValaCCodeBaseModule*) self)->module_init_param_name;
	_tmp51_ = vala_ccode_identifier_new (_tmp50_);
	_tmp52_ = _tmp51_;
	vala_ccode_function_call_add_argument (_tmp49_, (ValaCCodeExpression*) _tmp52_);
	_vala_ccode_node_unref0 (_tmp52_);
	_tmp53_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp54_ = _tmp53_;
	_tmp55_ = register_call;
	vala_ccode_function_add_expression (_tmp54_, (ValaCCodeExpression*) _tmp55_);
	_tmp56_ = type_symbol;
	_tmp57_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp56_, VALA_TYPE_INTERFACE) ? ((ValaInterface*) _tmp56_) : NULL);
	iface = _tmp57_;
	_tmp58_ = iface;
	if (_tmp58_ != NULL) {
		gchar* dbus_name = NULL;
		ValaObjectTypeSymbol* _tmp59_;
		gchar* _tmp60_;
		const gchar* _tmp61_;
		_tmp59_ = type_symbol;
		_tmp60_ = vala_gd_bus_module_get_dbus_name ((ValaTypeSymbol*) _tmp59_);
		dbus_name = _tmp60_;
		_tmp61_ = dbus_name;
		if (_tmp61_ != NULL) {
			gchar* proxy_cname = NULL;
			ValaObjectTypeSymbol* _tmp62_;
			gchar* _tmp63_;
			gchar* _tmp64_;
			gchar* _tmp65_;
			gchar* _tmp66_;
			ValaCCodeFunctionCall* register_proxy = NULL;
			const gchar* _tmp67_;
			gchar* _tmp68_;
			gchar* _tmp69_;
			ValaCCodeIdentifier* _tmp70_;
			ValaCCodeIdentifier* _tmp71_;
			ValaCCodeFunctionCall* _tmp72_;
			ValaCCodeFunctionCall* _tmp73_;
			ValaCCodeFunctionCall* _tmp74_;
			const gchar* _tmp75_;
			ValaCCodeIdentifier* _tmp76_;
			ValaCCodeIdentifier* _tmp77_;
			ValaCCodeFunction* _tmp78_;
			ValaCCodeFunction* _tmp79_;
			ValaCCodeFunctionCall* _tmp80_;
			_tmp62_ = type_symbol;
			_tmp63_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp62_);
			_tmp64_ = _tmp63_;
			_tmp65_ = g_strconcat (_tmp64_, "proxy", NULL);
			_tmp66_ = _tmp65_;
			_g_free0 (_tmp64_);
			proxy_cname = _tmp66_;
			_tmp67_ = proxy_cname;
			_tmp68_ = g_strdup_printf ("%s_register_dynamic_type", _tmp67_);
			_tmp69_ = _tmp68_;
			_tmp70_ = vala_ccode_identifier_new (_tmp69_);
			_tmp71_ = _tmp70_;
			_tmp72_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp71_);
			_tmp73_ = _tmp72_;
			_vala_ccode_node_unref0 (_tmp71_);
			_g_free0 (_tmp69_);
			register_proxy = _tmp73_;
			_tmp74_ = register_proxy;
			_tmp75_ = ((ValaCCodeBaseModule*) self)->module_init_param_name;
			_tmp76_ = vala_ccode_identifier_new (_tmp75_);
			_tmp77_ = _tmp76_;
			vala_ccode_function_call_add_argument (_tmp74_, (ValaCCodeExpression*) _tmp77_);
			_vala_ccode_node_unref0 (_tmp77_);
			_tmp78_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp79_ = _tmp78_;
			_tmp80_ = register_proxy;
			vala_ccode_function_add_expression (_tmp79_, (ValaCCodeExpression*) _tmp80_);
			_vala_ccode_node_unref0 (register_proxy);
			_g_free0 (proxy_cname);
		}
		_g_free0 (dbus_name);
	}
	_vala_code_node_unref0 (iface);
	_vala_ccode_node_unref0 (register_call);
	_vala_ccode_node_unref0 (register_func);
	_vala_code_node_unref0 (cl);
}


/**
 * This function generates the code the given method. If the method is
 * a constructor, _construct is generated, unless it's variadic, in which
 * case _constructv is generated (and _construct is generated together
 * with _new in visit_creation_method).
 */
static gpointer _vala_ccode_node_ref0 (gpointer self) {
	return self ? vala_ccode_node_ref (self) : NULL;
}


static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base, ValaMethod* m) {
	ValaCCodeMethodModule * self;
	gchar* real_name = NULL;
	ValaMethod* _tmp0_;
	gchar* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaMethod* _tmp3_;
	ValaMethod* _tmp8_;
	ValaCCodeBaseModuleEmitContext* _tmp9_;
	ValaCCodeBaseModuleEmitContext* _tmp10_;
	ValaMethod* _tmp11_;
	ValaSourceReference* _tmp12_;
	ValaSourceReference* _tmp13_;
	gboolean in_gobject_creation_method = FALSE;
	gboolean in_fundamental_creation_method = FALSE;
	ValaMethod* _tmp14_;
	ValaDataType* _tmp15_;
	ValaDataType* _tmp16_;
	gboolean profile = FALSE;
	ValaMethod* _tmp17_;
	ValaAttribute* _tmp18_;
	ValaAttribute* _tmp19_;
	gboolean _tmp20_;
	ValaMethod* _tmp21_;
	ValaDataType* creturn_type = NULL;
	ValaMethod* _tmp38_;
	ValaDataType* _tmp39_;
	ValaDataType* _tmp40_;
	ValaDataType* _tmp41_;
	ValaMethod* _tmp42_;
	ValaDataType* _tmp43_;
	ValaDataType* _tmp44_;
	gboolean _tmp45_;
	gboolean _tmp59_ = FALSE;
	gboolean _tmp60_ = FALSE;
	gboolean _tmp61_ = FALSE;
	ValaMethod* _tmp62_;
	gboolean _tmp63_;
	gboolean _tmp64_;
	gboolean _tmp88_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp206_;
	ValaCCodeFunction* _tmp207_;
	ValaMethod* _tmp208_;
	gboolean _tmp209_;
	gboolean _tmp210_;
	ValaHashMap* cparam_map = NULL;
	GHashFunc _tmp215_;
	GEqualFunc _tmp216_;
	GEqualFunc _tmp217_;
	ValaHashMap* _tmp218_;
	ValaMethod* _tmp219_;
	ValaCCodeFile* _tmp220_;
	ValaHashMap* _tmp221_;
	ValaCCodeFunction* _tmp222_;
	gboolean _tmp223_ = FALSE;
	ValaMethod* _tmp224_;
	gboolean _tmp225_;
	gboolean _tmp226_;
	ValaMethod* _tmp289_;
	ValaComment* _tmp290_;
	ValaComment* _tmp291_;
	ValaCCodeFunction* _tmp300_;
	ValaCCodeBlock* co_switch_block = NULL;
	gboolean _tmp301_ = FALSE;
	ValaMethod* _tmp302_;
	gboolean _tmp303_;
	gboolean _tmp304_;
	gboolean _tmp1003_;
	ValaMethod* _tmp1044_;
	ValaBlock* _tmp1045_;
	ValaBlock* _tmp1046_;
	gboolean _tmp1087_ = FALSE;
	gboolean _tmp1088_;
	gboolean _tmp1122_ = FALSE;
	ValaMethod* _tmp1123_;
	gboolean _tmp1124_;
	gboolean _tmp1125_;
	gboolean _tmp1271_ = FALSE;
	ValaMethod* _tmp1272_;
	gboolean _tmp1273_;
	gboolean _tmp1274_;
	gboolean _tmp1312_ = FALSE;
	gboolean _tmp1313_ = FALSE;
	gboolean _tmp1314_ = FALSE;
	ValaMethod* _tmp1315_;
	gboolean _tmp1316_;
	gboolean _tmp1317_;
	ValaMethod* _tmp1339_;
	gboolean _tmp1340_;
	gboolean _tmp1341_;
	self = (ValaCCodeMethodModule*) base;
	g_return_if_fail (m != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp0_);
	real_name = _tmp1_;
	_tmp3_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_CREATION_METHOD)) {
		ValaMethod* _tmp4_;
		gboolean _tmp5_;
		_tmp4_ = m;
		_tmp5_ = vala_method_is_variadic (_tmp4_);
		_tmp2_ = _tmp5_;
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		ValaMethod* _tmp6_;
		gchar* _tmp7_;
		_tmp6_ = m;
		_tmp7_ = vala_ccode_base_module_get_ccode_constructv_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
		_g_free0 (real_name);
		real_name = _tmp7_;
	}
	_tmp8_ = m;
	_tmp9_ = vala_ccode_base_module_emit_context_new ((ValaSymbol*) _tmp8_);
	_tmp10_ = _tmp9_;
	vala_ccode_base_module_push_context ((ValaCCodeBaseModule*) self, _tmp10_);
	_vala_ccode_base_module_emit_context_unref0 (_tmp10_);
	_tmp11_ = m;
	_tmp12_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp11_);
	_tmp13_ = _tmp12_;
	vala_ccode_base_module_push_line ((ValaCCodeBaseModule*) self, _tmp13_);
	in_gobject_creation_method = FALSE;
	in_fundamental_creation_method = FALSE;
	_tmp14_ = m;
	_tmp15_ = vala_callable_get_return_type ((ValaCallable*) _tmp14_);
	_tmp16_ = _tmp15_;
	vala_ccode_base_module_check_type ((ValaCCodeBaseModule*) self, _tmp16_);
	_tmp17_ = m;
	_tmp18_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp17_, "Profile");
	_tmp19_ = _tmp18_;
	_tmp20_ = _tmp19_ != NULL;
	_vala_code_node_unref0 (_tmp19_);
	profile = _tmp20_;
	_tmp21_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp21_, VALA_TYPE_CREATION_METHOD)) {
		ValaClass* cl = NULL;
		ValaTypeSymbol* _tmp22_;
		ValaTypeSymbol* _tmp23_;
		ValaClass* _tmp24_;
		gboolean _tmp25_ = FALSE;
		ValaClass* _tmp26_;
		_tmp22_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
		_tmp23_ = _tmp22_;
		_tmp24_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp23_) : NULL);
		cl = _tmp24_;
		_tmp26_ = cl;
		if (_tmp26_ != NULL) {
			ValaClass* _tmp27_;
			gboolean _tmp28_;
			gboolean _tmp29_;
			_tmp27_ = cl;
			_tmp28_ = vala_class_get_is_compact (_tmp27_);
			_tmp29_ = _tmp28_;
			_tmp25_ = !_tmp29_;
		} else {
			_tmp25_ = FALSE;
		}
		if (_tmp25_) {
			ValaClass* _tmp30_;
			ValaClass* _tmp31_;
			ValaClass* _tmp32_;
			_tmp30_ = cl;
			_tmp31_ = vala_class_get_base_class (_tmp30_);
			_tmp32_ = _tmp31_;
			if (_tmp32_ == NULL) {
				in_fundamental_creation_method = TRUE;
			} else {
				gboolean _tmp33_ = FALSE;
				ValaTypeSymbol* _tmp34_;
				_tmp34_ = ((ValaCCodeBaseModule*) self)->gobject_type;
				if (_tmp34_ != NULL) {
					ValaClass* _tmp35_;
					ValaTypeSymbol* _tmp36_;
					gboolean _tmp37_;
					_tmp35_ = cl;
					_tmp36_ = ((ValaCCodeBaseModule*) self)->gobject_type;
					_tmp37_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp35_, _tmp36_);
					_tmp33_ = _tmp37_;
				} else {
					_tmp33_ = FALSE;
				}
				if (_tmp33_) {
					in_gobject_creation_method = TRUE;
				}
			}
		}
		_vala_code_node_unref0 (cl);
	}
	_tmp38_ = m;
	_tmp39_ = vala_callable_get_return_type ((ValaCallable*) _tmp38_);
	_tmp40_ = _tmp39_;
	_tmp41_ = _vala_code_node_ref0 (_tmp40_);
	creturn_type = _tmp41_;
	_tmp42_ = m;
	_tmp43_ = vala_callable_get_return_type ((ValaCallable*) _tmp42_);
	_tmp44_ = _tmp43_;
	_tmp45_ = vala_data_type_is_real_non_null_struct_type (_tmp44_);
	if (_tmp45_) {
		ValaVoidType* _tmp46_;
		_tmp46_ = vala_void_type_new (NULL);
		_vala_code_node_unref0 (creturn_type);
		creturn_type = (ValaDataType*) _tmp46_;
	}
	{
		ValaList* _param_list = NULL;
		ValaMethod* _tmp47_;
		ValaList* _tmp48_;
		gint _param_size = 0;
		ValaList* _tmp49_;
		gint _tmp50_;
		gint _tmp51_;
		gint _param_index = 0;
		_tmp47_ = m;
		_tmp48_ = vala_callable_get_parameters ((ValaCallable*) _tmp47_);
		_param_list = _tmp48_;
		_tmp49_ = _param_list;
		_tmp50_ = vala_collection_get_size ((ValaCollection*) _tmp49_);
		_tmp51_ = _tmp50_;
		_param_size = _tmp51_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp52_;
			gint _tmp53_;
			gint _tmp54_;
			ValaParameter* param = NULL;
			ValaList* _tmp55_;
			gint _tmp56_;
			gpointer _tmp57_;
			ValaParameter* _tmp58_;
			_tmp52_ = _param_index;
			_param_index = _tmp52_ + 1;
			_tmp53_ = _param_index;
			_tmp54_ = _param_size;
			if (!(_tmp53_ < _tmp54_)) {
				break;
			}
			_tmp55_ = _param_list;
			_tmp56_ = _param_index;
			_tmp57_ = vala_list_get (_tmp55_, _tmp56_);
			param = (ValaParameter*) _tmp57_;
			_tmp58_ = param;
			vala_code_node_accept ((ValaCodeNode*) _tmp58_, (ValaCodeVisitor*) self);
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
	_tmp62_ = m;
	_tmp63_ = vala_method_get_is_abstract (_tmp62_);
	_tmp64_ = _tmp63_;
	if (_tmp64_) {
		_tmp61_ = TRUE;
	} else {
		ValaMethod* _tmp65_;
		gboolean _tmp66_;
		gboolean _tmp67_;
		_tmp65_ = m;
		_tmp66_ = vala_method_get_is_virtual (_tmp65_);
		_tmp67_ = _tmp66_;
		_tmp61_ = _tmp67_;
	}
	if (_tmp61_) {
		_tmp60_ = TRUE;
	} else {
		gboolean _tmp68_ = FALSE;
		ValaMethod* _tmp69_;
		ValaMethod* _tmp70_;
		ValaMethod* _tmp71_;
		_tmp69_ = m;
		_tmp70_ = vala_method_get_base_method (_tmp69_);
		_tmp71_ = _tmp70_;
		if (_tmp71_ == NULL) {
			ValaMethod* _tmp72_;
			ValaMethod* _tmp73_;
			ValaMethod* _tmp74_;
			_tmp72_ = m;
			_tmp73_ = vala_method_get_base_interface_method (_tmp72_);
			_tmp74_ = _tmp73_;
			_tmp68_ = _tmp74_ == NULL;
		} else {
			_tmp68_ = FALSE;
		}
		_tmp60_ = _tmp68_;
	}
	if (_tmp60_) {
		ValaMethod* _tmp75_;
		ValaSignal* _tmp76_;
		ValaSignal* _tmp77_;
		_tmp75_ = m;
		_tmp76_ = vala_method_get_signal_reference (_tmp75_);
		_tmp77_ = _tmp76_;
		_tmp59_ = _tmp77_ == NULL;
	} else {
		_tmp59_ = FALSE;
	}
	if (_tmp59_) {
		ValaMethod* _tmp78_;
		ValaCCodeFile* _tmp79_;
		ValaMethod* _tmp80_;
		gboolean _tmp81_;
		ValaMethod* _tmp84_;
		gboolean _tmp85_;
		_tmp78_ = m;
		_tmp79_ = ((ValaCCodeBaseModule*) self)->cfile;
		vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp78_, _tmp79_);
		_tmp80_ = m;
		_tmp81_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp80_);
		if (!_tmp81_) {
			ValaMethod* _tmp82_;
			ValaCCodeFile* _tmp83_;
			_tmp82_ = m;
			_tmp83_ = ((ValaCCodeBaseModule*) self)->header_file;
			vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp82_, _tmp83_);
		}
		_tmp84_ = m;
		_tmp85_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp84_);
		if (!_tmp85_) {
			ValaMethod* _tmp86_;
			ValaCCodeFile* _tmp87_;
			_tmp86_ = m;
			_tmp87_ = ((ValaCCodeBaseModule*) self)->internal_header_file;
			vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp86_, _tmp87_);
		}
	}
	_tmp88_ = profile;
	if (_tmp88_) {
		gchar* prefix = NULL;
		const gchar* _tmp89_;
		gchar* _tmp90_;
		ValaCCodeFile* _tmp91_;
		ValaCCodeIdentifier* counter = NULL;
		const gchar* _tmp92_;
		gchar* _tmp93_;
		gchar* _tmp94_;
		ValaCCodeIdentifier* _tmp95_;
		ValaCCodeIdentifier* _tmp96_;
		ValaCCodeDeclaration* counter_decl = NULL;
		ValaCCodeDeclaration* _tmp97_;
		ValaCCodeDeclaration* _tmp98_;
		ValaCCodeIdentifier* _tmp99_;
		const gchar* _tmp100_;
		const gchar* _tmp101_;
		ValaCCodeVariableDeclarator* _tmp102_;
		ValaCCodeVariableDeclarator* _tmp103_;
		ValaCCodeDeclaration* _tmp104_;
		ValaCCodeFile* _tmp105_;
		ValaCCodeDeclaration* _tmp106_;
		ValaCCodeIdentifier* level = NULL;
		const gchar* _tmp107_;
		gchar* _tmp108_;
		gchar* _tmp109_;
		ValaCCodeIdentifier* _tmp110_;
		ValaCCodeIdentifier* _tmp111_;
		ValaCCodeDeclaration* level_decl = NULL;
		ValaCCodeDeclaration* _tmp112_;
		ValaCCodeDeclaration* _tmp113_;
		ValaCCodeIdentifier* _tmp114_;
		const gchar* _tmp115_;
		const gchar* _tmp116_;
		ValaCCodeVariableDeclarator* _tmp117_;
		ValaCCodeVariableDeclarator* _tmp118_;
		ValaCCodeDeclaration* _tmp119_;
		ValaCCodeFile* _tmp120_;
		ValaCCodeDeclaration* _tmp121_;
		ValaCCodeIdentifier* timer = NULL;
		const gchar* _tmp122_;
		gchar* _tmp123_;
		gchar* _tmp124_;
		ValaCCodeIdentifier* _tmp125_;
		ValaCCodeIdentifier* _tmp126_;
		ValaCCodeDeclaration* timer_decl = NULL;
		ValaCCodeDeclaration* _tmp127_;
		ValaCCodeDeclaration* _tmp128_;
		ValaCCodeIdentifier* _tmp129_;
		const gchar* _tmp130_;
		const gchar* _tmp131_;
		ValaCCodeVariableDeclarator* _tmp132_;
		ValaCCodeVariableDeclarator* _tmp133_;
		ValaCCodeDeclaration* _tmp134_;
		ValaCCodeFile* _tmp135_;
		ValaCCodeDeclaration* _tmp136_;
		ValaCCodeFunction* constructor = NULL;
		const gchar* _tmp137_;
		gchar* _tmp138_;
		gchar* _tmp139_;
		ValaCCodeFunction* _tmp140_;
		ValaCCodeFunction* _tmp141_;
		ValaCCodeFunction* _tmp142_;
		ValaCCodeFile* _tmp143_;
		ValaCCodeFunction* _tmp144_;
		ValaCCodeFunction* _tmp145_;
		ValaCCodeFunction* _tmp146_;
		ValaCCodeFunction* _tmp147_;
		ValaCCodeIdentifier* _tmp148_;
		ValaCCodeIdentifier* _tmp149_;
		ValaCCodeIdentifier* _tmp150_;
		ValaCCodeFunctionCall* _tmp151_;
		ValaCCodeFunctionCall* _tmp152_;
		ValaCCodeFunctionCall* stop_call = NULL;
		ValaCCodeIdentifier* _tmp153_;
		ValaCCodeIdentifier* _tmp154_;
		ValaCCodeFunctionCall* _tmp155_;
		ValaCCodeFunctionCall* _tmp156_;
		ValaCCodeFunctionCall* _tmp157_;
		ValaCCodeIdentifier* _tmp158_;
		ValaCCodeFunction* _tmp159_;
		ValaCCodeFunction* _tmp160_;
		ValaCCodeFunctionCall* _tmp161_;
		ValaCCodeFile* _tmp162_;
		ValaCCodeFunction* _tmp163_;
		ValaCCodeFunction* destructor = NULL;
		const gchar* _tmp164_;
		gchar* _tmp165_;
		gchar* _tmp166_;
		ValaCCodeFunction* _tmp167_;
		ValaCCodeFunction* _tmp168_;
		ValaCCodeFunction* _tmp169_;
		ValaCCodeFile* _tmp170_;
		ValaCCodeFunction* _tmp171_;
		ValaCCodeFunction* _tmp172_;
		ValaCCodeFunctionCall* elapsed_call = NULL;
		ValaCCodeIdentifier* _tmp173_;
		ValaCCodeIdentifier* _tmp174_;
		ValaCCodeFunctionCall* _tmp175_;
		ValaCCodeFunctionCall* _tmp176_;
		ValaCCodeFunctionCall* _tmp177_;
		ValaCCodeIdentifier* _tmp178_;
		ValaCCodeFunctionCall* _tmp179_;
		ValaCCodeConstant* _tmp180_;
		ValaCCodeConstant* _tmp181_;
		ValaCCodeFunctionCall* print_call = NULL;
		ValaCCodeIdentifier* _tmp182_;
		ValaCCodeIdentifier* _tmp183_;
		ValaCCodeFunctionCall* _tmp184_;
		ValaCCodeFunctionCall* _tmp185_;
		ValaCCodeFunctionCall* _tmp186_;
		ValaCCodeIdentifier* _tmp187_;
		ValaCCodeIdentifier* _tmp188_;
		ValaCCodeFunctionCall* _tmp189_;
		ValaMethod* _tmp190_;
		gchar* _tmp191_;
		gchar* _tmp192_;
		gchar* _tmp193_;
		gchar* _tmp194_;
		ValaCCodeConstant* _tmp195_;
		ValaCCodeConstant* _tmp196_;
		ValaCCodeFunctionCall* _tmp197_;
		ValaCCodeFunctionCall* _tmp198_;
		ValaCCodeFunctionCall* _tmp199_;
		ValaCCodeIdentifier* _tmp200_;
		ValaCCodeFunction* _tmp201_;
		ValaCCodeFunction* _tmp202_;
		ValaCCodeFunctionCall* _tmp203_;
		ValaCCodeFile* _tmp204_;
		ValaCCodeFunction* _tmp205_;
		_tmp89_ = real_name;
		_tmp90_ = g_strdup_printf ("_vala_prof_%s", _tmp89_);
		prefix = _tmp90_;
		_tmp91_ = ((ValaCCodeBaseModule*) self)->cfile;
		vala_ccode_file_add_include (_tmp91_, "stdio.h", FALSE);
		_tmp92_ = prefix;
		_tmp93_ = g_strconcat (_tmp92_, "_counter", NULL);
		_tmp94_ = _tmp93_;
		_tmp95_ = vala_ccode_identifier_new (_tmp94_);
		_tmp96_ = _tmp95_;
		_g_free0 (_tmp94_);
		counter = _tmp96_;
		_tmp97_ = vala_ccode_declaration_new ("gint");
		counter_decl = _tmp97_;
		_tmp98_ = counter_decl;
		_tmp99_ = counter;
		_tmp100_ = vala_ccode_identifier_get_name (_tmp99_);
		_tmp101_ = _tmp100_;
		_tmp102_ = vala_ccode_variable_declarator_new (_tmp101_, NULL, NULL);
		_tmp103_ = _tmp102_;
		vala_ccode_declaration_add_declarator (_tmp98_, (ValaCCodeDeclarator*) _tmp103_);
		_vala_ccode_node_unref0 (_tmp103_);
		_tmp104_ = counter_decl;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp104_, VALA_CCODE_MODIFIERS_STATIC);
		_tmp105_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp106_ = counter_decl;
		vala_ccode_file_add_type_member_declaration (_tmp105_, (ValaCCodeNode*) _tmp106_);
		_tmp107_ = prefix;
		_tmp108_ = g_strconcat (_tmp107_, "_level", NULL);
		_tmp109_ = _tmp108_;
		_tmp110_ = vala_ccode_identifier_new (_tmp109_);
		_tmp111_ = _tmp110_;
		_g_free0 (_tmp109_);
		level = _tmp111_;
		_tmp112_ = vala_ccode_declaration_new ("gint");
		level_decl = _tmp112_;
		_tmp113_ = level_decl;
		_tmp114_ = level;
		_tmp115_ = vala_ccode_identifier_get_name (_tmp114_);
		_tmp116_ = _tmp115_;
		_tmp117_ = vala_ccode_variable_declarator_new (_tmp116_, NULL, NULL);
		_tmp118_ = _tmp117_;
		vala_ccode_declaration_add_declarator (_tmp113_, (ValaCCodeDeclarator*) _tmp118_);
		_vala_ccode_node_unref0 (_tmp118_);
		_tmp119_ = level_decl;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp119_, VALA_CCODE_MODIFIERS_STATIC);
		_tmp120_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp121_ = level_decl;
		vala_ccode_file_add_type_member_declaration (_tmp120_, (ValaCCodeNode*) _tmp121_);
		_tmp122_ = prefix;
		_tmp123_ = g_strconcat (_tmp122_, "_timer", NULL);
		_tmp124_ = _tmp123_;
		_tmp125_ = vala_ccode_identifier_new (_tmp124_);
		_tmp126_ = _tmp125_;
		_g_free0 (_tmp124_);
		timer = _tmp126_;
		_tmp127_ = vala_ccode_declaration_new ("GTimer *");
		timer_decl = _tmp127_;
		_tmp128_ = timer_decl;
		_tmp129_ = timer;
		_tmp130_ = vala_ccode_identifier_get_name (_tmp129_);
		_tmp131_ = _tmp130_;
		_tmp132_ = vala_ccode_variable_declarator_new (_tmp131_, NULL, NULL);
		_tmp133_ = _tmp132_;
		vala_ccode_declaration_add_declarator (_tmp128_, (ValaCCodeDeclarator*) _tmp133_);
		_vala_ccode_node_unref0 (_tmp133_);
		_tmp134_ = timer_decl;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp134_, VALA_CCODE_MODIFIERS_STATIC);
		_tmp135_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp136_ = timer_decl;
		vala_ccode_file_add_type_member_declaration (_tmp135_, (ValaCCodeNode*) _tmp136_);
		_tmp137_ = prefix;
		_tmp138_ = g_strconcat (_tmp137_, "_init", NULL);
		_tmp139_ = _tmp138_;
		_tmp140_ = vala_ccode_function_new (_tmp139_, "void");
		_tmp141_ = _tmp140_;
		_g_free0 (_tmp139_);
		constructor = _tmp141_;
		_tmp142_ = constructor;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp142_, VALA_CCODE_MODIFIERS_STATIC | VALA_CCODE_MODIFIERS_CONSTRUCTOR);
		_tmp143_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp144_ = constructor;
		vala_ccode_file_add_function_declaration (_tmp143_, _tmp144_);
		_tmp145_ = constructor;
		vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp145_);
		_tmp146_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp147_ = _tmp146_;
		_tmp148_ = timer;
		_tmp149_ = vala_ccode_identifier_new ("g_timer_new");
		_tmp150_ = _tmp149_;
		_tmp151_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp150_);
		_tmp152_ = _tmp151_;
		vala_ccode_function_add_assignment (_tmp147_, (ValaCCodeExpression*) _tmp148_, (ValaCCodeExpression*) _tmp152_);
		_vala_ccode_node_unref0 (_tmp152_);
		_vala_ccode_node_unref0 (_tmp150_);
		_tmp153_ = vala_ccode_identifier_new ("g_timer_stop");
		_tmp154_ = _tmp153_;
		_tmp155_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp154_);
		_tmp156_ = _tmp155_;
		_vala_ccode_node_unref0 (_tmp154_);
		stop_call = _tmp156_;
		_tmp157_ = stop_call;
		_tmp158_ = timer;
		vala_ccode_function_call_add_argument (_tmp157_, (ValaCCodeExpression*) _tmp158_);
		_tmp159_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp160_ = _tmp159_;
		_tmp161_ = stop_call;
		vala_ccode_function_add_expression (_tmp160_, (ValaCCodeExpression*) _tmp161_);
		vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
		_tmp162_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp163_ = constructor;
		vala_ccode_file_add_function (_tmp162_, _tmp163_);
		_tmp164_ = prefix;
		_tmp165_ = g_strconcat (_tmp164_, "_exit", NULL);
		_tmp166_ = _tmp165_;
		_tmp167_ = vala_ccode_function_new (_tmp166_, "void");
		_tmp168_ = _tmp167_;
		_g_free0 (_tmp166_);
		destructor = _tmp168_;
		_tmp169_ = destructor;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp169_, VALA_CCODE_MODIFIERS_STATIC | VALA_CCODE_MODIFIERS_DESTRUCTOR);
		_tmp170_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp171_ = destructor;
		vala_ccode_file_add_function_declaration (_tmp170_, _tmp171_);
		_tmp172_ = destructor;
		vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp172_);
		_tmp173_ = vala_ccode_identifier_new ("g_timer_elapsed");
		_tmp174_ = _tmp173_;
		_tmp175_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp174_);
		_tmp176_ = _tmp175_;
		_vala_ccode_node_unref0 (_tmp174_);
		elapsed_call = _tmp176_;
		_tmp177_ = elapsed_call;
		_tmp178_ = timer;
		vala_ccode_function_call_add_argument (_tmp177_, (ValaCCodeExpression*) _tmp178_);
		_tmp179_ = elapsed_call;
		_tmp180_ = vala_ccode_constant_new ("NULL");
		_tmp181_ = _tmp180_;
		vala_ccode_function_call_add_argument (_tmp179_, (ValaCCodeExpression*) _tmp181_);
		_vala_ccode_node_unref0 (_tmp181_);
		_tmp182_ = vala_ccode_identifier_new ("fprintf");
		_tmp183_ = _tmp182_;
		_tmp184_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp183_);
		_tmp185_ = _tmp184_;
		_vala_ccode_node_unref0 (_tmp183_);
		print_call = _tmp185_;
		_tmp186_ = print_call;
		_tmp187_ = vala_ccode_identifier_new ("stderr");
		_tmp188_ = _tmp187_;
		vala_ccode_function_call_add_argument (_tmp186_, (ValaCCodeExpression*) _tmp188_);
		_vala_ccode_node_unref0 (_tmp188_);
		_tmp189_ = print_call;
		_tmp190_ = m;
		_tmp191_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp190_);
		_tmp192_ = _tmp191_;
		_tmp193_ = g_strdup_printf ("\"%s: %%gs (%%d calls)\\n\"", _tmp192_);
		_tmp194_ = _tmp193_;
		_tmp195_ = vala_ccode_constant_new (_tmp194_);
		_tmp196_ = _tmp195_;
		vala_ccode_function_call_add_argument (_tmp189_, (ValaCCodeExpression*) _tmp196_);
		_vala_ccode_node_unref0 (_tmp196_);
		_g_free0 (_tmp194_);
		_g_free0 (_tmp192_);
		_tmp197_ = print_call;
		_tmp198_ = elapsed_call;
		vala_ccode_function_call_add_argument (_tmp197_, (ValaCCodeExpression*) _tmp198_);
		_tmp199_ = print_call;
		_tmp200_ = counter;
		vala_ccode_function_call_add_argument (_tmp199_, (ValaCCodeExpression*) _tmp200_);
		_tmp201_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp202_ = _tmp201_;
		_tmp203_ = print_call;
		vala_ccode_function_add_expression (_tmp202_, (ValaCCodeExpression*) _tmp203_);
		vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
		_tmp204_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp205_ = destructor;
		vala_ccode_file_add_function (_tmp204_, _tmp205_);
		_vala_ccode_node_unref0 (print_call);
		_vala_ccode_node_unref0 (elapsed_call);
		_vala_ccode_node_unref0 (destructor);
		_vala_ccode_node_unref0 (stop_call);
		_vala_ccode_node_unref0 (constructor);
		_vala_ccode_node_unref0 (timer_decl);
		_vala_ccode_node_unref0 (timer);
		_vala_ccode_node_unref0 (level_decl);
		_vala_ccode_node_unref0 (level);
		_vala_ccode_node_unref0 (counter_decl);
		_vala_ccode_node_unref0 (counter);
		_g_free0 (prefix);
	}
	_tmp206_ = real_name;
	_tmp207_ = vala_ccode_function_new (_tmp206_, "void");
	_vala_ccode_node_unref0 (function);
	function = _tmp207_;
	_tmp208_ = m;
	_tmp209_ = vala_method_get_is_inline (_tmp208_);
	_tmp210_ = _tmp209_;
	if (_tmp210_) {
		ValaCCodeFunction* _tmp211_;
		ValaCCodeFunction* _tmp212_;
		ValaCCodeModifiers _tmp213_;
		ValaCCodeModifiers _tmp214_;
		_tmp211_ = function;
		_tmp212_ = function;
		_tmp213_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp212_);
		_tmp214_ = _tmp213_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp212_, _tmp214_ | VALA_CCODE_MODIFIERS_INLINE);
	}
	_tmp215_ = g_direct_hash;
	_tmp216_ = g_direct_equal;
	_tmp217_ = g_direct_equal;
	_tmp218_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp215_, _tmp216_, _tmp217_);
	cparam_map = _tmp218_;
	_tmp219_ = m;
	_tmp220_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp221_ = cparam_map;
	_tmp222_ = function;
	vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp219_, _tmp220_, (ValaMap*) _tmp221_, _tmp222_, NULL, NULL, NULL, 3);
	_tmp224_ = m;
	_tmp225_ = vala_method_get_is_abstract (_tmp224_);
	_tmp226_ = _tmp225_;
	if (!_tmp226_) {
		_tmp223_ = TRUE;
	} else {
		gboolean _tmp227_ = FALSE;
		ValaMethod* _tmp228_;
		gboolean _tmp229_;
		gboolean _tmp230_;
		_tmp228_ = m;
		_tmp229_ = vala_method_get_is_abstract (_tmp228_);
		_tmp230_ = _tmp229_;
		if (_tmp230_) {
			ValaTypeSymbol* _tmp231_;
			ValaTypeSymbol* _tmp232_;
			_tmp231_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
			_tmp232_ = _tmp231_;
			_tmp227_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp232_, VALA_TYPE_CLASS);
		} else {
			_tmp227_ = FALSE;
		}
		_tmp223_ = _tmp227_;
	}
	if (_tmp223_) {
		ValaMethod* _tmp233_;
		gboolean _tmp234_;
		gboolean _tmp235_;
		_tmp233_ = m;
		_tmp234_ = vala_method_get_coroutine (_tmp233_);
		_tmp235_ = _tmp234_;
		if (!_tmp235_) {
			gboolean _tmp236_ = FALSE;
			ValaMethod* _tmp237_;
			ValaMethod* _tmp238_;
			ValaMethod* _tmp239_;
			_tmp237_ = m;
			_tmp238_ = vala_method_get_base_method (_tmp237_);
			_tmp239_ = _tmp238_;
			if (_tmp239_ != NULL) {
				_tmp236_ = TRUE;
			} else {
				ValaMethod* _tmp240_;
				ValaMethod* _tmp241_;
				ValaMethod* _tmp242_;
				_tmp240_ = m;
				_tmp241_ = vala_method_get_base_interface_method (_tmp240_);
				_tmp242_ = _tmp241_;
				_tmp236_ = _tmp242_ != NULL;
			}
			if (_tmp236_) {
				ValaCCodeFunction* _tmp243_;
				ValaCCodeFunction* _tmp244_;
				ValaCCodeModifiers _tmp245_;
				ValaCCodeModifiers _tmp246_;
				ValaCCodeFile* _tmp247_;
				ValaCCodeFunction* _tmp248_;
				_tmp243_ = function;
				_tmp244_ = function;
				_tmp245_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp244_);
				_tmp246_ = _tmp245_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp244_, _tmp246_ | VALA_CCODE_MODIFIERS_STATIC);
				_tmp247_ = ((ValaCCodeBaseModule*) self)->cfile;
				_tmp248_ = function;
				vala_ccode_file_add_function_declaration (_tmp247_, _tmp248_);
			} else {
				ValaMethod* _tmp249_;
				gboolean _tmp250_;
				_tmp249_ = m;
				_tmp250_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp249_);
				if (_tmp250_) {
					ValaCCodeFunction* _tmp251_;
					ValaCCodeFunction* _tmp252_;
					ValaCCodeModifiers _tmp253_;
					ValaCCodeModifiers _tmp254_;
					_tmp251_ = function;
					_tmp252_ = function;
					_tmp253_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp252_);
					_tmp254_ = _tmp253_;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp252_, _tmp254_ | VALA_CCODE_MODIFIERS_STATIC);
				} else {
					gboolean _tmp255_ = FALSE;
					ValaCodeContext* _tmp256_;
					ValaCodeContext* _tmp257_;
					gboolean _tmp258_;
					gboolean _tmp259_;
					_tmp256_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
					_tmp257_ = _tmp256_;
					_tmp258_ = vala_code_context_get_hide_internal (_tmp257_);
					_tmp259_ = _tmp258_;
					if (_tmp259_) {
						ValaMethod* _tmp260_;
						gboolean _tmp261_;
						_tmp260_ = m;
						_tmp261_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp260_);
						_tmp255_ = _tmp261_;
					} else {
						_tmp255_ = FALSE;
					}
					if (_tmp255_) {
						ValaCCodeFunction* _tmp262_;
						ValaCCodeFunction* _tmp263_;
						ValaCCodeModifiers _tmp264_;
						ValaCCodeModifiers _tmp265_;
						_tmp262_ = function;
						_tmp263_ = function;
						_tmp264_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp263_);
						_tmp265_ = _tmp264_;
						vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp263_, _tmp265_ | VALA_CCODE_MODIFIERS_INTERNAL);
					}
				}
			}
		} else {
			ValaMethod* _tmp266_;
			ValaBlock* _tmp267_;
			ValaBlock* _tmp268_;
			_tmp266_ = m;
			_tmp267_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp266_);
			_tmp268_ = _tmp267_;
			if (_tmp268_ != NULL) {
				const gchar* _tmp269_;
				gchar* _tmp270_;
				gchar* _tmp271_;
				ValaCCodeFunction* _tmp272_;
				ValaCCodeFunction* _tmp273_;
				ValaMethod* _tmp274_;
				gchar* _tmp275_;
				gchar* _tmp276_;
				gchar* _tmp277_;
				gchar* _tmp278_;
				gchar* _tmp279_;
				gchar* _tmp280_;
				ValaCCodeParameter* _tmp281_;
				ValaCCodeParameter* _tmp282_;
				ValaCCodeFunction* _tmp283_;
				ValaCCodeFunction* _tmp284_;
				ValaCCodeModifiers _tmp285_;
				ValaCCodeModifiers _tmp286_;
				ValaCCodeFile* _tmp287_;
				ValaCCodeFunction* _tmp288_;
				_tmp269_ = real_name;
				_tmp270_ = g_strconcat (_tmp269_, "_co", NULL);
				_tmp271_ = _tmp270_;
				_tmp272_ = vala_ccode_function_new (_tmp271_, "gboolean");
				_vala_ccode_node_unref0 (function);
				function = _tmp272_;
				_g_free0 (_tmp271_);
				_tmp273_ = function;
				_tmp274_ = m;
				_tmp275_ = vala_ccode_base_module_get_ccode_const_name ((ValaCodeNode*) _tmp274_);
				_tmp276_ = _tmp275_;
				_tmp277_ = vala_symbol_lower_case_to_camel_case (_tmp276_);
				_tmp278_ = _tmp277_;
				_tmp279_ = g_strconcat (_tmp278_, "Data*", NULL);
				_tmp280_ = _tmp279_;
				_tmp281_ = vala_ccode_parameter_new ("_data_", _tmp280_);
				_tmp282_ = _tmp281_;
				vala_ccode_function_add_parameter (_tmp273_, _tmp282_);
				_vala_ccode_node_unref0 (_tmp282_);
				_g_free0 (_tmp280_);
				_g_free0 (_tmp278_);
				_g_free0 (_tmp276_);
				_tmp283_ = function;
				_tmp284_ = function;
				_tmp285_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp284_);
				_tmp286_ = _tmp285_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp284_, _tmp286_ | VALA_CCODE_MODIFIERS_STATIC);
				_tmp287_ = ((ValaCCodeBaseModule*) self)->cfile;
				_tmp288_ = function;
				vala_ccode_file_add_function_declaration (_tmp287_, _tmp288_);
			}
		}
	}
	_tmp289_ = m;
	_tmp290_ = vala_symbol_get_comment ((ValaSymbol*) _tmp289_);
	_tmp291_ = _tmp290_;
	if (_tmp291_ != NULL) {
		ValaCCodeFile* _tmp292_;
		ValaMethod* _tmp293_;
		ValaComment* _tmp294_;
		ValaComment* _tmp295_;
		const gchar* _tmp296_;
		const gchar* _tmp297_;
		ValaCCodeComment* _tmp298_;
		ValaCCodeComment* _tmp299_;
		_tmp292_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp293_ = m;
		_tmp294_ = vala_symbol_get_comment ((ValaSymbol*) _tmp293_);
		_tmp295_ = _tmp294_;
		_tmp296_ = vala_comment_get_content (_tmp295_);
		_tmp297_ = _tmp296_;
		_tmp298_ = vala_ccode_comment_new (_tmp297_);
		_tmp299_ = _tmp298_;
		vala_ccode_file_add_type_member_definition (_tmp292_, (ValaCCodeNode*) _tmp299_);
		_vala_ccode_node_unref0 (_tmp299_);
	}
	_tmp300_ = function;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp300_);
	co_switch_block = NULL;
	_tmp302_ = m;
	_tmp303_ = vala_method_get_is_abstract (_tmp302_);
	_tmp304_ = _tmp303_;
	if (!_tmp304_) {
		_tmp301_ = TRUE;
	} else {
		gboolean _tmp305_ = FALSE;
		ValaMethod* _tmp306_;
		gboolean _tmp307_;
		gboolean _tmp308_;
		_tmp306_ = m;
		_tmp307_ = vala_method_get_is_abstract (_tmp306_);
		_tmp308_ = _tmp307_;
		if (_tmp308_) {
			ValaTypeSymbol* _tmp309_;
			ValaTypeSymbol* _tmp310_;
			_tmp309_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
			_tmp310_ = _tmp309_;
			_tmp305_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp310_, VALA_TYPE_CLASS);
		} else {
			_tmp305_ = FALSE;
		}
		_tmp301_ = _tmp305_;
	}
	if (_tmp301_) {
		ValaMethod* _tmp311_;
		ValaBlock* _tmp312_;
		ValaBlock* _tmp313_;
		_tmp311_ = m;
		_tmp312_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp311_);
		_tmp313_ = _tmp312_;
		if (_tmp313_ != NULL) {
			ValaMethod* _tmp314_;
			gboolean _tmp315_;
			gboolean _tmp316_;
			ValaMethod* _tmp337_;
			gboolean _tmp338_;
			gboolean _tmp339_;
			gboolean _tmp734_ = FALSE;
			gboolean _tmp735_ = FALSE;
			ValaMethod* _tmp736_;
			ValaDataType* _tmp737_;
			ValaDataType* _tmp738_;
			ValaMethod* _tmp762_;
			gboolean _tmp974_ = FALSE;
			ValaCodeContext* _tmp975_;
			ValaCodeContext* _tmp976_;
			ValaMethod* _tmp977_;
			ValaMethod* _tmp978_;
			ValaMethod* _tmp979_;
			_tmp314_ = m;
			_tmp315_ = vala_method_get_coroutine (_tmp314_);
			_tmp316_ = _tmp315_;
			if (_tmp316_) {
				ValaCCodeFunction* _tmp317_;
				ValaCCodeFunction* _tmp318_;
				ValaCCodeIdentifier* _tmp319_;
				ValaCCodeIdentifier* _tmp320_;
				ValaCCodeMemberAccess* _tmp321_;
				ValaCCodeMemberAccess* _tmp322_;
				ValaCCodeFunction* _tmp323_;
				ValaCCodeFunction* _tmp324_;
				ValaCCodeConstant* _tmp325_;
				ValaCCodeConstant* _tmp326_;
				ValaCCodeFunction* _tmp327_;
				ValaCCodeFunction* _tmp328_;
				ValaCCodeFunction* _tmp329_;
				ValaCCodeFunction* _tmp330_;
				ValaCCodeBlock* _tmp331_;
				ValaCCodeBlock* _tmp332_;
				ValaCCodeFunction* _tmp333_;
				ValaCCodeFunction* _tmp334_;
				ValaCCodeFunction* _tmp335_;
				ValaCCodeFunction* _tmp336_;
				_tmp317_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp318_ = _tmp317_;
				_tmp319_ = vala_ccode_identifier_new ("_data_");
				_tmp320_ = _tmp319_;
				_tmp321_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp320_, "_state_");
				_tmp322_ = _tmp321_;
				vala_ccode_function_open_switch (_tmp318_, (ValaCCodeExpression*) _tmp322_);
				_vala_ccode_node_unref0 (_tmp322_);
				_vala_ccode_node_unref0 (_tmp320_);
				_tmp323_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp324_ = _tmp323_;
				_tmp325_ = vala_ccode_constant_new ("0");
				_tmp326_ = _tmp325_;
				vala_ccode_function_add_case (_tmp324_, (ValaCCodeExpression*) _tmp326_);
				_vala_ccode_node_unref0 (_tmp326_);
				_tmp327_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp328_ = _tmp327_;
				vala_ccode_function_add_goto (_tmp328_, "_state_0");
				_tmp329_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp330_ = _tmp329_;
				_tmp331_ = vala_ccode_function_get_current_block (_tmp330_);
				_tmp332_ = _tmp331_;
				co_switch_block = _tmp332_;
				_tmp333_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp334_ = _tmp333_;
				vala_ccode_function_close (_tmp334_);
				_tmp335_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp336_ = _tmp335_;
				vala_ccode_function_add_label (_tmp336_, "_state_0");
			}
			_tmp337_ = m;
			_tmp338_ = vala_method_get_closure (_tmp337_);
			_tmp339_ = _tmp338_;
			if (_tmp339_) {
				ValaBlock* closure_block = NULL;
				ValaBlock* _tmp340_;
				ValaBlock* _tmp341_;
				ValaBlock* _tmp342_;
				gint block_id = 0;
				ValaBlock* _tmp343_;
				gint _tmp344_;
				ValaMethod* _tmp384_;
				ValaMemberBinding _tmp385_;
				ValaMemberBinding _tmp386_;
				_tmp340_ = vala_ccode_base_module_get_current_closure_block ((ValaCCodeBaseModule*) self);
				_tmp341_ = _tmp340_;
				_tmp342_ = _vala_code_node_ref0 (_tmp341_);
				closure_block = _tmp342_;
				_tmp343_ = closure_block;
				_tmp344_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp343_);
				block_id = _tmp344_;
				while (TRUE) {
					ValaBlock* parent_closure_block = NULL;
					ValaBlock* _tmp345_;
					ValaSymbol* _tmp346_;
					ValaSymbol* _tmp347_;
					ValaBlock* _tmp348_;
					ValaBlock* _tmp349_;
					ValaBlock* _tmp350_;
					gint parent_block_id = 0;
					ValaBlock* _tmp351_;
					gint _tmp352_;
					ValaCCodeMemberAccess* parent_data = NULL;
					gint _tmp353_;
					gchar* _tmp354_;
					gchar* _tmp355_;
					ValaCCodeIdentifier* _tmp356_;
					ValaCCodeIdentifier* _tmp357_;
					gint _tmp358_;
					gchar* _tmp359_;
					gchar* _tmp360_;
					ValaCCodeMemberAccess* _tmp361_;
					ValaCCodeMemberAccess* _tmp362_;
					ValaCCodeFunction* _tmp363_;
					ValaCCodeFunction* _tmp364_;
					gint _tmp365_;
					gchar* _tmp366_;
					gchar* _tmp367_;
					gint _tmp368_;
					gchar* _tmp369_;
					gchar* _tmp370_;
					ValaCCodeVariableDeclarator* _tmp371_;
					ValaCCodeVariableDeclarator* _tmp372_;
					ValaCCodeFunction* _tmp373_;
					ValaCCodeFunction* _tmp374_;
					gint _tmp375_;
					gchar* _tmp376_;
					gchar* _tmp377_;
					ValaCCodeIdentifier* _tmp378_;
					ValaCCodeIdentifier* _tmp379_;
					ValaCCodeMemberAccess* _tmp380_;
					ValaBlock* _tmp381_;
					ValaBlock* _tmp382_;
					gint _tmp383_;
					_tmp345_ = closure_block;
					_tmp346_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp345_);
					_tmp347_ = _tmp346_;
					_tmp348_ = vala_ccode_base_module_next_closure_block ((ValaCCodeBaseModule*) self, _tmp347_);
					_tmp349_ = _vala_code_node_ref0 (_tmp348_);
					parent_closure_block = _tmp349_;
					_tmp350_ = parent_closure_block;
					if (_tmp350_ == NULL) {
						_vala_code_node_unref0 (parent_closure_block);
						break;
					}
					_tmp351_ = parent_closure_block;
					_tmp352_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp351_);
					parent_block_id = _tmp352_;
					_tmp353_ = block_id;
					_tmp354_ = g_strdup_printf ("_data%d_", _tmp353_);
					_tmp355_ = _tmp354_;
					_tmp356_ = vala_ccode_identifier_new (_tmp355_);
					_tmp357_ = _tmp356_;
					_tmp358_ = parent_block_id;
					_tmp359_ = g_strdup_printf ("_data%d_", _tmp358_);
					_tmp360_ = _tmp359_;
					_tmp361_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp357_, _tmp360_);
					_tmp362_ = _tmp361_;
					_g_free0 (_tmp360_);
					_vala_ccode_node_unref0 (_tmp357_);
					_g_free0 (_tmp355_);
					parent_data = _tmp362_;
					_tmp363_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp364_ = _tmp363_;
					_tmp365_ = parent_block_id;
					_tmp366_ = g_strdup_printf ("Block%dData*", _tmp365_);
					_tmp367_ = _tmp366_;
					_tmp368_ = parent_block_id;
					_tmp369_ = g_strdup_printf ("_data%d_", _tmp368_);
					_tmp370_ = _tmp369_;
					_tmp371_ = vala_ccode_variable_declarator_new (_tmp370_, NULL, NULL);
					_tmp372_ = _tmp371_;
					vala_ccode_function_add_declaration (_tmp364_, _tmp367_, (ValaCCodeDeclarator*) _tmp372_, 0);
					_vala_ccode_node_unref0 (_tmp372_);
					_g_free0 (_tmp370_);
					_g_free0 (_tmp367_);
					_tmp373_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp374_ = _tmp373_;
					_tmp375_ = parent_block_id;
					_tmp376_ = g_strdup_printf ("_data%d_", _tmp375_);
					_tmp377_ = _tmp376_;
					_tmp378_ = vala_ccode_identifier_new (_tmp377_);
					_tmp379_ = _tmp378_;
					_tmp380_ = parent_data;
					vala_ccode_function_add_assignment (_tmp374_, (ValaCCodeExpression*) _tmp379_, (ValaCCodeExpression*) _tmp380_);
					_vala_ccode_node_unref0 (_tmp379_);
					_g_free0 (_tmp377_);
					_tmp381_ = parent_closure_block;
					_tmp382_ = _vala_code_node_ref0 (_tmp381_);
					_vala_code_node_unref0 (closure_block);
					closure_block = _tmp382_;
					_tmp383_ = parent_block_id;
					block_id = _tmp383_;
					_vala_ccode_node_unref0 (parent_data);
					_vala_code_node_unref0 (parent_closure_block);
				}
				_tmp384_ = m;
				_tmp385_ = vala_method_get_binding (_tmp384_);
				_tmp386_ = _tmp385_;
				if (_tmp386_ == VALA_MEMBER_BINDING_INSTANCE) {
					ValaCCodeMemberAccess* cself = NULL;
					gint _tmp387_;
					gchar* _tmp388_;
					gchar* _tmp389_;
					ValaCCodeIdentifier* _tmp390_;
					ValaCCodeIdentifier* _tmp391_;
					ValaCCodeMemberAccess* _tmp392_;
					ValaCCodeMemberAccess* _tmp393_;
					ValaCCodeFunction* _tmp394_;
					ValaCCodeFunction* _tmp395_;
					ValaTypeSymbol* _tmp396_;
					ValaTypeSymbol* _tmp397_;
					ValaDataType* _tmp398_;
					ValaDataType* _tmp399_;
					gchar* _tmp400_;
					gchar* _tmp401_;
					ValaCCodeVariableDeclarator* _tmp402_;
					ValaCCodeVariableDeclarator* _tmp403_;
					ValaCCodeFunction* _tmp404_;
					ValaCCodeFunction* _tmp405_;
					ValaCCodeIdentifier* _tmp406_;
					ValaCCodeIdentifier* _tmp407_;
					ValaCCodeMemberAccess* _tmp408_;
					_tmp387_ = block_id;
					_tmp388_ = g_strdup_printf ("_data%d_", _tmp387_);
					_tmp389_ = _tmp388_;
					_tmp390_ = vala_ccode_identifier_new (_tmp389_);
					_tmp391_ = _tmp390_;
					_tmp392_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp391_, "self");
					_tmp393_ = _tmp392_;
					_vala_ccode_node_unref0 (_tmp391_);
					_g_free0 (_tmp389_);
					cself = _tmp393_;
					_tmp394_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp395_ = _tmp394_;
					_tmp396_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
					_tmp397_ = _tmp396_;
					_tmp398_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp397_);
					_tmp399_ = _tmp398_;
					_tmp400_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp399_);
					_tmp401_ = _tmp400_;
					_tmp402_ = vala_ccode_variable_declarator_new ("self", NULL, NULL);
					_tmp403_ = _tmp402_;
					vala_ccode_function_add_declaration (_tmp395_, _tmp401_, (ValaCCodeDeclarator*) _tmp403_, 0);
					_vala_ccode_node_unref0 (_tmp403_);
					_g_free0 (_tmp401_);
					_vala_code_node_unref0 (_tmp399_);
					_tmp404_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp405_ = _tmp404_;
					_tmp406_ = vala_ccode_identifier_new ("self");
					_tmp407_ = _tmp406_;
					_tmp408_ = cself;
					vala_ccode_function_add_assignment (_tmp405_, (ValaCCodeExpression*) _tmp407_, (ValaCCodeExpression*) _tmp408_);
					_vala_ccode_node_unref0 (_tmp407_);
					_vala_ccode_node_unref0 (cself);
				}
				{
					ValaList* _type_param_list = NULL;
					ValaMethod* _tmp409_;
					ValaList* _tmp410_;
					gint _type_param_size = 0;
					ValaList* _tmp411_;
					gint _tmp412_;
					gint _tmp413_;
					gint _type_param_index = 0;
					_tmp409_ = m;
					_tmp410_ = vala_method_get_type_parameters (_tmp409_);
					_type_param_list = _tmp410_;
					_tmp411_ = _type_param_list;
					_tmp412_ = vala_collection_get_size ((ValaCollection*) _tmp411_);
					_tmp413_ = _tmp412_;
					_type_param_size = _tmp413_;
					_type_param_index = -1;
					while (TRUE) {
						gint _tmp414_;
						gint _tmp415_;
						gint _tmp416_;
						ValaTypeParameter* type_param = NULL;
						ValaList* _tmp417_;
						gint _tmp418_;
						gpointer _tmp419_;
						gchar* func_name = NULL;
						ValaTypeParameter* _tmp420_;
						const gchar* _tmp421_;
						const gchar* _tmp422_;
						gchar* _tmp423_;
						gchar* _tmp424_;
						gchar* _tmp425_;
						ValaCCodeFunction* _tmp426_;
						ValaCCodeFunction* _tmp427_;
						const gchar* _tmp428_;
						ValaCCodeVariableDeclarator* _tmp429_;
						ValaCCodeVariableDeclarator* _tmp430_;
						ValaCCodeFunction* _tmp431_;
						ValaCCodeFunction* _tmp432_;
						const gchar* _tmp433_;
						ValaCCodeIdentifier* _tmp434_;
						ValaCCodeIdentifier* _tmp435_;
						gint _tmp436_;
						gchar* _tmp437_;
						gchar* _tmp438_;
						ValaCCodeExpression* _tmp439_;
						ValaCCodeExpression* _tmp440_;
						const gchar* _tmp441_;
						ValaCCodeMemberAccess* _tmp442_;
						ValaCCodeMemberAccess* _tmp443_;
						ValaTypeParameter* _tmp444_;
						const gchar* _tmp445_;
						const gchar* _tmp446_;
						gchar* _tmp447_;
						gchar* _tmp448_;
						gchar* _tmp449_;
						ValaCCodeFunction* _tmp450_;
						ValaCCodeFunction* _tmp451_;
						const gchar* _tmp452_;
						ValaCCodeVariableDeclarator* _tmp453_;
						ValaCCodeVariableDeclarator* _tmp454_;
						ValaCCodeFunction* _tmp455_;
						ValaCCodeFunction* _tmp456_;
						const gchar* _tmp457_;
						ValaCCodeIdentifier* _tmp458_;
						ValaCCodeIdentifier* _tmp459_;
						gint _tmp460_;
						gchar* _tmp461_;
						gchar* _tmp462_;
						ValaCCodeExpression* _tmp463_;
						ValaCCodeExpression* _tmp464_;
						const gchar* _tmp465_;
						ValaCCodeMemberAccess* _tmp466_;
						ValaCCodeMemberAccess* _tmp467_;
						ValaTypeParameter* _tmp468_;
						const gchar* _tmp469_;
						const gchar* _tmp470_;
						gchar* _tmp471_;
						gchar* _tmp472_;
						gchar* _tmp473_;
						ValaCCodeFunction* _tmp474_;
						ValaCCodeFunction* _tmp475_;
						const gchar* _tmp476_;
						ValaCCodeVariableDeclarator* _tmp477_;
						ValaCCodeVariableDeclarator* _tmp478_;
						ValaCCodeFunction* _tmp479_;
						ValaCCodeFunction* _tmp480_;
						const gchar* _tmp481_;
						ValaCCodeIdentifier* _tmp482_;
						ValaCCodeIdentifier* _tmp483_;
						gint _tmp484_;
						gchar* _tmp485_;
						gchar* _tmp486_;
						ValaCCodeExpression* _tmp487_;
						ValaCCodeExpression* _tmp488_;
						const gchar* _tmp489_;
						ValaCCodeMemberAccess* _tmp490_;
						ValaCCodeMemberAccess* _tmp491_;
						_tmp414_ = _type_param_index;
						_type_param_index = _tmp414_ + 1;
						_tmp415_ = _type_param_index;
						_tmp416_ = _type_param_size;
						if (!(_tmp415_ < _tmp416_)) {
							break;
						}
						_tmp417_ = _type_param_list;
						_tmp418_ = _type_param_index;
						_tmp419_ = vala_list_get (_tmp417_, _tmp418_);
						type_param = (ValaTypeParameter*) _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_type", _tmp424_);
						_g_free0 (func_name);
						func_name = _tmp425_;
						_g_free0 (_tmp424_);
						_tmp426_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp427_ = _tmp426_;
						_tmp428_ = func_name;
						_tmp429_ = vala_ccode_variable_declarator_new (_tmp428_, NULL, NULL);
						_tmp430_ = _tmp429_;
						vala_ccode_function_add_declaration (_tmp427_, "GType", (ValaCCodeDeclarator*) _tmp430_, 0);
						_vala_ccode_node_unref0 (_tmp430_);
						_tmp431_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp432_ = _tmp431_;
						_tmp433_ = func_name;
						_tmp434_ = vala_ccode_identifier_new (_tmp433_);
						_tmp435_ = _tmp434_;
						_tmp436_ = block_id;
						_tmp437_ = g_strdup_printf ("_data%d_", _tmp436_);
						_tmp438_ = _tmp437_;
						_tmp439_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp438_);
						_tmp440_ = _tmp439_;
						_tmp441_ = func_name;
						_tmp442_ = vala_ccode_member_access_new_pointer (_tmp440_, _tmp441_);
						_tmp443_ = _tmp442_;
						vala_ccode_function_add_assignment (_tmp432_, (ValaCCodeExpression*) _tmp435_, (ValaCCodeExpression*) _tmp443_);
						_vala_ccode_node_unref0 (_tmp443_);
						_vala_ccode_node_unref0 (_tmp440_);
						_g_free0 (_tmp438_);
						_vala_ccode_node_unref0 (_tmp435_);
						_tmp444_ = type_param;
						_tmp445_ = vala_symbol_get_name ((ValaSymbol*) _tmp444_);
						_tmp446_ = _tmp445_;
						_tmp447_ = g_utf8_strdown (_tmp446_, (gssize) -1);
						_tmp448_ = _tmp447_;
						_tmp449_ = g_strdup_printf ("%s_dup_func", _tmp448_);
						_g_free0 (func_name);
						func_name = _tmp449_;
						_g_free0 (_tmp448_);
						_tmp450_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp451_ = _tmp450_;
						_tmp452_ = func_name;
						_tmp453_ = vala_ccode_variable_declarator_new (_tmp452_, NULL, NULL);
						_tmp454_ = _tmp453_;
						vala_ccode_function_add_declaration (_tmp451_, "GBoxedCopyFunc", (ValaCCodeDeclarator*) _tmp454_, 0);
						_vala_ccode_node_unref0 (_tmp454_);
						_tmp455_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp456_ = _tmp455_;
						_tmp457_ = func_name;
						_tmp458_ = vala_ccode_identifier_new (_tmp457_);
						_tmp459_ = _tmp458_;
						_tmp460_ = block_id;
						_tmp461_ = g_strdup_printf ("_data%d_", _tmp460_);
						_tmp462_ = _tmp461_;
						_tmp463_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp462_);
						_tmp464_ = _tmp463_;
						_tmp465_ = func_name;
						_tmp466_ = vala_ccode_member_access_new_pointer (_tmp464_, _tmp465_);
						_tmp467_ = _tmp466_;
						vala_ccode_function_add_assignment (_tmp456_, (ValaCCodeExpression*) _tmp459_, (ValaCCodeExpression*) _tmp467_);
						_vala_ccode_node_unref0 (_tmp467_);
						_vala_ccode_node_unref0 (_tmp464_);
						_g_free0 (_tmp462_);
						_vala_ccode_node_unref0 (_tmp459_);
						_tmp468_ = type_param;
						_tmp469_ = vala_symbol_get_name ((ValaSymbol*) _tmp468_);
						_tmp470_ = _tmp469_;
						_tmp471_ = g_utf8_strdown (_tmp470_, (gssize) -1);
						_tmp472_ = _tmp471_;
						_tmp473_ = g_strdup_printf ("%s_destroy_func", _tmp472_);
						_g_free0 (func_name);
						func_name = _tmp473_;
						_g_free0 (_tmp472_);
						_tmp474_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp475_ = _tmp474_;
						_tmp476_ = func_name;
						_tmp477_ = vala_ccode_variable_declarator_new (_tmp476_, NULL, NULL);
						_tmp478_ = _tmp477_;
						vala_ccode_function_add_declaration (_tmp475_, "GDestroyNotify", (ValaCCodeDeclarator*) _tmp478_, 0);
						_vala_ccode_node_unref0 (_tmp478_);
						_tmp479_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp480_ = _tmp479_;
						_tmp481_ = func_name;
						_tmp482_ = vala_ccode_identifier_new (_tmp481_);
						_tmp483_ = _tmp482_;
						_tmp484_ = block_id;
						_tmp485_ = g_strdup_printf ("_data%d_", _tmp484_);
						_tmp486_ = _tmp485_;
						_tmp487_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp486_);
						_tmp488_ = _tmp487_;
						_tmp489_ = func_name;
						_tmp490_ = vala_ccode_member_access_new_pointer (_tmp488_, _tmp489_);
						_tmp491_ = _tmp490_;
						vala_ccode_function_add_assignment (_tmp480_, (ValaCCodeExpression*) _tmp483_, (ValaCCodeExpression*) _tmp491_);
						_vala_ccode_node_unref0 (_tmp491_);
						_vala_ccode_node_unref0 (_tmp488_);
						_g_free0 (_tmp486_);
						_vala_ccode_node_unref0 (_tmp483_);
						_g_free0 (func_name);
						_vala_code_node_unref0 (type_param);
					}
					_vala_iterable_unref0 (_type_param_list);
				}
				_vala_code_node_unref0 (closure_block);
			} else {
				gboolean _tmp492_ = FALSE;
				ValaMethod* _tmp493_;
				ValaSymbol* _tmp494_;
				ValaSymbol* _tmp495_;
				_tmp493_ = m;
				_tmp494_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp493_);
				_tmp495_ = _tmp494_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp495_, VALA_TYPE_CLASS)) {
					ValaMethod* _tmp496_;
					gboolean _tmp497_;
					gboolean _tmp498_;
					_tmp496_ = m;
					_tmp497_ = vala_method_get_coroutine (_tmp496_);
					_tmp498_ = _tmp497_;
					_tmp492_ = !_tmp498_;
				} else {
					_tmp492_ = FALSE;
				}
				if (_tmp492_) {
					ValaClass* cl = NULL;
					ValaMethod* _tmp499_;
					ValaSymbol* _tmp500_;
					ValaSymbol* _tmp501_;
					ValaClass* _tmp502_;
					gboolean _tmp503_ = FALSE;
					ValaMethod* _tmp504_;
					gboolean _tmp505_;
					gboolean _tmp506_;
					_tmp499_ = m;
					_tmp500_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp499_);
					_tmp501_ = _tmp500_;
					_tmp502_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp501_, VALA_TYPE_CLASS, ValaClass));
					cl = _tmp502_;
					_tmp504_ = m;
					_tmp505_ = vala_method_get_overrides (_tmp504_);
					_tmp506_ = _tmp505_;
					if (_tmp506_) {
						_tmp503_ = TRUE;
					} else {
						gboolean _tmp507_ = FALSE;
						gboolean _tmp508_ = FALSE;
						ValaMethod* _tmp509_;
						ValaMethod* _tmp510_;
						ValaMethod* _tmp511_;
						_tmp509_ = m;
						_tmp510_ = vala_method_get_base_interface_method (_tmp509_);
						_tmp511_ = _tmp510_;
						if (_tmp511_ != NULL) {
							ValaMethod* _tmp512_;
							gboolean _tmp513_;
							gboolean _tmp514_;
							_tmp512_ = m;
							_tmp513_ = vala_method_get_is_abstract (_tmp512_);
							_tmp514_ = _tmp513_;
							_tmp508_ = !_tmp514_;
						} else {
							_tmp508_ = FALSE;
						}
						if (_tmp508_) {
							ValaMethod* _tmp515_;
							gboolean _tmp516_;
							gboolean _tmp517_;
							_tmp515_ = m;
							_tmp516_ = vala_method_get_is_virtual (_tmp515_);
							_tmp517_ = _tmp516_;
							_tmp507_ = !_tmp517_;
						} else {
							_tmp507_ = FALSE;
						}
						_tmp503_ = _tmp507_;
					}
					if (_tmp503_) {
						ValaMethod* base_method = NULL;
						ValaReferenceType* base_expression_type = NULL;
						ValaMethod* _tmp518_;
						gboolean _tmp519_;
						gboolean _tmp520_;
						ValaObjectType* self_target_type = NULL;
						ValaClass* _tmp537_;
						ValaObjectType* _tmp538_;
						ValaCCodeExpression* cself = NULL;
						ValaReferenceType* _tmp539_;
						ValaCCodeIdentifier* _tmp540_;
						ValaCCodeIdentifier* _tmp541_;
						ValaGLibValue* _tmp542_;
						ValaGLibValue* _tmp543_;
						ValaObjectType* _tmp544_;
						ValaMethod* _tmp545_;
						ValaTargetValue* _tmp546_;
						ValaTargetValue* _tmp547_;
						ValaCCodeExpression* _tmp548_;
						ValaCCodeExpression* _tmp549_;
						ValaCCodeFunction* _tmp550_;
						ValaCCodeFunction* _tmp551_;
						ValaClass* _tmp552_;
						gchar* _tmp553_;
						gchar* _tmp554_;
						gchar* _tmp555_;
						gchar* _tmp556_;
						ValaCCodeVariableDeclarator* _tmp557_;
						ValaCCodeVariableDeclarator* _tmp558_;
						ValaCCodeFunction* _tmp559_;
						ValaCCodeFunction* _tmp560_;
						ValaCCodeIdentifier* _tmp561_;
						ValaCCodeIdentifier* _tmp562_;
						ValaCCodeExpression* _tmp563_;
						_tmp518_ = m;
						_tmp519_ = vala_method_get_overrides (_tmp518_);
						_tmp520_ = _tmp519_;
						if (_tmp520_) {
							ValaMethod* _tmp521_;
							ValaMethod* _tmp522_;
							ValaMethod* _tmp523_;
							ValaMethod* _tmp524_;
							ValaMethod* _tmp525_;
							ValaSymbol* _tmp526_;
							ValaSymbol* _tmp527_;
							ValaObjectType* _tmp528_;
							_tmp521_ = m;
							_tmp522_ = vala_method_get_base_method (_tmp521_);
							_tmp523_ = _tmp522_;
							_tmp524_ = _vala_code_node_ref0 (_tmp523_);
							_vala_code_node_unref0 (base_method);
							base_method = _tmp524_;
							_tmp525_ = base_method;
							_tmp526_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp525_);
							_tmp527_ = _tmp526_;
							_tmp528_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp527_, VALA_TYPE_CLASS, ValaClass));
							_vala_code_node_unref0 (base_expression_type);
							base_expression_type = (ValaReferenceType*) _tmp528_;
						} else {
							ValaMethod* _tmp529_;
							ValaMethod* _tmp530_;
							ValaMethod* _tmp531_;
							ValaMethod* _tmp532_;
							ValaMethod* _tmp533_;
							ValaSymbol* _tmp534_;
							ValaSymbol* _tmp535_;
							ValaObjectType* _tmp536_;
							_tmp529_ = m;
							_tmp530_ = vala_method_get_base_interface_method (_tmp529_);
							_tmp531_ = _tmp530_;
							_tmp532_ = _vala_code_node_ref0 (_tmp531_);
							_vala_code_node_unref0 (base_method);
							base_method = _tmp532_;
							_tmp533_ = base_method;
							_tmp534_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp533_);
							_tmp535_ = _tmp534_;
							_tmp536_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp535_, VALA_TYPE_INTERFACE, ValaInterface));
							_vala_code_node_unref0 (base_expression_type);
							base_expression_type = (ValaReferenceType*) _tmp536_;
						}
						_tmp537_ = cl;
						_tmp538_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp537_);
						self_target_type = _tmp538_;
						_tmp539_ = base_expression_type;
						_tmp540_ = vala_ccode_identifier_new ("base");
						_tmp541_ = _tmp540_;
						_tmp542_ = vala_glib_value_new ((ValaDataType*) _tmp539_, (ValaCCodeExpression*) _tmp541_, TRUE);
						_tmp543_ = _tmp542_;
						_tmp544_ = self_target_type;
						_tmp545_ = m;
						_tmp546_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp543_, (ValaDataType*) _tmp544_, (ValaCodeNode*) _tmp545_);
						_tmp547_ = _tmp546_;
						_tmp548_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp547_);
						_tmp549_ = _tmp548_;
						_vala_target_value_unref0 (_tmp547_);
						_vala_target_value_unref0 (_tmp543_);
						_vala_ccode_node_unref0 (_tmp541_);
						cself = _tmp549_;
						_tmp550_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp551_ = _tmp550_;
						_tmp552_ = cl;
						_tmp553_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp552_);
						_tmp554_ = _tmp553_;
						_tmp555_ = g_strdup_printf ("%s *", _tmp554_);
						_tmp556_ = _tmp555_;
						_tmp557_ = vala_ccode_variable_declarator_new ("self", NULL, NULL);
						_tmp558_ = _tmp557_;
						vala_ccode_function_add_declaration (_tmp551_, _tmp556_, (ValaCCodeDeclarator*) _tmp558_, 0);
						_vala_ccode_node_unref0 (_tmp558_);
						_g_free0 (_tmp556_);
						_g_free0 (_tmp554_);
						_tmp559_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp560_ = _tmp559_;
						_tmp561_ = vala_ccode_identifier_new ("self");
						_tmp562_ = _tmp561_;
						_tmp563_ = cself;
						vala_ccode_function_add_assignment (_tmp560_, (ValaCCodeExpression*) _tmp562_, _tmp563_);
						_vala_ccode_node_unref0 (_tmp562_);
						_vala_ccode_node_unref0 (cself);
						_vala_code_node_unref0 (self_target_type);
						_vala_code_node_unref0 (base_expression_type);
						_vala_code_node_unref0 (base_method);
					} else {
						gboolean _tmp564_ = FALSE;
						gboolean _tmp565_ = FALSE;
						gboolean _tmp566_ = FALSE;
						ValaMethod* _tmp567_;
						ValaMemberBinding _tmp568_;
						ValaMemberBinding _tmp569_;
						_tmp567_ = m;
						_tmp568_ = vala_method_get_binding (_tmp567_);
						_tmp569_ = _tmp568_;
						if (_tmp569_ == VALA_MEMBER_BINDING_INSTANCE) {
							ValaMethod* _tmp570_;
							_tmp570_ = m;
							_tmp566_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp570_, VALA_TYPE_CREATION_METHOD);
						} else {
							_tmp566_ = FALSE;
						}
						if (_tmp566_) {
							ValaMethod* _tmp571_;
							ValaMethod* _tmp572_;
							ValaMethod* _tmp573_;
							_tmp571_ = m;
							_tmp572_ = vala_method_get_base_method (_tmp571_);
							_tmp573_ = _tmp572_;
							_tmp565_ = _tmp573_ == NULL;
						} else {
							_tmp565_ = FALSE;
						}
						if (_tmp565_) {
							ValaMethod* _tmp574_;
							ValaMethod* _tmp575_;
							ValaMethod* _tmp576_;
							_tmp574_ = m;
							_tmp575_ = vala_method_get_base_interface_method (_tmp574_);
							_tmp576_ = _tmp575_;
							_tmp564_ = _tmp576_ == NULL;
						} else {
							_tmp564_ = FALSE;
						}
						if (_tmp564_) {
							ValaMethod* _tmp577_;
							ValaDataType* _tmp578_;
							ValaClass* _tmp579_;
							_tmp577_ = m;
							_tmp578_ = creturn_type;
							_tmp579_ = cl;
							vala_ccode_method_module_create_method_type_check_statement (self, _tmp577_, _tmp578_, (ValaTypeSymbol*) _tmp579_, TRUE, "self");
						}
					}
					_vala_code_node_unref0 (cl);
				}
			}
			{
				ValaList* _param_list = NULL;
				ValaMethod* _tmp580_;
				ValaList* _tmp581_;
				gint _param_size = 0;
				ValaList* _tmp582_;
				gint _tmp583_;
				gint _tmp584_;
				gint _param_index = 0;
				_tmp580_ = m;
				_tmp581_ = vala_callable_get_parameters ((ValaCallable*) _tmp580_);
				_param_list = _tmp581_;
				_tmp582_ = _param_list;
				_tmp583_ = vala_collection_get_size ((ValaCollection*) _tmp582_);
				_tmp584_ = _tmp583_;
				_param_size = _tmp584_;
				_param_index = -1;
				while (TRUE) {
					gint _tmp585_;
					gint _tmp586_;
					gint _tmp587_;
					ValaParameter* param = NULL;
					ValaList* _tmp588_;
					gint _tmp589_;
					gpointer _tmp590_;
					ValaParameter* _tmp591_;
					gboolean _tmp592_;
					gboolean _tmp593_;
					ValaParameter* _tmp594_;
					ValaParameterDirection _tmp595_;
					ValaParameterDirection _tmp596_;
					_tmp585_ = _param_index;
					_param_index = _tmp585_ + 1;
					_tmp586_ = _param_index;
					_tmp587_ = _param_size;
					if (!(_tmp586_ < _tmp587_)) {
						break;
					}
					_tmp588_ = _param_list;
					_tmp589_ = _param_index;
					_tmp590_ = vala_list_get (_tmp588_, _tmp589_);
					param = (ValaParameter*) _tmp590_;
					_tmp591_ = param;
					_tmp592_ = vala_parameter_get_ellipsis (_tmp591_);
					_tmp593_ = _tmp592_;
					if (_tmp593_) {
						_vala_code_node_unref0 (param);
						break;
					}
					_tmp594_ = param;
					_tmp595_ = vala_parameter_get_direction (_tmp594_);
					_tmp596_ = _tmp595_;
					if (_tmp596_ != VALA_PARAMETER_DIRECTION_OUT) {
						ValaTypeSymbol* t = NULL;
						ValaParameter* _tmp597_;
						ValaDataType* _tmp598_;
						ValaDataType* _tmp599_;
						ValaTypeSymbol* _tmp600_;
						ValaTypeSymbol* _tmp601_;
						ValaTypeSymbol* _tmp602_;
						gboolean _tmp603_ = FALSE;
						ValaTypeSymbol* _tmp604_;
						_tmp597_ = param;
						_tmp598_ = vala_variable_get_variable_type ((ValaVariable*) _tmp597_);
						_tmp599_ = _tmp598_;
						_tmp600_ = vala_data_type_get_data_type (_tmp599_);
						_tmp601_ = _tmp600_;
						_tmp602_ = _vala_code_node_ref0 (_tmp601_);
						t = _tmp602_;
						_tmp604_ = t;
						if (_tmp604_ != NULL) {
							gboolean _tmp605_ = FALSE;
							ValaTypeSymbol* _tmp606_;
							gboolean _tmp607_;
							_tmp606_ = t;
							_tmp607_ = vala_typesymbol_is_reference_type (_tmp606_);
							if (_tmp607_) {
								_tmp605_ = TRUE;
							} else {
								ValaParameter* _tmp608_;
								ValaDataType* _tmp609_;
								ValaDataType* _tmp610_;
								gboolean _tmp611_;
								_tmp608_ = param;
								_tmp609_ = vala_variable_get_variable_type ((ValaVariable*) _tmp608_);
								_tmp610_ = _tmp609_;
								_tmp611_ = vala_data_type_is_real_struct_type (_tmp610_);
								_tmp605_ = _tmp611_;
							}
							_tmp603_ = _tmp605_;
						} else {
							_tmp603_ = FALSE;
						}
						if (_tmp603_) {
							gchar* cname = NULL;
							ValaParameter* _tmp612_;
							const gchar* _tmp613_;
							const gchar* _tmp614_;
							gchar* _tmp615_;
							gboolean _tmp616_ = FALSE;
							ValaParameter* _tmp617_;
							ValaParameterDirection _tmp618_;
							ValaParameterDirection _tmp619_;
							ValaMethod* _tmp626_;
							ValaDataType* _tmp627_;
							ValaTypeSymbol* _tmp628_;
							ValaParameter* _tmp629_;
							ValaDataType* _tmp630_;
							ValaDataType* _tmp631_;
							gboolean _tmp632_;
							gboolean _tmp633_;
							const gchar* _tmp634_;
							_tmp612_ = param;
							_tmp613_ = vala_symbol_get_name ((ValaSymbol*) _tmp612_);
							_tmp614_ = _tmp613_;
							_tmp615_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp614_);
							cname = _tmp615_;
							_tmp617_ = param;
							_tmp618_ = vala_parameter_get_direction (_tmp617_);
							_tmp619_ = _tmp618_;
							if (_tmp619_ == VALA_PARAMETER_DIRECTION_REF) {
								ValaParameter* _tmp620_;
								ValaDataType* _tmp621_;
								ValaDataType* _tmp622_;
								gboolean _tmp623_;
								_tmp620_ = param;
								_tmp621_ = vala_variable_get_variable_type ((ValaVariable*) _tmp620_);
								_tmp622_ = _tmp621_;
								_tmp623_ = vala_data_type_is_real_struct_type (_tmp622_);
								_tmp616_ = !_tmp623_;
							} else {
								_tmp616_ = FALSE;
							}
							if (_tmp616_) {
								const gchar* _tmp624_;
								gchar* _tmp625_;
								_tmp624_ = cname;
								_tmp625_ = g_strconcat ("*", _tmp624_, NULL);
								_g_free0 (cname);
								cname = _tmp625_;
							}
							_tmp626_ = m;
							_tmp627_ = creturn_type;
							_tmp628_ = t;
							_tmp629_ = param;
							_tmp630_ = vala_variable_get_variable_type ((ValaVariable*) _tmp629_);
							_tmp631_ = _tmp630_;
							_tmp632_ = vala_data_type_get_nullable (_tmp631_);
							_tmp633_ = _tmp632_;
							_tmp634_ = cname;
							vala_ccode_method_module_create_method_type_check_statement (self, _tmp626_, _tmp627_, _tmp628_, !_tmp633_, _tmp634_);
							_g_free0 (cname);
						}
						_vala_code_node_unref0 (t);
					} else {
						ValaMethod* _tmp635_;
						gboolean _tmp636_;
						gboolean _tmp637_;
						_tmp635_ = m;
						_tmp636_ = vala_method_get_coroutine (_tmp635_);
						_tmp637_ = _tmp636_;
						if (!_tmp637_) {
							ValaCCodeVariableDeclarator* vardecl = NULL;
							ValaParameter* _tmp638_;
							const gchar* _tmp639_;
							const gchar* _tmp640_;
							gchar* _tmp641_;
							gchar* _tmp642_;
							gchar* _tmp643_;
							gchar* _tmp644_;
							ValaParameter* _tmp645_;
							ValaDataType* _tmp646_;
							ValaDataType* _tmp647_;
							ValaCCodeExpression* _tmp648_;
							ValaCCodeExpression* _tmp649_;
							ValaCCodeVariableDeclarator* _tmp650_;
							ValaCCodeVariableDeclarator* _tmp651_;
							ValaCCodeFunction* _tmp652_;
							ValaCCodeFunction* _tmp653_;
							ValaParameter* _tmp654_;
							ValaDataType* _tmp655_;
							ValaDataType* _tmp656_;
							gchar* _tmp657_;
							gchar* _tmp658_;
							ValaCCodeVariableDeclarator* _tmp659_;
							ValaParameter* _tmp660_;
							ValaDataType* _tmp661_;
							ValaDataType* _tmp662_;
							_tmp638_ = param;
							_tmp639_ = vala_symbol_get_name ((ValaSymbol*) _tmp638_);
							_tmp640_ = _tmp639_;
							_tmp641_ = g_strdup_printf ("_vala_%s", _tmp640_);
							_tmp642_ = _tmp641_;
							_tmp643_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp642_);
							_tmp644_ = _tmp643_;
							_tmp645_ = param;
							_tmp646_ = vala_variable_get_variable_type ((ValaVariable*) _tmp645_);
							_tmp647_ = _tmp646_;
							_tmp648_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp647_, TRUE);
							_tmp649_ = _tmp648_;
							_tmp650_ = vala_ccode_variable_declarator_new_zero (_tmp644_, _tmp649_, NULL);
							_tmp651_ = _tmp650_;
							_vala_ccode_node_unref0 (_tmp649_);
							_g_free0 (_tmp644_);
							_g_free0 (_tmp642_);
							vardecl = _tmp651_;
							_tmp652_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
							_tmp653_ = _tmp652_;
							_tmp654_ = param;
							_tmp655_ = vala_variable_get_variable_type ((ValaVariable*) _tmp654_);
							_tmp656_ = _tmp655_;
							_tmp657_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp656_);
							_tmp658_ = _tmp657_;
							_tmp659_ = vardecl;
							vala_ccode_function_add_declaration (_tmp653_, _tmp658_, (ValaCCodeDeclarator*) _tmp659_, 0);
							_g_free0 (_tmp658_);
							_tmp660_ = param;
							_tmp661_ = vala_variable_get_variable_type ((ValaVariable*) _tmp660_);
							_tmp662_ = _tmp661_;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp662_, VALA_TYPE_ARRAY_TYPE)) {
								ValaArrayType* array_type = NULL;
								ValaParameter* _tmp663_;
								ValaDataType* _tmp664_;
								ValaDataType* _tmp665_;
								ValaArrayType* _tmp666_;
								ValaArrayType* _tmp667_;
								gboolean _tmp668_;
								gboolean _tmp669_;
								_tmp663_ = param;
								_tmp664_ = vala_variable_get_variable_type ((ValaVariable*) _tmp663_);
								_tmp665_ = _tmp664_;
								_tmp666_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp665_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
								array_type = _tmp666_;
								_tmp667_ = array_type;
								_tmp668_ = vala_array_type_get_fixed_length (_tmp667_);
								_tmp669_ = _tmp668_;
								if (!_tmp669_) {
									{
										gint dim = 0;
										dim = 1;
										{
											gboolean _tmp670_ = FALSE;
											_tmp670_ = TRUE;
											while (TRUE) {
												gint _tmp672_;
												ValaArrayType* _tmp673_;
												gint _tmp674_;
												gint _tmp675_;
												ValaParameter* _tmp676_;
												const gchar* _tmp677_;
												const gchar* _tmp678_;
												gchar* _tmp679_;
												gchar* _tmp680_;
												gchar* _tmp681_;
												gchar* _tmp682_;
												gint _tmp683_;
												gchar* _tmp684_;
												gchar* _tmp685_;
												ValaCCodeConstant* _tmp686_;
												ValaCCodeConstant* _tmp687_;
												ValaCCodeVariableDeclarator* _tmp688_;
												ValaCCodeFunction* _tmp689_;
												ValaCCodeFunction* _tmp690_;
												ValaCCodeVariableDeclarator* _tmp691_;
												if (!_tmp670_) {
													gint _tmp671_;
													_tmp671_ = dim;
													dim = _tmp671_ + 1;
												}
												_tmp670_ = FALSE;
												_tmp672_ = dim;
												_tmp673_ = array_type;
												_tmp674_ = vala_array_type_get_rank (_tmp673_);
												_tmp675_ = _tmp674_;
												if (!(_tmp672_ <= _tmp675_)) {
													break;
												}
												_tmp676_ = param;
												_tmp677_ = vala_symbol_get_name ((ValaSymbol*) _tmp676_);
												_tmp678_ = _tmp677_;
												_tmp679_ = g_strdup_printf ("_vala_%s", _tmp678_);
												_tmp680_ = _tmp679_;
												_tmp681_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp680_);
												_tmp682_ = _tmp681_;
												_tmp683_ = dim;
												_tmp684_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, _tmp682_, _tmp683_);
												_tmp685_ = _tmp684_;
												_tmp686_ = vala_ccode_constant_new ("0");
												_tmp687_ = _tmp686_;
												_tmp688_ = vala_ccode_variable_declarator_new_zero (_tmp685_, (ValaCCodeExpression*) _tmp687_, NULL);
												_vala_ccode_node_unref0 (vardecl);
												vardecl = _tmp688_;
												_vala_ccode_node_unref0 (_tmp687_);
												_g_free0 (_tmp685_);
												_g_free0 (_tmp682_);
												_g_free0 (_tmp680_);
												_tmp689_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
												_tmp690_ = _tmp689_;
												_tmp691_ = vardecl;
												vala_ccode_function_add_declaration (_tmp690_, "int", (ValaCCodeDeclarator*) _tmp691_, 0);
											}
										}
									}
								}
								_vala_code_node_unref0 (array_type);
							} else {
								ValaParameter* _tmp692_;
								ValaDataType* _tmp693_;
								ValaDataType* _tmp694_;
								_tmp692_ = param;
								_tmp693_ = vala_variable_get_variable_type ((ValaVariable*) _tmp692_);
								_tmp694_ = _tmp693_;
								if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp694_, VALA_TYPE_DELEGATE_TYPE)) {
									ValaDelegateType* deleg_type = NULL;
									ValaParameter* _tmp695_;
									ValaDataType* _tmp696_;
									ValaDataType* _tmp697_;
									ValaDelegateType* _tmp698_;
									ValaDelegate* d = NULL;
									ValaDelegateType* _tmp699_;
									ValaDelegate* _tmp700_;
									ValaDelegate* _tmp701_;
									ValaDelegate* _tmp702_;
									ValaDelegate* _tmp703_;
									gboolean _tmp704_;
									gboolean _tmp705_;
									_tmp695_ = param;
									_tmp696_ = vala_variable_get_variable_type ((ValaVariable*) _tmp695_);
									_tmp697_ = _tmp696_;
									_tmp698_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp697_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
									deleg_type = _tmp698_;
									_tmp699_ = deleg_type;
									_tmp700_ = vala_delegate_type_get_delegate_symbol (_tmp699_);
									_tmp701_ = _tmp700_;
									_tmp702_ = _vala_code_node_ref0 (_tmp701_);
									d = _tmp702_;
									_tmp703_ = d;
									_tmp704_ = vala_delegate_get_has_target (_tmp703_);
									_tmp705_ = _tmp704_;
									if (_tmp705_) {
										ValaParameter* _tmp706_;
										gchar* _tmp707_;
										gchar* _tmp708_;
										gchar* _tmp709_;
										gchar* _tmp710_;
										ValaCCodeConstant* _tmp711_;
										ValaCCodeConstant* _tmp712_;
										ValaCCodeVariableDeclarator* _tmp713_;
										ValaCCodeFunction* _tmp714_;
										ValaCCodeFunction* _tmp715_;
										ValaCCodeVariableDeclarator* _tmp716_;
										ValaDelegateType* _tmp717_;
										gboolean _tmp718_;
										_tmp706_ = param;
										_tmp707_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp706_);
										_tmp708_ = _tmp707_;
										_tmp709_ = g_strdup_printf ("_vala_%s", _tmp708_);
										_tmp710_ = _tmp709_;
										_tmp711_ = vala_ccode_constant_new ("NULL");
										_tmp712_ = _tmp711_;
										_tmp713_ = vala_ccode_variable_declarator_new_zero (_tmp710_, (ValaCCodeExpression*) _tmp712_, NULL);
										_vala_ccode_node_unref0 (vardecl);
										vardecl = _tmp713_;
										_vala_ccode_node_unref0 (_tmp712_);
										_g_free0 (_tmp710_);
										_g_free0 (_tmp708_);
										_tmp714_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
										_tmp715_ = _tmp714_;
										_tmp716_ = vardecl;
										vala_ccode_function_add_declaration (_tmp715_, "void *", (ValaCCodeDeclarator*) _tmp716_, 0);
										_tmp717_ = deleg_type;
										_tmp718_ = vala_data_type_is_disposable ((ValaDataType*) _tmp717_);
										if (_tmp718_) {
											ValaParameter* _tmp719_;
											const gchar* _tmp720_;
											const gchar* _tmp721_;
											gchar* _tmp722_;
											gchar* _tmp723_;
											gchar* _tmp724_;
											gchar* _tmp725_;
											gchar* _tmp726_;
											gchar* _tmp727_;
											ValaCCodeConstant* _tmp728_;
											ValaCCodeConstant* _tmp729_;
											ValaCCodeVariableDeclarator* _tmp730_;
											ValaCCodeFunction* _tmp731_;
											ValaCCodeFunction* _tmp732_;
											ValaCCodeVariableDeclarator* _tmp733_;
											_tmp719_ = param;
											_tmp720_ = vala_symbol_get_name ((ValaSymbol*) _tmp719_);
											_tmp721_ = _tmp720_;
											_tmp722_ = g_strdup_printf ("_vala_%s", _tmp721_);
											_tmp723_ = _tmp722_;
											_tmp724_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp723_);
											_tmp725_ = _tmp724_;
											_tmp726_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp725_);
											_tmp727_ = _tmp726_;
											_tmp728_ = vala_ccode_constant_new ("NULL");
											_tmp729_ = _tmp728_;
											_tmp730_ = vala_ccode_variable_declarator_new_zero (_tmp727_, (ValaCCodeExpression*) _tmp729_, NULL);
											_vala_ccode_node_unref0 (vardecl);
											vardecl = _tmp730_;
											_vala_ccode_node_unref0 (_tmp729_);
											_g_free0 (_tmp727_);
											_g_free0 (_tmp725_);
											_g_free0 (_tmp723_);
											_tmp731_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
											_tmp732_ = _tmp731_;
											_tmp733_ = vardecl;
											vala_ccode_function_add_declaration (_tmp732_, "GDestroyNotify", (ValaCCodeDeclarator*) _tmp733_, 0);
										}
									}
									_vala_code_node_unref0 (d);
									_vala_code_node_unref0 (deleg_type);
								}
							}
							_vala_ccode_node_unref0 (vardecl);
						}
					}
					_vala_code_node_unref0 (param);
				}
				_vala_iterable_unref0 (_param_list);
			}
			_tmp736_ = m;
			_tmp737_ = vala_callable_get_return_type ((ValaCallable*) _tmp736_);
			_tmp738_ = _tmp737_;
			if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp738_, VALA_TYPE_VOID_TYPE)) {
				ValaMethod* _tmp739_;
				ValaDataType* _tmp740_;
				ValaDataType* _tmp741_;
				gboolean _tmp742_;
				_tmp739_ = m;
				_tmp740_ = vala_callable_get_return_type ((ValaCallable*) _tmp739_);
				_tmp741_ = _tmp740_;
				_tmp742_ = vala_data_type_is_real_non_null_struct_type (_tmp741_);
				_tmp735_ = !_tmp742_;
			} else {
				_tmp735_ = FALSE;
			}
			if (_tmp735_) {
				ValaMethod* _tmp743_;
				gboolean _tmp744_;
				gboolean _tmp745_;
				_tmp743_ = m;
				_tmp744_ = vala_method_get_coroutine (_tmp743_);
				_tmp745_ = _tmp744_;
				_tmp734_ = !_tmp745_;
			} else {
				_tmp734_ = FALSE;
			}
			if (_tmp734_) {
				ValaCCodeVariableDeclarator* vardecl = NULL;
				ValaMethod* _tmp746_;
				ValaDataType* _tmp747_;
				ValaDataType* _tmp748_;
				ValaCCodeExpression* _tmp749_;
				ValaCCodeExpression* _tmp750_;
				ValaCCodeVariableDeclarator* _tmp751_;
				ValaCCodeVariableDeclarator* _tmp752_;
				ValaCCodeVariableDeclarator* _tmp753_;
				ValaCCodeFunction* _tmp754_;
				ValaCCodeFunction* _tmp755_;
				ValaMethod* _tmp756_;
				ValaDataType* _tmp757_;
				ValaDataType* _tmp758_;
				gchar* _tmp759_;
				gchar* _tmp760_;
				ValaCCodeVariableDeclarator* _tmp761_;
				_tmp746_ = m;
				_tmp747_ = vala_callable_get_return_type ((ValaCallable*) _tmp746_);
				_tmp748_ = _tmp747_;
				_tmp749_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp748_, TRUE);
				_tmp750_ = _tmp749_;
				_tmp751_ = vala_ccode_variable_declarator_new ("result", _tmp750_, NULL);
				_tmp752_ = _tmp751_;
				_vala_ccode_node_unref0 (_tmp750_);
				vardecl = _tmp752_;
				_tmp753_ = vardecl;
				vala_ccode_variable_declarator_set_init0 (_tmp753_, TRUE);
				_tmp754_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp755_ = _tmp754_;
				_tmp756_ = m;
				_tmp757_ = vala_callable_get_return_type ((ValaCallable*) _tmp756_);
				_tmp758_ = _tmp757_;
				_tmp759_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp758_);
				_tmp760_ = _tmp759_;
				_tmp761_ = vardecl;
				vala_ccode_function_add_declaration (_tmp755_, _tmp760_, (ValaCCodeDeclarator*) _tmp761_, 0);
				_g_free0 (_tmp760_);
				_vala_ccode_node_unref0 (vardecl);
			}
			_tmp762_ = m;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp762_, VALA_TYPE_CREATION_METHOD)) {
				gboolean _tmp763_;
				_tmp763_ = in_gobject_creation_method;
				if (_tmp763_) {
					ValaMethod* _tmp764_;
					gboolean _tmp765_;
					gboolean _tmp766_;
					_tmp764_ = m;
					_tmp765_ = vala_method_get_coroutine (_tmp764_);
					_tmp766_ = _tmp765_;
					if (!_tmp766_) {
						ValaCCodeFunction* _tmp767_;
						ValaCCodeFunction* _tmp768_;
						ValaTypeSymbol* _tmp769_;
						ValaTypeSymbol* _tmp770_;
						gchar* _tmp771_;
						gchar* _tmp772_;
						gchar* _tmp773_;
						gchar* _tmp774_;
						ValaCCodeConstant* _tmp775_;
						ValaCCodeConstant* _tmp776_;
						ValaCCodeVariableDeclarator* _tmp777_;
						ValaCCodeVariableDeclarator* _tmp778_;
						_tmp767_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp768_ = _tmp767_;
						_tmp769_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
						_tmp770_ = _tmp769_;
						_tmp771_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp770_);
						_tmp772_ = _tmp771_;
						_tmp773_ = g_strdup_printf ("%s *", _tmp772_);
						_tmp774_ = _tmp773_;
						_tmp775_ = vala_ccode_constant_new ("NULL");
						_tmp776_ = _tmp775_;
						_tmp777_ = vala_ccode_variable_declarator_new_zero ("self", (ValaCCodeExpression*) _tmp776_, NULL);
						_tmp778_ = _tmp777_;
						vala_ccode_function_add_declaration (_tmp768_, _tmp774_, (ValaCCodeDeclarator*) _tmp778_, 0);
						_vala_ccode_node_unref0 (_tmp778_);
						_vala_ccode_node_unref0 (_tmp776_);
						_g_free0 (_tmp774_);
						_g_free0 (_tmp772_);
					}
				} else {
					ValaMethod* _tmp779_;
					gboolean _tmp780_;
					_tmp779_ = m;
					_tmp780_ = vala_ccode_method_module_is_gtypeinstance_creation_method (self, _tmp779_);
					if (_tmp780_) {
						ValaClass* cl = NULL;
						ValaMethod* _tmp781_;
						ValaSymbol* _tmp782_;
						ValaSymbol* _tmp783_;
						ValaClass* _tmp784_;
						ValaCCodeFunction* _tmp785_;
						ValaCCodeFunction* _tmp786_;
						ValaClass* _tmp787_;
						gchar* _tmp788_;
						gchar* _tmp789_;
						gchar* _tmp790_;
						gchar* _tmp791_;
						ValaCCodeConstant* _tmp792_;
						ValaCCodeConstant* _tmp793_;
						ValaCCodeVariableDeclarator* _tmp794_;
						ValaCCodeVariableDeclarator* _tmp795_;
						gboolean _tmp796_ = FALSE;
						ValaClass* _tmp797_;
						gboolean _tmp798_;
						_tmp781_ = m;
						_tmp782_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp781_);
						_tmp783_ = _tmp782_;
						_tmp784_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp783_, VALA_TYPE_CLASS, ValaClass));
						cl = _tmp784_;
						_tmp785_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp786_ = _tmp785_;
						_tmp787_ = cl;
						_tmp788_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp787_);
						_tmp789_ = _tmp788_;
						_tmp790_ = g_strconcat (_tmp789_, "*", NULL);
						_tmp791_ = _tmp790_;
						_tmp792_ = vala_ccode_constant_new ("NULL");
						_tmp793_ = _tmp792_;
						_tmp794_ = vala_ccode_variable_declarator_new_zero ("self", (ValaCCodeExpression*) _tmp793_, NULL);
						_tmp795_ = _tmp794_;
						vala_ccode_function_add_declaration (_tmp786_, _tmp791_, (ValaCCodeDeclarator*) _tmp795_, 0);
						_vala_ccode_node_unref0 (_tmp795_);
						_vala_ccode_node_unref0 (_tmp793_);
						_g_free0 (_tmp791_);
						_g_free0 (_tmp789_);
						_tmp797_ = cl;
						_tmp798_ = vala_class_is_fundamental (_tmp797_);
						if (_tmp798_) {
							ValaMethod* _tmp799_;
							gboolean _tmp800_;
							gboolean _tmp801_;
							_tmp799_ = m;
							_tmp800_ = vala_creation_method_get_chain_up (G_TYPE_CHECK_INSTANCE_CAST (_tmp799_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
							_tmp801_ = _tmp800_;
							_tmp796_ = !_tmp801_;
						} else {
							_tmp796_ = FALSE;
						}
						if (_tmp796_) {
							ValaCCodeFunctionCall* ccall = NULL;
							ValaCCodeIdentifier* _tmp802_;
							ValaCCodeIdentifier* _tmp803_;
							ValaCCodeFunctionCall* _tmp804_;
							ValaCCodeFunctionCall* _tmp805_;
							ValaCCodeFunctionCall* _tmp806_;
							ValaCCodeExpression* _tmp807_;
							ValaCCodeExpression* _tmp808_;
							ValaCCodeFunction* _tmp809_;
							ValaCCodeFunction* _tmp810_;
							ValaCCodeExpression* _tmp811_;
							ValaCCodeExpression* _tmp812_;
							ValaCCodeFunctionCall* _tmp813_;
							ValaClass* _tmp814_;
							gchar* _tmp815_;
							gchar* _tmp816_;
							gchar* _tmp817_;
							gchar* _tmp818_;
							ValaCCodeCastExpression* _tmp819_;
							ValaCCodeCastExpression* _tmp820_;
							_tmp802_ = vala_ccode_identifier_new ("g_type_create_instance");
							_tmp803_ = _tmp802_;
							_tmp804_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp803_);
							_tmp805_ = _tmp804_;
							_vala_ccode_node_unref0 (_tmp803_);
							ccall = _tmp805_;
							_tmp806_ = ccall;
							_tmp807_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "object_type");
							_tmp808_ = _tmp807_;
							vala_ccode_function_call_add_argument (_tmp806_, _tmp808_);
							_vala_ccode_node_unref0 (_tmp808_);
							_tmp809_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
							_tmp810_ = _tmp809_;
							_tmp811_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self);
							_tmp812_ = _tmp811_;
							_tmp813_ = ccall;
							_tmp814_ = cl;
							_tmp815_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp814_);
							_tmp816_ = _tmp815_;
							_tmp817_ = g_strconcat (_tmp816_, "*", NULL);
							_tmp818_ = _tmp817_;
							_tmp819_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp813_, _tmp818_);
							_tmp820_ = _tmp819_;
							vala_ccode_function_add_assignment (_tmp810_, _tmp812_, (ValaCCodeExpression*) _tmp820_);
							_vala_ccode_node_unref0 (_tmp820_);
							_g_free0 (_tmp818_);
							_g_free0 (_tmp816_);
							_vala_ccode_node_unref0 (_tmp812_);
							{
								ValaList* _type_param_list = NULL;
								ValaClass* _tmp821_;
								ValaClass* _tmp822_;
								ValaList* _tmp823_;
								gint _type_param_size = 0;
								ValaList* _tmp824_;
								gint _tmp825_;
								gint _tmp826_;
								gint _type_param_index = 0;
								_tmp821_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
								_tmp822_ = _tmp821_;
								_tmp823_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp822_);
								_type_param_list = _tmp823_;
								_tmp824_ = _type_param_list;
								_tmp825_ = vala_collection_get_size ((ValaCollection*) _tmp824_);
								_tmp826_ = _tmp825_;
								_type_param_size = _tmp826_;
								_type_param_index = -1;
								while (TRUE) {
									gint _tmp827_;
									gint _tmp828_;
									gint _tmp829_;
									ValaTypeParameter* type_param = NULL;
									ValaList* _tmp830_;
									gint _tmp831_;
									gpointer _tmp832_;
									ValaCCodeIdentifier* param_name = NULL;
									ValaCCodeAssignment* assign = NULL;
									ValaCCodeMemberAccess* priv_access = NULL;
									ValaCCodeIdentifier* _tmp833_;
									ValaCCodeIdentifier* _tmp834_;
									ValaCCodeMemberAccess* _tmp835_;
									ValaCCodeMemberAccess* _tmp836_;
									ValaTypeParameter* _tmp837_;
									const gchar* _tmp838_;
									const gchar* _tmp839_;
									gchar* _tmp840_;
									gchar* _tmp841_;
									gchar* _tmp842_;
									gchar* _tmp843_;
									ValaCCodeIdentifier* _tmp844_;
									ValaCCodeMemberAccess* _tmp845_;
									ValaCCodeIdentifier* _tmp846_;
									const gchar* _tmp847_;
									const gchar* _tmp848_;
									ValaCCodeMemberAccess* _tmp849_;
									ValaCCodeMemberAccess* _tmp850_;
									ValaCCodeIdentifier* _tmp851_;
									ValaCCodeAssignment* _tmp852_;
									ValaCCodeFunction* _tmp853_;
									ValaCCodeFunction* _tmp854_;
									ValaCCodeAssignment* _tmp855_;
									ValaTypeParameter* _tmp856_;
									const gchar* _tmp857_;
									const gchar* _tmp858_;
									gchar* _tmp859_;
									gchar* _tmp860_;
									gchar* _tmp861_;
									gchar* _tmp862_;
									ValaCCodeIdentifier* _tmp863_;
									ValaCCodeMemberAccess* _tmp864_;
									ValaCCodeIdentifier* _tmp865_;
									const gchar* _tmp866_;
									const gchar* _tmp867_;
									ValaCCodeMemberAccess* _tmp868_;
									ValaCCodeMemberAccess* _tmp869_;
									ValaCCodeIdentifier* _tmp870_;
									ValaCCodeAssignment* _tmp871_;
									ValaCCodeFunction* _tmp872_;
									ValaCCodeFunction* _tmp873_;
									ValaCCodeAssignment* _tmp874_;
									ValaTypeParameter* _tmp875_;
									const gchar* _tmp876_;
									const gchar* _tmp877_;
									gchar* _tmp878_;
									gchar* _tmp879_;
									gchar* _tmp880_;
									gchar* _tmp881_;
									ValaCCodeIdentifier* _tmp882_;
									ValaCCodeMemberAccess* _tmp883_;
									ValaCCodeIdentifier* _tmp884_;
									const gchar* _tmp885_;
									const gchar* _tmp886_;
									ValaCCodeMemberAccess* _tmp887_;
									ValaCCodeMemberAccess* _tmp888_;
									ValaCCodeIdentifier* _tmp889_;
									ValaCCodeAssignment* _tmp890_;
									ValaCCodeFunction* _tmp891_;
									ValaCCodeFunction* _tmp892_;
									ValaCCodeAssignment* _tmp893_;
									_tmp827_ = _type_param_index;
									_type_param_index = _tmp827_ + 1;
									_tmp828_ = _type_param_index;
									_tmp829_ = _type_param_size;
									if (!(_tmp828_ < _tmp829_)) {
										break;
									}
									_tmp830_ = _type_param_list;
									_tmp831_ = _type_param_index;
									_tmp832_ = vala_list_get (_tmp830_, _tmp831_);
									type_param = (ValaTypeParameter*) _tmp832_;
									_tmp833_ = vala_ccode_identifier_new ("self");
									_tmp834_ = _tmp833_;
									_tmp835_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp834_, "priv");
									_tmp836_ = _tmp835_;
									_vala_ccode_node_unref0 (_tmp834_);
									priv_access = _tmp836_;
									_tmp837_ = type_param;
									_tmp838_ = vala_symbol_get_name ((ValaSymbol*) _tmp837_);
									_tmp839_ = _tmp838_;
									_tmp840_ = g_utf8_strdown (_tmp839_, (gssize) -1);
									_tmp841_ = _tmp840_;
									_tmp842_ = g_strdup_printf ("%s_type", _tmp841_);
									_tmp843_ = _tmp842_;
									_tmp844_ = vala_ccode_identifier_new (_tmp843_);
									_vala_ccode_node_unref0 (param_name);
									param_name = _tmp844_;
									_g_free0 (_tmp843_);
									_g_free0 (_tmp841_);
									_tmp845_ = priv_access;
									_tmp846_ = param_name;
									_tmp847_ = vala_ccode_identifier_get_name (_tmp846_);
									_tmp848_ = _tmp847_;
									_tmp849_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp845_, _tmp848_);
									_tmp850_ = _tmp849_;
									_tmp851_ = param_name;
									_tmp852_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp850_, (ValaCCodeExpression*) _tmp851_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
									_vala_ccode_node_unref0 (assign);
									assign = _tmp852_;
									_vala_ccode_node_unref0 (_tmp850_);
									_tmp853_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
									_tmp854_ = _tmp853_;
									_tmp855_ = assign;
									vala_ccode_function_add_expression (_tmp854_, (ValaCCodeExpression*) _tmp855_);
									_tmp856_ = type_param;
									_tmp857_ = vala_symbol_get_name ((ValaSymbol*) _tmp856_);
									_tmp858_ = _tmp857_;
									_tmp859_ = g_utf8_strdown (_tmp858_, (gssize) -1);
									_tmp860_ = _tmp859_;
									_tmp861_ = g_strdup_printf ("%s_dup_func", _tmp860_);
									_tmp862_ = _tmp861_;
									_tmp863_ = vala_ccode_identifier_new (_tmp862_);
									_vala_ccode_node_unref0 (param_name);
									param_name = _tmp863_;
									_g_free0 (_tmp862_);
									_g_free0 (_tmp860_);
									_tmp864_ = priv_access;
									_tmp865_ = param_name;
									_tmp866_ = vala_ccode_identifier_get_name (_tmp865_);
									_tmp867_ = _tmp866_;
									_tmp868_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp864_, _tmp867_);
									_tmp869_ = _tmp868_;
									_tmp870_ = param_name;
									_tmp871_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp869_, (ValaCCodeExpression*) _tmp870_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
									_vala_ccode_node_unref0 (assign);
									assign = _tmp871_;
									_vala_ccode_node_unref0 (_tmp869_);
									_tmp872_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
									_tmp873_ = _tmp872_;
									_tmp874_ = assign;
									vala_ccode_function_add_expression (_tmp873_, (ValaCCodeExpression*) _tmp874_);
									_tmp875_ = type_param;
									_tmp876_ = vala_symbol_get_name ((ValaSymbol*) _tmp875_);
									_tmp877_ = _tmp876_;
									_tmp878_ = g_utf8_strdown (_tmp877_, (gssize) -1);
									_tmp879_ = _tmp878_;
									_tmp880_ = g_strdup_printf ("%s_destroy_func", _tmp879_);
									_tmp881_ = _tmp880_;
									_tmp882_ = vala_ccode_identifier_new (_tmp881_);
									_vala_ccode_node_unref0 (param_name);
									param_name = _tmp882_;
									_g_free0 (_tmp881_);
									_g_free0 (_tmp879_);
									_tmp883_ = priv_access;
									_tmp884_ = param_name;
									_tmp885_ = vala_ccode_identifier_get_name (_tmp884_);
									_tmp886_ = _tmp885_;
									_tmp887_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp883_, _tmp886_);
									_tmp888_ = _tmp887_;
									_tmp889_ = param_name;
									_tmp890_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp888_, (ValaCCodeExpression*) _tmp889_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
									_vala_ccode_node_unref0 (assign);
									assign = _tmp890_;
									_vala_ccode_node_unref0 (_tmp888_);
									_tmp891_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
									_tmp892_ = _tmp891_;
									_tmp893_ = assign;
									vala_ccode_function_add_expression (_tmp892_, (ValaCCodeExpression*) _tmp893_);
									_vala_ccode_node_unref0 (priv_access);
									_vala_ccode_node_unref0 (assign);
									_vala_ccode_node_unref0 (param_name);
									_vala_code_node_unref0 (type_param);
								}
								_vala_iterable_unref0 (_type_param_list);
							}
							_vala_ccode_node_unref0 (ccall);
						}
						_vala_code_node_unref0 (cl);
					} else {
						ValaTypeSymbol* _tmp894_;
						ValaTypeSymbol* _tmp895_;
						_tmp894_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
						_tmp895_ = _tmp894_;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp895_, VALA_TYPE_CLASS)) {
							ValaClass* cl = NULL;
							ValaMethod* _tmp896_;
							ValaSymbol* _tmp897_;
							ValaSymbol* _tmp898_;
							ValaClass* _tmp899_;
							ValaMethod* _tmp900_;
							gboolean _tmp901_;
							gboolean _tmp902_;
							ValaMethod* _tmp912_;
							gboolean _tmp913_;
							gboolean _tmp914_;
							ValaClass* _tmp930_;
							ValaClass* _tmp931_;
							ValaClass* _tmp932_;
							_tmp896_ = m;
							_tmp897_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp896_);
							_tmp898_ = _tmp897_;
							_tmp899_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp898_, VALA_TYPE_CLASS, ValaClass));
							cl = _tmp899_;
							_tmp900_ = m;
							_tmp901_ = vala_method_get_coroutine (_tmp900_);
							_tmp902_ = _tmp901_;
							if (!_tmp902_) {
								ValaCCodeFunction* _tmp903_;
								ValaCCodeFunction* _tmp904_;
								ValaClass* _tmp905_;
								gchar* _tmp906_;
								gchar* _tmp907_;
								gchar* _tmp908_;
								gchar* _tmp909_;
								ValaCCodeVariableDeclarator* _tmp910_;
								ValaCCodeVariableDeclarator* _tmp911_;
								_tmp903_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
								_tmp904_ = _tmp903_;
								_tmp905_ = cl;
								_tmp906_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp905_);
								_tmp907_ = _tmp906_;
								_tmp908_ = g_strconcat (_tmp907_, "*", NULL);
								_tmp909_ = _tmp908_;
								_tmp910_ = vala_ccode_variable_declarator_new ("self", NULL, NULL);
								_tmp911_ = _tmp910_;
								vala_ccode_function_add_declaration (_tmp904_, _tmp909_, (ValaCCodeDeclarator*) _tmp911_, 0);
								_vala_ccode_node_unref0 (_tmp911_);
								_g_free0 (_tmp909_);
								_g_free0 (_tmp907_);
							}
							_tmp912_ = m;
							_tmp913_ = vala_creation_method_get_chain_up (G_TYPE_CHECK_INSTANCE_CAST (_tmp912_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
							_tmp914_ = _tmp913_;
							if (!_tmp914_) {
								ValaCCodeFunctionCall* ccall = NULL;
								ValaCCodeIdentifier* _tmp915_;
								ValaCCodeIdentifier* _tmp916_;
								ValaCCodeFunctionCall* _tmp917_;
								ValaCCodeFunctionCall* _tmp918_;
								ValaCCodeFunctionCall* _tmp919_;
								ValaClass* _tmp920_;
								gchar* _tmp921_;
								gchar* _tmp922_;
								ValaCCodeIdentifier* _tmp923_;
								ValaCCodeIdentifier* _tmp924_;
								ValaCCodeFunction* _tmp925_;
								ValaCCodeFunction* _tmp926_;
								ValaCCodeExpression* _tmp927_;
								ValaCCodeExpression* _tmp928_;
								ValaCCodeFunctionCall* _tmp929_;
								_tmp915_ = vala_ccode_identifier_new ("g_slice_new0");
								_tmp916_ = _tmp915_;
								_tmp917_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp916_);
								_tmp918_ = _tmp917_;
								_vala_ccode_node_unref0 (_tmp916_);
								ccall = _tmp918_;
								_tmp919_ = ccall;
								_tmp920_ = cl;
								_tmp921_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp920_);
								_tmp922_ = _tmp921_;
								_tmp923_ = vala_ccode_identifier_new (_tmp922_);
								_tmp924_ = _tmp923_;
								vala_ccode_function_call_add_argument (_tmp919_, (ValaCCodeExpression*) _tmp924_);
								_vala_ccode_node_unref0 (_tmp924_);
								_g_free0 (_tmp922_);
								_tmp925_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
								_tmp926_ = _tmp925_;
								_tmp927_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self);
								_tmp928_ = _tmp927_;
								_tmp929_ = ccall;
								vala_ccode_function_add_assignment (_tmp926_, _tmp928_, (ValaCCodeExpression*) _tmp929_);
								_vala_ccode_node_unref0 (_tmp928_);
								_vala_ccode_node_unref0 (ccall);
							}
							_tmp930_ = cl;
							_tmp931_ = vala_class_get_base_class (_tmp930_);
							_tmp932_ = _tmp931_;
							if (_tmp932_ == NULL) {
								ValaCCodeFunctionCall* cinitcall = NULL;
								ValaClass* _tmp933_;
								gchar* _tmp934_;
								gchar* _tmp935_;
								gchar* _tmp936_;
								gchar* _tmp937_;
								ValaCCodeIdentifier* _tmp938_;
								ValaCCodeIdentifier* _tmp939_;
								ValaCCodeFunctionCall* _tmp940_;
								ValaCCodeFunctionCall* _tmp941_;
								ValaCCodeFunctionCall* _tmp942_;
								ValaCCodeExpression* _tmp943_;
								ValaCCodeExpression* _tmp944_;
								ValaCCodeFunction* _tmp945_;
								ValaCCodeFunction* _tmp946_;
								ValaCCodeFunctionCall* _tmp947_;
								_tmp933_ = cl;
								_tmp934_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp933_, NULL);
								_tmp935_ = _tmp934_;
								_tmp936_ = g_strdup_printf ("%s_instance_init", _tmp935_);
								_tmp937_ = _tmp936_;
								_tmp938_ = vala_ccode_identifier_new (_tmp937_);
								_tmp939_ = _tmp938_;
								_tmp940_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp939_);
								_tmp941_ = _tmp940_;
								_vala_ccode_node_unref0 (_tmp939_);
								_g_free0 (_tmp937_);
								_g_free0 (_tmp935_);
								cinitcall = _tmp941_;
								_tmp942_ = cinitcall;
								_tmp943_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self);
								_tmp944_ = _tmp943_;
								vala_ccode_function_call_add_argument (_tmp942_, _tmp944_);
								_vala_ccode_node_unref0 (_tmp944_);
								_tmp945_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
								_tmp946_ = _tmp945_;
								_tmp947_ = cinitcall;
								vala_ccode_function_add_expression (_tmp946_, (ValaCCodeExpression*) _tmp947_);
								_vala_ccode_node_unref0 (cinitcall);
							}
							_vala_code_node_unref0 (cl);
						} else {
							ValaStruct* st = NULL;
							ValaMethod* _tmp948_;
							ValaSymbol* _tmp949_;
							ValaSymbol* _tmp950_;
							ValaStruct* _tmp951_;
							ValaCCodeFile* _tmp952_;
							ValaCCodeFunctionCall* czero = NULL;
							ValaCCodeIdentifier* _tmp953_;
							ValaCCodeIdentifier* _tmp954_;
							ValaCCodeFunctionCall* _tmp955_;
							ValaCCodeFunctionCall* _tmp956_;
							ValaCCodeFunctionCall* _tmp957_;
							ValaCCodeIdentifier* _tmp958_;
							ValaCCodeIdentifier* _tmp959_;
							ValaCCodeFunctionCall* _tmp960_;
							ValaCCodeConstant* _tmp961_;
							ValaCCodeConstant* _tmp962_;
							ValaCCodeFunctionCall* _tmp963_;
							ValaStruct* _tmp964_;
							gchar* _tmp965_;
							gchar* _tmp966_;
							gchar* _tmp967_;
							gchar* _tmp968_;
							ValaCCodeIdentifier* _tmp969_;
							ValaCCodeIdentifier* _tmp970_;
							ValaCCodeFunction* _tmp971_;
							ValaCCodeFunction* _tmp972_;
							ValaCCodeFunctionCall* _tmp973_;
							_tmp948_ = m;
							_tmp949_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp948_);
							_tmp950_ = _tmp949_;
							_tmp951_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp950_, VALA_TYPE_STRUCT, ValaStruct));
							st = _tmp951_;
							_tmp952_ = ((ValaCCodeBaseModule*) self)->cfile;
							vala_ccode_file_add_include (_tmp952_, "string.h", FALSE);
							_tmp953_ = vala_ccode_identifier_new ("memset");
							_tmp954_ = _tmp953_;
							_tmp955_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp954_);
							_tmp956_ = _tmp955_;
							_vala_ccode_node_unref0 (_tmp954_);
							czero = _tmp956_;
							_tmp957_ = czero;
							_tmp958_ = vala_ccode_identifier_new ("self");
							_tmp959_ = _tmp958_;
							vala_ccode_function_call_add_argument (_tmp957_, (ValaCCodeExpression*) _tmp959_);
							_vala_ccode_node_unref0 (_tmp959_);
							_tmp960_ = czero;
							_tmp961_ = vala_ccode_constant_new ("0");
							_tmp962_ = _tmp961_;
							vala_ccode_function_call_add_argument (_tmp960_, (ValaCCodeExpression*) _tmp962_);
							_vala_ccode_node_unref0 (_tmp962_);
							_tmp963_ = czero;
							_tmp964_ = st;
							_tmp965_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp964_);
							_tmp966_ = _tmp965_;
							_tmp967_ = g_strdup_printf ("sizeof (%s)", _tmp966_);
							_tmp968_ = _tmp967_;
							_tmp969_ = vala_ccode_identifier_new (_tmp968_);
							_tmp970_ = _tmp969_;
							vala_ccode_function_call_add_argument (_tmp963_, (ValaCCodeExpression*) _tmp970_);
							_vala_ccode_node_unref0 (_tmp970_);
							_g_free0 (_tmp968_);
							_g_free0 (_tmp966_);
							_tmp971_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
							_tmp972_ = _tmp971_;
							_tmp973_ = czero;
							vala_ccode_function_add_expression (_tmp972_, (ValaCCodeExpression*) _tmp973_);
							_vala_ccode_node_unref0 (czero);
							_vala_code_node_unref0 (st);
						}
					}
				}
			}
			_tmp975_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
			_tmp976_ = _tmp975_;
			_tmp977_ = vala_code_context_get_module_init_method (_tmp976_);
			_tmp978_ = _tmp977_;
			_tmp979_ = m;
			if (_tmp978_ == _tmp979_) {
				gboolean _tmp980_;
				_tmp980_ = ((ValaCCodeBaseModule*) self)->in_plugin;
				_tmp974_ = _tmp980_;
			} else {
				_tmp974_ = FALSE;
			}
			if (_tmp974_) {
				ValaCodeContext* _tmp981_;
				ValaCodeContext* _tmp982_;
				ValaNamespace* _tmp983_;
				ValaNamespace* _tmp984_;
				GHashFunc _tmp985_;
				GEqualFunc _tmp986_;
				ValaHashSet* _tmp987_;
				ValaHashSet* _tmp988_;
				_tmp981_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
				_tmp982_ = _tmp981_;
				_tmp983_ = vala_code_context_get_root (_tmp982_);
				_tmp984_ = _tmp983_;
				_tmp985_ = g_direct_hash;
				_tmp986_ = g_direct_equal;
				_tmp987_ = vala_hash_set_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp985_, _tmp986_);
				_tmp988_ = _tmp987_;
				vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp984_, (ValaSet*) _tmp988_);
				_vala_iterable_unref0 (_tmp988_);
			}
			{
				ValaList* _precondition_list = NULL;
				ValaMethod* _tmp989_;
				ValaList* _tmp990_;
				gint _precondition_size = 0;
				ValaList* _tmp991_;
				gint _tmp992_;
				gint _tmp993_;
				gint _precondition_index = 0;
				_tmp989_ = m;
				_tmp990_ = vala_method_get_preconditions (_tmp989_);
				_precondition_list = _tmp990_;
				_tmp991_ = _precondition_list;
				_tmp992_ = vala_collection_get_size ((ValaCollection*) _tmp991_);
				_tmp993_ = _tmp992_;
				_precondition_size = _tmp993_;
				_precondition_index = -1;
				while (TRUE) {
					gint _tmp994_;
					gint _tmp995_;
					gint _tmp996_;
					ValaExpression* precondition = NULL;
					ValaList* _tmp997_;
					gint _tmp998_;
					gpointer _tmp999_;
					ValaMethod* _tmp1000_;
					ValaDataType* _tmp1001_;
					ValaExpression* _tmp1002_;
					_tmp994_ = _precondition_index;
					_precondition_index = _tmp994_ + 1;
					_tmp995_ = _precondition_index;
					_tmp996_ = _precondition_size;
					if (!(_tmp995_ < _tmp996_)) {
						break;
					}
					_tmp997_ = _precondition_list;
					_tmp998_ = _precondition_index;
					_tmp999_ = vala_list_get (_tmp997_, _tmp998_);
					precondition = (ValaExpression*) _tmp999_;
					_tmp1000_ = m;
					_tmp1001_ = creturn_type;
					_tmp1002_ = precondition;
					vala_ccode_method_module_create_precondition_statement (self, (ValaCodeNode*) _tmp1000_, _tmp1001_, _tmp1002_);
					_vala_code_node_unref0 (precondition);
				}
				_vala_iterable_unref0 (_precondition_list);
			}
		}
	}
	_tmp1003_ = profile;
	if (_tmp1003_) {
		gchar* prefix = NULL;
		const gchar* _tmp1004_;
		gchar* _tmp1005_;
		ValaCCodeIdentifier* level = NULL;
		const gchar* _tmp1006_;
		gchar* _tmp1007_;
		gchar* _tmp1008_;
		ValaCCodeIdentifier* _tmp1009_;
		ValaCCodeIdentifier* _tmp1010_;
		ValaCCodeFunction* _tmp1011_;
		ValaCCodeFunction* _tmp1012_;
		ValaCCodeIdentifier* _tmp1013_;
		ValaCCodeUnaryExpression* _tmp1014_;
		ValaCCodeUnaryExpression* _tmp1015_;
		ValaCCodeUnaryExpression* _tmp1016_;
		ValaCCodeUnaryExpression* _tmp1017_;
		ValaCCodeIdentifier* counter = NULL;
		const gchar* _tmp1018_;
		gchar* _tmp1019_;
		gchar* _tmp1020_;
		ValaCCodeIdentifier* _tmp1021_;
		ValaCCodeIdentifier* _tmp1022_;
		ValaCCodeFunction* _tmp1023_;
		ValaCCodeFunction* _tmp1024_;
		ValaCCodeIdentifier* _tmp1025_;
		ValaCCodeUnaryExpression* _tmp1026_;
		ValaCCodeUnaryExpression* _tmp1027_;
		ValaCCodeIdentifier* timer = NULL;
		const gchar* _tmp1028_;
		gchar* _tmp1029_;
		gchar* _tmp1030_;
		ValaCCodeIdentifier* _tmp1031_;
		ValaCCodeIdentifier* _tmp1032_;
		ValaCCodeFunctionCall* cont_call = NULL;
		ValaCCodeIdentifier* _tmp1033_;
		ValaCCodeIdentifier* _tmp1034_;
		ValaCCodeFunctionCall* _tmp1035_;
		ValaCCodeFunctionCall* _tmp1036_;
		ValaCCodeFunctionCall* _tmp1037_;
		ValaCCodeIdentifier* _tmp1038_;
		ValaCCodeFunction* _tmp1039_;
		ValaCCodeFunction* _tmp1040_;
		ValaCCodeFunctionCall* _tmp1041_;
		ValaCCodeFunction* _tmp1042_;
		ValaCCodeFunction* _tmp1043_;
		_tmp1004_ = real_name;
		_tmp1005_ = g_strdup_printf ("_vala_prof_%s", _tmp1004_);
		prefix = _tmp1005_;
		_tmp1006_ = prefix;
		_tmp1007_ = g_strconcat (_tmp1006_, "_level", NULL);
		_tmp1008_ = _tmp1007_;
		_tmp1009_ = vala_ccode_identifier_new (_tmp1008_);
		_tmp1010_ = _tmp1009_;
		_g_free0 (_tmp1008_);
		level = _tmp1010_;
		_tmp1011_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1012_ = _tmp1011_;
		_tmp1013_ = level;
		_tmp1014_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp1013_);
		_tmp1015_ = _tmp1014_;
		_tmp1016_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp1015_);
		_tmp1017_ = _tmp1016_;
		vala_ccode_function_open_if (_tmp1012_, (ValaCCodeExpression*) _tmp1017_);
		_vala_ccode_node_unref0 (_tmp1017_);
		_vala_ccode_node_unref0 (_tmp1015_);
		_tmp1018_ = prefix;
		_tmp1019_ = g_strconcat (_tmp1018_, "_counter", NULL);
		_tmp1020_ = _tmp1019_;
		_tmp1021_ = vala_ccode_identifier_new (_tmp1020_);
		_tmp1022_ = _tmp1021_;
		_g_free0 (_tmp1020_);
		counter = _tmp1022_;
		_tmp1023_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1024_ = _tmp1023_;
		_tmp1025_ = counter;
		_tmp1026_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp1025_);
		_tmp1027_ = _tmp1026_;
		vala_ccode_function_add_expression (_tmp1024_, (ValaCCodeExpression*) _tmp1027_);
		_vala_ccode_node_unref0 (_tmp1027_);
		_tmp1028_ = prefix;
		_tmp1029_ = g_strconcat (_tmp1028_, "_timer", NULL);
		_tmp1030_ = _tmp1029_;
		_tmp1031_ = vala_ccode_identifier_new (_tmp1030_);
		_tmp1032_ = _tmp1031_;
		_g_free0 (_tmp1030_);
		timer = _tmp1032_;
		_tmp1033_ = vala_ccode_identifier_new ("g_timer_continue");
		_tmp1034_ = _tmp1033_;
		_tmp1035_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1034_);
		_tmp1036_ = _tmp1035_;
		_vala_ccode_node_unref0 (_tmp1034_);
		cont_call = _tmp1036_;
		_tmp1037_ = cont_call;
		_tmp1038_ = timer;
		vala_ccode_function_call_add_argument (_tmp1037_, (ValaCCodeExpression*) _tmp1038_);
		_tmp1039_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1040_ = _tmp1039_;
		_tmp1041_ = cont_call;
		vala_ccode_function_add_expression (_tmp1040_, (ValaCCodeExpression*) _tmp1041_);
		_tmp1042_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1043_ = _tmp1042_;
		vala_ccode_function_close (_tmp1043_);
		_vala_ccode_node_unref0 (cont_call);
		_vala_ccode_node_unref0 (timer);
		_vala_ccode_node_unref0 (counter);
		_vala_ccode_node_unref0 (level);
		_g_free0 (prefix);
	}
	_tmp1044_ = m;
	_tmp1045_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1044_);
	_tmp1046_ = _tmp1045_;
	if (_tmp1046_ != NULL) {
		ValaMethod* _tmp1047_;
		ValaBlock* _tmp1048_;
		ValaBlock* _tmp1049_;
		ValaCCodeBlock* _tmp1050_;
		_tmp1047_ = m;
		_tmp1048_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1047_);
		_tmp1049_ = _tmp1048_;
		vala_code_node_emit ((ValaCodeNode*) _tmp1049_, (ValaCodeGenerator*) self);
		_tmp1050_ = co_switch_block;
		if (_tmp1050_ != NULL) {
			ValaCCodeBlock* old_block = NULL;
			ValaCCodeFunction* _tmp1051_;
			ValaCCodeFunction* _tmp1052_;
			ValaCCodeBlock* _tmp1053_;
			ValaCCodeBlock* _tmp1054_;
			ValaCCodeBlock* _tmp1055_;
			ValaCCodeFunction* _tmp1056_;
			ValaCCodeFunction* _tmp1057_;
			ValaCCodeBlock* _tmp1058_;
			ValaCCodeFunction* _tmp1076_;
			ValaCCodeFunction* _tmp1077_;
			ValaCCodeFunction* _tmp1078_;
			ValaCCodeFunction* _tmp1079_;
			ValaCCodeIdentifier* _tmp1080_;
			ValaCCodeIdentifier* _tmp1081_;
			ValaCCodeFunctionCall* _tmp1082_;
			ValaCCodeFunctionCall* _tmp1083_;
			ValaCCodeFunction* _tmp1084_;
			ValaCCodeFunction* _tmp1085_;
			ValaCCodeBlock* _tmp1086_;
			_tmp1051_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1052_ = _tmp1051_;
			_tmp1053_ = vala_ccode_function_get_current_block (_tmp1052_);
			_tmp1054_ = _tmp1053_;
			_tmp1055_ = _vala_ccode_node_ref0 (_tmp1054_);
			old_block = _tmp1055_;
			_tmp1056_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1057_ = _tmp1056_;
			_tmp1058_ = co_switch_block;
			vala_ccode_function_set_current_block (_tmp1057_, _tmp1058_);
			{
				gint state = 0;
				state = 1;
				{
					gboolean _tmp1059_ = FALSE;
					_tmp1059_ = TRUE;
					while (TRUE) {
						gint _tmp1061_;
						ValaCCodeBaseModuleEmitContext* _tmp1062_;
						gint _tmp1063_;
						ValaCCodeFunction* _tmp1064_;
						ValaCCodeFunction* _tmp1065_;
						gint _tmp1066_;
						gchar* _tmp1067_;
						gchar* _tmp1068_;
						ValaCCodeConstant* _tmp1069_;
						ValaCCodeConstant* _tmp1070_;
						ValaCCodeFunction* _tmp1071_;
						ValaCCodeFunction* _tmp1072_;
						gint _tmp1073_;
						gchar* _tmp1074_;
						gchar* _tmp1075_;
						if (!_tmp1059_) {
							gint _tmp1060_;
							_tmp1060_ = state;
							state = _tmp1060_ + 1;
						}
						_tmp1059_ = FALSE;
						_tmp1061_ = state;
						_tmp1062_ = ((ValaCCodeBaseModule*) self)->emit_context;
						_tmp1063_ = _tmp1062_->next_coroutine_state;
						if (!(_tmp1061_ < _tmp1063_)) {
							break;
						}
						_tmp1064_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp1065_ = _tmp1064_;
						_tmp1066_ = state;
						_tmp1067_ = g_strdup_printf ("%i", _tmp1066_);
						_tmp1068_ = _tmp1067_;
						_tmp1069_ = vala_ccode_constant_new (_tmp1068_);
						_tmp1070_ = _tmp1069_;
						vala_ccode_function_add_case (_tmp1065_, (ValaCCodeExpression*) _tmp1070_);
						_vala_ccode_node_unref0 (_tmp1070_);
						_g_free0 (_tmp1068_);
						_tmp1071_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp1072_ = _tmp1071_;
						_tmp1073_ = state;
						_tmp1074_ = g_strdup_printf ("_state_%d", _tmp1073_);
						_tmp1075_ = _tmp1074_;
						vala_ccode_function_add_goto (_tmp1072_, _tmp1075_);
						_g_free0 (_tmp1075_);
					}
				}
			}
			_tmp1076_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1077_ = _tmp1076_;
			vala_ccode_function_add_default (_tmp1077_);
			_tmp1078_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1079_ = _tmp1078_;
			_tmp1080_ = vala_ccode_identifier_new ("g_assert_not_reached");
			_tmp1081_ = _tmp1080_;
			_tmp1082_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1081_);
			_tmp1083_ = _tmp1082_;
			vala_ccode_function_add_expression (_tmp1079_, (ValaCCodeExpression*) _tmp1083_);
			_vala_ccode_node_unref0 (_tmp1083_);
			_vala_ccode_node_unref0 (_tmp1081_);
			_tmp1084_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1085_ = _tmp1084_;
			_tmp1086_ = old_block;
			vala_ccode_function_set_current_block (_tmp1085_, _tmp1086_);
			co_switch_block = NULL;
			_vala_ccode_node_unref0 (old_block);
		}
	}
	_tmp1088_ = profile;
	if (_tmp1088_) {
		ValaMethod* _tmp1089_;
		ValaDataType* _tmp1090_;
		ValaDataType* _tmp1091_;
		_tmp1089_ = m;
		_tmp1090_ = vala_callable_get_return_type ((ValaCallable*) _tmp1089_);
		_tmp1091_ = _tmp1090_;
		_tmp1087_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1091_, VALA_TYPE_VOID_TYPE);
	} else {
		_tmp1087_ = FALSE;
	}
	if (_tmp1087_) {
		gchar* prefix = NULL;
		const gchar* _tmp1092_;
		gchar* _tmp1093_;
		ValaCCodeIdentifier* level = NULL;
		const gchar* _tmp1094_;
		gchar* _tmp1095_;
		gchar* _tmp1096_;
		ValaCCodeIdentifier* _tmp1097_;
		ValaCCodeIdentifier* _tmp1098_;
		ValaCCodeFunction* _tmp1099_;
		ValaCCodeFunction* _tmp1100_;
		ValaCCodeIdentifier* _tmp1101_;
		ValaCCodeUnaryExpression* _tmp1102_;
		ValaCCodeUnaryExpression* _tmp1103_;
		ValaCCodeUnaryExpression* _tmp1104_;
		ValaCCodeUnaryExpression* _tmp1105_;
		ValaCCodeIdentifier* timer = NULL;
		const gchar* _tmp1106_;
		gchar* _tmp1107_;
		gchar* _tmp1108_;
		ValaCCodeIdentifier* _tmp1109_;
		ValaCCodeIdentifier* _tmp1110_;
		ValaCCodeFunctionCall* stop_call = NULL;
		ValaCCodeIdentifier* _tmp1111_;
		ValaCCodeIdentifier* _tmp1112_;
		ValaCCodeFunctionCall* _tmp1113_;
		ValaCCodeFunctionCall* _tmp1114_;
		ValaCCodeFunctionCall* _tmp1115_;
		ValaCCodeIdentifier* _tmp1116_;
		ValaCCodeFunction* _tmp1117_;
		ValaCCodeFunction* _tmp1118_;
		ValaCCodeFunctionCall* _tmp1119_;
		ValaCCodeFunction* _tmp1120_;
		ValaCCodeFunction* _tmp1121_;
		_tmp1092_ = real_name;
		_tmp1093_ = g_strdup_printf ("_vala_prof_%s", _tmp1092_);
		prefix = _tmp1093_;
		_tmp1094_ = prefix;
		_tmp1095_ = g_strconcat (_tmp1094_, "_level", NULL);
		_tmp1096_ = _tmp1095_;
		_tmp1097_ = vala_ccode_identifier_new (_tmp1096_);
		_tmp1098_ = _tmp1097_;
		_g_free0 (_tmp1096_);
		level = _tmp1098_;
		_tmp1099_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1100_ = _tmp1099_;
		_tmp1101_ = level;
		_tmp1102_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp1101_);
		_tmp1103_ = _tmp1102_;
		_tmp1104_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp1103_);
		_tmp1105_ = _tmp1104_;
		vala_ccode_function_open_if (_tmp1100_, (ValaCCodeExpression*) _tmp1105_);
		_vala_ccode_node_unref0 (_tmp1105_);
		_vala_ccode_node_unref0 (_tmp1103_);
		_tmp1106_ = prefix;
		_tmp1107_ = g_strconcat (_tmp1106_, "_timer", NULL);
		_tmp1108_ = _tmp1107_;
		_tmp1109_ = vala_ccode_identifier_new (_tmp1108_);
		_tmp1110_ = _tmp1109_;
		_g_free0 (_tmp1108_);
		timer = _tmp1110_;
		_tmp1111_ = vala_ccode_identifier_new ("g_timer_stop");
		_tmp1112_ = _tmp1111_;
		_tmp1113_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1112_);
		_tmp1114_ = _tmp1113_;
		_vala_ccode_node_unref0 (_tmp1112_);
		stop_call = _tmp1114_;
		_tmp1115_ = stop_call;
		_tmp1116_ = timer;
		vala_ccode_function_call_add_argument (_tmp1115_, (ValaCCodeExpression*) _tmp1116_);
		_tmp1117_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1118_ = _tmp1117_;
		_tmp1119_ = stop_call;
		vala_ccode_function_add_expression (_tmp1118_, (ValaCCodeExpression*) _tmp1119_);
		_tmp1120_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1121_ = _tmp1120_;
		vala_ccode_function_close (_tmp1121_);
		_vala_ccode_node_unref0 (stop_call);
		_vala_ccode_node_unref0 (timer);
		_vala_ccode_node_unref0 (level);
		_g_free0 (prefix);
	}
	_tmp1123_ = m;
	_tmp1124_ = vala_method_get_is_abstract (_tmp1123_);
	_tmp1125_ = _tmp1124_;
	if (!_tmp1125_) {
		_tmp1122_ = TRUE;
	} else {
		gboolean _tmp1126_ = FALSE;
		ValaMethod* _tmp1127_;
		gboolean _tmp1128_;
		gboolean _tmp1129_;
		_tmp1127_ = m;
		_tmp1128_ = vala_method_get_is_abstract (_tmp1127_);
		_tmp1129_ = _tmp1128_;
		if (_tmp1129_) {
			ValaTypeSymbol* _tmp1130_;
			ValaTypeSymbol* _tmp1131_;
			_tmp1130_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
			_tmp1131_ = _tmp1130_;
			_tmp1126_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1131_, VALA_TYPE_CLASS);
		} else {
			_tmp1126_ = FALSE;
		}
		_tmp1122_ = _tmp1126_;
	}
	if (_tmp1122_) {
		ValaMethod* _tmp1132_;
		ValaBlock* _tmp1133_;
		ValaBlock* _tmp1134_;
		_tmp1132_ = m;
		_tmp1133_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1132_);
		_tmp1134_ = _tmp1133_;
		if (_tmp1134_ != NULL) {
			gboolean _tmp1135_;
			gboolean _tmp1136_;
			gboolean _tmp1147_ = FALSE;
			ValaMethod* _tmp1148_;
			ValaDataType* _tmp1149_;
			ValaDataType* _tmp1150_;
			gboolean _tmp1154_ = FALSE;
			gboolean _tmp1155_ = FALSE;
			ValaMethod* _tmp1156_;
			ValaDataType* _tmp1157_;
			ValaDataType* _tmp1158_;
			ValaMethod* _tmp1181_;
			ValaCCodeFile* _tmp1268_;
			ValaCCodeFunction* _tmp1269_;
			ValaCCodeFunction* _tmp1270_;
			_tmp1135_ = vala_ccode_base_module_get_current_method_inner_error ((ValaCCodeBaseModule*) self);
			_tmp1136_ = _tmp1135_;
			if (_tmp1136_) {
				ValaMethod* _tmp1137_;
				gboolean _tmp1138_;
				gboolean _tmp1139_;
				_tmp1137_ = m;
				_tmp1138_ = vala_method_get_coroutine (_tmp1137_);
				_tmp1139_ = _tmp1138_;
				if (_tmp1139_) {
					ValaCCodeStruct* _tmp1140_;
					_tmp1140_ = ((ValaCCodeBaseModule*) self)->closure_struct;
					vala_ccode_struct_add_field (_tmp1140_, "GError *", "_inner_error_", 0, NULL);
				} else {
					ValaCCodeFunction* _tmp1141_;
					ValaCCodeFunction* _tmp1142_;
					ValaCCodeConstant* _tmp1143_;
					ValaCCodeConstant* _tmp1144_;
					ValaCCodeVariableDeclarator* _tmp1145_;
					ValaCCodeVariableDeclarator* _tmp1146_;
					_tmp1141_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp1142_ = _tmp1141_;
					_tmp1143_ = vala_ccode_constant_new ("NULL");
					_tmp1144_ = _tmp1143_;
					_tmp1145_ = vala_ccode_variable_declarator_new_zero ("_inner_error_", (ValaCCodeExpression*) _tmp1144_, NULL);
					_tmp1146_ = _tmp1145_;
					vala_ccode_function_add_declaration (_tmp1142_, "GError *", (ValaCCodeDeclarator*) _tmp1146_, 0);
					_vala_ccode_node_unref0 (_tmp1146_);
					_vala_ccode_node_unref0 (_tmp1144_);
				}
			}
			_tmp1148_ = m;
			_tmp1149_ = vala_callable_get_return_type ((ValaCallable*) _tmp1148_);
			_tmp1150_ = _tmp1149_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1150_, VALA_TYPE_VOID_TYPE)) {
				ValaMethod* _tmp1151_;
				gboolean _tmp1152_;
				gboolean _tmp1153_;
				_tmp1151_ = m;
				_tmp1152_ = vala_method_get_coroutine (_tmp1151_);
				_tmp1153_ = _tmp1152_;
				_tmp1147_ = _tmp1153_;
			} else {
				_tmp1147_ = FALSE;
			}
			if (_tmp1147_) {
				vala_ccode_method_module_complete_async (self);
			}
			_tmp1156_ = m;
			_tmp1157_ = vala_callable_get_return_type ((ValaCallable*) _tmp1156_);
			_tmp1158_ = _tmp1157_;
			if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp1158_, VALA_TYPE_VOID_TYPE)) {
				ValaMethod* _tmp1159_;
				ValaDataType* _tmp1160_;
				ValaDataType* _tmp1161_;
				gboolean _tmp1162_;
				_tmp1159_ = m;
				_tmp1160_ = vala_callable_get_return_type ((ValaCallable*) _tmp1159_);
				_tmp1161_ = _tmp1160_;
				_tmp1162_ = vala_data_type_is_real_non_null_struct_type (_tmp1161_);
				_tmp1155_ = !_tmp1162_;
			} else {
				_tmp1155_ = FALSE;
			}
			if (_tmp1155_) {
				ValaMethod* _tmp1163_;
				gboolean _tmp1164_;
				gboolean _tmp1165_;
				_tmp1163_ = m;
				_tmp1164_ = vala_method_get_coroutine (_tmp1163_);
				_tmp1165_ = _tmp1164_;
				_tmp1154_ = !_tmp1165_;
			} else {
				_tmp1154_ = FALSE;
			}
			if (_tmp1154_) {
				gboolean _tmp1166_ = FALSE;
				ValaMethod* _tmp1167_;
				ValaBasicBlock* _tmp1168_;
				ValaBasicBlock* _tmp1169_;
				_tmp1167_ = m;
				_tmp1168_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp1167_);
				_tmp1169_ = _tmp1168_;
				if (_tmp1169_ != NULL) {
					ValaMethod* _tmp1170_;
					ValaBasicBlock* _tmp1171_;
					ValaBasicBlock* _tmp1172_;
					ValaList* _tmp1173_;
					ValaList* _tmp1174_;
					gint _tmp1175_;
					gint _tmp1176_;
					_tmp1170_ = m;
					_tmp1171_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp1170_);
					_tmp1172_ = _tmp1171_;
					_tmp1173_ = vala_basic_block_get_predecessors (_tmp1172_);
					_tmp1174_ = _tmp1173_;
					_tmp1175_ = vala_collection_get_size ((ValaCollection*) _tmp1174_);
					_tmp1176_ = _tmp1175_;
					_tmp1166_ = _tmp1176_ == 0;
					_vala_iterable_unref0 (_tmp1174_);
				} else {
					_tmp1166_ = FALSE;
				}
				if (_tmp1166_) {
					ValaCCodeFunction* _tmp1177_;
					ValaCCodeFunction* _tmp1178_;
					ValaCCodeIdentifier* _tmp1179_;
					ValaCCodeIdentifier* _tmp1180_;
					_tmp1177_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp1178_ = _tmp1177_;
					_tmp1179_ = vala_ccode_identifier_new ("result");
					_tmp1180_ = _tmp1179_;
					vala_ccode_function_add_return (_tmp1178_, (ValaCCodeExpression*) _tmp1180_);
					_vala_ccode_node_unref0 (_tmp1180_);
				}
			}
			_tmp1181_ = m;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1181_, VALA_TYPE_CREATION_METHOD)) {
				ValaTypeSymbol* _tmp1182_;
				ValaTypeSymbol* _tmp1183_;
				gboolean _tmp1188_ = FALSE;
				gboolean _tmp1189_ = FALSE;
				gboolean _tmp1190_ = FALSE;
				gboolean _tmp1191_ = FALSE;
				ValaTypeSymbol* _tmp1192_;
				ValaTypeSymbol* _tmp1193_;
				gboolean _tmp1249_ = FALSE;
				ValaTypeSymbol* _tmp1250_;
				ValaTypeSymbol* _tmp1251_;
				_tmp1182_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
				_tmp1183_ = _tmp1182_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1183_, VALA_TYPE_CLASS)) {
					ValaClass* _tmp1184_;
					ValaClass* _tmp1185_;
					ValaObjectType* _tmp1186_;
					_tmp1184_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
					_tmp1185_ = _tmp1184_;
					_tmp1186_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp1185_);
					_vala_code_node_unref0 (creturn_type);
					creturn_type = (ValaDataType*) _tmp1186_;
				} else {
					ValaVoidType* _tmp1187_;
					_tmp1187_ = vala_void_type_new (NULL);
					_vala_code_node_unref0 (creturn_type);
					creturn_type = (ValaDataType*) _tmp1187_;
				}
				_tmp1192_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
				_tmp1193_ = _tmp1192_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1193_, VALA_TYPE_CLASS)) {
					ValaTypeSymbol* _tmp1194_;
					_tmp1194_ = ((ValaCCodeBaseModule*) self)->gobject_type;
					_tmp1191_ = _tmp1194_ != NULL;
				} else {
					_tmp1191_ = FALSE;
				}
				if (_tmp1191_) {
					ValaClass* _tmp1195_;
					ValaClass* _tmp1196_;
					ValaTypeSymbol* _tmp1197_;
					gboolean _tmp1198_;
					_tmp1195_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
					_tmp1196_ = _tmp1195_;
					_tmp1197_ = ((ValaCCodeBaseModule*) self)->gobject_type;
					_tmp1198_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp1196_, _tmp1197_);
					_tmp1190_ = _tmp1198_;
				} else {
					_tmp1190_ = FALSE;
				}
				if (_tmp1190_) {
					ValaClass* _tmp1199_;
					ValaClass* _tmp1200_;
					ValaList* _tmp1201_;
					ValaList* _tmp1202_;
					gint _tmp1203_;
					gint _tmp1204_;
					_tmp1199_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
					_tmp1200_ = _tmp1199_;
					_tmp1201_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp1200_);
					_tmp1202_ = _tmp1201_;
					_tmp1203_ = vala_collection_get_size ((ValaCollection*) _tmp1202_);
					_tmp1204_ = _tmp1203_;
					_tmp1189_ = _tmp1204_ > 0;
					_vala_iterable_unref0 (_tmp1202_);
				} else {
					_tmp1189_ = FALSE;
				}
				if (_tmp1189_) {
					ValaMethod* _tmp1205_;
					gboolean _tmp1206_;
					gboolean _tmp1207_;
					_tmp1205_ = m;
					_tmp1206_ = vala_creation_method_get_chain_up (G_TYPE_CHECK_INSTANCE_CAST (_tmp1205_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
					_tmp1207_ = _tmp1206_;
					_tmp1188_ = !_tmp1207_;
				} else {
					_tmp1188_ = FALSE;
				}
				if (_tmp1188_) {
					ValaCCodeBinaryExpression* ccond = NULL;
					ValaCCodeIdentifier* _tmp1208_;
					ValaCCodeIdentifier* _tmp1209_;
					ValaCCodeIdentifier* _tmp1210_;
					ValaCCodeIdentifier* _tmp1211_;
					ValaCCodeBinaryExpression* _tmp1212_;
					ValaCCodeBinaryExpression* _tmp1213_;
					ValaCCodeFunction* _tmp1214_;
					ValaCCodeFunction* _tmp1215_;
					ValaCCodeBinaryExpression* _tmp1216_;
					ValaCCodeFunction* _tmp1217_;
					ValaCCodeFunction* _tmp1218_;
					ValaCCodeIdentifier* _tmp1219_;
					ValaCCodeIdentifier* _tmp1220_;
					ValaCCodeUnaryExpression* _tmp1221_;
					ValaCCodeUnaryExpression* _tmp1222_;
					ValaCCodeFunctionCall* cunsetcall = NULL;
					ValaCCodeIdentifier* _tmp1223_;
					ValaCCodeIdentifier* _tmp1224_;
					ValaCCodeFunctionCall* _tmp1225_;
					ValaCCodeFunctionCall* _tmp1226_;
					ValaCCodeFunctionCall* _tmp1227_;
					ValaCCodeIdentifier* _tmp1228_;
					ValaCCodeIdentifier* _tmp1229_;
					ValaCCodeMemberAccess* _tmp1230_;
					ValaCCodeMemberAccess* _tmp1231_;
					ValaCCodeUnaryExpression* _tmp1232_;
					ValaCCodeUnaryExpression* _tmp1233_;
					ValaCCodeFunction* _tmp1234_;
					ValaCCodeFunction* _tmp1235_;
					ValaCCodeFunctionCall* _tmp1236_;
					ValaCCodeFunction* _tmp1237_;
					ValaCCodeFunction* _tmp1238_;
					ValaCCodeFunctionCall* cfreeparams = NULL;
					ValaCCodeIdentifier* _tmp1239_;
					ValaCCodeIdentifier* _tmp1240_;
					ValaCCodeFunctionCall* _tmp1241_;
					ValaCCodeFunctionCall* _tmp1242_;
					ValaCCodeFunctionCall* _tmp1243_;
					ValaCCodeIdentifier* _tmp1244_;
					ValaCCodeIdentifier* _tmp1245_;
					ValaCCodeFunction* _tmp1246_;
					ValaCCodeFunction* _tmp1247_;
					ValaCCodeFunctionCall* _tmp1248_;
					_tmp1208_ = vala_ccode_identifier_new ("__params_it");
					_tmp1209_ = _tmp1208_;
					_tmp1210_ = vala_ccode_identifier_new ("__params");
					_tmp1211_ = _tmp1210_;
					_tmp1212_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, (ValaCCodeExpression*) _tmp1209_, (ValaCCodeExpression*) _tmp1211_);
					_tmp1213_ = _tmp1212_;
					_vala_ccode_node_unref0 (_tmp1211_);
					_vala_ccode_node_unref0 (_tmp1209_);
					ccond = _tmp1213_;
					_tmp1214_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp1215_ = _tmp1214_;
					_tmp1216_ = ccond;
					vala_ccode_function_open_while (_tmp1215_, (ValaCCodeExpression*) _tmp1216_);
					_tmp1217_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp1218_ = _tmp1217_;
					_tmp1219_ = vala_ccode_identifier_new ("__params_it");
					_tmp1220_ = _tmp1219_;
					_tmp1221_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp1220_);
					_tmp1222_ = _tmp1221_;
					vala_ccode_function_add_expression (_tmp1218_, (ValaCCodeExpression*) _tmp1222_);
					_vala_ccode_node_unref0 (_tmp1222_);
					_vala_ccode_node_unref0 (_tmp1220_);
					_tmp1223_ = vala_ccode_identifier_new ("g_value_unset");
					_tmp1224_ = _tmp1223_;
					_tmp1225_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1224_);
					_tmp1226_ = _tmp1225_;
					_vala_ccode_node_unref0 (_tmp1224_);
					cunsetcall = _tmp1226_;
					_tmp1227_ = cunsetcall;
					_tmp1228_ = vala_ccode_identifier_new ("__params_it");
					_tmp1229_ = _tmp1228_;
					_tmp1230_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp1229_, "value");
					_tmp1231_ = _tmp1230_;
					_tmp1232_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp1231_);
					_tmp1233_ = _tmp1232_;
					vala_ccode_function_call_add_argument (_tmp1227_, (ValaCCodeExpression*) _tmp1233_);
					_vala_ccode_node_unref0 (_tmp1233_);
					_vala_ccode_node_unref0 (_tmp1231_);
					_vala_ccode_node_unref0 (_tmp1229_);
					_tmp1234_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp1235_ = _tmp1234_;
					_tmp1236_ = cunsetcall;
					vala_ccode_function_add_expression (_tmp1235_, (ValaCCodeExpression*) _tmp1236_);
					_tmp1237_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp1238_ = _tmp1237_;
					vala_ccode_function_close (_tmp1238_);
					_tmp1239_ = vala_ccode_identifier_new ("g_free");
					_tmp1240_ = _tmp1239_;
					_tmp1241_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1240_);
					_tmp1242_ = _tmp1241_;
					_vala_ccode_node_unref0 (_tmp1240_);
					cfreeparams = _tmp1242_;
					_tmp1243_ = cfreeparams;
					_tmp1244_ = vala_ccode_identifier_new ("__params");
					_tmp1245_ = _tmp1244_;
					vala_ccode_function_call_add_argument (_tmp1243_, (ValaCCodeExpression*) _tmp1245_);
					_vala_ccode_node_unref0 (_tmp1245_);
					_tmp1246_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp1247_ = _tmp1246_;
					_tmp1248_ = cfreeparams;
					vala_ccode_function_add_expression (_tmp1247_, (ValaCCodeExpression*) _tmp1248_);
					_vala_ccode_node_unref0 (cfreeparams);
					_vala_ccode_node_unref0 (cunsetcall);
					_vala_ccode_node_unref0 (ccond);
				}
				_tmp1250_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
				_tmp1251_ = _tmp1250_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1251_, VALA_TYPE_CLASS)) {
					ValaMethod* _tmp1252_;
					gboolean _tmp1253_;
					gboolean _tmp1254_;
					_tmp1252_ = m;
					_tmp1253_ = vala_method_get_coroutine (_tmp1252_);
					_tmp1254_ = _tmp1253_;
					_tmp1249_ = !_tmp1254_;
				} else {
					_tmp1249_ = FALSE;
				}
				if (_tmp1249_) {
					ValaCCodeExpression* cresult = NULL;
					ValaCCodeIdentifier* _tmp1255_;
					ValaMethod* _tmp1256_;
					gchar* _tmp1257_;
					gchar* _tmp1258_;
					gboolean _tmp1259_;
					ValaCCodeFunction* _tmp1265_;
					ValaCCodeFunction* _tmp1266_;
					ValaCCodeExpression* _tmp1267_;
					_tmp1255_ = vala_ccode_identifier_new ("self");
					cresult = (ValaCCodeExpression*) _tmp1255_;
					_tmp1256_ = m;
					_tmp1257_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1256_);
					_tmp1258_ = _tmp1257_;
					_tmp1259_ = _tmp1258_ != NULL;
					_g_free0 (_tmp1258_);
					if (_tmp1259_) {
						ValaCCodeExpression* _tmp1260_;
						ValaMethod* _tmp1261_;
						gchar* _tmp1262_;
						gchar* _tmp1263_;
						ValaCCodeCastExpression* _tmp1264_;
						_tmp1260_ = cresult;
						_tmp1261_ = m;
						_tmp1262_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1261_);
						_tmp1263_ = _tmp1262_;
						_tmp1264_ = vala_ccode_cast_expression_new (_tmp1260_, _tmp1263_);
						_vala_ccode_node_unref0 (cresult);
						cresult = (ValaCCodeExpression*) _tmp1264_;
						_g_free0 (_tmp1263_);
					}
					_tmp1265_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp1266_ = _tmp1265_;
					_tmp1267_ = cresult;
					vala_ccode_function_add_return (_tmp1266_, _tmp1267_);
					_vala_ccode_node_unref0 (cresult);
				}
			}
			_tmp1268_ = ((ValaCCodeBaseModule*) self)->cfile;
			_tmp1269_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1270_ = _tmp1269_;
			vala_ccode_file_add_function (_tmp1268_, _tmp1270_);
		}
	}
	_tmp1272_ = m;
	_tmp1273_ = vala_method_get_is_abstract (_tmp1272_);
	_tmp1274_ = _tmp1273_;
	if (_tmp1274_) {
		ValaTypeSymbol* _tmp1275_;
		ValaTypeSymbol* _tmp1276_;
		_tmp1275_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
		_tmp1276_ = _tmp1275_;
		_tmp1271_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1276_, VALA_TYPE_CLASS);
	} else {
		_tmp1271_ = FALSE;
	}
	if (_tmp1271_) {
		ValaCCodeFunctionCall* type_from_instance_call = NULL;
		ValaCCodeIdentifier* _tmp1277_;
		ValaCCodeIdentifier* _tmp1278_;
		ValaCCodeFunctionCall* _tmp1279_;
		ValaCCodeFunctionCall* _tmp1280_;
		ValaCCodeFunctionCall* _tmp1281_;
		ValaCCodeIdentifier* _tmp1282_;
		ValaCCodeIdentifier* _tmp1283_;
		ValaCCodeFunctionCall* type_name_call = NULL;
		ValaCCodeIdentifier* _tmp1284_;
		ValaCCodeIdentifier* _tmp1285_;
		ValaCCodeFunctionCall* _tmp1286_;
		ValaCCodeFunctionCall* _tmp1287_;
		ValaCCodeFunctionCall* _tmp1288_;
		ValaCCodeFunctionCall* _tmp1289_;
		gchar* error_string = NULL;
		ValaMethod* _tmp1290_;
		gchar* _tmp1291_;
		gchar* _tmp1292_;
		gchar* _tmp1293_;
		gchar* _tmp1294_;
		ValaCCodeFunctionCall* cerrorcall = NULL;
		ValaCCodeIdentifier* _tmp1295_;
		ValaCCodeIdentifier* _tmp1296_;
		ValaCCodeFunctionCall* _tmp1297_;
		ValaCCodeFunctionCall* _tmp1298_;
		ValaCCodeFunctionCall* _tmp1299_;
		const gchar* _tmp1300_;
		ValaCCodeConstant* _tmp1301_;
		ValaCCodeConstant* _tmp1302_;
		ValaCCodeFunctionCall* _tmp1303_;
		ValaCCodeFunctionCall* _tmp1304_;
		ValaCCodeFunction* _tmp1305_;
		ValaCCodeFunction* _tmp1306_;
		ValaCCodeFunctionCall* _tmp1307_;
		ValaDataType* _tmp1308_;
		ValaCCodeFile* _tmp1309_;
		ValaCCodeFunction* _tmp1310_;
		ValaCCodeFunction* _tmp1311_;
		_tmp1277_ = vala_ccode_identifier_new ("G_TYPE_FROM_INSTANCE");
		_tmp1278_ = _tmp1277_;
		_tmp1279_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1278_);
		_tmp1280_ = _tmp1279_;
		_vala_ccode_node_unref0 (_tmp1278_);
		type_from_instance_call = _tmp1280_;
		_tmp1281_ = type_from_instance_call;
		_tmp1282_ = vala_ccode_identifier_new ("self");
		_tmp1283_ = _tmp1282_;
		vala_ccode_function_call_add_argument (_tmp1281_, (ValaCCodeExpression*) _tmp1283_);
		_vala_ccode_node_unref0 (_tmp1283_);
		_tmp1284_ = vala_ccode_identifier_new ("g_type_name");
		_tmp1285_ = _tmp1284_;
		_tmp1286_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1285_);
		_tmp1287_ = _tmp1286_;
		_vala_ccode_node_unref0 (_tmp1285_);
		type_name_call = _tmp1287_;
		_tmp1288_ = type_name_call;
		_tmp1289_ = type_from_instance_call;
		vala_ccode_function_call_add_argument (_tmp1288_, (ValaCCodeExpression*) _tmp1289_);
		_tmp1290_ = m;
		_tmp1291_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1290_);
		_tmp1292_ = _tmp1291_;
		_tmp1293_ = g_strdup_printf ("\"Type `%%s' does not implement abstract method `%s'\"", _tmp1292_);
		_tmp1294_ = _tmp1293_;
		_g_free0 (_tmp1292_);
		error_string = _tmp1294_;
		_tmp1295_ = vala_ccode_identifier_new ("g_critical");
		_tmp1296_ = _tmp1295_;
		_tmp1297_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1296_);
		_tmp1298_ = _tmp1297_;
		_vala_ccode_node_unref0 (_tmp1296_);
		cerrorcall = _tmp1298_;
		_tmp1299_ = cerrorcall;
		_tmp1300_ = error_string;
		_tmp1301_ = vala_ccode_constant_new (_tmp1300_);
		_tmp1302_ = _tmp1301_;
		vala_ccode_function_call_add_argument (_tmp1299_, (ValaCCodeExpression*) _tmp1302_);
		_vala_ccode_node_unref0 (_tmp1302_);
		_tmp1303_ = cerrorcall;
		_tmp1304_ = type_name_call;
		vala_ccode_function_call_add_argument (_tmp1303_, (ValaCCodeExpression*) _tmp1304_);
		_tmp1305_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1306_ = _tmp1305_;
		_tmp1307_ = cerrorcall;
		vala_ccode_function_add_expression (_tmp1306_, (ValaCCodeExpression*) _tmp1307_);
		_tmp1308_ = creturn_type;
		vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp1308_);
		_tmp1309_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp1310_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1311_ = _tmp1310_;
		vala_ccode_file_add_function (_tmp1309_, _tmp1311_);
		_vala_ccode_node_unref0 (cerrorcall);
		_g_free0 (error_string);
		_vala_ccode_node_unref0 (type_name_call);
		_vala_ccode_node_unref0 (type_from_instance_call);
	}
	vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self);
	_tmp1315_ = m;
	_tmp1316_ = vala_method_get_is_abstract (_tmp1315_);
	_tmp1317_ = _tmp1316_;
	if (_tmp1317_) {
		_tmp1314_ = TRUE;
	} else {
		ValaMethod* _tmp1318_;
		gboolean _tmp1319_;
		gboolean _tmp1320_;
		_tmp1318_ = m;
		_tmp1319_ = vala_method_get_is_virtual (_tmp1318_);
		_tmp1320_ = _tmp1319_;
		_tmp1314_ = _tmp1320_;
	}
	if (_tmp1314_) {
		ValaMethod* _tmp1321_;
		gboolean _tmp1322_;
		gboolean _tmp1323_;
		_tmp1321_ = m;
		_tmp1322_ = vala_method_get_coroutine (_tmp1321_);
		_tmp1323_ = _tmp1322_;
		_tmp1313_ = !_tmp1323_;
	} else {
		_tmp1313_ = FALSE;
	}
	if (_tmp1313_) {
		ValaMethod* _tmp1324_;
		ValaSignal* _tmp1325_;
		ValaSignal* _tmp1326_;
		_tmp1324_ = m;
		_tmp1325_ = vala_method_get_signal_reference (_tmp1324_);
		_tmp1326_ = _tmp1325_;
		_tmp1312_ = _tmp1326_ == NULL;
	} else {
		_tmp1312_ = FALSE;
	}
	if (_tmp1312_) {
		GHashFunc _tmp1327_;
		GEqualFunc _tmp1328_;
		GEqualFunc _tmp1329_;
		ValaHashMap* _tmp1330_;
		ValaHashMap* carg_map = NULL;
		GHashFunc _tmp1331_;
		GEqualFunc _tmp1332_;
		GEqualFunc _tmp1333_;
		ValaHashMap* _tmp1334_;
		ValaMethod* _tmp1335_;
		ValaDataType* _tmp1336_;
		ValaHashMap* _tmp1337_;
		ValaHashMap* _tmp1338_;
		_tmp1327_ = g_direct_hash;
		_tmp1328_ = g_direct_equal;
		_tmp1329_ = g_direct_equal;
		_tmp1330_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp1327_, _tmp1328_, _tmp1329_);
		_vala_map_unref0 (cparam_map);
		cparam_map = _tmp1330_;
		_tmp1331_ = g_direct_hash;
		_tmp1332_ = g_direct_equal;
		_tmp1333_ = g_direct_equal;
		_tmp1334_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp1331_, _tmp1332_, _tmp1333_);
		carg_map = _tmp1334_;
		_tmp1335_ = m;
		_tmp1336_ = creturn_type;
		_tmp1337_ = cparam_map;
		_tmp1338_ = carg_map;
		vala_ccode_method_module_generate_vfunc (self, _tmp1335_, _tmp1336_, (ValaMap*) _tmp1337_, (ValaMap*) _tmp1338_, "", 3);
		_vala_map_unref0 (carg_map);
	}
	_tmp1339_ = m;
	_tmp1340_ = vala_method_get_entry_point (_tmp1339_);
	_tmp1341_ = _tmp1340_;
	if (_tmp1341_) {
		ValaCCodeFunction* cmain = NULL;
		ValaCCodeFunction* _tmp1342_;
		ValaCCodeFunction* _tmp1343_;
		ValaCCodeFunction* _tmp1344_;
		ValaCCodeLineDirective* _tmp1345_;
		ValaCCodeLineDirective* _tmp1346_;
		ValaCCodeFunction* _tmp1347_;
		ValaCCodeParameter* _tmp1348_;
		ValaCCodeParameter* _tmp1349_;
		ValaCCodeFunction* _tmp1350_;
		ValaCCodeParameter* _tmp1351_;
		ValaCCodeParameter* _tmp1352_;
		ValaCCodeFunction* _tmp1353_;
		ValaCodeContext* _tmp1354_;
		ValaCodeContext* _tmp1355_;
		gboolean _tmp1356_;
		gboolean _tmp1357_;
		ValaCCodeIfSection* cond = NULL;
		ValaCCodeIfSection* _tmp1372_;
		ValaCCodeFunction* _tmp1373_;
		ValaCCodeFunction* _tmp1374_;
		ValaCCodeIfSection* _tmp1375_;
		ValaCCodeIfSection* _tmp1376_;
		ValaCCodeIdentifier* _tmp1377_;
		ValaCCodeIdentifier* _tmp1378_;
		ValaCCodeFunctionCall* _tmp1379_;
		ValaCCodeFunctionCall* _tmp1380_;
		ValaCCodeExpressionStatement* _tmp1381_;
		ValaCCodeExpressionStatement* _tmp1382_;
		ValaCCodeFunctionCall* main_call = NULL;
		ValaCCodeFunction* _tmp1383_;
		const gchar* _tmp1384_;
		const gchar* _tmp1385_;
		ValaCCodeIdentifier* _tmp1386_;
		ValaCCodeIdentifier* _tmp1387_;
		ValaCCodeFunctionCall* _tmp1388_;
		ValaCCodeFunctionCall* _tmp1389_;
		ValaMethod* _tmp1390_;
		ValaList* _tmp1391_;
		ValaList* _tmp1392_;
		gint _tmp1393_;
		gint _tmp1394_;
		gboolean _tmp1395_;
		ValaMethod* _tmp1402_;
		ValaDataType* _tmp1403_;
		ValaDataType* _tmp1404_;
		ValaCCodeFile* _tmp1415_;
		ValaCCodeFunction* _tmp1416_;
		_tmp1342_ = vala_ccode_function_new ("main", "int");
		cmain = _tmp1342_;
		_tmp1343_ = cmain;
		_tmp1344_ = function;
		_tmp1345_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1344_);
		_tmp1346_ = _tmp1345_;
		vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1343_, _tmp1346_);
		_tmp1347_ = cmain;
		_tmp1348_ = vala_ccode_parameter_new ("argc", "int");
		_tmp1349_ = _tmp1348_;
		vala_ccode_function_add_parameter (_tmp1347_, _tmp1349_);
		_vala_ccode_node_unref0 (_tmp1349_);
		_tmp1350_ = cmain;
		_tmp1351_ = vala_ccode_parameter_new ("argv", "char **");
		_tmp1352_ = _tmp1351_;
		vala_ccode_function_add_parameter (_tmp1350_, _tmp1352_);
		_vala_ccode_node_unref0 (_tmp1352_);
		_tmp1353_ = cmain;
		vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp1353_);
		_tmp1354_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp1355_ = _tmp1354_;
		_tmp1356_ = vala_code_context_get_mem_profiler (_tmp1355_);
		_tmp1357_ = _tmp1356_;
		if (_tmp1357_) {
			ValaCCodeFunctionCall* mem_profiler_init_call = NULL;
			ValaCCodeIdentifier* _tmp1358_;
			ValaCCodeIdentifier* _tmp1359_;
			ValaCCodeFunctionCall* _tmp1360_;
			ValaCCodeFunctionCall* _tmp1361_;
			ValaCCodeFunctionCall* _tmp1362_;
			ValaCCodeFunction* _tmp1363_;
			ValaCCodeLineDirective* _tmp1364_;
			ValaCCodeLineDirective* _tmp1365_;
			ValaCCodeFunctionCall* _tmp1366_;
			ValaCCodeConstant* _tmp1367_;
			ValaCCodeConstant* _tmp1368_;
			ValaCCodeFunction* _tmp1369_;
			ValaCCodeFunction* _tmp1370_;
			ValaCCodeFunctionCall* _tmp1371_;
			_tmp1358_ = vala_ccode_identifier_new ("g_mem_set_vtable");
			_tmp1359_ = _tmp1358_;
			_tmp1360_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1359_);
			_tmp1361_ = _tmp1360_;
			_vala_ccode_node_unref0 (_tmp1359_);
			mem_profiler_init_call = _tmp1361_;
			_tmp1362_ = mem_profiler_init_call;
			_tmp1363_ = cmain;
			_tmp1364_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1363_);
			_tmp1365_ = _tmp1364_;
			vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1362_, _tmp1365_);
			_tmp1366_ = mem_profiler_init_call;
			_tmp1367_ = vala_ccode_constant_new ("glib_mem_profiler_table");
			_tmp1368_ = _tmp1367_;
			vala_ccode_function_call_add_argument (_tmp1366_, (ValaCCodeExpression*) _tmp1368_);
			_vala_ccode_node_unref0 (_tmp1368_);
			_tmp1369_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1370_ = _tmp1369_;
			_tmp1371_ = mem_profiler_init_call;
			vala_ccode_function_add_expression (_tmp1370_, (ValaCCodeExpression*) _tmp1371_);
			_vala_ccode_node_unref0 (mem_profiler_init_call);
		}
		_tmp1372_ = vala_ccode_if_section_new ("!GLIB_CHECK_VERSION (2,35,0)");
		cond = _tmp1372_;
		_tmp1373_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1374_ = _tmp1373_;
		_tmp1375_ = cond;
		vala_ccode_function_add_statement (_tmp1374_, (ValaCCodeNode*) _tmp1375_);
		_tmp1376_ = cond;
		_tmp1377_ = vala_ccode_identifier_new ("g_type_init");
		_tmp1378_ = _tmp1377_;
		_tmp1379_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1378_);
		_tmp1380_ = _tmp1379_;
		_tmp1381_ = vala_ccode_expression_statement_new ((ValaCCodeExpression*) _tmp1380_);
		_tmp1382_ = _tmp1381_;
		vala_ccode_fragment_append ((ValaCCodeFragment*) _tmp1376_, (ValaCCodeNode*) _tmp1382_);
		_vala_ccode_node_unref0 (_tmp1382_);
		_vala_ccode_node_unref0 (_tmp1380_);
		_vala_ccode_node_unref0 (_tmp1378_);
		_tmp1383_ = function;
		_tmp1384_ = vala_ccode_function_get_name (_tmp1383_);
		_tmp1385_ = _tmp1384_;
		_tmp1386_ = vala_ccode_identifier_new (_tmp1385_);
		_tmp1387_ = _tmp1386_;
		_tmp1388_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1387_);
		_tmp1389_ = _tmp1388_;
		_vala_ccode_node_unref0 (_tmp1387_);
		main_call = _tmp1389_;
		_tmp1390_ = m;
		_tmp1391_ = vala_callable_get_parameters ((ValaCallable*) _tmp1390_);
		_tmp1392_ = _tmp1391_;
		_tmp1393_ = vala_collection_get_size ((ValaCollection*) _tmp1392_);
		_tmp1394_ = _tmp1393_;
		_tmp1395_ = _tmp1394_ == 1;
		_vala_iterable_unref0 (_tmp1392_);
		if (_tmp1395_) {
			ValaCCodeFunctionCall* _tmp1396_;
			ValaCCodeIdentifier* _tmp1397_;
			ValaCCodeIdentifier* _tmp1398_;
			ValaCCodeFunctionCall* _tmp1399_;
			ValaCCodeIdentifier* _tmp1400_;
			ValaCCodeIdentifier* _tmp1401_;
			_tmp1396_ = main_call;
			_tmp1397_ = vala_ccode_identifier_new ("argv");
			_tmp1398_ = _tmp1397_;
			vala_ccode_function_call_add_argument (_tmp1396_, (ValaCCodeExpression*) _tmp1398_);
			_vala_ccode_node_unref0 (_tmp1398_);
			_tmp1399_ = main_call;
			_tmp1400_ = vala_ccode_identifier_new ("argc");
			_tmp1401_ = _tmp1400_;
			vala_ccode_function_call_add_argument (_tmp1399_, (ValaCCodeExpression*) _tmp1401_);
			_vala_ccode_node_unref0 (_tmp1401_);
		}
		_tmp1402_ = m;
		_tmp1403_ = vala_callable_get_return_type ((ValaCallable*) _tmp1402_);
		_tmp1404_ = _tmp1403_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1404_, VALA_TYPE_VOID_TYPE)) {
			ValaCCodeFunction* _tmp1405_;
			ValaCCodeFunction* _tmp1406_;
			ValaCCodeFunctionCall* _tmp1407_;
			ValaCCodeFunction* _tmp1408_;
			ValaCCodeFunction* _tmp1409_;
			ValaCCodeConstant* _tmp1410_;
			ValaCCodeConstant* _tmp1411_;
			_tmp1405_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1406_ = _tmp1405_;
			_tmp1407_ = main_call;
			vala_ccode_function_add_expression (_tmp1406_, (ValaCCodeExpression*) _tmp1407_);
			_tmp1408_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1409_ = _tmp1408_;
			_tmp1410_ = vala_ccode_constant_new ("0");
			_tmp1411_ = _tmp1410_;
			vala_ccode_function_add_return (_tmp1409_, (ValaCCodeExpression*) _tmp1411_);
			_vala_ccode_node_unref0 (_tmp1411_);
		} else {
			ValaCCodeFunction* _tmp1412_;
			ValaCCodeFunction* _tmp1413_;
			ValaCCodeFunctionCall* _tmp1414_;
			_tmp1412_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1413_ = _tmp1412_;
			_tmp1414_ = main_call;
			vala_ccode_function_add_return (_tmp1413_, (ValaCCodeExpression*) _tmp1414_);
		}
		vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
		_tmp1415_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp1416_ = cmain;
		vala_ccode_file_add_function (_tmp1415_, _tmp1416_);
		_vala_ccode_node_unref0 (main_call);
		_vala_ccode_node_unref0 (cond);
		_vala_ccode_node_unref0 (cmain);
	}
	vala_ccode_base_module_pop_line ((ValaCCodeBaseModule*) self);
	_vala_map_unref0 (cparam_map);
	_vala_ccode_node_unref0 (function);
	_vala_code_node_unref0 (creturn_type);
	_g_free0 (real_name);
}


static ValaCCodeParameter* vala_ccode_method_module_real_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map) {
	ValaCCodeParameter* result = NULL;
	ValaCCodeParameter* cparam = NULL;
	ValaParameter* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	ValaMap* _tmp65_;
	ValaParameter* _tmp66_;
	gdouble _tmp67_;
	ValaParameter* _tmp68_;
	gboolean _tmp69_;
	gboolean _tmp70_;
	gint _tmp71_;
	ValaCCodeParameter* _tmp72_;
	gboolean _tmp73_ = FALSE;
	ValaMap* _tmp74_;
	g_return_val_if_fail (param != NULL, NULL);
	g_return_val_if_fail (decl_space != NULL, NULL);
	g_return_val_if_fail (cparam_map != NULL, NULL);
	_tmp0_ = param;
	_tmp1_ = vala_parameter_get_ellipsis (_tmp0_);
	_tmp2_ = _tmp1_;
	if (!_tmp2_) {
		gchar* ctypename = NULL;
		ValaParameter* _tmp3_;
		ValaDataType* _tmp4_;
		ValaDataType* _tmp5_;
		gchar* _tmp6_;
		ValaParameter* _tmp7_;
		ValaDataType* _tmp8_;
		ValaDataType* _tmp9_;
		ValaCCodeFile* _tmp10_;
		ValaParameter* _tmp11_;
		ValaDataType* _tmp12_;
		ValaDataType* _tmp13_;
		ValaTypeSymbol* _tmp14_;
		ValaTypeSymbol* _tmp15_;
		ValaParameter* _tmp46_;
		ValaParameterDirection _tmp47_;
		ValaParameterDirection _tmp48_;
		ValaParameter* _tmp51_;
		const gchar* _tmp52_;
		const gchar* _tmp53_;
		gchar* _tmp54_;
		gchar* _tmp55_;
		const gchar* _tmp56_;
		ValaCCodeParameter* _tmp57_;
		ValaParameter* _tmp58_;
		gboolean _tmp59_;
		gboolean _tmp60_;
		_tmp3_ = param;
		_tmp4_ = vala_variable_get_variable_type ((ValaVariable*) _tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp5_);
		ctypename = _tmp6_;
		_tmp7_ = param;
		_tmp8_ = vala_variable_get_variable_type ((ValaVariable*) _tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = decl_space;
		vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp9_, _tmp10_);
		_tmp11_ = param;
		_tmp12_ = vala_variable_get_variable_type ((ValaVariable*) _tmp11_);
		_tmp13_ = _tmp12_;
		_tmp14_ = vala_data_type_get_data_type (_tmp13_);
		_tmp15_ = _tmp14_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_STRUCT)) {
			ValaStruct* st = NULL;
			ValaParameter* _tmp16_;
			ValaDataType* _tmp17_;
			ValaDataType* _tmp18_;
			ValaTypeSymbol* _tmp19_;
			ValaTypeSymbol* _tmp20_;
			ValaStruct* _tmp21_;
			gboolean _tmp22_ = FALSE;
			ValaStruct* _tmp23_;
			gboolean _tmp24_;
			_tmp16_ = param;
			_tmp17_ = vala_variable_get_variable_type ((ValaVariable*) _tmp16_);
			_tmp18_ = _tmp17_;
			_tmp19_ = vala_data_type_get_data_type (_tmp18_);
			_tmp20_ = _tmp19_;
			_tmp21_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_STRUCT, ValaStruct));
			st = _tmp21_;
			_tmp23_ = st;
			_tmp24_ = vala_struct_is_simple_type (_tmp23_);
			if (!_tmp24_) {
				ValaParameter* _tmp25_;
				ValaParameterDirection _tmp26_;
				ValaParameterDirection _tmp27_;
				_tmp25_ = param;
				_tmp26_ = vala_parameter_get_direction (_tmp25_);
				_tmp27_ = _tmp26_;
				_tmp22_ = _tmp27_ == VALA_PARAMETER_DIRECTION_IN;
			} else {
				_tmp22_ = FALSE;
			}
			if (_tmp22_) {
				gboolean _tmp28_ = FALSE;
				ValaStruct* _tmp29_;
				gboolean _tmp30_;
				gboolean _tmp31_;
				ValaParameter* _tmp39_;
				ValaDataType* _tmp40_;
				ValaDataType* _tmp41_;
				gboolean _tmp42_;
				gboolean _tmp43_;
				_tmp29_ = st;
				_tmp30_ = vala_struct_get_is_immutable (_tmp29_);
				_tmp31_ = _tmp30_;
				if (_tmp31_) {
					ValaParameter* _tmp32_;
					ValaDataType* _tmp33_;
					ValaDataType* _tmp34_;
					gboolean _tmp35_;
					gboolean _tmp36_;
					_tmp32_ = param;
					_tmp33_ = vala_variable_get_variable_type ((ValaVariable*) _tmp32_);
					_tmp34_ = _tmp33_;
					_tmp35_ = vala_data_type_get_value_owned (_tmp34_);
					_tmp36_ = _tmp35_;
					_tmp28_ = !_tmp36_;
				} else {
					_tmp28_ = FALSE;
				}
				if (_tmp28_) {
					const gchar* _tmp37_;
					gchar* _tmp38_;
					_tmp37_ = ctypename;
					_tmp38_ = g_strconcat ("const ", _tmp37_, NULL);
					_g_free0 (ctypename);
					ctypename = _tmp38_;
				}
				_tmp39_ = param;
				_tmp40_ = vala_variable_get_variable_type ((ValaVariable*) _tmp39_);
				_tmp41_ = _tmp40_;
				_tmp42_ = vala_data_type_get_nullable (_tmp41_);
				_tmp43_ = _tmp42_;
				if (!_tmp43_) {
					const gchar* _tmp44_;
					gchar* _tmp45_;
					_tmp44_ = ctypename;
					_tmp45_ = g_strconcat (_tmp44_, "*", NULL);
					_g_free0 (ctypename);
					ctypename = _tmp45_;
				}
			}
			_vala_code_node_unref0 (st);
		}
		_tmp46_ = param;
		_tmp47_ = vala_parameter_get_direction (_tmp46_);
		_tmp48_ = _tmp47_;
		if (_tmp48_ != VALA_PARAMETER_DIRECTION_IN) {
			const gchar* _tmp49_;
			gchar* _tmp50_;
			_tmp49_ = ctypename;
			_tmp50_ = g_strconcat (_tmp49_, "*", NULL);
			_g_free0 (ctypename);
			ctypename = _tmp50_;
		}
		_tmp51_ = param;
		_tmp52_ = vala_symbol_get_name ((ValaSymbol*) _tmp51_);
		_tmp53_ = _tmp52_;
		_tmp54_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp53_);
		_tmp55_ = _tmp54_;
		_tmp56_ = ctypename;
		_tmp57_ = vala_ccode_parameter_new (_tmp55_, _tmp56_);
		_vala_ccode_node_unref0 (cparam);
		cparam = _tmp57_;
		_g_free0 (_tmp55_);
		_tmp58_ = param;
		_tmp59_ = vala_parameter_get_format_arg (_tmp58_);
		_tmp60_ = _tmp59_;
		if (_tmp60_) {
			ValaCCodeParameter* _tmp61_;
			_tmp61_ = cparam;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp61_, VALA_CCODE_MODIFIERS_FORMAT_ARG);
		}
		_g_free0 (ctypename);
	} else {
		gboolean _tmp62_;
		_tmp62_ = self->priv->ellipses_to_valist;
		if (_tmp62_) {
			ValaCCodeParameter* _tmp63_;
			_tmp63_ = vala_ccode_parameter_new ("_vala_va_list", "va_list");
			_vala_ccode_node_unref0 (cparam);
			cparam = _tmp63_;
		} else {
			ValaCCodeParameter* _tmp64_;
			_tmp64_ = vala_ccode_parameter_new_with_ellipsis ();
			_vala_ccode_node_unref0 (cparam);
			cparam = _tmp64_;
		}
	}
	_tmp65_ = cparam_map;
	_tmp66_ = param;
	_tmp67_ = vala_ccode_base_module_get_ccode_pos (_tmp66_);
	_tmp68_ = param;
	_tmp69_ = vala_parameter_get_ellipsis (_tmp68_);
	_tmp70_ = _tmp69_;
	_tmp71_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp67_, _tmp70_);
	_tmp72_ = cparam;
	vala_map_set (_tmp65_, (gpointer) ((gintptr) _tmp71_), _tmp72_);
	_tmp74_ = carg_map;
	if (_tmp74_ != NULL) {
		ValaParameter* _tmp75_;
		gboolean _tmp76_;
		gboolean _tmp77_;
		_tmp75_ = param;
		_tmp76_ = vala_parameter_get_ellipsis (_tmp75_);
		_tmp77_ = _tmp76_;
		_tmp73_ = !_tmp77_;
	} else {
		_tmp73_ = FALSE;
	}
	if (_tmp73_) {
		ValaMap* _tmp78_;
		ValaParameter* _tmp79_;
		gdouble _tmp80_;
		ValaParameter* _tmp81_;
		gboolean _tmp82_;
		gboolean _tmp83_;
		gint _tmp84_;
		ValaParameter* _tmp85_;
		const gchar* _tmp86_;
		const gchar* _tmp87_;
		ValaCCodeExpression* _tmp88_;
		ValaCCodeExpression* _tmp89_;
		_tmp78_ = carg_map;
		_tmp79_ = param;
		_tmp80_ = vala_ccode_base_module_get_ccode_pos (_tmp79_);
		_tmp81_ = param;
		_tmp82_ = vala_parameter_get_ellipsis (_tmp81_);
		_tmp83_ = _tmp82_;
		_tmp84_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp80_, _tmp83_);
		_tmp85_ = param;
		_tmp86_ = vala_symbol_get_name ((ValaSymbol*) _tmp85_);
		_tmp87_ = _tmp86_;
		_tmp88_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp87_);
		_tmp89_ = _tmp88_;
		vala_map_set (_tmp78_, (gpointer) ((gintptr) _tmp84_), _tmp89_);
		_vala_ccode_node_unref0 (_tmp89_);
	}
	result = cparam;
	return result;
}


ValaCCodeParameter* vala_ccode_method_module_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_METHOD_MODULE_GET_CLASS (self)->generate_parameter (self, param, decl_space, cparam_map, carg_map);
}


static void vala_ccode_method_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) {
	ValaCCodeMethodModule * self;
	ValaMethod* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	ValaMethod* _tmp145_;
	gboolean _tmp146_;
	gint _tmp348_;
	gint last_pos = 0;
	gint min_pos = 0;
	ValaMethod* _tmp391_;
	gboolean _tmp392_;
	gboolean _tmp393_;
	ValaMethod* _tmp405_;
	ValaVersionAttribute* _tmp406_;
	ValaVersionAttribute* _tmp407_;
	gboolean _tmp408_;
	gboolean _tmp409_;
	self = (ValaCCodeMethodModule*) 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_closure (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_) {
		ValaBlock* closure_block = NULL;
		ValaBlock* _tmp3_;
		ValaBlock* _tmp4_;
		ValaBlock* _tmp5_;
		gint block_id = 0;
		ValaBlock* _tmp6_;
		gint _tmp7_;
		ValaCCodeParameter* instance_param = NULL;
		gint _tmp8_;
		gchar* _tmp9_;
		gchar* _tmp10_;
		gint _tmp11_;
		gchar* _tmp12_;
		gchar* _tmp13_;
		ValaCCodeParameter* _tmp14_;
		ValaCCodeParameter* _tmp15_;
		ValaMap* _tmp16_;
		ValaMethod* _tmp17_;
		gdouble _tmp18_;
		gint _tmp19_;
		ValaCCodeParameter* _tmp20_;
		_tmp3_ = vala_ccode_base_module_get_current_closure_block ((ValaCCodeBaseModule*) self);
		_tmp4_ = _tmp3_;
		_tmp5_ = _vala_code_node_ref0 (_tmp4_);
		closure_block = _tmp5_;
		_tmp6_ = closure_block;
		_tmp7_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp6_);
		block_id = _tmp7_;
		_tmp8_ = block_id;
		_tmp9_ = g_strdup_printf ("_data%d_", _tmp8_);
		_tmp10_ = _tmp9_;
		_tmp11_ = block_id;
		_tmp12_ = g_strdup_printf ("Block%dData*", _tmp11_);
		_tmp13_ = _tmp12_;
		_tmp14_ = vala_ccode_parameter_new (_tmp10_, _tmp13_);
		_tmp15_ = _tmp14_;
		_g_free0 (_tmp13_);
		_g_free0 (_tmp10_);
		instance_param = _tmp15_;
		_tmp16_ = cparam_map;
		_tmp17_ = m;
		_tmp18_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp17_);
		_tmp19_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp18_, FALSE);
		_tmp20_ = instance_param;
		vala_map_set (_tmp16_, (gpointer) ((gintptr) _tmp19_), _tmp20_);
		_vala_ccode_node_unref0 (instance_param);
		_vala_code_node_unref0 (closure_block);
	} else {
		gboolean _tmp21_ = FALSE;
		ValaMethod* _tmp22_;
		ValaSymbol* _tmp23_;
		ValaSymbol* _tmp24_;
		_tmp22_ = m;
		_tmp23_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp22_);
		_tmp24_ = _tmp23_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp24_, VALA_TYPE_CLASS)) {
			ValaMethod* _tmp25_;
			_tmp25_ = m;
			_tmp21_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_CREATION_METHOD);
		} else {
			_tmp21_ = FALSE;
		}
		if (_tmp21_) {
			ValaClass* cl = NULL;
			ValaMethod* _tmp26_;
			ValaSymbol* _tmp27_;
			ValaSymbol* _tmp28_;
			ValaClass* _tmp29_;
			gboolean _tmp30_ = FALSE;
			gboolean _tmp31_ = FALSE;
			ValaClass* _tmp32_;
			gboolean _tmp33_;
			gboolean _tmp34_;
			_tmp26_ = m;
			_tmp27_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp26_);
			_tmp28_ = _tmp27_;
			_tmp29_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp28_, VALA_TYPE_CLASS, ValaClass));
			cl = _tmp29_;
			_tmp32_ = cl;
			_tmp33_ = vala_class_get_is_compact (_tmp32_);
			_tmp34_ = _tmp33_;
			if (!_tmp34_) {
				ValaCCodeFunctionCall* _tmp35_;
				_tmp35_ = vcall;
				_tmp31_ = _tmp35_ == NULL;
			} else {
				_tmp31_ = FALSE;
			}
			if (_tmp31_) {
				gint _tmp36_;
				_tmp36_ = direction;
				_tmp30_ = (_tmp36_ & 1) == 1;
			} else {
				_tmp30_ = FALSE;
			}
			if (_tmp30_) {
				ValaMap* _tmp37_;
				ValaMethod* _tmp38_;
				gdouble _tmp39_;
				gint _tmp40_;
				ValaCCodeParameter* _tmp41_;
				ValaCCodeParameter* _tmp42_;
				_tmp37_ = cparam_map;
				_tmp38_ = m;
				_tmp39_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp38_);
				_tmp40_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp39_, FALSE);
				_tmp41_ = vala_ccode_parameter_new ("object_type", "GType");
				_tmp42_ = _tmp41_;
				vala_map_set (_tmp37_, (gpointer) ((gintptr) _tmp40_), _tmp42_);
				_vala_ccode_node_unref0 (_tmp42_);
			}
			_vala_code_node_unref0 (cl);
		} else {
			gboolean _tmp43_ = FALSE;
			gboolean _tmp44_ = FALSE;
			ValaMethod* _tmp45_;
			ValaMemberBinding _tmp46_;
			ValaMemberBinding _tmp47_;
			_tmp45_ = m;
			_tmp46_ = vala_method_get_binding (_tmp45_);
			_tmp47_ = _tmp46_;
			if (_tmp47_ == VALA_MEMBER_BINDING_INSTANCE) {
				_tmp44_ = TRUE;
			} else {
				gboolean _tmp48_ = FALSE;
				ValaMethod* _tmp49_;
				ValaSymbol* _tmp50_;
				ValaSymbol* _tmp51_;
				_tmp49_ = m;
				_tmp50_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp49_);
				_tmp51_ = _tmp50_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp51_, VALA_TYPE_STRUCT)) {
					ValaMethod* _tmp52_;
					_tmp52_ = m;
					_tmp48_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp52_, VALA_TYPE_CREATION_METHOD);
				} else {
					_tmp48_ = FALSE;
				}
				_tmp44_ = _tmp48_;
			}
			if (_tmp44_) {
				gboolean _tmp53_ = FALSE;
				gint _tmp54_;
				_tmp54_ = direction;
				if (_tmp54_ != 2) {
					_tmp53_ = TRUE;
				} else {
					ValaMethod* _tmp55_;
					gboolean _tmp56_;
					_tmp55_ = m;
					_tmp56_ = vala_ccode_base_module_get_ccode_finish_instance ((ValaCodeNode*) _tmp55_);
					_tmp53_ = _tmp56_;
				}
				_tmp43_ = _tmp53_;
			} else {
				_tmp43_ = FALSE;
			}
			if (_tmp43_) {
				ValaTypeSymbol* parent_type = NULL;
				ValaMethod* _tmp57_;
				ValaTypeSymbol* _tmp58_;
				ValaDataType* this_type = NULL;
				ValaTypeSymbol* _tmp59_;
				ValaDataType* _tmp71_;
				ValaCCodeFile* _tmp72_;
				ValaCCodeParameter* instance_param = NULL;
				gboolean _tmp73_ = FALSE;
				gboolean _tmp74_ = FALSE;
				ValaMethod* _tmp75_;
				ValaMethod* _tmp76_;
				ValaMethod* _tmp77_;
				ValaMap* _tmp123_;
				ValaMethod* _tmp124_;
				gdouble _tmp125_;
				gint _tmp126_;
				ValaCCodeParameter* _tmp127_;
				_tmp57_ = m;
				_tmp58_ = vala_ccode_method_module_find_parent_type (self, (ValaSymbol*) _tmp57_);
				parent_type = _tmp58_;
				_tmp59_ = parent_type;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp59_, VALA_TYPE_CLASS)) {
					ValaTypeSymbol* _tmp60_;
					ValaObjectType* _tmp61_;
					_tmp60_ = parent_type;
					_tmp61_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp60_, VALA_TYPE_CLASS, ValaClass));
					_vala_code_node_unref0 (this_type);
					this_type = (ValaDataType*) _tmp61_;
				} else {
					ValaTypeSymbol* _tmp62_;
					_tmp62_ = parent_type;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp62_, VALA_TYPE_INTERFACE)) {
						ValaTypeSymbol* _tmp63_;
						ValaObjectType* _tmp64_;
						_tmp63_ = parent_type;
						_tmp64_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp63_, VALA_TYPE_INTERFACE, ValaInterface));
						_vala_code_node_unref0 (this_type);
						this_type = (ValaDataType*) _tmp64_;
					} else {
						ValaTypeSymbol* _tmp65_;
						_tmp65_ = parent_type;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp65_, VALA_TYPE_STRUCT)) {
							ValaTypeSymbol* _tmp66_;
							ValaStructValueType* _tmp67_;
							_tmp66_ = parent_type;
							_tmp67_ = vala_struct_value_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp66_, VALA_TYPE_STRUCT, ValaStruct));
							_vala_code_node_unref0 (this_type);
							this_type = (ValaDataType*) _tmp67_;
						} else {
							ValaTypeSymbol* _tmp68_;
							_tmp68_ = parent_type;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp68_, VALA_TYPE_ENUM)) {
								ValaTypeSymbol* _tmp69_;
								ValaEnumValueType* _tmp70_;
								_tmp69_ = parent_type;
								_tmp70_ = vala_enum_value_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp69_, VALA_TYPE_ENUM, ValaEnum));
								_vala_code_node_unref0 (this_type);
								this_type = (ValaDataType*) _tmp70_;
							} else {
								g_assert_not_reached ();
							}
						}
					}
				}
				_tmp71_ = this_type;
				_tmp72_ = decl_space;
				vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp71_, _tmp72_);
				instance_param = NULL;
				_tmp75_ = m;
				_tmp76_ = vala_method_get_base_interface_method (_tmp75_);
				_tmp77_ = _tmp76_;
				if (_tmp77_ != NULL) {
					ValaMethod* _tmp78_;
					gboolean _tmp79_;
					gboolean _tmp80_;
					_tmp78_ = m;
					_tmp79_ = vala_method_get_is_abstract (_tmp78_);
					_tmp80_ = _tmp79_;
					_tmp74_ = !_tmp80_;
				} else {
					_tmp74_ = FALSE;
				}
				if (_tmp74_) {
					ValaMethod* _tmp81_;
					gboolean _tmp82_;
					gboolean _tmp83_;
					_tmp81_ = m;
					_tmp82_ = vala_method_get_is_virtual (_tmp81_);
					_tmp83_ = _tmp82_;
					_tmp73_ = !_tmp83_;
				} else {
					_tmp73_ = FALSE;
				}
				if (_tmp73_) {
					ValaObjectType* base_type = NULL;
					ValaMethod* _tmp84_;
					ValaMethod* _tmp85_;
					ValaMethod* _tmp86_;
					ValaSymbol* _tmp87_;
					ValaSymbol* _tmp88_;
					ValaObjectType* _tmp89_;
					ValaObjectType* _tmp90_;
					gchar* _tmp91_;
					gchar* _tmp92_;
					ValaCCodeParameter* _tmp93_;
					_tmp84_ = m;
					_tmp85_ = vala_method_get_base_interface_method (_tmp84_);
					_tmp86_ = _tmp85_;
					_tmp87_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp86_);
					_tmp88_ = _tmp87_;
					_tmp89_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp88_, VALA_TYPE_INTERFACE, ValaInterface));
					base_type = _tmp89_;
					_tmp90_ = base_type;
					_tmp91_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp90_);
					_tmp92_ = _tmp91_;
					_tmp93_ = vala_ccode_parameter_new ("base", _tmp92_);
					_vala_ccode_node_unref0 (instance_param);
					instance_param = _tmp93_;
					_g_free0 (_tmp92_);
					_vala_code_node_unref0 (base_type);
				} else {
					ValaMethod* _tmp94_;
					gboolean _tmp95_;
					gboolean _tmp96_;
					_tmp94_ = m;
					_tmp95_ = vala_method_get_overrides (_tmp94_);
					_tmp96_ = _tmp95_;
					if (_tmp96_) {
						ValaObjectType* base_type = NULL;
						ValaMethod* _tmp97_;
						ValaMethod* _tmp98_;
						ValaMethod* _tmp99_;
						ValaSymbol* _tmp100_;
						ValaSymbol* _tmp101_;
						ValaObjectType* _tmp102_;
						ValaObjectType* _tmp103_;
						gchar* _tmp104_;
						gchar* _tmp105_;
						ValaCCodeParameter* _tmp106_;
						_tmp97_ = m;
						_tmp98_ = vala_method_get_base_method (_tmp97_);
						_tmp99_ = _tmp98_;
						_tmp100_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp99_);
						_tmp101_ = _tmp100_;
						_tmp102_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp101_, VALA_TYPE_CLASS, ValaClass));
						base_type = _tmp102_;
						_tmp103_ = base_type;
						_tmp104_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp103_);
						_tmp105_ = _tmp104_;
						_tmp106_ = vala_ccode_parameter_new ("base", _tmp105_);
						_vala_ccode_node_unref0 (instance_param);
						instance_param = _tmp106_;
						_g_free0 (_tmp105_);
						_vala_code_node_unref0 (base_type);
					} else {
						gboolean _tmp107_ = FALSE;
						ValaMethod* _tmp108_;
						ValaSymbol* _tmp109_;
						ValaSymbol* _tmp110_;
						_tmp108_ = m;
						_tmp109_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp108_);
						_tmp110_ = _tmp109_;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp110_, VALA_TYPE_STRUCT)) {
							ValaMethod* _tmp111_;
							ValaSymbol* _tmp112_;
							ValaSymbol* _tmp113_;
							gboolean _tmp114_;
							_tmp111_ = m;
							_tmp112_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp111_);
							_tmp113_ = _tmp112_;
							_tmp114_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp113_, VALA_TYPE_STRUCT, ValaStruct));
							_tmp107_ = !_tmp114_;
						} else {
							_tmp107_ = FALSE;
						}
						if (_tmp107_) {
							ValaDataType* _tmp115_;
							gchar* _tmp116_;
							gchar* _tmp117_;
							ValaCCodeParameter* _tmp118_;
							_tmp115_ = this_type;
							_tmp116_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp115_);
							_tmp117_ = _tmp116_;
							_tmp118_ = vala_ccode_parameter_new ("*self", _tmp117_);
							_vala_ccode_node_unref0 (instance_param);
							instance_param = _tmp118_;
							_g_free0 (_tmp117_);
						} else {
							ValaDataType* _tmp119_;
							gchar* _tmp120_;
							gchar* _tmp121_;
							ValaCCodeParameter* _tmp122_;
							_tmp119_ = this_type;
							_tmp120_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp119_);
							_tmp121_ = _tmp120_;
							_tmp122_ = vala_ccode_parameter_new ("self", _tmp121_);
							_vala_ccode_node_unref0 (instance_param);
							instance_param = _tmp122_;
							_g_free0 (_tmp121_);
						}
					}
				}
				_tmp123_ = cparam_map;
				_tmp124_ = m;
				_tmp125_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp124_);
				_tmp126_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp125_, FALSE);
				_tmp127_ = instance_param;
				vala_map_set (_tmp123_, (gpointer) ((gintptr) _tmp126_), _tmp127_);
				_vala_ccode_node_unref0 (instance_param);
				_vala_code_node_unref0 (this_type);
				_vala_code_node_unref0 (parent_type);
			} else {
				ValaMethod* _tmp128_;
				ValaMemberBinding _tmp129_;
				ValaMemberBinding _tmp130_;
				_tmp128_ = m;
				_tmp129_ = vala_method_get_binding (_tmp128_);
				_tmp130_ = _tmp129_;
				if (_tmp130_ == VALA_MEMBER_BINDING_CLASS) {
					ValaTypeSymbol* parent_type = NULL;
					ValaMethod* _tmp131_;
					ValaTypeSymbol* _tmp132_;
					ValaDataType* this_type = NULL;
					ValaTypeSymbol* _tmp133_;
					ValaClassType* _tmp134_;
					ValaCCodeParameter* class_param = NULL;
					ValaDataType* _tmp135_;
					gchar* _tmp136_;
					gchar* _tmp137_;
					ValaCCodeParameter* _tmp138_;
					ValaCCodeParameter* _tmp139_;
					ValaMap* _tmp140_;
					ValaMethod* _tmp141_;
					gdouble _tmp142_;
					gint _tmp143_;
					ValaCCodeParameter* _tmp144_;
					_tmp131_ = m;
					_tmp132_ = vala_ccode_method_module_find_parent_type (self, (ValaSymbol*) _tmp131_);
					parent_type = _tmp132_;
					_tmp133_ = parent_type;
					_tmp134_ = vala_class_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp133_, VALA_TYPE_CLASS, ValaClass));
					_vala_code_node_unref0 (this_type);
					this_type = (ValaDataType*) _tmp134_;
					_tmp135_ = this_type;
					_tmp136_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp135_);
					_tmp137_ = _tmp136_;
					_tmp138_ = vala_ccode_parameter_new ("klass", _tmp137_);
					_tmp139_ = _tmp138_;
					_g_free0 (_tmp137_);
					class_param = _tmp139_;
					_tmp140_ = cparam_map;
					_tmp141_ = m;
					_tmp142_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp141_);
					_tmp143_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp142_, FALSE);
					_tmp144_ = class_param;
					vala_map_set (_tmp140_, (gpointer) ((gintptr) _tmp143_), _tmp144_);
					_vala_ccode_node_unref0 (class_param);
					_vala_code_node_unref0 (this_type);
					_vala_code_node_unref0 (parent_type);
				}
			}
		}
	}
	_tmp145_ = m;
	_tmp146_ = vala_ccode_method_module_is_gtypeinstance_creation_method (self, _tmp145_);
	if (_tmp146_) {
		gint type_param_index = 0;
		ValaClass* cl = NULL;
		ValaMethod* _tmp147_;
		ValaSymbol* _tmp148_;
		ValaSymbol* _tmp149_;
		ValaClass* _tmp150_;
		type_param_index = 0;
		_tmp147_ = m;
		_tmp148_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp147_);
		_tmp149_ = _tmp148_;
		_tmp150_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp149_, VALA_TYPE_CLASS, ValaClass));
		cl = _tmp150_;
		{
			ValaList* _type_param_list = NULL;
			ValaClass* _tmp151_;
			ValaList* _tmp152_;
			gint _type_param_size = 0;
			ValaList* _tmp153_;
			gint _tmp154_;
			gint _tmp155_;
			gint _type_param_index = 0;
			_tmp151_ = cl;
			_tmp152_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp151_);
			_type_param_list = _tmp152_;
			_tmp153_ = _type_param_list;
			_tmp154_ = vala_collection_get_size ((ValaCollection*) _tmp153_);
			_tmp155_ = _tmp154_;
			_type_param_size = _tmp155_;
			_type_param_index = -1;
			while (TRUE) {
				gint _tmp156_;
				gint _tmp157_;
				gint _tmp158_;
				ValaTypeParameter* type_param = NULL;
				ValaList* _tmp159_;
				gint _tmp160_;
				gpointer _tmp161_;
				ValaMap* _tmp162_;
				gint _tmp163_;
				gint _tmp164_;
				ValaTypeParameter* _tmp165_;
				const gchar* _tmp166_;
				const gchar* _tmp167_;
				gchar* _tmp168_;
				gchar* _tmp169_;
				gchar* _tmp170_;
				gchar* _tmp171_;
				ValaCCodeParameter* _tmp172_;
				ValaCCodeParameter* _tmp173_;
				ValaMap* _tmp174_;
				gint _tmp175_;
				gint _tmp176_;
				ValaTypeParameter* _tmp177_;
				const gchar* _tmp178_;
				const gchar* _tmp179_;
				gchar* _tmp180_;
				gchar* _tmp181_;
				gchar* _tmp182_;
				gchar* _tmp183_;
				ValaCCodeParameter* _tmp184_;
				ValaCCodeParameter* _tmp185_;
				ValaMap* _tmp186_;
				gint _tmp187_;
				gint _tmp188_;
				ValaTypeParameter* _tmp189_;
				const gchar* _tmp190_;
				const gchar* _tmp191_;
				gchar* _tmp192_;
				gchar* _tmp193_;
				gchar* _tmp194_;
				gchar* _tmp195_;
				ValaCCodeParameter* _tmp196_;
				ValaCCodeParameter* _tmp197_;
				ValaMap* _tmp198_;
				gint _tmp235_;
				_tmp156_ = _type_param_index;
				_type_param_index = _tmp156_ + 1;
				_tmp157_ = _type_param_index;
				_tmp158_ = _type_param_size;
				if (!(_tmp157_ < _tmp158_)) {
					break;
				}
				_tmp159_ = _type_param_list;
				_tmp160_ = _type_param_index;
				_tmp161_ = vala_list_get (_tmp159_, _tmp160_);
				type_param = (ValaTypeParameter*) _tmp161_;
				_tmp162_ = cparam_map;
				_tmp163_ = type_param_index;
				_tmp164_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp163_) + 0.01, FALSE);
				_tmp165_ = type_param;
				_tmp166_ = vala_symbol_get_name ((ValaSymbol*) _tmp165_);
				_tmp167_ = _tmp166_;
				_tmp168_ = g_utf8_strdown (_tmp167_, (gssize) -1);
				_tmp169_ = _tmp168_;
				_tmp170_ = g_strdup_printf ("%s_type", _tmp169_);
				_tmp171_ = _tmp170_;
				_tmp172_ = vala_ccode_parameter_new (_tmp171_, "GType");
				_tmp173_ = _tmp172_;
				vala_map_set (_tmp162_, (gpointer) ((gintptr) _tmp164_), _tmp173_);
				_vala_ccode_node_unref0 (_tmp173_);
				_g_free0 (_tmp171_);
				_g_free0 (_tmp169_);
				_tmp174_ = cparam_map;
				_tmp175_ = type_param_index;
				_tmp176_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp175_) + 0.02, FALSE);
				_tmp177_ = type_param;
				_tmp178_ = vala_symbol_get_name ((ValaSymbol*) _tmp177_);
				_tmp179_ = _tmp178_;
				_tmp180_ = g_utf8_strdown (_tmp179_, (gssize) -1);
				_tmp181_ = _tmp180_;
				_tmp182_ = g_strdup_printf ("%s_dup_func", _tmp181_);
				_tmp183_ = _tmp182_;
				_tmp184_ = vala_ccode_parameter_new (_tmp183_, "GBoxedCopyFunc");
				_tmp185_ = _tmp184_;
				vala_map_set (_tmp174_, (gpointer) ((gintptr) _tmp176_), _tmp185_);
				_vala_ccode_node_unref0 (_tmp185_);
				_g_free0 (_tmp183_);
				_g_free0 (_tmp181_);
				_tmp186_ = cparam_map;
				_tmp187_ = type_param_index;
				_tmp188_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp187_) + 0.03, FALSE);
				_tmp189_ = type_param;
				_tmp190_ = vala_symbol_get_name ((ValaSymbol*) _tmp189_);
				_tmp191_ = _tmp190_;
				_tmp192_ = g_utf8_strdown (_tmp191_, (gssize) -1);
				_tmp193_ = _tmp192_;
				_tmp194_ = g_strdup_printf ("%s_destroy_func", _tmp193_);
				_tmp195_ = _tmp194_;
				_tmp196_ = vala_ccode_parameter_new (_tmp195_, "GDestroyNotify");
				_tmp197_ = _tmp196_;
				vala_map_set (_tmp186_, (gpointer) ((gintptr) _tmp188_), _tmp197_);
				_vala_ccode_node_unref0 (_tmp197_);
				_g_free0 (_tmp195_);
				_g_free0 (_tmp193_);
				_tmp198_ = carg_map;
				if (_tmp198_ != NULL) {
					ValaMap* _tmp199_;
					gint _tmp200_;
					gint _tmp201_;
					ValaTypeParameter* _tmp202_;
					const gchar* _tmp203_;
					const gchar* _tmp204_;
					gchar* _tmp205_;
					gchar* _tmp206_;
					gchar* _tmp207_;
					gchar* _tmp208_;
					ValaCCodeIdentifier* _tmp209_;
					ValaCCodeIdentifier* _tmp210_;
					ValaMap* _tmp211_;
					gint _tmp212_;
					gint _tmp213_;
					ValaTypeParameter* _tmp214_;
					const gchar* _tmp215_;
					const gchar* _tmp216_;
					gchar* _tmp217_;
					gchar* _tmp218_;
					gchar* _tmp219_;
					gchar* _tmp220_;
					ValaCCodeIdentifier* _tmp221_;
					ValaCCodeIdentifier* _tmp222_;
					ValaMap* _tmp223_;
					gint _tmp224_;
					gint _tmp225_;
					ValaTypeParameter* _tmp226_;
					const gchar* _tmp227_;
					const gchar* _tmp228_;
					gchar* _tmp229_;
					gchar* _tmp230_;
					gchar* _tmp231_;
					gchar* _tmp232_;
					ValaCCodeIdentifier* _tmp233_;
					ValaCCodeIdentifier* _tmp234_;
					_tmp199_ = carg_map;
					_tmp200_ = type_param_index;
					_tmp201_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp200_) + 0.01, FALSE);
					_tmp202_ = type_param;
					_tmp203_ = vala_symbol_get_name ((ValaSymbol*) _tmp202_);
					_tmp204_ = _tmp203_;
					_tmp205_ = g_utf8_strdown (_tmp204_, (gssize) -1);
					_tmp206_ = _tmp205_;
					_tmp207_ = g_strdup_printf ("%s_type", _tmp206_);
					_tmp208_ = _tmp207_;
					_tmp209_ = vala_ccode_identifier_new (_tmp208_);
					_tmp210_ = _tmp209_;
					vala_map_set (_tmp199_, (gpointer) ((gintptr) _tmp201_), (ValaCCodeExpression*) _tmp210_);
					_vala_ccode_node_unref0 (_tmp210_);
					_g_free0 (_tmp208_);
					_g_free0 (_tmp206_);
					_tmp211_ = carg_map;
					_tmp212_ = type_param_index;
					_tmp213_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp212_) + 0.02, FALSE);
					_tmp214_ = type_param;
					_tmp215_ = vala_symbol_get_name ((ValaSymbol*) _tmp214_);
					_tmp216_ = _tmp215_;
					_tmp217_ = g_utf8_strdown (_tmp216_, (gssize) -1);
					_tmp218_ = _tmp217_;
					_tmp219_ = g_strdup_printf ("%s_dup_func", _tmp218_);
					_tmp220_ = _tmp219_;
					_tmp221_ = vala_ccode_identifier_new (_tmp220_);
					_tmp222_ = _tmp221_;
					vala_map_set (_tmp211_, (gpointer) ((gintptr) _tmp213_), (ValaCCodeExpression*) _tmp222_);
					_vala_ccode_node_unref0 (_tmp222_);
					_g_free0 (_tmp220_);
					_g_free0 (_tmp218_);
					_tmp223_ = carg_map;
					_tmp224_ = type_param_index;
					_tmp225_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp224_) + 0.03, FALSE);
					_tmp226_ = type_param;
					_tmp227_ = vala_symbol_get_name ((ValaSymbol*) _tmp226_);
					_tmp228_ = _tmp227_;
					_tmp229_ = g_utf8_strdown (_tmp228_, (gssize) -1);
					_tmp230_ = _tmp229_;
					_tmp231_ = g_strdup_printf ("%s_destroy_func", _tmp230_);
					_tmp232_ = _tmp231_;
					_tmp233_ = vala_ccode_identifier_new (_tmp232_);
					_tmp234_ = _tmp233_;
					vala_map_set (_tmp223_, (gpointer) ((gintptr) _tmp225_), (ValaCCodeExpression*) _tmp234_);
					_vala_ccode_node_unref0 (_tmp234_);
					_g_free0 (_tmp232_);
					_g_free0 (_tmp230_);
				}
				_tmp235_ = type_param_index;
				type_param_index = _tmp235_ + 1;
				_vala_code_node_unref0 (type_param);
			}
			_vala_iterable_unref0 (_type_param_list);
		}
		_vala_code_node_unref0 (cl);
	} else {
		gboolean _tmp236_ = FALSE;
		ValaMethod* _tmp237_;
		gboolean _tmp238_;
		gboolean _tmp239_;
		_tmp237_ = m;
		_tmp238_ = vala_method_get_closure (_tmp237_);
		_tmp239_ = _tmp238_;
		if (!_tmp239_) {
			gint _tmp240_;
			_tmp240_ = direction;
			_tmp236_ = (_tmp240_ & 1) == 1;
		} else {
			_tmp236_ = FALSE;
		}
		if (_tmp236_) {
			gint type_param_index = 0;
			type_param_index = 0;
			{
				ValaList* _type_param_list = NULL;
				ValaMethod* _tmp241_;
				ValaList* _tmp242_;
				gint _type_param_size = 0;
				ValaList* _tmp243_;
				gint _tmp244_;
				gint _tmp245_;
				gint _type_param_index = 0;
				_tmp241_ = m;
				_tmp242_ = vala_method_get_type_parameters (_tmp241_);
				_type_param_list = _tmp242_;
				_tmp243_ = _type_param_list;
				_tmp244_ = vala_collection_get_size ((ValaCollection*) _tmp243_);
				_tmp245_ = _tmp244_;
				_type_param_size = _tmp245_;
				_type_param_index = -1;
				while (TRUE) {
					gint _tmp246_;
					gint _tmp247_;
					gint _tmp248_;
					ValaTypeParameter* type_param = NULL;
					ValaList* _tmp249_;
					gint _tmp250_;
					gpointer _tmp251_;
					ValaMap* _tmp252_;
					gint _tmp253_;
					gint _tmp254_;
					ValaTypeParameter* _tmp255_;
					const gchar* _tmp256_;
					const gchar* _tmp257_;
					gchar* _tmp258_;
					gchar* _tmp259_;
					gchar* _tmp260_;
					gchar* _tmp261_;
					ValaCCodeParameter* _tmp262_;
					ValaCCodeParameter* _tmp263_;
					ValaMap* _tmp264_;
					gint _tmp265_;
					gint _tmp266_;
					ValaTypeParameter* _tmp267_;
					const gchar* _tmp268_;
					const gchar* _tmp269_;
					gchar* _tmp270_;
					gchar* _tmp271_;
					gchar* _tmp272_;
					gchar* _tmp273_;
					ValaCCodeParameter* _tmp274_;
					ValaCCodeParameter* _tmp275_;
					ValaMap* _tmp276_;
					gint _tmp277_;
					gint _tmp278_;
					ValaTypeParameter* _tmp279_;
					const gchar* _tmp280_;
					const gchar* _tmp281_;
					gchar* _tmp282_;
					gchar* _tmp283_;
					gchar* _tmp284_;
					gchar* _tmp285_;
					ValaCCodeParameter* _tmp286_;
					ValaCCodeParameter* _tmp287_;
					ValaMap* _tmp288_;
					gint _tmp325_;
					_tmp246_ = _type_param_index;
					_type_param_index = _tmp246_ + 1;
					_tmp247_ = _type_param_index;
					_tmp248_ = _type_param_size;
					if (!(_tmp247_ < _tmp248_)) {
						break;
					}
					_tmp249_ = _type_param_list;
					_tmp250_ = _type_param_index;
					_tmp251_ = vala_list_get (_tmp249_, _tmp250_);
					type_param = (ValaTypeParameter*) _tmp251_;
					_tmp252_ = cparam_map;
					_tmp253_ = type_param_index;
					_tmp254_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp253_) + 0.01, FALSE);
					_tmp255_ = type_param;
					_tmp256_ = vala_symbol_get_name ((ValaSymbol*) _tmp255_);
					_tmp257_ = _tmp256_;
					_tmp258_ = g_utf8_strdown (_tmp257_, (gssize) -1);
					_tmp259_ = _tmp258_;
					_tmp260_ = g_strdup_printf ("%s_type", _tmp259_);
					_tmp261_ = _tmp260_;
					_tmp262_ = vala_ccode_parameter_new (_tmp261_, "GType");
					_tmp263_ = _tmp262_;
					vala_map_set (_tmp252_, (gpointer) ((gintptr) _tmp254_), _tmp263_);
					_vala_ccode_node_unref0 (_tmp263_);
					_g_free0 (_tmp261_);
					_g_free0 (_tmp259_);
					_tmp264_ = cparam_map;
					_tmp265_ = type_param_index;
					_tmp266_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp265_) + 0.02, FALSE);
					_tmp267_ = type_param;
					_tmp268_ = vala_symbol_get_name ((ValaSymbol*) _tmp267_);
					_tmp269_ = _tmp268_;
					_tmp270_ = g_utf8_strdown (_tmp269_, (gssize) -1);
					_tmp271_ = _tmp270_;
					_tmp272_ = g_strdup_printf ("%s_dup_func", _tmp271_);
					_tmp273_ = _tmp272_;
					_tmp274_ = vala_ccode_parameter_new (_tmp273_, "GBoxedCopyFunc");
					_tmp275_ = _tmp274_;
					vala_map_set (_tmp264_, (gpointer) ((gintptr) _tmp266_), _tmp275_);
					_vala_ccode_node_unref0 (_tmp275_);
					_g_free0 (_tmp273_);
					_g_free0 (_tmp271_);
					_tmp276_ = cparam_map;
					_tmp277_ = type_param_index;
					_tmp278_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp277_) + 0.03, FALSE);
					_tmp279_ = type_param;
					_tmp280_ = vala_symbol_get_name ((ValaSymbol*) _tmp279_);
					_tmp281_ = _tmp280_;
					_tmp282_ = g_utf8_strdown (_tmp281_, (gssize) -1);
					_tmp283_ = _tmp282_;
					_tmp284_ = g_strdup_printf ("%s_destroy_func", _tmp283_);
					_tmp285_ = _tmp284_;
					_tmp286_ = vala_ccode_parameter_new (_tmp285_, "GDestroyNotify");
					_tmp287_ = _tmp286_;
					vala_map_set (_tmp276_, (gpointer) ((gintptr) _tmp278_), _tmp287_);
					_vala_ccode_node_unref0 (_tmp287_);
					_g_free0 (_tmp285_);
					_g_free0 (_tmp283_);
					_tmp288_ = carg_map;
					if (_tmp288_ != NULL) {
						ValaMap* _tmp289_;
						gint _tmp290_;
						gint _tmp291_;
						ValaTypeParameter* _tmp292_;
						const gchar* _tmp293_;
						const gchar* _tmp294_;
						gchar* _tmp295_;
						gchar* _tmp296_;
						gchar* _tmp297_;
						gchar* _tmp298_;
						ValaCCodeIdentifier* _tmp299_;
						ValaCCodeIdentifier* _tmp300_;
						ValaMap* _tmp301_;
						gint _tmp302_;
						gint _tmp303_;
						ValaTypeParameter* _tmp304_;
						const gchar* _tmp305_;
						const gchar* _tmp306_;
						gchar* _tmp307_;
						gchar* _tmp308_;
						gchar* _tmp309_;
						gchar* _tmp310_;
						ValaCCodeIdentifier* _tmp311_;
						ValaCCodeIdentifier* _tmp312_;
						ValaMap* _tmp313_;
						gint _tmp314_;
						gint _tmp315_;
						ValaTypeParameter* _tmp316_;
						const gchar* _tmp317_;
						const gchar* _tmp318_;
						gchar* _tmp319_;
						gchar* _tmp320_;
						gchar* _tmp321_;
						gchar* _tmp322_;
						ValaCCodeIdentifier* _tmp323_;
						ValaCCodeIdentifier* _tmp324_;
						_tmp289_ = carg_map;
						_tmp290_ = type_param_index;
						_tmp291_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp290_) + 0.01, FALSE);
						_tmp292_ = type_param;
						_tmp293_ = vala_symbol_get_name ((ValaSymbol*) _tmp292_);
						_tmp294_ = _tmp293_;
						_tmp295_ = g_utf8_strdown (_tmp294_, (gssize) -1);
						_tmp296_ = _tmp295_;
						_tmp297_ = g_strdup_printf ("%s_type", _tmp296_);
						_tmp298_ = _tmp297_;
						_tmp299_ = vala_ccode_identifier_new (_tmp298_);
						_tmp300_ = _tmp299_;
						vala_map_set (_tmp289_, (gpointer) ((gintptr) _tmp291_), (ValaCCodeExpression*) _tmp300_);
						_vala_ccode_node_unref0 (_tmp300_);
						_g_free0 (_tmp298_);
						_g_free0 (_tmp296_);
						_tmp301_ = carg_map;
						_tmp302_ = type_param_index;
						_tmp303_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp302_) + 0.02, FALSE);
						_tmp304_ = type_param;
						_tmp305_ = vala_symbol_get_name ((ValaSymbol*) _tmp304_);
						_tmp306_ = _tmp305_;
						_tmp307_ = g_utf8_strdown (_tmp306_, (gssize) -1);
						_tmp308_ = _tmp307_;
						_tmp309_ = g_strdup_printf ("%s_dup_func", _tmp308_);
						_tmp310_ = _tmp309_;
						_tmp311_ = vala_ccode_identifier_new (_tmp310_);
						_tmp312_ = _tmp311_;
						vala_map_set (_tmp301_, (gpointer) ((gintptr) _tmp303_), (ValaCCodeExpression*) _tmp312_);
						_vala_ccode_node_unref0 (_tmp312_);
						_g_free0 (_tmp310_);
						_g_free0 (_tmp308_);
						_tmp313_ = carg_map;
						_tmp314_ = type_param_index;
						_tmp315_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp314_) + 0.03, FALSE);
						_tmp316_ = type_param;
						_tmp317_ = vala_symbol_get_name ((ValaSymbol*) _tmp316_);
						_tmp318_ = _tmp317_;
						_tmp319_ = g_utf8_strdown (_tmp318_, (gssize) -1);
						_tmp320_ = _tmp319_;
						_tmp321_ = g_strdup_printf ("%s_destroy_func", _tmp320_);
						_tmp322_ = _tmp321_;
						_tmp323_ = vala_ccode_identifier_new (_tmp322_);
						_tmp324_ = _tmp323_;
						vala_map_set (_tmp313_, (gpointer) ((gintptr) _tmp315_), (ValaCCodeExpression*) _tmp324_);
						_vala_ccode_node_unref0 (_tmp324_);
						_g_free0 (_tmp322_);
						_g_free0 (_tmp320_);
					}
					_tmp325_ = type_param_index;
					type_param_index = _tmp325_ + 1;
					_vala_code_node_unref0 (type_param);
				}
				_vala_iterable_unref0 (_type_param_list);
			}
		}
	}
	{
		ValaList* _param_list = NULL;
		ValaMethod* _tmp326_;
		ValaList* _tmp327_;
		gint _param_size = 0;
		ValaList* _tmp328_;
		gint _tmp329_;
		gint _tmp330_;
		gint _param_index = 0;
		_tmp326_ = m;
		_tmp327_ = vala_callable_get_parameters ((ValaCallable*) _tmp326_);
		_param_list = _tmp327_;
		_tmp328_ = _param_list;
		_tmp329_ = vala_collection_get_size ((ValaCollection*) _tmp328_);
		_tmp330_ = _tmp329_;
		_param_size = _tmp330_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp331_;
			gint _tmp332_;
			gint _tmp333_;
			ValaParameter* param = NULL;
			ValaList* _tmp334_;
			gint _tmp335_;
			gpointer _tmp336_;
			ValaParameter* _tmp337_;
			ValaParameterDirection _tmp338_;
			ValaParameterDirection _tmp339_;
			ValaParameter* _tmp342_;
			ValaCCodeFile* _tmp343_;
			ValaMap* _tmp344_;
			ValaMap* _tmp345_;
			ValaCCodeParameter* _tmp346_;
			ValaCCodeParameter* _tmp347_;
			_tmp331_ = _param_index;
			_param_index = _tmp331_ + 1;
			_tmp332_ = _param_index;
			_tmp333_ = _param_size;
			if (!(_tmp332_ < _tmp333_)) {
				break;
			}
			_tmp334_ = _param_list;
			_tmp335_ = _param_index;
			_tmp336_ = vala_list_get (_tmp334_, _tmp335_);
			param = (ValaParameter*) _tmp336_;
			_tmp337_ = param;
			_tmp338_ = vala_parameter_get_direction (_tmp337_);
			_tmp339_ = _tmp338_;
			if (_tmp339_ != VALA_PARAMETER_DIRECTION_OUT) {
				gint _tmp340_;
				_tmp340_ = direction;
				if ((_tmp340_ & 1) == 0) {
					_vala_code_node_unref0 (param);
					continue;
				}
			} else {
				gint _tmp341_;
				_tmp341_ = direction;
				if ((_tmp341_ & 2) == 0) {
					_vala_code_node_unref0 (param);
					continue;
				}
			}
			_tmp342_ = param;
			_tmp343_ = decl_space;
			_tmp344_ = cparam_map;
			_tmp345_ = carg_map;
			_tmp346_ = vala_ccode_method_module_generate_parameter (self, _tmp342_, _tmp343_, _tmp344_, _tmp345_);
			_tmp347_ = _tmp346_;
			_vala_ccode_node_unref0 (_tmp347_);
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
	_tmp348_ = direction;
	if ((_tmp348_ & 2) != 0) {
		ValaMethod* _tmp349_;
		ValaCCodeFile* _tmp350_;
		ValaCCodeFunction* _tmp351_;
		ValaMap* _tmp352_;
		ValaMap* _tmp353_;
		_tmp349_ = m;
		_tmp350_ = decl_space;
		_tmp351_ = func;
		_tmp352_ = cparam_map;
		_tmp353_ = carg_map;
		vala_ccode_method_module_generate_method_result_declaration (self, _tmp349_, _tmp350_, _tmp351_, _tmp352_, _tmp353_);
	}
	last_pos = -1;
	while (TRUE) {
		gint _tmp371_;
		ValaCCodeFunction* _tmp372_;
		ValaMap* _tmp373_;
		gint _tmp374_;
		gpointer _tmp375_;
		ValaCCodeParameter* _tmp376_;
		ValaCCodeFunctionDeclarator* _tmp377_;
		ValaCCodeFunctionCall* _tmp383_;
		gint _tmp390_;
		min_pos = -1;
		{
			ValaIterator* _pos_it = NULL;
			ValaMap* _tmp354_;
			ValaSet* _tmp355_;
			ValaSet* _tmp356_;
			ValaIterator* _tmp357_;
			ValaIterator* _tmp358_;
			_tmp354_ = cparam_map;
			_tmp355_ = vala_map_get_keys (_tmp354_);
			_tmp356_ = _tmp355_;
			_tmp357_ = vala_iterable_iterator ((ValaIterable*) _tmp356_);
			_tmp358_ = _tmp357_;
			_vala_iterable_unref0 (_tmp356_);
			_pos_it = _tmp358_;
			while (TRUE) {
				ValaIterator* _tmp359_;
				gboolean _tmp360_;
				gint pos = 0;
				ValaIterator* _tmp361_;
				gpointer _tmp362_;
				gboolean _tmp363_ = FALSE;
				gint _tmp364_;
				gint _tmp365_;
				_tmp359_ = _pos_it;
				_tmp360_ = vala_iterator_next (_tmp359_);
				if (!_tmp360_) {
					break;
				}
				_tmp361_ = _pos_it;
				_tmp362_ = vala_iterator_get (_tmp361_);
				pos = (gint) ((gintptr) _tmp362_);
				_tmp364_ = pos;
				_tmp365_ = last_pos;
				if (_tmp364_ > _tmp365_) {
					gboolean _tmp366_ = FALSE;
					gint _tmp367_;
					_tmp367_ = min_pos;
					if (_tmp367_ == -1) {
						_tmp366_ = TRUE;
					} else {
						gint _tmp368_;
						gint _tmp369_;
						_tmp368_ = pos;
						_tmp369_ = min_pos;
						_tmp366_ = _tmp368_ < _tmp369_;
					}
					_tmp363_ = _tmp366_;
				} else {
					_tmp363_ = FALSE;
				}
				if (_tmp363_) {
					gint _tmp370_;
					_tmp370_ = pos;
					min_pos = _tmp370_;
				}
			}
			_vala_iterator_unref0 (_pos_it);
		}
		_tmp371_ = min_pos;
		if (_tmp371_ == -1) {
			break;
		}
		_tmp372_ = func;
		_tmp373_ = cparam_map;
		_tmp374_ = min_pos;
		_tmp375_ = vala_map_get (_tmp373_, (gpointer) ((gintptr) _tmp374_));
		_tmp376_ = (ValaCCodeParameter*) _tmp375_;
		vala_ccode_function_add_parameter (_tmp372_, _tmp376_);
		_vala_ccode_node_unref0 (_tmp376_);
		_tmp377_ = vdeclarator;
		if (_tmp377_ != NULL) {
			ValaCCodeFunctionDeclarator* _tmp378_;
			ValaMap* _tmp379_;
			gint _tmp380_;
			gpointer _tmp381_;
			ValaCCodeParameter* _tmp382_;
			_tmp378_ = vdeclarator;
			_tmp379_ = cparam_map;
			_tmp380_ = min_pos;
			_tmp381_ = vala_map_get (_tmp379_, (gpointer) ((gintptr) _tmp380_));
			_tmp382_ = (ValaCCodeParameter*) _tmp381_;
			vala_ccode_function_declarator_add_parameter (_tmp378_, _tmp382_);
			_vala_ccode_node_unref0 (_tmp382_);
		}
		_tmp383_ = vcall;
		if (_tmp383_ != NULL) {
			ValaCCodeExpression* arg = NULL;
			ValaMap* _tmp384_;
			gint _tmp385_;
			gpointer _tmp386_;
			ValaCCodeExpression* _tmp387_;
			_tmp384_ = carg_map;
			_tmp385_ = min_pos;
			_tmp386_ = vala_map_get (_tmp384_, (gpointer) ((gintptr) _tmp385_));
			arg = (ValaCCodeExpression*) _tmp386_;
			_tmp387_ = arg;
			if (_tmp387_ != NULL) {
				ValaCCodeFunctionCall* _tmp388_;
				ValaCCodeExpression* _tmp389_;
				_tmp388_ = vcall;
				_tmp389_ = arg;
				vala_ccode_function_call_add_argument (_tmp388_, _tmp389_);
			}
			_vala_ccode_node_unref0 (arg);
		}
		_tmp390_ = min_pos;
		last_pos = _tmp390_;
	}
	_tmp391_ = m;
	_tmp392_ = vala_method_get_printf_format (_tmp391_);
	_tmp393_ = _tmp392_;
	if (_tmp393_) {
		ValaCCodeFunction* _tmp394_;
		ValaCCodeFunction* _tmp395_;
		ValaCCodeModifiers _tmp396_;
		ValaCCodeModifiers _tmp397_;
		_tmp394_ = func;
		_tmp395_ = func;
		_tmp396_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp395_);
		_tmp397_ = _tmp396_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp395_, _tmp397_ | VALA_CCODE_MODIFIERS_PRINTF);
	} else {
		ValaMethod* _tmp398_;
		gboolean _tmp399_;
		gboolean _tmp400_;
		_tmp398_ = m;
		_tmp399_ = vala_method_get_scanf_format (_tmp398_);
		_tmp400_ = _tmp399_;
		if (_tmp400_) {
			ValaCCodeFunction* _tmp401_;
			ValaCCodeFunction* _tmp402_;
			ValaCCodeModifiers _tmp403_;
			ValaCCodeModifiers _tmp404_;
			_tmp401_ = func;
			_tmp402_ = func;
			_tmp403_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp402_);
			_tmp404_ = _tmp403_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp402_, _tmp404_ | VALA_CCODE_MODIFIERS_SCANF);
		}
	}
	_tmp405_ = m;
	_tmp406_ = vala_symbol_get_version ((ValaSymbol*) _tmp405_);
	_tmp407_ = _tmp406_;
	_tmp408_ = vala_version_attribute_get_deprecated (_tmp407_);
	_tmp409_ = _tmp408_;
	if (_tmp409_) {
		ValaCCodeFunction* _tmp410_;
		ValaCCodeFunction* _tmp411_;
		ValaCCodeModifiers _tmp412_;
		ValaCCodeModifiers _tmp413_;
		_tmp410_ = func;
		_tmp411_ = func;
		_tmp412_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp411_);
		_tmp413_ = _tmp412_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp411_, _tmp413_ | VALA_CCODE_MODIFIERS_DEPRECATED);
	}
}


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


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) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaCCodeBaseModuleEmitContext* _tmp1_;
	gchar* cname = NULL;
	ValaMethod* _tmp2_;
	gchar* _tmp3_;
	gboolean _tmp4_ = FALSE;
	const gchar* _tmp5_;
	ValaCCodeFunction* vfunc = NULL;
	const gchar* _tmp15_;
	const gchar* _tmp16_;
	gchar* _tmp17_;
	gchar* _tmp18_;
	ValaCCodeFunction* _tmp19_;
	ValaCCodeFunction* _tmp20_;
	ValaCCodeFunctionCall* vcast = NULL;
	ValaMethod* _tmp21_;
	ValaSymbol* _tmp22_;
	ValaSymbol* _tmp23_;
	ValaCCodeFunctionCall* _tmp48_;
	ValaCCodeIdentifier* _tmp49_;
	ValaCCodeIdentifier* _tmp50_;
	ValaMethod* _tmp51_;
	gchar* _tmp52_;
	gboolean _tmp53_ = FALSE;
	const gchar* _tmp54_;
	ValaCCodeFunctionCall* vcall = NULL;
	ValaCCodeFunctionCall* _tmp64_;
	const gchar* _tmp65_;
	const gchar* _tmp66_;
	gchar* _tmp67_;
	gchar* _tmp68_;
	ValaCCodeMemberAccess* _tmp69_;
	ValaCCodeMemberAccess* _tmp70_;
	ValaCCodeFunctionCall* _tmp71_;
	ValaCCodeFunctionCall* _tmp72_;
	ValaMap* _tmp73_;
	ValaMethod* _tmp74_;
	gdouble _tmp75_;
	gint _tmp76_;
	ValaCCodeIdentifier* _tmp77_;
	ValaCCodeIdentifier* _tmp78_;
	ValaMethod* _tmp79_;
	ValaCCodeFile* _tmp80_;
	ValaMap* _tmp81_;
	ValaCCodeFunction* _tmp82_;
	ValaMap* _tmp83_;
	ValaCCodeFunctionCall* _tmp84_;
	gint _tmp85_;
	ValaCCodeFunction* _tmp86_;
	gboolean _tmp87_ = FALSE;
	gboolean _tmp88_ = FALSE;
	gboolean _tmp89_ = FALSE;
	ValaCodeContext* _tmp90_;
	ValaCodeContext* _tmp91_;
	gboolean _tmp92_;
	gboolean _tmp93_;
	ValaMethod* _tmp126_;
	ValaDataType* _tmp127_;
	ValaMethod* _tmp128_;
	ValaSymbol* _tmp129_;
	ValaSymbol* _tmp130_;
	gboolean _tmp145_ = FALSE;
	ValaDataType* _tmp146_;
	ValaMethod* _tmp176_;
	ValaList* _tmp177_;
	ValaList* _tmp178_;
	gint _tmp179_;
	gint _tmp180_;
	gboolean _tmp181_;
	ValaMethod* _tmp199_;
	gboolean _tmp200_;
	gboolean _tmp201_;
	ValaMethod* _tmp213_;
	ValaVersionAttribute* _tmp214_;
	ValaVersionAttribute* _tmp215_;
	gboolean _tmp216_;
	gboolean _tmp217_;
	ValaCCodeFile* _tmp222_;
	ValaCCodeFunction* _tmp223_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (m != NULL);
	g_return_if_fail (return_type != NULL);
	g_return_if_fail (cparam_map != NULL);
	g_return_if_fail (carg_map != NULL);
	g_return_if_fail (suffix != 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_);
	cname = _tmp3_;
	_tmp5_ = suffix;
	if (g_strcmp0 (_tmp5_, "_finish") == 0) {
		const gchar* _tmp6_;
		gboolean _tmp7_;
		_tmp6_ = cname;
		_tmp7_ = g_str_has_suffix (_tmp6_, "_async");
		_tmp4_ = _tmp7_;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		const gchar* _tmp8_;
		const gchar* _tmp9_;
		gint _tmp10_;
		gint _tmp11_;
		gint _tmp12_;
		gint _tmp13_;
		gchar* _tmp14_;
		_tmp8_ = cname;
		_tmp9_ = cname;
		_tmp10_ = strlen (_tmp9_);
		_tmp11_ = _tmp10_;
		_tmp12_ = strlen ("_async");
		_tmp13_ = _tmp12_;
		_tmp14_ = string_substring (_tmp8_, (glong) 0, (glong) (_tmp11_ - _tmp13_));
		_g_free0 (cname);
		cname = _tmp14_;
	}
	_tmp15_ = cname;
	_tmp16_ = suffix;
	_tmp17_ = g_strconcat (_tmp15_, _tmp16_, NULL);
	_tmp18_ = _tmp17_;
	_tmp19_ = vala_ccode_function_new (_tmp18_, "void");
	_tmp20_ = _tmp19_;
	_g_free0 (_tmp18_);
	vfunc = _tmp20_;
	vcast = NULL;
	_tmp21_ = m;
	_tmp22_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp21_);
	_tmp23_ = _tmp22_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_INTERFACE)) {
		ValaInterface* iface = NULL;
		ValaMethod* _tmp24_;
		ValaSymbol* _tmp25_;
		ValaSymbol* _tmp26_;
		ValaInterface* _tmp27_;
		ValaInterface* _tmp28_;
		gchar* _tmp29_;
		gchar* _tmp30_;
		gchar* _tmp31_;
		gchar* _tmp32_;
		ValaCCodeIdentifier* _tmp33_;
		ValaCCodeIdentifier* _tmp34_;
		ValaCCodeFunctionCall* _tmp35_;
		_tmp24_ = m;
		_tmp25_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp24_);
		_tmp26_ = _tmp25_;
		_tmp27_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_INTERFACE, ValaInterface));
		iface = _tmp27_;
		_tmp28_ = iface;
		_tmp29_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp28_, NULL);
		_tmp30_ = _tmp29_;
		_tmp31_ = g_strdup_printf ("%s_GET_INTERFACE", _tmp30_);
		_tmp32_ = _tmp31_;
		_tmp33_ = vala_ccode_identifier_new (_tmp32_);
		_tmp34_ = _tmp33_;
		_tmp35_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp34_);
		_vala_ccode_node_unref0 (vcast);
		vcast = _tmp35_;
		_vala_ccode_node_unref0 (_tmp34_);
		_g_free0 (_tmp32_);
		_g_free0 (_tmp30_);
		_vala_code_node_unref0 (iface);
	} else {
		ValaClass* cl = NULL;
		ValaMethod* _tmp36_;
		ValaSymbol* _tmp37_;
		ValaSymbol* _tmp38_;
		ValaClass* _tmp39_;
		ValaClass* _tmp40_;
		gchar* _tmp41_;
		gchar* _tmp42_;
		gchar* _tmp43_;
		gchar* _tmp44_;
		ValaCCodeIdentifier* _tmp45_;
		ValaCCodeIdentifier* _tmp46_;
		ValaCCodeFunctionCall* _tmp47_;
		_tmp36_ = m;
		_tmp37_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp36_);
		_tmp38_ = _tmp37_;
		_tmp39_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp38_, VALA_TYPE_CLASS, ValaClass));
		cl = _tmp39_;
		_tmp40_ = cl;
		_tmp41_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp40_, NULL);
		_tmp42_ = _tmp41_;
		_tmp43_ = g_strdup_printf ("%s_GET_CLASS", _tmp42_);
		_tmp44_ = _tmp43_;
		_tmp45_ = vala_ccode_identifier_new (_tmp44_);
		_tmp46_ = _tmp45_;
		_tmp47_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp46_);
		_vala_ccode_node_unref0 (vcast);
		vcast = _tmp47_;
		_vala_ccode_node_unref0 (_tmp46_);
		_g_free0 (_tmp44_);
		_g_free0 (_tmp42_);
		_vala_code_node_unref0 (cl);
	}
	_tmp48_ = vcast;
	_tmp49_ = vala_ccode_identifier_new ("self");
	_tmp50_ = _tmp49_;
	vala_ccode_function_call_add_argument (_tmp48_, (ValaCCodeExpression*) _tmp50_);
	_vala_ccode_node_unref0 (_tmp50_);
	_tmp51_ = m;
	_tmp52_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp51_);
	_g_free0 (cname);
	cname = _tmp52_;
	_tmp54_ = suffix;
	if (g_strcmp0 (_tmp54_, "_finish") == 0) {
		const gchar* _tmp55_;
		gboolean _tmp56_;
		_tmp55_ = cname;
		_tmp56_ = g_str_has_suffix (_tmp55_, "_async");
		_tmp53_ = _tmp56_;
	} else {
		_tmp53_ = FALSE;
	}
	if (_tmp53_) {
		const gchar* _tmp57_;
		const gchar* _tmp58_;
		gint _tmp59_;
		gint _tmp60_;
		gint _tmp61_;
		gint _tmp62_;
		gchar* _tmp63_;
		_tmp57_ = cname;
		_tmp58_ = cname;
		_tmp59_ = strlen (_tmp58_);
		_tmp60_ = _tmp59_;
		_tmp61_ = strlen ("_async");
		_tmp62_ = _tmp61_;
		_tmp63_ = string_substring (_tmp57_, (glong) 0, (glong) (_tmp60_ - _tmp62_));
		_g_free0 (cname);
		cname = _tmp63_;
	}
	_tmp64_ = vcast;
	_tmp65_ = cname;
	_tmp66_ = suffix;
	_tmp67_ = g_strconcat (_tmp65_, _tmp66_, NULL);
	_tmp68_ = _tmp67_;
	_tmp69_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp64_, _tmp68_);
	_tmp70_ = _tmp69_;
	_tmp71_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp70_);
	_tmp72_ = _tmp71_;
	_vala_ccode_node_unref0 (_tmp70_);
	_g_free0 (_tmp68_);
	vcall = _tmp72_;
	_tmp73_ = carg_map;
	_tmp74_ = m;
	_tmp75_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp74_);
	_tmp76_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp75_, FALSE);
	_tmp77_ = vala_ccode_identifier_new ("self");
	_tmp78_ = _tmp77_;
	vala_map_set (_tmp73_, (gpointer) ((gintptr) _tmp76_), (ValaCCodeExpression*) _tmp78_);
	_vala_ccode_node_unref0 (_tmp78_);
	_tmp79_ = m;
	_tmp80_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp81_ = cparam_map;
	_tmp82_ = vfunc;
	_tmp83_ = carg_map;
	_tmp84_ = vcall;
	_tmp85_ = direction;
	vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp79_, _tmp80_, _tmp81_, _tmp82_, NULL, _tmp83_, _tmp84_, _tmp85_);
	_tmp86_ = vfunc;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp86_);
	_tmp90_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp91_ = _tmp90_;
	_tmp92_ = vala_code_context_get_assert (_tmp91_);
	_tmp93_ = _tmp92_;
	if (_tmp93_) {
		ValaMethod* _tmp94_;
		ValaDataType* _tmp95_;
		ValaDataType* _tmp96_;
		ValaTypeSymbol* _tmp97_;
		ValaTypeSymbol* _tmp98_;
		_tmp94_ = m;
		_tmp95_ = vala_callable_get_return_type ((ValaCallable*) _tmp94_);
		_tmp96_ = _tmp95_;
		_tmp97_ = vala_data_type_get_data_type (_tmp96_);
		_tmp98_ = _tmp97_;
		_tmp89_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp98_, VALA_TYPE_STRUCT);
	} else {
		_tmp89_ = FALSE;
	}
	if (_tmp89_) {
		ValaMethod* _tmp99_;
		ValaDataType* _tmp100_;
		ValaDataType* _tmp101_;
		ValaTypeSymbol* _tmp102_;
		ValaTypeSymbol* _tmp103_;
		gboolean _tmp104_;
		_tmp99_ = m;
		_tmp100_ = vala_callable_get_return_type ((ValaCallable*) _tmp99_);
		_tmp101_ = _tmp100_;
		_tmp102_ = vala_data_type_get_data_type (_tmp101_);
		_tmp103_ = _tmp102_;
		_tmp104_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp103_, VALA_TYPE_STRUCT, ValaStruct));
		_tmp88_ = _tmp104_;
	} else {
		_tmp88_ = FALSE;
	}
	if (_tmp88_) {
		ValaMethod* _tmp105_;
		ValaDataType* _tmp106_;
		ValaDataType* _tmp107_;
		ValaCCodeExpression* _tmp108_;
		ValaCCodeExpression* _tmp109_;
		_tmp105_ = m;
		_tmp106_ = vala_callable_get_return_type ((ValaCallable*) _tmp105_);
		_tmp107_ = _tmp106_;
		_tmp108_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp107_, FALSE);
		_tmp109_ = _tmp108_;
		_tmp87_ = _tmp109_ == NULL;
		_vala_ccode_node_unref0 (_tmp109_);
	} else {
		_tmp87_ = FALSE;
	}
	if (_tmp87_) {
		ValaCCodeVariableDeclarator* vardecl = NULL;
		ValaMethod* _tmp110_;
		ValaDataType* _tmp111_;
		ValaDataType* _tmp112_;
		ValaCCodeExpression* _tmp113_;
		ValaCCodeExpression* _tmp114_;
		ValaCCodeVariableDeclarator* _tmp115_;
		ValaCCodeVariableDeclarator* _tmp116_;
		ValaCCodeVariableDeclarator* _tmp117_;
		ValaCCodeFunction* _tmp118_;
		ValaCCodeFunction* _tmp119_;
		ValaMethod* _tmp120_;
		ValaDataType* _tmp121_;
		ValaDataType* _tmp122_;
		gchar* _tmp123_;
		gchar* _tmp124_;
		ValaCCodeVariableDeclarator* _tmp125_;
		_tmp110_ = m;
		_tmp111_ = vala_callable_get_return_type ((ValaCallable*) _tmp110_);
		_tmp112_ = _tmp111_;
		_tmp113_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp112_, TRUE);
		_tmp114_ = _tmp113_;
		_tmp115_ = vala_ccode_variable_declarator_new ("result", _tmp114_, NULL);
		_tmp116_ = _tmp115_;
		_vala_ccode_node_unref0 (_tmp114_);
		vardecl = _tmp116_;
		_tmp117_ = vardecl;
		vala_ccode_variable_declarator_set_init0 (_tmp117_, TRUE);
		_tmp118_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp119_ = _tmp118_;
		_tmp120_ = m;
		_tmp121_ = vala_callable_get_return_type ((ValaCallable*) _tmp120_);
		_tmp122_ = _tmp121_;
		_tmp123_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp122_);
		_tmp124_ = _tmp123_;
		_tmp125_ = vardecl;
		vala_ccode_function_add_declaration (_tmp119_, _tmp124_, (ValaCCodeDeclarator*) _tmp125_, 0);
		_g_free0 (_tmp124_);
		_vala_ccode_node_unref0 (vardecl);
	}
	_tmp126_ = m;
	_tmp127_ = return_type;
	_tmp128_ = m;
	_tmp129_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp128_);
	_tmp130_ = _tmp129_;
	vala_ccode_method_module_create_method_type_check_statement (self, _tmp126_, _tmp127_, G_TYPE_CHECK_INSTANCE_CAST (_tmp130_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol), TRUE, "self");
	{
		ValaList* _precondition_list = NULL;
		ValaMethod* _tmp131_;
		ValaList* _tmp132_;
		gint _precondition_size = 0;
		ValaList* _tmp133_;
		gint _tmp134_;
		gint _tmp135_;
		gint _precondition_index = 0;
		_tmp131_ = m;
		_tmp132_ = vala_method_get_preconditions (_tmp131_);
		_precondition_list = _tmp132_;
		_tmp133_ = _precondition_list;
		_tmp134_ = vala_collection_get_size ((ValaCollection*) _tmp133_);
		_tmp135_ = _tmp134_;
		_precondition_size = _tmp135_;
		_precondition_index = -1;
		while (TRUE) {
			gint _tmp136_;
			gint _tmp137_;
			gint _tmp138_;
			ValaExpression* precondition = NULL;
			ValaList* _tmp139_;
			gint _tmp140_;
			gpointer _tmp141_;
			ValaMethod* _tmp142_;
			ValaDataType* _tmp143_;
			ValaExpression* _tmp144_;
			_tmp136_ = _precondition_index;
			_precondition_index = _tmp136_ + 1;
			_tmp137_ = _precondition_index;
			_tmp138_ = _precondition_size;
			if (!(_tmp137_ < _tmp138_)) {
				break;
			}
			_tmp139_ = _precondition_list;
			_tmp140_ = _precondition_index;
			_tmp141_ = vala_list_get (_tmp139_, _tmp140_);
			precondition = (ValaExpression*) _tmp141_;
			_tmp142_ = m;
			_tmp143_ = return_type;
			_tmp144_ = precondition;
			vala_ccode_method_module_create_precondition_statement (self, (ValaCodeNode*) _tmp142_, _tmp143_, _tmp144_);
			_vala_code_node_unref0 (precondition);
		}
		_vala_iterable_unref0 (_precondition_list);
	}
	_tmp146_ = return_type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp146_, VALA_TYPE_VOID_TYPE)) {
		_tmp145_ = TRUE;
	} else {
		ValaDataType* _tmp147_;
		gboolean _tmp148_;
		_tmp147_ = return_type;
		_tmp148_ = vala_data_type_is_real_non_null_struct_type (_tmp147_);
		_tmp145_ = _tmp148_;
	}
	if (_tmp145_) {
		ValaCCodeFunction* _tmp149_;
		ValaCCodeFunction* _tmp150_;
		ValaCCodeFunctionCall* _tmp151_;
		_tmp149_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp150_ = _tmp149_;
		_tmp151_ = vcall;
		vala_ccode_function_add_expression (_tmp150_, (ValaCCodeExpression*) _tmp151_);
	} else {
		ValaMethod* _tmp152_;
		ValaList* _tmp153_;
		ValaList* _tmp154_;
		gint _tmp155_;
		gint _tmp156_;
		gboolean _tmp157_;
		_tmp152_ = m;
		_tmp153_ = vala_method_get_postconditions (_tmp152_);
		_tmp154_ = _tmp153_;
		_tmp155_ = vala_collection_get_size ((ValaCollection*) _tmp154_);
		_tmp156_ = _tmp155_;
		_tmp157_ = _tmp156_ == 0;
		_vala_iterable_unref0 (_tmp154_);
		if (_tmp157_) {
			ValaCCodeFunction* _tmp158_;
			ValaCCodeFunction* _tmp159_;
			ValaCCodeFunctionCall* _tmp160_;
			_tmp158_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp159_ = _tmp158_;
			_tmp160_ = vcall;
			vala_ccode_function_add_return (_tmp159_, (ValaCCodeExpression*) _tmp160_);
		} else {
			ValaCCodeFunction* _tmp161_;
			ValaCCodeFunction* _tmp162_;
			ValaMethod* _tmp163_;
			ValaDataType* _tmp164_;
			gchar* _tmp165_;
			gchar* _tmp166_;
			gchar* _tmp167_;
			gchar* _tmp168_;
			ValaCCodeVariableDeclarator* _tmp169_;
			ValaCCodeVariableDeclarator* _tmp170_;
			ValaCCodeFunction* _tmp171_;
			ValaCCodeFunction* _tmp172_;
			ValaCCodeIdentifier* _tmp173_;
			ValaCCodeIdentifier* _tmp174_;
			ValaCCodeFunctionCall* _tmp175_;
			_tmp161_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp162_ = _tmp161_;
			_tmp163_ = m;
			_tmp164_ = return_type;
			_tmp165_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp164_);
			_tmp166_ = _tmp165_;
			_tmp167_ = vala_ccode_method_module_get_creturn_type (self, _tmp163_, _tmp166_);
			_tmp168_ = _tmp167_;
			_tmp169_ = vala_ccode_variable_declarator_new ("result", NULL, NULL);
			_tmp170_ = _tmp169_;
			vala_ccode_function_add_declaration (_tmp162_, _tmp168_, (ValaCCodeDeclarator*) _tmp170_, 0);
			_vala_ccode_node_unref0 (_tmp170_);
			_g_free0 (_tmp168_);
			_g_free0 (_tmp166_);
			_tmp171_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp172_ = _tmp171_;
			_tmp173_ = vala_ccode_identifier_new ("result");
			_tmp174_ = _tmp173_;
			_tmp175_ = vcall;
			vala_ccode_function_add_assignment (_tmp172_, (ValaCCodeExpression*) _tmp174_, (ValaCCodeExpression*) _tmp175_);
			_vala_ccode_node_unref0 (_tmp174_);
		}
	}
	_tmp176_ = m;
	_tmp177_ = vala_method_get_postconditions (_tmp176_);
	_tmp178_ = _tmp177_;
	_tmp179_ = vala_collection_get_size ((ValaCollection*) _tmp178_);
	_tmp180_ = _tmp179_;
	_tmp181_ = _tmp180_ > 0;
	_vala_iterable_unref0 (_tmp178_);
	if (_tmp181_) {
		ValaDataType* _tmp194_;
		{
			ValaList* _postcondition_list = NULL;
			ValaMethod* _tmp182_;
			ValaList* _tmp183_;
			gint _postcondition_size = 0;
			ValaList* _tmp184_;
			gint _tmp185_;
			gint _tmp186_;
			gint _postcondition_index = 0;
			_tmp182_ = m;
			_tmp183_ = vala_method_get_postconditions (_tmp182_);
			_postcondition_list = _tmp183_;
			_tmp184_ = _postcondition_list;
			_tmp185_ = vala_collection_get_size ((ValaCollection*) _tmp184_);
			_tmp186_ = _tmp185_;
			_postcondition_size = _tmp186_;
			_postcondition_index = -1;
			while (TRUE) {
				gint _tmp187_;
				gint _tmp188_;
				gint _tmp189_;
				ValaExpression* postcondition = NULL;
				ValaList* _tmp190_;
				gint _tmp191_;
				gpointer _tmp192_;
				ValaExpression* _tmp193_;
				_tmp187_ = _postcondition_index;
				_postcondition_index = _tmp187_ + 1;
				_tmp188_ = _postcondition_index;
				_tmp189_ = _postcondition_size;
				if (!(_tmp188_ < _tmp189_)) {
					break;
				}
				_tmp190_ = _postcondition_list;
				_tmp191_ = _postcondition_index;
				_tmp192_ = vala_list_get (_tmp190_, _tmp191_);
				postcondition = (ValaExpression*) _tmp192_;
				_tmp193_ = postcondition;
				vala_ccode_base_module_create_postcondition_statement ((ValaCCodeBaseModule*) self, _tmp193_);
				_vala_code_node_unref0 (postcondition);
			}
			_vala_iterable_unref0 (_postcondition_list);
		}
		_tmp194_ = return_type;
		if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp194_, VALA_TYPE_VOID_TYPE)) {
			ValaCCodeFunction* _tmp195_;
			ValaCCodeFunction* _tmp196_;
			ValaCCodeIdentifier* _tmp197_;
			ValaCCodeIdentifier* _tmp198_;
			_tmp195_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp196_ = _tmp195_;
			_tmp197_ = vala_ccode_identifier_new ("result");
			_tmp198_ = _tmp197_;
			vala_ccode_function_add_return (_tmp196_, (ValaCCodeExpression*) _tmp198_);
			_vala_ccode_node_unref0 (_tmp198_);
		}
	}
	_tmp199_ = m;
	_tmp200_ = vala_method_get_printf_format (_tmp199_);
	_tmp201_ = _tmp200_;
	if (_tmp201_) {
		ValaCCodeFunction* _tmp202_;
		ValaCCodeFunction* _tmp203_;
		ValaCCodeModifiers _tmp204_;
		ValaCCodeModifiers _tmp205_;
		_tmp202_ = vfunc;
		_tmp203_ = vfunc;
		_tmp204_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp203_);
		_tmp205_ = _tmp204_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp203_, _tmp205_ | VALA_CCODE_MODIFIERS_PRINTF);
	} else {
		ValaMethod* _tmp206_;
		gboolean _tmp207_;
		gboolean _tmp208_;
		_tmp206_ = m;
		_tmp207_ = vala_method_get_scanf_format (_tmp206_);
		_tmp208_ = _tmp207_;
		if (_tmp208_) {
			ValaCCodeFunction* _tmp209_;
			ValaCCodeFunction* _tmp210_;
			ValaCCodeModifiers _tmp211_;
			ValaCCodeModifiers _tmp212_;
			_tmp209_ = vfunc;
			_tmp210_ = vfunc;
			_tmp211_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp210_);
			_tmp212_ = _tmp211_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp210_, _tmp212_ | VALA_CCODE_MODIFIERS_SCANF);
		}
	}
	_tmp213_ = m;
	_tmp214_ = vala_symbol_get_version ((ValaSymbol*) _tmp213_);
	_tmp215_ = _tmp214_;
	_tmp216_ = vala_version_attribute_get_deprecated (_tmp215_);
	_tmp217_ = _tmp216_;
	if (_tmp217_) {
		ValaCCodeFunction* _tmp218_;
		ValaCCodeFunction* _tmp219_;
		ValaCCodeModifiers _tmp220_;
		ValaCCodeModifiers _tmp221_;
		_tmp218_ = vfunc;
		_tmp219_ = vfunc;
		_tmp220_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp219_);
		_tmp221_ = _tmp220_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp219_, _tmp221_ | VALA_CCODE_MODIFIERS_DEPRECATED);
	}
	_tmp222_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp223_ = vfunc;
	vala_ccode_file_add_function (_tmp222_, _tmp223_);
	vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self);
	_vala_ccode_node_unref0 (vcall);
	_vala_ccode_node_unref0 (vcast);
	_vala_ccode_node_unref0 (vfunc);
	_g_free0 (cname);
}


static void vala_ccode_method_module_create_method_type_check_statement (ValaCCodeMethodModule* self, ValaMethod* m, ValaDataType* return_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name) {
	ValaMethod* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (m != NULL);
	g_return_if_fail (return_type != NULL);
	g_return_if_fail (t != NULL);
	g_return_if_fail (var_name != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_method_get_coroutine (_tmp0_);
	_tmp2_ = _tmp1_;
	if (!_tmp2_) {
		ValaMethod* _tmp3_;
		ValaDataType* _tmp4_;
		ValaTypeSymbol* _tmp5_;
		gboolean _tmp6_;
		const gchar* _tmp7_;
		_tmp3_ = m;
		_tmp4_ = return_type;
		_tmp5_ = t;
		_tmp6_ = non_null;
		_tmp7_ = var_name;
		vala_ccode_base_module_create_type_check_statement ((ValaCCodeBaseModule*) self, (ValaCodeNode*) _tmp3_, _tmp4_, _tmp5_, _tmp6_, _tmp7_);
	}
}


static gchar* string_replace (const gchar* self, const gchar* old, const gchar* replacement) {
	gchar* result = NULL;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (old != NULL, NULL);
	g_return_val_if_fail (replacement != NULL, NULL);
	if ((*((gchar*) self)) == '\0') {
		_tmp1_ = TRUE;
	} else {
		const gchar* _tmp2_;
		_tmp2_ = old;
		_tmp1_ = (*((gchar*) _tmp2_)) == '\0';
	}
	if (_tmp1_) {
		_tmp0_ = TRUE;
	} else {
		const gchar* _tmp3_;
		const gchar* _tmp4_;
		_tmp3_ = old;
		_tmp4_ = replacement;
		_tmp0_ = g_strcmp0 (_tmp3_, _tmp4_) == 0;
	}
	if (_tmp0_) {
		gchar* _tmp5_;
		_tmp5_ = g_strdup (self);
		result = _tmp5_;
		return result;
	}
	{
		GRegex* regex = NULL;
		const gchar* _tmp6_;
		gchar* _tmp7_;
		gchar* _tmp8_;
		GRegex* _tmp9_;
		GRegex* _tmp10_;
		gchar* _tmp11_ = NULL;
		GRegex* _tmp12_;
		const gchar* _tmp13_;
		gchar* _tmp14_;
		gchar* _tmp15_;
		_tmp6_ = old;
		_tmp7_ = g_regex_escape_string (_tmp6_, -1);
		_tmp8_ = _tmp7_;
		_tmp9_ = g_regex_new (_tmp8_, 0, 0, &_inner_error_);
		_tmp10_ = _tmp9_;
		_g_free0 (_tmp8_);
		regex = _tmp10_;
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			if (_inner_error_->domain == G_REGEX_ERROR) {
				goto __catch5_g_regex_error;
			}
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
		_tmp12_ = regex;
		_tmp13_ = replacement;
		_tmp14_ = g_regex_replace_literal (_tmp12_, self, (gssize) -1, 0, _tmp13_, 0, &_inner_error_);
		_tmp11_ = _tmp14_;
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			_g_regex_unref0 (regex);
			if (_inner_error_->domain == G_REGEX_ERROR) {
				goto __catch5_g_regex_error;
			}
			_g_regex_unref0 (regex);
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
		_tmp15_ = _tmp11_;
		_tmp11_ = NULL;
		result = _tmp15_;
		_g_free0 (_tmp11_);
		_g_regex_unref0 (regex);
		return result;
	}
	goto __finally5;
	__catch5_g_regex_error:
	{
		GError* e = NULL;
		e = _inner_error_;
		_inner_error_ = NULL;
		g_assert_not_reached ();
		_g_error_free0 (e);
	}
	__finally5:
	if (G_UNLIKELY (_inner_error_ != NULL)) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
}


static void vala_ccode_method_module_create_precondition_statement (ValaCCodeMethodModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaExpression* precondition) {
	ValaCCodeFunctionCall* ccheck = NULL;
	ValaCCodeFunctionCall* _tmp0_;
	ValaExpression* _tmp1_;
	ValaCCodeFunctionCall* _tmp2_;
	ValaExpression* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	ValaCCodeExpression* _tmp5_;
	gchar* message = NULL;
	ValaExpression* _tmp6_;
	ValaSourceReference* _tmp7_;
	ValaSourceReference* _tmp8_;
	ValaSourceLocation _tmp9_ = {0};
	ValaSourceLocation _tmp10_;
	gchar* _tmp11_;
	ValaExpression* _tmp12_;
	ValaSourceReference* _tmp13_;
	ValaSourceReference* _tmp14_;
	ValaSourceLocation _tmp15_ = {0};
	ValaSourceLocation _tmp16_;
	gchar* _tmp17_;
	ValaExpression* _tmp18_;
	ValaSourceReference* _tmp19_;
	ValaSourceReference* _tmp20_;
	ValaSourceLocation _tmp21_ = {0};
	ValaSourceLocation _tmp22_;
	gchar* _tmp23_;
	gchar* _tmp24_;
	ValaCCodeFunctionCall* _tmp25_;
	const gchar* _tmp26_;
	gchar* _tmp27_;
	gchar* _tmp28_;
	gchar* _tmp29_;
	gchar* _tmp30_;
	gchar* _tmp31_;
	gchar* _tmp32_;
	ValaCCodeConstant* _tmp33_;
	ValaCCodeConstant* _tmp34_;
	ValaCodeNode* _tmp35_;
	ValaCCodeFunction* _tmp65_;
	ValaCCodeFunction* _tmp66_;
	ValaCCodeFunctionCall* _tmp67_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (method_node != NULL);
	g_return_if_fail (ret_type != NULL);
	g_return_if_fail (precondition != NULL);
	_tmp0_ = vala_ccode_function_call_new (NULL);
	ccheck = _tmp0_;
	_tmp1_ = precondition;
	vala_code_node_emit ((ValaCodeNode*) _tmp1_, (ValaCodeGenerator*) self);
	_tmp2_ = ccheck;
	_tmp3_ = precondition;
	_tmp4_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp3_);
	_tmp5_ = _tmp4_;
	vala_ccode_function_call_add_argument (_tmp2_, _tmp5_);
	_vala_ccode_node_unref0 (_tmp5_);
	_tmp6_ = precondition;
	_tmp7_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp6_);
	_tmp8_ = _tmp7_;
	vala_source_reference_get_begin (_tmp8_, &_tmp9_);
	_tmp10_ = _tmp9_;
	_tmp11_ = _tmp10_.pos;
	_tmp12_ = precondition;
	_tmp13_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp12_);
	_tmp14_ = _tmp13_;
	vala_source_reference_get_end (_tmp14_, &_tmp15_);
	_tmp16_ = _tmp15_;
	_tmp17_ = _tmp16_.pos;
	_tmp18_ = precondition;
	_tmp19_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp18_);
	_tmp20_ = _tmp19_;
	vala_source_reference_get_begin (_tmp20_, &_tmp21_);
	_tmp22_ = _tmp21_;
	_tmp23_ = _tmp22_.pos;
	_tmp24_ = string_substring ((const gchar*) _tmp11_, (glong) 0, (glong) ((gint) (_tmp17_ - _tmp23_)));
	message = _tmp24_;
	_tmp25_ = ccheck;
	_tmp26_ = message;
	_tmp27_ = string_replace (_tmp26_, "\n", " ");
	_tmp28_ = _tmp27_;
	_tmp29_ = g_strescape (_tmp28_, "");
	_tmp30_ = _tmp29_;
	_tmp31_ = g_strdup_printf ("\"%s\"", _tmp30_);
	_tmp32_ = _tmp31_;
	_tmp33_ = vala_ccode_constant_new (_tmp32_);
	_tmp34_ = _tmp33_;
	vala_ccode_function_call_add_argument (_tmp25_, (ValaCCodeExpression*) _tmp34_);
	_vala_ccode_node_unref0 (_tmp34_);
	_g_free0 (_tmp32_);
	_g_free0 (_tmp30_);
	_g_free0 (_tmp28_);
	((ValaCCodeBaseModule*) self)->requires_assert = TRUE;
	_tmp35_ = method_node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp35_, VALA_TYPE_CREATION_METHOD)) {
		ValaCCodeFunctionCall* _tmp36_;
		ValaCCodeIdentifier* _tmp37_;
		ValaCCodeIdentifier* _tmp38_;
		ValaCCodeFunctionCall* _tmp39_;
		ValaCCodeConstant* _tmp40_;
		ValaCCodeConstant* _tmp41_;
		_tmp36_ = ccheck;
		_tmp37_ = vala_ccode_identifier_new ("_vala_return_val_if_fail");
		_tmp38_ = _tmp37_;
		vala_ccode_function_call_set_call (_tmp36_, (ValaCCodeExpression*) _tmp38_);
		_vala_ccode_node_unref0 (_tmp38_);
		_tmp39_ = ccheck;
		_tmp40_ = vala_ccode_constant_new ("NULL");
		_tmp41_ = _tmp40_;
		vala_ccode_function_call_add_argument (_tmp39_, (ValaCCodeExpression*) _tmp41_);
		_vala_ccode_node_unref0 (_tmp41_);
	} else {
		gboolean _tmp42_ = FALSE;
		ValaCodeNode* _tmp43_;
		_tmp43_ = method_node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp43_, VALA_TYPE_METHOD)) {
			ValaCodeNode* _tmp44_;
			gboolean _tmp45_;
			gboolean _tmp46_;
			_tmp44_ = method_node;
			_tmp45_ = vala_method_get_coroutine (G_TYPE_CHECK_INSTANCE_CAST (_tmp44_, VALA_TYPE_METHOD, ValaMethod));
			_tmp46_ = _tmp45_;
			_tmp42_ = _tmp46_;
		} else {
			_tmp42_ = FALSE;
		}
		if (_tmp42_) {
			ValaCCodeFunctionCall* _tmp47_;
			ValaCCodeIdentifier* _tmp48_;
			ValaCCodeIdentifier* _tmp49_;
			ValaCCodeFunctionCall* _tmp50_;
			ValaCCodeConstant* _tmp51_;
			ValaCCodeConstant* _tmp52_;
			_tmp47_ = ccheck;
			_tmp48_ = vala_ccode_identifier_new ("_vala_return_val_if_fail");
			_tmp49_ = _tmp48_;
			vala_ccode_function_call_set_call (_tmp47_, (ValaCCodeExpression*) _tmp49_);
			_vala_ccode_node_unref0 (_tmp49_);
			_tmp50_ = ccheck;
			_tmp51_ = vala_ccode_constant_new ("FALSE");
			_tmp52_ = _tmp51_;
			vala_ccode_function_call_add_argument (_tmp50_, (ValaCCodeExpression*) _tmp52_);
			_vala_ccode_node_unref0 (_tmp52_);
		} else {
			ValaDataType* _tmp53_;
			_tmp53_ = ret_type;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp53_, VALA_TYPE_VOID_TYPE)) {
				ValaCCodeFunctionCall* _tmp54_;
				ValaCCodeIdentifier* _tmp55_;
				ValaCCodeIdentifier* _tmp56_;
				_tmp54_ = ccheck;
				_tmp55_ = vala_ccode_identifier_new ("_vala_return_if_fail");
				_tmp56_ = _tmp55_;
				vala_ccode_function_call_set_call (_tmp54_, (ValaCCodeExpression*) _tmp56_);
				_vala_ccode_node_unref0 (_tmp56_);
			} else {
				ValaCCodeFunctionCall* _tmp57_;
				ValaCCodeIdentifier* _tmp58_;
				ValaCCodeIdentifier* _tmp59_;
				ValaCCodeExpression* cdefault = NULL;
				ValaDataType* _tmp60_;
				ValaCCodeExpression* _tmp61_;
				ValaCCodeExpression* _tmp62_;
				_tmp57_ = ccheck;
				_tmp58_ = vala_ccode_identifier_new ("_vala_return_val_if_fail");
				_tmp59_ = _tmp58_;
				vala_ccode_function_call_set_call (_tmp57_, (ValaCCodeExpression*) _tmp59_);
				_vala_ccode_node_unref0 (_tmp59_);
				_tmp60_ = ret_type;
				_tmp61_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp60_, FALSE);
				cdefault = _tmp61_;
				_tmp62_ = cdefault;
				if (_tmp62_ != NULL) {
					ValaCCodeFunctionCall* _tmp63_;
					ValaCCodeExpression* _tmp64_;
					_tmp63_ = ccheck;
					_tmp64_ = cdefault;
					vala_ccode_function_call_add_argument (_tmp63_, _tmp64_);
				} else {
					_vala_ccode_node_unref0 (cdefault);
					_g_free0 (message);
					_vala_ccode_node_unref0 (ccheck);
					return;
				}
				_vala_ccode_node_unref0 (cdefault);
			}
		}
	}
	_tmp65_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp66_ = _tmp65_;
	_tmp67_ = ccheck;
	vala_ccode_function_add_expression (_tmp66_, (ValaCCodeExpression*) _tmp67_);
	_g_free0 (message);
	_vala_ccode_node_unref0 (ccheck);
}


static ValaTypeSymbol* vala_ccode_method_module_find_parent_type (ValaCCodeMethodModule* self, ValaSymbol* sym) {
	ValaTypeSymbol* result = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (sym != NULL, NULL);
	while (TRUE) {
		ValaSymbol* _tmp0_;
		ValaSymbol* _tmp1_;
		ValaSymbol* _tmp4_;
		ValaSymbol* _tmp5_;
		ValaSymbol* _tmp6_;
		_tmp0_ = sym;
		if (!(_tmp0_ != NULL)) {
			break;
		}
		_tmp1_ = sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_TYPESYMBOL)) {
			ValaSymbol* _tmp2_;
			ValaTypeSymbol* _tmp3_;
			_tmp2_ = sym;
			_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
			result = _tmp3_;
			return result;
		}
		_tmp4_ = sym;
		_tmp5_ = vala_symbol_get_parent_symbol (_tmp4_);
		_tmp6_ = _tmp5_;
		sym = _tmp6_;
	}
	result = NULL;
	return result;
}


static void vala_ccode_method_module_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m) {
	ValaCCodeMethodModule * self;
	ValaCreationMethod* _tmp0_;
	ValaSourceReference* _tmp1_;
	ValaSourceReference* _tmp2_;
	ValaCreationMethod* _tmp3_;
	ValaCreationMethod* _tmp4_;
	ValaSourceFileType _tmp5_;
	ValaSourceFileType _tmp6_;
	gboolean _tmp7_ = FALSE;
	gboolean _tmp8_ = FALSE;
	ValaTypeSymbol* _tmp9_;
	ValaTypeSymbol* _tmp10_;
	self = (ValaCCodeMethodModule*) base;
	g_return_if_fail (m != NULL);
	_tmp0_ = m;
	_tmp1_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	vala_ccode_base_module_push_line ((ValaCCodeBaseModule*) self, _tmp2_);
	self->priv->ellipses_to_valist = TRUE;
	_tmp3_ = m;
	vala_code_visitor_visit_method ((ValaCodeVisitor*) self, (ValaMethod*) _tmp3_);
	self->priv->ellipses_to_valist = FALSE;
	_tmp4_ = m;
	_tmp5_ = vala_symbol_get_source_type ((ValaSymbol*) _tmp4_);
	_tmp6_ = _tmp5_;
	if (_tmp6_ == VALA_SOURCE_FILE_TYPE_FAST) {
		return;
	}
	_tmp9_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
	_tmp10_ = _tmp9_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_CLASS)) {
		ValaClass* _tmp11_;
		ValaClass* _tmp12_;
		gboolean _tmp13_;
		gboolean _tmp14_;
		_tmp11_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp12_ = _tmp11_;
		_tmp13_ = vala_class_get_is_compact (_tmp12_);
		_tmp14_ = _tmp13_;
		_tmp8_ = !_tmp14_;
	} else {
		_tmp8_ = FALSE;
	}
	if (_tmp8_) {
		ValaClass* _tmp15_;
		ValaClass* _tmp16_;
		gboolean _tmp17_;
		gboolean _tmp18_;
		_tmp15_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp16_ = _tmp15_;
		_tmp17_ = vala_class_get_is_abstract (_tmp16_);
		_tmp18_ = _tmp17_;
		_tmp7_ = !_tmp18_;
	} else {
		_tmp7_ = FALSE;
	}
	if (_tmp7_) {
		ValaCreationMethod* _tmp19_;
		ValaCreationMethod* _tmp20_;
		gchar* _tmp21_;
		gchar* _tmp22_;
		ValaCreationMethod* _tmp23_;
		gboolean _tmp24_;
		_tmp19_ = m;
		_tmp20_ = m;
		_tmp21_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp20_);
		_tmp22_ = _tmp21_;
		vala_ccode_method_module_create_aux_constructor (self, _tmp19_, _tmp22_, FALSE);
		_g_free0 (_tmp22_);
		_tmp23_ = m;
		_tmp24_ = vala_method_is_variadic ((ValaMethod*) _tmp23_);
		if (_tmp24_) {
			ValaCreationMethod* _tmp25_;
			ValaCreationMethod* _tmp26_;
			gchar* _tmp27_;
			gchar* _tmp28_;
			_tmp25_ = m;
			_tmp26_ = m;
			_tmp27_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp26_);
			_tmp28_ = _tmp27_;
			vala_ccode_method_module_create_aux_constructor (self, _tmp25_, _tmp28_, TRUE);
			_g_free0 (_tmp28_);
		}
	}
	vala_ccode_base_module_pop_line ((ValaCCodeBaseModule*) self);
}


static void vala_ccode_method_module_create_aux_constructor (ValaCCodeMethodModule* self, ValaCreationMethod* m, const gchar* func_name, gboolean self_as_first_parameter) {
	ValaCCodeFunction* vfunc = NULL;
	const gchar* _tmp0_;
	ValaCCodeFunction* _tmp1_;
	ValaCreationMethod* _tmp2_;
	gboolean _tmp3_;
	ValaHashMap* cparam_map = NULL;
	GHashFunc _tmp19_;
	GEqualFunc _tmp20_;
	GEqualFunc _tmp21_;
	ValaHashMap* _tmp22_;
	ValaHashMap* carg_map = NULL;
	GHashFunc _tmp23_;
	GEqualFunc _tmp24_;
	GEqualFunc _tmp25_;
	ValaHashMap* _tmp26_;
	ValaCCodeFunction* _tmp27_;
	gchar* _tmp28_ = NULL;
	ValaCreationMethod* _tmp29_;
	gboolean _tmp30_;
	gchar* constructor = NULL;
	gchar* _tmp35_;
	ValaCCodeFunctionCall* vcall = NULL;
	const gchar* _tmp36_;
	ValaCCodeIdentifier* _tmp37_;
	ValaCCodeIdentifier* _tmp38_;
	ValaCCodeFunctionCall* _tmp39_;
	ValaCCodeFunctionCall* _tmp40_;
	gboolean _tmp41_;
	ValaCreationMethod* _tmp58_;
	ValaCCodeFile* _tmp59_;
	ValaHashMap* _tmp60_;
	ValaCCodeFunction* _tmp61_;
	ValaHashMap* _tmp62_;
	ValaCCodeFunctionCall* _tmp63_;
	ValaCreationMethod* _tmp64_;
	gboolean _tmp65_;
	ValaCCodeFunction* _tmp104_;
	ValaCCodeFunction* _tmp105_;
	ValaCCodeFunctionCall* _tmp106_;
	ValaCCodeFile* _tmp107_;
	ValaCCodeFunction* _tmp108_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (m != NULL);
	g_return_if_fail (func_name != NULL);
	_tmp0_ = func_name;
	_tmp1_ = vala_ccode_function_new (_tmp0_, "void");
	vfunc = _tmp1_;
	_tmp2_ = m;
	_tmp3_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp2_);
	if (_tmp3_) {
		ValaCCodeFunction* _tmp4_;
		ValaCCodeFunction* _tmp5_;
		ValaCCodeModifiers _tmp6_;
		ValaCCodeModifiers _tmp7_;
		_tmp4_ = vfunc;
		_tmp5_ = vfunc;
		_tmp6_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp5_);
		_tmp7_ = _tmp6_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp5_, _tmp7_ | VALA_CCODE_MODIFIERS_STATIC);
	} else {
		gboolean _tmp8_ = FALSE;
		ValaCodeContext* _tmp9_;
		ValaCodeContext* _tmp10_;
		gboolean _tmp11_;
		gboolean _tmp12_;
		_tmp9_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp10_ = _tmp9_;
		_tmp11_ = vala_code_context_get_hide_internal (_tmp10_);
		_tmp12_ = _tmp11_;
		if (_tmp12_) {
			ValaCreationMethod* _tmp13_;
			gboolean _tmp14_;
			_tmp13_ = m;
			_tmp14_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp13_);
			_tmp8_ = _tmp14_;
		} else {
			_tmp8_ = FALSE;
		}
		if (_tmp8_) {
			ValaCCodeFunction* _tmp15_;
			ValaCCodeFunction* _tmp16_;
			ValaCCodeModifiers _tmp17_;
			ValaCCodeModifiers _tmp18_;
			_tmp15_ = vfunc;
			_tmp16_ = vfunc;
			_tmp17_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp16_);
			_tmp18_ = _tmp17_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp16_, _tmp18_ | VALA_CCODE_MODIFIERS_INTERNAL);
		}
	}
	_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_ = vfunc;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp27_);
	_tmp29_ = m;
	_tmp30_ = vala_method_is_variadic ((ValaMethod*) _tmp29_);
	if (_tmp30_) {
		ValaCreationMethod* _tmp31_;
		gchar* _tmp32_;
		_tmp31_ = m;
		_tmp32_ = vala_ccode_base_module_get_ccode_constructv_name (_tmp31_);
		_g_free0 (_tmp28_);
		_tmp28_ = _tmp32_;
	} else {
		ValaCreationMethod* _tmp33_;
		gchar* _tmp34_;
		_tmp33_ = m;
		_tmp34_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp33_);
		_g_free0 (_tmp28_);
		_tmp28_ = _tmp34_;
	}
	_tmp35_ = g_strdup (_tmp28_);
	constructor = _tmp35_;
	_tmp36_ = constructor;
	_tmp37_ = vala_ccode_identifier_new (_tmp36_);
	_tmp38_ = _tmp37_;
	_tmp39_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp38_);
	_tmp40_ = _tmp39_;
	_vala_ccode_node_unref0 (_tmp38_);
	vcall = _tmp40_;
	_tmp41_ = self_as_first_parameter;
	if (_tmp41_) {
		ValaHashMap* _tmp42_;
		ValaCreationMethod* _tmp43_;
		gdouble _tmp44_;
		gint _tmp45_;
		ValaCCodeParameter* _tmp46_;
		ValaCCodeParameter* _tmp47_;
		ValaCCodeFunctionCall* _tmp48_;
		ValaCCodeExpression* _tmp49_;
		ValaCCodeExpression* _tmp50_;
		_tmp42_ = cparam_map;
		_tmp43_ = m;
		_tmp44_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp43_);
		_tmp45_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp44_, FALSE);
		_tmp46_ = vala_ccode_parameter_new ("object_type", "GType");
		_tmp47_ = _tmp46_;
		vala_map_set ((ValaMap*) _tmp42_, (gpointer) ((gintptr) _tmp45_), _tmp47_);
		_vala_ccode_node_unref0 (_tmp47_);
		_tmp48_ = vcall;
		_tmp49_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "object_type");
		_tmp50_ = _tmp49_;
		vala_ccode_function_call_add_argument (_tmp48_, _tmp50_);
		_vala_ccode_node_unref0 (_tmp50_);
	} else {
		ValaCCodeFunctionCall* _tmp51_;
		ValaClass* _tmp52_;
		ValaClass* _tmp53_;
		gchar* _tmp54_;
		gchar* _tmp55_;
		ValaCCodeIdentifier* _tmp56_;
		ValaCCodeIdentifier* _tmp57_;
		_tmp51_ = vcall;
		_tmp52_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp53_ = _tmp52_;
		_tmp54_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp53_);
		_tmp55_ = _tmp54_;
		_tmp56_ = vala_ccode_identifier_new (_tmp55_);
		_tmp57_ = _tmp56_;
		vala_ccode_function_call_add_argument (_tmp51_, (ValaCCodeExpression*) _tmp57_);
		_vala_ccode_node_unref0 (_tmp57_);
		_g_free0 (_tmp55_);
	}
	_tmp58_ = m;
	_tmp59_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp60_ = cparam_map;
	_tmp61_ = vfunc;
	_tmp62_ = carg_map;
	_tmp63_ = vcall;
	vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, (ValaMethod*) _tmp58_, _tmp59_, (ValaMap*) _tmp60_, _tmp61_, NULL, (ValaMap*) _tmp62_, _tmp63_, 3);
	_tmp64_ = m;
	_tmp65_ = vala_method_is_variadic ((ValaMethod*) _tmp64_);
	if (_tmp65_) {
		gint last_pos = 0;
		gint second_last_pos = 0;
		ValaCCodeFunctionCall* va_start = NULL;
		ValaCCodeIdentifier* _tmp82_;
		ValaCCodeIdentifier* _tmp83_;
		ValaCCodeFunctionCall* _tmp84_;
		ValaCCodeFunctionCall* _tmp85_;
		ValaCCodeFunctionCall* _tmp86_;
		ValaCCodeIdentifier* _tmp87_;
		ValaCCodeIdentifier* _tmp88_;
		ValaCCodeFunctionCall* _tmp89_;
		ValaHashMap* _tmp90_;
		gint _tmp91_;
		gpointer _tmp92_;
		ValaCCodeExpression* _tmp93_;
		ValaCCodeFunction* _tmp94_;
		ValaCCodeFunction* _tmp95_;
		ValaCCodeVariableDeclarator* _tmp96_;
		ValaCCodeVariableDeclarator* _tmp97_;
		ValaCCodeFunction* _tmp98_;
		ValaCCodeFunction* _tmp99_;
		ValaCCodeFunctionCall* _tmp100_;
		ValaCCodeFunctionCall* _tmp101_;
		ValaCCodeIdentifier* _tmp102_;
		ValaCCodeIdentifier* _tmp103_;
		last_pos = -1;
		second_last_pos = -1;
		{
			ValaIterator* _pos_it = NULL;
			ValaHashMap* _tmp66_;
			ValaSet* _tmp67_;
			ValaSet* _tmp68_;
			ValaIterator* _tmp69_;
			ValaIterator* _tmp70_;
			_tmp66_ = cparam_map;
			_tmp67_ = vala_map_get_keys ((ValaMap*) _tmp66_);
			_tmp68_ = _tmp67_;
			_tmp69_ = vala_iterable_iterator ((ValaIterable*) _tmp68_);
			_tmp70_ = _tmp69_;
			_vala_iterable_unref0 (_tmp68_);
			_pos_it = _tmp70_;
			while (TRUE) {
				ValaIterator* _tmp71_;
				gboolean _tmp72_;
				gint pos = 0;
				ValaIterator* _tmp73_;
				gpointer _tmp74_;
				gint _tmp75_;
				gint _tmp76_;
				_tmp71_ = _pos_it;
				_tmp72_ = vala_iterator_next (_tmp71_);
				if (!_tmp72_) {
					break;
				}
				_tmp73_ = _pos_it;
				_tmp74_ = vala_iterator_get (_tmp73_);
				pos = (gint) ((gintptr) _tmp74_);
				_tmp75_ = pos;
				_tmp76_ = last_pos;
				if (_tmp75_ > _tmp76_) {
					gint _tmp77_;
					gint _tmp78_;
					_tmp77_ = last_pos;
					second_last_pos = _tmp77_;
					_tmp78_ = pos;
					last_pos = _tmp78_;
				} else {
					gint _tmp79_;
					gint _tmp80_;
					_tmp79_ = pos;
					_tmp80_ = second_last_pos;
					if (_tmp79_ > _tmp80_) {
						gint _tmp81_;
						_tmp81_ = pos;
						second_last_pos = _tmp81_;
					}
				}
			}
			_vala_iterator_unref0 (_pos_it);
		}
		_tmp82_ = vala_ccode_identifier_new ("va_start");
		_tmp83_ = _tmp82_;
		_tmp84_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp83_);
		_tmp85_ = _tmp84_;
		_vala_ccode_node_unref0 (_tmp83_);
		va_start = _tmp85_;
		_tmp86_ = va_start;
		_tmp87_ = vala_ccode_identifier_new ("_vala_va_list_obj");
		_tmp88_ = _tmp87_;
		vala_ccode_function_call_add_argument (_tmp86_, (ValaCCodeExpression*) _tmp88_);
		_vala_ccode_node_unref0 (_tmp88_);
		_tmp89_ = va_start;
		_tmp90_ = carg_map;
		_tmp91_ = second_last_pos;
		_tmp92_ = vala_map_get ((ValaMap*) _tmp90_, (gpointer) ((gintptr) _tmp91_));
		_tmp93_ = (ValaCCodeExpression*) _tmp92_;
		vala_ccode_function_call_add_argument (_tmp89_, _tmp93_);
		_vala_ccode_node_unref0 (_tmp93_);
		_tmp94_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp95_ = _tmp94_;
		_tmp96_ = vala_ccode_variable_declarator_new ("_vala_va_list_obj", NULL, NULL);
		_tmp97_ = _tmp96_;
		vala_ccode_function_add_declaration (_tmp95_, "va_list", (ValaCCodeDeclarator*) _tmp97_, 0);
		_vala_ccode_node_unref0 (_tmp97_);
		_tmp98_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp99_ = _tmp98_;
		_tmp100_ = va_start;
		vala_ccode_function_add_expression (_tmp99_, (ValaCCodeExpression*) _tmp100_);
		_tmp101_ = vcall;
		_tmp102_ = vala_ccode_identifier_new ("_vala_va_list_obj");
		_tmp103_ = _tmp102_;
		vala_ccode_function_call_add_argument (_tmp101_, (ValaCCodeExpression*) _tmp103_);
		_vala_ccode_node_unref0 (_tmp103_);
		_vala_ccode_node_unref0 (va_start);
	}
	_tmp104_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp105_ = _tmp104_;
	_tmp106_ = vcall;
	vala_ccode_function_add_return (_tmp105_, (ValaCCodeExpression*) _tmp106_);
	vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
	_tmp107_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp108_ = vfunc;
	vala_ccode_file_add_function (_tmp107_, _tmp108_);
	_vala_ccode_node_unref0 (vcall);
	_g_free0 (constructor);
	_g_free0 (_tmp28_);
	_vala_map_unref0 (carg_map);
	_vala_map_unref0 (cparam_map);
	_vala_ccode_node_unref0 (vfunc);
}


ValaCCodeMethodModule* vala_ccode_method_module_construct (GType object_type) {
	ValaCCodeMethodModule* self = NULL;
	self = (ValaCCodeMethodModule*) vala_ccode_struct_module_construct (object_type);
	return self;
}


static void vala_ccode_method_module_class_init (ValaCCodeMethodModuleClass * klass) {
	vala_ccode_method_module_parent_class = g_type_class_peek_parent (klass);
	((ValaCodeVisitorClass *) klass)->finalize = vala_ccode_method_module_finalize;
	g_type_class_add_private (klass, sizeof (ValaCCodeMethodModulePrivate));
	((ValaCCodeBaseModuleClass *) klass)->method_has_wrapper = (gboolean (*) (ValaCCodeBaseModule *, ValaMethod*)) vala_ccode_method_module_real_method_has_wrapper;
	((ValaCCodeMethodModuleClass *) klass)->generate_method_result_declaration = (void (*) (ValaCCodeMethodModule *, ValaMethod*, ValaCCodeFile*, ValaCCodeFunction*, ValaMap*, ValaMap*)) vala_ccode_method_module_real_generate_method_result_declaration;
	((ValaCCodeBaseModuleClass *) klass)->generate_method_declaration = (void (*) (ValaCCodeBaseModule *, ValaMethod*, ValaCCodeFile*)) vala_ccode_method_module_real_generate_method_declaration;
	((ValaCodeVisitorClass *) klass)->visit_method = (void (*) (ValaCodeVisitor *, ValaMethod*)) vala_ccode_method_module_real_visit_method;
	((ValaCCodeMethodModuleClass *) klass)->generate_parameter = (ValaCCodeParameter* (*) (ValaCCodeMethodModule *, ValaParameter*, ValaCCodeFile*, ValaMap*, ValaMap*)) vala_ccode_method_module_real_generate_parameter;
	((ValaCCodeBaseModuleClass *) klass)->generate_cparameters = (void (*) (ValaCCodeBaseModule *, ValaMethod*, ValaCCodeFile*, ValaMap*, ValaCCodeFunction*, ValaCCodeFunctionDeclarator*, ValaMap*, ValaCCodeFunctionCall*, gint)) vala_ccode_method_module_real_generate_cparameters;
	((ValaCodeVisitorClass *) klass)->visit_creation_method = (void (*) (ValaCodeVisitor *, ValaCreationMethod*)) vala_ccode_method_module_real_visit_creation_method;
}


static void vala_ccode_method_module_instance_init (ValaCCodeMethodModule * self) {
	self->priv = VALA_CCODE_METHOD_MODULE_GET_PRIVATE (self);
	self->priv->ellipses_to_valist = FALSE;
}


static void vala_ccode_method_module_finalize (ValaCodeVisitor * obj) {
	ValaCCodeMethodModule * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModule);
	VALA_CODE_VISITOR_CLASS (vala_ccode_method_module_parent_class)->finalize (obj);
}


/**
 * The link between a method and generated code.
 */
GType vala_ccode_method_module_get_type (void) {
	static volatile gsize vala_ccode_method_module_type_id__volatile = 0;
	if (g_once_init_enter (&vala_ccode_method_module_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeMethodModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_method_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeMethodModule), 0, (GInstanceInitFunc) vala_ccode_method_module_instance_init, NULL };
		GType vala_ccode_method_module_type_id;
		vala_ccode_method_module_type_id = g_type_register_static (VALA_TYPE_CCODE_STRUCT_MODULE, "ValaCCodeMethodModule", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
		g_once_init_leave (&vala_ccode_method_module_type_id__volatile, vala_ccode_method_module_type_id);
	}
	return vala_ccode_method_module_type_id__volatile;
}



