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

/* valaccodeattribute.vala
 *
 * Copyright (C) 2011  Luca Bruno
 *
 * 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:
 * 	Luca Bruno <lucabru@src.gnome.org>
 */

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

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

#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

struct _ValaCCodeAttributePrivate {
	ValaCodeNode* node;
	ValaSymbol* sym;
	ValaAttribute* ccode;
	gchar* _array_length_name;
	gchar* _array_length_expr;
	gchar* _name;
	gchar* _const_name;
	gchar* _type_name;
	gchar* _feature_test_macros;
	gchar* _header_filenames;
	gchar* _prefix;
	gchar* _lower_case_prefix;
	gchar* _lower_case_suffix;
	gchar* _ref_function;
	gboolean ref_function_set;
	gboolean* _ref_function_void;
	gchar* _unref_function;
	gboolean unref_function_set;
	gchar* _ref_sink_function;
	gchar* _copy_function;
	gboolean copy_function_set;
	gchar* _destroy_function;
	gboolean destroy_function_set;
	gchar* _dup_function;
	gboolean dup_function_set;
	gchar* _free_function;
	gboolean free_function_set;
	gboolean* _free_function_address_of;
	gchar* _type_id;
	gchar* _marshaller_type_name;
	gchar* _get_value_function;
	gchar* _set_value_function;
	gchar* _take_value_function;
	gchar* _param_spec_function;
	gchar* _default_value;
	gchar* _default_value_on_error;
	gdouble* _pos;
	gchar* _vfunc_name;
	gchar* _finish_name;
	gchar* _finish_vfunc_name;
	gchar* _finish_real_name;
	gboolean* _finish_instance;
	gchar* _real_name;
	gboolean* _delegate_target;
	gchar* _delegate_target_name;
	gchar* _delegate_target_destroy_notify_name;
	gchar* _ctype;
	gboolean ctype_set;
	gboolean* _array_length;
	gchar* _array_length_type;
	gboolean* _array_null_terminated;
	gchar* _sentinel;
};

static gint ValaCCodeAttribute_private_offset;
static gpointer vala_ccode_attribute_parent_class = NULL;
static gint vala_ccode_attribute_dynamic_method_id;
static gint vala_ccode_attribute_dynamic_method_id = 0;

static gchar* vala_ccode_attribute_get_default_name (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_const_name (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_header_filenames (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_prefix (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_lower_case_prefix (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_lower_case_suffix (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_ref_function (ValaCCodeAttribute* self);
static gboolean* _bool_dup (gboolean* self);
static gchar* vala_ccode_attribute_get_default_unref_function (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_ref_sink_function (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_free_function (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_type_id (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_marshaller_type_name (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_get_value_function (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_set_value_function (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_take_value_function (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_param_spec_function (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_default_value (ValaCCodeAttribute* self);
static gdouble* _double_dup (gdouble* self);
static gchar* vala_ccode_attribute_get_default_real_name (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_finish_name_for_basename (ValaCCodeAttribute* self,
                                                          const gchar* basename);
static gboolean vala_ccode_attribute_get_default_delegate_target (ValaCCodeAttribute* self);
static gboolean vala_ccode_attribute_get_default_array_length (ValaCCodeAttribute* self);
static gboolean vala_ccode_attribute_get_default_array_null_terminated (ValaCCodeAttribute* self);
static gchar* vala_ccode_attribute_get_default_array_length_type (ValaCCodeAttribute* self);
static void vala_ccode_attribute_set_array_length_name (ValaCCodeAttribute* self,
                                                 const gchar* value);
static void vala_ccode_attribute_set_array_length_expr (ValaCCodeAttribute* self,
                                                 const gchar* value);
 G_GNUC_INTERNAL ValaCCodeAttribute* vala_get_ccode_attribute (ValaCodeNode* node);
static void vala_ccode_attribute_finalize (ValaAttributeCache * obj);
static GType vala_ccode_attribute_get_type_once (void);

static inline gpointer
vala_ccode_attribute_get_instance_private (ValaCCodeAttribute* self)
{
	return G_STRUCT_MEMBER_P (self, ValaCCodeAttribute_private_offset);
}

const gchar*
vala_ccode_attribute_get_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_name;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "cname", NULL);
			_g_free0 (self->priv->_name);
			self->priv->_name = _tmp3_;
		}
		_tmp4_ = self->priv->_name;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_name (self);
			_g_free0 (self->priv->_name);
			self->priv->_name = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_name;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_const_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_const_name;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "const_cname", NULL);
			_g_free0 (self->priv->_const_name);
			self->priv->_const_name = _tmp3_;
		}
		_tmp4_ = self->priv->_const_name;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_const_name (self);
			_g_free0 (self->priv->_const_name);
			self->priv->_const_name = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_const_name;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_type_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp19_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_type_name;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "type_cname", NULL);
			_g_free0 (self->priv->_type_name);
			self->priv->_type_name = _tmp3_;
		}
		_tmp4_ = self->priv->_type_name;
		if (_tmp4_ == NULL) {
			ValaSymbol* _tmp5_;
			_tmp5_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_CLASS)) {
				ValaSymbol* _tmp6_;
				gchar* _tmp7_;
				gchar* _tmp8_;
				gchar* _tmp9_;
				_tmp6_ = self->priv->sym;
				_tmp7_ = vala_get_ccode_name ((ValaCodeNode*) _tmp6_);
				_tmp8_ = _tmp7_;
				_tmp9_ = g_strdup_printf ("%sClass", _tmp8_);
				_g_free0 (self->priv->_type_name);
				self->priv->_type_name = _tmp9_;
				_g_free0 (_tmp8_);
			} else {
				ValaSymbol* _tmp10_;
				_tmp10_ = self->priv->sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_INTERFACE)) {
					ValaSymbol* _tmp11_;
					gchar* _tmp12_;
					gchar* _tmp13_;
					gchar* _tmp14_;
					_tmp11_ = self->priv->sym;
					_tmp12_ = vala_get_ccode_name ((ValaCodeNode*) _tmp11_);
					_tmp13_ = _tmp12_;
					_tmp14_ = g_strdup_printf ("%sIface", _tmp13_);
					_g_free0 (self->priv->_type_name);
					self->priv->_type_name = _tmp14_;
					_g_free0 (_tmp13_);
				} else {
					ValaSymbol* _tmp15_;
					ValaSourceReference* _tmp16_;
					ValaSourceReference* _tmp17_;
					gchar* _tmp18_;
					_tmp15_ = self->priv->sym;
					_tmp16_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp15_);
					_tmp17_ = _tmp16_;
					vala_report_error (_tmp17_, "`CCode.type_cname' not supported");
					_tmp18_ = g_strdup ("");
					_g_free0 (self->priv->_type_name);
					self->priv->_type_name = _tmp18_;
				}
			}
		}
	}
	_tmp19_ = self->priv->_type_name;
	result = _tmp19_;
	return result;
}

const gchar*
vala_ccode_attribute_get_feature_test_macros (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_feature_test_macros;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "feature_test_macro", NULL);
			_g_free0 (self->priv->_feature_test_macros);
			self->priv->_feature_test_macros = _tmp3_;
		}
		_tmp4_ = self->priv->_feature_test_macros;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = g_strdup ("");
			_g_free0 (self->priv->_feature_test_macros);
			self->priv->_feature_test_macros = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_feature_test_macros;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_header_filenames (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_header_filenames;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "cheader_filename", NULL);
			_g_free0 (self->priv->_header_filenames);
			self->priv->_header_filenames = _tmp3_;
		}
		_tmp4_ = self->priv->_header_filenames;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_header_filenames (self);
			_g_free0 (self->priv->_header_filenames);
			self->priv->_header_filenames = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_header_filenames;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_prefix (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_prefix;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "cprefix", NULL);
			_g_free0 (self->priv->_prefix);
			self->priv->_prefix = _tmp3_;
		}
		_tmp4_ = self->priv->_prefix;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_prefix (self);
			_g_free0 (self->priv->_prefix);
			self->priv->_prefix = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_prefix;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_lower_case_prefix (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp13_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_lower_case_prefix;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp11_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			gboolean _tmp4_ = FALSE;
			const gchar* _tmp5_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "lower_case_cprefix", NULL);
			_g_free0 (self->priv->_lower_case_prefix);
			self->priv->_lower_case_prefix = _tmp3_;
			_tmp5_ = self->priv->_lower_case_prefix;
			if (_tmp5_ == NULL) {
				gboolean _tmp6_ = FALSE;
				ValaSymbol* _tmp7_;
				_tmp7_ = self->priv->sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) {
					_tmp6_ = TRUE;
				} else {
					ValaSymbol* _tmp8_;
					_tmp8_ = self->priv->sym;
					_tmp6_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_STRUCT);
				}
				_tmp4_ = _tmp6_;
			} else {
				_tmp4_ = FALSE;
			}
			if (_tmp4_) {
				ValaAttribute* _tmp9_;
				gchar* _tmp10_;
				_tmp9_ = self->priv->ccode;
				_tmp10_ = vala_attribute_get_string (_tmp9_, "cprefix", NULL);
				_g_free0 (self->priv->_lower_case_prefix);
				self->priv->_lower_case_prefix = _tmp10_;
			}
		}
		_tmp11_ = self->priv->_lower_case_prefix;
		if (_tmp11_ == NULL) {
			gchar* _tmp12_;
			_tmp12_ = vala_ccode_attribute_get_default_lower_case_prefix (self);
			_g_free0 (self->priv->_lower_case_prefix);
			self->priv->_lower_case_prefix = _tmp12_;
		}
	}
	_tmp13_ = self->priv->_lower_case_prefix;
	result = _tmp13_;
	return result;
}

const gchar*
vala_ccode_attribute_get_lower_case_suffix (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_lower_case_suffix;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "lower_case_csuffix", NULL);
			_g_free0 (self->priv->_lower_case_suffix);
			self->priv->_lower_case_suffix = _tmp3_;
		}
		_tmp4_ = self->priv->_lower_case_suffix;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_lower_case_suffix (self);
			_g_free0 (self->priv->_lower_case_suffix);
			self->priv->_lower_case_suffix = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_lower_case_suffix;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_ref_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp5_;
	g_return_val_if_fail (self != NULL, NULL);
	if (!self->priv->ref_function_set) {
		ValaAttribute* _tmp0_;
		const gchar* _tmp3_;
		_tmp0_ = self->priv->ccode;
		if (_tmp0_ != NULL) {
			ValaAttribute* _tmp1_;
			gchar* _tmp2_;
			_tmp1_ = self->priv->ccode;
			_tmp2_ = vala_attribute_get_string (_tmp1_, "ref_function", NULL);
			_g_free0 (self->priv->_ref_function);
			self->priv->_ref_function = _tmp2_;
		}
		_tmp3_ = self->priv->_ref_function;
		if (_tmp3_ == NULL) {
			gchar* _tmp4_;
			_tmp4_ = vala_ccode_attribute_get_default_ref_function (self);
			_g_free0 (self->priv->_ref_function);
			self->priv->_ref_function = _tmp4_;
		}
		self->priv->ref_function_set = TRUE;
	}
	_tmp5_ = self->priv->_ref_function;
	result = _tmp5_;
	return result;
}

static gboolean*
_bool_dup (gboolean* self)
{
	gboolean* dup;
	dup = g_new0 (gboolean, 1);
	memcpy (dup, self, sizeof (gboolean));
	return dup;
}

static gpointer
__bool_dup0 (gpointer self)
{
	return self ? _bool_dup (self) : NULL;
}

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

gboolean
vala_ccode_attribute_get_ref_function_void (ValaCCodeAttribute* self)
{
	gboolean result;
	gboolean* _tmp0_;
	gboolean* _tmp19_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_ref_function_void;
	if (_tmp0_ == NULL) {
		gboolean _tmp1_ = FALSE;
		ValaAttribute* _tmp2_;
		_tmp2_ = self->priv->ccode;
		if (_tmp2_ != NULL) {
			ValaAttribute* _tmp3_;
			_tmp3_ = self->priv->ccode;
			_tmp1_ = vala_attribute_has_argument (_tmp3_, "ref_function_void");
		} else {
			_tmp1_ = FALSE;
		}
		if (_tmp1_) {
			ValaAttribute* _tmp4_;
			gboolean _tmp5_;
			gboolean* _tmp6_;
			_tmp4_ = self->priv->ccode;
			_tmp5_ = vala_attribute_get_bool (_tmp4_, "ref_function_void", FALSE);
			_tmp6_ = __bool_dup0 (&_tmp5_);
			_g_free0 (self->priv->_ref_function_void);
			self->priv->_ref_function_void = _tmp6_;
		} else {
			ValaClass* cl = NULL;
			ValaSymbol* _tmp7_;
			ValaClass* _tmp8_;
			ValaClass* _tmp9_;
			ValaClass* _tmp10_;
			ValaClass* _tmp11_;
			_tmp7_ = self->priv->sym;
			_tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_CLASS, ValaClass));
			cl = _tmp8_;
			_tmp9_ = cl;
			_tmp10_ = vala_class_get_base_class (_tmp9_);
			_tmp11_ = _tmp10_;
			if (_tmp11_ != NULL) {
				ValaClass* _tmp12_;
				ValaClass* _tmp13_;
				ValaClass* _tmp14_;
				gboolean _tmp15_;
				gboolean* _tmp16_;
				_tmp12_ = cl;
				_tmp13_ = vala_class_get_base_class (_tmp12_);
				_tmp14_ = _tmp13_;
				_tmp15_ = vala_get_ccode_ref_function_void (_tmp14_);
				_tmp16_ = __bool_dup0 (&_tmp15_);
				_g_free0 (self->priv->_ref_function_void);
				self->priv->_ref_function_void = _tmp16_;
			} else {
				gboolean _tmp17_;
				gboolean* _tmp18_;
				_tmp17_ = FALSE;
				_tmp18_ = __bool_dup0 (&_tmp17_);
				_g_free0 (self->priv->_ref_function_void);
				self->priv->_ref_function_void = _tmp18_;
			}
			_vala_code_node_unref0 (cl);
		}
	}
	_tmp19_ = self->priv->_ref_function_void;
	result = *_tmp19_;
	return result;
}

const gchar*
vala_ccode_attribute_get_unref_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp5_;
	g_return_val_if_fail (self != NULL, NULL);
	if (!self->priv->unref_function_set) {
		ValaAttribute* _tmp0_;
		const gchar* _tmp3_;
		_tmp0_ = self->priv->ccode;
		if (_tmp0_ != NULL) {
			ValaAttribute* _tmp1_;
			gchar* _tmp2_;
			_tmp1_ = self->priv->ccode;
			_tmp2_ = vala_attribute_get_string (_tmp1_, "unref_function", NULL);
			_g_free0 (self->priv->_unref_function);
			self->priv->_unref_function = _tmp2_;
		}
		_tmp3_ = self->priv->_unref_function;
		if (_tmp3_ == NULL) {
			gchar* _tmp4_;
			_tmp4_ = vala_ccode_attribute_get_default_unref_function (self);
			_g_free0 (self->priv->_unref_function);
			self->priv->_unref_function = _tmp4_;
		}
		self->priv->unref_function_set = TRUE;
	}
	_tmp5_ = self->priv->_unref_function;
	result = _tmp5_;
	return result;
}

const gchar*
vala_ccode_attribute_get_ref_sink_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_ref_sink_function;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "ref_sink_function", NULL);
			_g_free0 (self->priv->_ref_sink_function);
			self->priv->_ref_sink_function = _tmp3_;
		}
		_tmp4_ = self->priv->_ref_sink_function;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_ref_sink_function (self);
			_g_free0 (self->priv->_ref_sink_function);
			self->priv->_ref_sink_function = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_ref_sink_function;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_copy_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp18_;
	g_return_val_if_fail (self != NULL, NULL);
	if (!self->priv->copy_function_set) {
		ValaAttribute* _tmp0_;
		gboolean _tmp3_ = FALSE;
		const gchar* _tmp4_;
		gboolean _tmp9_ = FALSE;
		const gchar* _tmp10_;
		_tmp0_ = self->priv->ccode;
		if (_tmp0_ != NULL) {
			ValaAttribute* _tmp1_;
			gchar* _tmp2_;
			_tmp1_ = self->priv->ccode;
			_tmp2_ = vala_attribute_get_string (_tmp1_, "copy_function", NULL);
			_g_free0 (self->priv->_copy_function);
			self->priv->_copy_function = _tmp2_;
		}
		_tmp4_ = self->priv->_copy_function;
		if (_tmp4_ == NULL) {
			ValaSymbol* _tmp5_;
			_tmp5_ = self->priv->sym;
			_tmp3_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_STRUCT);
		} else {
			_tmp3_ = FALSE;
		}
		if (_tmp3_) {
			const gchar* _tmp6_;
			const gchar* _tmp7_;
			gchar* _tmp8_;
			_tmp6_ = vala_ccode_attribute_get_lower_case_prefix (self);
			_tmp7_ = _tmp6_;
			_tmp8_ = g_strdup_printf ("%scopy", _tmp7_);
			_g_free0 (self->priv->_copy_function);
			self->priv->_copy_function = _tmp8_;
		}
		_tmp10_ = self->priv->_copy_function;
		if (_tmp10_ == NULL) {
			ValaSymbol* _tmp11_;
			_tmp11_ = self->priv->sym;
			_tmp9_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp11_, VALA_TYPE_TYPEPARAMETER);
		} else {
			_tmp9_ = FALSE;
		}
		if (_tmp9_) {
			ValaSymbol* _tmp12_;
			const gchar* _tmp13_;
			const gchar* _tmp14_;
			gchar* _tmp15_;
			gchar* _tmp16_;
			gchar* _tmp17_;
			_tmp12_ = self->priv->sym;
			_tmp13_ = vala_symbol_get_name (_tmp12_);
			_tmp14_ = _tmp13_;
			_tmp15_ = g_ascii_strdown (_tmp14_, (gssize) -1);
			_tmp16_ = _tmp15_;
			_tmp17_ = g_strdup_printf ("%s_dup_func", _tmp16_);
			_g_free0 (self->priv->_copy_function);
			self->priv->_copy_function = _tmp17_;
			_g_free0 (_tmp16_);
		}
		self->priv->copy_function_set = TRUE;
	}
	_tmp18_ = self->priv->_copy_function;
	result = _tmp18_;
	return result;
}

const gchar*
vala_ccode_attribute_get_destroy_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp18_;
	g_return_val_if_fail (self != NULL, NULL);
	if (!self->priv->destroy_function_set) {
		ValaAttribute* _tmp0_;
		gboolean _tmp3_ = FALSE;
		const gchar* _tmp4_;
		gboolean _tmp9_ = FALSE;
		const gchar* _tmp10_;
		_tmp0_ = self->priv->ccode;
		if (_tmp0_ != NULL) {
			ValaAttribute* _tmp1_;
			gchar* _tmp2_;
			_tmp1_ = self->priv->ccode;
			_tmp2_ = vala_attribute_get_string (_tmp1_, "destroy_function", NULL);
			_g_free0 (self->priv->_destroy_function);
			self->priv->_destroy_function = _tmp2_;
		}
		_tmp4_ = self->priv->_destroy_function;
		if (_tmp4_ == NULL) {
			ValaSymbol* _tmp5_;
			_tmp5_ = self->priv->sym;
			_tmp3_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_STRUCT);
		} else {
			_tmp3_ = FALSE;
		}
		if (_tmp3_) {
			const gchar* _tmp6_;
			const gchar* _tmp7_;
			gchar* _tmp8_;
			_tmp6_ = vala_ccode_attribute_get_lower_case_prefix (self);
			_tmp7_ = _tmp6_;
			_tmp8_ = g_strdup_printf ("%sdestroy", _tmp7_);
			_g_free0 (self->priv->_destroy_function);
			self->priv->_destroy_function = _tmp8_;
		}
		_tmp10_ = self->priv->_destroy_function;
		if (_tmp10_ == NULL) {
			ValaSymbol* _tmp11_;
			_tmp11_ = self->priv->sym;
			_tmp9_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp11_, VALA_TYPE_TYPEPARAMETER);
		} else {
			_tmp9_ = FALSE;
		}
		if (_tmp9_) {
			ValaSymbol* _tmp12_;
			const gchar* _tmp13_;
			const gchar* _tmp14_;
			gchar* _tmp15_;
			gchar* _tmp16_;
			gchar* _tmp17_;
			_tmp12_ = self->priv->sym;
			_tmp13_ = vala_symbol_get_name (_tmp12_);
			_tmp14_ = _tmp13_;
			_tmp15_ = g_ascii_strdown (_tmp14_, (gssize) -1);
			_tmp16_ = _tmp15_;
			_tmp17_ = g_strdup_printf ("%s_destroy_func", _tmp16_);
			_g_free0 (self->priv->_destroy_function);
			self->priv->_destroy_function = _tmp17_;
			_g_free0 (_tmp16_);
		}
		self->priv->destroy_function_set = TRUE;
	}
	_tmp18_ = self->priv->_destroy_function;
	result = _tmp18_;
	return result;
}

const gchar*
vala_ccode_attribute_get_dup_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp15_;
	g_return_val_if_fail (self != NULL, NULL);
	if (!self->priv->dup_function_set) {
		ValaAttribute* _tmp0_;
		gboolean _tmp3_ = FALSE;
		gboolean _tmp4_ = FALSE;
		gboolean _tmp5_ = FALSE;
		const gchar* _tmp6_;
		_tmp0_ = self->priv->ccode;
		if (_tmp0_ != NULL) {
			ValaAttribute* _tmp1_;
			gchar* _tmp2_;
			_tmp1_ = self->priv->ccode;
			_tmp2_ = vala_attribute_get_string (_tmp1_, "dup_function", NULL);
			_g_free0 (self->priv->_dup_function);
			self->priv->_dup_function = _tmp2_;
		}
		_tmp6_ = self->priv->_dup_function;
		if (_tmp6_ == NULL) {
			ValaSymbol* _tmp7_;
			gboolean _tmp8_;
			gboolean _tmp9_;
			_tmp7_ = self->priv->sym;
			_tmp8_ = vala_symbol_get_external_package (_tmp7_);
			_tmp9_ = _tmp8_;
			_tmp5_ = !_tmp9_;
		} else {
			_tmp5_ = FALSE;
		}
		if (_tmp5_) {
			ValaSymbol* _tmp10_;
			_tmp10_ = self->priv->sym;
			_tmp4_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_STRUCT);
		} else {
			_tmp4_ = FALSE;
		}
		if (_tmp4_) {
			ValaSymbol* _tmp11_;
			_tmp11_ = self->priv->sym;
			_tmp3_ = !vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_STRUCT, ValaStruct));
		} else {
			_tmp3_ = FALSE;
		}
		if (_tmp3_) {
			const gchar* _tmp12_;
			const gchar* _tmp13_;
			gchar* _tmp14_;
			_tmp12_ = vala_ccode_attribute_get_lower_case_prefix (self);
			_tmp13_ = _tmp12_;
			_tmp14_ = g_strdup_printf ("%sdup", _tmp13_);
			_g_free0 (self->priv->_dup_function);
			self->priv->_dup_function = _tmp14_;
		}
		self->priv->dup_function_set = TRUE;
	}
	_tmp15_ = self->priv->_dup_function;
	result = _tmp15_;
	return result;
}

const gchar*
vala_ccode_attribute_get_free_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp5_;
	g_return_val_if_fail (self != NULL, NULL);
	if (!self->priv->free_function_set) {
		ValaAttribute* _tmp0_;
		const gchar* _tmp3_;
		_tmp0_ = self->priv->ccode;
		if (_tmp0_ != NULL) {
			ValaAttribute* _tmp1_;
			gchar* _tmp2_;
			_tmp1_ = self->priv->ccode;
			_tmp2_ = vala_attribute_get_string (_tmp1_, "free_function", NULL);
			_g_free0 (self->priv->_free_function);
			self->priv->_free_function = _tmp2_;
		}
		_tmp3_ = self->priv->_free_function;
		if (_tmp3_ == NULL) {
			gchar* _tmp4_;
			_tmp4_ = vala_ccode_attribute_get_default_free_function (self);
			_g_free0 (self->priv->_free_function);
			self->priv->_free_function = _tmp4_;
		}
		self->priv->free_function_set = TRUE;
	}
	_tmp5_ = self->priv->_free_function;
	result = _tmp5_;
	return result;
}

gboolean
vala_ccode_attribute_get_free_function_address_of (ValaCCodeAttribute* self)
{
	gboolean result;
	gboolean* _tmp0_;
	gboolean* _tmp18_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_free_function_address_of;
	if (_tmp0_ == NULL) {
		gboolean _tmp1_ = FALSE;
		ValaAttribute* _tmp2_;
		_tmp2_ = self->priv->ccode;
		if (_tmp2_ != NULL) {
			ValaAttribute* _tmp3_;
			_tmp3_ = self->priv->ccode;
			_tmp1_ = vala_attribute_has_argument (_tmp3_, "free_function_address_of");
		} else {
			_tmp1_ = FALSE;
		}
		if (_tmp1_) {
			ValaAttribute* _tmp4_;
			gboolean _tmp5_;
			gboolean* _tmp6_;
			_tmp4_ = self->priv->ccode;
			_tmp5_ = vala_attribute_get_bool (_tmp4_, "free_function_address_of", FALSE);
			_tmp6_ = __bool_dup0 (&_tmp5_);
			_g_free0 (self->priv->_free_function_address_of);
			self->priv->_free_function_address_of = _tmp6_;
		} else {
			ValaClass* cl = NULL;
			ValaSymbol* _tmp7_;
			ValaClass* _tmp8_;
			ValaClass* _tmp9_;
			ValaClass* _tmp10_;
			_tmp7_ = self->priv->sym;
			cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_CLASS, ValaClass);
			_tmp8_ = cl;
			_tmp9_ = vala_class_get_base_class (_tmp8_);
			_tmp10_ = _tmp9_;
			if (_tmp10_ != NULL) {
				ValaClass* _tmp11_;
				ValaClass* _tmp12_;
				ValaClass* _tmp13_;
				gboolean _tmp14_;
				gboolean* _tmp15_;
				_tmp11_ = cl;
				_tmp12_ = vala_class_get_base_class (_tmp11_);
				_tmp13_ = _tmp12_;
				_tmp14_ = vala_get_ccode_free_function_address_of (_tmp13_);
				_tmp15_ = __bool_dup0 (&_tmp14_);
				_g_free0 (self->priv->_free_function_address_of);
				self->priv->_free_function_address_of = _tmp15_;
			} else {
				gboolean _tmp16_;
				gboolean* _tmp17_;
				_tmp16_ = FALSE;
				_tmp17_ = __bool_dup0 (&_tmp16_);
				_g_free0 (self->priv->_free_function_address_of);
				self->priv->_free_function_address_of = _tmp17_;
			}
		}
	}
	_tmp18_ = self->priv->_free_function_address_of;
	result = *_tmp18_;
	return result;
}

const gchar*
vala_ccode_attribute_get_ctype (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp10_;
	g_return_val_if_fail (self != NULL, NULL);
	if (!self->priv->ctype_set) {
		ValaAttribute* _tmp0_;
		_tmp0_ = self->priv->ccode;
		if (_tmp0_ != NULL) {
			ValaAttribute* _tmp1_;
			gchar* _tmp2_;
			const gchar* _tmp3_;
			_tmp1_ = self->priv->ccode;
			_tmp2_ = vala_attribute_get_string (_tmp1_, "type", NULL);
			_g_free0 (self->priv->_ctype);
			self->priv->_ctype = _tmp2_;
			_tmp3_ = self->priv->_ctype;
			if (_tmp3_ == NULL) {
				ValaAttribute* _tmp4_;
				gchar* _tmp5_;
				const gchar* _tmp6_;
				_tmp4_ = self->priv->ccode;
				_tmp5_ = vala_attribute_get_string (_tmp4_, "ctype", NULL);
				_g_free0 (self->priv->_ctype);
				self->priv->_ctype = _tmp5_;
				_tmp6_ = self->priv->_ctype;
				if (_tmp6_ != NULL) {
					ValaCodeNode* _tmp7_;
					ValaSourceReference* _tmp8_;
					ValaSourceReference* _tmp9_;
					_tmp7_ = self->priv->node;
					_tmp8_ = vala_code_node_get_source_reference (_tmp7_);
					_tmp9_ = _tmp8_;
					vala_report_deprecated (_tmp9_, "[CCode (ctype = \"...\")] is deprecated, use [CCode (type = \"...\")] " \
"instead.");
				}
			}
		}
		self->priv->ctype_set = TRUE;
	}
	_tmp10_ = self->priv->_ctype;
	result = _tmp10_;
	return result;
}

const gchar*
vala_ccode_attribute_get_type_id (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp15_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_type_id;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		gboolean _tmp4_ = FALSE;
		const gchar* _tmp5_;
		const gchar* _tmp13_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "type_id", NULL);
			_g_free0 (self->priv->_type_id);
			self->priv->_type_id = _tmp3_;
		}
		_tmp5_ = self->priv->_type_id;
		if (_tmp5_ == NULL) {
			ValaSymbol* _tmp6_;
			_tmp6_ = self->priv->sym;
			_tmp4_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_TYPEPARAMETER);
		} else {
			_tmp4_ = FALSE;
		}
		if (_tmp4_) {
			ValaSymbol* _tmp7_;
			const gchar* _tmp8_;
			const gchar* _tmp9_;
			gchar* _tmp10_;
			gchar* _tmp11_;
			gchar* _tmp12_;
			_tmp7_ = self->priv->sym;
			_tmp8_ = vala_symbol_get_name (_tmp7_);
			_tmp9_ = _tmp8_;
			_tmp10_ = g_ascii_strdown (_tmp9_, (gssize) -1);
			_tmp11_ = _tmp10_;
			_tmp12_ = g_strdup_printf ("%s_type", _tmp11_);
			_g_free0 (self->priv->_type_id);
			self->priv->_type_id = _tmp12_;
			_g_free0 (_tmp11_);
		}
		_tmp13_ = self->priv->_type_id;
		if (_tmp13_ == NULL) {
			gchar* _tmp14_;
			_tmp14_ = vala_ccode_attribute_get_default_type_id (self);
			_g_free0 (self->priv->_type_id);
			self->priv->_type_id = _tmp14_;
		}
	}
	_tmp15_ = self->priv->_type_id;
	result = _tmp15_;
	return result;
}

const gchar*
vala_ccode_attribute_get_marshaller_type_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_marshaller_type_name;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "marshaller_type_name", NULL);
			_g_free0 (self->priv->_marshaller_type_name);
			self->priv->_marshaller_type_name = _tmp3_;
		}
		_tmp4_ = self->priv->_marshaller_type_name;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_marshaller_type_name (self);
			_g_free0 (self->priv->_marshaller_type_name);
			self->priv->_marshaller_type_name = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_marshaller_type_name;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_get_value_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_get_value_function;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "get_value_function", NULL);
			_g_free0 (self->priv->_get_value_function);
			self->priv->_get_value_function = _tmp3_;
		}
		_tmp4_ = self->priv->_get_value_function;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_get_value_function (self);
			_g_free0 (self->priv->_get_value_function);
			self->priv->_get_value_function = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_get_value_function;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_set_value_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_set_value_function;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "set_value_function", NULL);
			_g_free0 (self->priv->_set_value_function);
			self->priv->_set_value_function = _tmp3_;
		}
		_tmp4_ = self->priv->_set_value_function;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_set_value_function (self);
			_g_free0 (self->priv->_set_value_function);
			self->priv->_set_value_function = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_set_value_function;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_take_value_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_take_value_function;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "take_value_function", NULL);
			_g_free0 (self->priv->_take_value_function);
			self->priv->_take_value_function = _tmp3_;
		}
		_tmp4_ = self->priv->_take_value_function;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_take_value_function (self);
			_g_free0 (self->priv->_take_value_function);
			self->priv->_take_value_function = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_take_value_function;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_param_spec_function (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_param_spec_function;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "param_spec_function", NULL);
			_g_free0 (self->priv->_param_spec_function);
			self->priv->_param_spec_function = _tmp3_;
		}
		_tmp4_ = self->priv->_param_spec_function;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_param_spec_function (self);
			_g_free0 (self->priv->_param_spec_function);
			self->priv->_param_spec_function = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_param_spec_function;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_default_value (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_default_value;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "default_value", NULL);
			_g_free0 (self->priv->_default_value);
			self->priv->_default_value = _tmp3_;
		}
		_tmp4_ = self->priv->_default_value;
		if (_tmp4_ == NULL) {
			gchar* _tmp5_;
			_tmp5_ = vala_ccode_attribute_get_default_default_value (self);
			_g_free0 (self->priv->_default_value);
			self->priv->_default_value = _tmp5_;
		}
	}
	_tmp6_ = self->priv->_default_value;
	result = _tmp6_;
	return result;
}

const gchar*
vala_ccode_attribute_get_default_value_on_error (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_default_value_on_error;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "default_value_on_error", NULL);
			_g_free0 (self->priv->_default_value_on_error);
			self->priv->_default_value_on_error = _tmp3_;
		}
		_tmp4_ = self->priv->_default_value_on_error;
		if (_tmp4_ == NULL) {
			const gchar* _tmp5_;
			const gchar* _tmp6_;
			gchar* _tmp7_;
			_tmp5_ = vala_ccode_attribute_get_default_value (self);
			_tmp6_ = _tmp5_;
			_tmp7_ = g_strdup (_tmp6_);
			_g_free0 (self->priv->_default_value_on_error);
			self->priv->_default_value_on_error = _tmp7_;
		}
	}
	_tmp8_ = self->priv->_default_value_on_error;
	result = _tmp8_;
	return result;
}

