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

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

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

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

#include "valacodegen.h"
#include <glib.h>
#include <vala.h>
#include <valaccode.h>
#include <valagee.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <math.h>

#define _g_free0(var) (var = (g_free (var), NULL))
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
#define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_unref (var), NULL)))
#define _vala_ccode_base_module_emit_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_base_module_emit_context_unref (var), NULL)))

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

typedef struct _ValaGLibValue ValaGLibValue;
typedef struct _ValaGLibValueClass ValaGLibValueClass;
#define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL)))
#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)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

struct _ValaCCodeMethodModulePrivate {
	gboolean ellipses_to_valist;
};

static gint ValaCCodeMethodModule_private_offset;
static gpointer vala_ccode_method_module_parent_class = NULL;

static gboolean vala_ccode_method_module_real_method_has_wrapper (ValaCCodeBaseModule* base,
                                                           ValaMethod* method);
static gchar* vala_ccode_method_module_get_creturn_type (ValaCCodeMethodModule* self,
                                                  ValaMethod* m,
                                                  const gchar* default_value);
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 void 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);
G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_new (ValaDataType* value_type,
                                    ValaCCodeExpression* cvalue,
                                    gboolean lvalue);
G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_construct (GType object_type,
                                          ValaDataType* value_type,
                                          ValaCCodeExpression* cvalue,
                                          gboolean lvalue);
G_GNUC_INTERNAL GType vala_glib_value_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (ValaGLibValue, vala_target_value_unref)
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,
                                                             ValaCodeNode* method_node,
                                                             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 inline gpointer
vala_ccode_method_module_get_instance_private (ValaCCodeMethodModule* self)
{
	return G_STRUCT_MEMBER_P (self, ValaCCodeMethodModule_private_offset);
}

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

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 = NULL;
	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 = FALSE;
	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 gpointer
_vala_iterable_ref0 (gpointer self)
{
	return self ? vala_iterable_ref (self) : NULL;
}

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_;
	ValaDataType* _tmp2_;
	ValaDataType* _tmp12_;
	gchar* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
	gchar* _tmp16_;
	ValaDataType* _tmp17_;
	ValaDataType* _tmp18_;
	ValaDataType* _tmp19_;
	ValaDataType* _tmp20_;
	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_callable_get_return_type ((ValaCallable*) m);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (_tmp1_);
	creturn_type = _tmp2_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (m, VALA_TYPE_CREATION_METHOD)) {
		ValaClass* cl = NULL;
		ValaSymbol* _tmp3_;
		ValaSymbol* _tmp4_;
		ValaClass* _tmp5_;
		ValaClass* _tmp6_;
		_tmp3_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
		_tmp4_ = _tmp3_;
		_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp4_) : NULL);
		cl = _tmp5_;
		_tmp6_ = cl;
		if (_tmp6_ != NULL) {
			ValaClass* _tmp7_;
			ValaObjectType* _tmp8_;
			_tmp7_ = cl;
			_tmp8_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp7_);
			_vala_code_node_unref0 (creturn_type);
			creturn_type = (ValaDataType*) _tmp8_;
		}
		_vala_code_node_unref0 (cl);
	} else {
		ValaDataType* _tmp9_;
		ValaDataType* _tmp10_;
		_tmp9_ = vala_callable_get_return_type ((ValaCallable*) m);
		_tmp10_ = _tmp9_;
		if (vala_data_type_is_real_non_null_struct_type (_tmp10_)) {
			ValaVoidType* _tmp11_;
			_tmp11_ = vala_void_type_new (NULL);
			_vala_code_node_unref0 (creturn_type);
			creturn_type = (ValaDataType*) _tmp11_;
		}
	}
	_tmp12_ = creturn_type;
	_tmp13_ = vala_get_ccode_name ((ValaCodeNode*) _tmp12_);
	_tmp14_ = _tmp13_;
	_tmp15_ = vala_ccode_method_module_get_creturn_type (self, m, _tmp14_);
	_tmp16_ = _tmp15_;
	vala_ccode_function_set_return_type (cfunc, _tmp16_);
	_g_free0 (_tmp16_);
	_g_free0 (_tmp14_);
	_tmp17_ = vala_callable_get_return_type ((ValaCallable*) m);
	_tmp18_ = _tmp17_;
	vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp18_, decl_space);
	_tmp19_ = vala_callable_get_return_type ((ValaCallable*) m);
	_tmp20_ = _tmp19_;
	if (vala_data_type_is_real_non_null_struct_type (_tmp20_)) {
		ValaCCodeParameter* cparam = NULL;
		ValaDataType* _tmp21_;
		ValaDataType* _tmp22_;
		gchar* _tmp23_;
		gchar* _tmp24_;
		gchar* _tmp25_;
		gchar* _tmp26_;
		ValaCCodeParameter* _tmp27_;
		ValaCCodeParameter* _tmp28_;
		ValaCCodeParameter* _tmp29_;
		_tmp21_ = vala_callable_get_return_type ((ValaCallable*) m);
		_tmp22_ = _tmp21_;
		_tmp23_ = vala_get_ccode_name ((ValaCodeNode*) _tmp22_);
		_tmp24_ = _tmp23_;
		_tmp25_ = g_strconcat (_tmp24_, "*", NULL);
		_tmp26_ = _tmp25_;
		_tmp27_ = vala_ccode_parameter_new ("result", _tmp26_);
		_tmp28_ = _tmp27_;
		_g_free0 (_tmp26_);
		_g_free0 (_tmp24_);
		cparam = _tmp28_;
		_tmp29_ = cparam;
		vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE)), _tmp29_);
		if (carg_map != NULL) {
			ValaCCodeExpression* _tmp30_;
			ValaCCodeExpression* _tmp31_;
			_tmp30_ = vala_ccode_base_module_get_cexpression ((ValaCCodeBaseModule*) self, "result");
			_tmp31_ = _tmp30_;
			vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE)), _tmp31_);
			_vala_ccode_node_unref0 (_tmp31_);
		}
		_vala_ccode_node_unref0 (cparam);
	} else {
		gboolean _tmp32_ = FALSE;
		if (vala_get_ccode_array_length ((ValaCodeNode*) m)) {
			ValaDataType* _tmp33_;
			ValaDataType* _tmp34_;
			_tmp33_ = vala_callable_get_return_type ((ValaCallable*) m);
			_tmp34_ = _tmp33_;
			_tmp32_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp34_, VALA_TYPE_ARRAY_TYPE);
		} else {
			_tmp32_ = FALSE;
		}
		if (_tmp32_) {
			ValaArrayType* array_type = NULL;
			ValaDataType* _tmp35_;
			ValaDataType* _tmp36_;
			ValaArrayType* _tmp37_;
			gchar* _tmp38_ = NULL;
			gchar* _tmp39_;
			gchar* length_ctype = NULL;
			gchar* _tmp42_;
			_tmp35_ = vala_callable_get_return_type ((ValaCallable*) m);
			_tmp36_ = _tmp35_;
			_tmp37_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp36_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			array_type = _tmp37_;
			_tmp39_ = vala_get_ccode_array_length_type ((ValaCodeNode*) m);
			_tmp38_ = _tmp39_;
			if (_tmp38_ == NULL) {
				ValaArrayType* _tmp40_;
				gchar* _tmp41_;
				_tmp40_ = array_type;
				_tmp41_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp40_);
				_g_free0 (_tmp38_);
				_tmp38_ = _tmp41_;
			}
			_tmp42_ = g_strconcat (_tmp38_, "*", NULL);
			length_ctype = _tmp42_;
			{
				gint dim = 0;
				dim = 1;
				{
					gboolean _tmp43_ = FALSE;
					_tmp43_ = TRUE;
					while (TRUE) {
						ValaArrayType* _tmp45_;
						gint _tmp46_;
						gint _tmp47_;
						ValaCCodeParameter* cparam = NULL;
						gchar* _tmp48_;
						gchar* _tmp49_;
						const gchar* _tmp50_;
						ValaCCodeParameter* _tmp51_;
						ValaCCodeParameter* _tmp52_;
						ValaCCodeParameter* _tmp53_;
						if (!_tmp43_) {
							gint _tmp44_;
							_tmp44_ = dim;
							dim = _tmp44_ + 1;
						}
						_tmp43_ = FALSE;
						_tmp45_ = array_type;
						_tmp46_ = vala_array_type_get_rank (_tmp45_);
						_tmp47_ = _tmp46_;
						if (!(dim <= _tmp47_)) {
							break;
						}
						_tmp48_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", dim);
						_tmp49_ = _tmp48_;
						_tmp50_ = length_ctype;
						_tmp51_ = vala_ccode_parameter_new (_tmp49_, _tmp50_);
						_tmp52_ = _tmp51_;
						_g_free0 (_tmp49_);
						cparam = _tmp52_;
						_tmp53_ = 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)), _tmp53_);
						if (carg_map != NULL) {
							ValaCCodeParameter* _tmp54_;
							const gchar* _tmp55_;
							const gchar* _tmp56_;
							ValaCCodeExpression* _tmp57_;
							ValaCCodeExpression* _tmp58_;
							_tmp54_ = cparam;
							_tmp55_ = vala_ccode_parameter_get_name (_tmp54_);
							_tmp56_ = _tmp55_;
							_tmp57_ = vala_ccode_base_module_get_cexpression ((ValaCCodeBaseModule*) self, _tmp56_);
							_tmp58_ = _tmp57_;
							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)), _tmp58_);
							_vala_ccode_node_unref0 (_tmp58_);
						}
						_vala_ccode_node_unref0 (cparam);
					}
				}
			}
			_g_free0 (length_ctype);
			_g_free0 (_tmp38_);
			_vala_code_node_unref0 (array_type);
		} else {
			ValaDataType* _tmp59_;
			ValaDataType* _tmp60_;
			_tmp59_ = vala_callable_get_return_type ((ValaCallable*) m);
			_tmp60_ = _tmp59_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp60_, VALA_TYPE_DELEGATE_TYPE)) {
				ValaDelegateType* deleg_type = NULL;
				ValaDataType* _tmp61_;
				ValaDataType* _tmp62_;
				ValaDelegateType* _tmp63_;
				ValaDelegateType* _tmp64_;
				ValaDelegate* _tmp65_;
				ValaDelegate* _tmp66_;
				gboolean _tmp67_;
				gboolean _tmp68_;
				_tmp61_ = vala_callable_get_return_type ((ValaCallable*) m);
				_tmp62_ = _tmp61_;
				_tmp63_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp62_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
				deleg_type = _tmp63_;
				_tmp64_ = deleg_type;
				_tmp65_ = vala_delegate_type_get_delegate_symbol (_tmp64_);
				_tmp66_ = _tmp65_;
				_tmp67_ = vala_delegate_get_has_target (_tmp66_);
				_tmp68_ = _tmp67_;
				if (_tmp68_) {
					ValaCCodeParameter* cparam = NULL;
					gchar* _tmp69_;
					gchar* _tmp70_;
					ValaDataType* _tmp71_;
					gchar* _tmp72_;
					gchar* _tmp73_;
					gchar* _tmp74_;
					gchar* _tmp75_;
					ValaCCodeParameter* _tmp76_;
					ValaCCodeParameter* _tmp77_;
					ValaCCodeParameter* _tmp78_;
					ValaDelegateType* _tmp84_;
					_tmp69_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, "result");
					_tmp70_ = _tmp69_;
					_tmp71_ = ((ValaCCodeBaseModule*) self)->delegate_target_type;
					_tmp72_ = vala_get_ccode_name ((ValaCodeNode*) _tmp71_);
					_tmp73_ = _tmp72_;
					_tmp74_ = g_strconcat (_tmp73_, "*", NULL);
					_tmp75_ = _tmp74_;
					_tmp76_ = vala_ccode_parameter_new (_tmp70_, _tmp75_);
					_tmp77_ = _tmp76_;
					_g_free0 (_tmp75_);
					_g_free0 (_tmp73_);
					_g_free0 (_tmp70_);
					cparam = _tmp77_;
					_tmp78_ = 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)), _tmp78_);
					if (carg_map != NULL) {
						ValaCCodeParameter* _tmp79_;
						const gchar* _tmp80_;
						const gchar* _tmp81_;
						ValaCCodeExpression* _tmp82_;
						ValaCCodeExpression* _tmp83_;
						_tmp79_ = cparam;
						_tmp80_ = vala_ccode_parameter_get_name (_tmp79_);
						_tmp81_ = _tmp80_;
						_tmp82_ = vala_ccode_base_module_get_cexpression ((ValaCCodeBaseModule*) self, _tmp81_);
						_tmp83_ = _tmp82_;
						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)), _tmp83_);
						_vala_ccode_node_unref0 (_tmp83_);
					}
					_tmp84_ = deleg_type;
					if (vala_data_type_is_disposable ((ValaDataType*) _tmp84_)) {
						gchar* _tmp85_;
						gchar* _tmp86_;
						ValaDelegateType* _tmp87_;
						gchar* _tmp88_;
						gchar* _tmp89_;
						gchar* _tmp90_;
						gchar* _tmp91_;
						ValaCCodeParameter* _tmp92_;
						ValaCCodeParameter* _tmp93_;
						_tmp85_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, "result");
						_tmp86_ = _tmp85_;
						_tmp87_ = ((ValaCCodeBaseModule*) self)->delegate_target_destroy_type;
						_tmp88_ = vala_get_ccode_name ((ValaCodeNode*) _tmp87_);
						_tmp89_ = _tmp88_;
						_tmp90_ = g_strconcat (_tmp89_, "*", NULL);
						_tmp91_ = _tmp90_;
						_tmp92_ = vala_ccode_parameter_new (_tmp86_, _tmp91_);
						_vala_ccode_node_unref0 (cparam);
						cparam = _tmp92_;
						_g_free0 (_tmp91_);
						_g_free0 (_tmp89_);
						_g_free0 (_tmp86_);
						_tmp93_ = 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) + 0.01, FALSE)), _tmp93_);
						if (carg_map != NULL) {
							ValaCCodeParameter* _tmp94_;
							const gchar* _tmp95_;
							const gchar* _tmp96_;
							ValaCCodeExpression* _tmp97_;
							ValaCCodeExpression* _tmp98_;
							_tmp94_ = cparam;
							_tmp95_ = vala_ccode_parameter_get_name (_tmp94_);
							_tmp96_ = _tmp95_;
							_tmp97_ = vala_ccode_base_module_get_cexpression ((ValaCCodeBaseModule*) self, _tmp96_);
							_tmp98_ = _tmp97_;
							vala_map_set (carg_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) m) + 0.01, FALSE)), _tmp98_);
							_vala_ccode_node_unref0 (_tmp98_);
						}
					}
					_vala_ccode_node_unref0 (cparam);
				}
				_vala_code_node_unref0 (deleg_type);
			}
		}
	}
	if (vala_method_has_error_type_parameter (m)) {
		ValaArrayList* error_types = NULL;
		GEqualFunc _tmp99_;
		ValaArrayList* _tmp100_;
		ValaArrayList* _tmp101_;
		ValaCCodeParameter* cparam = NULL;
		ValaCCodeParameter* _tmp110_;
		ValaCCodeParameter* _tmp111_;
		_tmp99_ = g_direct_equal;
		_tmp100_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp99_);
		error_types = _tmp100_;
		_tmp101_ = error_types;
		vala_code_node_get_error_types ((ValaCodeNode*) m, (ValaCollection*) _tmp101_, NULL);
		{
			ValaArrayList* _error_type_list = NULL;
			ValaArrayList* _tmp102_;
			ValaArrayList* _tmp103_;
			gint _error_type_size = 0;
			ValaArrayList* _tmp104_;
			gint _tmp105_;
			gint _tmp106_;
			gint _error_type_index = 0;
			_tmp102_ = error_types;
			_tmp103_ = _vala_iterable_ref0 (_tmp102_);
			_error_type_list = _tmp103_;
			_tmp104_ = _error_type_list;
			_tmp105_ = vala_collection_get_size ((ValaCollection*) _tmp104_);
			_tmp106_ = _tmp105_;
			_error_type_size = _tmp106_;
			_error_type_index = -1;
			while (TRUE) {
				ValaDataType* error_type = NULL;
				ValaArrayList* _tmp107_;
				gpointer _tmp108_;
				ValaDataType* _tmp109_;
				_error_type_index = _error_type_index + 1;
				if (!(_error_type_index < _error_type_size)) {
					break;
				}
				_tmp107_ = _error_type_list;
				_tmp108_ = vala_list_get ((ValaList*) _tmp107_, _error_type_index);
				error_type = (ValaDataType*) _tmp108_;
				_tmp109_ = error_type;
				vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp109_, decl_space);
				_vala_code_node_unref0 (error_type);
			}
			_vala_iterable_unref0 (_error_type_list);
		}
		_tmp110_ = vala_ccode_parameter_new ("error", "GError**");
		cparam = _tmp110_;
		_tmp111_ = 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)), _tmp111_);
		if (carg_map != NULL) {
			ValaCCodeParameter* _tmp112_;
			const gchar* _tmp113_;
			const gchar* _tmp114_;
			ValaCCodeIdentifier* _tmp115_;
			ValaCCodeIdentifier* _tmp116_;
			_tmp112_ = cparam;
			_tmp113_ = vala_ccode_parameter_get_name (_tmp112_);
			_tmp114_ = _tmp113_;
			_tmp115_ = vala_ccode_identifier_new (_tmp114_);
			_tmp116_ = _tmp115_;
			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*) _tmp116_);
			_vala_ccode_node_unref0 (_tmp116_);
		}
		_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)
{
	g_return_if_fail (self != NULL);
	VALA_CCODE_METHOD_MODULE_GET_CLASS (self)->generate_method_result_declaration (self, m, decl_space, cfunc, cparam_map, carg_map);
}

