/* 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 "valacodegen.h"
#include <glib.h>
#include <vala.h>
#include <valaccode.h>
#include <valagee.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <math.h>

#define _g_free0(var) (var = (g_free (var), NULL))
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _vala_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_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL)))
#define _vala_ccode_declarator_suffix_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_declarator_suffix_unref (var), NULL)))
#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)))

struct _ValaCCodeMethodModulePrivate {
	gboolean ellipses_to_valist;
};

static gint ValaCCodeMethodModule_private_offset;
static gpointer vala_ccode_method_module_parent_class = NULL;

static gchar* vala_ccode_method_module_get_creturn_type (ValaCCodeMethodModule* self,
                                                  ValaMethod* m,
                                                  const gchar* default_value);
static gboolean vala_ccode_method_module_is_gtypeinstance_creation_method (ValaCCodeMethodModule* self,
                                                                    ValaMethod* m);
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);
static gboolean vala_ccode_method_module_real_generate_method_declaration (ValaCCodeBaseModule* base,
                                                                    ValaMethod* m,
                                                                    ValaCCodeFile* decl_space);
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);
static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base,
                                                 ValaMethod* m);
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);
static void vala_ccode_method_module_create_precondition_statement (ValaCCodeMethodModule* self,
                                                             ValaMethod* m,
                                                             ValaDataType* ret_type,
                                                             ValaExpression* precondition);
static ValaCCodeParameter* vala_ccode_method_module_real_generate_parameter (ValaCCodeMethodModule* self,
                                                                      ValaParameter* param,
                                                                      ValaCCodeFile* decl_space,
                                                                      ValaMap* cparam_map,
                                                                      ValaMap* 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);
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);
static void vala_ccode_method_module_finalize (ValaCodeVisitor * obj);
static GType vala_ccode_method_module_get_type_once (void);

static inline gpointer
vala_ccode_method_module_get_instance_private (ValaCCodeMethodModule* self)
{
	return G_STRUCT_MEMBER_P (self, ValaCCodeMethodModule_private_offset);
}

static gchar*
vala_ccode_method_module_get_creturn_type (ValaCCodeMethodModule* self,
                                           ValaMethod* m,
                                           const gchar* default_value)
{
	gchar* type = NULL;
	gchar* _tmp0_;
	const gchar* _tmp1_;
	gchar* result;
	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_ = vala_get_ccode_type ((ValaCodeNode*) m);
	type = _tmp0_;
	_tmp1_ = type;
	if (_tmp1_ == NULL) {
		gchar* _tmp2_;
		_tmp2_ = g_strdup (default_value);
		result = _tmp2_;
		_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;
	ValaClass* cl = NULL;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaClass* _tmp2_;
	gboolean _tmp3_ = FALSE;
	gboolean _tmp4_ = FALSE;
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (m != NULL, FALSE);
	_result_ = FALSE;
	_tmp0_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp1_) : NULL);
	cl = _tmp2_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (m, VALA_TYPE_CREATION_METHOD)) {
		ValaClass* _tmp5_;
		_tmp5_ = cl;
		_tmp4_ = _tmp5_ != NULL;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		ValaClass* _tmp6_;
		gboolean _tmp7_;
		gboolean _tmp8_;
		_tmp6_ = cl;
		_tmp7_ = vala_class_get_is_compact (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp3_ = !_tmp8_;
	} else {
		_tmp3_ = FALSE;
	}
	if (_tmp3_) {
		_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;
	ValaDataType* _tmp0_;
	ValaDataType* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	ValaDataType* _tmp6_;
	ValaDataType* _tmp7_;
	ValaDataType* _tmp8_;
	ValaDataType* _tmp9_;
	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_ = vala_ccode_base_module_get_callable_creturn_type ((ValaCallable*) m);
	creturn_type = _tmp0_;
	_tmp1_ = creturn_type;
	_tmp2_ = vala_get_ccode_name ((ValaCodeNode*) _tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_method_module_get_creturn_type (self, m, _tmp3_);
	_tmp5_ = _tmp4_;
	vala_ccode_function_set_return_type (cfunc, _tmp5_);
	_g_free0 (_tmp5_);
	_g_free0 (_tmp3_);
	_tmp6_ = vala_callable_get_return_type ((ValaCallable*) m);
	_tmp7_ = _tmp6_;
	vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp7_, decl_space);
	_tmp8_ = vala_callable_get_return_type ((ValaCallable*) m);
	_tmp9_ = _tmp8_;
	if (vala_data_type_is_real_non_null_struct_type (_tmp9_)) {
		ValaCCodeParameter* cparam = NULL;
		ValaDataType* _tmp10_;
		ValaDataType* _tmp11_;
		gchar* _tmp12_;
		gchar* _tmp13_;
		gchar* _tmp14_;
		gchar* _tmp15_;
		ValaCCodeParameter* _tmp16_;
		ValaCCodeParameter* _tmp17_;
		ValaCCodeParameter* _tmp18_;
		_tmp10_ = vala_callable_get_return_type ((ValaCallable*) m);
		_tmp11_ = _tmp10_;
		_tmp12_ = vala_get_ccode_name ((ValaCodeNode*) _tmp11_);
		_tmp13_ = _tmp12_;
		_tmp14_ = g_strconcat (_tmp13_, "*", NULL);
		_tmp15_ = _tmp14_;
		_tmp16_ = vala_ccode_parameter_new ("result", _tmp15_);
		_tmp17_ = _tmp16_;
		_g_free0 (_tmp15_);
		_g_free0 (_tmp13_);
		cparam = _tmp17_;
		_tmp18_ = cparam;
		vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE)), _tmp18_);
		if (carg_map != NULL) {
			ValaCCodeExpression* _tmp19_;
			ValaCCodeExpression* _tmp20_;
			_tmp19_ = vala_ccode_base_module_get_cexpression ((ValaCCodeBaseModule*) self, "result");
			_tmp20_ = _tmp19_;
			vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE)), _tmp20_);
			_vala_ccode_node_unref0 (_tmp20_);
		}
		_vala_ccode_node_unref0 (cparam);
	} else {
		gboolean _tmp21_ = FALSE;
		if (vala_get_ccode_array_length ((ValaCodeNode*) m)) {
			ValaDataType* _tmp22_;
			ValaDataType* _tmp23_;
			_tmp22_ = vala_callable_get_return_type ((ValaCallable*) m);
			_tmp23_ = _tmp22_;
			_tmp21_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_ARRAY_TYPE);
		} else {
			_tmp21_ = FALSE;
		}
		if (_tmp21_) {
			ValaArrayType* array_type = NULL;
			ValaDataType* _tmp24_;
			ValaDataType* _tmp25_;
			ValaArrayType* _tmp26_;
			gchar* length_ctype = NULL;
			gchar* _tmp27_;
			gchar* _tmp28_;
			gchar* _tmp29_;
			gchar* _tmp30_;
			_tmp24_ = vala_callable_get_return_type ((ValaCallable*) m);
			_tmp25_ = _tmp24_;
			_tmp26_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			array_type = _tmp26_;
			_tmp27_ = vala_get_ccode_array_length_type ((ValaCodeNode*) m);
			_tmp28_ = _tmp27_;
			_tmp29_ = g_strconcat (_tmp28_, "*", NULL);
			_tmp30_ = _tmp29_;
			_g_free0 (_tmp28_);
			length_ctype = _tmp30_;
			{
				gint dim = 0;
				dim = 1;
				{
					gboolean _tmp31_ = FALSE;
					_tmp31_ = TRUE;
					while (TRUE) {
						ValaArrayType* _tmp33_;
						gint _tmp34_;
						gint _tmp35_;
						ValaCCodeParameter* cparam = NULL;
						gchar* _tmp36_;
						gchar* _tmp37_;
						const gchar* _tmp38_;
						ValaCCodeParameter* _tmp39_;
						ValaCCodeParameter* _tmp40_;
						ValaCCodeParameter* _tmp41_;
						if (!_tmp31_) {
							gint _tmp32_;
							_tmp32_ = dim;
							dim = _tmp32_ + 1;
						}
						_tmp31_ = FALSE;
						_tmp33_ = array_type;
						_tmp34_ = vala_array_type_get_rank (_tmp33_);
						_tmp35_ = _tmp34_;
						if (!(dim <= _tmp35_)) {
							break;
						}
						_tmp36_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", dim);
						_tmp37_ = _tmp36_;
						_tmp38_ = length_ctype;
						_tmp39_ = vala_ccode_parameter_new (_tmp37_, _tmp38_);
						_tmp40_ = _tmp39_;
						_g_free0 (_tmp37_);
						cparam = _tmp40_;
						_tmp41_ = cparam;
						vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) m) + (0.01 * dim), FALSE)), _tmp41_);
						if (carg_map != NULL) {
							ValaCCodeParameter* _tmp42_;
							const gchar* _tmp43_;
							const gchar* _tmp44_;
							ValaCCodeExpression* _tmp45_;
							ValaCCodeExpression* _tmp46_;
							_tmp42_ = cparam;
							_tmp43_ = vala_ccode_parameter_get_name (_tmp42_);
							_tmp44_ = _tmp43_;
							_tmp45_ = vala_ccode_base_module_get_cexpression ((ValaCCodeBaseModule*) self, _tmp44_);
							_tmp46_ = _tmp45_;
							vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) m) + (0.01 * dim), FALSE)), _tmp46_);
							_vala_ccode_node_unref0 (_tmp46_);
						}
						_vala_ccode_node_unref0 (cparam);
					}
				}
			}
			_g_free0 (length_ctype);
			_vala_code_node_unref0 (array_type);
		} else {
			gboolean _tmp47_ = FALSE;
			if (vala_get_ccode_delegate_target ((ValaCodeNode*) m)) {
				ValaDataType* _tmp48_;
				ValaDataType* _tmp49_;
				_tmp48_ = vala_callable_get_return_type ((ValaCallable*) m);
				_tmp49_ = _tmp48_;
				_tmp47_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp49_, VALA_TYPE_DELEGATE_TYPE);
			} else {
				_tmp47_ = FALSE;
			}
			if (_tmp47_) {
				ValaDelegateType* deleg_type = NULL;
				ValaDataType* _tmp50_;
				ValaDataType* _tmp51_;
				ValaDelegateType* _tmp52_;
				ValaDelegateType* _tmp53_;
				ValaDelegate* _tmp54_;
				ValaDelegate* _tmp55_;
				gboolean _tmp56_;
				gboolean _tmp57_;
				_tmp50_ = vala_callable_get_return_type ((ValaCallable*) m);
				_tmp51_ = _tmp50_;
				_tmp52_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp51_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
				deleg_type = _tmp52_;
				_tmp53_ = deleg_type;
				_tmp54_ = vala_delegate_type_get_delegate_symbol (_tmp53_);
				_tmp55_ = _tmp54_;
				_tmp56_ = vala_delegate_get_has_target (_tmp55_);
				_tmp57_ = _tmp56_;
				if (_tmp57_) {
					ValaCCodeParameter* cparam = NULL;
					gchar* _tmp58_;
					gchar* _tmp59_;
					ValaDataType* _tmp60_;
					gchar* _tmp61_;
					gchar* _tmp62_;
					gchar* _tmp63_;
					gchar* _tmp64_;
					ValaCCodeParameter* _tmp65_;
					ValaCCodeParameter* _tmp66_;
					ValaCCodeParameter* _tmp67_;
					ValaDelegateType* _tmp73_;
					_tmp58_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, "result");
					_tmp59_ = _tmp58_;
					_tmp60_ = ((ValaCCodeBaseModule*) self)->delegate_target_type;
					_tmp61_ = vala_get_ccode_name ((ValaCodeNode*) _tmp60_);
					_tmp62_ = _tmp61_;
					_tmp63_ = g_strconcat (_tmp62_, "*", NULL);
					_tmp64_ = _tmp63_;
					_tmp65_ = vala_ccode_parameter_new (_tmp59_, _tmp64_);
					_tmp66_ = _tmp65_;
					_g_free0 (_tmp64_);
					_g_free0 (_tmp62_);
					_g_free0 (_tmp59_);
					cparam = _tmp66_;
					_tmp67_ = cparam;
					vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) m), FALSE)), _tmp67_);
					if (carg_map != NULL) {
						ValaCCodeParameter* _tmp68_;
						const gchar* _tmp69_;
						const gchar* _tmp70_;
						ValaCCodeExpression* _tmp71_;
						ValaCCodeExpression* _tmp72_;
						_tmp68_ = cparam;
						_tmp69_ = vala_ccode_parameter_get_name (_tmp68_);
						_tmp70_ = _tmp69_;
						_tmp71_ = vala_ccode_base_module_get_cexpression ((ValaCCodeBaseModule*) self, _tmp70_);
						_tmp72_ = _tmp71_;
						vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) m), FALSE)), _tmp72_);
						_vala_ccode_node_unref0 (_tmp72_);
					}
					_tmp73_ = deleg_type;
					if (vala_data_type_is_disposable ((ValaDataType*) _tmp73_)) {
						gchar* _tmp74_;
						gchar* _tmp75_;
						ValaDelegateType* _tmp76_;
						gchar* _tmp77_;
						gchar* _tmp78_;
						gchar* _tmp79_;
						gchar* _tmp80_;
						ValaCCodeParameter* _tmp81_;
						ValaCCodeParameter* _tmp82_;
						_tmp74_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, "result");
						_tmp75_ = _tmp74_;
						_tmp76_ = ((ValaCCodeBaseModule*) self)->delegate_target_destroy_type;
						_tmp77_ = vala_get_ccode_name ((ValaCodeNode*) _tmp76_);
						_tmp78_ = _tmp77_;
						_tmp79_ = g_strconcat (_tmp78_, "*", NULL);
						_tmp80_ = _tmp79_;
						_tmp81_ = vala_ccode_parameter_new (_tmp75_, _tmp80_);
						_vala_ccode_node_unref0 (cparam);
						cparam = _tmp81_;
						_g_free0 (_tmp80_);
						_g_free0 (_tmp78_);
						_g_free0 (_tmp75_);
						_tmp82_ = cparam;
						vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) m), FALSE)), _tmp82_);
						if (carg_map != NULL) {
							ValaCCodeParameter* _tmp83_;
							const gchar* _tmp84_;
							const gchar* _tmp85_;
							ValaCCodeExpression* _tmp86_;
							ValaCCodeExpression* _tmp87_;
							_tmp83_ = cparam;
							_tmp84_ = vala_ccode_parameter_get_name (_tmp83_);
							_tmp85_ = _tmp84_;
							_tmp86_ = vala_ccode_base_module_get_cexpression ((ValaCCodeBaseModule*) self, _tmp85_);
							_tmp87_ = _tmp86_;
							vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) m), FALSE)), _tmp87_);
							_vala_ccode_node_unref0 (_tmp87_);
						}
					}
					_vala_ccode_node_unref0 (cparam);
				}
				_vala_code_node_unref0 (deleg_type);
			}
		}
	}
	if (vala_method_has_error_type_parameter (m)) {
		ValaArrayList* error_types = NULL;
		GEqualFunc _tmp88_;
		ValaArrayList* _tmp89_;
		ValaArrayList* _tmp90_;
		ValaCCodeParameter* cparam = NULL;
		ValaCCodeParameter* _tmp100_;
		ValaCCodeParameter* _tmp101_;
		_tmp88_ = g_direct_equal;
		_tmp89_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp88_);
		error_types = _tmp89_;
		_tmp90_ = error_types;
		vala_code_node_get_error_types ((ValaCodeNode*) m, (ValaCollection*) _tmp90_, NULL);
		{
			ValaArrayList* _error_type_list = NULL;
			ValaArrayList* _tmp91_;
			gint _error_type_size = 0;
			ValaArrayList* _tmp92_;
			gint _tmp93_;
			gint _tmp94_;
			gint _error_type_index = 0;
			_tmp91_ = error_types;
			_error_type_list = _tmp91_;
			_tmp92_ = _error_type_list;
			_tmp93_ = vala_collection_get_size ((ValaCollection*) _tmp92_);
			_tmp94_ = _tmp93_;
			_error_type_size = _tmp94_;
			_error_type_index = -1;
			while (TRUE) {
				gint _tmp95_;
				gint _tmp96_;
				ValaDataType* error_type = NULL;
				ValaArrayList* _tmp97_;
				gpointer _tmp98_;
				ValaDataType* _tmp99_;
				_error_type_index = _error_type_index + 1;
				_tmp95_ = _error_type_index;
				_tmp96_ = _error_type_size;
				if (!(_tmp95_ < _tmp96_)) {
					break;
				}
				_tmp97_ = _error_type_list;
				_tmp98_ = vala_list_get ((ValaList*) _tmp97_, _error_type_index);
				error_type = (ValaDataType*) _tmp98_;
				_tmp99_ = error_type;
				vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp99_, decl_space);
				_vala_code_node_unref0 (error_type);
			}
		}
		_tmp100_ = vala_ccode_parameter_new ("error", "GError**");
		cparam = _tmp100_;
		_tmp101_ = cparam;
		vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_error_pos ((ValaCallable*) m), FALSE)), _tmp101_);
		if (carg_map != NULL) {
			ValaCCodeParameter* _tmp102_;
			const gchar* _tmp103_;
			const gchar* _tmp104_;
			ValaCCodeIdentifier* _tmp105_;
			ValaCCodeIdentifier* _tmp106_;
			_tmp102_ = cparam;
			_tmp103_ = vala_ccode_parameter_get_name (_tmp102_);
			_tmp104_ = _tmp103_;
			_tmp105_ = vala_ccode_identifier_new (_tmp104_);
			_tmp106_ = _tmp105_;
			vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_error_pos ((ValaCallable*) m), FALSE)), (ValaCCodeExpression*) _tmp106_);
			_vala_ccode_node_unref0 (_tmp106_);
		}
		_vala_ccode_node_unref0 (cparam);
		_vala_iterable_unref0 (error_types);
	}
	_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)
{
	ValaCCodeMethodModuleClass* _klass_;
	g_return_if_fail (self != NULL);
	_klass_ = VALA_CCODE_METHOD_MODULE_GET_CLASS (self);
	if (_klass_->generate_method_result_declaration) {
		_klass_->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;
	ValaCCodeMemberAccess* _tmp1_;
	ValaCCodeFunctionCall* finish_call = NULL;
	ValaCCodeIdentifier* _tmp2_;
	ValaCCodeIdentifier* _tmp3_;
	ValaCCodeFunctionCall* _tmp4_;
	ValaCCodeFunctionCall* _tmp5_;
	ValaCCodeConstant* _tmp6_;
	ValaCCodeConstant* _tmp7_;
	ValaCCodeFunction* _tmp8_;
	ValaCCodeFunction* _tmp9_;
	ValaCCodeMemberAccess* state = NULL;
	ValaCCodeMemberAccess* _tmp10_;
	ValaCCodeConstant* zero = NULL;
	ValaCCodeConstant* _tmp11_;
	ValaCCodeBinaryExpression* state_is_not_zero = NULL;
	ValaCCodeBinaryExpression* _tmp12_;
	ValaCCodeFunction* _tmp13_;
	ValaCCodeFunction* _tmp14_;
	ValaCCodeExpression* task_is_complete = NULL;
	ValaCCodeFunctionCall* task_complete = NULL;
	ValaCCodeIdentifier* _tmp15_;
	ValaCCodeIdentifier* _tmp16_;
	ValaCCodeFunctionCall* _tmp17_;
	ValaCCodeFunctionCall* _tmp18_;
	ValaCCodeUnaryExpression* _tmp19_;
	ValaCCodeFunction* _tmp20_;
	ValaCCodeFunction* _tmp21_;
	ValaCCodeFunctionCall* task_context = NULL;
	ValaCCodeIdentifier* _tmp22_;
	ValaCCodeIdentifier* _tmp23_;
	ValaCCodeFunctionCall* _tmp24_;
	ValaCCodeFunctionCall* _tmp25_;
	ValaCCodeFunctionCall* iterate_context = NULL;
	ValaCCodeIdentifier* _tmp26_;
	ValaCCodeIdentifier* _tmp27_;
	ValaCCodeFunctionCall* _tmp28_;
	ValaCCodeFunctionCall* _tmp29_;
	ValaCCodeConstant* _tmp30_;
	ValaCCodeConstant* _tmp31_;
	ValaCCodeFunction* _tmp32_;
	ValaCCodeFunction* _tmp33_;
	ValaCCodeFunction* _tmp34_;
	ValaCCodeFunction* _tmp35_;
	ValaCCodeFunction* _tmp36_;
	ValaCCodeFunction* _tmp37_;
	ValaCCodeFunctionCall* unref = NULL;
	ValaCCodeIdentifier* _tmp38_;
	ValaCCodeIdentifier* _tmp39_;
	ValaCCodeFunctionCall* _tmp40_;
	ValaCCodeFunctionCall* _tmp41_;
	ValaCCodeFunction* _tmp42_;
	ValaCCodeFunction* _tmp43_;
	ValaCCodeFunction* _tmp44_;
	ValaCCodeFunction* _tmp45_;
	ValaCCodeConstant* _tmp46_;
	ValaCCodeConstant* _tmp47_;
	g_return_if_fail (self != NULL);
	_tmp0_ = vala_ccode_identifier_new ("_data_");
	data_var = _tmp0_;
	_tmp1_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) data_var, "_async_result");
	async_result_expr = _tmp1_;
	_tmp2_ = vala_ccode_identifier_new ("g_task_return_pointer");
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp3_);
	_tmp5_ = _tmp4_;
	_vala_ccode_node_unref0 (_tmp3_);
	finish_call = _tmp5_;
	vala_ccode_function_call_add_argument (finish_call, (ValaCCodeExpression*) async_result_expr);
	vala_ccode_function_call_add_argument (finish_call, (ValaCCodeExpression*) data_var);
	_tmp6_ = vala_ccode_constant_new ("NULL");
	_tmp7_ = _tmp6_;
	vala_ccode_function_call_add_argument (finish_call, (ValaCCodeExpression*) _tmp7_);
	_vala_ccode_node_unref0 (_tmp7_);
	_tmp8_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp9_ = _tmp8_;
	vala_ccode_function_add_expression (_tmp9_, (ValaCCodeExpression*) finish_call);
	_tmp10_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) data_var, "_state_");
	state = _tmp10_;
	_tmp11_ = vala_ccode_constant_new ("0");
	zero = _tmp11_;
	_tmp12_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) state, (ValaCCodeExpression*) zero);
	state_is_not_zero = _tmp12_;
	_tmp13_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp14_ = _tmp13_;
	vala_ccode_function_open_if (_tmp14_, (ValaCCodeExpression*) state_is_not_zero);
	_tmp15_ = vala_ccode_identifier_new ("g_task_get_completed");
	_tmp16_ = _tmp15_;
	_tmp17_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp16_);
	_tmp18_ = _tmp17_;
	_vala_ccode_node_unref0 (_tmp16_);
	task_complete = _tmp18_;
	vala_ccode_function_call_add_argument (task_complete, (ValaCCodeExpression*) async_result_expr);
	_tmp19_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) task_complete);
	_vala_ccode_node_unref0 (task_is_complete);
	task_is_complete = (ValaCCodeExpression*) _tmp19_;
	_tmp20_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp21_ = _tmp20_;
	vala_ccode_function_open_while (_tmp21_, task_is_complete);
	_tmp22_ = vala_ccode_identifier_new ("g_task_get_context");
	_tmp23_ = _tmp22_;
	_tmp24_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp23_);
	_tmp25_ = _tmp24_;
	_vala_ccode_node_unref0 (_tmp23_);
	task_context = _tmp25_;
	vala_ccode_function_call_add_argument (task_context, (ValaCCodeExpression*) async_result_expr);
	_tmp26_ = vala_ccode_identifier_new ("g_main_context_iteration");
	_tmp27_ = _tmp26_;
	_tmp28_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp27_);
	_tmp29_ = _tmp28_;
	_vala_ccode_node_unref0 (_tmp27_);
	iterate_context = _tmp29_;
	vala_ccode_function_call_add_argument (iterate_context, (ValaCCodeExpression*) task_context);
	_tmp30_ = vala_ccode_constant_new ("TRUE");
	_tmp31_ = _tmp30_;
	vala_ccode_function_call_add_argument (iterate_context, (ValaCCodeExpression*) _tmp31_);
	_vala_ccode_node_unref0 (_tmp31_);
	_tmp32_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp33_ = _tmp32_;
	vala_ccode_function_add_expression (_tmp33_, (ValaCCodeExpression*) iterate_context);
	_tmp34_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp35_ = _tmp34_;
	vala_ccode_function_close (_tmp35_);
	_tmp36_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp37_ = _tmp36_;
	vala_ccode_function_close (_tmp37_);
	_tmp38_ = vala_ccode_identifier_new ("g_object_unref");
	_tmp39_ = _tmp38_;
	_tmp40_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp39_);
	_tmp41_ = _tmp40_;
	_vala_ccode_node_unref0 (_tmp39_);
	unref = _tmp41_;
	vala_ccode_function_call_add_argument (unref, (ValaCCodeExpression*) async_result_expr);
	_tmp42_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp43_ = _tmp42_;
	vala_ccode_function_add_expression (_tmp43_, (ValaCCodeExpression*) unref);
	_tmp44_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp45_ = _tmp44_;
	_tmp46_ = vala_ccode_constant_new ("FALSE");
	_tmp47_ = _tmp46_;
	vala_ccode_function_add_return (_tmp45_, (ValaCCodeExpression*) _tmp47_);
	_vala_ccode_node_unref0 (_tmp47_);
	_vala_ccode_node_unref0 (unref);
	_vala_ccode_node_unref0 (iterate_context);
	_vala_ccode_node_unref0 (task_context);
	_vala_ccode_node_unref0 (task_complete);
	_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);
	_vala_ccode_node_unref0 (async_result_expr);
	_vala_ccode_node_unref0 (data_var);
}

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

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

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

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

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;
	gboolean _tmp0_;
	gboolean _tmp1_;
	ValaList* type_parameters = NULL;
	gboolean _tmp88_ = FALSE;
	ValaList* _tmp98_;
	gboolean _tmp132_ = FALSE;
	gboolean needs_format_arg = FALSE;
	ValaCCodeParameter* prev_cparam = NULL;
	gint last_pos = 0;
	gint min_pos = 0;
	gboolean _tmp178_;
	gboolean _tmp179_;
	ValaVersionAttribute* _tmp186_;
	ValaVersionAttribute* _tmp187_;
	gboolean _tmp188_;
	gboolean _tmp189_;
	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_ = vala_method_get_closure (m);
	_tmp1_ = _tmp0_;
	if (_tmp1_) {
		ValaBlock* closure_block = NULL;
		ValaBlock* _tmp2_;
		ValaBlock* _tmp3_;
		ValaBlock* _tmp4_;
		gint block_id = 0;
		ValaBlock* _tmp5_;
		ValaCCodeParameter* instance_param = NULL;
		gchar* _tmp6_;
		gchar* _tmp7_;
		gchar* _tmp8_;
		gchar* _tmp9_;
		ValaCCodeParameter* _tmp10_;
		ValaCCodeParameter* _tmp11_;
		ValaCCodeParameter* _tmp12_;
		_tmp2_ = vala_ccode_base_module_get_current_closure_block ((ValaCCodeBaseModule*) self);
		_tmp3_ = _tmp2_;
		_tmp4_ = _vala_code_node_ref0 (_tmp3_);
		closure_block = _tmp4_;
		_tmp5_ = closure_block;
		block_id = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp5_);
		_tmp6_ = g_strdup_printf ("_data%d_", block_id);
		_tmp7_ = _tmp6_;
		_tmp8_ = g_strdup_printf ("Block%dData*", block_id);
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_ccode_parameter_new (_tmp7_, _tmp9_);
		_tmp11_ = _tmp10_;
		_g_free0 (_tmp9_);
		_g_free0 (_tmp7_);
		instance_param = _tmp11_;
		_tmp12_ = instance_param;
		vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) m), FALSE)), _tmp12_);
		_vala_ccode_node_unref0 (instance_param);
		_vala_code_node_unref0 (closure_block);
	} else {
		gboolean _tmp13_ = FALSE;
		ValaSymbol* _tmp14_;
		ValaSymbol* _tmp15_;
		_tmp14_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
		_tmp15_ = _tmp14_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_CLASS)) {
			_tmp13_ = G_TYPE_CHECK_INSTANCE_TYPE (m, VALA_TYPE_CREATION_METHOD);
		} else {
			_tmp13_ = FALSE;
		}
		if (_tmp13_) {
			ValaClass* cl = NULL;
			ValaSymbol* _tmp16_;
			ValaSymbol* _tmp17_;
			ValaClass* _tmp18_;
			gboolean _tmp19_ = FALSE;
			gboolean _tmp20_ = FALSE;
			ValaClass* _tmp21_;
			gboolean _tmp22_;
			gboolean _tmp23_;
			_tmp16_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
			_tmp17_ = _tmp16_;
			_tmp18_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_CLASS, ValaClass));
			cl = _tmp18_;
			_tmp21_ = cl;
			_tmp22_ = vala_class_get_is_compact (_tmp21_);
			_tmp23_ = _tmp22_;
			if (!_tmp23_) {
				_tmp20_ = vcall == NULL;
			} else {
				_tmp20_ = FALSE;
			}
			if (_tmp20_) {
				_tmp19_ = (direction & 1) == 1;
			} else {
				_tmp19_ = FALSE;
			}
			if (_tmp19_) {
				ValaCCodeParameter* _tmp24_;
				ValaCCodeParameter* _tmp25_;
				_tmp24_ = vala_ccode_parameter_new ("object_type", "GType");
				_tmp25_ = _tmp24_;
				vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) m), FALSE)), _tmp25_);
				_vala_ccode_node_unref0 (_tmp25_);
			}
			_vala_code_node_unref0 (cl);
		} else {
			gboolean _tmp26_ = FALSE;
			ValaMemberBinding _tmp27_;
			ValaMemberBinding _tmp28_;
			_tmp27_ = vala_method_get_binding (m);
			_tmp28_ = _tmp27_;
			if (_tmp28_ == VALA_MEMBER_BINDING_INSTANCE) {
				gboolean _tmp29_ = FALSE;
				if (direction != 2) {
					_tmp29_ = TRUE;
				} else {
					_tmp29_ = vala_get_ccode_finish_instance (m);
				}
				_tmp26_ = _tmp29_;
			} else {
				_tmp26_ = FALSE;
			}
			if (_tmp26_) {
				ValaDataType* this_type = NULL;
				ValaDataType* _tmp30_;
				ValaDataType* _tmp31_;
				ValaCCodeParameter* instance_param = NULL;
				gboolean _tmp32_ = FALSE;
				gboolean _tmp33_ = FALSE;
				ValaMethod* _tmp34_;
				ValaMethod* _tmp35_;
				ValaCCodeParameter* _tmp77_;
				_tmp30_ = vala_semantic_analyzer_get_this_type ((ValaSymbol*) m, NULL);
				this_type = _tmp30_;
				_tmp31_ = this_type;
				vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp31_, decl_space);
				instance_param = NULL;
				_tmp34_ = vala_method_get_base_interface_method (m);
				_tmp35_ = _tmp34_;
				if (_tmp35_ != NULL) {
					gboolean _tmp36_;
					gboolean _tmp37_;
					_tmp36_ = vala_method_get_is_abstract (m);
					_tmp37_ = _tmp36_;
					_tmp33_ = !_tmp37_;
				} else {
					_tmp33_ = FALSE;
				}
				if (_tmp33_) {
					gboolean _tmp38_;
					gboolean _tmp39_;
					_tmp38_ = vala_method_get_is_virtual (m);
					_tmp39_ = _tmp38_;
					_tmp32_ = !_tmp39_;
				} else {
					_tmp32_ = FALSE;
				}
				if (_tmp32_) {
					ValaObjectType* base_type = NULL;
					ValaMethod* _tmp40_;
					ValaMethod* _tmp41_;
					ValaSymbol* _tmp42_;
					ValaSymbol* _tmp43_;
					ValaObjectType* _tmp44_;
					ValaObjectType* _tmp45_;
					gchar* _tmp46_;
					gchar* _tmp47_;
					ValaCCodeParameter* _tmp48_;
					_tmp40_ = vala_method_get_base_interface_method (m);
					_tmp41_ = _tmp40_;
					_tmp42_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp41_);
					_tmp43_ = _tmp42_;
					_tmp44_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp43_, VALA_TYPE_INTERFACE, ValaInterface), NULL);
					base_type = _tmp44_;
					_tmp45_ = base_type;
					_tmp46_ = vala_get_ccode_name ((ValaCodeNode*) _tmp45_);
					_tmp47_ = _tmp46_;
					_tmp48_ = vala_ccode_parameter_new ("base", _tmp47_);
					_vala_ccode_node_unref0 (instance_param);
					instance_param = _tmp48_;
					_g_free0 (_tmp47_);
					_vala_code_node_unref0 (base_type);
				} else {
					gboolean _tmp49_;
					gboolean _tmp50_;
					_tmp49_ = vala_method_get_overrides (m);
					_tmp50_ = _tmp49_;
					if (_tmp50_) {
						ValaObjectType* base_type = NULL;
						ValaMethod* _tmp51_;
						ValaMethod* _tmp52_;
						ValaSymbol* _tmp53_;
						ValaSymbol* _tmp54_;
						ValaObjectType* _tmp55_;
						ValaObjectType* _tmp56_;
						gchar* _tmp57_;
						gchar* _tmp58_;
						ValaCCodeParameter* _tmp59_;
						_tmp51_ = vala_method_get_base_method (m);
						_tmp52_ = _tmp51_;
						_tmp53_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp52_);
						_tmp54_ = _tmp53_;
						_tmp55_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp54_, VALA_TYPE_CLASS, ValaClass), NULL);
						base_type = _tmp55_;
						_tmp56_ = base_type;
						_tmp57_ = vala_get_ccode_name ((ValaCodeNode*) _tmp56_);
						_tmp58_ = _tmp57_;
						_tmp59_ = vala_ccode_parameter_new ("base", _tmp58_);
						_vala_ccode_node_unref0 (instance_param);
						instance_param = _tmp59_;
						_g_free0 (_tmp58_);
						_vala_code_node_unref0 (base_type);
					} else {
						ValaStruct* st = NULL;
						ValaSymbol* _tmp60_;
						ValaSymbol* _tmp61_;
						gboolean _tmp62_ = FALSE;
						ValaStruct* _tmp63_;
						_tmp60_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
						_tmp61_ = _tmp60_;
						st = G_TYPE_CHECK_INSTANCE_TYPE (_tmp61_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp61_) : NULL;
						_tmp63_ = st;
						if (_tmp63_ != NULL) {
							ValaStruct* _tmp64_;
							_tmp64_ = st;
							_tmp62_ = !vala_struct_is_simple_type (_tmp64_);
						} else {
							_tmp62_ = FALSE;
						}
						if (_tmp62_) {
							ValaDataType* _tmp65_;
							gchar* _tmp66_;
							gchar* _tmp67_;
							ValaCCodeParameter* _tmp68_;
							_tmp65_ = this_type;
							_tmp66_ = vala_get_ccode_name ((ValaCodeNode*) _tmp65_);
							_tmp67_ = _tmp66_;
							_tmp68_ = vala_ccode_parameter_new ("*self", _tmp67_);
							_vala_ccode_node_unref0 (instance_param);
							instance_param = _tmp68_;
							_g_free0 (_tmp67_);
						} else {
							gboolean _tmp69_ = FALSE;
							gboolean _tmp70_ = FALSE;
							ValaStruct* _tmp71_;
							_tmp71_ = st;
							if (_tmp71_ != NULL) {
								ValaStruct* _tmp72_;
								_tmp72_ = st;
								_tmp70_ = vala_struct_is_simple_type (_tmp72_);
							} else {
								_tmp70_ = FALSE;
							}
							if (_tmp70_) {
								_tmp69_ = G_TYPE_CHECK_INSTANCE_TYPE (m, VALA_TYPE_CREATION_METHOD);
							} else {
								_tmp69_ = FALSE;
							}
							if (_tmp69_) {
							} else {
								ValaDataType* _tmp73_;
								gchar* _tmp74_;
								gchar* _tmp75_;
								ValaCCodeParameter* _tmp76_;
								_tmp73_ = this_type;
								_tmp74_ = vala_get_ccode_name ((ValaCodeNode*) _tmp73_);
								_tmp75_ = _tmp74_;
								_tmp76_ = vala_ccode_parameter_new ("self", _tmp75_);
								_vala_ccode_node_unref0 (instance_param);
								instance_param = _tmp76_;
								_g_free0 (_tmp75_);
							}
						}
					}
				}
				_tmp77_ = instance_param;
				if (_tmp77_ != NULL) {
					ValaCCodeParameter* _tmp78_;
					_tmp78_ = instance_param;
					vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) m), FALSE)), _tmp78_);
				}
				_vala_ccode_node_unref0 (instance_param);
				_vala_code_node_unref0 (this_type);
			} else {
				ValaMemberBinding _tmp79_;
				ValaMemberBinding _tmp80_;
				_tmp79_ = vala_method_get_binding (m);
				_tmp80_ = _tmp79_;
				if (_tmp80_ == VALA_MEMBER_BINDING_CLASS) {
					ValaDataType* this_type = NULL;
					ValaDataType* _tmp81_;
					ValaCCodeParameter* class_param = NULL;
					ValaDataType* _tmp82_;
					gchar* _tmp83_;
					gchar* _tmp84_;
					ValaCCodeParameter* _tmp85_;
					ValaCCodeParameter* _tmp86_;
					ValaCCodeParameter* _tmp87_;
					_tmp81_ = vala_semantic_analyzer_get_this_type ((ValaSymbol*) m, NULL);
					this_type = _tmp81_;
					_tmp82_ = this_type;
					_tmp83_ = vala_get_ccode_name ((ValaCodeNode*) _tmp82_);
					_tmp84_ = _tmp83_;
					_tmp85_ = vala_ccode_parameter_new ("klass", _tmp84_);
					_tmp86_ = _tmp85_;
					_g_free0 (_tmp84_);
					class_param = _tmp86_;
					_tmp87_ = class_param;
					vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) m), FALSE)), _tmp87_);
					_vala_ccode_node_unref0 (class_param);
					_vala_code_node_unref0 (this_type);
				}
			}
		}
	}
	type_parameters = NULL;
	if (vala_ccode_method_module_is_gtypeinstance_creation_method (self, m)) {
		_tmp88_ = (direction & 1) == 1;
	} else {
		_tmp88_ = FALSE;
	}
	if (_tmp88_) {
		ValaSymbol* _tmp89_;
		ValaSymbol* _tmp90_;
		ValaList* _tmp91_;
		ValaList* _tmp92_;
		_tmp89_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
		_tmp90_ = _tmp89_;
		_tmp91_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp90_, VALA_TYPE_CLASS, ValaClass));
		_tmp92_ = _vala_iterable_ref0 (_tmp91_);
		_vala_iterable_unref0 (type_parameters);
		type_parameters = _tmp92_;
	} else {
		gboolean _tmp93_ = FALSE;
		gboolean _tmp94_;
		gboolean _tmp95_;
		_tmp94_ = vala_method_get_closure (m);
		_tmp95_ = _tmp94_;
		if (!_tmp95_) {
			_tmp93_ = (direction & 1) == 1;
		} else {
			_tmp93_ = FALSE;
		}
		if (_tmp93_) {
			ValaList* _tmp96_;
			ValaList* _tmp97_;
			_tmp96_ = vala_method_get_type_parameters (m);
			_tmp97_ = _vala_iterable_ref0 (_tmp96_);
			_vala_iterable_unref0 (type_parameters);
			type_parameters = _tmp97_;
		}
	}
	_tmp98_ = type_parameters;
	if (_tmp98_ != NULL) {
		gint type_param_index = 0;
		type_param_index = 0;
		{
			ValaList* _type_param_list = NULL;
			ValaList* _tmp99_;
			gint _type_param_size = 0;
			ValaList* _tmp100_;
			gint _tmp101_;
			gint _tmp102_;
			gint _type_param_index = 0;
			_tmp99_ = type_parameters;
			_type_param_list = _tmp99_;
			_tmp100_ = _type_param_list;
			_tmp101_ = vala_collection_get_size ((ValaCollection*) _tmp100_);
			_tmp102_ = _tmp101_;
			_type_param_size = _tmp102_;
			_type_param_index = -1;
			while (TRUE) {
				gint _tmp103_;
				gint _tmp104_;
				ValaTypeParameter* type_param = NULL;
				ValaList* _tmp105_;
				gpointer _tmp106_;
				gchar* type = NULL;
				ValaTypeParameter* _tmp107_;
				gchar* _tmp108_;
				gchar* dup_func = NULL;
				ValaTypeParameter* _tmp109_;
				gchar* _tmp110_;
				gchar* destroy_func = NULL;
				ValaTypeParameter* _tmp111_;
				gchar* _tmp112_;
				const gchar* _tmp113_;
				ValaCCodeParameter* _tmp114_;
				ValaCCodeParameter* _tmp115_;
				const gchar* _tmp116_;
				ValaCCodeParameter* _tmp117_;
				ValaCCodeParameter* _tmp118_;
				const gchar* _tmp119_;
				ValaCCodeParameter* _tmp120_;
				ValaCCodeParameter* _tmp121_;
				gint _tmp131_;
				_type_param_index = _type_param_index + 1;
				_tmp103_ = _type_param_index;
				_tmp104_ = _type_param_size;
				if (!(_tmp103_ < _tmp104_)) {
					break;
				}
				_tmp105_ = _type_param_list;
				_tmp106_ = vala_list_get (_tmp105_, _type_param_index);
				type_param = (ValaTypeParameter*) _tmp106_;
				_tmp107_ = type_param;
				_tmp108_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp107_);
				type = _tmp108_;
				_tmp109_ = type_param;
				_tmp110_ = vala_get_ccode_copy_function ((ValaTypeSymbol*) _tmp109_);
				dup_func = _tmp110_;
				_tmp111_ = type_param;
				_tmp112_ = vala_get_ccode_destroy_function ((ValaTypeSymbol*) _tmp111_);
				destroy_func = _tmp112_;
				_tmp113_ = type;
				_tmp114_ = vala_ccode_parameter_new (_tmp113_, "GType");
				_tmp115_ = _tmp114_;
				vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.01, FALSE)), _tmp115_);
				_vala_ccode_node_unref0 (_tmp115_);
				_tmp116_ = dup_func;
				_tmp117_ = vala_ccode_parameter_new (_tmp116_, "GBoxedCopyFunc");
				_tmp118_ = _tmp117_;
				vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.02, FALSE)), _tmp118_);
				_vala_ccode_node_unref0 (_tmp118_);
				_tmp119_ = destroy_func;
				_tmp120_ = vala_ccode_parameter_new (_tmp119_, "GDestroyNotify");
				_tmp121_ = _tmp120_;
				vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.03, FALSE)), _tmp121_);
				_vala_ccode_node_unref0 (_tmp121_);
				if (carg_map != NULL) {
					const gchar* _tmp122_;
					ValaCCodeIdentifier* _tmp123_;
					ValaCCodeIdentifier* _tmp124_;
					const gchar* _tmp125_;
					ValaCCodeIdentifier* _tmp126_;
					ValaCCodeIdentifier* _tmp127_;
					const gchar* _tmp128_;
					ValaCCodeIdentifier* _tmp129_;
					ValaCCodeIdentifier* _tmp130_;
					_tmp122_ = type;
					_tmp123_ = vala_ccode_identifier_new (_tmp122_);
					_tmp124_ = _tmp123_;
					vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.01, FALSE)), (ValaCCodeExpression*) _tmp124_);
					_vala_ccode_node_unref0 (_tmp124_);
					_tmp125_ = dup_func;
					_tmp126_ = vala_ccode_identifier_new (_tmp125_);
					_tmp127_ = _tmp126_;
					vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.02, FALSE)), (ValaCCodeExpression*) _tmp127_);
					_vala_ccode_node_unref0 (_tmp127_);
					_tmp128_ = destroy_func;
					_tmp129_ = vala_ccode_identifier_new (_tmp128_);
					_tmp130_ = _tmp129_;
					vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.03, FALSE)), (ValaCCodeExpression*) _tmp130_);
					_vala_ccode_node_unref0 (_tmp130_);
				}
				_tmp131_ = type_param_index;
				type_param_index = _tmp131_ + 1;
				_g_free0 (destroy_func);
				_g_free0 (dup_func);
				_g_free0 (type);
				_vala_code_node_unref0 (type_param);
			}
		}
	}
	if (vala_method_get_format_arg_index (m) < 0) {
		gboolean _tmp133_ = FALSE;
		gboolean _tmp134_;
		gboolean _tmp135_;
		_tmp134_ = vala_method_get_printf_format (m);
		_tmp135_ = _tmp134_;
		if (_tmp135_) {
			_tmp133_ = TRUE;
		} else {
			gboolean _tmp136_;
			gboolean _tmp137_;
			_tmp136_ = vala_method_get_scanf_format (m);
			_tmp137_ = _tmp136_;
			_tmp133_ = _tmp137_;
		}
		_tmp132_ = _tmp133_;
	} else {
		_tmp132_ = FALSE;
	}
	needs_format_arg = _tmp132_;
	prev_cparam = NULL;
	{
		ValaList* _param_list = NULL;
		ValaList* _tmp138_;
		gint _param_size = 0;
		ValaList* _tmp139_;
		gint _tmp140_;
		gint _tmp141_;
		gint _param_index = 0;
		_tmp138_ = vala_callable_get_parameters ((ValaCallable*) m);
		_param_list = _tmp138_;
		_tmp139_ = _param_list;
		_tmp140_ = vala_collection_get_size ((ValaCollection*) _tmp139_);
		_tmp141_ = _tmp140_;
		_param_size = _tmp141_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp142_;
			gint _tmp143_;
			ValaParameter* param = NULL;
			ValaList* _tmp144_;
			gpointer _tmp145_;
			ValaParameter* _tmp146_;
			ValaParameterDirection _tmp147_;
			ValaParameterDirection _tmp148_;
			ValaCCodeParameter* cparam = NULL;
			ValaParameter* _tmp149_;
			ValaCCodeParameter* _tmp150_;
			_param_index = _param_index + 1;
			_tmp142_ = _param_index;
			_tmp143_ = _param_size;
			if (!(_tmp142_ < _tmp143_)) {
				break;
			}
			_tmp144_ = _param_list;
			_tmp145_ = vala_list_get (_tmp144_, _param_index);
			param = (ValaParameter*) _tmp145_;
			_tmp146_ = param;
			_tmp147_ = vala_parameter_get_direction (_tmp146_);
			_tmp148_ = _tmp147_;
			if (_tmp148_ != VALA_PARAMETER_DIRECTION_OUT) {
				if ((direction & 1) == 0) {
					_vala_code_node_unref0 (param);
					continue;
				}
			} else {
				if ((direction & 2) == 0) {
					_vala_code_node_unref0 (param);
					continue;
				}
			}
			_tmp149_ = param;
			_tmp150_ = vala_ccode_method_module_generate_parameter (self, _tmp149_, decl_space, cparam_map, carg_map);
			cparam = _tmp150_;
			if (needs_format_arg) {
				gboolean _tmp151_ = FALSE;
				ValaCCodeParameter* _tmp152_;
				ValaCCodeParameter* _tmp160_;
				ValaCCodeParameter* _tmp161_;
				_tmp152_ = prev_cparam;
				if (_tmp152_ != NULL) {
					ValaCCodeParameter* _tmp153_;
					gboolean _tmp154_;
					gboolean _tmp155_;
					_tmp153_ = cparam;
					_tmp154_ = vala_ccode_parameter_get_ellipsis (_tmp153_);
					_tmp155_ = _tmp154_;
					_tmp151_ = _tmp155_;
				} else {
					_tmp151_ = FALSE;
				}
				if (_tmp151_) {
					ValaCCodeParameter* _tmp156_;
					ValaCCodeParameter* _tmp157_;
					ValaCCodeModifiers _tmp158_;
					ValaCCodeModifiers _tmp159_;
					_tmp156_ = prev_cparam;
					_tmp157_ = prev_cparam;
					_tmp158_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp157_);
					_tmp159_ = _tmp158_;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp157_, _tmp159_ | VALA_CCODE_MODIFIERS_FORMAT_ARG);
				}
				_tmp160_ = cparam;
				_tmp161_ = _vala_ccode_node_ref0 (_tmp160_);
				_vala_ccode_node_unref0 (prev_cparam);
				prev_cparam = _tmp161_;
			}
			_vala_ccode_node_unref0 (cparam);
			_vala_code_node_unref0 (param);
		}
	}
	if ((direction & 2) != 0) {
		vala_ccode_method_module_generate_method_result_declaration (self, m, decl_space, func, cparam_map, carg_map);
	}
	last_pos = -1;
	while (TRUE) {
		gpointer _tmp171_;
		ValaCCodeParameter* _tmp172_;
		min_pos = -1;
		{
			ValaIterator* _pos_it = NULL;
			ValaSet* _tmp162_;
			ValaSet* _tmp163_;
			ValaIterator* _tmp164_;
			ValaIterator* _tmp165_;
			_tmp162_ = vala_map_get_keys (cparam_map);
			_tmp163_ = _tmp162_;
			_tmp164_ = vala_iterable_iterator ((ValaIterable*) _tmp163_);
			_tmp165_ = _tmp164_;
			_vala_iterable_unref0 (_tmp163_);
			_pos_it = _tmp165_;
			while (TRUE) {
				ValaIterator* _tmp166_;
				gint pos = 0;
				ValaIterator* _tmp167_;
				gpointer _tmp168_;
				gboolean _tmp169_ = FALSE;
				_tmp166_ = _pos_it;
				if (!vala_iterator_next (_tmp166_)) {
					break;
				}
				_tmp167_ = _pos_it;
				_tmp168_ = vala_iterator_get (_tmp167_);
				pos = (gint) ((gintptr) _tmp168_);
				if (pos > last_pos) {
					gboolean _tmp170_ = FALSE;
					if (min_pos == -1) {
						_tmp170_ = TRUE;
					} else {
						_tmp170_ = pos < min_pos;
					}
					_tmp169_ = _tmp170_;
				} else {
					_tmp169_ = FALSE;
				}
				if (_tmp169_) {
					min_pos = pos;
				}
			}
			_vala_iterator_unref0 (_pos_it);
		}
		if (min_pos == -1) {
			break;
		}
		_tmp171_ = vala_map_get (cparam_map, (gpointer) ((gintptr) min_pos));
		_tmp172_ = (ValaCCodeParameter*) _tmp171_;
		vala_ccode_function_add_parameter (func, _tmp172_);
		_vala_ccode_node_unref0 (_tmp172_);
		if (vdeclarator != NULL) {
			gpointer _tmp173_;
			ValaCCodeParameter* _tmp174_;
			_tmp173_ = vala_map_get (cparam_map, (gpointer) ((gintptr) min_pos));
			_tmp174_ = (ValaCCodeParameter*) _tmp173_;
			vala_ccode_function_declarator_add_parameter (vdeclarator, _tmp174_);
			_vala_ccode_node_unref0 (_tmp174_);
		}
		if (vcall != NULL) {
			ValaCCodeExpression* arg = NULL;
			gpointer _tmp175_;
			ValaCCodeExpression* _tmp176_;
			_tmp175_ = vala_map_get (carg_map, (gpointer) ((gintptr) min_pos));
			arg = (ValaCCodeExpression*) _tmp175_;
			_tmp176_ = arg;
			if (_tmp176_ != NULL) {
				ValaCCodeExpression* _tmp177_;
				_tmp177_ = arg;
				vala_ccode_function_call_add_argument (vcall, _tmp177_);
			}
			_vala_ccode_node_unref0 (arg);
		}
		last_pos = min_pos;
	}
	_tmp178_ = vala_method_get_printf_format (m);
	_tmp179_ = _tmp178_;
	if (_tmp179_) {
		ValaCCodeModifiers _tmp180_;
		ValaCCodeModifiers _tmp181_;
		_tmp180_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) func);
		_tmp181_ = _tmp180_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) func, _tmp181_ | VALA_CCODE_MODIFIERS_PRINTF);
	} else {
		gboolean _tmp182_;
		gboolean _tmp183_;
		_tmp182_ = vala_method_get_scanf_format (m);
		_tmp183_ = _tmp182_;
		if (_tmp183_) {
			ValaCCodeModifiers _tmp184_;
			ValaCCodeModifiers _tmp185_;
			_tmp184_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) func);
			_tmp185_ = _tmp184_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) func, _tmp185_ | VALA_CCODE_MODIFIERS_SCANF);
		}
	}
	_tmp186_ = vala_symbol_get_version ((ValaSymbol*) m);
	_tmp187_ = _tmp186_;
	_tmp188_ = vala_version_attribute_get_deprecated (_tmp187_);
	_tmp189_ = _tmp188_;
	if (_tmp189_) {
		ValaCCodeModifiers _tmp190_;
		ValaCCodeModifiers _tmp191_;
		_tmp190_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) func);
		_tmp191_ = _tmp190_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) func, _tmp191_ | VALA_CCODE_MODIFIERS_DEPRECATED);
	}
	_vala_ccode_node_unref0 (prev_cparam);
	_vala_iterable_unref0 (type_parameters);
}

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

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)
{
	gboolean _tmp0_;
	gboolean _tmp1_;
	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_ = vala_method_get_coroutine (m);
	_tmp1_ = _tmp0_;
	if (!_tmp1_) {
		vala_ccode_base_module_create_type_check_statement ((ValaCCodeBaseModule*) self, (ValaCodeNode*) m, return_type, t, non_null, var_name);
	}
}

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

static gchar*
string_substring (const gchar* self,
                  glong offset,
                  glong len)
{
	glong string_length = 0L;
	gboolean _tmp0_ = FALSE;
	gchar* _tmp3_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	if (offset >= ((glong) 0)) {
		_tmp0_ = len >= ((glong) 0);
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		string_length = string_strnlen ((gchar*) self, offset + len);
	} else {
		gint _tmp1_;
		gint _tmp2_;
		_tmp1_ = strlen (self);
		_tmp2_ = _tmp1_;
		string_length = (glong) _tmp2_;
	}
	if (offset < ((glong) 0)) {
		offset = string_length + offset;
		g_return_val_if_fail (offset >= ((glong) 0), NULL);
	} else {
		g_return_val_if_fail (offset <= string_length, NULL);
	}
	if (len < ((glong) 0)) {
		len = string_length - offset;
	}
	g_return_val_if_fail ((offset + len) <= string_length, NULL);
	_tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
	result = _tmp3_;
	return result;
}

static gchar*
string_replace (const gchar* self,
                const gchar* old,
                const gchar* replacement)
{
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	GError* _inner_error0_ = NULL;
	gchar* result;
	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 {
		_tmp1_ = (*((gchar*) old)) == '\0';
	}
	if (_tmp1_) {
		_tmp0_ = TRUE;
	} else {
		_tmp0_ = g_strcmp0 (old, replacement) == 0;
	}
	if (_tmp0_) {
		gchar* _tmp2_;
		_tmp2_ = g_strdup (self);
		result = _tmp2_;
		return result;
	}
	{
		GRegex* regex = NULL;
		gchar* _tmp3_;
		gchar* _tmp4_;
		GRegex* _tmp5_;
		GRegex* _tmp6_;
		gchar* _tmp7_ = NULL;
		GRegex* _tmp8_;
		gchar* _tmp9_;
		gchar* _tmp10_;
		_tmp3_ = g_regex_escape_string (old, -1);
		_tmp4_ = _tmp3_;
		_tmp5_ = g_regex_new (_tmp4_, 0, 0, &_inner_error0_);
		_tmp6_ = _tmp5_;
		_g_free0 (_tmp4_);
		regex = _tmp6_;
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			if (_inner_error0_->domain == G_REGEX_ERROR) {
				goto __catch0_g_regex_error;
			}
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
		_tmp8_ = regex;
		_tmp9_ = g_regex_replace_literal (_tmp8_, self, (gssize) -1, 0, replacement, 0, &_inner_error0_);
		_tmp7_ = _tmp9_;
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			_g_regex_unref0 (regex);
			if (_inner_error0_->domain == G_REGEX_ERROR) {
				goto __catch0_g_regex_error;
			}
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
		_tmp10_ = _tmp7_;
		_tmp7_ = NULL;
		result = _tmp10_;
		_g_free0 (_tmp7_);
		_g_regex_unref0 (regex);
		return result;
	}
	goto __finally0;
	__catch0_g_regex_error:
	{
		g_clear_error (&_inner_error0_);
		g_assert_not_reached ();
	}
	__finally0:
	g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
	g_clear_error (&_inner_error0_);
	return NULL;
}

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

static void
vala_ccode_method_module_real_visit_creation_method (ValaCodeVisitor* base,
                                                     ValaCreationMethod* m)
{
	ValaCCodeMethodModule * self;
	ValaSourceReference* _tmp0_;
	ValaSourceReference* _tmp1_;
	ValaClass* cl = NULL;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp3_;
	gboolean _tmp4_ = FALSE;
	ValaClass* _tmp5_;
	gboolean _tmp9_ = FALSE;
	gboolean _tmp10_ = FALSE;
	gboolean _tmp11_;
	gboolean _tmp12_;
	gboolean _tmp17_ = FALSE;
	gboolean _tmp18_ = FALSE;
	ValaTypeSymbol* _tmp19_;
	ValaTypeSymbol* _tmp20_;
	self = (ValaCCodeMethodModule*) base;
	g_return_if_fail (m != NULL);
	_tmp0_ = vala_code_node_get_source_reference ((ValaCodeNode*) m);
	_tmp1_ = _tmp0_;
	vala_ccode_base_module_push_line ((ValaCCodeBaseModule*) self, _tmp1_);
	_tmp2_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
	_tmp3_ = _tmp2_;
	cl = G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp3_) : NULL;
	_tmp5_ = cl;
	if (_tmp5_ != NULL) {
		ValaClass* _tmp6_;
		gboolean _tmp7_;
		gboolean _tmp8_;
		_tmp6_ = cl;
		_tmp7_ = vala_class_get_is_compact (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp4_ = !_tmp8_;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		self->priv->ellipses_to_valist = TRUE;
	} else {
		self->priv->ellipses_to_valist = FALSE;
	}
	vala_code_visitor_visit_method ((ValaCodeVisitor*) self, (ValaMethod*) m);
	self->priv->ellipses_to_valist = FALSE;
	_tmp11_ = vala_symbol_get_external ((ValaSymbol*) m);
	_tmp12_ = _tmp11_;
	if (!_tmp12_) {
		gboolean _tmp13_;
		gboolean _tmp14_;
		_tmp13_ = vala_symbol_get_external_package ((ValaSymbol*) m);
		_tmp14_ = _tmp13_;
		_tmp10_ = _tmp14_;
	} else {
		_tmp10_ = FALSE;
	}
	if (_tmp10_) {
		_tmp9_ = TRUE;
	} else {
		ValaSourceFileType _tmp15_;
		ValaSourceFileType _tmp16_;
		_tmp15_ = vala_symbol_get_source_type ((ValaSymbol*) m);
		_tmp16_ = _tmp15_;
		_tmp9_ = _tmp16_ == VALA_SOURCE_FILE_TYPE_FAST;
	}
	if (_tmp9_) {
		vala_ccode_base_module_pop_line ((ValaCCodeBaseModule*) self);
		return;
	}
	_tmp19_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
	_tmp20_ = _tmp19_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp20_, VALA_TYPE_CLASS)) {
		ValaClass* _tmp21_;
		ValaClass* _tmp22_;
		gboolean _tmp23_;
		gboolean _tmp24_;
		_tmp21_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp22_ = _tmp21_;
		_tmp23_ = vala_class_get_is_compact (_tmp22_);
		_tmp24_ = _tmp23_;
		_tmp18_ = !_tmp24_;
	} else {
		_tmp18_ = FALSE;
	}
	if (_tmp18_) {
		ValaClass* _tmp25_;
		ValaClass* _tmp26_;
		gboolean _tmp27_;
		gboolean _tmp28_;
		_tmp25_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp26_ = _tmp25_;
		_tmp27_ = vala_class_get_is_abstract (_tmp26_);
		_tmp28_ = _tmp27_;
		_tmp17_ = !_tmp28_;
	} else {
		_tmp17_ = FALSE;
	}
	if (_tmp17_) {
		gchar* _tmp29_;
		gchar* _tmp30_;
		_tmp29_ = vala_get_ccode_name ((ValaCodeNode*) m);
		_tmp30_ = _tmp29_;
		vala_ccode_method_module_create_aux_constructor (self, m, _tmp30_, FALSE);
		_g_free0 (_tmp30_);
		if (vala_method_is_variadic ((ValaMethod*) m)) {
			gchar* _tmp31_;
			gchar* _tmp32_;
			_tmp31_ = vala_get_ccode_real_name ((ValaSymbol*) m);
			_tmp32_ = _tmp31_;
			vala_ccode_method_module_create_aux_constructor (self, m, _tmp32_, TRUE);
			_g_free0 (_tmp32_);
		}
	}
	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;
	ValaCCodeFunction* _tmp0_;
	ValaHashMap* cparam_map = NULL;
	GHashFunc _tmp14_;
	GEqualFunc _tmp15_;
	GEqualFunc _tmp16_;
	ValaHashMap* _tmp17_;
	ValaHashMap* carg_map = NULL;
	GHashFunc _tmp18_;
	GEqualFunc _tmp19_;
	GEqualFunc _tmp20_;
	ValaHashMap* _tmp21_;
	ValaCCodeFunction* _tmp22_;
	gchar* _tmp23_ = NULL;
	gchar* constructor = NULL;
	gchar* _tmp26_;
	ValaCCodeFunctionCall* vcall = NULL;
	const gchar* _tmp27_;
	ValaCCodeIdentifier* _tmp28_;
	ValaCCodeIdentifier* _tmp29_;
	ValaCCodeFunctionCall* _tmp30_;
	ValaCCodeFunctionCall* _tmp31_;
	ValaCCodeFile* _tmp45_;
	ValaHashMap* _tmp46_;
	ValaCCodeFunction* _tmp47_;
	ValaHashMap* _tmp48_;
	ValaCCodeFunctionCall* _tmp49_;
	ValaCCodeFunction* _tmp88_;
	ValaCCodeFunction* _tmp89_;
	ValaCCodeFunctionCall* _tmp90_;
	ValaCCodeFile* _tmp91_;
	ValaCCodeFunction* _tmp92_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (m != NULL);
	g_return_if_fail (func_name != NULL);
	_tmp0_ = vala_ccode_function_new (func_name, "void");
	vfunc = _tmp0_;
	if (vala_symbol_is_private_symbol ((ValaSymbol*) m)) {
		ValaCCodeFunction* _tmp1_;
		ValaCCodeFunction* _tmp2_;
		ValaCCodeModifiers _tmp3_;
		ValaCCodeModifiers _tmp4_;
		_tmp1_ = vfunc;
		_tmp2_ = vfunc;
		_tmp3_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp2_);
		_tmp4_ = _tmp3_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp2_, _tmp4_ | VALA_CCODE_MODIFIERS_STATIC);
	} else {
		gboolean _tmp5_ = FALSE;
		ValaCodeContext* _tmp6_;
		ValaCodeContext* _tmp7_;
		gboolean _tmp8_;
		gboolean _tmp9_;
		_tmp6_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_code_context_get_hide_internal (_tmp7_);
		_tmp9_ = _tmp8_;
		if (_tmp9_) {
			_tmp5_ = vala_symbol_is_internal_symbol ((ValaSymbol*) m);
		} else {
			_tmp5_ = FALSE;
		}
		if (_tmp5_) {
			ValaCCodeFunction* _tmp10_;
			ValaCCodeFunction* _tmp11_;
			ValaCCodeModifiers _tmp12_;
			ValaCCodeModifiers _tmp13_;
			_tmp10_ = vfunc;
			_tmp11_ = vfunc;
			_tmp12_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp11_);
			_tmp13_ = _tmp12_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp11_, _tmp13_ | VALA_CCODE_MODIFIERS_INTERNAL);
		}
	}
	_tmp14_ = g_direct_hash;
	_tmp15_ = g_direct_equal;
	_tmp16_ = g_direct_equal;
	_tmp17_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp14_, _tmp15_, _tmp16_);
	cparam_map = _tmp17_;
	_tmp18_ = g_direct_hash;
	_tmp19_ = g_direct_equal;
	_tmp20_ = g_direct_equal;
	_tmp21_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp18_, _tmp19_, _tmp20_);
	carg_map = _tmp21_;
	_tmp22_ = vfunc;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp22_);
	if (vala_method_is_variadic ((ValaMethod*) m)) {
		gchar* _tmp24_;
		_tmp24_ = vala_get_ccode_constructv_name (m);
		_g_free0 (_tmp23_);
		_tmp23_ = _tmp24_;
	} else {
		gchar* _tmp25_;
		_tmp25_ = vala_get_ccode_real_name ((ValaSymbol*) m);
		_g_free0 (_tmp23_);
		_tmp23_ = _tmp25_;
	}
	_tmp26_ = g_strdup (_tmp23_);
	constructor = _tmp26_;
	_tmp27_ = constructor;
	_tmp28_ = vala_ccode_identifier_new (_tmp27_);
	_tmp29_ = _tmp28_;
	_tmp30_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp29_);
	_tmp31_ = _tmp30_;
	_vala_ccode_node_unref0 (_tmp29_);
	vcall = _tmp31_;
	if (self_as_first_parameter) {
		ValaHashMap* _tmp32_;
		ValaCCodeParameter* _tmp33_;
		ValaCCodeParameter* _tmp34_;
		ValaCCodeFunctionCall* _tmp35_;
		ValaCCodeExpression* _tmp36_;
		ValaCCodeExpression* _tmp37_;
		_tmp32_ = cparam_map;
		_tmp33_ = vala_ccode_parameter_new ("object_type", "GType");
		_tmp34_ = _tmp33_;
		vala_map_set ((ValaMap*) _tmp32_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) m), FALSE)), _tmp34_);
		_vala_ccode_node_unref0 (_tmp34_);
		_tmp35_ = vcall;
		_tmp36_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "object_type");
		_tmp37_ = _tmp36_;
		vala_ccode_function_call_add_argument (_tmp35_, _tmp37_);
		_vala_ccode_node_unref0 (_tmp37_);
	} else {
		ValaCCodeFunctionCall* _tmp38_;
		ValaClass* _tmp39_;
		ValaClass* _tmp40_;
		gchar* _tmp41_;
		gchar* _tmp42_;
		ValaCCodeIdentifier* _tmp43_;
		ValaCCodeIdentifier* _tmp44_;
		_tmp38_ = vcall;
		_tmp39_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp40_ = _tmp39_;
		_tmp41_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp40_);
		_tmp42_ = _tmp41_;
		_tmp43_ = vala_ccode_identifier_new (_tmp42_);
		_tmp44_ = _tmp43_;
		vala_ccode_function_call_add_argument (_tmp38_, (ValaCCodeExpression*) _tmp44_);
		_vala_ccode_node_unref0 (_tmp44_);
		_g_free0 (_tmp42_);
	}
	_tmp45_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp46_ = cparam_map;
	_tmp47_ = vfunc;
	_tmp48_ = carg_map;
	_tmp49_ = vcall;
	vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, (ValaMethod*) m, _tmp45_, (ValaMap*) _tmp46_, _tmp47_, NULL, (ValaMap*) _tmp48_, _tmp49_, 3);
	if (vala_method_is_variadic ((ValaMethod*) m)) {
		gint last_pos = 0;
		gint second_last_pos = 0;
		ValaCCodeExpression* carg = NULL;
		ValaHashMap* _tmp58_;
		gpointer _tmp59_;
		ValaCCodeExpression* _tmp60_;
		ValaCCodeFunctionCall* vastart = NULL;
		ValaCCodeIdentifier* _tmp69_;
		ValaCCodeIdentifier* _tmp70_;
		ValaCCodeFunctionCall* _tmp71_;
		ValaCCodeFunctionCall* _tmp72_;
		ValaCCodeFunctionCall* _tmp73_;
		ValaCCodeIdentifier* _tmp74_;
		ValaCCodeIdentifier* _tmp75_;
		ValaCCodeFunctionCall* _tmp76_;
		ValaCCodeExpression* _tmp77_;
		ValaCCodeFunction* _tmp78_;
		ValaCCodeFunction* _tmp79_;
		ValaCCodeVariableDeclarator* _tmp80_;
		ValaCCodeVariableDeclarator* _tmp81_;
		ValaCCodeFunction* _tmp82_;
		ValaCCodeFunction* _tmp83_;
		ValaCCodeFunctionCall* _tmp84_;
		ValaCCodeFunctionCall* _tmp85_;
		ValaCCodeIdentifier* _tmp86_;
		ValaCCodeIdentifier* _tmp87_;
		last_pos = -1;
		second_last_pos = -1;
		{
			ValaIterator* _pos_it = NULL;
			ValaHashMap* _tmp50_;
			ValaSet* _tmp51_;
			ValaSet* _tmp52_;
			ValaIterator* _tmp53_;
			ValaIterator* _tmp54_;
			_tmp50_ = cparam_map;
			_tmp51_ = vala_map_get_keys ((ValaMap*) _tmp50_);
			_tmp52_ = _tmp51_;
			_tmp53_ = vala_iterable_iterator ((ValaIterable*) _tmp52_);
			_tmp54_ = _tmp53_;
			_vala_iterable_unref0 (_tmp52_);
			_pos_it = _tmp54_;
			while (TRUE) {
				ValaIterator* _tmp55_;
				gint pos = 0;
				ValaIterator* _tmp56_;
				gpointer _tmp57_;
				_tmp55_ = _pos_it;
				if (!vala_iterator_next (_tmp55_)) {
					break;
				}
				_tmp56_ = _pos_it;
				_tmp57_ = vala_iterator_get (_tmp56_);
				pos = (gint) ((gintptr) _tmp57_);
				if (pos > last_pos) {
					second_last_pos = last_pos;
					last_pos = pos;
				} else {
					if (pos > second_last_pos) {
						second_last_pos = pos;
					}
				}
			}
			_vala_iterator_unref0 (_pos_it);
		}
		_tmp58_ = carg_map;
		_tmp59_ = vala_map_get ((ValaMap*) _tmp58_, (gpointer) ((gintptr) second_last_pos));
		carg = (ValaCCodeExpression*) _tmp59_;
		_tmp60_ = carg;
		if (_tmp60_ == NULL) {
			ValaHashMap* _tmp61_;
			gpointer _tmp62_;
			ValaCCodeParameter* _tmp63_;
			const gchar* _tmp64_;
			const gchar* _tmp65_;
			ValaCCodeIdentifier* _tmp66_;
			ValaCCodeFunctionCall* _tmp67_;
			ValaCCodeExpression* _tmp68_;
			_tmp61_ = cparam_map;
			_tmp62_ = vala_map_get ((ValaMap*) _tmp61_, (gpointer) ((gintptr) second_last_pos));
			_tmp63_ = (ValaCCodeParameter*) _tmp62_;
			_tmp64_ = vala_ccode_parameter_get_name (_tmp63_);
			_tmp65_ = _tmp64_;
			_tmp66_ = vala_ccode_identifier_new (_tmp65_);
			_vala_ccode_node_unref0 (carg);
			carg = (ValaCCodeExpression*) _tmp66_;
			_vala_ccode_node_unref0 (_tmp63_);
			_tmp67_ = vcall;
			_tmp68_ = carg;
			vala_ccode_function_call_add_argument (_tmp67_, _tmp68_);
		}
		_tmp69_ = vala_ccode_identifier_new ("va_start");
		_tmp70_ = _tmp69_;
		_tmp71_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp70_);
		_tmp72_ = _tmp71_;
		_vala_ccode_node_unref0 (_tmp70_);
		vastart = _tmp72_;
		_tmp73_ = vastart;
		_tmp74_ = vala_ccode_identifier_new ("_vala_va_list_obj");
		_tmp75_ = _tmp74_;
		vala_ccode_function_call_add_argument (_tmp73_, (ValaCCodeExpression*) _tmp75_);
		_vala_ccode_node_unref0 (_tmp75_);
		_tmp76_ = vastart;
		_tmp77_ = carg;
		vala_ccode_function_call_add_argument (_tmp76_, _tmp77_);
		_tmp78_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp79_ = _tmp78_;
		_tmp80_ = vala_ccode_variable_declarator_new ("_vala_va_list_obj", NULL, NULL);
		_tmp81_ = _tmp80_;
		vala_ccode_function_add_declaration (_tmp79_, "va_list", (ValaCCodeDeclarator*) _tmp81_, 0);
		_vala_ccode_node_unref0 (_tmp81_);
		_tmp82_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp83_ = _tmp82_;
		_tmp84_ = vastart;
		vala_ccode_function_add_expression (_tmp83_, (ValaCCodeExpression*) _tmp84_);
		_tmp85_ = vcall;
		_tmp86_ = vala_ccode_identifier_new ("_vala_va_list_obj");
		_tmp87_ = _tmp86_;
		vala_ccode_function_call_add_argument (_tmp85_, (ValaCCodeExpression*) _tmp87_);
		_vala_ccode_node_unref0 (_tmp87_);
		_vala_ccode_node_unref0 (vastart);
		_vala_ccode_node_unref0 (carg);
	}
	_tmp88_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp89_ = _tmp88_;
	_tmp90_ = vcall;
	vala_ccode_function_add_return (_tmp89_, (ValaCCodeExpression*) _tmp90_);
	vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
	_tmp91_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp92_ = vfunc;
	vala_ccode_file_add_function (_tmp91_, _tmp92_);
	_vala_ccode_node_unref0 (vcall);
	_g_free0 (constructor);
	_g_free0 (_tmp23_);
	_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,
                                     gpointer klass_data)
{
	vala_ccode_method_module_parent_class = g_type_class_peek_parent (klass);
	((ValaCodeVisitorClass *) klass)->finalize = vala_ccode_method_module_finalize;
	g_type_class_adjust_private_offset (klass, &ValaCCodeMethodModule_private_offset);
	((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 = (gboolean (*) (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,
                                        gpointer klass)
{
	self->priv = vala_ccode_method_module_get_instance_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.
 */
static GType
vala_ccode_method_module_get_type_once (void)
{
	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);
	ValaCCodeMethodModule_private_offset = g_type_add_instance_private (vala_ccode_method_module_type_id, sizeof (ValaCCodeMethodModulePrivate));
	return vala_ccode_method_module_type_id;
}

GType
vala_ccode_method_module_get_type (void)
{
	static volatile gsize vala_ccode_method_module_type_id__once = 0;
	if (g_once_init_enter (&vala_ccode_method_module_type_id__once)) {
		GType vala_ccode_method_module_type_id;
		vala_ccode_method_module_type_id = vala_ccode_method_module_get_type_once ();
		g_once_init_leave (&vala_ccode_method_module_type_id__once, vala_ccode_method_module_type_id);
	}
	return vala_ccode_method_module_type_id__once;
}