static gdouble*
_double_dup (gdouble* self)
{
	gdouble* dup;
	dup = g_new0 (gdouble, 1);
	memcpy (dup, self, sizeof (gdouble));
	return dup;
}

static gpointer
__double_dup0 (gpointer self)
{
	return self ? _double_dup (self) : NULL;
}

gdouble
vala_ccode_attribute_get_pos (ValaCCodeAttribute* self)
{
	gdouble result;
	gdouble* _tmp0_;
	gdouble* _tmp44_;
	g_return_val_if_fail (self != NULL, 0.0);
	_tmp0_ = self->priv->_pos;
	if (_tmp0_ == NULL) {
		gboolean _tmp1_ = FALSE;
		ValaAttribute* _tmp2_;
		_tmp2_ = self->priv->ccode;
		if (_tmp2_ != NULL) {
			ValaAttribute* _tmp3_;
			_tmp3_ = self->priv->ccode;
			_tmp1_ = vala_attribute_has_argument (_tmp3_, "pos");
		} else {
			_tmp1_ = FALSE;
		}
		if (_tmp1_) {
			ValaAttribute* _tmp4_;
			gdouble _tmp5_;
			gdouble* _tmp6_;
			_tmp4_ = self->priv->ccode;
			_tmp5_ = vala_attribute_get_double (_tmp4_, "pos", (gdouble) 0);
			_tmp6_ = __double_dup0 (&_tmp5_);
			_g_free0 (self->priv->_pos);
			self->priv->_pos = _tmp6_;
		} else {
			ValaParameter* param = NULL;
			ValaCodeNode* _tmp7_;
			ValaCallable* callable = NULL;
			ValaParameter* _tmp8_;
			ValaSymbol* _tmp9_;
			ValaSymbol* _tmp10_;
			ValaMethod* method = NULL;
			ValaParameter* _tmp11_;
			ValaSymbol* _tmp12_;
			ValaSymbol* _tmp13_;
			gboolean _tmp14_ = FALSE;
			ValaMethod* _tmp15_;
			_tmp7_ = self->priv->node;
			param = G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_PARAMETER, ValaParameter);
			_tmp8_ = param;
			_tmp9_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp8_);
			_tmp10_ = _tmp9_;
			callable = G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_CALLABLE) ? ((ValaCallable*) _tmp10_) : NULL;
			_tmp11_ = param;
			_tmp12_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp11_);
			_tmp13_ = _tmp12_;
			method = G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp13_) : NULL;
			_tmp15_ = method;
			if (_tmp15_ != NULL) {
				ValaMethod* _tmp16_;
				gboolean _tmp17_;
				gboolean _tmp18_;
				_tmp16_ = method;
				_tmp17_ = vala_method_get_coroutine (_tmp16_);
				_tmp18_ = _tmp17_;
				_tmp14_ = _tmp18_;
			} else {
				_tmp14_ = FALSE;
			}
			if (_tmp14_) {
				gint index = 0;
				ValaMethod* _tmp19_;
				ValaList* _tmp20_;
				ValaParameter* _tmp21_;
				gdouble _tmp34_;
				gdouble* _tmp35_;
				_tmp19_ = method;
				_tmp20_ = vala_method_get_async_begin_parameters (_tmp19_);
				_tmp21_ = param;
				index = vala_list_index_of (_tmp20_, _tmp21_);
				if (index < 0) {
					ValaMethod* _tmp22_;
					ValaList* _tmp23_;
					ValaParameter* _tmp24_;
					_tmp22_ = method;
					_tmp23_ = vala_method_get_async_end_parameters (_tmp22_);
					_tmp24_ = param;
					index = vala_list_index_of (_tmp23_, _tmp24_);
				}
				if (index < 0) {
					ValaParameter* _tmp25_;
					ValaSourceReference* _tmp26_;
					ValaSourceReference* _tmp27_;
					ValaParameter* _tmp28_;
					const gchar* _tmp29_;
					const gchar* _tmp30_;
					ValaMethod* _tmp31_;
					gchar* _tmp32_;
					gchar* _tmp33_;
					_tmp25_ = param;
					_tmp26_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp25_);
					_tmp27_ = _tmp26_;
					_tmp28_ = param;
					_tmp29_ = vala_symbol_get_name ((ValaSymbol*) _tmp28_);
					_tmp30_ = _tmp29_;
					_tmp31_ = method;
					_tmp32_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp31_);
					_tmp33_ = _tmp32_;
					vala_report_error (_tmp27_, "internal: Parameter `%s' not found in `%s'", _tmp30_, _tmp33_);
					_g_free0 (_tmp33_);
				}
				_tmp34_ = index + 1.0;
				_tmp35_ = __double_dup0 (&_tmp34_);
				_g_free0 (self->priv->_pos);
				self->priv->_pos = _tmp35_;
			} else {
				ValaCallable* _tmp36_;
				_tmp36_ = callable;
				if (_tmp36_ != NULL) {
					ValaCallable* _tmp37_;
					ValaList* _tmp38_;
					ValaParameter* _tmp39_;
					gdouble _tmp40_;
					gdouble* _tmp41_;
					_tmp37_ = callable;
					_tmp38_ = vala_callable_get_parameters (_tmp37_);
					_tmp39_ = param;
					_tmp40_ = vala_list_index_of (_tmp38_, _tmp39_) + 1.0;
					_tmp41_ = __double_dup0 (&_tmp40_);
					_g_free0 (self->priv->_pos);
					self->priv->_pos = _tmp41_;
				} else {
					gdouble _tmp42_;
					gdouble* _tmp43_;
					_tmp42_ = 0.0;
					_tmp43_ = __double_dup0 (&_tmp42_);
					_g_free0 (self->priv->_pos);
					self->priv->_pos = _tmp43_;
				}
			}
		}
	}
	_tmp44_ = self->priv->_pos;
	result = *_tmp44_;
	return result;
}

const gchar*
vala_ccode_attribute_get_real_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_real_name;
	if (_tmp0_ == NULL) {
		gboolean _tmp1_ = FALSE;
		ValaAttribute* _tmp2_;
		const gchar* _tmp6_;
		_tmp2_ = self->priv->ccode;
		if (_tmp2_ != NULL) {
			ValaSymbol* _tmp3_;
			_tmp3_ = self->priv->sym;
			_tmp1_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_CREATION_METHOD);
		} else {
			_tmp1_ = FALSE;
		}
		if (_tmp1_) {
			ValaAttribute* _tmp4_;
			gchar* _tmp5_;
			_tmp4_ = self->priv->ccode;
			_tmp5_ = vala_attribute_get_string (_tmp4_, "construct_function", NULL);
			_g_free0 (self->priv->_real_name);
			self->priv->_real_name = _tmp5_;
		}
		_tmp6_ = self->priv->_real_name;
		if (_tmp6_ == NULL) {
			gchar* _tmp7_;
			_tmp7_ = vala_ccode_attribute_get_default_real_name (self);
			_g_free0 (self->priv->_real_name);
			self->priv->_real_name = _tmp7_;
		}
	}
	_tmp8_ = self->priv->_real_name;
	result = _tmp8_;
	return result;
}

const gchar*
vala_ccode_attribute_get_vfunc_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp19_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_vfunc_name;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "vfunc_name", NULL);
			_g_free0 (self->priv->_vfunc_name);
			self->priv->_vfunc_name = _tmp3_;
		}
		_tmp4_ = self->priv->_vfunc_name;
		if (_tmp4_ == NULL) {
			ValaMethod* m = NULL;
			ValaCodeNode* _tmp5_;
			gboolean _tmp6_ = FALSE;
			ValaMethod* _tmp7_;
			_tmp5_ = self->priv->node;
			m = G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp5_) : NULL;
			_tmp7_ = m;
			if (_tmp7_ != NULL) {
				ValaMethod* _tmp8_;
				ValaSignal* _tmp9_;
				ValaSignal* _tmp10_;
				_tmp8_ = m;
				_tmp9_ = vala_method_get_signal_reference (_tmp8_);
				_tmp10_ = _tmp9_;
				_tmp6_ = _tmp10_ != NULL;
			} else {
				_tmp6_ = FALSE;
			}
			if (_tmp6_) {
				ValaMethod* _tmp11_;
				ValaSignal* _tmp12_;
				ValaSignal* _tmp13_;
				gchar* _tmp14_;
				_tmp11_ = m;
				_tmp12_ = vala_method_get_signal_reference (_tmp11_);
				_tmp13_ = _tmp12_;
				_tmp14_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp13_, NULL);
				_g_free0 (self->priv->_vfunc_name);
				self->priv->_vfunc_name = _tmp14_;
			} else {
				ValaSymbol* _tmp15_;
				const gchar* _tmp16_;
				const gchar* _tmp17_;
				gchar* _tmp18_;
				_tmp15_ = self->priv->sym;
				_tmp16_ = vala_symbol_get_name (_tmp15_);
				_tmp17_ = _tmp16_;
				_tmp18_ = g_strdup (_tmp17_);
				_g_free0 (self->priv->_vfunc_name);
				self->priv->_vfunc_name = _tmp18_;
			}
		}
	}
	_tmp19_ = self->priv->_vfunc_name;
	result = _tmp19_;
	return result;
}

const gchar*
vala_ccode_attribute_get_finish_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp15_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_finish_name;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp11_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			const gchar* _tmp4_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "finish_name", NULL);
			_g_free0 (self->priv->_finish_name);
			self->priv->_finish_name = _tmp3_;
			_tmp4_ = self->priv->_finish_name;
			if (_tmp4_ == NULL) {
				ValaAttribute* _tmp5_;
				gchar* _tmp6_;
				const gchar* _tmp7_;
				_tmp5_ = self->priv->ccode;
				_tmp6_ = vala_attribute_get_string (_tmp5_, "finish_function", NULL);
				_g_free0 (self->priv->_finish_name);
				self->priv->_finish_name = _tmp6_;
				_tmp7_ = self->priv->_finish_name;
				if (_tmp7_ != NULL) {
					ValaCodeNode* _tmp8_;
					ValaSourceReference* _tmp9_;
					ValaSourceReference* _tmp10_;
					_tmp8_ = self->priv->node;
					_tmp9_ = vala_code_node_get_source_reference (_tmp8_);
					_tmp10_ = _tmp9_;
					vala_report_deprecated (_tmp10_, "[CCode (finish_function = \"...\")] is deprecated, use [CCode (finish_" \
"name = \"...\")] instead.");
				}
			}
		}
		_tmp11_ = self->priv->_finish_name;
		if (_tmp11_ == NULL) {
			const gchar* _tmp12_;
			const gchar* _tmp13_;
			gchar* _tmp14_;
			_tmp12_ = vala_ccode_attribute_get_name (self);
			_tmp13_ = _tmp12_;
			_tmp14_ = vala_ccode_attribute_get_finish_name_for_basename (self, _tmp13_);
			_g_free0 (self->priv->_finish_name);
			self->priv->_finish_name = _tmp14_;
		}
	}
	_tmp15_ = self->priv->_finish_name;
	result = _tmp15_;
	return result;
}

const gchar*
vala_ccode_attribute_get_finish_vfunc_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_finish_vfunc_name;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "finish_vfunc_name", NULL);
			_g_free0 (self->priv->_finish_vfunc_name);
			self->priv->_finish_vfunc_name = _tmp3_;
		}
		_tmp4_ = self->priv->_finish_vfunc_name;
		if (_tmp4_ == NULL) {
			const gchar* _tmp5_;
			const gchar* _tmp6_;
			gchar* _tmp7_;
			_tmp5_ = vala_ccode_attribute_get_vfunc_name (self);
			_tmp6_ = _tmp5_;
			_tmp7_ = vala_ccode_attribute_get_finish_name_for_basename (self, _tmp6_);
			_g_free0 (self->priv->_finish_vfunc_name);
			self->priv->_finish_vfunc_name = _tmp7_;
		}
	}
	_tmp8_ = self->priv->_finish_vfunc_name;
	result = _tmp8_;
	return result;
}

const gchar*
vala_ccode_attribute_get_finish_real_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp19_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_finish_real_name;
	if (_tmp0_ == NULL) {
		ValaMethod* m = NULL;
		ValaCodeNode* _tmp1_;
		gboolean _tmp2_ = FALSE;
		gboolean _tmp3_ = FALSE;
		ValaMethod* _tmp4_;
		_tmp1_ = self->priv->node;
		m = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp1_) : NULL;
		_tmp4_ = m;
		if (_tmp4_ != NULL) {
			ValaMethod* _tmp5_;
			_tmp5_ = m;
			_tmp3_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_CREATION_METHOD);
		} else {
			_tmp3_ = FALSE;
		}
		if (_tmp3_) {
			gboolean _tmp6_ = FALSE;
			ValaMethod* _tmp7_;
			gboolean _tmp8_;
			gboolean _tmp9_;
			_tmp7_ = m;
			_tmp8_ = vala_method_get_is_abstract (_tmp7_);
			_tmp9_ = _tmp8_;
			if (_tmp9_) {
				_tmp6_ = TRUE;
			} else {
				ValaMethod* _tmp10_;
				gboolean _tmp11_;
				gboolean _tmp12_;
				_tmp10_ = m;
				_tmp11_ = vala_method_get_is_virtual (_tmp10_);
				_tmp12_ = _tmp11_;
				_tmp6_ = _tmp12_;
			}
			_tmp2_ = !_tmp6_;
		} else {
			_tmp2_ = FALSE;
		}
		if (_tmp2_) {
			const gchar* _tmp13_;
			const gchar* _tmp14_;
			gchar* _tmp15_;
			_tmp13_ = vala_ccode_attribute_get_finish_name (self);
			_tmp14_ = _tmp13_;
			_tmp15_ = g_strdup (_tmp14_);
			_g_free0 (self->priv->_finish_real_name);
			self->priv->_finish_real_name = _tmp15_;
		} else {
			const gchar* _tmp16_;
			const gchar* _tmp17_;
			gchar* _tmp18_;
			_tmp16_ = vala_ccode_attribute_get_real_name (self);
			_tmp17_ = _tmp16_;
			_tmp18_ = vala_ccode_attribute_get_finish_name_for_basename (self, _tmp17_);
			_g_free0 (self->priv->_finish_real_name);
			self->priv->_finish_real_name = _tmp18_;
		}
	}
	_tmp19_ = self->priv->_finish_real_name;
	result = _tmp19_;
	return result;
}

gboolean
vala_ccode_attribute_get_finish_instance (ValaCCodeAttribute* self)
{
	gboolean result;
	gboolean* _tmp0_;
	gboolean* _tmp19_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_finish_instance;
	if (_tmp0_ == NULL) {
		ValaMethod* m = NULL;
		ValaCodeNode* _tmp1_;
		gboolean is_creation_method = FALSE;
		ValaMethod* _tmp2_;
		gboolean _tmp3_ = FALSE;
		gboolean _tmp4_ = FALSE;
		gboolean _tmp5_ = FALSE;
		ValaAttribute* _tmp6_;
		_tmp1_ = self->priv->node;
		m = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp1_) : NULL;
		_tmp2_ = m;
		is_creation_method = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CREATION_METHOD);
		_tmp6_ = self->priv->ccode;
		if (_tmp6_ == NULL) {
			_tmp5_ = TRUE;
		} else {
			ValaMethod* _tmp7_;
			_tmp7_ = m;
			_tmp5_ = _tmp7_ == NULL;
		}
		if (_tmp5_) {
			_tmp4_ = TRUE;
		} else {
			ValaMethod* _tmp8_;
			gboolean _tmp9_;
			gboolean _tmp10_;
			_tmp8_ = m;
			_tmp9_ = vala_method_get_is_abstract (_tmp8_);
			_tmp10_ = _tmp9_;
			_tmp4_ = _tmp10_;
		}
		if (_tmp4_) {
			_tmp3_ = TRUE;
		} else {
			ValaMethod* _tmp11_;
			gboolean _tmp12_;
			gboolean _tmp13_;
			_tmp11_ = m;
			_tmp12_ = vala_method_get_is_virtual (_tmp11_);
			_tmp13_ = _tmp12_;
			_tmp3_ = _tmp13_;
		}
		if (_tmp3_) {
			gboolean _tmp14_;
			gboolean* _tmp15_;
			_tmp14_ = !is_creation_method;
			_tmp15_ = __bool_dup0 (&_tmp14_);
			_g_free0 (self->priv->_finish_instance);
			self->priv->_finish_instance = _tmp15_;
		} else {
			ValaAttribute* _tmp16_;
			gboolean _tmp17_;
			gboolean* _tmp18_;
			_tmp16_ = self->priv->ccode;
			_tmp17_ = vala_attribute_get_bool (_tmp16_, "finish_instance", !is_creation_method);
			_tmp18_ = __bool_dup0 (&_tmp17_);
			_g_free0 (self->priv->_finish_instance);
			self->priv->_finish_instance = _tmp18_;
		}
	}
	_tmp19_ = self->priv->_finish_instance;
	result = *_tmp19_;
	return result;
}

gboolean
vala_ccode_attribute_get_delegate_target (ValaCCodeAttribute* self)
{
	gboolean result;
	gboolean* _tmp0_;
	gboolean* _tmp7_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_delegate_target;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gboolean _tmp3_;
			gboolean* _tmp4_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_bool (_tmp2_, "delegate_target", vala_ccode_attribute_get_default_delegate_target (self));
			_tmp4_ = __bool_dup0 (&_tmp3_);
			_g_free0 (self->priv->_delegate_target);
			self->priv->_delegate_target = _tmp4_;
		} else {
			gboolean _tmp5_;
			gboolean* _tmp6_;
			_tmp5_ = vala_ccode_attribute_get_default_delegate_target (self);
			_tmp6_ = __bool_dup0 (&_tmp5_);
			_g_free0 (self->priv->_delegate_target);
			self->priv->_delegate_target = _tmp6_;
		}
	}
	_tmp7_ = self->priv->_delegate_target;
	result = *_tmp7_;
	return result;
}

const gchar*
vala_ccode_attribute_get_delegate_target_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_delegate_target_name;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "delegate_target_cname", NULL);
			_g_free0 (self->priv->_delegate_target_name);
			self->priv->_delegate_target_name = _tmp3_;
		}
		_tmp4_ = self->priv->_delegate_target_name;
		if (_tmp4_ == NULL) {
			const gchar* _tmp5_;
			const gchar* _tmp6_;
			gchar* _tmp7_;
			_tmp5_ = vala_ccode_attribute_get_name (self);
			_tmp6_ = _tmp5_;
			_tmp7_ = g_strdup_printf ("%s_target", _tmp6_);
			_g_free0 (self->priv->_delegate_target_name);
			self->priv->_delegate_target_name = _tmp7_;
		}
	}
	_tmp8_ = self->priv->_delegate_target_name;
	result = _tmp8_;
	return result;
}

const gchar*
vala_ccode_attribute_get_delegate_target_destroy_notify_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_delegate_target_destroy_notify_name;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		const gchar* _tmp4_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "destroy_notify_cname", NULL);
			_g_free0 (self->priv->_delegate_target_destroy_notify_name);
			self->priv->_delegate_target_destroy_notify_name = _tmp3_;
		}
		_tmp4_ = self->priv->_delegate_target_destroy_notify_name;
		if (_tmp4_ == NULL) {
			const gchar* _tmp5_;
			const gchar* _tmp6_;
			gchar* _tmp7_;
			_tmp5_ = vala_ccode_attribute_get_delegate_target_name (self);
			_tmp6_ = _tmp5_;
			_tmp7_ = g_strdup_printf ("%s_destroy_notify", _tmp6_);
			_g_free0 (self->priv->_delegate_target_destroy_notify_name);
			self->priv->_delegate_target_destroy_notify_name = _tmp7_;
		}
	}
	_tmp8_ = self->priv->_delegate_target_destroy_notify_name;
	result = _tmp8_;
	return result;
}

gboolean
vala_ccode_attribute_get_array_length (ValaCCodeAttribute* self)
{
	gboolean result;
	gboolean* _tmp0_;
	gboolean* _tmp15_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_array_length;
	if (_tmp0_ == NULL) {
		ValaCodeNode* _tmp1_;
		_tmp1_ = self->priv->node;
		if (vala_code_node_has_attribute (_tmp1_, "NoArrayLength")) {
			ValaCodeNode* _tmp2_;
			ValaSourceReference* _tmp3_;
			ValaSourceReference* _tmp4_;
			gboolean _tmp5_;
			gboolean* _tmp6_;
			_tmp2_ = self->priv->node;
			_tmp3_ = vala_code_node_get_source_reference (_tmp2_);
			_tmp4_ = _tmp3_;
			vala_report_deprecated (_tmp4_, "[NoArrayLength] is deprecated, use [CCode (array_length = false)] inst" \
"ead.");
			_tmp5_ = FALSE;
			_tmp6_ = __bool_dup0 (&_tmp5_);
			_g_free0 (self->priv->_array_length);
			self->priv->_array_length = _tmp6_;
		} else {
			gboolean _tmp7_ = FALSE;
			ValaAttribute* _tmp8_;
			_tmp8_ = self->priv->ccode;
			if (_tmp8_ != NULL) {
				ValaAttribute* _tmp9_;
				_tmp9_ = self->priv->ccode;
				_tmp7_ = vala_attribute_has_argument (_tmp9_, "array_length");
			} else {
				_tmp7_ = FALSE;
			}
			if (_tmp7_) {
				ValaAttribute* _tmp10_;
				gboolean _tmp11_;
				gboolean* _tmp12_;
				_tmp10_ = self->priv->ccode;
				_tmp11_ = vala_attribute_get_bool (_tmp10_, "array_length", FALSE);
				_tmp12_ = __bool_dup0 (&_tmp11_);
				_g_free0 (self->priv->_array_length);
				self->priv->_array_length = _tmp12_;
			} else {
				gboolean _tmp13_;
				gboolean* _tmp14_;
				_tmp13_ = vala_ccode_attribute_get_default_array_length (self);
				_tmp14_ = __bool_dup0 (&_tmp13_);
				_g_free0 (self->priv->_array_length);
				self->priv->_array_length = _tmp14_;
			}
		}
	}
	_tmp15_ = self->priv->_array_length;
	result = *_tmp15_;
	return result;
}

gboolean
vala_ccode_attribute_get_array_null_terminated (ValaCCodeAttribute* self)
{
	gboolean result;
	gboolean* _tmp0_;
	gboolean* _tmp16_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->_array_null_terminated;
	if (_tmp0_ == NULL) {
		gboolean _tmp1_ = FALSE;
		gboolean _tmp2_ = FALSE;
		ValaAttribute* _tmp3_;
		_tmp3_ = self->priv->ccode;
		if (_tmp3_ != NULL) {
			ValaAttribute* _tmp4_;
			_tmp4_ = self->priv->ccode;
			_tmp2_ = vala_attribute_has_argument (_tmp4_, "array_length");
		} else {
			_tmp2_ = FALSE;
		}
		if (_tmp2_) {
			ValaAttribute* _tmp5_;
			_tmp5_ = self->priv->ccode;
			_tmp1_ = vala_attribute_get_bool (_tmp5_, "array_length", FALSE);
		} else {
			_tmp1_ = FALSE;
		}
		if (_tmp1_) {
			gboolean _tmp6_;
			gboolean* _tmp7_;
			_tmp6_ = FALSE;
			_tmp7_ = __bool_dup0 (&_tmp6_);
			_g_free0 (self->priv->_array_null_terminated);
			self->priv->_array_null_terminated = _tmp7_;
		} else {
			gboolean _tmp8_ = FALSE;
			ValaAttribute* _tmp9_;
			_tmp9_ = self->priv->ccode;
			if (_tmp9_ != NULL) {
				ValaAttribute* _tmp10_;
				_tmp10_ = self->priv->ccode;
				_tmp8_ = vala_attribute_has_argument (_tmp10_, "array_null_terminated");
			} else {
				_tmp8_ = FALSE;
			}
			if (_tmp8_) {
				ValaAttribute* _tmp11_;
				gboolean _tmp12_;
				gboolean* _tmp13_;
				_tmp11_ = self->priv->ccode;
				_tmp12_ = vala_attribute_get_bool (_tmp11_, "array_null_terminated", FALSE);
				_tmp13_ = __bool_dup0 (&_tmp12_);
				_g_free0 (self->priv->_array_null_terminated);
				self->priv->_array_null_terminated = _tmp13_;
			} else {
				gboolean _tmp14_;
				gboolean* _tmp15_;
				_tmp14_ = vala_ccode_attribute_get_default_array_null_terminated (self);
				_tmp15_ = __bool_dup0 (&_tmp14_);
				_g_free0 (self->priv->_array_null_terminated);
				self->priv->_array_null_terminated = _tmp15_;
			}
		}
	}
	_tmp16_ = self->priv->_array_null_terminated;
	result = *_tmp16_;
	return result;
}

const gchar*
vala_ccode_attribute_get_array_length_type (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp7_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_array_length_type;
	if (_tmp0_ == NULL) {
		gboolean _tmp1_ = FALSE;
		ValaAttribute* _tmp2_;
		_tmp2_ = self->priv->ccode;
		if (_tmp2_ != NULL) {
			ValaAttribute* _tmp3_;
			_tmp3_ = self->priv->ccode;
			_tmp1_ = vala_attribute_has_argument (_tmp3_, "array_length_type");
		} else {
			_tmp1_ = FALSE;
		}
		if (_tmp1_) {
			ValaAttribute* _tmp4_;
			gchar* _tmp5_;
			_tmp4_ = self->priv->ccode;
			_tmp5_ = vala_attribute_get_string (_tmp4_, "array_length_type", NULL);
			_g_free0 (self->priv->_array_length_type);
			self->priv->_array_length_type = _tmp5_;
		} else {
			gchar* _tmp6_;
			_tmp6_ = vala_ccode_attribute_get_default_array_length_type (self);
			_g_free0 (self->priv->_array_length_type);
			self->priv->_array_length_type = _tmp6_;
		}
	}
	_tmp7_ = self->priv->_array_length_type;
	result = _tmp7_;
	return result;
}

const gchar*
vala_ccode_attribute_get_sentinel (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	const gchar* _tmp5_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_sentinel;
	if (_tmp0_ == NULL) {
		ValaAttribute* _tmp1_;
		_tmp1_ = self->priv->ccode;
		if (_tmp1_ != NULL) {
			ValaAttribute* _tmp2_;
			gchar* _tmp3_;
			_tmp2_ = self->priv->ccode;
			_tmp3_ = vala_attribute_get_string (_tmp2_, "sentinel", "NULL");
			_g_free0 (self->priv->_sentinel);
			self->priv->_sentinel = _tmp3_;
		} else {
			gchar* _tmp4_;
			_tmp4_ = g_strdup ("NULL");
			_g_free0 (self->priv->_sentinel);
			self->priv->_sentinel = _tmp4_;
		}
	}
	_tmp5_ = self->priv->_sentinel;
	result = _tmp5_;
	return result;
}

const gchar*
vala_ccode_attribute_get_array_length_name (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_array_length_name;
	result = _tmp0_;
	return result;
}

static void
vala_ccode_attribute_set_array_length_name (ValaCCodeAttribute* self,
                                            const gchar* value)
{
	gchar* _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = g_strdup (value);
	_g_free0 (self->priv->_array_length_name);
	self->priv->_array_length_name = _tmp0_;
}

const gchar*
vala_ccode_attribute_get_array_length_expr (ValaCCodeAttribute* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_array_length_expr;
	result = _tmp0_;
	return result;
}

static void
vala_ccode_attribute_set_array_length_expr (ValaCCodeAttribute* self,
                                            const gchar* value)
{
	gchar* _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = g_strdup (value);
	_g_free0 (self->priv->_array_length_expr);
	self->priv->_array_length_expr = _tmp0_;
}

ValaCCodeAttribute*
vala_ccode_attribute_construct (GType object_type,
                                ValaCodeNode* node)
{
	ValaCCodeAttribute* self = NULL;
	ValaAttribute* _tmp0_;
	ValaAttribute* _tmp1_;
	ValaAttribute* _tmp2_;
	g_return_val_if_fail (node != NULL, NULL);
	self = (ValaCCodeAttribute*) vala_attribute_cache_construct (object_type);
	self->priv->node = node;
	self->priv->sym = G_TYPE_CHECK_INSTANCE_TYPE (node, VALA_TYPE_SYMBOL) ? ((ValaSymbol*) node) : NULL;
	_tmp0_ = vala_code_node_get_attribute (node, "CCode");
	_tmp1_ = _vala_code_node_ref0 (_tmp0_);
	_vala_code_node_unref0 (self->priv->ccode);
	self->priv->ccode = _tmp1_;
	_tmp2_ = self->priv->ccode;
	if (_tmp2_ != NULL) {
		ValaAttribute* _tmp3_;
		gchar* _tmp4_;
		gchar* _tmp5_;
		ValaAttribute* _tmp6_;
		gchar* _tmp7_;
		gchar* _tmp8_;
		_tmp3_ = self->priv->ccode;
		_tmp4_ = vala_attribute_get_string (_tmp3_, "array_length_cname", NULL);
		_tmp5_ = _tmp4_;
		vala_ccode_attribute_set_array_length_name (self, _tmp5_);
		_g_free0 (_tmp5_);
		_tmp6_ = self->priv->ccode;
		_tmp7_ = vala_attribute_get_string (_tmp6_, "array_length_cexpr", NULL);
		_tmp8_ = _tmp7_;
		vala_ccode_attribute_set_array_length_expr (self, _tmp8_);
		_g_free0 (_tmp8_);
	}
	return self;
}

ValaCCodeAttribute*
vala_ccode_attribute_new (ValaCodeNode* node)
{
	return vala_ccode_attribute_construct (VALA_TYPE_CCODE_ATTRIBUTE, node);
}

static gchar
string_get (const gchar* self,
            glong index)
{
	gchar _tmp0_;
	gchar result;
	g_return_val_if_fail (self != NULL, '\0');
	_tmp0_ = ((gchar*) self)[index];
	result = _tmp0_;
	return result;
}

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

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

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