void
vala_ccode_method_module_complete_async (ValaCCodeMethodModule* self)
{
	ValaCCodeIdentifier* data_var = NULL;
	ValaCCodeIdentifier* _tmp0_;
	ValaCCodeMemberAccess* async_result_expr = NULL;
	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 void
vala_ccode_method_module_real_generate_method_declaration (ValaCCodeBaseModule* base,
                                                           ValaMethod* m,
                                                           ValaCCodeFile* decl_space)
{
	ValaCCodeMethodModule * self;
	gboolean _tmp0_;
	gboolean _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gboolean _tmp4_;
	ValaMethodType* _tmp5_;
	ValaMethodType* _tmp6_;
	ValaCCodeFunction* function = NULL;
	gchar* _tmp7_;
	gchar* _tmp8_;
	ValaCCodeFunction* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	gboolean _tmp11_ = FALSE;
	ValaVersionAttribute* _tmp36_;
	ValaVersionAttribute* _tmp37_;
	gboolean _tmp38_;
	gboolean _tmp39_;
	ValaHashMap* cparam_map = NULL;
	GHashFunc _tmp44_;
	GEqualFunc _tmp45_;
	GEqualFunc _tmp46_;
	ValaHashMap* _tmp47_;
	ValaHashMap* carg_map = NULL;
	GHashFunc _tmp48_;
	GEqualFunc _tmp49_;
	GEqualFunc _tmp50_;
	ValaHashMap* _tmp51_;
	ValaClass* cl = NULL;
	ValaSymbol* _tmp52_;
	ValaSymbol* _tmp53_;
	ValaClass* _tmp54_;
	gboolean _tmp55_ = FALSE;
	gboolean _tmp56_ = FALSE;
	gboolean _tmp57_ = FALSE;
	self = (ValaCCodeMethodModule*) base;
	g_return_if_fail (m != NULL);
	g_return_if_fail (decl_space != NULL);
	_tmp0_ = vala_method_get_is_async_callback (m);
	_tmp1_ = _tmp0_;
	if (_tmp1_) {
		return;
	}
	_tmp2_ = vala_get_ccode_name ((ValaCodeNode*) m);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_base_module_add_symbol_declaration ((ValaCCodeBaseModule*) self, decl_space, (ValaSymbol*) m, _tmp3_);
	_g_free0 (_tmp3_);
	if (_tmp4_) {
		return;
	}
	_tmp5_ = vala_method_type_new (m);
	_tmp6_ = _tmp5_;
	vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp6_, decl_space);
	_vala_code_node_unref0 (_tmp6_);
	_tmp7_ = vala_get_ccode_name ((ValaCodeNode*) m);
	_tmp8_ = _tmp7_;
	_tmp9_ = vala_ccode_function_new (_tmp8_, "void");
	_tmp10_ = _tmp9_;
	_g_free0 (_tmp8_);
	function = _tmp10_;
	if (vala_symbol_is_private_symbol ((ValaSymbol*) m)) {
		gboolean _tmp12_;
		gboolean _tmp13_;
		_tmp12_ = vala_symbol_get_external ((ValaSymbol*) m);
		_tmp13_ = _tmp12_;
		_tmp11_ = !_tmp13_;
	} else {
		_tmp11_ = FALSE;
	}
	if (_tmp11_) {
		ValaCCodeFunction* _tmp14_;
		ValaCCodeFunction* _tmp15_;
		ValaCCodeModifiers _tmp16_;
		ValaCCodeModifiers _tmp17_;
		gboolean _tmp18_;
		gboolean _tmp19_;
		_tmp14_ = function;
		_tmp15_ = function;
		_tmp16_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp15_);
		_tmp17_ = _tmp16_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp15_, _tmp17_ | VALA_CCODE_MODIFIERS_STATIC);
		_tmp18_ = vala_method_get_is_inline (m);
		_tmp19_ = _tmp18_;
		if (_tmp19_) {
			ValaCCodeFunction* _tmp20_;
			ValaCCodeFunction* _tmp21_;
			ValaCCodeModifiers _tmp22_;
			ValaCCodeModifiers _tmp23_;
			_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_INLINE);
		}
	} else {
		gboolean _tmp24_ = FALSE;
		gboolean _tmp25_ = FALSE;
		ValaCodeContext* _tmp26_;
		ValaCodeContext* _tmp27_;
		gboolean _tmp28_;
		gboolean _tmp29_;
		_tmp26_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
		_tmp27_ = _tmp26_;
		_tmp28_ = vala_code_context_get_hide_internal (_tmp27_);
		_tmp29_ = _tmp28_;
		if (_tmp29_) {
			_tmp25_ = vala_symbol_is_internal_symbol ((ValaSymbol*) m);
		} else {
			_tmp25_ = FALSE;
		}
		if (_tmp25_) {
			gboolean _tmp30_;
			gboolean _tmp31_;
			_tmp30_ = vala_symbol_get_external ((ValaSymbol*) m);
			_tmp31_ = _tmp30_;
			_tmp24_ = !_tmp31_;
		} else {
			_tmp24_ = FALSE;
		}
		if (_tmp24_) {
			ValaCCodeFunction* _tmp32_;
			ValaCCodeFunction* _tmp33_;
			ValaCCodeModifiers _tmp34_;
			ValaCCodeModifiers _tmp35_;
			_tmp32_ = function;
			_tmp33_ = function;
			_tmp34_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp33_);
			_tmp35_ = _tmp34_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp33_, _tmp35_ | VALA_CCODE_MODIFIERS_INTERNAL);
		}
	}
	_tmp36_ = vala_symbol_get_version ((ValaSymbol*) m);
	_tmp37_ = _tmp36_;
	_tmp38_ = vala_version_attribute_get_deprecated (_tmp37_);
	_tmp39_ = _tmp38_;
	if (_tmp39_) {
		ValaCCodeFunction* _tmp40_;
		ValaCCodeFunction* _tmp41_;
		ValaCCodeModifiers _tmp42_;
		ValaCCodeModifiers _tmp43_;
		_tmp40_ = function;
		_tmp41_ = function;
		_tmp42_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp41_);
		_tmp43_ = _tmp42_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp41_, _tmp43_ | VALA_CCODE_MODIFIERS_DEPRECATED);
	}
	_tmp44_ = g_direct_hash;
	_tmp45_ = g_direct_equal;
	_tmp46_ = g_direct_equal;
	_tmp47_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp44_, _tmp45_, _tmp46_);
	cparam_map = _tmp47_;
	_tmp48_ = g_direct_hash;
	_tmp49_ = g_direct_equal;
	_tmp50_ = g_direct_equal;
	_tmp51_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp48_, _tmp49_, _tmp50_);
	carg_map = _tmp51_;
	_tmp52_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
	_tmp53_ = _tmp52_;
	_tmp54_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp53_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp53_) : NULL);
	cl = _tmp54_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (m, VALA_TYPE_CREATION_METHOD)) {
		ValaClass* _tmp58_;
		_tmp58_ = cl;
		_tmp57_ = _tmp58_ != NULL;
	} else {
		_tmp57_ = FALSE;
	}
	if (_tmp57_) {
		ValaClass* _tmp59_;
		gboolean _tmp60_;
		gboolean _tmp61_;
		_tmp59_ = cl;
		_tmp60_ = vala_class_get_is_abstract (_tmp59_);
		_tmp61_ = _tmp60_;
		_tmp56_ = _tmp61_;
	} else {
		_tmp56_ = FALSE;
	}
	if (_tmp56_) {
		ValaClass* _tmp62_;
		gboolean _tmp63_;
		gboolean _tmp64_;
		_tmp62_ = cl;
		_tmp63_ = vala_class_get_is_compact (_tmp62_);
		_tmp64_ = _tmp63_;
		_tmp55_ = !_tmp64_;
	} else {
		_tmp55_ = FALSE;
	}
	if (!_tmp55_) {
		gboolean etv_tmp = FALSE;
		ValaHashMap* _tmp65_;
		ValaCCodeFunction* _tmp66_;
		ValaHashMap* _tmp67_;
		ValaCCodeIdentifier* _tmp68_;
		ValaCCodeIdentifier* _tmp69_;
		ValaCCodeFunctionCall* _tmp70_;
		ValaCCodeFunctionCall* _tmp71_;
		ValaCCodeFunction* _tmp72_;
		etv_tmp = self->priv->ellipses_to_valist;
		self->priv->ellipses_to_valist = FALSE;
		_tmp65_ = cparam_map;
		_tmp66_ = function;
		_tmp67_ = carg_map;
		_tmp68_ = vala_ccode_identifier_new ("fake");
		_tmp69_ = _tmp68_;
		_tmp70_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp69_);
		_tmp71_ = _tmp70_;
		vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, m, decl_space, (ValaMap*) _tmp65_, _tmp66_, NULL, (ValaMap*) _tmp67_, _tmp71_, 3);
		_vala_ccode_node_unref0 (_tmp71_);
		_vala_ccode_node_unref0 (_tmp69_);
		self->priv->ellipses_to_valist = etv_tmp;
		_tmp72_ = function;
		vala_ccode_file_add_function_declaration (decl_space, _tmp72_);
	}
	if (vala_ccode_method_module_is_gtypeinstance_creation_method (self, m)) {
		gchar* _tmp73_;
		gchar* _tmp74_;
		ValaCCodeFunction* _tmp75_;
		GHashFunc _tmp89_;
		GEqualFunc _tmp90_;
		GEqualFunc _tmp91_;
		ValaHashMap* _tmp92_;
		gboolean etv_tmp = FALSE;
		ValaHashMap* _tmp93_;
		ValaCCodeFunction* _tmp94_;
		ValaCCodeFunction* _tmp95_;
		_tmp73_ = vala_get_ccode_real_name ((ValaSymbol*) m);
		_tmp74_ = _tmp73_;
		_tmp75_ = vala_ccode_function_new (_tmp74_, "void");
		_vala_ccode_node_unref0 (function);
		function = _tmp75_;
		_g_free0 (_tmp74_);
		if (vala_symbol_is_private_symbol ((ValaSymbol*) m)) {
			ValaCCodeFunction* _tmp76_;
			ValaCCodeFunction* _tmp77_;
			ValaCCodeModifiers _tmp78_;
			ValaCCodeModifiers _tmp79_;
			_tmp76_ = function;
			_tmp77_ = function;
			_tmp78_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp77_);
			_tmp79_ = _tmp78_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp77_, _tmp79_ | VALA_CCODE_MODIFIERS_STATIC);
		} else {
			gboolean _tmp80_ = FALSE;
			ValaCodeContext* _tmp81_;
			ValaCodeContext* _tmp82_;
			gboolean _tmp83_;
			gboolean _tmp84_;
			_tmp81_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
			_tmp82_ = _tmp81_;
			_tmp83_ = vala_code_context_get_hide_internal (_tmp82_);
			_tmp84_ = _tmp83_;
			if (_tmp84_) {
				_tmp80_ = vala_symbol_is_internal_symbol ((ValaSymbol*) m);
			} else {
				_tmp80_ = FALSE;
			}
			if (_tmp80_) {
				ValaCCodeFunction* _tmp85_;
				ValaCCodeFunction* _tmp86_;
				ValaCCodeModifiers _tmp87_;
				ValaCCodeModifiers _tmp88_;
				_tmp85_ = function;
				_tmp86_ = function;
				_tmp87_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp86_);
				_tmp88_ = _tmp87_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp86_, _tmp88_ | VALA_CCODE_MODIFIERS_INTERNAL);
			}
		}
		_tmp89_ = g_direct_hash;
		_tmp90_ = g_direct_equal;
		_tmp91_ = g_direct_equal;
		_tmp92_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp89_, _tmp90_, _tmp91_);
		_vala_map_unref0 (cparam_map);
		cparam_map = _tmp92_;
		etv_tmp = self->priv->ellipses_to_valist;
		self->priv->ellipses_to_valist = FALSE;
		_tmp93_ = cparam_map;
		_tmp94_ = function;
		vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, m, decl_space, (ValaMap*) _tmp93_, _tmp94_, NULL, NULL, NULL, 3);
		self->priv->ellipses_to_valist = etv_tmp;
		_tmp95_ = function;
		vala_ccode_file_add_function_declaration (decl_space, _tmp95_);
		if (vala_method_is_variadic (m)) {
			gchar* _tmp96_;
			gchar* _tmp97_;
			ValaCCodeFunction* _tmp98_;
			GHashFunc _tmp99_;
			GEqualFunc _tmp100_;
			GEqualFunc _tmp101_;
			ValaHashMap* _tmp102_;
			ValaHashMap* _tmp103_;
			ValaCCodeFunction* _tmp104_;
			ValaCCodeFunction* _tmp105_;
			_tmp96_ = vala_get_ccode_constructv_name (G_TYPE_CHECK_INSTANCE_CAST (m, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
			_tmp97_ = _tmp96_;
			_tmp98_ = vala_ccode_function_new (_tmp97_, "void");
			_vala_ccode_node_unref0 (function);
			function = _tmp98_;
			_g_free0 (_tmp97_);
			_tmp99_ = g_direct_hash;
			_tmp100_ = g_direct_equal;
			_tmp101_ = g_direct_equal;
			_tmp102_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp99_, _tmp100_, _tmp101_);
			_vala_map_unref0 (cparam_map);
			cparam_map = _tmp102_;
			_tmp103_ = cparam_map;
			_tmp104_ = function;
			vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, m, decl_space, (ValaMap*) _tmp103_, _tmp104_, NULL, NULL, NULL, 3);
			_tmp105_ = function;
			vala_ccode_file_add_function_declaration (decl_space, _tmp105_);
		}
	}
	_vala_code_node_unref0 (cl);
	_vala_map_unref0 (carg_map);
	_vala_map_unref0 (cparam_map);
	_vala_ccode_node_unref0 (function);
}

