/* 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>

#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif

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