static gchar*
vala_ccode_attribute_get_default_name (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (_tmp0_ != NULL) {
		gboolean _tmp1_ = FALSE;
		ValaSymbol* _tmp2_;
		_tmp2_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CONSTANT)) {
			ValaSymbol* _tmp3_;
			_tmp3_ = self->priv->sym;
			_tmp1_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_ENUM_VALUE);
		} else {
			_tmp1_ = FALSE;
		}
		if (_tmp1_) {
			ValaSymbol* _tmp4_;
			ValaSymbol* _tmp5_;
			ValaSymbol* _tmp6_;
			ValaSymbol* _tmp11_;
			ValaSymbol* _tmp12_;
			ValaSymbol* _tmp13_;
			gchar* _tmp14_;
			gchar* _tmp15_;
			gchar* _tmp16_;
			gchar* _tmp17_;
			ValaSymbol* _tmp18_;
			const gchar* _tmp19_;
			const gchar* _tmp20_;
			gchar* _tmp21_;
			gchar* _tmp22_;
			_tmp4_ = self->priv->sym;
			_tmp5_ = vala_symbol_get_parent_symbol (_tmp4_);
			_tmp6_ = _tmp5_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_BLOCK)) {
				ValaSymbol* _tmp7_;
				const gchar* _tmp8_;
				const gchar* _tmp9_;
				gchar* _tmp10_;
				_tmp7_ = self->priv->sym;
				_tmp8_ = vala_symbol_get_name (_tmp7_);
				_tmp9_ = _tmp8_;
				_tmp10_ = g_strdup (_tmp9_);
				result = _tmp10_;
				return result;
			}
			_tmp11_ = self->priv->sym;
			_tmp12_ = vala_symbol_get_parent_symbol (_tmp11_);
			_tmp13_ = _tmp12_;
			_tmp14_ = vala_get_ccode_lower_case_prefix (_tmp13_);
			_tmp15_ = _tmp14_;
			_tmp16_ = g_ascii_strup (_tmp15_, (gssize) -1);
			_tmp17_ = _tmp16_;
			_tmp18_ = self->priv->sym;
			_tmp19_ = vala_symbol_get_name (_tmp18_);
			_tmp20_ = _tmp19_;
			_tmp21_ = g_strdup_printf ("%s%s", _tmp17_, _tmp20_);
			_tmp22_ = _tmp21_;
			_g_free0 (_tmp17_);
			_g_free0 (_tmp15_);
			result = _tmp22_;
			return result;
		} else {
			ValaSymbol* _tmp23_;
			_tmp23_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_FIELD)) {
				gchar* cname = NULL;
				ValaSymbol* _tmp24_;
				const gchar* _tmp25_;
				const gchar* _tmp26_;
				gchar* _tmp27_;
				ValaSymbol* _tmp28_;
				ValaMemberBinding _tmp29_;
				ValaMemberBinding _tmp30_;
				const gchar* _tmp40_;
				_tmp24_ = self->priv->sym;
				_tmp25_ = vala_symbol_get_name (_tmp24_);
				_tmp26_ = _tmp25_;
				_tmp27_ = g_strdup (_tmp26_);
				cname = _tmp27_;
				_tmp28_ = self->priv->sym;
				_tmp29_ = vala_field_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp28_, VALA_TYPE_FIELD, ValaField));
				_tmp30_ = _tmp29_;
				if (_tmp30_ == VALA_MEMBER_BINDING_STATIC) {
					ValaSymbol* _tmp31_;
					ValaSymbol* _tmp32_;
					ValaSymbol* _tmp33_;
					gchar* _tmp34_;
					gchar* _tmp35_;
					ValaSymbol* _tmp36_;
					const gchar* _tmp37_;
					const gchar* _tmp38_;
					gchar* _tmp39_;
					_tmp31_ = self->priv->sym;
					_tmp32_ = vala_symbol_get_parent_symbol (_tmp31_);
					_tmp33_ = _tmp32_;
					_tmp34_ = vala_get_ccode_lower_case_prefix (_tmp33_);
					_tmp35_ = _tmp34_;
					_tmp36_ = self->priv->sym;
					_tmp37_ = vala_symbol_get_name (_tmp36_);
					_tmp38_ = _tmp37_;
					_tmp39_ = g_strdup_printf ("%s%s", _tmp35_, _tmp38_);
					_g_free0 (cname);
					cname = _tmp39_;
					_g_free0 (_tmp35_);
				}
				_tmp40_ = cname;
				if (g_ascii_isdigit (string_get (_tmp40_, (glong) 0))) {
					ValaCodeNode* _tmp41_;
					ValaSourceReference* _tmp42_;
					ValaSourceReference* _tmp43_;
					_tmp41_ = self->priv->node;
					_tmp42_ = vala_code_node_get_source_reference (_tmp41_);
					_tmp43_ = _tmp42_;
					vala_report_error (_tmp43_, "Field name starts with a digit. Use the `cname' attribute to provide a" \
" valid C name if intended");
				} else {
					ValaSet* _tmp44_;
					const gchar* _tmp45_;
					_tmp44_ = vala_ccode_base_module_reserved_identifiers;
					_tmp45_ = cname;
					if (vala_collection_contains ((ValaCollection*) _tmp44_, _tmp45_)) {
						ValaCodeNode* _tmp46_;
						ValaSourceReference* _tmp47_;
						ValaSourceReference* _tmp48_;
						const gchar* _tmp49_;
						_tmp46_ = self->priv->node;
						_tmp47_ = vala_code_node_get_source_reference (_tmp46_);
						_tmp48_ = _tmp47_;
						_tmp49_ = cname;
						vala_report_error (_tmp48_, "Field name `%s' collides with reserved identifier. Use the `cname' att" \
"ribute to provide a valid C name if intended", _tmp49_);
					}
				}
				result = cname;
				return result;
			} else {
				ValaSymbol* _tmp50_;
				_tmp50_ = self->priv->sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp50_, VALA_TYPE_CREATION_METHOD)) {
					ValaCreationMethod* m = NULL;
					ValaSymbol* _tmp51_;
					gchar* infix = NULL;
					ValaCreationMethod* _tmp52_;
					ValaSymbol* _tmp53_;
					ValaSymbol* _tmp54_;
					ValaCreationMethod* _tmp57_;
					const gchar* _tmp58_;
					const gchar* _tmp59_;
					_tmp51_ = self->priv->sym;
					m = G_TYPE_CHECK_INSTANCE_CAST (_tmp51_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod);
					_tmp52_ = m;
					_tmp53_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp52_);
					_tmp54_ = _tmp53_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp54_, VALA_TYPE_STRUCT)) {
						gchar* _tmp55_;
						_tmp55_ = g_strdup ("init");
						_g_free0 (infix);
						infix = _tmp55_;
					} else {
						gchar* _tmp56_;
						_tmp56_ = g_strdup ("new");
						_g_free0 (infix);
						infix = _tmp56_;
					}
					_tmp57_ = m;
					_tmp58_ = vala_symbol_get_name ((ValaSymbol*) _tmp57_);
					_tmp59_ = _tmp58_;
					if (g_strcmp0 (_tmp59_, ".new") == 0) {
						ValaCreationMethod* _tmp60_;
						ValaSymbol* _tmp61_;
						ValaSymbol* _tmp62_;
						gchar* _tmp63_;
						gchar* _tmp64_;
						const gchar* _tmp65_;
						gchar* _tmp66_;
						gchar* _tmp67_;
						_tmp60_ = m;
						_tmp61_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp60_);
						_tmp62_ = _tmp61_;
						_tmp63_ = vala_get_ccode_lower_case_prefix (_tmp62_);
						_tmp64_ = _tmp63_;
						_tmp65_ = infix;
						_tmp66_ = g_strdup_printf ("%s%s", _tmp64_, _tmp65_);
						_tmp67_ = _tmp66_;
						_g_free0 (_tmp64_);
						result = _tmp67_;
						_g_free0 (infix);
						return result;
					} else {
						ValaCreationMethod* _tmp68_;
						ValaSymbol* _tmp69_;
						ValaSymbol* _tmp70_;
						gchar* _tmp71_;
						gchar* _tmp72_;
						const gchar* _tmp73_;
						ValaCreationMethod* _tmp74_;
						const gchar* _tmp75_;
						const gchar* _tmp76_;
						gchar* _tmp77_;
						gchar* _tmp78_;
						_tmp68_ = m;
						_tmp69_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp68_);
						_tmp70_ = _tmp69_;
						_tmp71_ = vala_get_ccode_lower_case_prefix (_tmp70_);
						_tmp72_ = _tmp71_;
						_tmp73_ = infix;
						_tmp74_ = m;
						_tmp75_ = vala_symbol_get_name ((ValaSymbol*) _tmp74_);
						_tmp76_ = _tmp75_;
						_tmp77_ = g_strdup_printf ("%s%s_%s", _tmp72_, _tmp73_, _tmp76_);
						_tmp78_ = _tmp77_;
						_g_free0 (_tmp72_);
						result = _tmp78_;
						_g_free0 (infix);
						return result;
					}
					_g_free0 (infix);
				} else {
					ValaSymbol* _tmp79_;
					_tmp79_ = self->priv->sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp79_, VALA_TYPE_DYNAMIC_METHOD)) {
						ValaSymbol* _tmp80_;
						const gchar* _tmp81_;
						const gchar* _tmp82_;
						gint _tmp83_;
						gchar* _tmp84_;
						_tmp80_ = self->priv->sym;
						_tmp81_ = vala_symbol_get_name (_tmp80_);
						_tmp82_ = _tmp81_;
						_tmp83_ = vala_ccode_attribute_dynamic_method_id;
						vala_ccode_attribute_dynamic_method_id = _tmp83_ + 1;
						_tmp84_ = g_strdup_printf ("_dynamic_%s%d", _tmp82_, _tmp83_);
						result = _tmp84_;
						return result;
					} else {
						ValaSymbol* _tmp85_;
						_tmp85_ = self->priv->sym;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp85_, VALA_TYPE_METHOD)) {
							ValaMethod* m = NULL;
							ValaSymbol* _tmp86_;
							ValaMethod* _tmp87_;
							gboolean _tmp88_;
							gboolean _tmp89_;
							ValaMethod* _tmp97_;
							ValaSignal* _tmp98_;
							ValaSignal* _tmp99_;
							gchar* cname = NULL;
							gboolean _tmp112_ = FALSE;
							ValaSymbol* _tmp113_;
							const gchar* _tmp114_;
							const gchar* _tmp115_;
							ValaSet* _tmp149_;
							const gchar* _tmp150_;
							_tmp86_ = self->priv->sym;
							m = G_TYPE_CHECK_INSTANCE_CAST (_tmp86_, VALA_TYPE_METHOD, ValaMethod);
							_tmp87_ = m;
							_tmp88_ = vala_method_get_is_async_callback (_tmp87_);
							_tmp89_ = _tmp88_;
							if (_tmp89_) {
								ValaMethod* _tmp90_;
								ValaSymbol* _tmp91_;
								ValaSymbol* _tmp92_;
								gchar* _tmp93_;
								gchar* _tmp94_;
								gchar* _tmp95_;
								gchar* _tmp96_;
								_tmp90_ = m;
								_tmp91_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp90_);
								_tmp92_ = _tmp91_;
								_tmp93_ = vala_get_ccode_real_name ((ValaSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp92_, VALA_TYPE_METHOD, ValaMethod));
								_tmp94_ = _tmp93_;
								_tmp95_ = g_strdup_printf ("%s_co", _tmp94_);
								_tmp96_ = _tmp95_;
								_g_free0 (_tmp94_);
								result = _tmp96_;
								return result;
							}
							_tmp97_ = m;
							_tmp98_ = vala_method_get_signal_reference (_tmp97_);
							_tmp99_ = _tmp98_;
							if (_tmp99_ != NULL) {
								ValaMethod* _tmp100_;
								ValaSymbol* _tmp101_;
								ValaSymbol* _tmp102_;
								gchar* _tmp103_;
								gchar* _tmp104_;
								ValaMethod* _tmp105_;
								ValaSignal* _tmp106_;
								ValaSignal* _tmp107_;
								gchar* _tmp108_;
								gchar* _tmp109_;
								gchar* _tmp110_;
								gchar* _tmp111_;
								_tmp100_ = m;
								_tmp101_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp100_);
								_tmp102_ = _tmp101_;
								_tmp103_ = vala_get_ccode_lower_case_prefix (_tmp102_);
								_tmp104_ = _tmp103_;
								_tmp105_ = m;
								_tmp106_ = vala_method_get_signal_reference (_tmp105_);
								_tmp107_ = _tmp106_;
								_tmp108_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp107_, NULL);
								_tmp109_ = _tmp108_;
								_tmp110_ = g_strdup_printf ("%s%s", _tmp104_, _tmp109_);
								_tmp111_ = _tmp110_;
								_g_free0 (_tmp109_);
								_g_free0 (_tmp104_);
								result = _tmp111_;
								return result;
							}
							_tmp113_ = self->priv->sym;
							_tmp114_ = vala_symbol_get_name (_tmp113_);
							_tmp115_ = _tmp114_;
							if (g_strcmp0 (_tmp115_, "main") == 0) {
								ValaSymbol* _tmp116_;
								ValaSymbol* _tmp117_;
								ValaSymbol* _tmp118_;
								const gchar* _tmp119_;
								const gchar* _tmp120_;
								_tmp116_ = self->priv->sym;
								_tmp117_ = vala_symbol_get_parent_symbol (_tmp116_);
								_tmp118_ = _tmp117_;
								_tmp119_ = vala_symbol_get_name (_tmp118_);
								_tmp120_ = _tmp119_;
								_tmp112_ = _tmp120_ == NULL;
							} else {
								_tmp112_ = FALSE;
							}
							if (_tmp112_) {
								ValaMethod* _tmp121_;
								gboolean _tmp122_;
								gboolean _tmp123_;
								_tmp121_ = m;
								_tmp122_ = vala_method_get_coroutine (_tmp121_);
								_tmp123_ = _tmp122_;
								if (_tmp123_) {
									gchar* _tmp124_;
									_tmp124_ = g_strdup ("_vala_main_async");
									result = _tmp124_;
									_g_free0 (cname);
									return result;
								} else {
									gchar* _tmp125_;
									_tmp125_ = g_strdup ("_vala_main");
									result = _tmp125_;
									_g_free0 (cname);
									return result;
								}
							} else {
								ValaSymbol* _tmp126_;
								const gchar* _tmp127_;
								const gchar* _tmp128_;
								_tmp126_ = self->priv->sym;
								_tmp127_ = vala_symbol_get_name (_tmp126_);
								_tmp128_ = _tmp127_;
								if (g_str_has_prefix (_tmp128_, "_")) {
									ValaSymbol* _tmp129_;
									ValaSymbol* _tmp130_;
									ValaSymbol* _tmp131_;
									gchar* _tmp132_;
									gchar* _tmp133_;
									ValaSymbol* _tmp134_;
									const gchar* _tmp135_;
									const gchar* _tmp136_;
									gchar* _tmp137_;
									gchar* _tmp138_;
									gchar* _tmp139_;
									_tmp129_ = self->priv->sym;
									_tmp130_ = vala_symbol_get_parent_symbol (_tmp129_);
									_tmp131_ = _tmp130_;
									_tmp132_ = vala_get_ccode_lower_case_prefix (_tmp131_);
									_tmp133_ = _tmp132_;
									_tmp134_ = self->priv->sym;
									_tmp135_ = vala_symbol_get_name (_tmp134_);
									_tmp136_ = _tmp135_;
									_tmp137_ = string_substring (_tmp136_, (glong) 1, (glong) -1);
									_tmp138_ = _tmp137_;
									_tmp139_ = g_strdup_printf ("_%s%s", _tmp133_, _tmp138_);
									_g_free0 (cname);
									cname = _tmp139_;
									_g_free0 (_tmp138_);
									_g_free0 (_tmp133_);
								} else {
									ValaSymbol* _tmp140_;
									ValaSymbol* _tmp141_;
									ValaSymbol* _tmp142_;
									gchar* _tmp143_;
									gchar* _tmp144_;
									ValaSymbol* _tmp145_;
									const gchar* _tmp146_;
									const gchar* _tmp147_;
									gchar* _tmp148_;
									_tmp140_ = self->priv->sym;
									_tmp141_ = vala_symbol_get_parent_symbol (_tmp140_);
									_tmp142_ = _tmp141_;
									_tmp143_ = vala_get_ccode_lower_case_prefix (_tmp142_);
									_tmp144_ = _tmp143_;
									_tmp145_ = self->priv->sym;
									_tmp146_ = vala_symbol_get_name (_tmp145_);
									_tmp147_ = _tmp146_;
									_tmp148_ = g_strdup_printf ("%s%s", _tmp144_, _tmp147_);
									_g_free0 (cname);
									cname = _tmp148_;
									_g_free0 (_tmp144_);
								}
							}
							_tmp149_ = vala_ccode_base_module_reserved_identifiers;
							_tmp150_ = cname;
							if (vala_collection_contains ((ValaCollection*) _tmp149_, _tmp150_)) {
								ValaCodeNode* _tmp151_;
								ValaSourceReference* _tmp152_;
								ValaSourceReference* _tmp153_;
								const gchar* _tmp154_;
								_tmp151_ = self->priv->node;
								_tmp152_ = vala_code_node_get_source_reference (_tmp151_);
								_tmp153_ = _tmp152_;
								_tmp154_ = cname;
								vala_report_error (_tmp153_, "Method name `%s' collides with reserved identifier. Use the `cname' at" \
"tribute to provide a valid C name if intended", _tmp154_);
							}
							result = cname;
							return result;
						} else {
							ValaSymbol* _tmp155_;
							_tmp155_ = self->priv->sym;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp155_, VALA_TYPE_PROPERTY)) {
								ValaSymbol* _tmp156_;
								const gchar* _tmp157_;
								const gchar* _tmp158_;
								gchar* _tmp159_;
								_tmp156_ = self->priv->sym;
								_tmp157_ = vala_symbol_get_name (_tmp156_);
								_tmp158_ = _tmp157_;
								_tmp159_ = string_replace (_tmp158_, "_", "-");
								result = _tmp159_;
								return result;
							} else {
								ValaSymbol* _tmp160_;
								_tmp160_ = self->priv->sym;
								if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp160_, VALA_TYPE_PROPERTY_ACCESSOR)) {
									ValaPropertyAccessor* acc = NULL;
									ValaSymbol* _tmp161_;
									ValaTypeSymbol* t = NULL;
									ValaPropertyAccessor* _tmp162_;
									ValaProperty* _tmp163_;
									ValaProperty* _tmp164_;
									ValaSymbol* _tmp165_;
									ValaSymbol* _tmp166_;
									ValaTypeSymbol* _tmp167_;
									ValaPropertyAccessor* _tmp168_;
									gboolean _tmp169_;
									gboolean _tmp170_;
									_tmp161_ = self->priv->sym;
									acc = G_TYPE_CHECK_INSTANCE_CAST (_tmp161_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor);
									_tmp162_ = acc;
									_tmp163_ = vala_property_accessor_get_prop (_tmp162_);
									_tmp164_ = _tmp163_;
									_tmp165_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp164_);
									_tmp166_ = _tmp165_;
									_tmp167_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp166_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
									t = _tmp167_;
									_tmp168_ = acc;
									_tmp169_ = vala_property_accessor_get_readable (_tmp168_);
									_tmp170_ = _tmp169_;
									if (_tmp170_) {
										ValaTypeSymbol* _tmp171_;
										gchar* _tmp172_;
										gchar* _tmp173_;
										ValaPropertyAccessor* _tmp174_;
										ValaProperty* _tmp175_;
										ValaProperty* _tmp176_;
										const gchar* _tmp177_;
										const gchar* _tmp178_;
										gchar* _tmp179_;
										gchar* _tmp180_;
										_tmp171_ = t;
										_tmp172_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp171_);
										_tmp173_ = _tmp172_;
										_tmp174_ = acc;
										_tmp175_ = vala_property_accessor_get_prop (_tmp174_);
										_tmp176_ = _tmp175_;
										_tmp177_ = vala_symbol_get_name ((ValaSymbol*) _tmp176_);
										_tmp178_ = _tmp177_;
										_tmp179_ = g_strdup_printf ("%sget_%s", _tmp173_, _tmp178_);
										_tmp180_ = _tmp179_;
										_g_free0 (_tmp173_);
										result = _tmp180_;
										_vala_code_node_unref0 (t);
										return result;
									} else {
										ValaTypeSymbol* _tmp181_;
										gchar* _tmp182_;
										gchar* _tmp183_;
										ValaPropertyAccessor* _tmp184_;
										ValaProperty* _tmp185_;
										ValaProperty* _tmp186_;
										const gchar* _tmp187_;
										const gchar* _tmp188_;
										gchar* _tmp189_;
										gchar* _tmp190_;
										_tmp181_ = t;
										_tmp182_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp181_);
										_tmp183_ = _tmp182_;
										_tmp184_ = acc;
										_tmp185_ = vala_property_accessor_get_prop (_tmp184_);
										_tmp186_ = _tmp185_;
										_tmp187_ = vala_symbol_get_name ((ValaSymbol*) _tmp186_);
										_tmp188_ = _tmp187_;
										_tmp189_ = g_strdup_printf ("%sset_%s", _tmp183_, _tmp188_);
										_tmp190_ = _tmp189_;
										_g_free0 (_tmp183_);
										result = _tmp190_;
										_vala_code_node_unref0 (t);
										return result;
									}
									_vala_code_node_unref0 (t);
								} else {
									ValaSymbol* _tmp191_;
									_tmp191_ = self->priv->sym;
									if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp191_, VALA_TYPE_SIGNAL)) {
										ValaSymbol* _tmp192_;
										const gchar* _tmp193_;
										const gchar* _tmp194_;
										gchar* _tmp195_;
										gchar* _tmp196_;
										gchar* _tmp197_;
										gchar* _tmp198_;
										_tmp192_ = self->priv->sym;
										_tmp193_ = vala_symbol_get_name (_tmp192_);
										_tmp194_ = _tmp193_;
										_tmp195_ = vala_symbol_camel_case_to_lower_case (_tmp194_);
										_tmp196_ = _tmp195_;
										_tmp197_ = string_replace (_tmp196_, "_", "-");
										_tmp198_ = _tmp197_;
										_g_free0 (_tmp196_);
										result = _tmp198_;
										return result;
									} else {
										ValaSymbol* _tmp199_;
										_tmp199_ = self->priv->sym;
										if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp199_, VALA_TYPE_LOCAL_VARIABLE)) {
											const gchar* name = NULL;
											ValaSymbol* _tmp200_;
											const gchar* _tmp201_;
											const gchar* _tmp202_;
											gboolean _tmp203_ = FALSE;
											ValaSet* _tmp204_;
											const gchar* _tmp205_;
											_tmp200_ = self->priv->sym;
											_tmp201_ = vala_symbol_get_name (_tmp200_);
											_tmp202_ = _tmp201_;
											name = _tmp202_;
											_tmp204_ = vala_ccode_base_module_reserved_identifiers;
											_tmp205_ = name;
											if (vala_collection_contains ((ValaCollection*) _tmp204_, _tmp205_)) {
												_tmp203_ = TRUE;
											} else {
												ValaSet* _tmp206_;
												const gchar* _tmp207_;
												_tmp206_ = vala_ccode_base_module_reserved_vala_identifiers;
												_tmp207_ = name;
												_tmp203_ = vala_collection_contains ((ValaCollection*) _tmp206_, _tmp207_);
											}
											if (_tmp203_) {
												const gchar* _tmp208_;
												gchar* _tmp209_;
												_tmp208_ = name;
												_tmp209_ = g_strdup_printf ("_%s_", _tmp208_);
												result = _tmp209_;
												return result;
											} else {
												const gchar* _tmp210_;
												gchar* _tmp211_;
												_tmp210_ = name;
												_tmp211_ = g_strdup (_tmp210_);
												result = _tmp211_;
												return result;
											}
										} else {
											ValaSymbol* _tmp212_;
											_tmp212_ = self->priv->sym;
											if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp212_, VALA_TYPE_PARAMETER)) {
												ValaParameter* param = NULL;
												ValaSymbol* _tmp213_;
												ValaParameter* _tmp214_;
												gboolean _tmp215_;
												gboolean _tmp216_;
												const gchar* name = NULL;
												ValaSymbol* _tmp218_;
												const gchar* _tmp219_;
												const gchar* _tmp220_;
												gboolean _tmp221_ = FALSE;
												ValaSet* _tmp222_;
												const gchar* _tmp223_;
												_tmp213_ = self->priv->sym;
												param = G_TYPE_CHECK_INSTANCE_CAST (_tmp213_, VALA_TYPE_PARAMETER, ValaParameter);
												_tmp214_ = param;
												_tmp215_ = vala_parameter_get_ellipsis (_tmp214_);
												_tmp216_ = _tmp215_;
												if (_tmp216_) {
													gchar* _tmp217_;
													_tmp217_ = g_strdup ("...");
													result = _tmp217_;
													return result;
												}
												_tmp218_ = self->priv->sym;
												_tmp219_ = vala_symbol_get_name (_tmp218_);
												_tmp220_ = _tmp219_;
												name = _tmp220_;
												_tmp222_ = vala_ccode_base_module_reserved_identifiers;
												_tmp223_ = name;
												if (vala_collection_contains ((ValaCollection*) _tmp222_, _tmp223_)) {
													_tmp221_ = TRUE;
												} else {
													ValaSet* _tmp224_;
													const gchar* _tmp225_;
													_tmp224_ = vala_ccode_base_module_reserved_vala_identifiers;
													_tmp225_ = name;
													_tmp221_ = vala_collection_contains ((ValaCollection*) _tmp224_, _tmp225_);
												}
												if (_tmp221_) {
													const gchar* _tmp226_;
													gchar* _tmp227_;
													_tmp226_ = name;
													_tmp227_ = g_strdup_printf ("_%s_", _tmp226_);
													result = _tmp227_;
													return result;
												} else {
													const gchar* _tmp228_;
													gchar* _tmp229_;
													_tmp228_ = name;
													_tmp229_ = g_strdup (_tmp228_);
													result = _tmp229_;
													return result;
												}
											} else {
												ValaSymbol* _tmp230_;
												_tmp230_ = self->priv->sym;
												if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp230_, VALA_TYPE_TYPEPARAMETER)) {
													ValaCodeNode* _tmp231_;
													ValaGenericType* type = NULL;
													ValaCodeNode* _tmp232_;
													ValaGenericType* _tmp233_;
													ValaGenericType* _tmp234_;
													gboolean _tmp235_;
													gboolean _tmp236_;
													_tmp231_ = self->priv->node;
													_vala_assert (G_TYPE_CHECK_INSTANCE_TYPE (_tmp231_, VALA_TYPE_GENERIC_TYPE), "node is GenericType");
													_tmp232_ = self->priv->node;
													_tmp233_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp232_, VALA_TYPE_GENERIC_TYPE, ValaGenericType));
													type = _tmp233_;
													_tmp234_ = type;
													_tmp235_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp234_);
													_tmp236_ = _tmp235_;
													if (_tmp236_) {
														ValaCodeContext* _tmp237_;
														ValaCodeContext* _tmp238_;
														ValaProfile _tmp239_;
														ValaProfile _tmp240_;
														gboolean _tmp241_;
														_tmp237_ = vala_code_context_get ();
														_tmp238_ = _tmp237_;
														_tmp239_ = vala_code_context_get_profile (_tmp238_);
														_tmp240_ = _tmp239_;
														_tmp241_ = _tmp240_ == VALA_PROFILE_GOBJECT;
														_vala_code_context_unref0 (_tmp238_);
														if (_tmp241_) {
															gchar* _tmp242_;
															_tmp242_ = g_strdup ("gpointer");
															result = _tmp242_;
															_vala_code_node_unref0 (type);
															return result;
														} else {
															gchar* _tmp243_;
															_tmp243_ = g_strdup ("void *");
															result = _tmp243_;
															_vala_code_node_unref0 (type);
															return result;
														}
													} else {
														ValaCodeContext* _tmp244_;
														ValaCodeContext* _tmp245_;
														ValaProfile _tmp246_;
														ValaProfile _tmp247_;
														gboolean _tmp248_;
														_tmp244_ = vala_code_context_get ();
														_tmp245_ = _tmp244_;
														_tmp246_ = vala_code_context_get_profile (_tmp245_);
														_tmp247_ = _tmp246_;
														_tmp248_ = _tmp247_ == VALA_PROFILE_GOBJECT;
														_vala_code_context_unref0 (_tmp245_);
														if (_tmp248_) {
															gchar* _tmp249_;
															_tmp249_ = g_strdup ("gconstpointer");
															result = _tmp249_;
															_vala_code_node_unref0 (type);
															return result;
														} else {
															gchar* _tmp250_;
															_tmp250_ = g_strdup ("const void *");
															result = _tmp250_;
															_vala_code_node_unref0 (type);
															return result;
														}
													}
													_vala_code_node_unref0 (type);
												} else {
													ValaSymbol* _tmp251_;
													ValaSymbol* _tmp252_;
													ValaSymbol* _tmp253_;
													gchar* _tmp254_;
													gchar* _tmp255_;
													ValaSymbol* _tmp256_;
													const gchar* _tmp257_;
													const gchar* _tmp258_;
													gchar* _tmp259_;
													gchar* _tmp260_;
													_tmp251_ = self->priv->sym;
													_tmp252_ = vala_symbol_get_parent_symbol (_tmp251_);
													_tmp253_ = _tmp252_;
													_tmp254_ = vala_get_ccode_prefix (_tmp253_);
													_tmp255_ = _tmp254_;
													_tmp256_ = self->priv->sym;
													_tmp257_ = vala_symbol_get_name (_tmp256_);
													_tmp258_ = _tmp257_;
													_tmp259_ = g_strdup_printf ("%s%s", _tmp255_, _tmp258_);
													_tmp260_ = _tmp259_;
													_g_free0 (_tmp255_);
													result = _tmp260_;
													return result;
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
	} else {
		ValaCodeNode* _tmp261_;
		_tmp261_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp261_, VALA_TYPE_OBJECT_TYPE)) {
			ValaObjectType* type = NULL;
			ValaCodeNode* _tmp262_;
			ValaObjectType* _tmp263_;
			gchar* cname = NULL;
			ValaObjectType* _tmp264_;
			gboolean _tmp265_;
			gboolean _tmp266_;
			const gchar* _tmp275_;
			gchar* _tmp276_;
			_tmp262_ = self->priv->node;
			_tmp263_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp262_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));
			type = _tmp263_;
			_tmp264_ = type;
			_tmp265_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp264_);
			_tmp266_ = _tmp265_;
			if (!_tmp266_) {
				ValaObjectType* _tmp267_;
				ValaTypeSymbol* _tmp268_;
				ValaTypeSymbol* _tmp269_;
				gchar* _tmp270_;
				_tmp267_ = type;
				_tmp268_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp267_);
				_tmp269_ = _tmp268_;
				_tmp270_ = vala_get_ccode_const_name ((ValaCodeNode*) _tmp269_);
				_g_free0 (cname);
				cname = _tmp270_;
			} else {
				ValaObjectType* _tmp271_;
				ValaTypeSymbol* _tmp272_;
				ValaTypeSymbol* _tmp273_;
				gchar* _tmp274_;
				_tmp271_ = type;
				_tmp272_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp271_);
				_tmp273_ = _tmp272_;
				_tmp274_ = vala_get_ccode_name ((ValaCodeNode*) _tmp273_);
				_g_free0 (cname);
				cname = _tmp274_;
			}
			_tmp275_ = cname;
			_tmp276_ = g_strdup_printf ("%s*", _tmp275_);
			result = _tmp276_;
			_g_free0 (cname);
			_vala_code_node_unref0 (type);
			return result;
		} else {
			ValaCodeNode* _tmp277_;
			_tmp277_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp277_, VALA_TYPE_ARRAY_TYPE)) {
				ValaArrayType* type = NULL;
				ValaCodeNode* _tmp278_;
				ValaArrayType* _tmp279_;
				gchar* cname = NULL;
				ValaArrayType* _tmp280_;
				ValaDataType* _tmp281_;
				ValaDataType* _tmp282_;
				gchar* _tmp283_;
				ValaArrayType* _tmp284_;
				gboolean _tmp285_;
				gboolean _tmp286_;
				_tmp278_ = self->priv->node;
				_tmp279_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp278_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
				type = _tmp279_;
				_tmp280_ = type;
				_tmp281_ = vala_array_type_get_element_type (_tmp280_);
				_tmp282_ = _tmp281_;
				_tmp283_ = vala_get_ccode_name ((ValaCodeNode*) _tmp282_);
				cname = _tmp283_;
				_tmp284_ = type;
				_tmp285_ = vala_array_type_get_inline_allocated (_tmp284_);
				_tmp286_ = _tmp285_;
				if (_tmp286_) {
					result = cname;
					_vala_code_node_unref0 (type);
					return result;
				} else {
					const gchar* _tmp287_;
					gchar* _tmp288_;
					_tmp287_ = cname;
					_tmp288_ = g_strdup_printf ("%s*", _tmp287_);
					result = _tmp288_;
					_g_free0 (cname);
					_vala_code_node_unref0 (type);
					return result;
				}
				_g_free0 (cname);
				_vala_code_node_unref0 (type);
			} else {
				ValaCodeNode* _tmp289_;
				_tmp289_ = self->priv->node;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp289_, VALA_TYPE_DELEGATE_TYPE)) {
					ValaDelegateType* type = NULL;
					ValaCodeNode* _tmp290_;
					ValaDelegateType* _tmp291_;
					ValaDelegateType* _tmp292_;
					ValaDelegate* _tmp293_;
					ValaDelegate* _tmp294_;
					gchar* _tmp295_;
					_tmp290_ = self->priv->node;
					_tmp291_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp290_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
					type = _tmp291_;
					_tmp292_ = type;
					_tmp293_ = vala_delegate_type_get_delegate_symbol (_tmp292_);
					_tmp294_ = _tmp293_;
					_tmp295_ = vala_get_ccode_name ((ValaCodeNode*) _tmp294_);
					result = _tmp295_;
					_vala_code_node_unref0 (type);
					return result;
				} else {
					ValaCodeNode* _tmp296_;
					_tmp296_ = self->priv->node;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp296_, VALA_TYPE_ERROR_TYPE)) {
						gchar* _tmp297_;
						_tmp297_ = g_strdup ("GError*");
						result = _tmp297_;
						return result;
					} else {
						ValaCodeNode* _tmp298_;
						_tmp298_ = self->priv->node;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp298_, VALA_TYPE_GENERIC_TYPE)) {
							ValaGenericType* type = NULL;
							ValaCodeNode* _tmp299_;
							ValaGenericType* _tmp300_;
							ValaGenericType* _tmp301_;
							gboolean _tmp302_;
							gboolean _tmp303_;
							_tmp299_ = self->priv->node;
							_tmp300_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp299_, VALA_TYPE_GENERIC_TYPE, ValaGenericType));
							type = _tmp300_;
							_tmp301_ = type;
							_tmp302_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp301_);
							_tmp303_ = _tmp302_;
							if (_tmp303_) {
								ValaCodeContext* _tmp304_;
								ValaCodeContext* _tmp305_;
								ValaProfile _tmp306_;
								ValaProfile _tmp307_;
								gboolean _tmp308_;
								_tmp304_ = vala_code_context_get ();
								_tmp305_ = _tmp304_;
								_tmp306_ = vala_code_context_get_profile (_tmp305_);
								_tmp307_ = _tmp306_;
								_tmp308_ = _tmp307_ == VALA_PROFILE_GOBJECT;
								_vala_code_context_unref0 (_tmp305_);
								if (_tmp308_) {
									gchar* _tmp309_;
									_tmp309_ = g_strdup ("gpointer");
									result = _tmp309_;
									_vala_code_node_unref0 (type);
									return result;
								} else {
									gchar* _tmp310_;
									_tmp310_ = g_strdup ("void *");
									result = _tmp310_;
									_vala_code_node_unref0 (type);
									return result;
								}
							} else {
								ValaCodeContext* _tmp311_;
								ValaCodeContext* _tmp312_;
								ValaProfile _tmp313_;
								ValaProfile _tmp314_;
								gboolean _tmp315_;
								_tmp311_ = vala_code_context_get ();
								_tmp312_ = _tmp311_;
								_tmp313_ = vala_code_context_get_profile (_tmp312_);
								_tmp314_ = _tmp313_;
								_tmp315_ = _tmp314_ == VALA_PROFILE_GOBJECT;
								_vala_code_context_unref0 (_tmp312_);
								if (_tmp315_) {
									gchar* _tmp316_;
									_tmp316_ = g_strdup ("gconstpointer");
									result = _tmp316_;
									_vala_code_node_unref0 (type);
									return result;
								} else {
									gchar* _tmp317_;
									_tmp317_ = g_strdup ("const void *");
									result = _tmp317_;
									_vala_code_node_unref0 (type);
									return result;
								}
							}
							_vala_code_node_unref0 (type);
						} else {
							ValaCodeNode* _tmp318_;
							_tmp318_ = self->priv->node;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp318_, VALA_TYPE_METHOD_TYPE)) {
								ValaCodeContext* _tmp319_;
								ValaCodeContext* _tmp320_;
								ValaProfile _tmp321_;
								ValaProfile _tmp322_;
								gboolean _tmp323_;
								_tmp319_ = vala_code_context_get ();
								_tmp320_ = _tmp319_;
								_tmp321_ = vala_code_context_get_profile (_tmp320_);
								_tmp322_ = _tmp321_;
								_tmp323_ = _tmp322_ == VALA_PROFILE_GOBJECT;
								_vala_code_context_unref0 (_tmp320_);
								if (_tmp323_) {
									gchar* _tmp324_;
									_tmp324_ = g_strdup ("gpointer");
									result = _tmp324_;
									return result;
								} else {
									gchar* _tmp325_;
									_tmp325_ = g_strdup ("void *");
									result = _tmp325_;
									return result;
								}
							} else {
								ValaCodeNode* _tmp326_;
								_tmp326_ = self->priv->node;
								if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp326_, VALA_TYPE_NULL_TYPE)) {
									ValaCodeContext* _tmp327_;
									ValaCodeContext* _tmp328_;
									ValaProfile _tmp329_;
									ValaProfile _tmp330_;
									gboolean _tmp331_;
									_tmp327_ = vala_code_context_get ();
									_tmp328_ = _tmp327_;
									_tmp329_ = vala_code_context_get_profile (_tmp328_);
									_tmp330_ = _tmp329_;
									_tmp331_ = _tmp330_ == VALA_PROFILE_GOBJECT;
									_vala_code_context_unref0 (_tmp328_);
									if (_tmp331_) {
										gchar* _tmp332_;
										_tmp332_ = g_strdup ("gpointer");
										result = _tmp332_;
										return result;
									} else {
										gchar* _tmp333_;
										_tmp333_ = g_strdup ("void *");
										result = _tmp333_;
										return result;
									}
								} else {
									ValaCodeNode* _tmp334_;
									_tmp334_ = self->priv->node;
									if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp334_, VALA_TYPE_POINTER_TYPE)) {
										ValaPointerType* type = NULL;
										ValaCodeNode* _tmp335_;
										ValaPointerType* _tmp336_;
										gboolean _tmp337_ = FALSE;
										ValaPointerType* _tmp338_;
										ValaDataType* _tmp339_;
										ValaDataType* _tmp340_;
										ValaTypeSymbol* _tmp341_;
										ValaTypeSymbol* _tmp342_;
										_tmp335_ = self->priv->node;
										_tmp336_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp335_, VALA_TYPE_POINTER_TYPE, ValaPointerType));
										type = _tmp336_;
										_tmp338_ = type;
										_tmp339_ = vala_pointer_type_get_base_type (_tmp338_);
										_tmp340_ = _tmp339_;
										_tmp341_ = vala_data_type_get_type_symbol (_tmp340_);
										_tmp342_ = _tmp341_;
										if (_tmp342_ != NULL) {
											ValaPointerType* _tmp343_;
											ValaDataType* _tmp344_;
											ValaDataType* _tmp345_;
											ValaTypeSymbol* _tmp346_;
											ValaTypeSymbol* _tmp347_;
											_tmp343_ = type;
											_tmp344_ = vala_pointer_type_get_base_type (_tmp343_);
											_tmp345_ = _tmp344_;
											_tmp346_ = vala_data_type_get_type_symbol (_tmp345_);
											_tmp347_ = _tmp346_;
											_tmp337_ = vala_typesymbol_is_reference_type (_tmp347_);
										} else {
											_tmp337_ = FALSE;
										}
										if (_tmp337_) {
											ValaPointerType* _tmp348_;
											ValaDataType* _tmp349_;
											ValaDataType* _tmp350_;
											gchar* _tmp351_;
											_tmp348_ = type;
											_tmp349_ = vala_pointer_type_get_base_type (_tmp348_);
											_tmp350_ = _tmp349_;
											_tmp351_ = vala_get_ccode_name ((ValaCodeNode*) _tmp350_);
											result = _tmp351_;
											_vala_code_node_unref0 (type);
											return result;
										} else {
											ValaPointerType* _tmp352_;
											ValaDataType* _tmp353_;
											ValaDataType* _tmp354_;
											gchar* _tmp355_;
											gchar* _tmp356_;
											gchar* _tmp357_;
											gchar* _tmp358_;
											_tmp352_ = type;
											_tmp353_ = vala_pointer_type_get_base_type (_tmp352_);
											_tmp354_ = _tmp353_;
											_tmp355_ = vala_get_ccode_name ((ValaCodeNode*) _tmp354_);
											_tmp356_ = _tmp355_;
											_tmp357_ = g_strdup_printf ("%s*", _tmp356_);
											_tmp358_ = _tmp357_;
											_g_free0 (_tmp356_);
											result = _tmp358_;
											_vala_code_node_unref0 (type);
											return result;
										}
										_vala_code_node_unref0 (type);
									} else {
										ValaCodeNode* _tmp359_;
										_tmp359_ = self->priv->node;
										if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp359_, VALA_TYPE_VOID_TYPE)) {
											gchar* _tmp360_;
											_tmp360_ = g_strdup ("void");
											result = _tmp360_;
											return result;
										} else {
											ValaCodeNode* _tmp361_;
											_tmp361_ = self->priv->node;
											if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp361_, VALA_TYPE_CLASS_TYPE)) {
												ValaClassType* type = NULL;
												ValaCodeNode* _tmp362_;
												ValaClassType* _tmp363_;
												ValaClassType* _tmp364_;
												ValaClass* _tmp365_;
												ValaClass* _tmp366_;
												gchar* _tmp367_;
												gchar* _tmp368_;
												gchar* _tmp369_;
												gchar* _tmp370_;
												_tmp362_ = self->priv->node;
												_tmp363_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp362_, VALA_TYPE_CLASS_TYPE, ValaClassType));
												type = _tmp363_;
												_tmp364_ = type;
												_tmp365_ = vala_class_type_get_class_symbol (_tmp364_);
												_tmp366_ = _tmp365_;
												_tmp367_ = vala_get_ccode_type_name ((ValaObjectTypeSymbol*) _tmp366_);
												_tmp368_ = _tmp367_;
												_tmp369_ = g_strdup_printf ("%s*", _tmp368_);
												_tmp370_ = _tmp369_;
												_g_free0 (_tmp368_);
												result = _tmp370_;
												_vala_code_node_unref0 (type);
												return result;
											} else {
												ValaCodeNode* _tmp371_;
												_tmp371_ = self->priv->node;
												if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp371_, VALA_TYPE_INTERFACE_TYPE)) {
													ValaInterfaceType* type = NULL;
													ValaCodeNode* _tmp372_;
													ValaInterfaceType* _tmp373_;
													ValaInterfaceType* _tmp374_;
													ValaInterface* _tmp375_;
													ValaInterface* _tmp376_;
													gchar* _tmp377_;
													gchar* _tmp378_;
													gchar* _tmp379_;
													gchar* _tmp380_;
													_tmp372_ = self->priv->node;
													_tmp373_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp372_, VALA_TYPE_INTERFACE_TYPE, ValaInterfaceType));
													type = _tmp373_;
													_tmp374_ = type;
													_tmp375_ = vala_interface_type_get_interface_symbol (_tmp374_);
													_tmp376_ = _tmp375_;
													_tmp377_ = vala_get_ccode_type_name ((ValaObjectTypeSymbol*) _tmp376_);
													_tmp378_ = _tmp377_;
													_tmp379_ = g_strdup_printf ("%s*", _tmp378_);
													_tmp380_ = _tmp379_;
													_g_free0 (_tmp378_);
													result = _tmp380_;
													_vala_code_node_unref0 (type);
													return result;
												} else {
													ValaCodeNode* _tmp381_;
													_tmp381_ = self->priv->node;
													if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp381_, VALA_TYPE_VALUE_TYPE)) {
														ValaValueType* type = NULL;
														ValaCodeNode* _tmp382_;
														ValaValueType* _tmp383_;
														gchar* cname = NULL;
														ValaValueType* _tmp384_;
														ValaTypeSymbol* _tmp385_;
														ValaTypeSymbol* _tmp386_;
														gchar* _tmp387_;
														ValaValueType* _tmp388_;
														gboolean _tmp389_;
														gboolean _tmp390_;
														_tmp382_ = self->priv->node;
														_tmp383_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp382_, VALA_TYPE_VALUE_TYPE, ValaValueType));
														type = _tmp383_;
														_tmp384_ = type;
														_tmp385_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp384_);
														_tmp386_ = _tmp385_;
														_tmp387_ = vala_get_ccode_name ((ValaCodeNode*) _tmp386_);
														cname = _tmp387_;
														_tmp388_ = type;
														_tmp389_ = vala_data_type_get_nullable ((ValaDataType*) _tmp388_);
														_tmp390_ = _tmp389_;
														if (_tmp390_) {
															const gchar* _tmp391_;
															gchar* _tmp392_;
															_tmp391_ = cname;
															_tmp392_ = g_strdup_printf ("%s*", _tmp391_);
															result = _tmp392_;
															_g_free0 (cname);
															_vala_code_node_unref0 (type);
															return result;
														} else {
															result = cname;
															_vala_code_node_unref0 (type);
															return result;
														}
														_g_free0 (cname);
														_vala_code_node_unref0 (type);
													} else {
														ValaCodeNode* _tmp393_;
														_tmp393_ = self->priv->node;
														if (VALA_IS_CTYPE (_tmp393_)) {
															ValaCodeNode* _tmp394_;
															const gchar* _tmp395_;
															const gchar* _tmp396_;
															gchar* _tmp397_;
															_tmp394_ = self->priv->node;
															_tmp395_ = vala_ctype_get_ctype_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp394_, VALA_TYPE_CTYPE, ValaCType));
															_tmp396_ = _tmp395_;
															_tmp397_ = g_strdup (_tmp396_);
															result = _tmp397_;
															return result;
														} else {
															ValaCodeNode* _tmp398_;
															ValaSourceReference* _tmp399_;
															ValaSourceReference* _tmp400_;
															gchar* _tmp401_;
															_tmp398_ = self->priv->node;
															_tmp399_ = vala_code_node_get_source_reference (_tmp398_);
															_tmp400_ = _tmp399_;
															vala_report_error (_tmp400_, "Unresolved type reference");
															_tmp401_ = g_strdup ("");
															result = _tmp401_;
															return result;
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}
}