static void
vala_ccode_method_module_register_plugin_types (ValaCCodeMethodModule* self,
                                                ValaSymbol* sym,
                                                ValaSet* registered_types)
{
	ValaNamespace* ns = NULL;
	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) {
				ValaNamespace* ns_ns = NULL;
				ValaList* _tmp9_;
				gpointer _tmp10_;
				ValaNamespace* _tmp11_;
				_ns_ns_index = _ns_ns_index + 1;
				if (!(_ns_ns_index < _ns_ns_size)) {
					break;
				}
				_tmp9_ = _ns_ns_list;
				_tmp10_ = vala_list_get (_tmp9_, _ns_ns_index);
				ns_ns = (ValaNamespace*) _tmp10_;
				_tmp11_ = ns_ns;
				vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp11_, registered_types);
				_vala_code_node_unref0 (ns_ns);
			}
			_vala_iterable_unref0 (_ns_ns_list);
		}
		{
			ValaList* _ns_cl_list = NULL;
			ValaNamespace* _tmp12_;
			ValaList* _tmp13_;
			gint _ns_cl_size = 0;
			ValaList* _tmp14_;
			gint _tmp15_;
			gint _tmp16_;
			gint _ns_cl_index = 0;
			_tmp12_ = ns;
			_tmp13_ = vala_namespace_get_classes (_tmp12_);
			_ns_cl_list = _tmp13_;
			_tmp14_ = _ns_cl_list;
			_tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);
			_tmp16_ = _tmp15_;
			_ns_cl_size = _tmp16_;
			_ns_cl_index = -1;
			while (TRUE) {
				ValaClass* ns_cl = NULL;
				ValaList* _tmp17_;
				gpointer _tmp18_;
				ValaClass* _tmp19_;
				_ns_cl_index = _ns_cl_index + 1;
				if (!(_ns_cl_index < _ns_cl_size)) {
					break;
				}
				_tmp17_ = _ns_cl_list;
				_tmp18_ = vala_list_get (_tmp17_, _ns_cl_index);
				ns_cl = (ValaClass*) _tmp18_;
				_tmp19_ = ns_cl;
				vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp19_, registered_types);
				_vala_code_node_unref0 (ns_cl);
			}
			_vala_iterable_unref0 (_ns_cl_list);
		}
		{
			ValaList* _ns_iface_list = NULL;
			ValaNamespace* _tmp20_;
			ValaList* _tmp21_;
			gint _ns_iface_size = 0;
			ValaList* _tmp22_;
			gint _tmp23_;
			gint _tmp24_;
			gint _ns_iface_index = 0;
			_tmp20_ = ns;
			_tmp21_ = vala_namespace_get_interfaces (_tmp20_);
			_ns_iface_list = _tmp21_;
			_tmp22_ = _ns_iface_list;
			_tmp23_ = vala_collection_get_size ((ValaCollection*) _tmp22_);
			_tmp24_ = _tmp23_;
			_ns_iface_size = _tmp24_;
			_ns_iface_index = -1;
			while (TRUE) {
				ValaInterface* ns_iface = NULL;
				ValaList* _tmp25_;
				gpointer _tmp26_;
				ValaInterface* _tmp27_;
				_ns_iface_index = _ns_iface_index + 1;
				if (!(_ns_iface_index < _ns_iface_size)) {
					break;
				}
				_tmp25_ = _ns_iface_list;
				_tmp26_ = vala_list_get (_tmp25_, _ns_iface_index);
				ns_iface = (ValaInterface*) _tmp26_;
				_tmp27_ = ns_iface;
				vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp27_, registered_types);
				_vala_code_node_unref0 (ns_iface);
			}
			_vala_iterable_unref0 (_ns_iface_list);
		}
	} else {
		ValaClass* _tmp28_;
		_tmp28_ = cl;
		if (_tmp28_ != NULL) {
			ValaClass* _tmp29_;
			_tmp29_ = cl;
			vala_ccode_method_module_register_plugin_type (self, (ValaObjectTypeSymbol*) _tmp29_, registered_types);
			{
				ValaList* _cl_cl_list = NULL;
				ValaClass* _tmp30_;
				ValaList* _tmp31_;
				gint _cl_cl_size = 0;
				ValaList* _tmp32_;
				gint _tmp33_;
				gint _tmp34_;
				gint _cl_cl_index = 0;
				_tmp30_ = cl;
				_tmp31_ = vala_object_type_symbol_get_classes ((ValaObjectTypeSymbol*) _tmp30_);
				_cl_cl_list = _tmp31_;
				_tmp32_ = _cl_cl_list;
				_tmp33_ = vala_collection_get_size ((ValaCollection*) _tmp32_);
				_tmp34_ = _tmp33_;
				_cl_cl_size = _tmp34_;
				_cl_cl_index = -1;
				while (TRUE) {
					ValaClass* cl_cl = NULL;
					ValaList* _tmp35_;
					gpointer _tmp36_;
					ValaClass* _tmp37_;
					_cl_cl_index = _cl_cl_index + 1;
					if (!(_cl_cl_index < _cl_cl_size)) {
						break;
					}
					_tmp35_ = _cl_cl_list;
					_tmp36_ = vala_list_get (_tmp35_, _cl_cl_index);
					cl_cl = (ValaClass*) _tmp36_;
					_tmp37_ = cl_cl;
					vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp37_, registered_types);
					_vala_code_node_unref0 (cl_cl);
				}
				_vala_iterable_unref0 (_cl_cl_list);
			}
		} else {
			ValaInterface* _tmp38_;
			_tmp38_ = iface;
			if (_tmp38_ != NULL) {
				ValaInterface* _tmp39_;
				_tmp39_ = iface;
				vala_ccode_method_module_register_plugin_type (self, (ValaObjectTypeSymbol*) _tmp39_, registered_types);
				{
					ValaList* _iface_cl_list = NULL;
					ValaInterface* _tmp40_;
					ValaList* _tmp41_;
					gint _iface_cl_size = 0;
					ValaList* _tmp42_;
					gint _tmp43_;
					gint _tmp44_;
					gint _iface_cl_index = 0;
					_tmp40_ = iface;
					_tmp41_ = vala_object_type_symbol_get_classes ((ValaObjectTypeSymbol*) _tmp40_);
					_iface_cl_list = _tmp41_;
					_tmp42_ = _iface_cl_list;
					_tmp43_ = vala_collection_get_size ((ValaCollection*) _tmp42_);
					_tmp44_ = _tmp43_;
					_iface_cl_size = _tmp44_;
					_iface_cl_index = -1;
					while (TRUE) {
						ValaClass* iface_cl = NULL;
						ValaList* _tmp45_;
						gpointer _tmp46_;
						ValaClass* _tmp47_;
						_iface_cl_index = _iface_cl_index + 1;
						if (!(_iface_cl_index < _iface_cl_size)) {
							break;
						}
						_tmp45_ = _iface_cl_list;
						_tmp46_ = vala_list_get (_tmp45_, _iface_cl_index);
						iface_cl = (ValaClass*) _tmp46_;
						_tmp47_ = iface_cl;
						vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp47_, registered_types);
						_vala_code_node_unref0 (iface_cl);
					}
					_vala_iterable_unref0 (_iface_cl_list);
				}
			}
		}
	}
	_vala_code_node_unref0 (iface);
	_vala_code_node_unref0 (cl);
	_vala_code_node_unref0 (ns);
}

static void
vala_ccode_method_module_register_plugin_type (ValaCCodeMethodModule* self,
                                               ValaObjectTypeSymbol* type_symbol,
                                               ValaSet* registered_types)
{
	gboolean _tmp0_;
	gboolean _tmp1_;
	ValaClass* cl = NULL;
	ValaClass* _tmp2_;
	ValaClass* _tmp3_;
	ValaSourceReference* _tmp17_;
	ValaSourceReference* _tmp18_;
	ValaSourceFile* _tmp19_;
	ValaSourceFile* _tmp20_;
	ValaCCodeFile* _tmp21_;
	ValaSourceFile* _tmp22_;
	ValaSourceFile* _tmp23_;
	ValaCCodeFunctionCall* register_call = NULL;
	gchar* _tmp36_;
	gchar* _tmp37_;
	gchar* _tmp38_;
	gchar* _tmp39_;
	ValaCCodeIdentifier* _tmp40_;
	ValaCCodeIdentifier* _tmp41_;
	ValaCCodeFunctionCall* _tmp42_;
	ValaCCodeFunctionCall* _tmp43_;
	ValaCCodeFunctionCall* _tmp44_;
	const gchar* _tmp45_;
	ValaCCodeIdentifier* _tmp46_;
	ValaCCodeIdentifier* _tmp47_;
	ValaCCodeFunction* _tmp48_;
	ValaCCodeFunction* _tmp49_;
	ValaCCodeFunctionCall* _tmp50_;
	ValaInterface* iface = NULL;
	ValaInterface* _tmp51_;
	ValaInterface* _tmp52_;
	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) {
				ValaDataType* base_type = NULL;
				ValaList* _tmp12_;
				gpointer _tmp13_;
				ValaDataType* _tmp14_;
				ValaTypeSymbol* _tmp15_;
				ValaTypeSymbol* _tmp16_;
				_base_type_index = _base_type_index + 1;
				if (!(_base_type_index < _base_type_size)) {
					break;
				}
				_tmp12_ = _base_type_list;
				_tmp13_ = vala_list_get (_tmp12_, _base_type_index);
				base_type = (ValaDataType*) _tmp13_;
				_tmp14_ = base_type;
				_tmp15_ = vala_data_type_get_data_type (_tmp14_);
				_tmp16_ = _tmp15_;
				vala_ccode_method_module_register_plugin_type (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp16_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol), registered_types);
				_vala_code_node_unref0 (base_type);
			}
			_vala_iterable_unref0 (_base_type_list);
		}
	}
	_tmp17_ = vala_code_node_get_source_reference ((ValaCodeNode*) type_symbol);
	_tmp18_ = _tmp17_;
	_tmp19_ = vala_source_reference_get_file (_tmp18_);
	_tmp20_ = _tmp19_;
	_tmp21_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp22_ = vala_ccode_file_get_file (_tmp21_);
	_tmp23_ = _tmp22_;
	if (_tmp20_ != _tmp23_) {
		ValaCCodeFunction* register_func = NULL;
		gchar* _tmp24_;
		gchar* _tmp25_;
		gchar* _tmp26_;
		gchar* _tmp27_;
		ValaCCodeFunction* _tmp28_;
		ValaCCodeFunction* _tmp29_;
		ValaCCodeFunction* _tmp30_;
		ValaCCodeParameter* _tmp31_;
		ValaCCodeParameter* _tmp32_;
		ValaCCodeFunction* _tmp33_;
		ValaCCodeFile* _tmp34_;
		ValaCCodeFunction* _tmp35_;
		_tmp24_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) type_symbol, NULL);
		_tmp25_ = _tmp24_;
		_tmp26_ = g_strdup_printf ("%s_register_type", _tmp25_);
		_tmp27_ = _tmp26_;
		_tmp28_ = vala_ccode_function_new (_tmp27_, "GType");
		_tmp29_ = _tmp28_;
		_g_free0 (_tmp27_);
		_g_free0 (_tmp25_);
		register_func = _tmp29_;
		_tmp30_ = register_func;
		_tmp31_ = vala_ccode_parameter_new ("module", "GTypeModule *");
		_tmp32_ = _tmp31_;
		vala_ccode_function_add_parameter (_tmp30_, _tmp32_);
		_vala_ccode_node_unref0 (_tmp32_);
		_tmp33_ = register_func;
		vala_ccode_function_set_is_declaration (_tmp33_, TRUE);
		_tmp34_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp35_ = register_func;
		vala_ccode_file_add_function_declaration (_tmp34_, _tmp35_);
		_vala_ccode_node_unref0 (register_func);
	}
	_tmp36_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) type_symbol, NULL);
	_tmp37_ = _tmp36_;
	_tmp38_ = g_strdup_printf ("%s_register_type", _tmp37_);
	_tmp39_ = _tmp38_;
	_tmp40_ = vala_ccode_identifier_new (_tmp39_);
	_tmp41_ = _tmp40_;
	_tmp42_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp41_);
	_tmp43_ = _tmp42_;
	_vala_ccode_node_unref0 (_tmp41_);
	_g_free0 (_tmp39_);
	_g_free0 (_tmp37_);
	register_call = _tmp43_;
	_tmp44_ = register_call;
	_tmp45_ = ((ValaCCodeBaseModule*) self)->module_init_param_name;
	_tmp46_ = vala_ccode_identifier_new (_tmp45_);
	_tmp47_ = _tmp46_;
	vala_ccode_function_call_add_argument (_tmp44_, (ValaCCodeExpression*) _tmp47_);
	_vala_ccode_node_unref0 (_tmp47_);
	_tmp48_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp49_ = _tmp48_;
	_tmp50_ = register_call;
	vala_ccode_function_add_expression (_tmp49_, (ValaCCodeExpression*) _tmp50_);
	_tmp51_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (type_symbol, VALA_TYPE_INTERFACE) ? ((ValaInterface*) type_symbol) : NULL);
	iface = _tmp51_;
	_tmp52_ = iface;
	if (_tmp52_ != NULL) {
		gchar* dbus_name = NULL;
		gchar* _tmp53_;
		const gchar* _tmp54_;
		_tmp53_ = vala_gd_bus_module_get_dbus_name ((ValaTypeSymbol*) type_symbol);
		dbus_name = _tmp53_;
		_tmp54_ = dbus_name;
		if (_tmp54_ != NULL) {
			gchar* proxy_cname = NULL;
			gchar* _tmp55_;
			gchar* _tmp56_;
			gchar* _tmp57_;
			gchar* _tmp58_;
			ValaCCodeFunctionCall* register_proxy = NULL;
			const gchar* _tmp59_;
			gchar* _tmp60_;
			gchar* _tmp61_;
			ValaCCodeIdentifier* _tmp62_;
			ValaCCodeIdentifier* _tmp63_;
			ValaCCodeFunctionCall* _tmp64_;
			ValaCCodeFunctionCall* _tmp65_;
			ValaCCodeFunctionCall* _tmp66_;
			const gchar* _tmp67_;
			ValaCCodeIdentifier* _tmp68_;
			ValaCCodeIdentifier* _tmp69_;
			ValaCCodeFunction* _tmp70_;
			ValaCCodeFunction* _tmp71_;
			ValaCCodeFunctionCall* _tmp72_;
			_tmp55_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) type_symbol);
			_tmp56_ = _tmp55_;
			_tmp57_ = g_strconcat (_tmp56_, "proxy", NULL);
			_tmp58_ = _tmp57_;
			_g_free0 (_tmp56_);
			proxy_cname = _tmp58_;
			_tmp59_ = proxy_cname;
			_tmp60_ = g_strdup_printf ("%s_register_dynamic_type", _tmp59_);
			_tmp61_ = _tmp60_;
			_tmp62_ = vala_ccode_identifier_new (_tmp61_);
			_tmp63_ = _tmp62_;
			_tmp64_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp63_);
			_tmp65_ = _tmp64_;
			_vala_ccode_node_unref0 (_tmp63_);
			_g_free0 (_tmp61_);
			register_proxy = _tmp65_;
			_tmp66_ = register_proxy;
			_tmp67_ = ((ValaCCodeBaseModule*) self)->module_init_param_name;
			_tmp68_ = vala_ccode_identifier_new (_tmp67_);
			_tmp69_ = _tmp68_;
			vala_ccode_function_call_add_argument (_tmp66_, (ValaCCodeExpression*) _tmp69_);
			_vala_ccode_node_unref0 (_tmp69_);
			_tmp70_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp71_ = _tmp70_;
			_tmp72_ = register_proxy;
			vala_ccode_function_add_expression (_tmp71_, (ValaCCodeExpression*) _tmp72_);
			_vala_ccode_node_unref0 (register_proxy);
			_g_free0 (proxy_cname);
		}
		_g_free0 (dbus_name);
	}
	_vala_code_node_unref0 (iface);
	_vala_ccode_node_unref0 (register_call);
	_vala_code_node_unref0 (cl);
}

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

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

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