static gchar*
vala_ccode_attribute_get_default_header_filenames (ValaCCodeAttribute* self)
{
	gboolean _tmp0_ = FALSE;
	ValaSymbol* _tmp1_;
	gboolean _tmp4_ = FALSE;
	ValaSymbol* _tmp5_;
	ValaSymbol* _tmp6_;
	ValaSymbol* _tmp7_;
	gboolean _tmp18_ = FALSE;
	gboolean _tmp19_ = FALSE;
	ValaSymbol* _tmp20_;
	ValaSourceReference* _tmp21_;
	ValaSourceReference* _tmp22_;
	gchar* _tmp35_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp1_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_DYNAMIC_PROPERTY)) {
		_tmp0_ = TRUE;
	} else {
		ValaSymbol* _tmp2_;
		_tmp2_ = self->priv->sym;
		_tmp0_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_DYNAMIC_METHOD);
	}
	if (_tmp0_) {
		gchar* _tmp3_;
		_tmp3_ = g_strdup ("");
		result = _tmp3_;
		return result;
	}
	_tmp5_ = self->priv->sym;
	_tmp6_ = vala_symbol_get_parent_symbol (_tmp5_);
	_tmp7_ = _tmp6_;
	if (_tmp7_ != NULL) {
		ValaSymbol* _tmp8_;
		gboolean _tmp9_;
		gboolean _tmp10_;
		_tmp8_ = self->priv->sym;
		_tmp9_ = vala_symbol_get_is_extern (_tmp8_);
		_tmp10_ = _tmp9_;
		_tmp4_ = !_tmp10_;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		gchar* parent_headers = NULL;
		ValaSymbol* _tmp11_;
		ValaSymbol* _tmp12_;
		ValaSymbol* _tmp13_;
		gchar* _tmp14_;
		const gchar* _tmp15_;
		gint _tmp16_;
		gint _tmp17_;
		_tmp11_ = self->priv->sym;
		_tmp12_ = vala_symbol_get_parent_symbol (_tmp11_);
		_tmp13_ = _tmp12_;
		_tmp14_ = vala_get_ccode_header_filenames (_tmp13_);
		parent_headers = _tmp14_;
		_tmp15_ = parent_headers;
		_tmp16_ = strlen (_tmp15_);
		_tmp17_ = _tmp16_;
		if (_tmp17_ > 0) {
			result = parent_headers;
			return result;
		}
		_g_free0 (parent_headers);
	}
	_tmp20_ = self->priv->sym;
	_tmp21_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp20_);
	_tmp22_ = _tmp21_;
	if (_tmp22_ != NULL) {
		ValaSymbol* _tmp23_;
		gboolean _tmp24_;
		gboolean _tmp25_;
		_tmp23_ = self->priv->sym;
		_tmp24_ = vala_symbol_get_external_package (_tmp23_);
		_tmp25_ = _tmp24_;
		_tmp19_ = !_tmp25_;
	} else {
		_tmp19_ = FALSE;
	}
	if (_tmp19_) {
		ValaSymbol* _tmp26_;
		gboolean _tmp27_;
		gboolean _tmp28_;
		_tmp26_ = self->priv->sym;
		_tmp27_ = vala_symbol_get_is_extern (_tmp26_);
		_tmp28_ = _tmp27_;
		_tmp18_ = !_tmp28_;
	} else {
		_tmp18_ = FALSE;
	}
	if (_tmp18_) {
		ValaSymbol* _tmp29_;
		ValaSourceReference* _tmp30_;
		ValaSourceReference* _tmp31_;
		ValaSourceFile* _tmp32_;
		ValaSourceFile* _tmp33_;
		gchar* _tmp34_;
		_tmp29_ = self->priv->sym;
		_tmp30_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp29_);
		_tmp31_ = _tmp30_;
		_tmp32_ = vala_source_reference_get_file (_tmp31_);
		_tmp33_ = _tmp32_;
		_tmp34_ = vala_source_file_get_cinclude_filename (_tmp33_);
		result = _tmp34_;
		return result;
	}
	_tmp35_ = g_strdup ("");
	result = _tmp35_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_prefix (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* _tmp37_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) {
		const gchar* _tmp1_;
		const gchar* _tmp2_;
		gchar* _tmp3_;
		_tmp1_ = vala_ccode_attribute_get_name (self);
		_tmp2_ = _tmp1_;
		_tmp3_ = g_strdup (_tmp2_);
		result = _tmp3_;
		return result;
	} else {
		gboolean _tmp4_ = FALSE;
		ValaSymbol* _tmp5_;
		_tmp5_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_ENUM)) {
			_tmp4_ = TRUE;
		} else {
			ValaSymbol* _tmp6_;
			_tmp6_ = self->priv->sym;
			_tmp4_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_ERROR_DOMAIN);
		}
		if (_tmp4_) {
			ValaSymbol* _tmp7_;
			gchar* _tmp8_;
			gchar* _tmp9_;
			gchar* _tmp10_;
			gchar* _tmp11_;
			_tmp7_ = self->priv->sym;
			_tmp8_ = vala_get_ccode_upper_case_name (_tmp7_, NULL);
			_tmp9_ = _tmp8_;
			_tmp10_ = g_strdup_printf ("%s_", _tmp9_);
			_tmp11_ = _tmp10_;
			_g_free0 (_tmp9_);
			result = _tmp11_;
			return result;
		} else {
			ValaSymbol* _tmp12_;
			_tmp12_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_NAMESPACE)) {
				ValaSymbol* _tmp13_;
				const gchar* _tmp14_;
				const gchar* _tmp15_;
				_tmp13_ = self->priv->sym;
				_tmp14_ = vala_symbol_get_name (_tmp13_);
				_tmp15_ = _tmp14_;
				if (_tmp15_ != NULL) {
					gchar* parent_prefix = NULL;
					gchar* _tmp16_;
					ValaSymbol* _tmp17_;
					ValaSymbol* _tmp18_;
					ValaSymbol* _tmp19_;
					const gchar* _tmp24_;
					ValaSymbol* _tmp25_;
					const gchar* _tmp26_;
					const gchar* _tmp27_;
					gchar* _tmp28_;
					_tmp16_ = g_strdup ("");
					parent_prefix = _tmp16_;
					_tmp17_ = self->priv->sym;
					_tmp18_ = vala_symbol_get_parent_symbol (_tmp17_);
					_tmp19_ = _tmp18_;
					if (_tmp19_ != NULL) {
						ValaSymbol* _tmp20_;
						ValaSymbol* _tmp21_;
						ValaSymbol* _tmp22_;
						gchar* _tmp23_;
						_tmp20_ = self->priv->sym;
						_tmp21_ = vala_symbol_get_parent_symbol (_tmp20_);
						_tmp22_ = _tmp21_;
						_tmp23_ = vala_get_ccode_prefix (_tmp22_);
						_g_free0 (parent_prefix);
						parent_prefix = _tmp23_;
					}
					_tmp24_ = parent_prefix;
					_tmp25_ = self->priv->sym;
					_tmp26_ = vala_symbol_get_name (_tmp25_);
					_tmp27_ = _tmp26_;
					_tmp28_ = g_strdup_printf ("%s%s", _tmp24_, _tmp27_);
					result = _tmp28_;
					_g_free0 (parent_prefix);
					return result;
				} else {
					gchar* _tmp29_;
					_tmp29_ = g_strdup ("");
					result = _tmp29_;
					return result;
				}
			} else {
				ValaSymbol* _tmp30_;
				const gchar* _tmp31_;
				const gchar* _tmp32_;
				_tmp30_ = self->priv->sym;
				_tmp31_ = vala_symbol_get_name (_tmp30_);
				_tmp32_ = _tmp31_;
				if (_tmp32_ != NULL) {
					ValaSymbol* _tmp33_;
					const gchar* _tmp34_;
					const gchar* _tmp35_;
					gchar* _tmp36_;
					_tmp33_ = self->priv->sym;
					_tmp34_ = vala_symbol_get_name (_tmp33_);
					_tmp35_ = _tmp34_;
					_tmp36_ = g_strdup (_tmp35_);
					result = _tmp36_;
					return result;
				}
			}
		}
	}
	_tmp37_ = g_strdup ("");
	result = _tmp37_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_lower_case_prefix (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_NAMESPACE)) {
		ValaSymbol* _tmp1_;
		const gchar* _tmp2_;
		const gchar* _tmp3_;
		_tmp1_ = self->priv->sym;
		_tmp2_ = vala_symbol_get_name (_tmp1_);
		_tmp3_ = _tmp2_;
		if (_tmp3_ == NULL) {
			gchar* _tmp4_;
			_tmp4_ = g_strdup ("");
			result = _tmp4_;
			return result;
		} else {
			ValaSymbol* _tmp5_;
			ValaSymbol* _tmp6_;
			ValaSymbol* _tmp7_;
			gchar* _tmp8_;
			gchar* _tmp9_;
			ValaSymbol* _tmp10_;
			const gchar* _tmp11_;
			const gchar* _tmp12_;
			gchar* _tmp13_;
			gchar* _tmp14_;
			gchar* _tmp15_;
			gchar* _tmp16_;
			_tmp5_ = self->priv->sym;
			_tmp6_ = vala_symbol_get_parent_symbol (_tmp5_);
			_tmp7_ = _tmp6_;
			_tmp8_ = vala_get_ccode_lower_case_prefix (_tmp7_);
			_tmp9_ = _tmp8_;
			_tmp10_ = self->priv->sym;
			_tmp11_ = vala_symbol_get_name (_tmp10_);
			_tmp12_ = _tmp11_;
			_tmp13_ = vala_symbol_camel_case_to_lower_case (_tmp12_);
			_tmp14_ = _tmp13_;
			_tmp15_ = g_strdup_printf ("%s%s_", _tmp9_, _tmp14_);
			_tmp16_ = _tmp15_;
			_g_free0 (_tmp14_);
			_g_free0 (_tmp9_);
			result = _tmp16_;
			return result;
		}
	} else {
		ValaSymbol* _tmp17_;
		_tmp17_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_METHOD)) {
			gchar* _tmp18_;
			_tmp18_ = g_strdup ("");
			result = _tmp18_;
			return result;
		} else {
			ValaSymbol* _tmp19_;
			gchar* _tmp20_;
			gchar* _tmp21_;
			gchar* _tmp22_;
			gchar* _tmp23_;
			_tmp19_ = self->priv->sym;
			_tmp20_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp19_, NULL);
			_tmp21_ = _tmp20_;
			_tmp22_ = g_strdup_printf ("%s_", _tmp21_);
			_tmp23_ = _tmp22_;
			_g_free0 (_tmp21_);
			result = _tmp23_;
			return result;
		}
	}
}

static gchar*
vala_ccode_attribute_get_default_lower_case_suffix (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* _tmp42_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) {
		gchar* csuffix = NULL;
		ValaSymbol* _tmp1_;
		const gchar* _tmp2_;
		const gchar* _tmp3_;
		gchar* _tmp4_;
		const gchar* _tmp5_;
		const gchar* _tmp19_;
		_tmp1_ = self->priv->sym;
		_tmp2_ = vala_symbol_get_name (_tmp1_);
		_tmp3_ = _tmp2_;
		_tmp4_ = vala_symbol_camel_case_to_lower_case (_tmp3_);
		csuffix = _tmp4_;
		_tmp5_ = csuffix;
		if (g_str_has_prefix (_tmp5_, "type_")) {
			const gchar* _tmp6_;
			gint _tmp7_;
			gint _tmp8_;
			gchar* _tmp9_;
			gchar* _tmp10_;
			gchar* _tmp11_;
			_tmp6_ = csuffix;
			_tmp7_ = strlen ("type_");
			_tmp8_ = _tmp7_;
			_tmp9_ = string_substring (_tmp6_, (glong) _tmp8_, (glong) -1);
			_tmp10_ = _tmp9_;
			_tmp11_ = g_strconcat ("type", _tmp10_, NULL);
			_g_free0 (csuffix);
			csuffix = _tmp11_;
			_g_free0 (_tmp10_);
		} else {
			const gchar* _tmp12_;
			_tmp12_ = csuffix;
			if (g_str_has_prefix (_tmp12_, "is_")) {
				const gchar* _tmp13_;
				gint _tmp14_;
				gint _tmp15_;
				gchar* _tmp16_;
				gchar* _tmp17_;
				gchar* _tmp18_;
				_tmp13_ = csuffix;
				_tmp14_ = strlen ("is_");
				_tmp15_ = _tmp14_;
				_tmp16_ = string_substring (_tmp13_, (glong) _tmp15_, (glong) -1);
				_tmp17_ = _tmp16_;
				_tmp18_ = g_strconcat ("is", _tmp17_, NULL);
				_g_free0 (csuffix);
				csuffix = _tmp18_;
				_g_free0 (_tmp17_);
			}
		}
		_tmp19_ = csuffix;
		if (g_str_has_suffix (_tmp19_, "_class")) {
			const gchar* _tmp20_;
			const gchar* _tmp21_;
			gint _tmp22_;
			gint _tmp23_;
			gint _tmp24_;
			gint _tmp25_;
			gchar* _tmp26_;
			gchar* _tmp27_;
			gchar* _tmp28_;
			_tmp20_ = csuffix;
			_tmp21_ = csuffix;
			_tmp22_ = strlen (_tmp21_);
			_tmp23_ = _tmp22_;
			_tmp24_ = strlen ("_class");
			_tmp25_ = _tmp24_;
			_tmp26_ = string_substring (_tmp20_, (glong) 0, (glong) (_tmp23_ - _tmp25_));
			_tmp27_ = _tmp26_;
			_tmp28_ = g_strconcat (_tmp27_, "class", NULL);
			_g_free0 (csuffix);
			csuffix = _tmp28_;
			_g_free0 (_tmp27_);
		}
		result = csuffix;
		return result;
	} else {
		ValaSymbol* _tmp29_;
		_tmp29_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_SIGNAL)) {
			ValaSymbol* _tmp30_;
			ValaCCodeAttribute* _tmp31_;
			const gchar* _tmp32_;
			const gchar* _tmp33_;
			gchar* _tmp34_;
			_tmp30_ = self->priv->sym;
			_tmp31_ = vala_get_ccode_attribute ((ValaCodeNode*) _tmp30_);
			_tmp32_ = vala_ccode_attribute_get_name (_tmp31_);
			_tmp33_ = _tmp32_;
			_tmp34_ = string_replace (_tmp33_, "-", "_");
			result = _tmp34_;
			return result;
		} else {
			ValaSymbol* _tmp35_;
			const gchar* _tmp36_;
			const gchar* _tmp37_;
			_tmp35_ = self->priv->sym;
			_tmp36_ = vala_symbol_get_name (_tmp35_);
			_tmp37_ = _tmp36_;
			if (_tmp37_ != NULL) {
				ValaSymbol* _tmp38_;
				const gchar* _tmp39_;
				const gchar* _tmp40_;
				gchar* _tmp41_;
				_tmp38_ = self->priv->sym;
				_tmp39_ = vala_symbol_get_name (_tmp38_);
				_tmp40_ = _tmp39_;
				_tmp41_ = vala_symbol_camel_case_to_lower_case (_tmp40_);
				result = _tmp41_;
				return result;
			}
		}
	}
	_tmp42_ = g_strdup ("");
	result = _tmp42_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_ref_function (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
		ValaClass* cl = NULL;
		ValaSymbol* _tmp1_;
		ValaClass* _tmp2_;
		_tmp1_ = self->priv->sym;
		cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
		_tmp2_ = cl;
		if (vala_class_is_fundamental (_tmp2_)) {
			const gchar* _tmp3_;
			const gchar* _tmp4_;
			gchar* _tmp5_;
			_tmp3_ = vala_ccode_attribute_get_lower_case_prefix (self);
			_tmp4_ = _tmp3_;
			_tmp5_ = g_strdup_printf ("%sref", _tmp4_);
			result = _tmp5_;
			return result;
		} else {
			ValaClass* _tmp6_;
			ValaClass* _tmp7_;
			ValaClass* _tmp8_;
			_tmp6_ = cl;
			_tmp7_ = vala_class_get_base_class (_tmp6_);
			_tmp8_ = _tmp7_;
			if (_tmp8_ != NULL) {
				ValaClass* _tmp9_;
				ValaClass* _tmp10_;
				ValaClass* _tmp11_;
				gchar* _tmp12_;
				_tmp9_ = cl;
				_tmp10_ = vala_class_get_base_class (_tmp9_);
				_tmp11_ = _tmp10_;
				_tmp12_ = vala_get_ccode_ref_function ((ValaTypeSymbol*) _tmp11_);
				result = _tmp12_;
				return result;
			}
		}
	} else {
		ValaSymbol* _tmp13_;
		_tmp13_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_INTERFACE)) {
			{
				ValaList* _prereq_list = NULL;
				ValaSymbol* _tmp14_;
				ValaList* _tmp15_;
				gint _prereq_size = 0;
				ValaList* _tmp16_;
				gint _tmp17_;
				gint _tmp18_;
				gint _prereq_index = 0;
				_tmp14_ = self->priv->sym;
				_tmp15_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_INTERFACE, ValaInterface));
				_prereq_list = _tmp15_;
				_tmp16_ = _prereq_list;
				_tmp17_ = vala_collection_get_size ((ValaCollection*) _tmp16_);
				_tmp18_ = _tmp17_;
				_prereq_size = _tmp18_;
				_prereq_index = -1;
				while (TRUE) {
					gint _tmp19_;
					gint _tmp20_;
					ValaDataType* prereq = NULL;
					ValaList* _tmp21_;
					gpointer _tmp22_;
					gchar* ref_func = NULL;
					ValaDataType* _tmp23_;
					ValaTypeSymbol* _tmp24_;
					ValaTypeSymbol* _tmp25_;
					gchar* _tmp26_;
					const gchar* _tmp27_;
					_prereq_index = _prereq_index + 1;
					_tmp19_ = _prereq_index;
					_tmp20_ = _prereq_size;
					if (!(_tmp19_ < _tmp20_)) {
						break;
					}
					_tmp21_ = _prereq_list;
					_tmp22_ = vala_list_get (_tmp21_, _prereq_index);
					prereq = (ValaDataType*) _tmp22_;
					_tmp23_ = prereq;
					_tmp24_ = vala_data_type_get_type_symbol (_tmp23_);
					_tmp25_ = _tmp24_;
					_tmp26_ = vala_get_ccode_ref_function ((ValaTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
					ref_func = _tmp26_;
					_tmp27_ = ref_func;
					if (_tmp27_ != NULL) {
						result = ref_func;
						_vala_code_node_unref0 (prereq);
						return result;
					}
					_g_free0 (ref_func);
					_vala_code_node_unref0 (prereq);
				}
			}
		}
	}
	result = NULL;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_unref_function (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
		ValaClass* cl = NULL;
		ValaSymbol* _tmp1_;
		ValaClass* _tmp2_;
		_tmp1_ = self->priv->sym;
		cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
		_tmp2_ = cl;
		if (vala_class_is_fundamental (_tmp2_)) {
			const gchar* _tmp3_;
			const gchar* _tmp4_;
			gchar* _tmp5_;
			_tmp3_ = vala_ccode_attribute_get_lower_case_prefix (self);
			_tmp4_ = _tmp3_;
			_tmp5_ = g_strdup_printf ("%sunref", _tmp4_);
			result = _tmp5_;
			return result;
		} else {
			ValaClass* _tmp6_;
			ValaClass* _tmp7_;
			ValaClass* _tmp8_;
			_tmp6_ = cl;
			_tmp7_ = vala_class_get_base_class (_tmp6_);
			_tmp8_ = _tmp7_;
			if (_tmp8_ != NULL) {
				ValaClass* _tmp9_;
				ValaClass* _tmp10_;
				ValaClass* _tmp11_;
				gchar* _tmp12_;
				_tmp9_ = cl;
				_tmp10_ = vala_class_get_base_class (_tmp9_);
				_tmp11_ = _tmp10_;
				_tmp12_ = vala_get_ccode_unref_function ((ValaObjectTypeSymbol*) _tmp11_);
				result = _tmp12_;
				return result;
			}
		}
	} else {
		ValaSymbol* _tmp13_;
		_tmp13_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_INTERFACE)) {
			{
				ValaList* _prereq_list = NULL;
				ValaSymbol* _tmp14_;
				ValaList* _tmp15_;
				gint _prereq_size = 0;
				ValaList* _tmp16_;
				gint _tmp17_;
				gint _tmp18_;
				gint _prereq_index = 0;
				_tmp14_ = self->priv->sym;
				_tmp15_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_INTERFACE, ValaInterface));
				_prereq_list = _tmp15_;
				_tmp16_ = _prereq_list;
				_tmp17_ = vala_collection_get_size ((ValaCollection*) _tmp16_);
				_tmp18_ = _tmp17_;
				_prereq_size = _tmp18_;
				_prereq_index = -1;
				while (TRUE) {
					gint _tmp19_;
					gint _tmp20_;
					ValaDataType* prereq = NULL;
					ValaList* _tmp21_;
					gpointer _tmp22_;
					gchar* unref_func = NULL;
					ValaDataType* _tmp23_;
					ValaTypeSymbol* _tmp24_;
					ValaTypeSymbol* _tmp25_;
					gchar* _tmp26_;
					const gchar* _tmp27_;
					_prereq_index = _prereq_index + 1;
					_tmp19_ = _prereq_index;
					_tmp20_ = _prereq_size;
					if (!(_tmp19_ < _tmp20_)) {
						break;
					}
					_tmp21_ = _prereq_list;
					_tmp22_ = vala_list_get (_tmp21_, _prereq_index);
					prereq = (ValaDataType*) _tmp22_;
					_tmp23_ = prereq;
					_tmp24_ = vala_data_type_get_type_symbol (_tmp23_);
					_tmp25_ = _tmp24_;
					_tmp26_ = vala_get_ccode_unref_function (G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
					unref_func = _tmp26_;
					_tmp27_ = unref_func;
					if (_tmp27_ != NULL) {
						result = unref_func;
						_vala_code_node_unref0 (prereq);
						return result;
					}
					_g_free0 (unref_func);
					_vala_code_node_unref0 (prereq);
				}
			}
		}
	}
	result = NULL;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_ref_sink_function (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* _tmp22_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
		ValaClass* base_class = NULL;
		ValaSymbol* _tmp1_;
		ValaClass* _tmp2_;
		ValaClass* _tmp3_;
		ValaClass* _tmp4_;
		_tmp1_ = self->priv->sym;
		_tmp2_ = vala_class_get_base_class (G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass));
		_tmp3_ = _tmp2_;
		base_class = _tmp3_;
		_tmp4_ = base_class;
		if (_tmp4_ != NULL) {
			ValaClass* _tmp5_;
			gchar* _tmp6_;
			_tmp5_ = base_class;
			_tmp6_ = vala_get_ccode_ref_sink_function ((ValaObjectTypeSymbol*) _tmp5_);
			result = _tmp6_;
			return result;
		}
	} else {
		ValaSymbol* _tmp7_;
		_tmp7_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_INTERFACE)) {
			{
				ValaList* _prereq_list = NULL;
				ValaSymbol* _tmp8_;
				ValaList* _tmp9_;
				gint _prereq_size = 0;
				ValaList* _tmp10_;
				gint _tmp11_;
				gint _tmp12_;
				gint _prereq_index = 0;
				_tmp8_ = self->priv->sym;
				_tmp9_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_INTERFACE, ValaInterface));
				_prereq_list = _tmp9_;
				_tmp10_ = _prereq_list;
				_tmp11_ = vala_collection_get_size ((ValaCollection*) _tmp10_);
				_tmp12_ = _tmp11_;
				_prereq_size = _tmp12_;
				_prereq_index = -1;
				while (TRUE) {
					gint _tmp13_;
					gint _tmp14_;
					ValaDataType* prereq = NULL;
					ValaList* _tmp15_;
					gpointer _tmp16_;
					gchar* ref_sink_func = NULL;
					ValaDataType* _tmp17_;
					ValaTypeSymbol* _tmp18_;
					ValaTypeSymbol* _tmp19_;
					gchar* _tmp20_;
					const gchar* _tmp21_;
					_prereq_index = _prereq_index + 1;
					_tmp13_ = _prereq_index;
					_tmp14_ = _prereq_size;
					if (!(_tmp13_ < _tmp14_)) {
						break;
					}
					_tmp15_ = _prereq_list;
					_tmp16_ = vala_list_get (_tmp15_, _prereq_index);
					prereq = (ValaDataType*) _tmp16_;
					_tmp17_ = prereq;
					_tmp18_ = vala_data_type_get_type_symbol (_tmp17_);
					_tmp19_ = _tmp18_;
					_tmp20_ = vala_get_ccode_ref_sink_function (G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
					ref_sink_func = _tmp20_;
					_tmp21_ = ref_sink_func;
					if (g_strcmp0 (_tmp21_, "") != 0) {
						result = ref_sink_func;
						_vala_code_node_unref0 (prereq);
						return result;
					}
					_g_free0 (ref_sink_func);
					_vala_code_node_unref0 (prereq);
				}
			}
		}
	}
	_tmp22_ = g_strdup ("");
	result = _tmp22_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_free_function (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
		ValaClass* cl = NULL;
		ValaSymbol* _tmp1_;
		ValaClass* _tmp2_;
		ValaClass* _tmp3_;
		ValaClass* _tmp4_;
		const gchar* _tmp9_;
		const gchar* _tmp10_;
		gchar* _tmp11_;
		_tmp1_ = self->priv->sym;
		cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
		_tmp2_ = cl;
		_tmp3_ = vala_class_get_base_class (_tmp2_);
		_tmp4_ = _tmp3_;
		if (_tmp4_ != NULL) {
			ValaClass* _tmp5_;
			ValaClass* _tmp6_;
			ValaClass* _tmp7_;
			gchar* _tmp8_;
			_tmp5_ = cl;
			_tmp6_ = vala_class_get_base_class (_tmp5_);
			_tmp7_ = _tmp6_;
			_tmp8_ = vala_get_ccode_free_function ((ValaTypeSymbol*) _tmp7_);
			result = _tmp8_;
			return result;
		}
		_tmp9_ = vala_ccode_attribute_get_lower_case_prefix (self);
		_tmp10_ = _tmp9_;
		_tmp11_ = g_strdup_printf ("%sfree", _tmp10_);
		result = _tmp11_;
		return result;
	} else {
		ValaSymbol* _tmp12_;
		_tmp12_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_STRUCT)) {
			gboolean _tmp13_ = FALSE;
			ValaSymbol* _tmp14_;
			gboolean _tmp15_;
			gboolean _tmp16_;
			_tmp14_ = self->priv->sym;
			_tmp15_ = vala_symbol_get_external_package (_tmp14_);
			_tmp16_ = _tmp15_;
			if (!_tmp16_) {
				ValaSymbol* _tmp17_;
				_tmp17_ = self->priv->sym;
				_tmp13_ = !vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_STRUCT, ValaStruct));
			} else {
				_tmp13_ = FALSE;
			}
			if (_tmp13_) {
				const gchar* _tmp18_;
				const gchar* _tmp19_;
				gchar* _tmp20_;
				_tmp18_ = vala_ccode_attribute_get_lower_case_prefix (self);
				_tmp19_ = _tmp18_;
				_tmp20_ = g_strdup_printf ("%sfree", _tmp19_);
				result = _tmp20_;
				return result;
			}
		}
	}
	result = NULL;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_type_id (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* _tmp76_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (_tmp0_ != NULL) {
		gboolean _tmp1_ = FALSE;
		gboolean _tmp2_ = FALSE;
		ValaSymbol* _tmp3_;
		_tmp3_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_CLASS)) {
			ValaSymbol* _tmp4_;
			gboolean _tmp5_;
			gboolean _tmp6_;
			_tmp4_ = self->priv->sym;
			_tmp5_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_CLASS, ValaClass));
			_tmp6_ = _tmp5_;
			_tmp2_ = !_tmp6_;
		} else {
			_tmp2_ = FALSE;
		}
		if (_tmp2_) {
			_tmp1_ = TRUE;
		} else {
			ValaSymbol* _tmp7_;
			_tmp7_ = self->priv->sym;
			_tmp1_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_INTERFACE);
		}
		if (_tmp1_) {
			ValaSymbol* _tmp8_;
			gchar* _tmp9_;
			_tmp8_ = self->priv->sym;
			_tmp9_ = vala_get_ccode_upper_case_name (_tmp8_, "TYPE_");
			result = _tmp9_;
			return result;
		} else {
			ValaSymbol* _tmp10_;
			_tmp10_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_STRUCT)) {
				ValaStruct* st = NULL;
				ValaSymbol* _tmp11_;
				ValaStruct* base_struct = NULL;
				ValaStruct* _tmp12_;
				ValaStruct* _tmp13_;
				ValaStruct* _tmp14_;
				gboolean _tmp15_ = FALSE;
				ValaStruct* _tmp16_;
				_tmp11_ = self->priv->sym;
				st = G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_STRUCT, ValaStruct);
				_tmp12_ = st;
				_tmp13_ = vala_struct_get_base_struct (_tmp12_);
				_tmp14_ = _tmp13_;
				base_struct = _tmp14_;
				_tmp16_ = st;
				if (!vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp16_)) {
					_tmp15_ = TRUE;
				} else {
					gboolean _tmp17_ = FALSE;
					ValaStruct* _tmp18_;
					_tmp18_ = base_struct;
					if (_tmp18_ != NULL) {
						ValaStruct* _tmp19_;
						_tmp19_ = base_struct;
						_tmp17_ = vala_struct_is_simple_type (_tmp19_);
					} else {
						_tmp17_ = FALSE;
					}
					_tmp15_ = _tmp17_;
				}
				if (_tmp15_) {
					ValaStruct* _tmp20_;
					ValaStruct* _tmp23_;
					_tmp20_ = base_struct;
					if (_tmp20_ != NULL) {
						ValaStruct* _tmp21_;
						gchar* _tmp22_;
						_tmp21_ = base_struct;
						_tmp22_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp21_);
						result = _tmp22_;
						return result;
					}
					_tmp23_ = st;
					if (!vala_struct_is_simple_type (_tmp23_)) {
						gchar* _tmp24_;
						_tmp24_ = g_strdup ("G_TYPE_POINTER");
						result = _tmp24_;
						return result;
					}
				} else {
					ValaStruct* _tmp25_;
					gchar* _tmp26_;
					_tmp25_ = st;
					_tmp26_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp25_, "TYPE_");
					result = _tmp26_;
					return result;
				}
			} else {
				ValaSymbol* _tmp27_;
				_tmp27_ = self->priv->sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp27_, VALA_TYPE_ENUM)) {
					ValaEnum* en = NULL;
					ValaSymbol* _tmp28_;
					ValaEnum* _tmp29_;
					_tmp28_ = self->priv->sym;
					en = G_TYPE_CHECK_INSTANCE_CAST (_tmp28_, VALA_TYPE_ENUM, ValaEnum);
					_tmp29_ = en;
					if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp29_)) {
						ValaEnum* _tmp30_;
						gchar* _tmp31_;
						_tmp30_ = en;
						_tmp31_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp30_, "TYPE_");
						result = _tmp31_;
						return result;
					} else {
						const gchar* _tmp32_ = NULL;
						ValaEnum* _tmp33_;
						gboolean _tmp34_;
						gboolean _tmp35_;
						gchar* _tmp36_;
						_tmp33_ = en;
						_tmp34_ = vala_enum_get_is_flags (_tmp33_);
						_tmp35_ = _tmp34_;
						if (_tmp35_) {
							_tmp32_ = "G_TYPE_UINT";
						} else {
							_tmp32_ = "G_TYPE_INT";
						}
						_tmp36_ = g_strdup (_tmp32_);
						result = _tmp36_;
						return result;
					}
				} else {
					ValaSymbol* _tmp37_;
					_tmp37_ = self->priv->sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp37_, VALA_TYPE_ERROR_DOMAIN)) {
						ValaErrorDomain* edomain = NULL;
						ValaSymbol* _tmp38_;
						ValaErrorDomain* _tmp39_;
						_tmp38_ = self->priv->sym;
						edomain = G_TYPE_CHECK_INSTANCE_CAST (_tmp38_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain);
						_tmp39_ = edomain;
						if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp39_)) {
							ValaErrorDomain* _tmp40_;
							gchar* _tmp41_;
							_tmp40_ = edomain;
							_tmp41_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp40_, "TYPE_");
							result = _tmp41_;
							return result;
						} else {
							gchar* _tmp42_;
							_tmp42_ = g_strdup ("G_TYPE_ERROR");
							result = _tmp42_;
							return result;
						}
					} else {
						gchar* _tmp43_;
						_tmp43_ = g_strdup ("G_TYPE_POINTER");
						result = _tmp43_;
						return result;
					}
				}
			}
		}
	} else {
		gboolean _tmp44_ = FALSE;
		ValaCodeNode* _tmp45_;
		_tmp45_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp45_, VALA_TYPE_ARRAY_TYPE)) {
			ValaCodeNode* _tmp46_;
			ValaDataType* _tmp47_;
			ValaDataType* _tmp48_;
			ValaTypeSymbol* _tmp49_;
			ValaTypeSymbol* _tmp50_;
			ValaCodeContext* _tmp51_;
			ValaCodeContext* _tmp52_;
			ValaSemanticAnalyzer* _tmp53_;
			ValaSemanticAnalyzer* _tmp54_;
			ValaDataType* _tmp55_;
			ValaTypeSymbol* _tmp56_;
			ValaTypeSymbol* _tmp57_;
			_tmp46_ = self->priv->node;
			_tmp47_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp46_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			_tmp48_ = _tmp47_;
			_tmp49_ = vala_data_type_get_type_symbol (_tmp48_);
			_tmp50_ = _tmp49_;
			_tmp51_ = vala_code_context_get ();
			_tmp52_ = _tmp51_;
			_tmp53_ = vala_code_context_get_analyzer (_tmp52_);
			_tmp54_ = _tmp53_;
			_tmp55_ = _tmp54_->string_type;
			_tmp56_ = vala_data_type_get_type_symbol (_tmp55_);
			_tmp57_ = _tmp56_;
			_tmp44_ = _tmp50_ == _tmp57_;
			_vala_code_context_unref0 (_tmp52_);
		} else {
			_tmp44_ = FALSE;
		}
		if (_tmp44_) {
			gchar* _tmp58_;
			_tmp58_ = g_strdup ("G_TYPE_STRV");
			result = _tmp58_;
			return result;
		} else {
			gboolean _tmp59_ = FALSE;
			ValaCodeNode* _tmp60_;
			_tmp60_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp60_, VALA_TYPE_POINTER_TYPE)) {
				_tmp59_ = TRUE;
			} else {
				ValaCodeNode* _tmp61_;
				_tmp61_ = self->priv->node;
				_tmp59_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp61_, VALA_TYPE_DELEGATE_TYPE);
			}
			if (_tmp59_) {
				gchar* _tmp62_;
				_tmp62_ = g_strdup ("G_TYPE_POINTER");
				result = _tmp62_;
				return result;
			} else {
				ValaCodeNode* _tmp63_;
				_tmp63_ = self->priv->node;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp63_, VALA_TYPE_ERROR_TYPE)) {
					gchar* _tmp64_;
					_tmp64_ = g_strdup ("G_TYPE_ERROR");
					result = _tmp64_;
					return result;
				} else {
					ValaCodeNode* _tmp65_;
					_tmp65_ = self->priv->node;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp65_, VALA_TYPE_VOID_TYPE)) {
						gchar* _tmp66_;
						_tmp66_ = g_strdup ("G_TYPE_NONE");
						result = _tmp66_;
						return result;
					} else {
						ValaDataType* type = NULL;
						ValaCodeNode* _tmp67_;
						ValaDataType* _tmp68_;
						ValaDataType* _tmp69_;
						ValaTypeSymbol* _tmp70_;
						ValaTypeSymbol* _tmp71_;
						_tmp67_ = self->priv->node;
						_tmp68_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp67_, VALA_TYPE_DATA_TYPE, ValaDataType));
						type = _tmp68_;
						_tmp69_ = type;
						_tmp70_ = vala_data_type_get_type_symbol (_tmp69_);
						_tmp71_ = _tmp70_;
						if (_tmp71_ != NULL) {
							ValaDataType* _tmp72_;
							ValaTypeSymbol* _tmp73_;
							ValaTypeSymbol* _tmp74_;
							gchar* _tmp75_;
							_tmp72_ = type;
							_tmp73_ = vala_data_type_get_type_symbol (_tmp72_);
							_tmp74_ = _tmp73_;
							_tmp75_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp74_);
							result = _tmp75_;
							_vala_code_node_unref0 (type);
							return result;
						}
						_vala_code_node_unref0 (type);
					}
				}
			}
		}
	}
	_tmp76_ = g_strdup ("");
	result = _tmp76_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_marshaller_type_name (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* _tmp151_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (_tmp0_ != NULL) {
		ValaSymbol* _tmp1_;
		_tmp1_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CLASS)) {
			ValaClass* cl = NULL;
			ValaSymbol* _tmp2_;
			ValaClass* _tmp3_;
			ValaClass* _tmp4_;
			ValaClass* _tmp5_;
			_tmp2_ = self->priv->sym;
			cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_CLASS, ValaClass);
			_tmp3_ = cl;
			_tmp4_ = vala_class_get_base_class (_tmp3_);
			_tmp5_ = _tmp4_;
			if (_tmp5_ != NULL) {
				ValaClass* _tmp6_;
				ValaClass* _tmp7_;
				ValaClass* _tmp8_;
				gchar* _tmp9_;
				_tmp6_ = cl;
				_tmp7_ = vala_class_get_base_class (_tmp6_);
				_tmp8_ = _tmp7_;
				_tmp9_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp8_);
				result = _tmp9_;
				return result;
			} else {
				ValaClass* _tmp10_;
				gboolean _tmp11_;
				gboolean _tmp12_;
				_tmp10_ = cl;
				_tmp11_ = vala_class_get_is_compact (_tmp10_);
				_tmp12_ = _tmp11_;
				if (!_tmp12_) {
					ValaClass* _tmp13_;
					gchar* _tmp14_;
					_tmp13_ = cl;
					_tmp14_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp13_, NULL);
					result = _tmp14_;
					return result;
				} else {
					const gchar* _tmp15_;
					const gchar* _tmp16_;
					_tmp15_ = vala_ccode_attribute_get_type_id (self);
					_tmp16_ = _tmp15_;
					if (g_strcmp0 (_tmp16_, "G_TYPE_POINTER") == 0) {
						gchar* _tmp17_;
						_tmp17_ = g_strdup ("POINTER");
						result = _tmp17_;
						return result;
					} else {
						gchar* _tmp18_;
						_tmp18_ = g_strdup ("BOXED");
						result = _tmp18_;
						return result;
					}
				}
			}
		} else {
			ValaSymbol* _tmp19_;
			_tmp19_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp19_, VALA_TYPE_ENUM)) {
				ValaEnum* en = NULL;
				ValaSymbol* _tmp20_;
				ValaEnum* _tmp21_;
				_tmp20_ = self->priv->sym;
				en = G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_ENUM, ValaEnum);
				_tmp21_ = en;
				if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp21_)) {
					ValaEnum* _tmp22_;
					gboolean _tmp23_;
					gboolean _tmp24_;
					_tmp22_ = en;
					_tmp23_ = vala_enum_get_is_flags (_tmp22_);
					_tmp24_ = _tmp23_;
					if (_tmp24_) {
						gchar* _tmp25_;
						_tmp25_ = g_strdup ("FLAGS");
						result = _tmp25_;
						return result;
					} else {
						gchar* _tmp26_;
						_tmp26_ = g_strdup ("ENUM");
						result = _tmp26_;
						return result;
					}
				} else {
					ValaEnum* _tmp27_;
					gboolean _tmp28_;
					gboolean _tmp29_;
					_tmp27_ = en;
					_tmp28_ = vala_enum_get_is_flags (_tmp27_);
					_tmp29_ = _tmp28_;
					if (_tmp29_) {
						gchar* _tmp30_;
						_tmp30_ = g_strdup ("UINT");
						result = _tmp30_;
						return result;
					} else {
						gchar* _tmp31_;
						_tmp31_ = g_strdup ("INT");
						result = _tmp31_;
						return result;
					}
				}
			} else {
				ValaSymbol* _tmp32_;
				_tmp32_ = self->priv->sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_INTERFACE)) {
					gchar* _tmp47_;
					{
						ValaList* _prereq_list = NULL;
						ValaSymbol* _tmp33_;
						ValaList* _tmp34_;
						gint _prereq_size = 0;
						ValaList* _tmp35_;
						gint _tmp36_;
						gint _tmp37_;
						gint _prereq_index = 0;
						_tmp33_ = self->priv->sym;
						_tmp34_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_INTERFACE, ValaInterface));
						_prereq_list = _tmp34_;
						_tmp35_ = _prereq_list;
						_tmp36_ = vala_collection_get_size ((ValaCollection*) _tmp35_);
						_tmp37_ = _tmp36_;
						_prereq_size = _tmp37_;
						_prereq_index = -1;
						while (TRUE) {
							gint _tmp38_;
							gint _tmp39_;
							ValaDataType* prereq = NULL;
							ValaList* _tmp40_;
							gpointer _tmp41_;
							gchar* type_name = NULL;
							ValaDataType* _tmp42_;
							ValaTypeSymbol* _tmp43_;
							ValaTypeSymbol* _tmp44_;
							gchar* _tmp45_;
							const gchar* _tmp46_;
							_prereq_index = _prereq_index + 1;
							_tmp38_ = _prereq_index;
							_tmp39_ = _prereq_size;
							if (!(_tmp38_ < _tmp39_)) {
								break;
							}
							_tmp40_ = _prereq_list;
							_tmp41_ = vala_list_get (_tmp40_, _prereq_index);
							prereq = (ValaDataType*) _tmp41_;
							_tmp42_ = prereq;
							_tmp43_ = vala_data_type_get_type_symbol (_tmp42_);
							_tmp44_ = _tmp43_;
							_tmp45_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp44_);
							type_name = _tmp45_;
							_tmp46_ = type_name;
							if (g_strcmp0 (_tmp46_, "") != 0) {
								result = type_name;
								_vala_code_node_unref0 (prereq);
								return result;
							}
							_g_free0 (type_name);
							_vala_code_node_unref0 (prereq);
						}
					}
					_tmp47_ = g_strdup ("POINTER");
					result = _tmp47_;
					return result;
				} else {
					ValaSymbol* _tmp48_;
					_tmp48_ = self->priv->sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp48_, VALA_TYPE_STRUCT)) {
						ValaStruct* st = NULL;
						ValaSymbol* _tmp49_;
						ValaStruct* base_st = NULL;
						ValaStruct* _tmp50_;
						ValaStruct* _tmp51_;
						ValaStruct* _tmp52_;
						ValaStruct* _tmp60_;
						_tmp49_ = self->priv->sym;
						st = G_TYPE_CHECK_INSTANCE_CAST (_tmp49_, VALA_TYPE_STRUCT, ValaStruct);
						_tmp50_ = st;
						_tmp51_ = vala_struct_get_base_struct (_tmp50_);
						_tmp52_ = _tmp51_;
						base_st = _tmp52_;
						while (TRUE) {
							ValaStruct* _tmp53_;
							ValaStruct* _tmp54_;
							_tmp53_ = base_st;
							if (!(_tmp53_ != NULL)) {
								break;
							}
							_tmp54_ = base_st;
							if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp54_)) {
								ValaStruct* _tmp55_;
								gchar* _tmp56_;
								_tmp55_ = base_st;
								_tmp56_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp55_);
								result = _tmp56_;
								return result;
							} else {
								ValaStruct* _tmp57_;
								ValaStruct* _tmp58_;
								ValaStruct* _tmp59_;
								_tmp57_ = base_st;
								_tmp58_ = vala_struct_get_base_struct (_tmp57_);
								_tmp59_ = _tmp58_;
								base_st = _tmp59_;
							}
						}
						_tmp60_ = st;
						if (vala_struct_is_simple_type (_tmp60_)) {
							ValaStruct* _tmp61_;
							ValaSourceReference* _tmp62_;
							ValaSourceReference* _tmp63_;
							ValaStruct* _tmp64_;
							gchar* _tmp65_;
							gchar* _tmp66_;
							_tmp61_ = st;
							_tmp62_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp61_);
							_tmp63_ = _tmp62_;
							_tmp64_ = st;
							_tmp65_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp64_);
							_tmp66_ = _tmp65_;
							vala_report_error (_tmp63_, "The type `%s' doesn't declare a marshaller type name", _tmp66_);
							_g_free0 (_tmp66_);
						} else {
							ValaStruct* _tmp67_;
							_tmp67_ = st;
							if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp67_)) {
								gchar* _tmp68_;
								_tmp68_ = g_strdup ("BOXED");
								result = _tmp68_;
								return result;
							} else {
								gchar* _tmp69_;
								_tmp69_ = g_strdup ("POINTER");
								result = _tmp69_;
								return result;
							}
						}
					} else {
						ValaSymbol* _tmp70_;
						_tmp70_ = self->priv->sym;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp70_, VALA_TYPE_PARAMETER)) {
							ValaParameter* param = NULL;
							ValaSymbol* _tmp71_;
							ValaParameter* _tmp72_;
							ValaParameterDirection _tmp73_;
							ValaParameterDirection _tmp74_;
							_tmp71_ = self->priv->sym;
							param = G_TYPE_CHECK_INSTANCE_CAST (_tmp71_, VALA_TYPE_PARAMETER, ValaParameter);
							_tmp72_ = param;
							_tmp73_ = vala_parameter_get_direction (_tmp72_);
							_tmp74_ = _tmp73_;
							if (_tmp74_ != VALA_PARAMETER_DIRECTION_IN) {
								gchar* _tmp75_;
								_tmp75_ = g_strdup ("POINTER");
								result = _tmp75_;
								return result;
							} else {
								ValaParameter* _tmp76_;
								ValaDataType* _tmp77_;
								ValaDataType* _tmp78_;
								gchar* _tmp79_;
								_tmp76_ = param;
								_tmp77_ = vala_variable_get_variable_type ((ValaVariable*) _tmp76_);
								_tmp78_ = _tmp77_;
								_tmp79_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp78_);
								result = _tmp79_;
								return result;
							}
						} else {
							gchar* _tmp80_;
							_tmp80_ = g_strdup ("POINTER");
							result = _tmp80_;
							return result;
						}
					}
				}
			}
		}
	} else {
		gboolean _tmp81_ = FALSE;
		ValaCodeNode* _tmp82_;
		_tmp82_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp82_, VALA_TYPE_VALUE_TYPE)) {
			ValaCodeNode* _tmp83_;
			gboolean _tmp84_;
			gboolean _tmp85_;
			_tmp83_ = self->priv->node;
			_tmp84_ = vala_data_type_get_nullable ((ValaDataType*) G_TYPE_CHECK_INSTANCE_CAST (_tmp83_, VALA_TYPE_VALUE_TYPE, ValaValueType));
			_tmp85_ = _tmp84_;
			_tmp81_ = _tmp85_;
		} else {
			_tmp81_ = FALSE;
		}
		if (_tmp81_) {
			gchar* _tmp86_;
			_tmp86_ = g_strdup ("POINTER");
			result = _tmp86_;
			return result;
		} else {
			gboolean _tmp87_ = FALSE;
			ValaCodeNode* _tmp88_;
			_tmp88_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp88_, VALA_TYPE_POINTER_TYPE)) {
				_tmp87_ = TRUE;
			} else {
				ValaCodeNode* _tmp89_;
				_tmp89_ = self->priv->node;
				_tmp87_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp89_, VALA_TYPE_GENERIC_TYPE);
			}
			if (_tmp87_) {
				gchar* _tmp90_;
				_tmp90_ = g_strdup ("POINTER");
				result = _tmp90_;
				return result;
			} else {
				ValaCodeNode* _tmp91_;
				_tmp91_ = self->priv->node;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp91_, VALA_TYPE_ERROR_TYPE)) {
					gchar* _tmp92_;
					_tmp92_ = g_strdup ("BOXED");
					result = _tmp92_;
					return result;
				} else {
					ValaCodeNode* _tmp93_;
					_tmp93_ = self->priv->node;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp93_, VALA_TYPE_ARRAY_TYPE)) {
						ValaArrayType* array_type = NULL;
						ValaCodeNode* _tmp94_;
						ValaArrayType* _tmp95_;
						ValaDataType* _tmp96_;
						ValaDataType* _tmp97_;
						ValaTypeSymbol* _tmp98_;
						ValaTypeSymbol* _tmp99_;
						ValaCodeContext* _tmp100_;
						ValaCodeContext* _tmp101_;
						ValaSemanticAnalyzer* _tmp102_;
						ValaSemanticAnalyzer* _tmp103_;
						ValaDataType* _tmp104_;
						ValaTypeSymbol* _tmp105_;
						ValaTypeSymbol* _tmp106_;
						gboolean _tmp107_;
						_tmp94_ = self->priv->node;
						array_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp94_, VALA_TYPE_ARRAY_TYPE, ValaArrayType);
						_tmp95_ = array_type;
						_tmp96_ = vala_array_type_get_element_type (_tmp95_);
						_tmp97_ = _tmp96_;
						_tmp98_ = vala_data_type_get_type_symbol (_tmp97_);
						_tmp99_ = _tmp98_;
						_tmp100_ = vala_code_context_get ();
						_tmp101_ = _tmp100_;
						_tmp102_ = vala_code_context_get_analyzer (_tmp101_);
						_tmp103_ = _tmp102_;
						_tmp104_ = _tmp103_->string_type;
						_tmp105_ = vala_data_type_get_type_symbol (_tmp104_);
						_tmp106_ = _tmp105_;
						_tmp107_ = _tmp99_ == _tmp106_;
						_vala_code_context_unref0 (_tmp101_);
						if (_tmp107_) {
							ValaArrayType* _tmp108_;
							ValaDataType* _tmp109_;
							ValaDataType* _tmp110_;
							ValaTypeSymbol* _tmp111_;
							ValaTypeSymbol* _tmp112_;
							gchar* _tmp113_;
							gchar* _tmp114_;
							gchar* _tmp115_;
							gchar* _tmp116_;
							_tmp108_ = array_type;
							_tmp109_ = vala_array_type_get_length_type (_tmp108_);
							_tmp110_ = _tmp109_;
							_tmp111_ = vala_data_type_get_type_symbol (_tmp110_);
							_tmp112_ = _tmp111_;
							_tmp113_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp112_);
							_tmp114_ = _tmp113_;
							_tmp115_ = g_strdup_printf ("BOXED,%s", _tmp114_);
							_tmp116_ = _tmp115_;
							_g_free0 (_tmp114_);
							result = _tmp116_;
							return result;
						} else {
							gchar* ret = NULL;
							gchar* _tmp117_;
							gchar* length_marshaller_type_name = NULL;
							ValaArrayType* _tmp118_;
							ValaDataType* _tmp119_;
							ValaDataType* _tmp120_;
							ValaTypeSymbol* _tmp121_;
							ValaTypeSymbol* _tmp122_;
							gchar* _tmp123_;
							_tmp117_ = g_strdup ("POINTER");
							ret = _tmp117_;
							_tmp118_ = array_type;
							_tmp119_ = vala_array_type_get_length_type (_tmp118_);
							_tmp120_ = _tmp119_;
							_tmp121_ = vala_data_type_get_type_symbol (_tmp120_);
							_tmp122_ = _tmp121_;
							_tmp123_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp122_);
							length_marshaller_type_name = _tmp123_;
							{
								gint i = 0;
								i = 0;
								{
									gboolean _tmp124_ = FALSE;
									_tmp124_ = TRUE;
									while (TRUE) {
										ValaArrayType* _tmp126_;
										gint _tmp127_;
										gint _tmp128_;
										const gchar* _tmp129_;
										const gchar* _tmp130_;
										gchar* _tmp131_;
										if (!_tmp124_) {
											gint _tmp125_;
											_tmp125_ = i;
											i = _tmp125_ + 1;
										}
										_tmp124_ = FALSE;
										_tmp126_ = array_type;
										_tmp127_ = vala_array_type_get_rank (_tmp126_);
										_tmp128_ = _tmp127_;
										if (!(i < _tmp128_)) {
											break;
										}
										_tmp129_ = ret;
										_tmp130_ = length_marshaller_type_name;
										_tmp131_ = g_strdup_printf ("%s,%s", _tmp129_, _tmp130_);
										_g_free0 (ret);
										ret = _tmp131_;
									}
								}
							}
							result = ret;
							_g_free0 (length_marshaller_type_name);
							return result;
						}
					} else {
						ValaCodeNode* _tmp132_;
						_tmp132_ = self->priv->node;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp132_, VALA_TYPE_DELEGATE_TYPE)) {
							ValaDelegateType* delegate_type = NULL;
							ValaCodeNode* _tmp133_;
							gchar* ret = NULL;
							gchar* _tmp134_;
							ValaDelegateType* _tmp135_;
							ValaDelegate* _tmp136_;
							ValaDelegate* _tmp137_;
							gboolean _tmp138_;
							gboolean _tmp139_;
							_tmp133_ = self->priv->node;
							delegate_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp133_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType);
							_tmp134_ = g_strdup ("POINTER");
							ret = _tmp134_;
							_tmp135_ = delegate_type;
							_tmp136_ = vala_delegate_type_get_delegate_symbol (_tmp135_);
							_tmp137_ = _tmp136_;
							_tmp138_ = vala_delegate_get_has_target (_tmp137_);
							_tmp139_ = _tmp138_;
							if (_tmp139_) {
								const gchar* _tmp140_;
								gchar* _tmp141_;
								ValaDelegateType* _tmp142_;
								_tmp140_ = ret;
								_tmp141_ = g_strdup_printf ("%s,POINTER", _tmp140_);
								_g_free0 (ret);
								ret = _tmp141_;
								_tmp142_ = delegate_type;
								if (vala_data_type_is_disposable ((ValaDataType*) _tmp142_)) {
									const gchar* _tmp143_;
									gchar* _tmp144_;
									_tmp143_ = ret;
									_tmp144_ = g_strdup_printf ("%s,POINTER", _tmp143_);
									_g_free0 (ret);
									ret = _tmp144_;
								}
							}
							result = ret;
							return result;
						} else {
							ValaCodeNode* _tmp145_;
							_tmp145_ = self->priv->node;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp145_, VALA_TYPE_VOID_TYPE)) {
								gchar* _tmp146_;
								_tmp146_ = g_strdup ("VOID");
								result = _tmp146_;
								return result;
							} else {
								ValaCodeNode* _tmp147_;
								ValaTypeSymbol* _tmp148_;
								ValaTypeSymbol* _tmp149_;
								gchar* _tmp150_;
								_tmp147_ = self->priv->node;
								_tmp148_ = vala_data_type_get_type_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp147_, VALA_TYPE_DATA_TYPE, ValaDataType));
								_tmp149_ = _tmp148_;
								_tmp150_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp149_);
								result = _tmp150_;
								return result;
							}
						}
					}
				}
			}
		}
	}
	_tmp151_ = g_strdup ("");
	result = _tmp151_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_get_value_function (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* _tmp70_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
		ValaClass* cl = NULL;
		ValaSymbol* _tmp1_;
		ValaClass* _tmp2_;
		_tmp1_ = self->priv->sym;
		cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
		_tmp2_ = cl;
		if (vala_class_is_fundamental (_tmp2_)) {
			ValaClass* _tmp3_;
			gchar* _tmp4_;
			_tmp3_ = cl;
			_tmp4_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp3_, "value_get_");
			result = _tmp4_;
			return result;
		} else {
			ValaClass* _tmp5_;
			ValaClass* _tmp6_;
			ValaClass* _tmp7_;
			_tmp5_ = cl;
			_tmp6_ = vala_class_get_base_class (_tmp5_);
			_tmp7_ = _tmp6_;
			if (_tmp7_ != NULL) {
				ValaClass* _tmp8_;
				ValaClass* _tmp9_;
				ValaClass* _tmp10_;
				gchar* _tmp11_;
				_tmp8_ = cl;
				_tmp9_ = vala_class_get_base_class (_tmp8_);
				_tmp10_ = _tmp9_;
				_tmp11_ = vala_get_ccode_get_value_function ((ValaCodeNode*) _tmp10_);
				result = _tmp11_;
				return result;
			} else {
				const gchar* _tmp12_;
				const gchar* _tmp13_;
				_tmp12_ = vala_ccode_attribute_get_type_id (self);
				_tmp13_ = _tmp12_;
				if (g_strcmp0 (_tmp13_, "G_TYPE_POINTER") == 0) {
					gchar* _tmp14_;
					_tmp14_ = g_strdup ("g_value_get_pointer");
					result = _tmp14_;
					return result;
				} else {
					gchar* _tmp15_;
					_tmp15_ = g_strdup ("g_value_get_boxed");
					result = _tmp15_;
					return result;
				}
			}
		}
	} else {
		ValaSymbol* _tmp16_;
		_tmp16_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_ENUM)) {
			ValaEnum* en = NULL;
			ValaSymbol* _tmp17_;
			ValaEnum* _tmp18_;
			_tmp17_ = self->priv->sym;
			en = G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_ENUM, ValaEnum);
			_tmp18_ = en;
			if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp18_)) {
				ValaEnum* _tmp19_;
				gboolean _tmp20_;
				gboolean _tmp21_;
				_tmp19_ = en;
				_tmp20_ = vala_enum_get_is_flags (_tmp19_);
				_tmp21_ = _tmp20_;
				if (_tmp21_) {
					gchar* _tmp22_;
					_tmp22_ = g_strdup ("g_value_get_flags");
					result = _tmp22_;
					return result;
				} else {
					gchar* _tmp23_;
					_tmp23_ = g_strdup ("g_value_get_enum");
					result = _tmp23_;
					return result;
				}
			} else {
				ValaEnum* _tmp24_;
				gboolean _tmp25_;
				gboolean _tmp26_;
				_tmp24_ = en;
				_tmp25_ = vala_enum_get_is_flags (_tmp24_);
				_tmp26_ = _tmp25_;
				if (_tmp26_) {
					gchar* _tmp27_;
					_tmp27_ = g_strdup ("g_value_get_uint");
					result = _tmp27_;
					return result;
				} else {
					gchar* _tmp28_;
					_tmp28_ = g_strdup ("g_value_get_int");
					result = _tmp28_;
					return result;
				}
			}
		} else {
			ValaSymbol* _tmp29_;
			_tmp29_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_ERROR_DOMAIN)) {
				gchar* _tmp30_;
				_tmp30_ = g_strdup ("g_value_get_boxed");
				result = _tmp30_;
				return result;
			} else {
				ValaSymbol* _tmp31_;
				_tmp31_ = self->priv->sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp31_, VALA_TYPE_INTERFACE)) {
					gchar* _tmp46_;
					{
						ValaList* _prereq_list = NULL;
						ValaSymbol* _tmp32_;
						ValaList* _tmp33_;
						gint _prereq_size = 0;
						ValaList* _tmp34_;
						gint _tmp35_;
						gint _tmp36_;
						gint _prereq_index = 0;
						_tmp32_ = self->priv->sym;
						_tmp33_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp32_, VALA_TYPE_INTERFACE, ValaInterface));
						_prereq_list = _tmp33_;
						_tmp34_ = _prereq_list;
						_tmp35_ = vala_collection_get_size ((ValaCollection*) _tmp34_);
						_tmp36_ = _tmp35_;
						_prereq_size = _tmp36_;
						_prereq_index = -1;
						while (TRUE) {
							gint _tmp37_;
							gint _tmp38_;
							ValaDataType* prereq = NULL;
							ValaList* _tmp39_;
							gpointer _tmp40_;
							gchar* type_name = NULL;
							ValaDataType* _tmp41_;
							ValaTypeSymbol* _tmp42_;
							ValaTypeSymbol* _tmp43_;
							gchar* _tmp44_;
							const gchar* _tmp45_;
							_prereq_index = _prereq_index + 1;
							_tmp37_ = _prereq_index;
							_tmp38_ = _prereq_size;
							if (!(_tmp37_ < _tmp38_)) {
								break;
							}
							_tmp39_ = _prereq_list;
							_tmp40_ = vala_list_get (_tmp39_, _prereq_index);
							prereq = (ValaDataType*) _tmp40_;
							_tmp41_ = prereq;
							_tmp42_ = vala_data_type_get_type_symbol (_tmp41_);
							_tmp43_ = _tmp42_;
							_tmp44_ = vala_get_ccode_get_value_function ((ValaCodeNode*) _tmp43_);
							type_name = _tmp44_;
							_tmp45_ = type_name;
							if (g_strcmp0 (_tmp45_, "") != 0) {
								result = type_name;
								_vala_code_node_unref0 (prereq);
								return result;
							}
							_g_free0 (type_name);
							_vala_code_node_unref0 (prereq);
						}
					}
					_tmp46_ = g_strdup ("g_value_get_pointer");
					result = _tmp46_;
					return result;
				} else {
					ValaSymbol* _tmp47_;
					_tmp47_ = self->priv->sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp47_, VALA_TYPE_STRUCT)) {
						ValaStruct* st = NULL;
						ValaSymbol* _tmp48_;
						ValaStruct* base_st = NULL;
						ValaStruct* _tmp49_;
						ValaStruct* _tmp50_;
						ValaStruct* _tmp51_;
						ValaStruct* _tmp59_;
						_tmp48_ = self->priv->sym;
						st = G_TYPE_CHECK_INSTANCE_CAST (_tmp48_, VALA_TYPE_STRUCT, ValaStruct);
						_tmp49_ = st;
						_tmp50_ = vala_struct_get_base_struct (_tmp49_);
						_tmp51_ = _tmp50_;
						base_st = _tmp51_;
						while (TRUE) {
							ValaStruct* _tmp52_;
							ValaStruct* _tmp53_;
							_tmp52_ = base_st;
							if (!(_tmp52_ != NULL)) {
								break;
							}
							_tmp53_ = base_st;
							if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp53_)) {
								ValaStruct* _tmp54_;
								gchar* _tmp55_;
								_tmp54_ = base_st;
								_tmp55_ = vala_get_ccode_get_value_function ((ValaCodeNode*) _tmp54_);
								result = _tmp55_;
								return result;
							} else {
								ValaStruct* _tmp56_;
								ValaStruct* _tmp57_;
								ValaStruct* _tmp58_;
								_tmp56_ = base_st;
								_tmp57_ = vala_struct_get_base_struct (_tmp56_);
								_tmp58_ = _tmp57_;
								base_st = _tmp58_;
							}
						}
						_tmp59_ = st;
						if (vala_struct_is_simple_type (_tmp59_)) {
							ValaStruct* _tmp60_;
							ValaSourceReference* _tmp61_;
							ValaSourceReference* _tmp62_;
							ValaStruct* _tmp63_;
							gchar* _tmp64_;
							gchar* _tmp65_;
							_tmp60_ = st;
							_tmp61_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp60_);
							_tmp62_ = _tmp61_;
							_tmp63_ = st;
							_tmp64_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp63_);
							_tmp65_ = _tmp64_;
							vala_report_error (_tmp62_, "The type `%s' doesn't declare a GValue get function", _tmp65_);
							_g_free0 (_tmp65_);
						} else {
							ValaStruct* _tmp66_;
							_tmp66_ = st;
							if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp66_)) {
								gchar* _tmp67_;
								_tmp67_ = g_strdup ("g_value_get_boxed");
								result = _tmp67_;
								return result;
							} else {
								gchar* _tmp68_;
								_tmp68_ = g_strdup ("g_value_get_pointer");
								result = _tmp68_;
								return result;
							}
						}
					} else {
						gchar* _tmp69_;
						_tmp69_ = g_strdup ("g_value_get_pointer");
						result = _tmp69_;
						return result;
					}
				}
			}
		}
	}
	_tmp70_ = g_strdup ("");
	result = _tmp70_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_set_value_function (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* _tmp70_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
		ValaClass* cl = NULL;
		ValaSymbol* _tmp1_;
		ValaClass* _tmp2_;
		_tmp1_ = self->priv->sym;
		cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
		_tmp2_ = cl;
		if (vala_class_is_fundamental (_tmp2_)) {
			ValaClass* _tmp3_;
			gchar* _tmp4_;
			_tmp3_ = cl;
			_tmp4_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp3_, "value_set_");
			result = _tmp4_;
			return result;
		} else {
			ValaClass* _tmp5_;
			ValaClass* _tmp6_;
			ValaClass* _tmp7_;
			_tmp5_ = cl;
			_tmp6_ = vala_class_get_base_class (_tmp5_);
			_tmp7_ = _tmp6_;
			if (_tmp7_ != NULL) {
				ValaClass* _tmp8_;
				ValaClass* _tmp9_;
				ValaClass* _tmp10_;
				gchar* _tmp11_;
				_tmp8_ = cl;
				_tmp9_ = vala_class_get_base_class (_tmp8_);
				_tmp10_ = _tmp9_;
				_tmp11_ = vala_get_ccode_set_value_function ((ValaCodeNode*) _tmp10_);
				result = _tmp11_;
				return result;
			} else {
				const gchar* _tmp12_;
				const gchar* _tmp13_;
				_tmp12_ = vala_ccode_attribute_get_type_id (self);
				_tmp13_ = _tmp12_;
				if (g_strcmp0 (_tmp13_, "G_TYPE_POINTER") == 0) {
					gchar* _tmp14_;
					_tmp14_ = g_strdup ("g_value_set_pointer");
					result = _tmp14_;
					return result;
				} else {
					gchar* _tmp15_;
					_tmp15_ = g_strdup ("g_value_set_boxed");
					result = _tmp15_;
					return result;
				}
			}
		}
	} else {
		ValaSymbol* _tmp16_;
		_tmp16_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_ENUM)) {
			ValaEnum* en = NULL;
			ValaSymbol* _tmp17_;
			ValaEnum* _tmp18_;
			_tmp17_ = self->priv->sym;
			en = G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_ENUM, ValaEnum);
			_tmp18_ = en;
			if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp18_)) {
				ValaEnum* _tmp19_;
				gboolean _tmp20_;
				gboolean _tmp21_;
				_tmp19_ = en;
				_tmp20_ = vala_enum_get_is_flags (_tmp19_);
				_tmp21_ = _tmp20_;
				if (_tmp21_) {
					gchar* _tmp22_;
					_tmp22_ = g_strdup ("g_value_set_flags");
					result = _tmp22_;
					return result;
				} else {
					gchar* _tmp23_;
					_tmp23_ = g_strdup ("g_value_set_enum");
					result = _tmp23_;
					return result;
				}
			} else {
				ValaEnum* _tmp24_;
				gboolean _tmp25_;
				gboolean _tmp26_;
				_tmp24_ = en;
				_tmp25_ = vala_enum_get_is_flags (_tmp24_);
				_tmp26_ = _tmp25_;
				if (_tmp26_) {
					gchar* _tmp27_;
					_tmp27_ = g_strdup ("g_value_set_uint");
					result = _tmp27_;
					return result;
				} else {
					gchar* _tmp28_;
					_tmp28_ = g_strdup ("g_value_set_int");
					result = _tmp28_;
					return result;
				}
			}
		} else {
			ValaSymbol* _tmp29_;
			_tmp29_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_ERROR_DOMAIN)) {
				gchar* _tmp30_;
				_tmp30_ = g_strdup ("g_value_set_boxed");
				result = _tmp30_;
				return result;
			} else {
				ValaSymbol* _tmp31_;
				_tmp31_ = self->priv->sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp31_, VALA_TYPE_INTERFACE)) {
					gchar* _tmp46_;
					{
						ValaList* _prereq_list = NULL;
						ValaSymbol* _tmp32_;
						ValaList* _tmp33_;
						gint _prereq_size = 0;
						ValaList* _tmp34_;
						gint _tmp35_;
						gint _tmp36_;
						gint _prereq_index = 0;
						_tmp32_ = self->priv->sym;
						_tmp33_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp32_, VALA_TYPE_INTERFACE, ValaInterface));
						_prereq_list = _tmp33_;
						_tmp34_ = _prereq_list;
						_tmp35_ = vala_collection_get_size ((ValaCollection*) _tmp34_);
						_tmp36_ = _tmp35_;
						_prereq_size = _tmp36_;
						_prereq_index = -1;
						while (TRUE) {
							gint _tmp37_;
							gint _tmp38_;
							ValaDataType* prereq = NULL;
							ValaList* _tmp39_;
							gpointer _tmp40_;
							gchar* type_name = NULL;
							ValaDataType* _tmp41_;
							ValaTypeSymbol* _tmp42_;
							ValaTypeSymbol* _tmp43_;
							gchar* _tmp44_;
							const gchar* _tmp45_;
							_prereq_index = _prereq_index + 1;
							_tmp37_ = _prereq_index;
							_tmp38_ = _prereq_size;
							if (!(_tmp37_ < _tmp38_)) {
								break;
							}
							_tmp39_ = _prereq_list;
							_tmp40_ = vala_list_get (_tmp39_, _prereq_index);
							prereq = (ValaDataType*) _tmp40_;
							_tmp41_ = prereq;
							_tmp42_ = vala_data_type_get_type_symbol (_tmp41_);
							_tmp43_ = _tmp42_;
							_tmp44_ = vala_get_ccode_set_value_function ((ValaCodeNode*) _tmp43_);
							type_name = _tmp44_;
							_tmp45_ = type_name;
							if (g_strcmp0 (_tmp45_, "") != 0) {
								result = type_name;
								_vala_code_node_unref0 (prereq);
								return result;
							}
							_g_free0 (type_name);
							_vala_code_node_unref0 (prereq);
						}
					}
					_tmp46_ = g_strdup ("g_value_set_pointer");
					result = _tmp46_;
					return result;
				} else {
					ValaSymbol* _tmp47_;
					_tmp47_ = self->priv->sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp47_, VALA_TYPE_STRUCT)) {
						ValaStruct* st = NULL;
						ValaSymbol* _tmp48_;
						ValaStruct* base_st = NULL;
						ValaStruct* _tmp49_;
						ValaStruct* _tmp50_;
						ValaStruct* _tmp51_;
						ValaStruct* _tmp59_;
						_tmp48_ = self->priv->sym;
						st = G_TYPE_CHECK_INSTANCE_CAST (_tmp48_, VALA_TYPE_STRUCT, ValaStruct);
						_tmp49_ = st;
						_tmp50_ = vala_struct_get_base_struct (_tmp49_);
						_tmp51_ = _tmp50_;
						base_st = _tmp51_;
						while (TRUE) {
							ValaStruct* _tmp52_;
							ValaStruct* _tmp53_;
							_tmp52_ = base_st;
							if (!(_tmp52_ != NULL)) {
								break;
							}
							_tmp53_ = base_st;
							if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp53_)) {
								ValaStruct* _tmp54_;
								gchar* _tmp55_;
								_tmp54_ = base_st;
								_tmp55_ = vala_get_ccode_set_value_function ((ValaCodeNode*) _tmp54_);
								result = _tmp55_;
								return result;
							} else {
								ValaStruct* _tmp56_;
								ValaStruct* _tmp57_;
								ValaStruct* _tmp58_;
								_tmp56_ = base_st;
								_tmp57_ = vala_struct_get_base_struct (_tmp56_);
								_tmp58_ = _tmp57_;
								base_st = _tmp58_;
							}
						}
						_tmp59_ = st;
						if (vala_struct_is_simple_type (_tmp59_)) {
							ValaStruct* _tmp60_;
							ValaSourceReference* _tmp61_;
							ValaSourceReference* _tmp62_;
							ValaStruct* _tmp63_;
							gchar* _tmp64_;
							gchar* _tmp65_;
							_tmp60_ = st;
							_tmp61_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp60_);
							_tmp62_ = _tmp61_;
							_tmp63_ = st;
							_tmp64_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp63_);
							_tmp65_ = _tmp64_;
							vala_report_error (_tmp62_, "The type `%s' doesn't declare a GValue set function", _tmp65_);
							_g_free0 (_tmp65_);
						} else {
							ValaStruct* _tmp66_;
							_tmp66_ = st;
							if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp66_)) {
								gchar* _tmp67_;
								_tmp67_ = g_strdup ("g_value_set_boxed");
								result = _tmp67_;
								return result;
							} else {
								gchar* _tmp68_;
								_tmp68_ = g_strdup ("g_value_set_pointer");
								result = _tmp68_;
								return result;
							}
						}
					} else {
						gchar* _tmp69_;
						_tmp69_ = g_strdup ("g_value_set_pointer");
						result = _tmp69_;
						return result;
					}
				}
			}
		}
	}
	_tmp70_ = g_strdup ("");
	result = _tmp70_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_take_value_function (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* _tmp70_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
		ValaClass* cl = NULL;
		ValaSymbol* _tmp1_;
		ValaClass* _tmp2_;
		_tmp1_ = self->priv->sym;
		cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
		_tmp2_ = cl;
		if (vala_class_is_fundamental (_tmp2_)) {
			ValaClass* _tmp3_;
			gchar* _tmp4_;
			_tmp3_ = cl;
			_tmp4_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp3_, "value_take_");
			result = _tmp4_;
			return result;
		} else {
			ValaClass* _tmp5_;
			ValaClass* _tmp6_;
			ValaClass* _tmp7_;
			_tmp5_ = cl;
			_tmp6_ = vala_class_get_base_class (_tmp5_);
			_tmp7_ = _tmp6_;
			if (_tmp7_ != NULL) {
				ValaClass* _tmp8_;
				ValaClass* _tmp9_;
				ValaClass* _tmp10_;
				gchar* _tmp11_;
				_tmp8_ = cl;
				_tmp9_ = vala_class_get_base_class (_tmp8_);
				_tmp10_ = _tmp9_;
				_tmp11_ = vala_get_ccode_take_value_function ((ValaCodeNode*) _tmp10_);
				result = _tmp11_;
				return result;
			} else {
				const gchar* _tmp12_;
				const gchar* _tmp13_;
				_tmp12_ = vala_ccode_attribute_get_type_id (self);
				_tmp13_ = _tmp12_;
				if (g_strcmp0 (_tmp13_, "G_TYPE_POINTER") == 0) {
					gchar* _tmp14_;
					_tmp14_ = g_strdup ("g_value_set_pointer");
					result = _tmp14_;
					return result;
				} else {
					gchar* _tmp15_;
					_tmp15_ = g_strdup ("g_value_take_boxed");
					result = _tmp15_;
					return result;
				}
			}
		}
	} else {
		ValaSymbol* _tmp16_;
		_tmp16_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_ENUM)) {
			ValaEnum* en = NULL;
			ValaSymbol* _tmp17_;
			ValaEnum* _tmp18_;
			_tmp17_ = self->priv->sym;
			en = G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_ENUM, ValaEnum);
			_tmp18_ = en;
			if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp18_)) {
				ValaEnum* _tmp19_;
				gboolean _tmp20_;
				gboolean _tmp21_;
				_tmp19_ = en;
				_tmp20_ = vala_enum_get_is_flags (_tmp19_);
				_tmp21_ = _tmp20_;
				if (_tmp21_) {
					gchar* _tmp22_;
					_tmp22_ = g_strdup ("g_value_take_flags");
					result = _tmp22_;
					return result;
				} else {
					gchar* _tmp23_;
					_tmp23_ = g_strdup ("g_value_take_enum");
					result = _tmp23_;
					return result;
				}
			} else {
				ValaEnum* _tmp24_;
				gboolean _tmp25_;
				gboolean _tmp26_;
				_tmp24_ = en;
				_tmp25_ = vala_enum_get_is_flags (_tmp24_);
				_tmp26_ = _tmp25_;
				if (_tmp26_) {
					gchar* _tmp27_;
					_tmp27_ = g_strdup ("g_value_take_uint");
					result = _tmp27_;
					return result;
				} else {
					gchar* _tmp28_;
					_tmp28_ = g_strdup ("g_value_take_int");
					result = _tmp28_;
					return result;
				}
			}
		} else {
			ValaSymbol* _tmp29_;
			_tmp29_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_ERROR_DOMAIN)) {
				gchar* _tmp30_;
				_tmp30_ = g_strdup ("g_value_take_boxed");
				result = _tmp30_;
				return result;
			} else {
				ValaSymbol* _tmp31_;
				_tmp31_ = self->priv->sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp31_, VALA_TYPE_INTERFACE)) {
					gchar* _tmp46_;
					{
						ValaList* _prereq_list = NULL;
						ValaSymbol* _tmp32_;
						ValaList* _tmp33_;
						gint _prereq_size = 0;
						ValaList* _tmp34_;
						gint _tmp35_;
						gint _tmp36_;
						gint _prereq_index = 0;
						_tmp32_ = self->priv->sym;
						_tmp33_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp32_, VALA_TYPE_INTERFACE, ValaInterface));
						_prereq_list = _tmp33_;
						_tmp34_ = _prereq_list;
						_tmp35_ = vala_collection_get_size ((ValaCollection*) _tmp34_);
						_tmp36_ = _tmp35_;
						_prereq_size = _tmp36_;
						_prereq_index = -1;
						while (TRUE) {
							gint _tmp37_;
							gint _tmp38_;
							ValaDataType* prereq = NULL;
							ValaList* _tmp39_;
							gpointer _tmp40_;
							gchar* func = NULL;
							ValaDataType* _tmp41_;
							ValaTypeSymbol* _tmp42_;
							ValaTypeSymbol* _tmp43_;
							gchar* _tmp44_;
							const gchar* _tmp45_;
							_prereq_index = _prereq_index + 1;
							_tmp37_ = _prereq_index;
							_tmp38_ = _prereq_size;
							if (!(_tmp37_ < _tmp38_)) {
								break;
							}
							_tmp39_ = _prereq_list;
							_tmp40_ = vala_list_get (_tmp39_, _prereq_index);
							prereq = (ValaDataType*) _tmp40_;
							_tmp41_ = prereq;
							_tmp42_ = vala_data_type_get_type_symbol (_tmp41_);
							_tmp43_ = _tmp42_;
							_tmp44_ = vala_get_ccode_take_value_function ((ValaCodeNode*) _tmp43_);
							func = _tmp44_;
							_tmp45_ = func;
							if (g_strcmp0 (_tmp45_, "") != 0) {
								result = func;
								_vala_code_node_unref0 (prereq);
								return result;
							}
							_g_free0 (func);
							_vala_code_node_unref0 (prereq);
						}
					}
					_tmp46_ = g_strdup ("g_value_set_pointer");
					result = _tmp46_;
					return result;
				} else {
					ValaSymbol* _tmp47_;
					_tmp47_ = self->priv->sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp47_, VALA_TYPE_STRUCT)) {
						ValaStruct* st = NULL;
						ValaSymbol* _tmp48_;
						ValaStruct* base_st = NULL;
						ValaStruct* _tmp49_;
						ValaStruct* _tmp50_;
						ValaStruct* _tmp51_;
						ValaStruct* _tmp59_;
						_tmp48_ = self->priv->sym;
						st = G_TYPE_CHECK_INSTANCE_CAST (_tmp48_, VALA_TYPE_STRUCT, ValaStruct);
						_tmp49_ = st;
						_tmp50_ = vala_struct_get_base_struct (_tmp49_);
						_tmp51_ = _tmp50_;
						base_st = _tmp51_;
						while (TRUE) {
							ValaStruct* _tmp52_;
							ValaStruct* _tmp53_;
							_tmp52_ = base_st;
							if (!(_tmp52_ != NULL)) {
								break;
							}
							_tmp53_ = base_st;
							if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp53_)) {
								ValaStruct* _tmp54_;
								gchar* _tmp55_;
								_tmp54_ = base_st;
								_tmp55_ = vala_get_ccode_take_value_function ((ValaCodeNode*) _tmp54_);
								result = _tmp55_;
								return result;
							} else {
								ValaStruct* _tmp56_;
								ValaStruct* _tmp57_;
								ValaStruct* _tmp58_;
								_tmp56_ = base_st;
								_tmp57_ = vala_struct_get_base_struct (_tmp56_);
								_tmp58_ = _tmp57_;
								base_st = _tmp58_;
							}
						}
						_tmp59_ = st;
						if (vala_struct_is_simple_type (_tmp59_)) {
							ValaStruct* _tmp60_;
							ValaSourceReference* _tmp61_;
							ValaSourceReference* _tmp62_;
							ValaStruct* _tmp63_;
							gchar* _tmp64_;
							gchar* _tmp65_;
							_tmp60_ = st;
							_tmp61_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp60_);
							_tmp62_ = _tmp61_;
							_tmp63_ = st;
							_tmp64_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp63_);
							_tmp65_ = _tmp64_;
							vala_report_error (_tmp62_, "The type `%s' doesn't declare a GValue take function", _tmp65_);
							_g_free0 (_tmp65_);
						} else {
							ValaStruct* _tmp66_;
							_tmp66_ = st;
							if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp66_)) {
								gchar* _tmp67_;
								_tmp67_ = g_strdup ("g_value_take_boxed");
								result = _tmp67_;
								return result;
							} else {
								gchar* _tmp68_;
								_tmp68_ = g_strdup ("g_value_set_pointer");
								result = _tmp68_;
								return result;
							}
						}
					} else {
						gchar* _tmp69_;
						_tmp69_ = g_strdup ("g_value_set_pointer");
						result = _tmp69_;
						return result;
					}
				}
			}
		}
	}
	_tmp70_ = g_strdup ("");
	result = _tmp70_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_param_spec_function (ValaCCodeAttribute* self)
{
	ValaCodeNode* _tmp0_;
	gchar* _tmp100_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_SYMBOL)) {
		ValaSymbol* _tmp1_;
		_tmp1_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CLASS)) {
			ValaClass* cl = NULL;
			ValaSymbol* _tmp2_;
			ValaClass* _tmp3_;
			_tmp2_ = self->priv->sym;
			cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_CLASS, ValaClass);
			_tmp3_ = cl;
			if (vala_class_is_fundamental (_tmp3_)) {
				ValaClass* _tmp4_;
				gchar* _tmp5_;
				_tmp4_ = cl;
				_tmp5_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp4_, "param_spec_");
				result = _tmp5_;
				return result;
			} else {
				ValaClass* _tmp6_;
				ValaClass* _tmp7_;
				ValaClass* _tmp8_;
				_tmp6_ = cl;
				_tmp7_ = vala_class_get_base_class (_tmp6_);
				_tmp8_ = _tmp7_;
				if (_tmp8_ != NULL) {
					ValaClass* _tmp9_;
					ValaClass* _tmp10_;
					ValaClass* _tmp11_;
					gchar* _tmp12_;
					_tmp9_ = cl;
					_tmp10_ = vala_class_get_base_class (_tmp9_);
					_tmp11_ = _tmp10_;
					_tmp12_ = vala_get_ccode_param_spec_function ((ValaCodeNode*) _tmp11_);
					result = _tmp12_;
					return result;
				} else {
					const gchar* _tmp13_;
					const gchar* _tmp14_;
					_tmp13_ = vala_ccode_attribute_get_type_id (self);
					_tmp14_ = _tmp13_;
					if (g_strcmp0 (_tmp14_, "G_TYPE_POINTER") == 0) {
						gchar* _tmp15_;
						_tmp15_ = g_strdup ("g_param_spec_pointer");
						result = _tmp15_;
						return result;
					} else {
						gchar* _tmp16_;
						_tmp16_ = g_strdup ("g_param_spec_boxed");
						result = _tmp16_;
						return result;
					}
				}
			}
		} else {
			ValaSymbol* _tmp17_;
			_tmp17_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_INTERFACE)) {
				gchar* _tmp32_;
				{
					ValaList* _prereq_list = NULL;
					ValaSymbol* _tmp18_;
					ValaList* _tmp19_;
					gint _prereq_size = 0;
					ValaList* _tmp20_;
					gint _tmp21_;
					gint _tmp22_;
					gint _prereq_index = 0;
					_tmp18_ = self->priv->sym;
					_tmp19_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp18_, VALA_TYPE_INTERFACE, ValaInterface));
					_prereq_list = _tmp19_;
					_tmp20_ = _prereq_list;
					_tmp21_ = vala_collection_get_size ((ValaCollection*) _tmp20_);
					_tmp22_ = _tmp21_;
					_prereq_size = _tmp22_;
					_prereq_index = -1;
					while (TRUE) {
						gint _tmp23_;
						gint _tmp24_;
						ValaDataType* prereq = NULL;
						ValaList* _tmp25_;
						gpointer _tmp26_;
						gchar* func = NULL;
						ValaDataType* _tmp27_;
						ValaTypeSymbol* _tmp28_;
						ValaTypeSymbol* _tmp29_;
						gchar* _tmp30_;
						const gchar* _tmp31_;
						_prereq_index = _prereq_index + 1;
						_tmp23_ = _prereq_index;
						_tmp24_ = _prereq_size;
						if (!(_tmp23_ < _tmp24_)) {
							break;
						}
						_tmp25_ = _prereq_list;
						_tmp26_ = vala_list_get (_tmp25_, _prereq_index);
						prereq = (ValaDataType*) _tmp26_;
						_tmp27_ = prereq;
						_tmp28_ = vala_data_type_get_type_symbol (_tmp27_);
						_tmp29_ = _tmp28_;
						_tmp30_ = vala_get_ccode_param_spec_function ((ValaCodeNode*) _tmp29_);
						func = _tmp30_;
						_tmp31_ = func;
						if (g_strcmp0 (_tmp31_, "") != 0) {
							result = func;
							_vala_code_node_unref0 (prereq);
							return result;
						}
						_g_free0 (func);
						_vala_code_node_unref0 (prereq);
					}
				}
				_tmp32_ = g_strdup ("g_param_spec_pointer");
				result = _tmp32_;
				return result;
			} else {
				ValaSymbol* _tmp33_;
				_tmp33_ = self->priv->sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp33_, VALA_TYPE_ENUM)) {
					ValaEnum* e = NULL;
					ValaSymbol* _tmp34_;
					ValaEnum* _tmp35_;
					_tmp34_ = self->priv->sym;
					e = G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, VALA_TYPE_ENUM, ValaEnum);
					_tmp35_ = e;
					if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp35_)) {
						ValaEnum* _tmp36_;
						gboolean _tmp37_;
						gboolean _tmp38_;
						_tmp36_ = e;
						_tmp37_ = vala_enum_get_is_flags (_tmp36_);
						_tmp38_ = _tmp37_;
						if (_tmp38_) {
							gchar* _tmp39_;
							_tmp39_ = g_strdup ("g_param_spec_flags");
							result = _tmp39_;
							return result;
						} else {
							gchar* _tmp40_;
							_tmp40_ = g_strdup ("g_param_spec_enum");
							result = _tmp40_;
							return result;
						}
					} else {
						ValaEnum* _tmp41_;
						gboolean _tmp42_;
						gboolean _tmp43_;
						_tmp41_ = e;
						_tmp42_ = vala_enum_get_is_flags (_tmp41_);
						_tmp43_ = _tmp42_;
						if (_tmp43_) {
							gchar* _tmp44_;
							_tmp44_ = g_strdup ("g_param_spec_uint");
							result = _tmp44_;
							return result;
						} else {
							gchar* _tmp45_;
							_tmp45_ = g_strdup ("g_param_spec_int");
							result = _tmp45_;
							return result;
						}
					}
				} else {
					ValaSymbol* _tmp46_;
					_tmp46_ = self->priv->sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp46_, VALA_TYPE_ERROR_DOMAIN)) {
						gchar* _tmp47_;
						_tmp47_ = g_strdup ("g_param_spec_boxed");
						result = _tmp47_;
						return result;
					} else {
						ValaSymbol* _tmp48_;
						_tmp48_ = self->priv->sym;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp48_, VALA_TYPE_STRUCT)) {
							gchar* type_id = NULL;
							ValaSymbol* _tmp49_;
							gchar* _tmp50_;
							const gchar* _tmp51_;
							_tmp49_ = self->priv->sym;
							_tmp50_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp49_);
							type_id = _tmp50_;
							_tmp51_ = type_id;
							if (g_strcmp0 (_tmp51_, "G_TYPE_INT") == 0) {
								gchar* _tmp52_;
								_tmp52_ = g_strdup ("g_param_spec_int");
								result = _tmp52_;
								_g_free0 (type_id);
								return result;
							} else {
								const gchar* _tmp53_;
								_tmp53_ = type_id;
								if (g_strcmp0 (_tmp53_, "G_TYPE_UINT") == 0) {
									gchar* _tmp54_;
									_tmp54_ = g_strdup ("g_param_spec_uint");
									result = _tmp54_;
									_g_free0 (type_id);
									return result;
								} else {
									const gchar* _tmp55_;
									_tmp55_ = type_id;
									if (g_strcmp0 (_tmp55_, "G_TYPE_INT64") == 0) {
										gchar* _tmp56_;
										_tmp56_ = g_strdup ("g_param_spec_int64");
										result = _tmp56_;
										_g_free0 (type_id);
										return result;
									} else {
										const gchar* _tmp57_;
										_tmp57_ = type_id;
										if (g_strcmp0 (_tmp57_, "G_TYPE_UINT64") == 0) {
											gchar* _tmp58_;
											_tmp58_ = g_strdup ("g_param_spec_uint64");
											result = _tmp58_;
											_g_free0 (type_id);
											return result;
										} else {
											const gchar* _tmp59_;
											_tmp59_ = type_id;
											if (g_strcmp0 (_tmp59_, "G_TYPE_LONG") == 0) {
												gchar* _tmp60_;
												_tmp60_ = g_strdup ("g_param_spec_long");
												result = _tmp60_;
												_g_free0 (type_id);
												return result;
											} else {
												const gchar* _tmp61_;
												_tmp61_ = type_id;
												if (g_strcmp0 (_tmp61_, "G_TYPE_ULONG") == 0) {
													gchar* _tmp62_;
													_tmp62_ = g_strdup ("g_param_spec_ulong");
													result = _tmp62_;
													_g_free0 (type_id);
													return result;
												} else {
													const gchar* _tmp63_;
													_tmp63_ = type_id;
													if (g_strcmp0 (_tmp63_, "G_TYPE_BOOLEAN") == 0) {
														gchar* _tmp64_;
														_tmp64_ = g_strdup ("g_param_spec_boolean");
														result = _tmp64_;
														_g_free0 (type_id);
														return result;
													} else {
														const gchar* _tmp65_;
														_tmp65_ = type_id;
														if (g_strcmp0 (_tmp65_, "G_TYPE_CHAR") == 0) {
															gchar* _tmp66_;
															_tmp66_ = g_strdup ("g_param_spec_char");
															result = _tmp66_;
															_g_free0 (type_id);
															return result;
														} else {
															const gchar* _tmp67_;
															_tmp67_ = type_id;
															if (g_strcmp0 (_tmp67_, "G_TYPE_UCHAR") == 0) {
																gchar* _tmp68_;
																_tmp68_ = g_strdup ("g_param_spec_uchar");
																result = _tmp68_;
																_g_free0 (type_id);
																return result;
															} else {
																const gchar* _tmp69_;
																_tmp69_ = type_id;
																if (g_strcmp0 (_tmp69_, "G_TYPE_FLOAT") == 0) {
																	gchar* _tmp70_;
																	_tmp70_ = g_strdup ("g_param_spec_float");
																	result = _tmp70_;
																	_g_free0 (type_id);
																	return result;
																} else {
																	const gchar* _tmp71_;
																	_tmp71_ = type_id;
																	if (g_strcmp0 (_tmp71_, "G_TYPE_DOUBLE") == 0) {
																		gchar* _tmp72_;
																		_tmp72_ = g_strdup ("g_param_spec_double");
																		result = _tmp72_;
																		_g_free0 (type_id);
																		return result;
																	} else {
																		const gchar* _tmp73_;
																		_tmp73_ = type_id;
																		if (g_strcmp0 (_tmp73_, "G_TYPE_GTYPE") == 0) {
																			gchar* _tmp74_;
																			_tmp74_ = g_strdup ("g_param_spec_gtype");
																			result = _tmp74_;
																			_g_free0 (type_id);
																			return result;
																		} else {
																			gchar* _tmp75_;
																			_tmp75_ = g_strdup ("g_param_spec_boxed");
																			result = _tmp75_;
																			_g_free0 (type_id);
																			return result;
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
							_g_free0 (type_id);
						}
					}
				}
			}
		}
	} else {
		gboolean _tmp76_ = FALSE;
		ValaCodeNode* _tmp77_;
		_tmp77_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp77_, VALA_TYPE_ARRAY_TYPE)) {
			ValaCodeNode* _tmp78_;
			ValaDataType* _tmp79_;
			ValaDataType* _tmp80_;
			ValaTypeSymbol* _tmp81_;
			ValaTypeSymbol* _tmp82_;
			ValaCodeContext* _tmp83_;
			ValaCodeContext* _tmp84_;
			ValaSemanticAnalyzer* _tmp85_;
			ValaSemanticAnalyzer* _tmp86_;
			ValaDataType* _tmp87_;
			ValaTypeSymbol* _tmp88_;
			ValaTypeSymbol* _tmp89_;
			_tmp78_ = self->priv->node;
			_tmp79_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp78_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			_tmp80_ = _tmp79_;
			_tmp81_ = vala_data_type_get_type_symbol (_tmp80_);
			_tmp82_ = _tmp81_;
			_tmp83_ = vala_code_context_get ();
			_tmp84_ = _tmp83_;
			_tmp85_ = vala_code_context_get_analyzer (_tmp84_);
			_tmp86_ = _tmp85_;
			_tmp87_ = _tmp86_->string_type;
			_tmp88_ = vala_data_type_get_type_symbol (_tmp87_);
			_tmp89_ = _tmp88_;
			_tmp76_ = _tmp82_ == _tmp89_;
			_vala_code_context_unref0 (_tmp84_);
		} else {
			_tmp76_ = FALSE;
		}
		if (_tmp76_) {
			gchar* _tmp90_;
			_tmp90_ = g_strdup ("g_param_spec_boxed");
			result = _tmp90_;
			return result;
		} else {
			gboolean _tmp91_ = FALSE;
			ValaCodeNode* _tmp92_;
			_tmp92_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp92_, VALA_TYPE_DATA_TYPE)) {
				ValaCodeNode* _tmp93_;
				ValaTypeSymbol* _tmp94_;
				ValaTypeSymbol* _tmp95_;
				_tmp93_ = self->priv->node;
				_tmp94_ = vala_data_type_get_type_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp93_, VALA_TYPE_DATA_TYPE, ValaDataType));
				_tmp95_ = _tmp94_;
				_tmp91_ = _tmp95_ != NULL;
			} else {
				_tmp91_ = FALSE;
			}
			if (_tmp91_) {
				ValaCodeNode* _tmp96_;
				ValaTypeSymbol* _tmp97_;
				ValaTypeSymbol* _tmp98_;
				gchar* _tmp99_;
				_tmp96_ = self->priv->node;
				_tmp97_ = vala_data_type_get_type_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp96_, VALA_TYPE_DATA_TYPE, ValaDataType));
				_tmp98_ = _tmp97_;
				_tmp99_ = vala_get_ccode_param_spec_function ((ValaCodeNode*) _tmp98_);
				result = _tmp99_;
				return result;
			}
		}
	}
	_tmp100_ = g_strdup ("g_param_spec_pointer");
	result = _tmp100_;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_default_value (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* _tmp15_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ENUM)) {
		ValaEnum* en = NULL;
		ValaSymbol* _tmp1_;
		ValaEnum* _tmp2_;
		gboolean _tmp3_;
		gboolean _tmp4_;
		_tmp1_ = self->priv->sym;
		en = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_ENUM, ValaEnum);
		_tmp2_ = en;
		_tmp3_ = vala_enum_get_is_flags (_tmp2_);
		_tmp4_ = _tmp3_;
		if (_tmp4_) {
			gchar* _tmp5_;
			_tmp5_ = g_strdup ("0U");
			result = _tmp5_;
			return result;
		} else {
			gchar* _tmp6_;
			_tmp6_ = g_strdup ("0");
			result = _tmp6_;
			return result;
		}
	} else {
		ValaSymbol* _tmp7_;
		_tmp7_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_STRUCT)) {
			ValaStruct* st = NULL;
			ValaSymbol* _tmp8_;
			ValaStruct* base_st = NULL;
			ValaStruct* _tmp9_;
			ValaStruct* _tmp10_;
			ValaStruct* _tmp11_;
			ValaStruct* _tmp12_;
			_tmp8_ = self->priv->sym;
			st = G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_STRUCT, ValaStruct);
			_tmp9_ = st;
			_tmp10_ = vala_struct_get_base_struct (_tmp9_);
			_tmp11_ = _tmp10_;
			base_st = _tmp11_;
			_tmp12_ = base_st;
			if (_tmp12_ != NULL) {
				ValaStruct* _tmp13_;
				gchar* _tmp14_;
				_tmp13_ = base_st;
				_tmp14_ = vala_get_ccode_default_value ((ValaTypeSymbol*) _tmp13_);
				result = _tmp14_;
				return result;
			}
		}
	}
	_tmp15_ = g_strdup ("");
	result = _tmp15_;
	return result;
}