static void
vala_ccode_method_module_real_generate_cparameters (ValaCCodeBaseModule* base,
                                                    ValaMethod* m,
                                                    ValaCCodeFile* decl_space,
                                                    ValaMap* cparam_map,
                                                    ValaCCodeFunction* func,
                                                    ValaCCodeFunctionDeclarator* vdeclarator,
                                                    ValaMap* carg_map,
                                                    ValaCCodeFunctionCall* vcall,
                                                    gint direction)
{
	ValaCCodeMethodModule * self;
	gboolean _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp212_ = FALSE;
	gboolean needs_format_arg = FALSE;
	ValaCCodeParameter* prev_cparam = NULL;
	gint last_pos = 0;
	gint min_pos = 0;
	gboolean _tmp256_;
	gboolean _tmp257_;
	ValaVersionAttribute* _tmp264_;
	ValaVersionAttribute* _tmp265_;
	gboolean _tmp266_;
	gboolean _tmp267_;
	self = (ValaCCodeMethodModule*) base;
	g_return_if_fail (m != NULL);
	g_return_if_fail (decl_space != NULL);
	g_return_if_fail (cparam_map != NULL);
	g_return_if_fail (func != NULL);
	_tmp0_ = vala_method_get_closure (m);
	_tmp1_ = _tmp0_;
	if (_tmp1_) {
		ValaBlock* closure_block = NULL;
		ValaBlock* _tmp2_;
		ValaBlock* _tmp3_;
		ValaBlock* _tmp4_;
		gint block_id = 0;
		ValaBlock* _tmp5_;
		ValaCCodeParameter* instance_param = NULL;
		gchar* _tmp6_;
		gchar* _tmp7_;
		gchar* _tmp8_;
		gchar* _tmp9_;
		ValaCCodeParameter* _tmp10_;
		ValaCCodeParameter* _tmp11_;
		ValaCCodeParameter* _tmp12_;
		_tmp2_ = vala_ccode_base_module_get_current_closure_block ((ValaCCodeBaseModule*) self);
		_tmp3_ = _tmp2_;
		_tmp4_ = _vala_code_node_ref0 (_tmp3_);
		closure_block = _tmp4_;
		_tmp5_ = closure_block;
		block_id = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp5_);
		_tmp6_ = g_strdup_printf ("_data%d_", block_id);
		_tmp7_ = _tmp6_;
		_tmp8_ = g_strdup_printf ("Block%dData*", block_id);
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_ccode_parameter_new (_tmp7_, _tmp9_);
		_tmp11_ = _tmp10_;
		_g_free0 (_tmp9_);
		_g_free0 (_tmp7_);
		instance_param = _tmp11_;
		_tmp12_ = instance_param;
		vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) m), FALSE)), _tmp12_);
		_vala_ccode_node_unref0 (instance_param);
		_vala_code_node_unref0 (closure_block);
	} else {
		gboolean _tmp13_ = FALSE;
		ValaSymbol* _tmp14_;
		ValaSymbol* _tmp15_;
		_tmp14_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
		_tmp15_ = _tmp14_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_CLASS)) {
			_tmp13_ = G_TYPE_CHECK_INSTANCE_TYPE (m, VALA_TYPE_CREATION_METHOD);
		} else {
			_tmp13_ = FALSE;
		}
		if (_tmp13_) {
			ValaClass* cl = NULL;
			ValaSymbol* _tmp16_;
			ValaSymbol* _tmp17_;
			ValaClass* _tmp18_;
			gboolean _tmp19_ = FALSE;
			gboolean _tmp20_ = FALSE;
			ValaClass* _tmp21_;
			gboolean _tmp22_;
			gboolean _tmp23_;
			_tmp16_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
			_tmp17_ = _tmp16_;
			_tmp18_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_CLASS, ValaClass));
			cl = _tmp18_;
			_tmp21_ = cl;
			_tmp22_ = vala_class_get_is_compact (_tmp21_);
			_tmp23_ = _tmp22_;
			if (!_tmp23_) {
				_tmp20_ = vcall == NULL;
			} else {
				_tmp20_ = FALSE;
			}
			if (_tmp20_) {
				_tmp19_ = (direction & 1) == 1;
			} else {
				_tmp19_ = FALSE;
			}
			if (_tmp19_) {
				ValaCCodeParameter* _tmp24_;
				ValaCCodeParameter* _tmp25_;
				_tmp24_ = vala_ccode_parameter_new ("object_type", "GType");
				_tmp25_ = _tmp24_;
				vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) m), FALSE)), _tmp25_);
				_vala_ccode_node_unref0 (_tmp25_);
			}
			_vala_code_node_unref0 (cl);
		} else {
			gboolean _tmp26_ = FALSE;
			ValaMemberBinding _tmp27_;
			ValaMemberBinding _tmp28_;
			_tmp27_ = vala_method_get_binding (m);
			_tmp28_ = _tmp27_;
			if (_tmp28_ == VALA_MEMBER_BINDING_INSTANCE) {
				gboolean _tmp29_ = FALSE;
				if (direction != 2) {
					_tmp29_ = TRUE;
				} else {
					_tmp29_ = vala_get_ccode_finish_instance ((ValaCodeNode*) m);
				}
				_tmp26_ = _tmp29_;
			} else {
				_tmp26_ = FALSE;
			}
			if (_tmp26_) {
				ValaDataType* this_type = NULL;
				ValaDataType* _tmp30_;
				ValaDataType* _tmp31_;
				ValaCCodeParameter* instance_param = NULL;
				gboolean _tmp32_ = FALSE;
				gboolean _tmp33_ = FALSE;
				ValaMethod* _tmp34_;
				ValaMethod* _tmp35_;
				ValaCCodeParameter* _tmp73_;
				_tmp30_ = vala_semantic_analyzer_get_this_type (m);
				this_type = _tmp30_;
				_tmp31_ = this_type;
				vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp31_, decl_space);
				instance_param = NULL;
				_tmp34_ = vala_method_get_base_interface_method (m);
				_tmp35_ = _tmp34_;
				if (_tmp35_ != NULL) {
					gboolean _tmp36_;
					gboolean _tmp37_;
					_tmp36_ = vala_method_get_is_abstract (m);
					_tmp37_ = _tmp36_;
					_tmp33_ = !_tmp37_;
				} else {
					_tmp33_ = FALSE;
				}
				if (_tmp33_) {
					gboolean _tmp38_;
					gboolean _tmp39_;
					_tmp38_ = vala_method_get_is_virtual (m);
					_tmp39_ = _tmp38_;
					_tmp32_ = !_tmp39_;
				} else {
					_tmp32_ = FALSE;
				}
				if (_tmp32_) {
					ValaObjectType* base_type = NULL;
					ValaMethod* _tmp40_;
					ValaMethod* _tmp41_;
					ValaSymbol* _tmp42_;
					ValaSymbol* _tmp43_;
					ValaObjectType* _tmp44_;
					ValaObjectType* _tmp45_;
					gchar* _tmp46_;
					gchar* _tmp47_;
					ValaCCodeParameter* _tmp48_;
					_tmp40_ = vala_method_get_base_interface_method (m);
					_tmp41_ = _tmp40_;
					_tmp42_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp41_);
					_tmp43_ = _tmp42_;
					_tmp44_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp43_, VALA_TYPE_INTERFACE, ValaInterface));
					base_type = _tmp44_;
					_tmp45_ = base_type;
					_tmp46_ = vala_get_ccode_name ((ValaCodeNode*) _tmp45_);
					_tmp47_ = _tmp46_;
					_tmp48_ = vala_ccode_parameter_new ("base", _tmp47_);
					_vala_ccode_node_unref0 (instance_param);
					instance_param = _tmp48_;
					_g_free0 (_tmp47_);
					_vala_code_node_unref0 (base_type);
				} else {
					gboolean _tmp49_;
					gboolean _tmp50_;
					_tmp49_ = vala_method_get_overrides (m);
					_tmp50_ = _tmp49_;
					if (_tmp50_) {
						ValaObjectType* base_type = NULL;
						ValaMethod* _tmp51_;
						ValaMethod* _tmp52_;
						ValaSymbol* _tmp53_;
						ValaSymbol* _tmp54_;
						ValaObjectType* _tmp55_;
						ValaObjectType* _tmp56_;
						gchar* _tmp57_;
						gchar* _tmp58_;
						ValaCCodeParameter* _tmp59_;
						_tmp51_ = vala_method_get_base_method (m);
						_tmp52_ = _tmp51_;
						_tmp53_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp52_);
						_tmp54_ = _tmp53_;
						_tmp55_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp54_, VALA_TYPE_CLASS, ValaClass));
						base_type = _tmp55_;
						_tmp56_ = base_type;
						_tmp57_ = vala_get_ccode_name ((ValaCodeNode*) _tmp56_);
						_tmp58_ = _tmp57_;
						_tmp59_ = vala_ccode_parameter_new ("base", _tmp58_);
						_vala_ccode_node_unref0 (instance_param);
						instance_param = _tmp59_;
						_g_free0 (_tmp58_);
						_vala_code_node_unref0 (base_type);
					} else {
						gboolean _tmp60_ = FALSE;
						ValaSymbol* _tmp61_;
						ValaSymbol* _tmp62_;
						_tmp61_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
						_tmp62_ = _tmp61_;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp62_, VALA_TYPE_STRUCT)) {
							ValaSymbol* _tmp63_;
							ValaSymbol* _tmp64_;
							_tmp63_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
							_tmp64_ = _tmp63_;
							_tmp60_ = !vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp64_, VALA_TYPE_STRUCT, ValaStruct));
						} else {
							_tmp60_ = FALSE;
						}
						if (_tmp60_) {
							ValaDataType* _tmp65_;
							gchar* _tmp66_;
							gchar* _tmp67_;
							ValaCCodeParameter* _tmp68_;
							_tmp65_ = this_type;
							_tmp66_ = vala_get_ccode_name ((ValaCodeNode*) _tmp65_);
							_tmp67_ = _tmp66_;
							_tmp68_ = vala_ccode_parameter_new ("*self", _tmp67_);
							_vala_ccode_node_unref0 (instance_param);
							instance_param = _tmp68_;
							_g_free0 (_tmp67_);
						} else {
							ValaDataType* _tmp69_;
							gchar* _tmp70_;
							gchar* _tmp71_;
							ValaCCodeParameter* _tmp72_;
							_tmp69_ = this_type;
							_tmp70_ = vala_get_ccode_name ((ValaCodeNode*) _tmp69_);
							_tmp71_ = _tmp70_;
							_tmp72_ = vala_ccode_parameter_new ("self", _tmp71_);
							_vala_ccode_node_unref0 (instance_param);
							instance_param = _tmp72_;
							_g_free0 (_tmp71_);
						}
					}
				}
				_tmp73_ = 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)), _tmp73_);
				_vala_ccode_node_unref0 (instance_param);
				_vala_code_node_unref0 (this_type);
			} else {
				ValaMemberBinding _tmp74_;
				ValaMemberBinding _tmp75_;
				_tmp74_ = vala_method_get_binding (m);
				_tmp75_ = _tmp74_;
				if (_tmp75_ == VALA_MEMBER_BINDING_CLASS) {
					ValaDataType* this_type = NULL;
					ValaDataType* _tmp76_;
					ValaCCodeParameter* class_param = NULL;
					ValaDataType* _tmp77_;
					gchar* _tmp78_;
					gchar* _tmp79_;
					ValaCCodeParameter* _tmp80_;
					ValaCCodeParameter* _tmp81_;
					ValaCCodeParameter* _tmp82_;
					_tmp76_ = vala_semantic_analyzer_get_this_type (m);
					this_type = _tmp76_;
					_tmp77_ = this_type;
					_tmp78_ = vala_get_ccode_name ((ValaCodeNode*) _tmp77_);
					_tmp79_ = _tmp78_;
					_tmp80_ = vala_ccode_parameter_new ("klass", _tmp79_);
					_tmp81_ = _tmp80_;
					_g_free0 (_tmp79_);
					class_param = _tmp81_;
					_tmp82_ = 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)), _tmp82_);
					_vala_ccode_node_unref0 (class_param);
					_vala_code_node_unref0 (this_type);
				}
			}
		}
	}
	if (vala_ccode_method_module_is_gtypeinstance_creation_method (self, m)) {
		gint type_param_index = 0;
		ValaClass* cl = NULL;
		ValaSymbol* _tmp83_;
		ValaSymbol* _tmp84_;
		ValaClass* _tmp85_;
		type_param_index = 0;
		_tmp83_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
		_tmp84_ = _tmp83_;
		_tmp85_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp84_, VALA_TYPE_CLASS, ValaClass));
		cl = _tmp85_;
		{
			ValaList* _type_param_list = NULL;
			ValaClass* _tmp86_;
			ValaList* _tmp87_;
			gint _type_param_size = 0;
			ValaList* _tmp88_;
			gint _tmp89_;
			gint _tmp90_;
			gint _type_param_index = 0;
			_tmp86_ = cl;
			_tmp87_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp86_);
			_type_param_list = _tmp87_;
			_tmp88_ = _type_param_list;
			_tmp89_ = vala_collection_get_size ((ValaCollection*) _tmp88_);
			_tmp90_ = _tmp89_;
			_type_param_size = _tmp90_;
			_type_param_index = -1;
			while (TRUE) {
				ValaTypeParameter* type_param = NULL;
				ValaList* _tmp91_;
				gpointer _tmp92_;
				ValaTypeParameter* _tmp93_;
				const gchar* _tmp94_;
				const gchar* _tmp95_;
				gchar* _tmp96_;
				gchar* _tmp97_;
				gchar* _tmp98_;
				gchar* _tmp99_;
				ValaCCodeParameter* _tmp100_;
				ValaCCodeParameter* _tmp101_;
				ValaTypeParameter* _tmp102_;
				const gchar* _tmp103_;
				const gchar* _tmp104_;
				gchar* _tmp105_;
				gchar* _tmp106_;
				gchar* _tmp107_;
				gchar* _tmp108_;
				ValaCCodeParameter* _tmp109_;
				ValaCCodeParameter* _tmp110_;
				ValaTypeParameter* _tmp111_;
				const gchar* _tmp112_;
				const gchar* _tmp113_;
				gchar* _tmp114_;
				gchar* _tmp115_;
				gchar* _tmp116_;
				gchar* _tmp117_;
				ValaCCodeParameter* _tmp118_;
				ValaCCodeParameter* _tmp119_;
				gint _tmp147_;
				_type_param_index = _type_param_index + 1;
				if (!(_type_param_index < _type_param_size)) {
					break;
				}
				_tmp91_ = _type_param_list;
				_tmp92_ = vala_list_get (_tmp91_, _type_param_index);
				type_param = (ValaTypeParameter*) _tmp92_;
				_tmp93_ = type_param;
				_tmp94_ = vala_symbol_get_name ((ValaSymbol*) _tmp93_);
				_tmp95_ = _tmp94_;
				_tmp96_ = g_utf8_strdown (_tmp95_, (gssize) -1);
				_tmp97_ = _tmp96_;
				_tmp98_ = g_strdup_printf ("%s_type", _tmp97_);
				_tmp99_ = _tmp98_;
				_tmp100_ = vala_ccode_parameter_new (_tmp99_, "GType");
				_tmp101_ = _tmp100_;
				vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.01, FALSE)), _tmp101_);
				_vala_ccode_node_unref0 (_tmp101_);
				_g_free0 (_tmp99_);
				_g_free0 (_tmp97_);
				_tmp102_ = type_param;
				_tmp103_ = vala_symbol_get_name ((ValaSymbol*) _tmp102_);
				_tmp104_ = _tmp103_;
				_tmp105_ = g_utf8_strdown (_tmp104_, (gssize) -1);
				_tmp106_ = _tmp105_;
				_tmp107_ = g_strdup_printf ("%s_dup_func", _tmp106_);
				_tmp108_ = _tmp107_;
				_tmp109_ = vala_ccode_parameter_new (_tmp108_, "GBoxedCopyFunc");
				_tmp110_ = _tmp109_;
				vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.02, FALSE)), _tmp110_);
				_vala_ccode_node_unref0 (_tmp110_);
				_g_free0 (_tmp108_);
				_g_free0 (_tmp106_);
				_tmp111_ = type_param;
				_tmp112_ = vala_symbol_get_name ((ValaSymbol*) _tmp111_);
				_tmp113_ = _tmp112_;
				_tmp114_ = g_utf8_strdown (_tmp113_, (gssize) -1);
				_tmp115_ = _tmp114_;
				_tmp116_ = g_strdup_printf ("%s_destroy_func", _tmp115_);
				_tmp117_ = _tmp116_;
				_tmp118_ = vala_ccode_parameter_new (_tmp117_, "GDestroyNotify");
				_tmp119_ = _tmp118_;
				vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.03, FALSE)), _tmp119_);
				_vala_ccode_node_unref0 (_tmp119_);
				_g_free0 (_tmp117_);
				_g_free0 (_tmp115_);
				if (carg_map != NULL) {
					ValaTypeParameter* _tmp120_;
					const gchar* _tmp121_;
					const gchar* _tmp122_;
					gchar* _tmp123_;
					gchar* _tmp124_;
					gchar* _tmp125_;
					gchar* _tmp126_;
					ValaCCodeIdentifier* _tmp127_;
					ValaCCodeIdentifier* _tmp128_;
					ValaTypeParameter* _tmp129_;
					const gchar* _tmp130_;
					const gchar* _tmp131_;
					gchar* _tmp132_;
					gchar* _tmp133_;
					gchar* _tmp134_;
					gchar* _tmp135_;
					ValaCCodeIdentifier* _tmp136_;
					ValaCCodeIdentifier* _tmp137_;
					ValaTypeParameter* _tmp138_;
					const gchar* _tmp139_;
					const gchar* _tmp140_;
					gchar* _tmp141_;
					gchar* _tmp142_;
					gchar* _tmp143_;
					gchar* _tmp144_;
					ValaCCodeIdentifier* _tmp145_;
					ValaCCodeIdentifier* _tmp146_;
					_tmp120_ = type_param;
					_tmp121_ = vala_symbol_get_name ((ValaSymbol*) _tmp120_);
					_tmp122_ = _tmp121_;
					_tmp123_ = g_utf8_strdown (_tmp122_, (gssize) -1);
					_tmp124_ = _tmp123_;
					_tmp125_ = g_strdup_printf ("%s_type", _tmp124_);
					_tmp126_ = _tmp125_;
					_tmp127_ = vala_ccode_identifier_new (_tmp126_);
					_tmp128_ = _tmp127_;
					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*) _tmp128_);
					_vala_ccode_node_unref0 (_tmp128_);
					_g_free0 (_tmp126_);
					_g_free0 (_tmp124_);
					_tmp129_ = type_param;
					_tmp130_ = vala_symbol_get_name ((ValaSymbol*) _tmp129_);
					_tmp131_ = _tmp130_;
					_tmp132_ = g_utf8_strdown (_tmp131_, (gssize) -1);
					_tmp133_ = _tmp132_;
					_tmp134_ = g_strdup_printf ("%s_dup_func", _tmp133_);
					_tmp135_ = _tmp134_;
					_tmp136_ = vala_ccode_identifier_new (_tmp135_);
					_tmp137_ = _tmp136_;
					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*) _tmp137_);
					_vala_ccode_node_unref0 (_tmp137_);
					_g_free0 (_tmp135_);
					_g_free0 (_tmp133_);
					_tmp138_ = type_param;
					_tmp139_ = vala_symbol_get_name ((ValaSymbol*) _tmp138_);
					_tmp140_ = _tmp139_;
					_tmp141_ = g_utf8_strdown (_tmp140_, (gssize) -1);
					_tmp142_ = _tmp141_;
					_tmp143_ = g_strdup_printf ("%s_destroy_func", _tmp142_);
					_tmp144_ = _tmp143_;
					_tmp145_ = vala_ccode_identifier_new (_tmp144_);
					_tmp146_ = _tmp145_;
					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*) _tmp146_);
					_vala_ccode_node_unref0 (_tmp146_);
					_g_free0 (_tmp144_);
					_g_free0 (_tmp142_);
				}
				_tmp147_ = type_param_index;
				type_param_index = _tmp147_ + 1;
				_vala_code_node_unref0 (type_param);
			}
			_vala_iterable_unref0 (_type_param_list);
		}
		_vala_code_node_unref0 (cl);
	} else {
		gboolean _tmp148_ = FALSE;
		gboolean _tmp149_;
		gboolean _tmp150_;
		_tmp149_ = vala_method_get_closure (m);
		_tmp150_ = _tmp149_;
		if (!_tmp150_) {
			_tmp148_ = (direction & 1) == 1;
		} else {
			_tmp148_ = FALSE;
		}
		if (_tmp148_) {
			gint type_param_index = 0;
			type_param_index = 0;
			{
				ValaList* _type_param_list = NULL;
				ValaList* _tmp151_;
				gint _type_param_size = 0;
				ValaList* _tmp152_;
				gint _tmp153_;
				gint _tmp154_;
				gint _type_param_index = 0;
				_tmp151_ = vala_method_get_type_parameters (m);
				_type_param_list = _tmp151_;
				_tmp152_ = _type_param_list;
				_tmp153_ = vala_collection_get_size ((ValaCollection*) _tmp152_);
				_tmp154_ = _tmp153_;
				_type_param_size = _tmp154_;
				_type_param_index = -1;
				while (TRUE) {
					ValaTypeParameter* type_param = NULL;
					ValaList* _tmp155_;
					gpointer _tmp156_;
					ValaTypeParameter* _tmp157_;
					const gchar* _tmp158_;
					const gchar* _tmp159_;
					gchar* _tmp160_;
					gchar* _tmp161_;
					gchar* _tmp162_;
					gchar* _tmp163_;
					ValaCCodeParameter* _tmp164_;
					ValaCCodeParameter* _tmp165_;
					ValaTypeParameter* _tmp166_;
					const gchar* _tmp167_;
					const gchar* _tmp168_;
					gchar* _tmp169_;
					gchar* _tmp170_;
					gchar* _tmp171_;
					gchar* _tmp172_;
					ValaCCodeParameter* _tmp173_;
					ValaCCodeParameter* _tmp174_;
					ValaTypeParameter* _tmp175_;
					const gchar* _tmp176_;
					const gchar* _tmp177_;
					gchar* _tmp178_;
					gchar* _tmp179_;
					gchar* _tmp180_;
					gchar* _tmp181_;
					ValaCCodeParameter* _tmp182_;
					ValaCCodeParameter* _tmp183_;
					gint _tmp211_;
					_type_param_index = _type_param_index + 1;
					if (!(_type_param_index < _type_param_size)) {
						break;
					}
					_tmp155_ = _type_param_list;
					_tmp156_ = vala_list_get (_tmp155_, _type_param_index);
					type_param = (ValaTypeParameter*) _tmp156_;
					_tmp157_ = type_param;
					_tmp158_ = vala_symbol_get_name ((ValaSymbol*) _tmp157_);
					_tmp159_ = _tmp158_;
					_tmp160_ = g_utf8_strdown (_tmp159_, (gssize) -1);
					_tmp161_ = _tmp160_;
					_tmp162_ = g_strdup_printf ("%s_type", _tmp161_);
					_tmp163_ = _tmp162_;
					_tmp164_ = vala_ccode_parameter_new (_tmp163_, "GType");
					_tmp165_ = _tmp164_;
					vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.01, FALSE)), _tmp165_);
					_vala_ccode_node_unref0 (_tmp165_);
					_g_free0 (_tmp163_);
					_g_free0 (_tmp161_);
					_tmp166_ = type_param;
					_tmp167_ = vala_symbol_get_name ((ValaSymbol*) _tmp166_);
					_tmp168_ = _tmp167_;
					_tmp169_ = g_utf8_strdown (_tmp168_, (gssize) -1);
					_tmp170_ = _tmp169_;
					_tmp171_ = g_strdup_printf ("%s_dup_func", _tmp170_);
					_tmp172_ = _tmp171_;
					_tmp173_ = vala_ccode_parameter_new (_tmp172_, "GBoxedCopyFunc");
					_tmp174_ = _tmp173_;
					vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.02, FALSE)), _tmp174_);
					_vala_ccode_node_unref0 (_tmp174_);
					_g_free0 (_tmp172_);
					_g_free0 (_tmp170_);
					_tmp175_ = type_param;
					_tmp176_ = vala_symbol_get_name ((ValaSymbol*) _tmp175_);
					_tmp177_ = _tmp176_;
					_tmp178_ = g_utf8_strdown (_tmp177_, (gssize) -1);
					_tmp179_ = _tmp178_;
					_tmp180_ = g_strdup_printf ("%s_destroy_func", _tmp179_);
					_tmp181_ = _tmp180_;
					_tmp182_ = vala_ccode_parameter_new (_tmp181_, "GDestroyNotify");
					_tmp183_ = _tmp182_;
					vala_map_set (cparam_map, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.03, FALSE)), _tmp183_);
					_vala_ccode_node_unref0 (_tmp183_);
					_g_free0 (_tmp181_);
					_g_free0 (_tmp179_);
					if (carg_map != NULL) {
						ValaTypeParameter* _tmp184_;
						const gchar* _tmp185_;
						const gchar* _tmp186_;
						gchar* _tmp187_;
						gchar* _tmp188_;
						gchar* _tmp189_;
						gchar* _tmp190_;
						ValaCCodeIdentifier* _tmp191_;
						ValaCCodeIdentifier* _tmp192_;
						ValaTypeParameter* _tmp193_;
						const gchar* _tmp194_;
						const gchar* _tmp195_;
						gchar* _tmp196_;
						gchar* _tmp197_;
						gchar* _tmp198_;
						gchar* _tmp199_;
						ValaCCodeIdentifier* _tmp200_;
						ValaCCodeIdentifier* _tmp201_;
						ValaTypeParameter* _tmp202_;
						const gchar* _tmp203_;
						const gchar* _tmp204_;
						gchar* _tmp205_;
						gchar* _tmp206_;
						gchar* _tmp207_;
						gchar* _tmp208_;
						ValaCCodeIdentifier* _tmp209_;
						ValaCCodeIdentifier* _tmp210_;
						_tmp184_ = type_param;
						_tmp185_ = vala_symbol_get_name ((ValaSymbol*) _tmp184_);
						_tmp186_ = _tmp185_;
						_tmp187_ = g_utf8_strdown (_tmp186_, (gssize) -1);
						_tmp188_ = _tmp187_;
						_tmp189_ = g_strdup_printf ("%s_type", _tmp188_);
						_tmp190_ = _tmp189_;
						_tmp191_ = vala_ccode_identifier_new (_tmp190_);
						_tmp192_ = _tmp191_;
						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*) _tmp192_);
						_vala_ccode_node_unref0 (_tmp192_);
						_g_free0 (_tmp190_);
						_g_free0 (_tmp188_);
						_tmp193_ = type_param;
						_tmp194_ = vala_symbol_get_name ((ValaSymbol*) _tmp193_);
						_tmp195_ = _tmp194_;
						_tmp196_ = g_utf8_strdown (_tmp195_, (gssize) -1);
						_tmp197_ = _tmp196_;
						_tmp198_ = g_strdup_printf ("%s_dup_func", _tmp197_);
						_tmp199_ = _tmp198_;
						_tmp200_ = vala_ccode_identifier_new (_tmp199_);
						_tmp201_ = _tmp200_;
						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*) _tmp201_);
						_vala_ccode_node_unref0 (_tmp201_);
						_g_free0 (_tmp199_);
						_g_free0 (_tmp197_);
						_tmp202_ = type_param;
						_tmp203_ = vala_symbol_get_name ((ValaSymbol*) _tmp202_);
						_tmp204_ = _tmp203_;
						_tmp205_ = g_utf8_strdown (_tmp204_, (gssize) -1);
						_tmp206_ = _tmp205_;
						_tmp207_ = g_strdup_printf ("%s_destroy_func", _tmp206_);
						_tmp208_ = _tmp207_;
						_tmp209_ = vala_ccode_identifier_new (_tmp208_);
						_tmp210_ = _tmp209_;
						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*) _tmp210_);
						_vala_ccode_node_unref0 (_tmp210_);
						_g_free0 (_tmp208_);
						_g_free0 (_tmp206_);
					}
					_tmp211_ = type_param_index;
					type_param_index = _tmp211_ + 1;
					_vala_code_node_unref0 (type_param);
				}
				_vala_iterable_unref0 (_type_param_list);
			}
		}
	}
	if (vala_method_get_format_arg_index (m) < 0) {
		gboolean _tmp213_ = FALSE;
		gboolean _tmp214_;
		gboolean _tmp215_;
		_tmp214_ = vala_method_get_printf_format (m);
		_tmp215_ = _tmp214_;
		if (_tmp215_) {
			_tmp213_ = TRUE;
		} else {
			gboolean _tmp216_;
			gboolean _tmp217_;
			_tmp216_ = vala_method_get_scanf_format (m);
			_tmp217_ = _tmp216_;
			_tmp213_ = _tmp217_;
		}
		_tmp212_ = _tmp213_;
	} else {
		_tmp212_ = FALSE;
	}
	needs_format_arg = _tmp212_;
	prev_cparam = NULL;
	{
		ValaList* _param_list = NULL;
		ValaList* _tmp218_;
		gint _param_size = 0;
		ValaList* _tmp219_;
		gint _tmp220_;
		gint _tmp221_;
		gint _param_index = 0;
		_tmp218_ = vala_callable_get_parameters ((ValaCallable*) m);
		_param_list = _tmp218_;
		_tmp219_ = _param_list;
		_tmp220_ = vala_collection_get_size ((ValaCollection*) _tmp219_);
		_tmp221_ = _tmp220_;
		_param_size = _tmp221_;
		_param_index = -1;
		while (TRUE) {
			ValaParameter* param = NULL;
			ValaList* _tmp222_;
			gpointer _tmp223_;
			ValaParameter* _tmp224_;
			ValaParameterDirection _tmp225_;
			ValaParameterDirection _tmp226_;
			ValaCCodeParameter* cparam = NULL;
			ValaParameter* _tmp227_;
			ValaCCodeParameter* _tmp228_;
			_param_index = _param_index + 1;
			if (!(_param_index < _param_size)) {
				break;
			}
			_tmp222_ = _param_list;
			_tmp223_ = vala_list_get (_tmp222_, _param_index);
			param = (ValaParameter*) _tmp223_;
			_tmp224_ = param;
			_tmp225_ = vala_parameter_get_direction (_tmp224_);
			_tmp226_ = _tmp225_;
			if (_tmp226_ != 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;
				}
			}
			_tmp227_ = param;
			_tmp228_ = vala_ccode_method_module_generate_parameter (self, _tmp227_, decl_space, cparam_map, carg_map);
			cparam = _tmp228_;
			if (needs_format_arg) {
				gboolean _tmp229_ = FALSE;
				ValaCCodeParameter* _tmp230_;
				ValaCCodeParameter* _tmp238_;
				ValaCCodeParameter* _tmp239_;
				_tmp230_ = prev_cparam;
				if (_tmp230_ != NULL) {
					ValaCCodeParameter* _tmp231_;
					gboolean _tmp232_;
					gboolean _tmp233_;
					_tmp231_ = cparam;
					_tmp232_ = vala_ccode_parameter_get_ellipsis (_tmp231_);
					_tmp233_ = _tmp232_;
					_tmp229_ = _tmp233_;
				} else {
					_tmp229_ = FALSE;
				}
				if (_tmp229_) {
					ValaCCodeParameter* _tmp234_;
					ValaCCodeParameter* _tmp235_;
					ValaCCodeModifiers _tmp236_;
					ValaCCodeModifiers _tmp237_;
					_tmp234_ = prev_cparam;
					_tmp235_ = prev_cparam;
					_tmp236_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp235_);
					_tmp237_ = _tmp236_;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp235_, _tmp237_ | VALA_CCODE_MODIFIERS_FORMAT_ARG);
				}
				_tmp238_ = cparam;
				_tmp239_ = _vala_ccode_node_ref0 (_tmp238_);
				_vala_ccode_node_unref0 (prev_cparam);
				prev_cparam = _tmp239_;
			}
			_vala_ccode_node_unref0 (cparam);
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
	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 _tmp249_;
		ValaCCodeParameter* _tmp250_;
		min_pos = -1;
		{
			ValaIterator* _pos_it = NULL;
			ValaSet* _tmp240_;
			ValaSet* _tmp241_;
			ValaIterator* _tmp242_;
			ValaIterator* _tmp243_;
			_tmp240_ = vala_map_get_keys (cparam_map);
			_tmp241_ = _tmp240_;
			_tmp242_ = vala_iterable_iterator ((ValaIterable*) _tmp241_);
			_tmp243_ = _tmp242_;
			_vala_iterable_unref0 (_tmp241_);
			_pos_it = _tmp243_;
			while (TRUE) {
				ValaIterator* _tmp244_;
				gint pos = 0;
				ValaIterator* _tmp245_;
				gpointer _tmp246_;
				gboolean _tmp247_ = FALSE;
				_tmp244_ = _pos_it;
				if (!vala_iterator_next (_tmp244_)) {
					break;
				}
				_tmp245_ = _pos_it;
				_tmp246_ = vala_iterator_get (_tmp245_);
				pos = (gint) ((gintptr) _tmp246_);
				if (pos > last_pos) {
					gboolean _tmp248_ = FALSE;
					if (min_pos == -1) {
						_tmp248_ = TRUE;
					} else {
						_tmp248_ = pos < min_pos;
					}
					_tmp247_ = _tmp248_;
				} else {
					_tmp247_ = FALSE;
				}
				if (_tmp247_) {
					min_pos = pos;
				}
			}
			_vala_iterator_unref0 (_pos_it);
		}
		if (min_pos == -1) {
			break;
		}
		_tmp249_ = vala_map_get (cparam_map, (gpointer) ((gintptr) min_pos));
		_tmp250_ = (ValaCCodeParameter*) _tmp249_;
		vala_ccode_function_add_parameter (func, _tmp250_);
		_vala_ccode_node_unref0 (_tmp250_);
		if (vdeclarator != NULL) {
			gpointer _tmp251_;
			ValaCCodeParameter* _tmp252_;
			_tmp251_ = vala_map_get (cparam_map, (gpointer) ((gintptr) min_pos));
			_tmp252_ = (ValaCCodeParameter*) _tmp251_;
			vala_ccode_function_declarator_add_parameter (vdeclarator, _tmp252_);
			_vala_ccode_node_unref0 (_tmp252_);
		}
		if (vcall != NULL) {
			ValaCCodeExpression* arg = NULL;
			gpointer _tmp253_;
			ValaCCodeExpression* _tmp254_;
			_tmp253_ = vala_map_get (carg_map, (gpointer) ((gintptr) min_pos));
			arg = (ValaCCodeExpression*) _tmp253_;
			_tmp254_ = arg;
			if (_tmp254_ != NULL) {
				ValaCCodeExpression* _tmp255_;
				_tmp255_ = arg;
				vala_ccode_function_call_add_argument (vcall, _tmp255_);
			}
			_vala_ccode_node_unref0 (arg);
		}
		last_pos = min_pos;
	}
	_tmp256_ = vala_method_get_printf_format (m);
	_tmp257_ = _tmp256_;
	if (_tmp257_) {
		ValaCCodeModifiers _tmp258_;
		ValaCCodeModifiers _tmp259_;
		_tmp258_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) func);
		_tmp259_ = _tmp258_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) func, _tmp259_ | VALA_CCODE_MODIFIERS_PRINTF);
	} else {
		gboolean _tmp260_;
		gboolean _tmp261_;
		_tmp260_ = vala_method_get_scanf_format (m);
		_tmp261_ = _tmp260_;
		if (_tmp261_) {
			ValaCCodeModifiers _tmp262_;
			ValaCCodeModifiers _tmp263_;
			_tmp262_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) func);
			_tmp263_ = _tmp262_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) func, _tmp263_ | VALA_CCODE_MODIFIERS_SCANF);
		}
	}
	_tmp264_ = vala_symbol_get_version ((ValaSymbol*) m);
	_tmp265_ = _tmp264_;
	_tmp266_ = vala_version_attribute_get_deprecated (_tmp265_);
	_tmp267_ = _tmp266_;
	if (_tmp267_) {
		ValaCCodeModifiers _tmp268_;
		ValaCCodeModifiers _tmp269_;
		_tmp268_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) func);
		_tmp269_ = _tmp268_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) func, _tmp269_ | VALA_CCODE_MODIFIERS_DEPRECATED);
	}
	_vala_ccode_node_unref0 (prev_cparam);
}

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* _tmp50_;
	ValaCCodeIdentifier* _tmp51_;
	ValaCCodeFile* _tmp52_;
	ValaCCodeFunction* _tmp53_;
	ValaCCodeFunctionCall* _tmp54_;
	ValaCCodeFunction* _tmp55_;
	gboolean _tmp56_ = FALSE;
	gboolean _tmp57_ = FALSE;
	gboolean _tmp58_ = FALSE;
	ValaCodeContext* _tmp59_;
	ValaCodeContext* _tmp60_;
	gboolean _tmp61_;
	gboolean _tmp62_;
	ValaSymbol* _tmp89_;
	ValaSymbol* _tmp90_;
	gboolean _tmp98_ = FALSE;
	ValaList* _tmp123_;
	ValaList* _tmp124_;
	gint _tmp125_;
	gint _tmp126_;
	gboolean _tmp127_;
	gboolean _tmp139_;
	gboolean _tmp140_;
	ValaVersionAttribute* _tmp151_;
	ValaVersionAttribute* _tmp152_;
	gboolean _tmp153_;
	gboolean _tmp154_;
	ValaCCodeFile* _tmp159_;
	ValaCCodeFunction* _tmp160_;
	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)) {
		ValaInterface* iface = NULL;
		ValaSymbol* _tmp10_;
		ValaSymbol* _tmp11_;
		ValaInterface* _tmp12_;
		ValaInterface* _tmp13_;
		gchar* _tmp14_;
		gchar* _tmp15_;
		ValaCCodeIdentifier* _tmp16_;
		ValaCCodeIdentifier* _tmp17_;
		ValaCCodeFunctionCall* _tmp18_;
		ValaCCodeExpression* _tmp19_;
		ValaCCodeIdentifier* _tmp20_;
		ValaCCodeIdentifier* _tmp21_;
		_tmp10_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
		_tmp11_ = _tmp10_;
		_tmp12_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_INTERFACE, ValaInterface));
		iface = _tmp12_;
		_tmp13_ = iface;
		_tmp14_ = vala_get_ccode_interface_get_function (_tmp13_);
		_tmp15_ = _tmp14_;
		_tmp16_ = vala_ccode_identifier_new (_tmp15_);
		_tmp17_ = _tmp16_;
		_tmp18_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp17_);
		_vala_ccode_node_unref0 (vcast);
		vcast = (ValaCCodeExpression*) _tmp18_;
		_vala_ccode_node_unref0 (_tmp17_);
		_g_free0 (_tmp15_);
		_tmp19_ = vcast;
		_tmp20_ = vala_ccode_identifier_new ("self");
		_tmp21_ = _tmp20_;
		vala_ccode_function_call_add_argument (G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, VALA_TYPE_CCODE_FUNCTION_CALL, ValaCCodeFunctionCall), (ValaCCodeExpression*) _tmp21_);
		_vala_ccode_node_unref0 (_tmp21_);
		_vala_code_node_unref0 (iface);
	} else {
		ValaClass* cl = NULL;
		ValaSymbol* _tmp22_;
		ValaSymbol* _tmp23_;
		ValaClass* _tmp24_;
		ValaClass* _tmp25_;
		gboolean _tmp26_;
		gboolean _tmp27_;
		_tmp22_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
		_tmp23_ = _tmp22_;
		_tmp24_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp23_, VALA_TYPE_CLASS, ValaClass));
		cl = _tmp24_;
		_tmp25_ = cl;
		_tmp26_ = vala_class_get_is_compact (_tmp25_);
		_tmp27_ = _tmp26_;
		if (!_tmp27_) {
			ValaClass* _tmp28_;
			gchar* _tmp29_;
			gchar* _tmp30_;
			ValaCCodeIdentifier* _tmp31_;
			ValaCCodeIdentifier* _tmp32_;
			ValaCCodeFunctionCall* _tmp33_;
			ValaCCodeExpression* _tmp34_;
			ValaCCodeIdentifier* _tmp35_;
			ValaCCodeIdentifier* _tmp36_;
			_tmp28_ = cl;
			_tmp29_ = vala_get_ccode_class_get_function (_tmp28_);
			_tmp30_ = _tmp29_;
			_tmp31_ = vala_ccode_identifier_new (_tmp30_);
			_tmp32_ = _tmp31_;
			_tmp33_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp32_);
			_vala_ccode_node_unref0 (vcast);
			vcast = (ValaCCodeExpression*) _tmp33_;
			_vala_ccode_node_unref0 (_tmp32_);
			_g_free0 (_tmp30_);
			_tmp34_ = vcast;
			_tmp35_ = vala_ccode_identifier_new ("self");
			_tmp36_ = _tmp35_;
			vala_ccode_function_call_add_argument (G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, VALA_TYPE_CCODE_FUNCTION_CALL, ValaCCodeFunctionCall), (ValaCCodeExpression*) _tmp36_);
			_vala_ccode_node_unref0 (_tmp36_);
		} else {
			ValaCCodeIdentifier* _tmp37_;
			_tmp37_ = vala_ccode_identifier_new ("self");
			_vala_ccode_node_unref0 (vcast);
			vcast = (ValaCCodeExpression*) _tmp37_;
		}
		_vala_code_node_unref0 (cl);
	}
	if (g_strcmp0 (suffix, "_finish") == 0) {
		ValaCCodeExpression* _tmp38_;
		gchar* _tmp39_;
		gchar* _tmp40_;
		ValaCCodeMemberAccess* _tmp41_;
		ValaCCodeMemberAccess* _tmp42_;
		ValaCCodeFunctionCall* _tmp43_;
		_tmp38_ = vcast;
		_tmp39_ = vala_get_ccode_finish_vfunc_name (m);
		_tmp40_ = _tmp39_;
		_tmp41_ = vala_ccode_member_access_new_pointer (_tmp38_, _tmp40_);
		_tmp42_ = _tmp41_;
		_tmp43_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp42_);
		_vala_ccode_node_unref0 (vcall);
		vcall = _tmp43_;
		_vala_ccode_node_unref0 (_tmp42_);
		_g_free0 (_tmp40_);
	} else {
		ValaCCodeExpression* _tmp44_;
		gchar* _tmp45_;
		gchar* _tmp46_;
		ValaCCodeMemberAccess* _tmp47_;
		ValaCCodeMemberAccess* _tmp48_;
		ValaCCodeFunctionCall* _tmp49_;
		_tmp44_ = vcast;
		_tmp45_ = vala_get_ccode_vfunc_name (m);
		_tmp46_ = _tmp45_;
		_tmp47_ = vala_ccode_member_access_new_pointer (_tmp44_, _tmp46_);
		_tmp48_ = _tmp47_;
		_tmp49_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp48_);
		_vala_ccode_node_unref0 (vcall);
		vcall = _tmp49_;
		_vala_ccode_node_unref0 (_tmp48_);
		_g_free0 (_tmp46_);
	}
	_tmp50_ = vala_ccode_identifier_new ("self");
	_tmp51_ = _tmp50_;
	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*) _tmp51_);
	_vala_ccode_node_unref0 (_tmp51_);
	_tmp52_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp53_ = vfunc;
	_tmp54_ = vcall;
	vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, m, _tmp52_, cparam_map, _tmp53_, NULL, carg_map, _tmp54_, direction);
	_tmp55_ = vfunc;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp55_);
	_tmp59_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
	_tmp60_ = _tmp59_;
	_tmp61_ = vala_code_context_get_assert (_tmp60_);
	_tmp62_ = _tmp61_;
	if (_tmp62_) {
		ValaDataType* _tmp63_;
		ValaDataType* _tmp64_;
		ValaTypeSymbol* _tmp65_;
		ValaTypeSymbol* _tmp66_;
		_tmp63_ = vala_callable_get_return_type ((ValaCallable*) m);
		_tmp64_ = _tmp63_;
		_tmp65_ = vala_data_type_get_data_type (_tmp64_);
		_tmp66_ = _tmp65_;
		_tmp58_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp66_, VALA_TYPE_STRUCT);
	} else {
		_tmp58_ = FALSE;
	}
	if (_tmp58_) {
		ValaDataType* _tmp67_;
		ValaDataType* _tmp68_;
		ValaTypeSymbol* _tmp69_;
		ValaTypeSymbol* _tmp70_;
		_tmp67_ = vala_callable_get_return_type ((ValaCallable*) m);
		_tmp68_ = _tmp67_;
		_tmp69_ = vala_data_type_get_data_type (_tmp68_);
		_tmp70_ = _tmp69_;
		_tmp57_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp70_, VALA_TYPE_STRUCT, ValaStruct));
	} else {
		_tmp57_ = FALSE;
	}
	if (_tmp57_) {
		ValaDataType* _tmp71_;
		ValaDataType* _tmp72_;
		ValaCCodeExpression* _tmp73_;
		ValaCCodeExpression* _tmp74_;
		_tmp71_ = vala_callable_get_return_type ((ValaCallable*) m);
		_tmp72_ = _tmp71_;
		_tmp73_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp72_, FALSE, FALSE);
		_tmp74_ = _tmp73_;
		_tmp56_ = _tmp74_ == NULL;
		_vala_ccode_node_unref0 (_tmp74_);
	} else {
		_tmp56_ = FALSE;
	}
	if (_tmp56_) {
		ValaCCodeVariableDeclarator* vardecl = NULL;
		ValaDataType* _tmp75_;
		ValaDataType* _tmp76_;
		ValaCCodeExpression* _tmp77_;
		ValaCCodeExpression* _tmp78_;
		ValaCCodeVariableDeclarator* _tmp79_;
		ValaCCodeVariableDeclarator* _tmp80_;
		ValaCCodeVariableDeclarator* _tmp81_;
		ValaCCodeFunction* _tmp82_;
		ValaCCodeFunction* _tmp83_;
		ValaDataType* _tmp84_;
		ValaDataType* _tmp85_;
		gchar* _tmp86_;
		gchar* _tmp87_;
		ValaCCodeVariableDeclarator* _tmp88_;
		_tmp75_ = vala_callable_get_return_type ((ValaCallable*) m);
		_tmp76_ = _tmp75_;
		_tmp77_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp76_, TRUE, FALSE);
		_tmp78_ = _tmp77_;
		_tmp79_ = vala_ccode_variable_declarator_new ("result", _tmp78_, NULL);
		_tmp80_ = _tmp79_;
		_vala_ccode_node_unref0 (_tmp78_);
		vardecl = _tmp80_;
		_tmp81_ = vardecl;
		vala_ccode_variable_declarator_set_init0 (_tmp81_, TRUE);
		_tmp82_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp83_ = _tmp82_;
		_tmp84_ = vala_callable_get_return_type ((ValaCallable*) m);
		_tmp85_ = _tmp84_;
		_tmp86_ = vala_get_ccode_name ((ValaCodeNode*) _tmp85_);
		_tmp87_ = _tmp86_;
		_tmp88_ = vardecl;
		vala_ccode_function_add_declaration (_tmp83_, _tmp87_, (ValaCCodeDeclarator*) _tmp88_, 0);
		_g_free0 (_tmp87_);
		_vala_ccode_node_unref0 (vardecl);
	}
	_tmp89_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
	_tmp90_ = _tmp89_;
	vala_ccode_method_module_create_method_type_check_statement (self, m, return_type, G_TYPE_CHECK_INSTANCE_CAST (_tmp90_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol), TRUE, "self");
	{
		ValaList* _precondition_list = NULL;
		ValaList* _tmp91_;
		gint _precondition_size = 0;
		ValaList* _tmp92_;
		gint _tmp93_;
		gint _tmp94_;
		gint _precondition_index = 0;
		_tmp91_ = vala_method_get_preconditions (m);
		_precondition_list = _tmp91_;
		_tmp92_ = _precondition_list;
		_tmp93_ = vala_collection_get_size ((ValaCollection*) _tmp92_);
		_tmp94_ = _tmp93_;
		_precondition_size = _tmp94_;
		_precondition_index = -1;
		while (TRUE) {
			ValaExpression* precondition = NULL;
			ValaList* _tmp95_;
			gpointer _tmp96_;
			ValaExpression* _tmp97_;
			_precondition_index = _precondition_index + 1;
			if (!(_precondition_index < _precondition_size)) {
				break;
			}
			_tmp95_ = _precondition_list;
			_tmp96_ = vala_list_get (_tmp95_, _precondition_index);
			precondition = (ValaExpression*) _tmp96_;
			_tmp97_ = precondition;
			vala_ccode_method_module_create_precondition_statement (self, (ValaCodeNode*) m, return_type, _tmp97_);
			_vala_code_node_unref0 (precondition);
		}
		_vala_iterable_unref0 (_precondition_list);
	}
	if (G_TYPE_CHECK_INSTANCE_TYPE (return_type, VALA_TYPE_VOID_TYPE)) {
		_tmp98_ = TRUE;
	} else {
		_tmp98_ = vala_data_type_is_real_non_null_struct_type (return_type);
	}
	if (_tmp98_) {
		ValaCCodeFunction* _tmp99_;
		ValaCCodeFunction* _tmp100_;
		ValaCCodeFunctionCall* _tmp101_;
		_tmp99_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp100_ = _tmp99_;
		_tmp101_ = vcall;
		vala_ccode_function_add_expression (_tmp100_, (ValaCCodeExpression*) _tmp101_);
	} else {
		ValaList* _tmp102_;
		ValaList* _tmp103_;
		gint _tmp104_;
		gint _tmp105_;
		gboolean _tmp106_;
		_tmp102_ = vala_method_get_postconditions (m);
		_tmp103_ = _tmp102_;
		_tmp104_ = vala_collection_get_size ((ValaCollection*) _tmp103_);
		_tmp105_ = _tmp104_;
		_tmp106_ = _tmp105_ == 0;
		_vala_iterable_unref0 (_tmp103_);
		if (_tmp106_) {
			ValaCCodeFunction* _tmp107_;
			ValaCCodeFunction* _tmp108_;
			ValaCCodeFunctionCall* _tmp109_;
			_tmp107_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp108_ = _tmp107_;
			_tmp109_ = vcall;
			vala_ccode_function_add_return (_tmp108_, (ValaCCodeExpression*) _tmp109_);
		} else {
			ValaCCodeFunction* _tmp110_;
			ValaCCodeFunction* _tmp111_;
			gchar* _tmp112_;
			gchar* _tmp113_;
			gchar* _tmp114_;
			gchar* _tmp115_;
			ValaCCodeVariableDeclarator* _tmp116_;
			ValaCCodeVariableDeclarator* _tmp117_;
			ValaCCodeFunction* _tmp118_;
			ValaCCodeFunction* _tmp119_;
			ValaCCodeIdentifier* _tmp120_;
			ValaCCodeIdentifier* _tmp121_;
			ValaCCodeFunctionCall* _tmp122_;
			_tmp110_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp111_ = _tmp110_;
			_tmp112_ = vala_get_ccode_name ((ValaCodeNode*) return_type);
			_tmp113_ = _tmp112_;
			_tmp114_ = vala_ccode_method_module_get_creturn_type (self, m, _tmp113_);
			_tmp115_ = _tmp114_;
			_tmp116_ = vala_ccode_variable_declarator_new ("result", NULL, NULL);
			_tmp117_ = _tmp116_;
			vala_ccode_function_add_declaration (_tmp111_, _tmp115_, (ValaCCodeDeclarator*) _tmp117_, 0);
			_vala_ccode_node_unref0 (_tmp117_);
			_g_free0 (_tmp115_);
			_g_free0 (_tmp113_);
			_tmp118_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp119_ = _tmp118_;
			_tmp120_ = vala_ccode_identifier_new ("result");
			_tmp121_ = _tmp120_;
			_tmp122_ = vcall;
			vala_ccode_function_add_assignment (_tmp119_, (ValaCCodeExpression*) _tmp121_, (ValaCCodeExpression*) _tmp122_);
			_vala_ccode_node_unref0 (_tmp121_);
		}
	}
	_tmp123_ = vala_method_get_postconditions (m);
	_tmp124_ = _tmp123_;
	_tmp125_ = vala_collection_get_size ((ValaCollection*) _tmp124_);
	_tmp126_ = _tmp125_;
	_tmp127_ = _tmp126_ > 0;
	_vala_iterable_unref0 (_tmp124_);
	if (_tmp127_) {
		{
			ValaList* _postcondition_list = NULL;
			ValaList* _tmp128_;
			gint _postcondition_size = 0;
			ValaList* _tmp129_;
			gint _tmp130_;
			gint _tmp131_;
			gint _postcondition_index = 0;
			_tmp128_ = vala_method_get_postconditions (m);
			_postcondition_list = _tmp128_;
			_tmp129_ = _postcondition_list;
			_tmp130_ = vala_collection_get_size ((ValaCollection*) _tmp129_);
			_tmp131_ = _tmp130_;
			_postcondition_size = _tmp131_;
			_postcondition_index = -1;
			while (TRUE) {
				ValaExpression* postcondition = NULL;
				ValaList* _tmp132_;
				gpointer _tmp133_;
				ValaExpression* _tmp134_;
				_postcondition_index = _postcondition_index + 1;
				if (!(_postcondition_index < _postcondition_size)) {
					break;
				}
				_tmp132_ = _postcondition_list;
				_tmp133_ = vala_list_get (_tmp132_, _postcondition_index);
				postcondition = (ValaExpression*) _tmp133_;
				_tmp134_ = postcondition;
				vala_ccode_base_module_create_postcondition_statement ((ValaCCodeBaseModule*) self, _tmp134_);
				_vala_code_node_unref0 (postcondition);
			}
			_vala_iterable_unref0 (_postcondition_list);
		}
		if (!G_TYPE_CHECK_INSTANCE_TYPE (return_type, VALA_TYPE_VOID_TYPE)) {
			ValaCCodeFunction* _tmp135_;
			ValaCCodeFunction* _tmp136_;
			ValaCCodeIdentifier* _tmp137_;
			ValaCCodeIdentifier* _tmp138_;
			_tmp135_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp136_ = _tmp135_;
			_tmp137_ = vala_ccode_identifier_new ("result");
			_tmp138_ = _tmp137_;
			vala_ccode_function_add_return (_tmp136_, (ValaCCodeExpression*) _tmp138_);
			_vala_ccode_node_unref0 (_tmp138_);
		}
	}
	_tmp139_ = vala_method_get_printf_format (m);
	_tmp140_ = _tmp139_;
	if (_tmp140_) {
		ValaCCodeFunction* _tmp141_;
		ValaCCodeFunction* _tmp142_;
		ValaCCodeModifiers _tmp143_;
		ValaCCodeModifiers _tmp144_;
		_tmp141_ = vfunc;
		_tmp142_ = vfunc;
		_tmp143_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp142_);
		_tmp144_ = _tmp143_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp142_, _tmp144_ | VALA_CCODE_MODIFIERS_PRINTF);
	} else {
		gboolean _tmp145_;
		gboolean _tmp146_;
		_tmp145_ = vala_method_get_scanf_format (m);
		_tmp146_ = _tmp145_;
		if (_tmp146_) {
			ValaCCodeFunction* _tmp147_;
			ValaCCodeFunction* _tmp148_;
			ValaCCodeModifiers _tmp149_;
			ValaCCodeModifiers _tmp150_;
			_tmp147_ = vfunc;
			_tmp148_ = vfunc;
			_tmp149_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp148_);
			_tmp150_ = _tmp149_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp148_, _tmp150_ | VALA_CCODE_MODIFIERS_SCANF);
		}
	}
	_tmp151_ = vala_symbol_get_version ((ValaSymbol*) m);
	_tmp152_ = _tmp151_;
	_tmp153_ = vala_version_attribute_get_deprecated (_tmp152_);
	_tmp154_ = _tmp153_;
	if (_tmp154_) {
		ValaCCodeFunction* _tmp155_;
		ValaCCodeFunction* _tmp156_;
		ValaCCodeModifiers _tmp157_;
		ValaCCodeModifiers _tmp158_;
		_tmp155_ = vfunc;
		_tmp156_ = vfunc;
		_tmp157_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp156_);
		_tmp158_ = _tmp157_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp156_, _tmp158_ | VALA_CCODE_MODIFIERS_DEPRECATED);
	}
	_tmp159_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp160_ = vfunc;
	vala_ccode_file_add_function (_tmp159_, _tmp160_);
	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 = 0L;
	_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 = NULL;
	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 = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (old != NULL, NULL);
	g_return_val_if_fail (replacement != NULL, NULL);
	if ((*((gchar*) self)) == '\0') {
		_tmp1_ = TRUE;
	} else {
		_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 __catch5_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 __catch5_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 __finally5;
	__catch5_g_regex_error:
	{
		GError* e = NULL;
		e = _inner_error0_;
		_inner_error0_ = NULL;
		g_assert_not_reached ();
		_g_error_free0 (e);
	}
	__finally5:
	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,
                                                        ValaCodeNode* method_node,
                                                        ValaDataType* ret_type,
                                                        ValaExpression* precondition)
{
	ValaCCodeFunctionCall* ccheck = NULL;
	ValaCCodeFunctionCall* _tmp0_;
	ValaCCodeFunctionCall* _tmp1_;
	ValaCCodeExpression* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	gchar* message = NULL;
	ValaSourceReference* _tmp4_;
	ValaSourceReference* _tmp5_;
	ValaSourceLocation _tmp6_ = {0};
	ValaSourceLocation _tmp7_;
	gchar* _tmp8_;
	ValaSourceReference* _tmp9_;
	ValaSourceReference* _tmp10_;
	ValaSourceLocation _tmp11_ = {0};
	ValaSourceLocation _tmp12_;
	gchar* _tmp13_;
	ValaSourceReference* _tmp14_;
	ValaSourceReference* _tmp15_;
	ValaSourceLocation _tmp16_ = {0};
	ValaSourceLocation _tmp17_;
	gchar* _tmp18_;
	gchar* _tmp19_;
	ValaCCodeFunctionCall* _tmp20_;
	const gchar* _tmp21_;
	gchar* _tmp22_;
	gchar* _tmp23_;
	gchar* _tmp24_;
	gchar* _tmp25_;
	gchar* _tmp26_;
	gchar* _tmp27_;
	ValaCCodeConstant* _tmp28_;
	ValaCCodeConstant* _tmp29_;
	ValaCCodeFunction* _tmp55_;
	ValaCCodeFunction* _tmp56_;
	ValaCCodeFunctionCall* _tmp57_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (method_node != NULL);
	g_return_if_fail (ret_type != NULL);
	g_return_if_fail (precondition != NULL);
	_tmp0_ = vala_ccode_function_call_new (NULL);
	ccheck = _tmp0_;
	vala_code_node_emit ((ValaCodeNode*) precondition, (ValaCodeGenerator*) self);
	_tmp1_ = ccheck;
	_tmp2_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, precondition);
	_tmp3_ = _tmp2_;
	vala_ccode_function_call_add_argument (_tmp1_, _tmp3_);
	_vala_ccode_node_unref0 (_tmp3_);
	_tmp4_ = vala_code_node_get_source_reference ((ValaCodeNode*) precondition);
	_tmp5_ = _tmp4_;
	vala_source_reference_get_begin (_tmp5_, &_tmp6_);
	_tmp7_ = _tmp6_;
	_tmp8_ = _tmp7_.pos;
	_tmp9_ = vala_code_node_get_source_reference ((ValaCodeNode*) precondition);
	_tmp10_ = _tmp9_;
	vala_source_reference_get_end (_tmp10_, &_tmp11_);
	_tmp12_ = _tmp11_;
	_tmp13_ = _tmp12_.pos;
	_tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) precondition);
	_tmp15_ = _tmp14_;
	vala_source_reference_get_begin (_tmp15_, &_tmp16_);
	_tmp17_ = _tmp16_;
	_tmp18_ = _tmp17_.pos;
	_tmp19_ = string_substring ((const gchar*) _tmp8_, (glong) 0, (glong) ((gint) (_tmp13_ - _tmp18_)));
	message = _tmp19_;
	_tmp20_ = ccheck;
	_tmp21_ = message;
	_tmp22_ = string_replace (_tmp21_, "\n", " ");
	_tmp23_ = _tmp22_;
	_tmp24_ = g_strescape (_tmp23_, "");
	_tmp25_ = _tmp24_;
	_tmp26_ = g_strdup_printf ("\"%s\"", _tmp25_);
	_tmp27_ = _tmp26_;
	_tmp28_ = vala_ccode_constant_new (_tmp27_);
	_tmp29_ = _tmp28_;
	vala_ccode_function_call_add_argument (_tmp20_, (ValaCCodeExpression*) _tmp29_);
	_vala_ccode_node_unref0 (_tmp29_);
	_g_free0 (_tmp27_);
	_g_free0 (_tmp25_);
	_g_free0 (_tmp23_);
	((ValaCCodeBaseModule*) self)->requires_assert = TRUE;
	if (G_TYPE_CHECK_INSTANCE_TYPE (method_node, VALA_TYPE_CREATION_METHOD)) {
		ValaCCodeFunctionCall* _tmp30_;
		ValaCCodeIdentifier* _tmp31_;
		ValaCCodeIdentifier* _tmp32_;
		ValaCCodeFunctionCall* _tmp33_;
		ValaCCodeConstant* _tmp34_;
		ValaCCodeConstant* _tmp35_;
		_tmp30_ = ccheck;
		_tmp31_ = vala_ccode_identifier_new ("_vala_return_val_if_fail");
		_tmp32_ = _tmp31_;
		vala_ccode_function_call_set_call (_tmp30_, (ValaCCodeExpression*) _tmp32_);
		_vala_ccode_node_unref0 (_tmp32_);
		_tmp33_ = ccheck;
		_tmp34_ = vala_ccode_constant_new ("NULL");
		_tmp35_ = _tmp34_;
		vala_ccode_function_call_add_argument (_tmp33_, (ValaCCodeExpression*) _tmp35_);
		_vala_ccode_node_unref0 (_tmp35_);
	} else {
		gboolean _tmp36_ = FALSE;
		if (G_TYPE_CHECK_INSTANCE_TYPE (method_node, VALA_TYPE_METHOD)) {
			gboolean _tmp37_;
			gboolean _tmp38_;
			_tmp37_ = vala_method_get_coroutine (G_TYPE_CHECK_INSTANCE_CAST (method_node, VALA_TYPE_METHOD, ValaMethod));
			_tmp38_ = _tmp37_;
			_tmp36_ = _tmp38_;
		} else {
			_tmp36_ = FALSE;
		}
		if (_tmp36_) {
			ValaCCodeFunctionCall* _tmp39_;
			ValaCCodeIdentifier* _tmp40_;
			ValaCCodeIdentifier* _tmp41_;
			ValaCCodeFunctionCall* _tmp42_;
			ValaCCodeConstant* _tmp43_;
			ValaCCodeConstant* _tmp44_;
			_tmp39_ = ccheck;
			_tmp40_ = vala_ccode_identifier_new ("_vala_return_val_if_fail");
			_tmp41_ = _tmp40_;
			vala_ccode_function_call_set_call (_tmp39_, (ValaCCodeExpression*) _tmp41_);
			_vala_ccode_node_unref0 (_tmp41_);
			_tmp42_ = ccheck;
			_tmp43_ = vala_ccode_constant_new ("FALSE");
			_tmp44_ = _tmp43_;
			vala_ccode_function_call_add_argument (_tmp42_, (ValaCCodeExpression*) _tmp44_);
			_vala_ccode_node_unref0 (_tmp44_);
		} else {
			if (G_TYPE_CHECK_INSTANCE_TYPE (ret_type, VALA_TYPE_VOID_TYPE)) {
				ValaCCodeFunctionCall* _tmp45_;
				ValaCCodeIdentifier* _tmp46_;
				ValaCCodeIdentifier* _tmp47_;
				_tmp45_ = ccheck;
				_tmp46_ = vala_ccode_identifier_new ("_vala_return_if_fail");
				_tmp47_ = _tmp46_;
				vala_ccode_function_call_set_call (_tmp45_, (ValaCCodeExpression*) _tmp47_);
				_vala_ccode_node_unref0 (_tmp47_);
			} else {
				ValaCCodeFunctionCall* _tmp48_;
				ValaCCodeIdentifier* _tmp49_;
				ValaCCodeIdentifier* _tmp50_;
				ValaCCodeExpression* cdefault = NULL;
				ValaCCodeExpression* _tmp51_;
				ValaCCodeExpression* _tmp52_;
				_tmp48_ = ccheck;
				_tmp49_ = vala_ccode_identifier_new ("_vala_return_val_if_fail");
				_tmp50_ = _tmp49_;
				vala_ccode_function_call_set_call (_tmp48_, (ValaCCodeExpression*) _tmp50_);
				_vala_ccode_node_unref0 (_tmp50_);
				_tmp51_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, ret_type, FALSE, FALSE);
				cdefault = _tmp51_;
				_tmp52_ = cdefault;
				if (_tmp52_ != NULL) {
					ValaCCodeFunctionCall* _tmp53_;
					ValaCCodeExpression* _tmp54_;
					_tmp53_ = ccheck;
					_tmp54_ = cdefault;
					vala_ccode_function_call_add_argument (_tmp53_, _tmp54_);
				} else {
					_vala_ccode_node_unref0 (cdefault);
					_g_free0 (message);
					_vala_ccode_node_unref0 (ccheck);
					return;
				}
				_vala_ccode_node_unref0 (cdefault);
			}
		}
	}
	_tmp55_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp56_ = _tmp55_;
	_tmp57_ = ccheck;
	vala_ccode_function_add_expression (_tmp56_, (ValaCCodeExpression*) _tmp57_);
	vala_ccode_base_module_set_current_method_return ((ValaCCodeBaseModule*) self, TRUE);
	_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_;
	ValaSourceFileType _tmp2_;
	ValaSourceFileType _tmp3_;
	gboolean _tmp4_ = FALSE;
	gboolean _tmp5_ = FALSE;
	ValaTypeSymbol* _tmp6_;
	ValaTypeSymbol* _tmp7_;
	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_);
	self->priv->ellipses_to_valist = TRUE;
	vala_code_visitor_visit_method ((ValaCodeVisitor*) self, (ValaMethod*) m);
	self->priv->ellipses_to_valist = FALSE;
	_tmp2_ = vala_symbol_get_source_type ((ValaSymbol*) m);
	_tmp3_ = _tmp2_;
	if (_tmp3_ == VALA_SOURCE_FILE_TYPE_FAST) {
		vala_ccode_base_module_pop_line ((ValaCCodeBaseModule*) self);
		return;
	}
	_tmp6_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);
	_tmp7_ = _tmp6_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_CLASS)) {
		ValaClass* _tmp8_;
		ValaClass* _tmp9_;
		gboolean _tmp10_;
		gboolean _tmp11_;
		_tmp8_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_class_get_is_compact (_tmp9_);
		_tmp11_ = _tmp10_;
		_tmp5_ = !_tmp11_;
	} else {
		_tmp5_ = FALSE;
	}
	if (_tmp5_) {
		ValaClass* _tmp12_;
		ValaClass* _tmp13_;
		gboolean _tmp14_;
		gboolean _tmp15_;
		_tmp12_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp13_ = _tmp12_;
		_tmp14_ = vala_class_get_is_abstract (_tmp13_);
		_tmp15_ = _tmp14_;
		_tmp4_ = !_tmp15_;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		gchar* _tmp16_;
		gchar* _tmp17_;
		_tmp16_ = vala_get_ccode_name ((ValaCodeNode*) m);
		_tmp17_ = _tmp16_;
		vala_ccode_method_module_create_aux_constructor (self, m, _tmp17_, FALSE);
		_g_free0 (_tmp17_);
		if (vala_method_is_variadic ((ValaMethod*) m)) {
			gchar* _tmp18_;
			gchar* _tmp19_;
			_tmp18_ = vala_get_ccode_real_name ((ValaSymbol*) m);
			_tmp19_ = _tmp18_;
			vala_ccode_method_module_create_aux_constructor (self, m, _tmp19_, TRUE);
			_g_free0 (_tmp19_);
		}
	}
	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* _tmp79_;
	ValaCCodeFunction* _tmp80_;
	ValaCCodeFunctionCall* _tmp81_;
	ValaCCodeFile* _tmp82_;
	ValaCCodeFunction* _tmp83_;
	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;
		ValaCCodeFunctionCall* va_start = NULL;
		ValaCCodeIdentifier* _tmp58_;
		ValaCCodeIdentifier* _tmp59_;
		ValaCCodeFunctionCall* _tmp60_;
		ValaCCodeFunctionCall* _tmp61_;
		ValaCCodeFunctionCall* _tmp62_;
		ValaCCodeIdentifier* _tmp63_;
		ValaCCodeIdentifier* _tmp64_;
		ValaCCodeFunctionCall* _tmp65_;
		ValaHashMap* _tmp66_;
		gpointer _tmp67_;
		ValaCCodeExpression* _tmp68_;
		ValaCCodeFunction* _tmp69_;
		ValaCCodeFunction* _tmp70_;
		ValaCCodeVariableDeclarator* _tmp71_;
		ValaCCodeVariableDeclarator* _tmp72_;
		ValaCCodeFunction* _tmp73_;
		ValaCCodeFunction* _tmp74_;
		ValaCCodeFunctionCall* _tmp75_;
		ValaCCodeFunctionCall* _tmp76_;
		ValaCCodeIdentifier* _tmp77_;
		ValaCCodeIdentifier* _tmp78_;
		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_ = vala_ccode_identifier_new ("va_start");
		_tmp59_ = _tmp58_;
		_tmp60_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp59_);
		_tmp61_ = _tmp60_;
		_vala_ccode_node_unref0 (_tmp59_);
		va_start = _tmp61_;
		_tmp62_ = va_start;
		_tmp63_ = vala_ccode_identifier_new ("_vala_va_list_obj");
		_tmp64_ = _tmp63_;
		vala_ccode_function_call_add_argument (_tmp62_, (ValaCCodeExpression*) _tmp64_);
		_vala_ccode_node_unref0 (_tmp64_);
		_tmp65_ = va_start;
		_tmp66_ = carg_map;
		_tmp67_ = vala_map_get ((ValaMap*) _tmp66_, (gpointer) ((gintptr) second_last_pos));
		_tmp68_ = (ValaCCodeExpression*) _tmp67_;
		vala_ccode_function_call_add_argument (_tmp65_, _tmp68_);
		_vala_ccode_node_unref0 (_tmp68_);
		_tmp69_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp70_ = _tmp69_;
		_tmp71_ = vala_ccode_variable_declarator_new ("_vala_va_list_obj", NULL, NULL);
		_tmp72_ = _tmp71_;
		vala_ccode_function_add_declaration (_tmp70_, "va_list", (ValaCCodeDeclarator*) _tmp72_, 0);
		_vala_ccode_node_unref0 (_tmp72_);
		_tmp73_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp74_ = _tmp73_;
		_tmp75_ = va_start;
		vala_ccode_function_add_expression (_tmp74_, (ValaCCodeExpression*) _tmp75_);
		_tmp76_ = vcall;
		_tmp77_ = vala_ccode_identifier_new ("_vala_va_list_obj");
		_tmp78_ = _tmp77_;
		vala_ccode_function_call_add_argument (_tmp76_, (ValaCCodeExpression*) _tmp78_);
		_vala_ccode_node_unref0 (_tmp78_);
		_vala_ccode_node_unref0 (va_start);
	}
	_tmp79_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp80_ = _tmp79_;
	_tmp81_ = vcall;
	vala_ccode_function_add_return (_tmp80_, (ValaCCodeExpression*) _tmp81_);
	vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
	_tmp82_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp83_ = vfunc;
	vala_ccode_file_add_function (_tmp82_, _tmp83_);
	_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);
	((ValaCCodeBaseModuleClass *) klass)->method_has_wrapper = (gboolean (*) (ValaCCodeBaseModule*, ValaMethod*)) vala_ccode_method_module_real_method_has_wrapper;
	((ValaCCodeMethodModuleClass *) klass)->generate_method_result_declaration = (void (*) (ValaCCodeMethodModule*, ValaMethod*, ValaCCodeFile*, ValaCCodeFunction*, ValaMap*, ValaMap*)) vala_ccode_method_module_real_generate_method_result_declaration;
	((ValaCCodeBaseModuleClass *) klass)->generate_method_declaration = (void (*) (ValaCCodeBaseModule*, ValaMethod*, ValaCCodeFile*)) vala_ccode_method_module_real_generate_method_declaration;
	((ValaCodeVisitorClass *) klass)->visit_method = (void (*) (ValaCodeVisitor*, ValaMethod*)) vala_ccode_method_module_real_visit_method;
	((ValaCCodeMethodModuleClass *) klass)->generate_parameter = (ValaCCodeParameter* (*) (ValaCCodeMethodModule*, ValaParameter*, ValaCCodeFile*, ValaMap*, ValaMap*)) vala_ccode_method_module_real_generate_parameter;
	((ValaCCodeBaseModuleClass *) klass)->generate_cparameters = (void (*) (ValaCCodeBaseModule*, ValaMethod*, ValaCCodeFile*, ValaMap*, ValaCCodeFunction*, ValaCCodeFunctionDeclarator*, ValaMap*, ValaCCodeFunctionCall*, gint)) vala_ccode_method_module_real_generate_cparameters;
	((ValaCodeVisitorClass *) klass)->visit_creation_method = (void (*) (ValaCodeVisitor*, ValaCreationMethod*)) vala_ccode_method_module_real_visit_creation_method;
}

static void
vala_ccode_method_module_instance_init (ValaCCodeMethodModule * self,
                                        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.
 */
GType
vala_ccode_method_module_get_type (void)
{
	static volatile gsize vala_ccode_method_module_type_id__volatile = 0;
	if (g_once_init_enter (&vala_ccode_method_module_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeMethodModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_method_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeMethodModule), 0, (GInstanceInitFunc) vala_ccode_method_module_instance_init, NULL };
		GType vala_ccode_method_module_type_id;
		vala_ccode_method_module_type_id = g_type_register_static (VALA_TYPE_CCODE_STRUCT_MODULE, "ValaCCodeMethodModule", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
		ValaCCodeMethodModule_private_offset = g_type_add_instance_private (vala_ccode_method_module_type_id, sizeof (ValaCCodeMethodModulePrivate));
		g_once_init_leave (&vala_ccode_method_module_type_id__volatile, vala_ccode_method_module_type_id);
	}
	return vala_ccode_method_module_type_id__volatile;
}