static gchar*
vala_ccode_attribute_get_finish_name_for_basename (ValaCCodeAttribute* self,
                                                   const gchar* basename)
{
	gchar* _result_ = NULL;
	gchar* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (basename != NULL, NULL);
	_tmp0_ = g_strdup (basename);
	_result_ = _tmp0_;
	_tmp1_ = _result_;
	if (g_str_has_suffix (_tmp1_, "_async")) {
		const gchar* _tmp2_;
		const gchar* _tmp3_;
		gint _tmp4_;
		gint _tmp5_;
		gint _tmp6_;
		gint _tmp7_;
		gchar* _tmp8_;
		_tmp2_ = _result_;
		_tmp3_ = _result_;
		_tmp4_ = strlen (_tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = strlen ("_async");
		_tmp7_ = _tmp6_;
		_tmp8_ = string_substring (_tmp2_, (glong) 0, (glong) (_tmp5_ - _tmp7_));
		_g_free0 (_result_);
		_result_ = _tmp8_;
	}
	_tmp9_ = _result_;
	_tmp10_ = g_strdup_printf ("%s_finish", _tmp9_);
	result = _tmp10_;
	_g_free0 (_result_);
	return result;
}

static gchar*
vala_ccode_attribute_get_default_real_name (ValaCCodeAttribute* self)
{
	ValaSymbol* _tmp0_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CREATION_METHOD)) {
		ValaCreationMethod* m = NULL;
		ValaSymbol* _tmp1_;
		ValaClass* parent = NULL;
		ValaCreationMethod* _tmp2_;
		ValaSymbol* _tmp3_;
		ValaSymbol* _tmp4_;
		gboolean _tmp5_ = FALSE;
		ValaClass* _tmp6_;
		gchar* infix = NULL;
		gchar* _tmp13_;
		ValaCreationMethod* _tmp14_;
		const gchar* _tmp15_;
		const gchar* _tmp16_;
		_tmp1_ = self->priv->sym;
		m = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod);
		_tmp2_ = m;
		_tmp3_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2_);
		_tmp4_ = _tmp3_;
		parent = G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp4_) : NULL;
		_tmp6_ = parent;
		if (_tmp6_ == NULL) {
			_tmp5_ = TRUE;
		} else {
			ValaClass* _tmp7_;
			gboolean _tmp8_;
			gboolean _tmp9_;
			_tmp7_ = parent;
			_tmp8_ = vala_class_get_is_compact (_tmp7_);
			_tmp9_ = _tmp8_;
			_tmp5_ = _tmp9_;
		}
		if (_tmp5_) {
			const gchar* _tmp10_;
			const gchar* _tmp11_;
			gchar* _tmp12_;
			_tmp10_ = vala_ccode_attribute_get_name (self);
			_tmp11_ = _tmp10_;
			_tmp12_ = g_strdup (_tmp11_);
			result = _tmp12_;
			return result;
		}
		_tmp13_ = g_strdup ("construct");
		infix = _tmp13_;
		_tmp14_ = m;
		_tmp15_ = vala_symbol_get_name ((ValaSymbol*) _tmp14_);
		_tmp16_ = _tmp15_;
		if (g_strcmp0 (_tmp16_, ".new") == 0) {
			ValaClass* _tmp17_;
			gchar* _tmp18_;
			gchar* _tmp19_;
			const gchar* _tmp20_;
			gchar* _tmp21_;
			gchar* _tmp22_;
			_tmp17_ = parent;
			_tmp18_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp17_);
			_tmp19_ = _tmp18_;
			_tmp20_ = infix;
			_tmp21_ = g_strdup_printf ("%s%s", _tmp19_, _tmp20_);
			_tmp22_ = _tmp21_;
			_g_free0 (_tmp19_);
			result = _tmp22_;
			_g_free0 (infix);
			return result;
		} else {
			ValaClass* _tmp23_;
			gchar* _tmp24_;
			gchar* _tmp25_;
			const gchar* _tmp26_;
			ValaCreationMethod* _tmp27_;
			const gchar* _tmp28_;
			const gchar* _tmp29_;
			gchar* _tmp30_;
			gchar* _tmp31_;
			_tmp23_ = parent;
			_tmp24_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp23_);
			_tmp25_ = _tmp24_;
			_tmp26_ = infix;
			_tmp27_ = m;
			_tmp28_ = vala_symbol_get_name ((ValaSymbol*) _tmp27_);
			_tmp29_ = _tmp28_;
			_tmp30_ = g_strdup_printf ("%s%s_%s", _tmp25_, _tmp26_, _tmp29_);
			_tmp31_ = _tmp30_;
			_g_free0 (_tmp25_);
			result = _tmp31_;
			_g_free0 (infix);
			return result;
		}
		_g_free0 (infix);
	} else {
		ValaSymbol* _tmp32_;
		_tmp32_ = self->priv->sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_METHOD)) {
			ValaMethod* m = NULL;
			ValaSymbol* _tmp33_;
			gboolean _tmp34_ = FALSE;
			gboolean _tmp35_ = FALSE;
			ValaMethod* _tmp36_;
			ValaMethod* _tmp37_;
			ValaMethod* _tmp38_;
			_tmp33_ = self->priv->sym;
			m = G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_METHOD, ValaMethod);
			_tmp36_ = m;
			_tmp37_ = vala_method_get_base_method (_tmp36_);
			_tmp38_ = _tmp37_;
			if (_tmp38_ != NULL) {
				_tmp35_ = TRUE;
			} else {
				ValaMethod* _tmp39_;
				ValaMethod* _tmp40_;
				ValaMethod* _tmp41_;
				_tmp39_ = m;
				_tmp40_ = vala_method_get_base_interface_method (_tmp39_);
				_tmp41_ = _tmp40_;
				_tmp35_ = _tmp41_ != NULL;
			}
			if (_tmp35_) {
				_tmp34_ = TRUE;
			} else {
				ValaMethod* _tmp42_;
				ValaSignal* _tmp43_;
				ValaSignal* _tmp44_;
				_tmp42_ = m;
				_tmp43_ = vala_method_get_signal_reference (_tmp42_);
				_tmp44_ = _tmp43_;
				_tmp34_ = _tmp44_ != NULL;
			}
			if (_tmp34_) {
				gchar* m_name = NULL;
				ValaMethod* _tmp45_;
				ValaSignal* _tmp46_;
				ValaSignal* _tmp47_;
				ValaMethod* _tmp56_;
				ValaDataType* _tmp57_;
				ValaDataType* _tmp58_;
				_tmp45_ = m;
				_tmp46_ = vala_method_get_signal_reference (_tmp45_);
				_tmp47_ = _tmp46_;
				if (_tmp47_ != NULL) {
					ValaMethod* _tmp48_;
					ValaSignal* _tmp49_;
					ValaSignal* _tmp50_;
					gchar* _tmp51_;
					_tmp48_ = m;
					_tmp49_ = vala_method_get_signal_reference (_tmp48_);
					_tmp50_ = _tmp49_;
					_tmp51_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp50_, NULL);
					_g_free0 (m_name);
					m_name = _tmp51_;
				} else {
					ValaMethod* _tmp52_;
					const gchar* _tmp53_;
					const gchar* _tmp54_;
					gchar* _tmp55_;
					_tmp52_ = m;
					_tmp53_ = vala_symbol_get_name ((ValaSymbol*) _tmp52_);
					_tmp54_ = _tmp53_;
					_tmp55_ = g_strdup (_tmp54_);
					_g_free0 (m_name);
					m_name = _tmp55_;
				}
				_tmp56_ = m;
				_tmp57_ = vala_method_get_base_interface_type (_tmp56_);
				_tmp58_ = _tmp57_;
				if (_tmp58_ != NULL) {
					ValaMethod* _tmp59_;
					ValaSymbol* _tmp60_;
					ValaSymbol* _tmp61_;
					gchar* _tmp62_;
					gchar* _tmp63_;
					ValaMethod* _tmp64_;
					ValaDataType* _tmp65_;
					ValaDataType* _tmp66_;
					ValaTypeSymbol* _tmp67_;
					ValaTypeSymbol* _tmp68_;
					gchar* _tmp69_;
					gchar* _tmp70_;
					const gchar* _tmp71_;
					gchar* _tmp72_;
					gchar* _tmp73_;
					_tmp59_ = m;
					_tmp60_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp59_);
					_tmp61_ = _tmp60_;
					_tmp62_ = vala_get_ccode_lower_case_prefix (_tmp61_);
					_tmp63_ = _tmp62_;
					_tmp64_ = m;
					_tmp65_ = vala_method_get_base_interface_type (_tmp64_);
					_tmp66_ = _tmp65_;
					_tmp67_ = vala_data_type_get_type_symbol (_tmp66_);
					_tmp68_ = _tmp67_;
					_tmp69_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp68_);
					_tmp70_ = _tmp69_;
					_tmp71_ = m_name;
					_tmp72_ = g_strdup_printf ("%sreal_%s%s", _tmp63_, _tmp70_, _tmp71_);
					_tmp73_ = _tmp72_;
					_g_free0 (_tmp70_);
					_g_free0 (_tmp63_);
					result = _tmp73_;
					_g_free0 (m_name);
					return result;
				} else {
					ValaMethod* _tmp74_;
					ValaSymbol* _tmp75_;
					ValaSymbol* _tmp76_;
					gchar* _tmp77_;
					gchar* _tmp78_;
					const gchar* _tmp79_;
					gchar* _tmp80_;
					gchar* _tmp81_;
					_tmp74_ = m;
					_tmp75_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp74_);
					_tmp76_ = _tmp75_;
					_tmp77_ = vala_get_ccode_lower_case_prefix (_tmp76_);
					_tmp78_ = _tmp77_;
					_tmp79_ = m_name;
					_tmp80_ = g_strdup_printf ("%sreal_%s", _tmp78_, _tmp79_);
					_tmp81_ = _tmp80_;
					_g_free0 (_tmp78_);
					result = _tmp81_;
					_g_free0 (m_name);
					return result;
				}
				_g_free0 (m_name);
			} else {
				const gchar* _tmp82_;
				const gchar* _tmp83_;
				gchar* _tmp84_;
				_tmp82_ = vala_ccode_attribute_get_name (self);
				_tmp83_ = _tmp82_;
				_tmp84_ = g_strdup (_tmp83_);
				result = _tmp84_;
				return result;
			}
		} else {
			ValaSymbol* _tmp85_;
			_tmp85_ = self->priv->sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp85_, VALA_TYPE_PROPERTY_ACCESSOR)) {
				ValaPropertyAccessor* acc = NULL;
				ValaSymbol* _tmp86_;
				ValaProperty* prop = NULL;
				ValaPropertyAccessor* _tmp87_;
				ValaProperty* _tmp88_;
				ValaProperty* _tmp89_;
				gboolean _tmp90_ = FALSE;
				ValaProperty* _tmp91_;
				ValaProperty* _tmp92_;
				ValaProperty* _tmp93_;
				_tmp86_ = self->priv->sym;
				acc = G_TYPE_CHECK_INSTANCE_CAST (_tmp86_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor);
				_tmp87_ = acc;
				_tmp88_ = vala_property_accessor_get_prop (_tmp87_);
				_tmp89_ = _tmp88_;
				prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp89_, VALA_TYPE_PROPERTY, ValaProperty);
				_tmp91_ = prop;
				_tmp92_ = vala_property_get_base_property (_tmp91_);
				_tmp93_ = _tmp92_;
				if (_tmp93_ != NULL) {
					_tmp90_ = TRUE;
				} else {
					ValaProperty* _tmp94_;
					ValaProperty* _tmp95_;
					ValaProperty* _tmp96_;
					_tmp94_ = prop;
					_tmp95_ = vala_property_get_base_interface_property (_tmp94_);
					_tmp96_ = _tmp95_;
					_tmp90_ = _tmp96_ != NULL;
				}
				if (_tmp90_) {
					ValaPropertyAccessor* _tmp97_;
					gboolean _tmp98_;
					gboolean _tmp99_;
					_tmp97_ = acc;
					_tmp98_ = vala_property_accessor_get_readable (_tmp97_);
					_tmp99_ = _tmp98_;
					if (_tmp99_) {
						ValaProperty* _tmp100_;
						ValaSymbol* _tmp101_;
						ValaSymbol* _tmp102_;
						gchar* _tmp103_;
						gchar* _tmp104_;
						ValaProperty* _tmp105_;
						const gchar* _tmp106_;
						const gchar* _tmp107_;
						gchar* _tmp108_;
						gchar* _tmp109_;
						_tmp100_ = prop;
						_tmp101_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp100_);
						_tmp102_ = _tmp101_;
						_tmp103_ = vala_get_ccode_lower_case_prefix (_tmp102_);
						_tmp104_ = _tmp103_;
						_tmp105_ = prop;
						_tmp106_ = vala_symbol_get_name ((ValaSymbol*) _tmp105_);
						_tmp107_ = _tmp106_;
						_tmp108_ = g_strdup_printf ("%sreal_get_%s", _tmp104_, _tmp107_);
						_tmp109_ = _tmp108_;
						_g_free0 (_tmp104_);
						result = _tmp109_;
						return result;
					} else {
						ValaProperty* _tmp110_;
						ValaSymbol* _tmp111_;
						ValaSymbol* _tmp112_;
						gchar* _tmp113_;
						gchar* _tmp114_;
						ValaProperty* _tmp115_;
						const gchar* _tmp116_;
						const gchar* _tmp117_;
						gchar* _tmp118_;
						gchar* _tmp119_;
						_tmp110_ = prop;
						_tmp111_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp110_);
						_tmp112_ = _tmp111_;
						_tmp113_ = vala_get_ccode_lower_case_prefix (_tmp112_);
						_tmp114_ = _tmp113_;
						_tmp115_ = prop;
						_tmp116_ = vala_symbol_get_name ((ValaSymbol*) _tmp115_);
						_tmp117_ = _tmp116_;
						_tmp118_ = g_strdup_printf ("%sreal_set_%s", _tmp114_, _tmp117_);
						_tmp119_ = _tmp118_;
						_g_free0 (_tmp114_);
						result = _tmp119_;
						return result;
					}
				} else {
					const gchar* _tmp120_;
					const gchar* _tmp121_;
					gchar* _tmp122_;
					_tmp120_ = vala_ccode_attribute_get_name (self);
					_tmp121_ = _tmp120_;
					_tmp122_ = g_strdup (_tmp121_);
					result = _tmp122_;
					return result;
				}
			}
		}
	}
	g_assert_not_reached ();
}

static gchar*
vala_ccode_attribute_get_default_const_name (ValaCCodeAttribute* self)
{
	ValaCodeNode* _tmp0_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_DATA_TYPE)) {
		ValaDataType* type = NULL;
		ValaCodeNode* _tmp1_;
		gchar* ptr = NULL;
		ValaTypeSymbol* t = NULL;
		ValaDataType* _tmp2_;
		ValaTypeSymbol* _tmp13_;
		ValaTypeSymbol* _tmp16_;
		gchar* _tmp17_;
		gchar* _tmp18_;
		const gchar* _tmp19_;
		gchar* _tmp20_;
		gchar* _tmp21_;
		_tmp1_ = self->priv->node;
		type = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_DATA_TYPE, ValaDataType);
		_tmp2_ = type;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_ARRAY_TYPE)) {
			ValaDataType* _tmp3_;
			ValaDataType* _tmp4_;
			ValaDataType* _tmp5_;
			ValaTypeSymbol* _tmp6_;
			ValaTypeSymbol* _tmp7_;
			ValaTypeSymbol* _tmp8_;
			_tmp3_ = type;
			_tmp4_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			_tmp5_ = _tmp4_;
			_tmp6_ = vala_data_type_get_type_symbol (_tmp5_);
			_tmp7_ = _tmp6_;
			_tmp8_ = _vala_code_node_ref0 (_tmp7_);
			_vala_code_node_unref0 (t);
			t = _tmp8_;
		} else {
			ValaDataType* _tmp9_;
			ValaTypeSymbol* _tmp10_;
			ValaTypeSymbol* _tmp11_;
			ValaTypeSymbol* _tmp12_;
			_tmp9_ = type;
			_tmp10_ = vala_data_type_get_type_symbol (_tmp9_);
			_tmp11_ = _tmp10_;
			_tmp12_ = _vala_code_node_ref0 (_tmp11_);
			_vala_code_node_unref0 (t);
			t = _tmp12_;
		}
		_tmp13_ = t;
		if (!vala_typesymbol_is_reference_type (_tmp13_)) {
			gchar* _tmp14_;
			_tmp14_ = g_strdup ("");
			_g_free0 (ptr);
			ptr = _tmp14_;
		} else {
			gchar* _tmp15_;
			_tmp15_ = g_strdup ("*");
			_g_free0 (ptr);
			ptr = _tmp15_;
		}
		_tmp16_ = t;
		_tmp17_ = vala_get_ccode_name ((ValaCodeNode*) _tmp16_);
		_tmp18_ = _tmp17_;
		_tmp19_ = ptr;
		_tmp20_ = g_strdup_printf ("const %s%s", _tmp18_, _tmp19_);
		_tmp21_ = _tmp20_;
		_g_free0 (_tmp18_);
		result = _tmp21_;
		_vala_code_node_unref0 (t);
		_g_free0 (ptr);
		return result;
	} else {
		gboolean _tmp22_ = FALSE;
		ValaCodeNode* _tmp23_;
		_tmp23_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_CLASS)) {
			ValaCodeNode* _tmp24_;
			gboolean _tmp25_;
			gboolean _tmp26_;
			_tmp24_ = self->priv->node;
			_tmp25_ = vala_class_get_is_immutable (G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, VALA_TYPE_CLASS, ValaClass));
			_tmp26_ = _tmp25_;
			_tmp22_ = _tmp26_;
		} else {
			_tmp22_ = FALSE;
		}
		if (_tmp22_) {
			const gchar* _tmp27_;
			const gchar* _tmp28_;
			gchar* _tmp29_;
			_tmp27_ = vala_ccode_attribute_get_name (self);
			_tmp28_ = _tmp27_;
			_tmp29_ = g_strdup_printf ("const %s", _tmp28_);
			result = _tmp29_;
			return result;
		} else {
			const gchar* _tmp30_;
			const gchar* _tmp31_;
			gchar* _tmp32_;
			_tmp30_ = vala_ccode_attribute_get_name (self);
			_tmp31_ = _tmp30_;
			_tmp32_ = g_strdup (_tmp31_);
			result = _tmp32_;
			return result;
		}
	}
}

static gboolean
vala_ccode_attribute_get_default_delegate_target (ValaCCodeAttribute* self)
{
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	ValaCodeNode* _tmp2_;
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp2_ = self->priv->node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_FIELD)) {
		_tmp1_ = TRUE;
	} else {
		ValaCodeNode* _tmp3_;
		_tmp3_ = self->priv->node;
		_tmp1_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_PARAMETER);
	}
	if (_tmp1_) {
		_tmp0_ = TRUE;
	} else {
		ValaCodeNode* _tmp4_;
		_tmp4_ = self->priv->node;
		_tmp0_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_LOCAL_VARIABLE);
	}
	if (_tmp0_) {
		ValaCodeNode* _tmp5_;
		ValaDelegateType* delegate_type = NULL;
		ValaCodeNode* _tmp13_;
		ValaDataType* _tmp14_;
		ValaDataType* _tmp15_;
		gboolean _tmp16_ = FALSE;
		ValaDelegateType* _tmp17_;
		_tmp5_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_PARAMETER)) {
			ValaParameter* param = NULL;
			ValaCodeNode* _tmp6_;
			ValaParameter* _tmp7_;
			ValaParameter* _tmp8_;
			ValaParameter* _tmp9_;
			_tmp6_ = self->priv->node;
			param = G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_PARAMETER, ValaParameter);
			_tmp7_ = param;
			_tmp8_ = vala_parameter_get_base_parameter (_tmp7_);
			_tmp9_ = _tmp8_;
			if (_tmp9_ != NULL) {
				ValaParameter* _tmp10_;
				ValaParameter* _tmp11_;
				ValaParameter* _tmp12_;
				_tmp10_ = param;
				_tmp11_ = vala_parameter_get_base_parameter (_tmp10_);
				_tmp12_ = _tmp11_;
				result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp12_);
				return result;
			}
		}
		_tmp13_ = self->priv->node;
		_tmp14_ = vala_variable_get_variable_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp13_, VALA_TYPE_VARIABLE, ValaVariable));
		_tmp15_ = _tmp14_;
		delegate_type = G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp15_) : NULL;
		_tmp17_ = delegate_type;
		if (_tmp17_ != NULL) {
			ValaDelegateType* _tmp18_;
			ValaDelegate* _tmp19_;
			ValaDelegate* _tmp20_;
			gboolean _tmp21_;
			gboolean _tmp22_;
			_tmp18_ = delegate_type;
			_tmp19_ = vala_delegate_type_get_delegate_symbol (_tmp18_);
			_tmp20_ = _tmp19_;
			_tmp21_ = vala_delegate_get_has_target (_tmp20_);
			_tmp22_ = _tmp21_;
			_tmp16_ = _tmp22_;
		} else {
			_tmp16_ = FALSE;
		}
		result = _tmp16_;
		return result;
	} else {
		ValaCodeNode* _tmp23_;
		_tmp23_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_CALLABLE)) {
			ValaCodeNode* _tmp24_;
			ValaDelegateType* delegate_type = NULL;
			ValaCodeNode* _tmp48_;
			ValaDataType* _tmp49_;
			ValaDataType* _tmp50_;
			gboolean _tmp51_ = FALSE;
			ValaDelegateType* _tmp52_;
			_tmp24_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp24_, VALA_TYPE_METHOD)) {
				ValaMethod* method = NULL;
				ValaCodeNode* _tmp25_;
				gboolean _tmp26_ = FALSE;
				ValaMethod* _tmp27_;
				ValaMethod* _tmp28_;
				ValaMethod* _tmp29_;
				_tmp25_ = self->priv->node;
				method = G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_METHOD, ValaMethod);
				_tmp27_ = method;
				_tmp28_ = vala_method_get_base_method (_tmp27_);
				_tmp29_ = _tmp28_;
				if (_tmp29_ != NULL) {
					ValaMethod* _tmp30_;
					ValaMethod* _tmp31_;
					ValaMethod* _tmp32_;
					ValaMethod* _tmp33_;
					_tmp30_ = method;
					_tmp31_ = vala_method_get_base_method (_tmp30_);
					_tmp32_ = _tmp31_;
					_tmp33_ = method;
					_tmp26_ = _tmp32_ != _tmp33_;
				} else {
					_tmp26_ = FALSE;
				}
				if (_tmp26_) {
					ValaMethod* _tmp34_;
					ValaMethod* _tmp35_;
					ValaMethod* _tmp36_;
					_tmp34_ = method;
					_tmp35_ = vala_method_get_base_method (_tmp34_);
					_tmp36_ = _tmp35_;
					result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp36_);
					return result;
				} else {
					gboolean _tmp37_ = FALSE;
					ValaMethod* _tmp38_;
					ValaMethod* _tmp39_;
					ValaMethod* _tmp40_;
					_tmp38_ = method;
					_tmp39_ = vala_method_get_base_interface_method (_tmp38_);
					_tmp40_ = _tmp39_;
					if (_tmp40_ != NULL) {
						ValaMethod* _tmp41_;
						ValaMethod* _tmp42_;
						ValaMethod* _tmp43_;
						ValaMethod* _tmp44_;
						_tmp41_ = method;
						_tmp42_ = vala_method_get_base_interface_method (_tmp41_);
						_tmp43_ = _tmp42_;
						_tmp44_ = method;
						_tmp37_ = _tmp43_ != _tmp44_;
					} else {
						_tmp37_ = FALSE;
					}
					if (_tmp37_) {
						ValaMethod* _tmp45_;
						ValaMethod* _tmp46_;
						ValaMethod* _tmp47_;
						_tmp45_ = method;
						_tmp46_ = vala_method_get_base_interface_method (_tmp45_);
						_tmp47_ = _tmp46_;
						result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp47_);
						return result;
					}
				}
			}
			_tmp48_ = self->priv->node;
			_tmp49_ = vala_callable_get_return_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp48_, VALA_TYPE_CALLABLE, ValaCallable));
			_tmp50_ = _tmp49_;
			delegate_type = G_TYPE_CHECK_INSTANCE_TYPE (_tmp50_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp50_) : NULL;
			_tmp52_ = delegate_type;
			if (_tmp52_ != NULL) {
				ValaDelegateType* _tmp53_;
				ValaDelegate* _tmp54_;
				ValaDelegate* _tmp55_;
				gboolean _tmp56_;
				gboolean _tmp57_;
				_tmp53_ = delegate_type;
				_tmp54_ = vala_delegate_type_get_delegate_symbol (_tmp53_);
				_tmp55_ = _tmp54_;
				_tmp56_ = vala_delegate_get_has_target (_tmp55_);
				_tmp57_ = _tmp56_;
				_tmp51_ = _tmp57_;
			} else {
				_tmp51_ = FALSE;
			}
			result = _tmp51_;
			return result;
		} else {
			ValaCodeNode* _tmp58_;
			_tmp58_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp58_, VALA_TYPE_PROPERTY)) {
				ValaProperty* prop = NULL;
				ValaCodeNode* _tmp59_;
				gboolean _tmp60_ = FALSE;
				ValaProperty* _tmp61_;
				ValaProperty* _tmp62_;
				ValaProperty* _tmp63_;
				ValaDelegateType* delegate_type = NULL;
				ValaProperty* _tmp82_;
				ValaDataType* _tmp83_;
				ValaDataType* _tmp84_;
				gboolean _tmp85_ = FALSE;
				ValaDelegateType* _tmp86_;
				_tmp59_ = self->priv->node;
				prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp59_, VALA_TYPE_PROPERTY, ValaProperty);
				_tmp61_ = prop;
				_tmp62_ = vala_property_get_base_property (_tmp61_);
				_tmp63_ = _tmp62_;
				if (_tmp63_ != NULL) {
					ValaProperty* _tmp64_;
					ValaProperty* _tmp65_;
					ValaProperty* _tmp66_;
					ValaProperty* _tmp67_;
					_tmp64_ = prop;
					_tmp65_ = vala_property_get_base_property (_tmp64_);
					_tmp66_ = _tmp65_;
					_tmp67_ = prop;
					_tmp60_ = _tmp66_ != _tmp67_;
				} else {
					_tmp60_ = FALSE;
				}
				if (_tmp60_) {
					ValaProperty* _tmp68_;
					ValaProperty* _tmp69_;
					ValaProperty* _tmp70_;
					_tmp68_ = prop;
					_tmp69_ = vala_property_get_base_property (_tmp68_);
					_tmp70_ = _tmp69_;
					result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp70_);
					return result;
				} else {
					gboolean _tmp71_ = FALSE;
					ValaProperty* _tmp72_;
					ValaProperty* _tmp73_;
					ValaProperty* _tmp74_;
					_tmp72_ = prop;
					_tmp73_ = vala_property_get_base_interface_property (_tmp72_);
					_tmp74_ = _tmp73_;
					if (_tmp74_ != NULL) {
						ValaProperty* _tmp75_;
						ValaProperty* _tmp76_;
						ValaProperty* _tmp77_;
						ValaProperty* _tmp78_;
						_tmp75_ = prop;
						_tmp76_ = vala_property_get_base_interface_property (_tmp75_);
						_tmp77_ = _tmp76_;
						_tmp78_ = prop;
						_tmp71_ = _tmp77_ != _tmp78_;
					} else {
						_tmp71_ = FALSE;
					}
					if (_tmp71_) {
						ValaProperty* _tmp79_;
						ValaProperty* _tmp80_;
						ValaProperty* _tmp81_;
						_tmp79_ = prop;
						_tmp80_ = vala_property_get_base_interface_property (_tmp79_);
						_tmp81_ = _tmp80_;
						result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp81_);
						return result;
					}
				}
				_tmp82_ = prop;
				_tmp83_ = vala_property_get_property_type (_tmp82_);
				_tmp84_ = _tmp83_;
				delegate_type = G_TYPE_CHECK_INSTANCE_TYPE (_tmp84_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp84_) : NULL;
				_tmp86_ = delegate_type;
				if (_tmp86_ != NULL) {
					ValaDelegateType* _tmp87_;
					ValaDelegate* _tmp88_;
					ValaDelegate* _tmp89_;
					gboolean _tmp90_;
					gboolean _tmp91_;
					_tmp87_ = delegate_type;
					_tmp88_ = vala_delegate_type_get_delegate_symbol (_tmp87_);
					_tmp89_ = _tmp88_;
					_tmp90_ = vala_delegate_get_has_target (_tmp89_);
					_tmp91_ = _tmp90_;
					_tmp85_ = _tmp91_;
				} else {
					_tmp85_ = FALSE;
				}
				result = _tmp85_;
				return result;
			} else {
				ValaCodeNode* _tmp92_;
				_tmp92_ = self->priv->node;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp92_, VALA_TYPE_PROPERTY_ACCESSOR)) {
					ValaCodeNode* _tmp93_;
					ValaProperty* _tmp94_;
					ValaProperty* _tmp95_;
					_tmp93_ = self->priv->node;
					_tmp94_ = vala_property_accessor_get_prop (G_TYPE_CHECK_INSTANCE_CAST (_tmp93_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
					_tmp95_ = _tmp94_;
					result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp95_);
					return result;
				} else {
					ValaCodeNode* _tmp96_;
					_tmp96_ = self->priv->node;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp96_, VALA_TYPE_EXPRESSION)) {
						ValaSymbol* symbol = NULL;
						ValaCodeNode* _tmp97_;
						ValaSymbol* _tmp98_;
						ValaSymbol* _tmp99_;
						ValaSymbol* _tmp100_;
						_tmp97_ = self->priv->node;
						_tmp98_ = vala_expression_get_symbol_reference (G_TYPE_CHECK_INSTANCE_CAST (_tmp97_, VALA_TYPE_EXPRESSION, ValaExpression));
						_tmp99_ = _tmp98_;
						symbol = _tmp99_;
						_tmp100_ = symbol;
						if (_tmp100_ != NULL) {
							ValaSymbol* _tmp101_;
							_tmp101_ = symbol;
							result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp101_);
							return result;
						}
					}
				}
			}
		}
	}
	result = FALSE;
	return result;
}

static gboolean
vala_ccode_attribute_get_default_array_length (ValaCCodeAttribute* self)
{
	ValaCodeNode* _tmp0_;
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_PARAMETER)) {
		ValaParameter* param = NULL;
		ValaCodeNode* _tmp1_;
		ValaParameter* _tmp2_;
		ValaParameter* _tmp3_;
		ValaParameter* _tmp4_;
		_tmp1_ = self->priv->node;
		param = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_PARAMETER, ValaParameter);
		_tmp2_ = param;
		_tmp3_ = vala_parameter_get_base_parameter (_tmp2_);
		_tmp4_ = _tmp3_;
		if (_tmp4_ != NULL) {
			ValaParameter* _tmp5_;
			ValaParameter* _tmp6_;
			ValaParameter* _tmp7_;
			_tmp5_ = param;
			_tmp6_ = vala_parameter_get_base_parameter (_tmp5_);
			_tmp7_ = _tmp6_;
			result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp7_);
			return result;
		}
	} else {
		ValaCodeNode* _tmp8_;
		_tmp8_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_METHOD)) {
			ValaMethod* method = NULL;
			ValaCodeNode* _tmp9_;
			gboolean _tmp10_ = FALSE;
			ValaMethod* _tmp11_;
			ValaMethod* _tmp12_;
			ValaMethod* _tmp13_;
			_tmp9_ = self->priv->node;
			method = G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_METHOD, ValaMethod);
			_tmp11_ = method;
			_tmp12_ = vala_method_get_base_method (_tmp11_);
			_tmp13_ = _tmp12_;
			if (_tmp13_ != NULL) {
				ValaMethod* _tmp14_;
				ValaMethod* _tmp15_;
				ValaMethod* _tmp16_;
				ValaMethod* _tmp17_;
				_tmp14_ = method;
				_tmp15_ = vala_method_get_base_method (_tmp14_);
				_tmp16_ = _tmp15_;
				_tmp17_ = method;
				_tmp10_ = _tmp16_ != _tmp17_;
			} else {
				_tmp10_ = FALSE;
			}
			if (_tmp10_) {
				ValaMethod* _tmp18_;
				ValaMethod* _tmp19_;
				ValaMethod* _tmp20_;
				_tmp18_ = method;
				_tmp19_ = vala_method_get_base_method (_tmp18_);
				_tmp20_ = _tmp19_;
				result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp20_);
				return result;
			} else {
				gboolean _tmp21_ = FALSE;
				ValaMethod* _tmp22_;
				ValaMethod* _tmp23_;
				ValaMethod* _tmp24_;
				_tmp22_ = method;
				_tmp23_ = vala_method_get_base_interface_method (_tmp22_);
				_tmp24_ = _tmp23_;
				if (_tmp24_ != NULL) {
					ValaMethod* _tmp25_;
					ValaMethod* _tmp26_;
					ValaMethod* _tmp27_;
					ValaMethod* _tmp28_;
					_tmp25_ = method;
					_tmp26_ = vala_method_get_base_interface_method (_tmp25_);
					_tmp27_ = _tmp26_;
					_tmp28_ = method;
					_tmp21_ = _tmp27_ != _tmp28_;
				} else {
					_tmp21_ = FALSE;
				}
				if (_tmp21_) {
					ValaMethod* _tmp29_;
					ValaMethod* _tmp30_;
					ValaMethod* _tmp31_;
					_tmp29_ = method;
					_tmp30_ = vala_method_get_base_interface_method (_tmp29_);
					_tmp31_ = _tmp30_;
					result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp31_);
					return result;
				}
			}
		} else {
			ValaCodeNode* _tmp32_;
			_tmp32_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_PROPERTY)) {
				ValaProperty* prop = NULL;
				ValaCodeNode* _tmp33_;
				gboolean _tmp34_ = FALSE;
				ValaProperty* _tmp35_;
				ValaProperty* _tmp36_;
				ValaProperty* _tmp37_;
				_tmp33_ = self->priv->node;
				prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_PROPERTY, ValaProperty);
				_tmp35_ = prop;
				_tmp36_ = vala_property_get_base_property (_tmp35_);
				_tmp37_ = _tmp36_;
				if (_tmp37_ != NULL) {
					ValaProperty* _tmp38_;
					ValaProperty* _tmp39_;
					ValaProperty* _tmp40_;
					ValaProperty* _tmp41_;
					_tmp38_ = prop;
					_tmp39_ = vala_property_get_base_property (_tmp38_);
					_tmp40_ = _tmp39_;
					_tmp41_ = prop;
					_tmp34_ = _tmp40_ != _tmp41_;
				} else {
					_tmp34_ = FALSE;
				}
				if (_tmp34_) {
					ValaProperty* _tmp42_;
					ValaProperty* _tmp43_;
					ValaProperty* _tmp44_;
					_tmp42_ = prop;
					_tmp43_ = vala_property_get_base_property (_tmp42_);
					_tmp44_ = _tmp43_;
					result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp44_);
					return result;
				} else {
					gboolean _tmp45_ = FALSE;
					ValaProperty* _tmp46_;
					ValaProperty* _tmp47_;
					ValaProperty* _tmp48_;
					_tmp46_ = prop;
					_tmp47_ = vala_property_get_base_interface_property (_tmp46_);
					_tmp48_ = _tmp47_;
					if (_tmp48_ != NULL) {
						ValaProperty* _tmp49_;
						ValaProperty* _tmp50_;
						ValaProperty* _tmp51_;
						ValaProperty* _tmp52_;
						_tmp49_ = prop;
						_tmp50_ = vala_property_get_base_interface_property (_tmp49_);
						_tmp51_ = _tmp50_;
						_tmp52_ = prop;
						_tmp45_ = _tmp51_ != _tmp52_;
					} else {
						_tmp45_ = FALSE;
					}
					if (_tmp45_) {
						ValaProperty* _tmp53_;
						ValaProperty* _tmp54_;
						ValaProperty* _tmp55_;
						_tmp53_ = prop;
						_tmp54_ = vala_property_get_base_interface_property (_tmp53_);
						_tmp55_ = _tmp54_;
						result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp55_);
						return result;
					}
				}
			} else {
				ValaCodeNode* _tmp56_;
				_tmp56_ = self->priv->node;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp56_, VALA_TYPE_PROPERTY_ACCESSOR)) {
					ValaCodeNode* _tmp57_;
					ValaProperty* _tmp58_;
					ValaProperty* _tmp59_;
					_tmp57_ = self->priv->node;
					_tmp58_ = vala_property_accessor_get_prop (G_TYPE_CHECK_INSTANCE_CAST (_tmp57_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
					_tmp59_ = _tmp58_;
					result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp59_);
					return result;
				}
			}
		}
	}
	result = TRUE;
	return result;
}

static gboolean
vala_ccode_attribute_get_default_array_null_terminated (ValaCCodeAttribute* self)
{
	ValaCodeNode* _tmp0_;
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->priv->node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_PARAMETER)) {
		ValaParameter* param = NULL;
		ValaCodeNode* _tmp1_;
		ValaParameter* _tmp2_;
		ValaParameter* _tmp3_;
		ValaParameter* _tmp4_;
		_tmp1_ = self->priv->node;
		param = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_PARAMETER, ValaParameter);
		_tmp2_ = param;
		_tmp3_ = vala_parameter_get_base_parameter (_tmp2_);
		_tmp4_ = _tmp3_;
		if (_tmp4_ != NULL) {
			ValaParameter* _tmp5_;
			ValaParameter* _tmp6_;
			ValaParameter* _tmp7_;
			_tmp5_ = param;
			_tmp6_ = vala_parameter_get_base_parameter (_tmp5_);
			_tmp7_ = _tmp6_;
			result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp7_);
			return result;
		}
	} else {
		ValaCodeNode* _tmp8_;
		_tmp8_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_METHOD)) {
			ValaMethod* method = NULL;
			ValaCodeNode* _tmp9_;
			gboolean _tmp10_ = FALSE;
			ValaMethod* _tmp11_;
			ValaMethod* _tmp12_;
			ValaMethod* _tmp13_;
			_tmp9_ = self->priv->node;
			method = G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_METHOD, ValaMethod);
			_tmp11_ = method;
			_tmp12_ = vala_method_get_base_method (_tmp11_);
			_tmp13_ = _tmp12_;
			if (_tmp13_ != NULL) {
				ValaMethod* _tmp14_;
				ValaMethod* _tmp15_;
				ValaMethod* _tmp16_;
				ValaMethod* _tmp17_;
				_tmp14_ = method;
				_tmp15_ = vala_method_get_base_method (_tmp14_);
				_tmp16_ = _tmp15_;
				_tmp17_ = method;
				_tmp10_ = _tmp16_ != _tmp17_;
			} else {
				_tmp10_ = FALSE;
			}
			if (_tmp10_) {
				ValaMethod* _tmp18_;
				ValaMethod* _tmp19_;
				ValaMethod* _tmp20_;
				_tmp18_ = method;
				_tmp19_ = vala_method_get_base_method (_tmp18_);
				_tmp20_ = _tmp19_;
				result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp20_);
				return result;
			} else {
				gboolean _tmp21_ = FALSE;
				ValaMethod* _tmp22_;
				ValaMethod* _tmp23_;
				ValaMethod* _tmp24_;
				_tmp22_ = method;
				_tmp23_ = vala_method_get_base_interface_method (_tmp22_);
				_tmp24_ = _tmp23_;
				if (_tmp24_ != NULL) {
					ValaMethod* _tmp25_;
					ValaMethod* _tmp26_;
					ValaMethod* _tmp27_;
					ValaMethod* _tmp28_;
					_tmp25_ = method;
					_tmp26_ = vala_method_get_base_interface_method (_tmp25_);
					_tmp27_ = _tmp26_;
					_tmp28_ = method;
					_tmp21_ = _tmp27_ != _tmp28_;
				} else {
					_tmp21_ = FALSE;
				}
				if (_tmp21_) {
					ValaMethod* _tmp29_;
					ValaMethod* _tmp30_;
					ValaMethod* _tmp31_;
					_tmp29_ = method;
					_tmp30_ = vala_method_get_base_interface_method (_tmp29_);
					_tmp31_ = _tmp30_;
					result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp31_);
					return result;
				}
			}
		} else {
			ValaCodeNode* _tmp32_;
			_tmp32_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_PROPERTY)) {
				ValaProperty* prop = NULL;
				ValaCodeNode* _tmp33_;
				gboolean _tmp34_ = FALSE;
				ValaProperty* _tmp35_;
				ValaProperty* _tmp36_;
				ValaProperty* _tmp37_;
				_tmp33_ = self->priv->node;
				prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_PROPERTY, ValaProperty);
				_tmp35_ = prop;
				_tmp36_ = vala_property_get_base_property (_tmp35_);
				_tmp37_ = _tmp36_;
				if (_tmp37_ != NULL) {
					ValaProperty* _tmp38_;
					ValaProperty* _tmp39_;
					ValaProperty* _tmp40_;
					ValaProperty* _tmp41_;
					_tmp38_ = prop;
					_tmp39_ = vala_property_get_base_property (_tmp38_);
					_tmp40_ = _tmp39_;
					_tmp41_ = prop;
					_tmp34_ = _tmp40_ != _tmp41_;
				} else {
					_tmp34_ = FALSE;
				}
				if (_tmp34_) {
					ValaProperty* _tmp42_;
					ValaProperty* _tmp43_;
					ValaProperty* _tmp44_;
					_tmp42_ = prop;
					_tmp43_ = vala_property_get_base_property (_tmp42_);
					_tmp44_ = _tmp43_;
					result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp44_);
					return result;
				} else {
					gboolean _tmp45_ = FALSE;
					ValaProperty* _tmp46_;
					ValaProperty* _tmp47_;
					ValaProperty* _tmp48_;
					_tmp46_ = prop;
					_tmp47_ = vala_property_get_base_interface_property (_tmp46_);
					_tmp48_ = _tmp47_;
					if (_tmp48_ != NULL) {
						ValaProperty* _tmp49_;
						ValaProperty* _tmp50_;
						ValaProperty* _tmp51_;
						ValaProperty* _tmp52_;
						_tmp49_ = prop;
						_tmp50_ = vala_property_get_base_interface_property (_tmp49_);
						_tmp51_ = _tmp50_;
						_tmp52_ = prop;
						_tmp45_ = _tmp51_ != _tmp52_;
					} else {
						_tmp45_ = FALSE;
					}
					if (_tmp45_) {
						ValaProperty* _tmp53_;
						ValaProperty* _tmp54_;
						ValaProperty* _tmp55_;
						_tmp53_ = prop;
						_tmp54_ = vala_property_get_base_interface_property (_tmp53_);
						_tmp55_ = _tmp54_;
						result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp55_);
						return result;
					}
				}
			} else {
				ValaCodeNode* _tmp56_;
				_tmp56_ = self->priv->node;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp56_, VALA_TYPE_PROPERTY_ACCESSOR)) {
					ValaCodeNode* _tmp57_;
					ValaProperty* _tmp58_;
					ValaProperty* _tmp59_;
					_tmp57_ = self->priv->node;
					_tmp58_ = vala_property_accessor_get_prop (G_TYPE_CHECK_INSTANCE_CAST (_tmp57_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
					_tmp59_ = _tmp58_;
					result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp59_);
					return result;
				}
			}
		}
	}
	result = FALSE;
	return result;
}

static gchar*
vala_ccode_attribute_get_default_array_length_type (ValaCCodeAttribute* self)
{
	gboolean _tmp0_ = FALSE;
	ValaCodeNode* _tmp1_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp1_ = self->priv->node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_FIELD)) {
		_tmp0_ = TRUE;
	} else {
		ValaCodeNode* _tmp2_;
		_tmp2_ = self->priv->node;
		_tmp0_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_PARAMETER);
	}
	if (_tmp0_) {
		ValaCodeNode* _tmp3_;
		ValaCodeNode* _tmp12_;
		ValaDataType* _tmp13_;
		ValaDataType* _tmp14_;
		gchar* _tmp15_;
		_tmp3_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_PARAMETER)) {
			ValaParameter* param = NULL;
			ValaCodeNode* _tmp4_;
			ValaParameter* _tmp5_;
			ValaParameter* _tmp6_;
			ValaParameter* _tmp7_;
			_tmp4_ = self->priv->node;
			param = G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_PARAMETER, ValaParameter);
			_tmp5_ = param;
			_tmp6_ = vala_parameter_get_base_parameter (_tmp5_);
			_tmp7_ = _tmp6_;
			if (_tmp7_ != NULL) {
				ValaParameter* _tmp8_;
				ValaParameter* _tmp9_;
				ValaParameter* _tmp10_;
				gchar* _tmp11_;
				_tmp8_ = param;
				_tmp9_ = vala_parameter_get_base_parameter (_tmp8_);
				_tmp10_ = _tmp9_;
				_tmp11_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp10_);
				result = _tmp11_;
				return result;
			}
		}
		_tmp12_ = self->priv->node;
		_tmp13_ = vala_variable_get_variable_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALA_TYPE_VARIABLE, ValaVariable));
		_tmp14_ = _tmp13_;
		_tmp15_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp14_);
		result = _tmp15_;
		return result;
	} else {
		gboolean _tmp16_ = FALSE;
		ValaCodeNode* _tmp17_;
		_tmp17_ = self->priv->node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_METHOD)) {
			_tmp16_ = TRUE;
		} else {
			ValaCodeNode* _tmp18_;
			_tmp18_ = self->priv->node;
			_tmp16_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp18_, VALA_TYPE_DELEGATE);
		}
		if (_tmp16_) {
			ValaCodeNode* _tmp19_;
			ValaCodeNode* _tmp45_;
			ValaDataType* _tmp46_;
			ValaDataType* _tmp47_;
			gchar* _tmp48_;
			_tmp19_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp19_, VALA_TYPE_METHOD)) {
				ValaMethod* method = NULL;
				ValaCodeNode* _tmp20_;
				gboolean _tmp21_ = FALSE;
				ValaMethod* _tmp22_;
				ValaMethod* _tmp23_;
				ValaMethod* _tmp24_;
				_tmp20_ = self->priv->node;
				method = G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_METHOD, ValaMethod);
				_tmp22_ = method;
				_tmp23_ = vala_method_get_base_method (_tmp22_);
				_tmp24_ = _tmp23_;
				if (_tmp24_ != NULL) {
					ValaMethod* _tmp25_;
					ValaMethod* _tmp26_;
					ValaMethod* _tmp27_;
					ValaMethod* _tmp28_;
					_tmp25_ = method;
					_tmp26_ = vala_method_get_base_method (_tmp25_);
					_tmp27_ = _tmp26_;
					_tmp28_ = method;
					_tmp21_ = _tmp27_ != _tmp28_;
				} else {
					_tmp21_ = FALSE;
				}
				if (_tmp21_) {
					ValaMethod* _tmp29_;
					ValaMethod* _tmp30_;
					ValaMethod* _tmp31_;
					gchar* _tmp32_;
					_tmp29_ = method;
					_tmp30_ = vala_method_get_base_method (_tmp29_);
					_tmp31_ = _tmp30_;
					_tmp32_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp31_);
					result = _tmp32_;
					return result;
				} else {
					gboolean _tmp33_ = FALSE;
					ValaMethod* _tmp34_;
					ValaMethod* _tmp35_;
					ValaMethod* _tmp36_;
					_tmp34_ = method;
					_tmp35_ = vala_method_get_base_interface_method (_tmp34_);
					_tmp36_ = _tmp35_;
					if (_tmp36_ != NULL) {
						ValaMethod* _tmp37_;
						ValaMethod* _tmp38_;
						ValaMethod* _tmp39_;
						ValaMethod* _tmp40_;
						_tmp37_ = method;
						_tmp38_ = vala_method_get_base_interface_method (_tmp37_);
						_tmp39_ = _tmp38_;
						_tmp40_ = method;
						_tmp33_ = _tmp39_ != _tmp40_;
					} else {
						_tmp33_ = FALSE;
					}
					if (_tmp33_) {
						ValaMethod* _tmp41_;
						ValaMethod* _tmp42_;
						ValaMethod* _tmp43_;
						gchar* _tmp44_;
						_tmp41_ = method;
						_tmp42_ = vala_method_get_base_interface_method (_tmp41_);
						_tmp43_ = _tmp42_;
						_tmp44_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp43_);
						result = _tmp44_;
						return result;
					}
				}
			}
			_tmp45_ = self->priv->node;
			_tmp46_ = vala_callable_get_return_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp45_, VALA_TYPE_CALLABLE, ValaCallable));
			_tmp47_ = _tmp46_;
			_tmp48_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp47_);
			result = _tmp48_;
			return result;
		} else {
			ValaCodeNode* _tmp49_;
			_tmp49_ = self->priv->node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp49_, VALA_TYPE_PROPERTY)) {
				ValaProperty* prop = NULL;
				ValaCodeNode* _tmp50_;
				gboolean _tmp51_ = FALSE;
				ValaProperty* _tmp52_;
				ValaProperty* _tmp53_;
				ValaProperty* _tmp54_;
				_tmp50_ = self->priv->node;
				prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp50_, VALA_TYPE_PROPERTY, ValaProperty);
				_tmp52_ = prop;
				_tmp53_ = vala_property_get_base_property (_tmp52_);
				_tmp54_ = _tmp53_;
				if (_tmp54_ != NULL) {
					ValaProperty* _tmp55_;
					ValaProperty* _tmp56_;
					ValaProperty* _tmp57_;
					ValaProperty* _tmp58_;
					_tmp55_ = prop;
					_tmp56_ = vala_property_get_base_property (_tmp55_);
					_tmp57_ = _tmp56_;
					_tmp58_ = prop;
					_tmp51_ = _tmp57_ != _tmp58_;
				} else {
					_tmp51_ = FALSE;
				}
				if (_tmp51_) {
					ValaProperty* _tmp59_;
					ValaProperty* _tmp60_;
					ValaProperty* _tmp61_;
					gchar* _tmp62_;
					_tmp59_ = prop;
					_tmp60_ = vala_property_get_base_property (_tmp59_);
					_tmp61_ = _tmp60_;
					_tmp62_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp61_);
					result = _tmp62_;
					return result;
				} else {
					gboolean _tmp63_ = FALSE;
					ValaProperty* _tmp64_;
					ValaProperty* _tmp65_;
					ValaProperty* _tmp66_;
					_tmp64_ = prop;
					_tmp65_ = vala_property_get_base_interface_property (_tmp64_);
					_tmp66_ = _tmp65_;
					if (_tmp66_ != NULL) {
						ValaProperty* _tmp67_;
						ValaProperty* _tmp68_;
						ValaProperty* _tmp69_;
						ValaProperty* _tmp70_;
						_tmp67_ = prop;
						_tmp68_ = vala_property_get_base_interface_property (_tmp67_);
						_tmp69_ = _tmp68_;
						_tmp70_ = prop;
						_tmp63_ = _tmp69_ != _tmp70_;
					} else {
						_tmp63_ = FALSE;
					}
					if (_tmp63_) {
						ValaProperty* _tmp71_;
						ValaProperty* _tmp72_;
						ValaProperty* _tmp73_;
						gchar* _tmp74_;
						_tmp71_ = prop;
						_tmp72_ = vala_property_get_base_interface_property (_tmp71_);
						_tmp73_ = _tmp72_;
						_tmp74_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp73_);
						result = _tmp74_;
						return result;
					} else {
						ValaProperty* _tmp75_;
						ValaDataType* _tmp76_;
						ValaDataType* _tmp77_;
						gchar* _tmp78_;
						_tmp75_ = prop;
						_tmp76_ = vala_property_get_property_type (_tmp75_);
						_tmp77_ = _tmp76_;
						_tmp78_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp77_);
						result = _tmp78_;
						return result;
					}
				}
			} else {
				ValaCodeNode* _tmp79_;
				_tmp79_ = self->priv->node;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp79_, VALA_TYPE_PROPERTY_ACCESSOR)) {
					ValaCodeNode* _tmp80_;
					ValaProperty* _tmp81_;
					ValaProperty* _tmp82_;
					gchar* _tmp83_;
					_tmp80_ = self->priv->node;
					_tmp81_ = vala_property_accessor_get_prop (G_TYPE_CHECK_INSTANCE_CAST (_tmp80_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
					_tmp82_ = _tmp81_;
					_tmp83_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp82_);
					result = _tmp83_;
					return result;
				} else {
					ValaCodeNode* _tmp84_;
					ValaSourceReference* _tmp85_;
					ValaSourceReference* _tmp86_;
					gchar* _tmp87_;
					_tmp84_ = self->priv->node;
					_tmp85_ = vala_code_node_get_source_reference (_tmp84_);
					_tmp86_ = _tmp85_;
					vala_report_error (_tmp86_, "`CCode.array_length_type' not supported");
					_tmp87_ = g_strdup ("");
					result = _tmp87_;
					return result;
				}
			}
		}
	}
}

static void
vala_ccode_attribute_class_init (ValaCCodeAttributeClass * klass,
                                 gpointer klass_data)
{
	vala_ccode_attribute_parent_class = g_type_class_peek_parent (klass);
	((ValaAttributeCacheClass *) klass)->finalize = vala_ccode_attribute_finalize;
	g_type_class_adjust_private_offset (klass, &ValaCCodeAttribute_private_offset);
}

static void
vala_ccode_attribute_instance_init (ValaCCodeAttribute * self,
                                    gpointer klass)
{
	self->priv = vala_ccode_attribute_get_instance_private (self);
	self->priv->ctype_set = FALSE;
}

static void
vala_ccode_attribute_finalize (ValaAttributeCache * obj)
{
	ValaCCodeAttribute * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_CCODE_ATTRIBUTE, ValaCCodeAttribute);
	_vala_code_node_unref0 (self->priv->ccode);
	_g_free0 (self->priv->_array_length_name);
	_g_free0 (self->priv->_array_length_expr);
	_g_free0 (self->priv->_name);
	_g_free0 (self->priv->_const_name);
	_g_free0 (self->priv->_type_name);
	_g_free0 (self->priv->_feature_test_macros);
	_g_free0 (self->priv->_header_filenames);
	_g_free0 (self->priv->_prefix);
	_g_free0 (self->priv->_lower_case_prefix);
	_g_free0 (self->priv->_lower_case_suffix);
	_g_free0 (self->priv->_ref_function);
	_g_free0 (self->priv->_ref_function_void);
	_g_free0 (self->priv->_unref_function);
	_g_free0 (self->priv->_ref_sink_function);
	_g_free0 (self->priv->_copy_function);
	_g_free0 (self->priv->_destroy_function);
	_g_free0 (self->priv->_dup_function);
	_g_free0 (self->priv->_free_function);
	_g_free0 (self->priv->_free_function_address_of);
	_g_free0 (self->priv->_type_id);
	_g_free0 (self->priv->_marshaller_type_name);
	_g_free0 (self->priv->_get_value_function);
	_g_free0 (self->priv->_set_value_function);
	_g_free0 (self->priv->_take_value_function);
	_g_free0 (self->priv->_param_spec_function);
	_g_free0 (self->priv->_default_value);
	_g_free0 (self->priv->_default_value_on_error);
	_g_free0 (self->priv->_pos);
	_g_free0 (self->priv->_vfunc_name);
	_g_free0 (self->priv->_finish_name);
	_g_free0 (self->priv->_finish_vfunc_name);
	_g_free0 (self->priv->_finish_real_name);
	_g_free0 (self->priv->_finish_instance);
	_g_free0 (self->priv->_real_name);
	_g_free0 (self->priv->_delegate_target);
	_g_free0 (self->priv->_delegate_target_name);
	_g_free0 (self->priv->_delegate_target_destroy_notify_name);
	_g_free0 (self->priv->_ctype);
	_g_free0 (self->priv->_array_length);
	_g_free0 (self->priv->_array_length_type);
	_g_free0 (self->priv->_array_null_terminated);
	_g_free0 (self->priv->_sentinel);
	VALA_ATTRIBUTE_CACHE_CLASS (vala_ccode_attribute_parent_class)->finalize (obj);
}

/**
 * Cache for the CCode attribute
 */
static GType
vala_ccode_attribute_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeAttributeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_attribute_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeAttribute), 0, (GInstanceInitFunc) vala_ccode_attribute_instance_init, NULL };
	GType vala_ccode_attribute_type_id;
	vala_ccode_attribute_type_id = g_type_register_static (VALA_TYPE_ATTRIBUTE_CACHE, "ValaCCodeAttribute", &g_define_type_info, 0);
	ValaCCodeAttribute_private_offset = g_type_add_instance_private (vala_ccode_attribute_type_id, sizeof (ValaCCodeAttributePrivate));
	return vala_ccode_attribute_type_id;
}

GType
vala_ccode_attribute_get_type (void)
{
	static volatile gsize vala_ccode_attribute_type_id__once = 0;
	if (g_once_init_enter (&vala_ccode_attribute_type_id__once)) {
		GType vala_ccode_attribute_type_id;
		vala_ccode_attribute_type_id = vala_ccode_attribute_get_type_once ();
		g_once_init_leave (&vala_ccode_attribute_type_id__once, vala_ccode_attribute_type_id);
	}
	return vala_ccode_attribute_type_id__once;
}

