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

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

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

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

#include <glib.h>
#include <glib-object.h>
#include <vala.h>
#include <valaccode.h>
#include <valagee.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <glib/gstdio.h>
#include <float.h>
#include <math.h>
#include <gobject/gvaluecollector.h>


#define VALA_TYPE_CCODE_BASE_MODULE (vala_ccode_base_module_get_type ())
#define VALA_CCODE_BASE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModule))
#define VALA_CCODE_BASE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModuleClass))
#define VALA_IS_CCODE_BASE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_BASE_MODULE))
#define VALA_IS_CCODE_BASE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_BASE_MODULE))
#define VALA_CCODE_BASE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModuleClass))

typedef struct _ValaCCodeBaseModule ValaCCodeBaseModule;
typedef struct _ValaCCodeBaseModuleClass ValaCCodeBaseModuleClass;
typedef struct _ValaCCodeBaseModulePrivate ValaCCodeBaseModulePrivate;

#define VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT (vala_ccode_base_module_emit_context_get_type ())
#define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContext))
#define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass))
#define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT))
#define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT))
#define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass))

typedef struct _ValaCCodeBaseModuleEmitContext ValaCCodeBaseModuleEmitContext;
typedef struct _ValaCCodeBaseModuleEmitContextClass ValaCCodeBaseModuleEmitContextClass;
#define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _vala_ccode_base_module_emit_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_base_module_emit_context_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
#define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL)))
#define _vala_ccode_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_file_unref (var), NULL)))
#define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _vala_source_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_file_unref (var), NULL)))
#define _fclose0(var) ((var == NULL) ? NULL : (var = (fclose (var), NULL)))
typedef struct _ValaCCodeBaseModuleEmitContextPrivate ValaCCodeBaseModuleEmitContextPrivate;
#define _vala_comment_unref0(var) ((var == NULL) ? NULL : (var = (vala_comment_unref (var), NULL)))
#define _vala_ccode_declarator_suffix_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_declarator_suffix_unref (var), NULL)))
#define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL)))

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

typedef struct _ValaGLibValue ValaGLibValue;
typedef struct _ValaGLibValueClass ValaGLibValueClass;
typedef struct _ValaGLibValuePrivate ValaGLibValuePrivate;
#define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

#define VALA_TYPE_CCODE_ATTRIBUTE (vala_ccode_attribute_get_type ())
#define VALA_CCODE_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ATTRIBUTE, ValaCCodeAttribute))
#define VALA_CCODE_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ATTRIBUTE, ValaCCodeAttributeClass))
#define VALA_IS_CCODE_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ATTRIBUTE))
#define VALA_IS_CCODE_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ATTRIBUTE))
#define VALA_CCODE_ATTRIBUTE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ATTRIBUTE, ValaCCodeAttributeClass))

typedef struct _ValaCCodeAttribute ValaCCodeAttribute;
typedef struct _ValaCCodeAttributeClass ValaCCodeAttributeClass;
#define _vala_attribute_cache_unref0(var) ((var == NULL) ? NULL : (var = (vala_attribute_cache_unref (var), NULL)))
typedef struct _ValaCCodeBaseModuleParamSpecEmitContext ValaCCodeBaseModuleParamSpecEmitContext;
#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 _ValaCCodeBaseModule {
	ValaCodeGenerator parent_instance;
	ValaCCodeBaseModulePrivate * priv;
	ValaSymbol* root_symbol;
	ValaCCodeBaseModuleEmitContext* emit_context;
	ValaCCodeLineDirective* current_line;
	ValaCCodeFile* header_file;
	ValaCCodeFile* internal_header_file;
	ValaCCodeFile* cfile;
	ValaCCodeBaseModuleEmitContext* class_init_context;
	ValaCCodeBaseModuleEmitContext* base_init_context;
	ValaCCodeBaseModuleEmitContext* class_finalize_context;
	ValaCCodeBaseModuleEmitContext* base_finalize_context;
	ValaCCodeBaseModuleEmitContext* instance_init_context;
	ValaCCodeBaseModuleEmitContext* instance_finalize_context;
	ValaCCodeStruct* param_spec_struct;
	ValaCCodeStruct* closure_struct;
	ValaCCodeEnum* prop_enum;
	ValaCCodeEnum* signal_enum;
	ValaSet* user_marshal_set;
	ValaSet* predefined_marshal_set;
	gint next_regex_id;
	gint next_coroutine_state G_GNUC_DEPRECATED;
	ValaDataType* void_type;
	ValaDataType* bool_type;
	ValaDataType* char_type;
	ValaDataType* uchar_type;
	ValaDataType* unichar_type;
	ValaDataType* short_type;
	ValaDataType* ushort_type;
	ValaDataType* int_type;
	ValaDataType* uint_type;
	ValaDataType* long_type;
	ValaDataType* ulong_type;
	ValaDataType* int8_type;
	ValaDataType* uint8_type;
	ValaDataType* int16_type;
	ValaDataType* uint16_type;
	ValaDataType* int32_type;
	ValaDataType* uint32_type;
	ValaDataType* int64_type;
	ValaDataType* uint64_type;
	ValaDataType* string_type;
	ValaDataType* regex_type;
	ValaDataType* float_type;
	ValaDataType* double_type;
	ValaTypeSymbol* gtype_type;
	ValaTypeSymbol* gobject_type;
	ValaErrorType* gerror_type;
	ValaClass* glist_type;
	ValaClass* gslist_type;
	ValaClass* gnode_type;
	ValaClass* gqueue_type;
	ValaClass* gvaluearray_type;
	ValaTypeSymbol* gstringbuilder_type;
	ValaTypeSymbol* garray_type;
	ValaTypeSymbol* gbytearray_type;
	ValaTypeSymbol* gptrarray_type;
	ValaTypeSymbol* gthreadpool_type;
	ValaDataType* gdestroynotify_type;
	ValaDataType* gquark_type;
	ValaStruct* gvalue_type;
	ValaClass* gvariant_type;
	ValaStruct* mutex_type;
	ValaStruct* gmutex_type;
	ValaStruct* grecmutex_type;
	ValaStruct* grwlock_type;
	ValaStruct* gcond_type;
	ValaClass* gsource_type;
	ValaTypeSymbol* type_module_type;
	ValaTypeSymbol* dbus_proxy_type;
	ValaClass* gtk_widget_type;
	gboolean in_plugin;
	gchar* module_init_param_name;
	gboolean gvaluecollector_h_needed;
	gboolean requires_assert;
	gboolean requires_array_free;
	gboolean requires_array_move;
	gboolean requires_array_length;
	gboolean requires_clear_mutex;
	ValaSet* wrappers;
};

struct _ValaCCodeBaseModuleClass {
	ValaCodeGeneratorClass parent_class;
	void (*append_vala_array_free) (ValaCCodeBaseModule* self);
	void (*append_vala_array_move) (ValaCCodeBaseModule* self);
	void (*append_vala_array_length) (ValaCCodeBaseModule* self);
	gboolean (*generate_enum_declaration) (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space);
	void (*generate_class_struct_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
	void (*generate_struct_declaration) (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space);
	void (*generate_delegate_declaration) (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space);
	void (*generate_cparameters) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);
	ValaCCodeExpression* (*get_dup_func_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);
	gchar* (*append_struct_array_free) (ValaCCodeBaseModule* self, ValaStruct* st);
	ValaCCodeExpression* (*destroy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
	void (*append_scope_free) (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);
	ValaTargetValue* (*get_local_cvalue) (ValaCCodeBaseModule* self, ValaLocalVariable* local);
	ValaTargetValue* (*get_parameter_cvalue) (ValaCCodeBaseModule* self, ValaParameter* param);
	ValaTargetValue* (*get_field_cvalue) (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance);
	ValaTargetValue* (*load_variable) (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value);
	ValaTargetValue* (*load_this_parameter) (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
	void (*store_value) (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
	gchar* (*get_delegate_target_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
	ValaCCodeExpression* (*get_delegate_target_cexpression) (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression* * delegate_target_destroy_notify);
	ValaCCodeExpression* (*get_delegate_target_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
	ValaCCodeExpression* (*get_delegate_target_destroy_notify_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
	gchar* (*get_delegate_target_destroy_notify_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
	ValaTargetValue* (*copy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
	void (*generate_class_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
	void (*generate_interface_declaration) (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space);
	void (*generate_method_declaration) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
	void (*generate_error_domain_declaration) (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);
	ValaCCodeExpression* (*deserialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail);
	ValaCCodeExpression* (*serialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr);
	ValaCCodeExpression* (*get_implicit_cast_expression) (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node);
	void (*create_type_check_statement) (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);
	gboolean (*is_gobject_property) (ValaCCodeBaseModule* self, ValaProperty* prop);
	void (*generate_dynamic_method_wrapper) (ValaCCodeBaseModule* self, ValaDynamicMethod* method);
	gboolean (*method_has_wrapper) (ValaCCodeBaseModule* self, ValaMethod* method);
	ValaCCodeFunctionCall* (*get_param_spec) (ValaCCodeBaseModule* self, ValaProperty* prop);
	ValaCCodeExpression* (*get_signal_creation) (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type);
	void (*register_dbus_info) (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable);
	gchar* (*get_dynamic_property_getter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
	gchar* (*get_dynamic_property_setter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
	gchar* (*get_dynamic_signal_cname) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_dynamic_signal_connect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_dynamic_signal_connect_after_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_dynamic_signal_disconnect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_array_length_cname) (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim);
	gchar* (*get_parameter_array_length_cname) (ValaCCodeBaseModule* self, ValaParameter* param, gint dim);
	ValaCCodeExpression* (*get_array_length_cexpression) (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim);
	ValaCCodeExpression* (*get_array_length_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim);
	gchar* (*get_array_size_cname) (ValaCCodeBaseModule* self, const gchar* array_cname);
	void (*add_simple_check) (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);
	gchar* (*generate_ready_function) (ValaCCodeBaseModule* self, ValaMethod* m);
};

struct _ValaCCodeBaseModulePrivate {
	ValaCodeContext* _context;
	ValaList* emit_context_stack;
	ValaList* line_directive_stack;
	ValaSet* reserved_identifiers;
	gint next_block_id;
	ValaMap* block_map;
	ValaSet* generated_external_symbols;
	gint next_variant_function_id;
};

struct _ValaCCodeBaseModuleEmitContext {
	GTypeInstance parent_instance;
	volatile int ref_count;
	ValaCCodeBaseModuleEmitContextPrivate * priv;
	ValaSymbol* current_symbol;
	ValaArrayList* symbol_stack;
	ValaTryStatement* current_try;
	ValaCatchClause* current_catch;
	ValaCCodeFunction* ccode;
	ValaArrayList* ccode_stack;
	ValaArrayList* temp_ref_values;
	gint next_temp_var_id;
	gboolean current_method_inner_error;
	gboolean current_method_return;
	ValaMap* variable_name_map;
	ValaMap* closure_variable_count_map;
	ValaMap* closure_variable_clash_map;
	gint next_coroutine_state;
};

struct _ValaCCodeBaseModuleEmitContextClass {
	GTypeClass parent_class;
	void (*finalize) (ValaCCodeBaseModuleEmitContext *self);
};

struct _ValaGLibValue {
	ValaTargetValue parent_instance;
	ValaGLibValuePrivate * priv;
	ValaCCodeExpression* cvalue;
	gboolean lvalue;
	gboolean non_null;
	gchar* ctype;
	ValaList* array_length_cvalues;
	ValaCCodeExpression* array_size_cvalue;
	gboolean array_null_terminated;
	ValaCCodeExpression* array_length_cexpr;
	ValaCCodeExpression* delegate_target_cvalue;
	ValaCCodeExpression* delegate_target_destroy_notify_cvalue;
};

struct _ValaGLibValueClass {
	ValaTargetValueClass parent_class;
};

struct _ValaCCodeBaseModuleParamSpecEmitContext {
	GParamSpec parent_instance;
};


static gpointer vala_ccode_base_module_parent_class = NULL;
extern gint vala_ccode_base_module_ccode_attribute_cache_index;
gint vala_ccode_base_module_ccode_attribute_cache_index = 0;
static gpointer vala_ccode_base_module_emit_context_parent_class = NULL;
static gpointer vala_glib_value_parent_class = NULL;

GType vala_ccode_base_module_get_type (void) G_GNUC_CONST;
gpointer vala_ccode_base_module_emit_context_ref (gpointer instance);
void vala_ccode_base_module_emit_context_unref (gpointer instance);
GParamSpec* vala_ccode_base_module_param_spec_emit_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_ccode_base_module_value_set_emit_context (GValue* value, gpointer v_object);
void vala_ccode_base_module_value_take_emit_context (GValue* value, gpointer v_object);
gpointer vala_ccode_base_module_value_get_emit_context (const GValue* value);
GType vala_ccode_base_module_emit_context_get_type (void) G_GNUC_CONST;
#define VALA_CCODE_BASE_MODULE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModulePrivate))
enum  {
	VALA_CCODE_BASE_MODULE_DUMMY_PROPERTY
};
ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_new (ValaSymbol* symbol);
ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_construct (GType object_type, ValaSymbol* symbol);
gboolean vala_ccode_base_module_is_in_coroutine (ValaCCodeBaseModule* self);
ValaMethod* vala_ccode_base_module_get_current_method (ValaCCodeBaseModule* self);
gboolean vala_ccode_base_module_is_in_constructor (ValaCCodeBaseModule* self);
ValaSymbol* vala_ccode_base_module_get_current_symbol (ValaCCodeBaseModule* self);
gboolean vala_ccode_base_module_is_in_destructor (ValaCCodeBaseModule* self);
ValaBlock* vala_ccode_base_module_next_closure_block (ValaCCodeBaseModule* self, ValaSymbol* sym);
ValaCCodeBaseModule* vala_ccode_base_module_construct (GType object_type);
static void vala_ccode_base_module_real_emit (ValaCodeGenerator* base, ValaCodeContext* context);
void vala_ccode_base_module_set_context (ValaCCodeBaseModule* self, ValaCodeContext* value);
void vala_ccode_base_module_push_context (ValaCCodeBaseModule* self, ValaCCodeBaseModuleEmitContext* emit_context);
ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);
void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self);
void vala_ccode_base_module_push_line (ValaCCodeBaseModule* self, ValaSourceReference* source_reference);
void vala_ccode_base_module_pop_line (ValaCCodeBaseModule* self);
void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func);
void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self);
gboolean vala_ccode_base_module_add_symbol_declaration (ValaCCodeBaseModule* self, ValaCCodeFile* decl_space, ValaSymbol* sym, const gchar* name);
gchar* vala_ccode_base_module_get_ccode_header_filenames (ValaSymbol* sym);
ValaCCodeIdentifier* vala_ccode_base_module_get_value_setter_function (ValaCCodeBaseModule* self, ValaDataType* type_reference);
gchar* vala_ccode_base_module_get_ccode_set_value_function (ValaCodeNode* sym);
ValaCCodeIdentifier* vala_ccode_base_module_get_value_taker_function (ValaCCodeBaseModule* self, ValaDataType* type_reference);
gchar* vala_ccode_base_module_get_ccode_take_value_function (ValaCodeNode* sym);
static ValaCCodeIdentifier* vala_ccode_base_module_get_value_getter_function (ValaCCodeBaseModule* self, ValaDataType* type_reference);
gchar* vala_ccode_base_module_get_ccode_get_value_function (ValaCodeNode* sym);
void vala_ccode_base_module_append_vala_array_free (ValaCCodeBaseModule* self);
static void vala_ccode_base_module_real_append_vala_array_free (ValaCCodeBaseModule* self);
void vala_ccode_base_module_append_vala_array_move (ValaCCodeBaseModule* self);
static void vala_ccode_base_module_real_append_vala_array_move (ValaCCodeBaseModule* self);
void vala_ccode_base_module_append_vala_array_length (ValaCCodeBaseModule* self);
static void vala_ccode_base_module_real_append_vala_array_length (ValaCCodeBaseModule* self);
void vala_ccode_base_module_append_vala_clear_mutex (ValaCCodeBaseModule* self, const gchar* typename, const gchar* funcprefix);
static void vala_ccode_base_module_real_visit_source_file (ValaCodeVisitor* base, ValaSourceFile* source_file);
ValaCodeContext* vala_ccode_base_module_get_context (ValaCCodeBaseModule* self);
gboolean vala_ccode_base_module_generate_enum_declaration (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space);
static gboolean vala_ccode_base_module_real_generate_enum_declaration (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space);
gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr);
gboolean vala_ccode_base_module_get_ccode_has_type_id (ValaTypeSymbol* sym);
gchar* vala_ccode_base_module_get_ccode_lower_case_name (ValaCodeNode* node, const gchar* infix);
gchar* vala_ccode_base_module_get_ccode_type_id (ValaCodeNode* node);
static void vala_ccode_base_module_real_visit_enum (ValaCodeVisitor* base, ValaEnum* en);
void vala_ccode_base_module_visit_member (ValaCCodeBaseModule* self, ValaSymbol* m);
gchar* vala_ccode_base_module_get_symbol_lock_name (ValaCCodeBaseModule* self, const gchar* symname);
gchar* vala_ccode_base_module_get_ccode_upper_case_name (ValaSymbol* sym, const gchar* infix);
void vala_ccode_base_module_generate_constant_declaration (ValaCCodeBaseModule* self, ValaConstant* c, ValaCCodeFile* decl_space, gboolean definition);
void vala_ccode_base_module_generate_type_declaration (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeFile* decl_space);
gchar* vala_ccode_base_module_get_ccode_const_name (ValaCodeNode* node);
static void vala_ccode_base_module_real_visit_constant (ValaCodeVisitor* base, ValaConstant* c);
void vala_ccode_base_module_generate_field_declaration (ValaCCodeBaseModule* self, ValaField* f, ValaCCodeFile* decl_space);
ValaCCodeDeclaratorSuffix* vala_ccode_base_module_get_ccode_declarator_suffix (ValaCCodeBaseModule* self, ValaDataType* type);
gboolean vala_ccode_base_module_get_ccode_array_length (ValaCodeNode* node);
gchar* vala_ccode_base_module_get_array_length_cname (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim);
gchar* vala_ccode_base_module_get_ccode_delegate_target_name (ValaVariable* variable);
gchar* vala_ccode_base_module_get_delegate_target_destroy_notify_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname);
static void vala_ccode_base_module_real_visit_field (ValaCodeVisitor* base, ValaField* f);
void vala_ccode_base_module_check_type (ValaCCodeBaseModule* self, ValaDataType* type);
gboolean vala_ccode_base_module_is_simple_struct_creation (ValaCCodeBaseModule* self, ValaVariable* variable, ValaExpression* expr);
ValaTargetValue* vala_ccode_base_module_get_field_cvalue (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance);
ValaTargetValue* vala_ccode_base_module_load_this_parameter (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
G_GNUC_INTERNAL GType vala_glib_value_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
ValaCCodeExpression* vala_ccode_base_module_get_array_length_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value);
ValaCCodeExpression* vala_ccode_base_module_get_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
ValaArrayList* vala_ccode_base_module_get_temp_ref_values (ValaCCodeBaseModule* self);
ValaCCodeExpression* vala_ccode_base_module_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
gboolean vala_ccode_base_module_requires_destroy (ValaCCodeBaseModule* self, ValaDataType* type);
ValaCCodeExpression* vala_ccode_base_module_destroy_field (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance);
ValaCCodeExpression* vala_ccode_base_module_default_value_for_type (ValaCCodeBaseModule* self, ValaDataType* type, gboolean initializer_expression);
gboolean vala_ccode_base_module_is_constant_ccode_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr);
gchar* vala_ccode_base_module_get_array_size_cname (ValaCCodeBaseModule* self, const gchar* array_cname);
ValaLocalVariable* vala_ccode_base_module_get_temp_variable (ValaCCodeBaseModule* self, ValaDataType* type, gboolean value_owned, ValaCodeNode* node_reference, gboolean init);
ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name);
gchar* vala_ccode_base_module_get_variable_cname (ValaCCodeBaseModule* self, const gchar* name);
gboolean vala_ccode_base_module_is_pure_ccode_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr);
static void vala_ccode_base_module_real_visit_formal_parameter (ValaCodeVisitor* base, ValaParameter* p);
static void vala_ccode_base_module_real_visit_property (ValaCodeVisitor* base, ValaProperty* prop);
void vala_ccode_base_module_generate_class_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
void vala_ccode_base_module_generate_interface_declaration (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space);
void vala_ccode_base_module_generate_delegate_declaration (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space);
void vala_ccode_base_module_generate_struct_declaration (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space);
void vala_ccode_base_module_generate_error_domain_declaration (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);
void vala_ccode_base_module_generate_class_struct_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
static void vala_ccode_base_module_real_generate_class_struct_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
static void vala_ccode_base_module_real_generate_struct_declaration (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space);
static void vala_ccode_base_module_real_generate_delegate_declaration (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space);
void vala_ccode_base_module_generate_cparameters (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);
static void vala_ccode_base_module_real_generate_cparameters (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);
void vala_ccode_base_module_generate_property_accessor_declaration (ValaCCodeBaseModule* self, ValaPropertyAccessor* acc, ValaCCodeFile* decl_space);
ValaDataType* vala_ccode_base_module_get_data_type_for_symbol (ValaTypeSymbol* sym);
gchar* vala_ccode_base_module_get_delegate_target_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname);
static void vala_ccode_base_module_real_visit_property_accessor (ValaCodeVisitor* base, ValaPropertyAccessor* acc);
gboolean vala_ccode_base_module_is_gobject_property (ValaCCodeBaseModule* self, ValaProperty* prop);
ValaDataType* vala_ccode_base_module_get_current_return_type (ValaCCodeBaseModule* self);
static void vala_ccode_base_module_create_property_type_check_statement (ValaCCodeBaseModule* self, ValaProperty* prop, gboolean check_return_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);
gchar* vala_ccode_base_module_get_ccode_real_name (ValaSymbol* sym);
ValaTargetValue* vala_ccode_base_module_transform_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* target_type, ValaCodeNode* node);
G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
ValaCCodeConstant* vala_ccode_base_module_get_property_canonical_cconstant (ValaCCodeBaseModule* self, ValaProperty* prop);
static gchar* vala_ccode_base_module_generate_struct_equal_function (ValaCCodeBaseModule* self, ValaStruct* st);
gboolean vala_ccode_base_module_get_current_method_inner_error (ValaCCodeBaseModule* self);
static void vala_ccode_base_module_real_visit_destructor (ValaCodeVisitor* base, ValaDestructor* d);
gint vala_ccode_base_module_get_block_id (ValaCCodeBaseModule* self, ValaBlock* b);
gboolean vala_ccode_base_module_no_implicit_copy (ValaCCodeBaseModule* self, ValaDataType* type);
gboolean vala_ccode_base_module_is_reference_counting (ValaTypeSymbol* sym);
gboolean vala_ccode_base_module_get_ccode_is_gboxed (ValaTypeSymbol* sym);
static void vala_ccode_base_module_capture_parameter (ValaCCodeBaseModule* self, ValaParameter* param, ValaCCodeStruct* data, gint block_id);
gchar* vala_ccode_base_module_get_parameter_array_length_cname (ValaCCodeBaseModule* self, ValaParameter* param, gint dim);
ValaTargetValue* vala_ccode_base_module_get_parameter_cvalue (ValaCCodeBaseModule* self, ValaParameter* param);
static void vala_ccode_base_module_real_visit_block (ValaCodeVisitor* base, ValaBlock* b);
void vala_ccode_base_module_emit_context_push_symbol (ValaCCodeBaseModuleEmitContext* self, ValaSymbol* symbol);
ValaDataType* vala_ccode_base_module_get_this_type (ValaCCodeBaseModule* self);
ValaTypeSymbol* vala_ccode_base_module_get_current_type_symbol (ValaCCodeBaseModule* self);
gchar* vala_ccode_base_module_get_local_cname (ValaCCodeBaseModule* self, ValaLocalVariable* local);
ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self);
ValaCCodeExpression* vala_ccode_base_module_get_dup_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);
ValaCCodeExpression* vala_ccode_base_module_get_result_cexpression (ValaCCodeBaseModule* self, const gchar* cname);
ValaCCodeExpression* vala_ccode_base_module_destroy_local (ValaCCodeBaseModule* self, ValaLocalVariable* local);
ValaCCodeExpression* vala_ccode_base_module_destroy_parameter (ValaCCodeBaseModule* self, ValaParameter* param);
void vala_ccode_base_module_return_out_parameter (ValaCCodeBaseModule* self, ValaParameter* param);
void vala_ccode_base_module_create_postcondition_statement (ValaCCodeBaseModule* self, ValaExpression* postcondition);
void vala_ccode_base_module_emit_context_pop_symbol (ValaCCodeBaseModuleEmitContext* self);
static void vala_ccode_base_module_real_visit_declaration_statement (ValaCodeVisitor* base, ValaDeclarationStatement* stmt);
ValaCCodeExpression* vala_ccode_base_module_get_local_cexpression (ValaCCodeBaseModule* self, ValaLocalVariable* local);
ValaCCodeExpression* vala_ccode_base_module_get_this_cexpression (ValaCCodeBaseModule* self);
ValaMap* vala_ccode_base_module_get_variable_name_map (ValaCCodeBaseModule* self);
gint vala_ccode_base_module_get_next_temp_var_id (ValaCCodeBaseModule* self);
void vala_ccode_base_module_set_next_temp_var_id (ValaCCodeBaseModule* self, gint value);
static gboolean vala_ccode_base_module_is_foreach_element_variable (ValaCCodeBaseModule* self, ValaLocalVariable* local);
static void vala_ccode_base_module_real_visit_local_variable (ValaCodeVisitor* base, ValaLocalVariable* local);
void vala_ccode_base_module_emit_temp_var (ValaCCodeBaseModule* self, ValaLocalVariable* local);
void vala_ccode_base_module_add_simple_check (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);
ValaTargetValue* vala_ccode_base_module_create_temp_value (ValaCCodeBaseModule* self, ValaDataType* type, gboolean init, ValaCodeNode* node_reference, gboolean* value_owned);
ValaTargetValue* vala_ccode_base_module_get_local_cvalue (ValaCCodeBaseModule* self, ValaLocalVariable* local);
void vala_ccode_base_module_set_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCCodeExpression* cvalue);
ValaTargetValue* vala_ccode_base_module_load_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue);
G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_copy (ValaGLibValue* self);
ValaTargetValue* vala_ccode_base_module_store_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* initializer, ValaCodeNode* node_reference, gboolean* value_owned);
void vala_ccode_base_module_store_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
static void vala_ccode_base_module_real_visit_initializer_list (ValaCodeVisitor* base, ValaInitializerList* list);
gchar* vala_ccode_base_module_get_ccode_type (ValaCodeNode* node);
gboolean vala_ccode_base_module_get_ccode_array_null_terminated (ValaCodeNode* node);
void vala_ccode_base_module_set_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* cvalue);
static gboolean vala_ccode_base_module_is_in_generic_type (ValaCCodeBaseModule* self, ValaDataType* type);
static void vala_ccode_base_module_require_generic_accessors (ValaCCodeBaseModule* self, ValaInterface* iface);
ValaCCodeExpression* vala_ccode_base_module_get_type_id_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup);
gboolean vala_ccode_base_module_get_in_creation_method (ValaCCodeBaseModule* self);
static ValaCCodeExpression* vala_ccode_base_module_real_get_dup_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);
gchar* vala_ccode_base_module_get_ccode_ref_function (ValaTypeSymbol* sym);
gchar* vala_ccode_base_module_get_ccode_dup_function (ValaTypeSymbol* sym);
gchar* vala_ccode_base_module_generate_dup_func_wrapper (ValaCCodeBaseModule* self, ValaDataType* type);
static gchar* vala_ccode_base_module_generate_struct_dup_wrapper (ValaCCodeBaseModule* self, ValaValueType* value_type);
static void vala_ccode_base_module_make_comparable_cexpression (ValaCCodeBaseModule* self, ValaDataType* * left_type, ValaCCodeExpression* * cleft, ValaDataType* * right_type, ValaCCodeExpression* * cright);
ValaCCodeExpression* vala_ccode_base_module_try_cast_value_to_type (ValaCCodeBaseModule* self, ValaCCodeExpression* ccodeexpr, ValaDataType* from, ValaDataType* to, ValaExpression* expr);
ValaCCodeFunctionCall* vala_ccode_base_module_generate_instance_cast (ValaCCodeBaseModule* self, ValaCCodeExpression* expr, ValaTypeSymbol* type);
gchar* vala_ccode_base_module_get_ccode_lower_case_prefix (ValaSymbol* sym);
gboolean vala_ccode_base_module_add_wrapper (ValaCCodeBaseModule* self, const gchar* wrapper_name);
static gchar* vala_ccode_base_module_generate_numeric_equal_function (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
gboolean vala_ccode_base_module_get_ccode_has_copy_function (ValaStruct* st);
static void vala_ccode_base_module_generate_struct_copy_function (ValaCCodeBaseModule* self, ValaStruct* st);
gchar* vala_ccode_base_module_get_ccode_copy_function (ValaTypeSymbol* sym);
gchar* vala_ccode_base_module_generate_free_function_address_of_wrapper (ValaCCodeBaseModule* self, ValaDataType* type);
gchar* vala_ccode_base_module_get_ccode_free_function (ValaTypeSymbol* sym);
gchar* vala_ccode_base_module_generate_free_func_wrapper (ValaCCodeBaseModule* self, ValaDataType* type);
gboolean vala_ccode_base_module_get_ccode_has_destroy_function (ValaStruct* st);
static void vala_ccode_base_module_generate_struct_destroy_function (ValaCCodeBaseModule* self, ValaStruct* st);
gchar* vala_ccode_base_module_get_ccode_destroy_function (ValaTypeSymbol* sym);
ValaCCodeExpression* vala_ccode_base_module_get_destroy0_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup);
ValaCCodeExpression* vala_ccode_base_module_get_destroy_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup);
static gchar* vala_ccode_base_module_generate_collection_free_wrapper (ValaCCodeBaseModule* self, ValaDataType* collection_type, ValaCCodeIdentifier* element_destroy_func_expression);
gchar* vala_ccode_base_module_get_ccode_unref_function (ValaObjectTypeSymbol* sym);
static gboolean vala_ccode_base_module_is_free_function_address_of (ValaCCodeBaseModule* self, ValaDataType* type);
gchar* vala_ccode_base_module_append_struct_array_free (ValaCCodeBaseModule* self, ValaStruct* st);
static gchar* vala_ccode_base_module_real_append_struct_array_free (ValaCCodeBaseModule* self, ValaStruct* st);
static ValaCCodeExpression* vala_ccode_base_module_real_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
gboolean vala_ccode_base_module_get_array_null_terminated (ValaCCodeBaseModule* self, ValaTargetValue* value);
ValaCCodeExpression* vala_ccode_base_module_get_array_length_cexpr (ValaCCodeBaseModule* self, ValaTargetValue* value);
static void vala_ccode_base_module_real_visit_end_full_expression (ValaCodeVisitor* base, ValaExpression* expr);
static void vala_ccode_base_module_real_visit_expression_statement (ValaCodeVisitor* base, ValaExpressionStatement* stmt);
void vala_ccode_base_module_append_scope_free (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);
static void vala_ccode_base_module_real_append_scope_free (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);
void vala_ccode_base_module_append_local_free (ValaCCodeBaseModule* self, ValaSymbol* sym, gboolean stop_at_loop, ValaCodeNode* stop_at);
static void vala_ccode_base_module_append_param_free (ValaCCodeBaseModule* self, ValaMethod* m);
gboolean vala_ccode_base_module_variable_accessible_in_finally (ValaCCodeBaseModule* self, ValaLocalVariable* local);
ValaTryStatement* vala_ccode_base_module_get_current_try (ValaCCodeBaseModule* self);
static void vala_ccode_base_module_real_visit_return_statement (ValaCodeVisitor* base, ValaReturnStatement* stmt);
ValaPropertyAccessor* vala_ccode_base_module_get_current_property_accessor (ValaCCodeBaseModule* self);
void vala_ccode_base_module_set_current_method_return (ValaCCodeBaseModule* self, gboolean value);
static ValaCCodeExpression* vala_ccode_base_module_get_lock_expression (ValaCCodeBaseModule* self, ValaStatement* stmt, ValaExpression* resource);
static void vala_ccode_base_module_real_visit_lock_statement (ValaCodeVisitor* base, ValaLockStatement* stmt);
static void vala_ccode_base_module_real_visit_unlock_statement (ValaCodeVisitor* base, ValaUnlockStatement* stmt);
static void vala_ccode_base_module_real_visit_delete_statement (ValaCodeVisitor* base, ValaDeleteStatement* stmt);
static void vala_ccode_base_module_real_visit_expression (ValaCodeVisitor* base, ValaExpression* expr);
ValaCCodeExpression* vala_ccode_base_module_convert_from_generic_pointer (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr, ValaDataType* actual_type);
ValaCCodeExpression* vala_ccode_base_module_convert_to_generic_pointer (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr, ValaDataType* actual_type);
static void vala_ccode_base_module_real_visit_boolean_literal (ValaCodeVisitor* base, ValaBooleanLiteral* expr);
static void vala_ccode_base_module_real_visit_character_literal (ValaCodeVisitor* base, ValaCharacterLiteral* expr);
static void vala_ccode_base_module_real_visit_integer_literal (ValaCodeVisitor* base, ValaIntegerLiteral* expr);
static void vala_ccode_base_module_real_visit_real_literal (ValaCodeVisitor* base, ValaRealLiteral* expr);
static void vala_ccode_base_module_real_visit_string_literal (ValaCodeVisitor* base, ValaStringLiteral* expr);
static void vala_ccode_base_module_real_visit_regex_literal (ValaCodeVisitor* base, ValaRegexLiteral* expr);
static void vala_ccode_base_module_real_visit_null_literal (ValaCodeVisitor* base, ValaNullLiteral* expr);
void vala_ccode_base_module_append_array_length (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* size);
void vala_ccode_base_module_set_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* delegate_target);
void vala_ccode_base_module_set_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* destroy_notify);
static ValaTargetValue* vala_ccode_base_module_real_get_local_cvalue (ValaCCodeBaseModule* self, ValaLocalVariable* local);
static ValaTargetValue* vala_ccode_base_module_real_get_parameter_cvalue (ValaCCodeBaseModule* self, ValaParameter* param);
static ValaTargetValue* vala_ccode_base_module_real_get_field_cvalue (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance);
ValaTargetValue* vala_ccode_base_module_load_variable (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value);
static ValaTargetValue* vala_ccode_base_module_real_load_variable (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value);
static ValaTargetValue* vala_ccode_base_module_real_load_this_parameter (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
static void vala_ccode_base_module_real_store_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
static gchar* vala_ccode_base_module_real_get_delegate_target_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cexpression (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression* * delegate_target_destroy_notify);
static ValaCCodeExpression* vala_ccode_base_module_real_get_delegate_target_cexpression (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression* * delegate_target_destroy_notify);
static ValaCCodeExpression* vala_ccode_base_module_real_get_delegate_target_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
static ValaCCodeExpression* vala_ccode_base_module_real_get_delegate_target_destroy_notify_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
static gchar* vala_ccode_base_module_real_get_delegate_target_destroy_notify_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname);
static void vala_ccode_base_module_real_visit_base_access (ValaCodeVisitor* base, ValaBaseAccess* expr);
static void vala_ccode_base_module_real_visit_postfix_expression (ValaCodeVisitor* base, ValaPostfixExpression* expr);
static ValaMemberAccess* vala_ccode_base_module_find_property_access (ValaCCodeBaseModule* self, ValaExpression* expr);
void vala_ccode_base_module_store_property (ValaCCodeBaseModule* self, ValaProperty* prop, ValaExpression* instance, ValaTargetValue* value);
static gboolean vala_ccode_base_module_is_limited_generic_type (ValaCCodeBaseModule* self, ValaDataType* type);
gboolean vala_ccode_base_module_requires_copy (ValaCCodeBaseModule* self, ValaDataType* type);
static gboolean vala_ccode_base_module_is_ref_function_void (ValaCCodeBaseModule* self, ValaDataType* type);
gboolean vala_ccode_base_module_get_ccode_ref_function_void (ValaClass* cl);
gboolean vala_ccode_base_module_get_ccode_free_function_address_of (ValaClass* cl);
ValaTargetValue* vala_ccode_base_module_copy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
static ValaTargetValue* vala_ccode_base_module_real_copy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
gboolean vala_ccode_base_module_get_non_null (ValaCCodeBaseModule* self, ValaTargetValue* value);
static gboolean vala_ccode_base_module_is_reference_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg);
static gboolean vala_ccode_base_module_is_nullable_value_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg);
static gboolean vala_ccode_base_module_is_signed_integer_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg);
static gboolean vala_ccode_base_module_is_unsigned_integer_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg);
static void vala_ccode_base_module_check_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg);
void vala_ccode_base_module_check_type_arguments (ValaCCodeBaseModule* self, ValaMemberAccess* access);
static void vala_ccode_base_module_real_generate_class_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
static void vala_ccode_base_module_real_generate_interface_declaration (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space);
void vala_ccode_base_module_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
static void vala_ccode_base_module_real_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
static void vala_ccode_base_module_real_generate_error_domain_declaration (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);
void vala_ccode_base_module_add_generic_type_arguments (ValaCCodeBaseModule* self, ValaMap* arg_map, ValaList* type_args, ValaCodeNode* expr, gboolean is_chainup, ValaList* type_parameters);
gint vala_ccode_base_module_get_param_pos (ValaCCodeBaseModule* self, gdouble param_pos, gboolean ellipsis);
static void vala_ccode_base_module_real_visit_object_creation_expression (ValaCodeVisitor* base, ValaObjectCreationExpression* expr);
gboolean vala_ccode_base_module_get_ccode_has_new_function (ValaMethod* m);
gdouble vala_ccode_base_module_get_ccode_instance_pos (ValaCodeNode* node);
gchar* vala_ccode_base_module_get_ccode_finish_name (ValaMethod* m);
gboolean vala_ccode_base_module_get_ccode_simple_generics (ValaMethod* m);
gdouble vala_ccode_base_module_get_ccode_array_length_pos (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_get_array_length_cexpression (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim);
gdouble vala_ccode_base_module_get_ccode_delegate_target_pos (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_handle_struct_argument (ValaCCodeBaseModule* self, ValaParameter* param, ValaExpression* arg, ValaCCodeExpression* cexpr);
gdouble vala_ccode_base_module_get_ccode_pos (ValaParameter* param);
void vala_ccode_base_module_set_current_method_inner_error (ValaCCodeBaseModule* self, gboolean value);
gchar* vala_ccode_base_module_get_ccode_sentinel (ValaMethod* m);
gchar* vala_ccode_base_module_generate_ready_function (ValaCCodeBaseModule* self, ValaMethod* m);
gboolean vala_ccode_base_module_get_ccode_finish_instance (ValaCodeNode* node);
static void vala_ccode_base_module_real_visit_sizeof_expression (ValaCodeVisitor* base, ValaSizeofExpression* expr);
static void vala_ccode_base_module_real_visit_typeof_expression (ValaCodeVisitor* base, ValaTypeofExpression* expr);
static void vala_ccode_base_module_real_visit_unary_expression (ValaCodeVisitor* base, ValaUnaryExpression* expr);
G_GNUC_INTERNAL void vala_glib_value_append_array_length_cvalue (ValaGLibValue* self, ValaCCodeExpression* length_cvalue);
ValaTargetValue* vala_ccode_base_module_try_cast_variant_to_type (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* to, ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_deserialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail);
static ValaCCodeExpression* vala_ccode_base_module_real_deserialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail);
ValaCCodeExpression* vala_ccode_base_module_serialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr);
static ValaCCodeExpression* vala_ccode_base_module_real_serialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr);
static void vala_ccode_base_module_real_visit_cast_expression (ValaCodeVisitor* base, ValaCastExpression* expr);
gboolean vala_ccode_base_module_get_lvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
static ValaCCodeExpression* vala_ccode_base_module_create_type_check (ValaCCodeBaseModule* self, ValaCCodeNode* ccodenode, ValaDataType* type);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr);
static void vala_ccode_base_module_real_visit_named_argument (ValaCodeVisitor* base, ValaNamedArgument* expr);
static void vala_ccode_base_module_real_visit_pointer_indirection (ValaCodeVisitor* base, ValaPointerIndirection* expr);
static void vala_ccode_base_module_real_visit_addressof_expression (ValaCodeVisitor* base, ValaAddressofExpression* expr);
static void vala_ccode_base_module_real_visit_reference_transfer_expression (ValaCodeVisitor* base, ValaReferenceTransferExpression* expr);
static void vala_ccode_base_module_real_visit_binary_expression (ValaCodeVisitor* base, ValaBinaryExpression* expr);
static gchar* vala_ccode_base_module_generate_array_contains_wrapper (ValaCCodeBaseModule* self, ValaArrayType* array_type);
static void vala_ccode_base_module_real_visit_type_check (ValaCodeVisitor* base, ValaTypeCheck* expr);
static void vala_ccode_base_module_real_visit_lambda_expression (ValaCodeVisitor* base, ValaLambdaExpression* lambda);
gchar* vala_ccode_base_module_get_ccode_array_length_type (ValaCodeNode* node);
ValaBlock* vala_ccode_base_module_get_current_closure_block (ValaCCodeBaseModule* self);
gchar* vala_ccode_base_module_get_ccode_ref_sink_function (ValaObjectTypeSymbol* sym);
gboolean vala_ccode_base_module_is_lvalue_access_allowed (ValaCCodeBaseModule* self, ValaDataType* type);
ValaCCodeExpression* vala_ccode_base_module_get_implicit_cast_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node);
static ValaCCodeExpression* vala_ccode_base_module_real_get_implicit_cast_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_get_ccodenode (ValaCCodeBaseModule* self, ValaExpression* node);
gboolean vala_ccode_base_module_get_ccode_no_accessor_method (ValaProperty* p);
gchar* vala_ccode_base_module_get_dynamic_property_setter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
gboolean vala_ccode_base_module_add_generated_external_symbol (ValaCCodeBaseModule* self, ValaSymbol* external_symbol);
gchar* vala_ccode_base_module_get_ccode_default_value (ValaTypeSymbol* sym);
void vala_ccode_base_module_create_type_check_statement (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);
static void vala_ccode_base_module_real_create_type_check_statement (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);
GType vala_ccode_attribute_get_type (void) G_GNUC_CONST;
ValaCCodeAttribute* vala_ccode_base_module_get_ccode_attribute (ValaCodeNode* node);
ValaCCodeAttribute* vala_ccode_attribute_new (ValaCodeNode* node);
ValaCCodeAttribute* vala_ccode_attribute_construct (GType object_type, ValaCodeNode* node);
const gchar* vala_ccode_attribute_get_name (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_const_name (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_type_name (ValaInterface* iface);
const gchar* vala_ccode_attribute_get_type_name (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_lower_case_suffix (ValaSymbol* sym);
const gchar* vala_ccode_attribute_get_header_filenames (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_prefix (ValaSymbol* sym);
const gchar* vala_ccode_attribute_get_prefix (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_lower_case_prefix (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_lower_case_suffix (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_ref_function (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_quark_name (ValaErrorDomain* edomain);
gboolean vala_ccode_attribute_get_ref_function_void (ValaCCodeAttribute* self);
gboolean vala_ccode_attribute_get_free_function_address_of (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_unref_function (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_ref_sink_function (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_copy_function (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_destroy_function (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_free_function (ValaCCodeAttribute* self);
gboolean vala_ccode_attribute_get_finish_instance (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_type_id (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_marshaller_type_name (ValaCodeNode* node);
const gchar* vala_ccode_attribute_get_marshaller_type_name (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_get_value_function (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_set_value_function (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_take_value_function (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_param_spec_function (ValaCodeNode* sym);
const gchar* vala_ccode_attribute_get_param_spec_function (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_type_check_function (ValaTypeSymbol* sym);
const gchar* vala_ccode_attribute_get_default_value (ValaCCodeAttribute* self);
gboolean vala_ccode_attribute_get_array_length (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_array_length_type (ValaCCodeAttribute* self);
gboolean vala_ccode_attribute_get_array_null_terminated (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_array_length_name (ValaCodeNode* node);
const gchar* vala_ccode_attribute_get_array_length_name (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_array_length_expr (ValaCodeNode* node);
const gchar* vala_ccode_attribute_get_array_length_expr (ValaCCodeAttribute* self);
gdouble vala_ccode_base_module_get_ccode_destroy_notify_pos (ValaCodeNode* node);
gboolean vala_ccode_base_module_get_ccode_delegate_target (ValaCodeNode* node);
gboolean vala_ccode_attribute_get_delegate_target (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_delegate_target_name (ValaCCodeAttribute* self);
gdouble vala_ccode_attribute_get_pos (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_ctype (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_real_name (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_constructv_name (ValaCreationMethod* m);
gchar* vala_ccode_base_module_get_ccode_vfunc_name (ValaMethod* m);
const gchar* vala_ccode_attribute_get_vfunc_name (ValaCCodeAttribute* self);
const gchar* vala_ccode_attribute_get_finish_name (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_finish_vfunc_name (ValaMethod* m);
const gchar* vala_ccode_attribute_get_finish_vfunc_name (ValaCCodeAttribute* self);
gchar* vala_ccode_base_module_get_ccode_finish_real_name (ValaMethod* m);
const gchar* vala_ccode_attribute_get_finish_real_name (ValaCCodeAttribute* self);
gboolean vala_ccode_base_module_get_ccode_concrete_accessor (ValaProperty* p);
gboolean vala_ccode_base_module_get_ccode_has_generic_type_parameter (ValaMethod* m);
gdouble vala_ccode_base_module_get_ccode_generic_type_pos (ValaMethod* m);
const gchar* vala_ccode_attribute_get_sentinel (ValaCCodeAttribute* self);
ValaCCodeConstant* vala_ccode_base_module_get_signal_canonical_constant (ValaCCodeBaseModule* self, ValaSignal* sig, const gchar* detail);
ValaCCodeConstant* vala_ccode_base_module_get_enum_value_canonical_cconstant (ValaEnumValue* ev);
gboolean vala_ccode_base_module_get_signal_has_emitter (ValaCCodeBaseModule* self, ValaSignal* sig);
static void vala_ccode_base_module_real_visit_class (ValaCodeVisitor* base, ValaClass* cl);
static gboolean vala_ccode_base_module_real_is_gobject_property (ValaCCodeBaseModule* self, ValaProperty* prop);
ValaConstructor* vala_ccode_base_module_get_current_constructor (ValaCCodeBaseModule* self);
ValaDestructor* vala_ccode_base_module_get_current_destructor (ValaCCodeBaseModule* self);
void vala_ccode_base_module_return_default_value (ValaCCodeBaseModule* self, ValaDataType* return_type);
void vala_ccode_base_module_generate_dynamic_method_wrapper (ValaCCodeBaseModule* self, ValaDynamicMethod* method);
static void vala_ccode_base_module_real_generate_dynamic_method_wrapper (ValaCCodeBaseModule* self, ValaDynamicMethod* method);
gboolean vala_ccode_base_module_method_has_wrapper (ValaCCodeBaseModule* self, ValaMethod* method);
static gboolean vala_ccode_base_module_real_method_has_wrapper (ValaCCodeBaseModule* self, ValaMethod* method);
ValaCCodeFunctionCall* vala_ccode_base_module_get_param_spec (ValaCCodeBaseModule* self, ValaProperty* prop);
static ValaCCodeFunctionCall* vala_ccode_base_module_real_get_param_spec (ValaCCodeBaseModule* self, ValaProperty* prop);
ValaCCodeExpression* vala_ccode_base_module_get_signal_creation (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type);
static ValaCCodeExpression* vala_ccode_base_module_real_get_signal_creation (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type);
void vala_ccode_base_module_register_dbus_info (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable);
static void vala_ccode_base_module_real_register_dbus_info (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable);
gchar* vala_ccode_base_module_get_dynamic_property_getter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
static gchar* vala_ccode_base_module_real_get_dynamic_property_getter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
static gchar* vala_ccode_base_module_real_get_dynamic_property_setter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
gchar* vala_ccode_base_module_get_dynamic_signal_cname (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
static gchar* vala_ccode_base_module_real_get_dynamic_signal_cname (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
gchar* vala_ccode_base_module_get_dynamic_signal_connect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
static gchar* vala_ccode_base_module_real_get_dynamic_signal_connect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
gchar* vala_ccode_base_module_get_dynamic_signal_connect_after_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
static gchar* vala_ccode_base_module_real_get_dynamic_signal_connect_after_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
gchar* vala_ccode_base_module_get_dynamic_signal_disconnect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
static gchar* vala_ccode_base_module_real_get_dynamic_signal_disconnect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
static gchar* vala_ccode_base_module_real_get_array_length_cname (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim);
static gchar* vala_ccode_base_module_real_get_parameter_array_length_cname (ValaCCodeBaseModule* self, ValaParameter* param, gint dim);
static ValaCCodeExpression* vala_ccode_base_module_real_get_array_length_cexpression (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim);
static ValaCCodeExpression* vala_ccode_base_module_real_get_array_length_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim);
static gchar* vala_ccode_base_module_real_get_array_size_cname (ValaCCodeBaseModule* self, const gchar* array_cname);
static void vala_ccode_base_module_real_add_simple_check (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);
static gchar* vala_ccode_base_module_real_generate_ready_function (ValaCCodeBaseModule* self, ValaMethod* m);
ValaList* vala_ccode_base_module_get_array_lengths (ValaCCodeBaseModule* self, ValaExpression* expr);
gchar* vala_ccode_base_module_get_ctype (ValaCCodeBaseModule* self, ValaTargetValue* value);
void vala_ccode_base_module_set_current_try (ValaCCodeBaseModule* self, ValaTryStatement* value);
ValaCatchClause* vala_ccode_base_module_get_current_catch (ValaCCodeBaseModule* self);
void vala_ccode_base_module_set_current_catch (ValaCCodeBaseModule* self, ValaCatchClause* value);
gboolean vala_ccode_base_module_get_current_method_return (ValaCCodeBaseModule* self);
enum  {
	VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_DUMMY_PROPERTY
};
static void vala_ccode_base_module_emit_context_finalize (ValaCCodeBaseModuleEmitContext * obj);
static void vala_ccode_base_module_finalize (ValaCodeVisitor * obj);
enum  {
	VALA_GLIB_VALUE_DUMMY_PROPERTY
};
static void vala_glib_value_finalize (ValaTargetValue * obj);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
static gint _vala_array_length (gpointer array);


gboolean vala_ccode_base_module_is_in_coroutine (ValaCCodeBaseModule* self) {
	gboolean result = FALSE;
	gboolean _tmp0_ = FALSE;
	ValaMethod* _tmp1_;
	ValaMethod* _tmp2_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp1_ = vala_ccode_base_module_get_current_method (self);
	_tmp2_ = _tmp1_;
	if (_tmp2_ != NULL) {
		ValaMethod* _tmp3_;
		ValaMethod* _tmp4_;
		gboolean _tmp5_;
		gboolean _tmp6_;
		_tmp3_ = vala_ccode_base_module_get_current_method (self);
		_tmp4_ = _tmp3_;
		_tmp5_ = vala_method_get_coroutine (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp0_ = _tmp6_;
	} else {
		_tmp0_ = FALSE;
	}
	result = _tmp0_;
	return result;
}


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


gboolean vala_ccode_base_module_is_in_constructor (ValaCCodeBaseModule* self) {
	gboolean result = FALSE;
	ValaMethod* _tmp0_;
	ValaMethod* _tmp1_;
	ValaSymbol* sym = NULL;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp3_;
	ValaSymbol* _tmp4_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = vala_ccode_base_module_get_current_method (self);
	_tmp1_ = _tmp0_;
	if (_tmp1_ != NULL) {
		result = FALSE;
		return result;
	}
	_tmp2_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp3_ = _tmp2_;
	_tmp4_ = _vala_code_node_ref0 (_tmp3_);
	sym = _tmp4_;
	while (TRUE) {
		ValaSymbol* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		ValaSymbol* _tmp8_;
		ValaSymbol* _tmp9_;
		ValaSymbol* _tmp10_;
		_tmp5_ = sym;
		if (!(_tmp5_ != NULL)) {
			break;
		}
		_tmp6_ = sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_CONSTRUCTOR)) {
			result = TRUE;
			_vala_code_node_unref0 (sym);
			return result;
		}
		_tmp7_ = sym;
		_tmp8_ = vala_symbol_get_parent_symbol (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = _vala_code_node_ref0 (_tmp9_);
		_vala_code_node_unref0 (sym);
		sym = _tmp10_;
	}
	result = FALSE;
	_vala_code_node_unref0 (sym);
	return result;
}


gboolean vala_ccode_base_module_is_in_destructor (ValaCCodeBaseModule* self) {
	gboolean result = FALSE;
	ValaMethod* _tmp0_;
	ValaMethod* _tmp1_;
	ValaSymbol* sym = NULL;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp3_;
	ValaSymbol* _tmp4_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = vala_ccode_base_module_get_current_method (self);
	_tmp1_ = _tmp0_;
	if (_tmp1_ != NULL) {
		result = FALSE;
		return result;
	}
	_tmp2_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp3_ = _tmp2_;
	_tmp4_ = _vala_code_node_ref0 (_tmp3_);
	sym = _tmp4_;
	while (TRUE) {
		ValaSymbol* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		ValaSymbol* _tmp8_;
		ValaSymbol* _tmp9_;
		ValaSymbol* _tmp10_;
		_tmp5_ = sym;
		if (!(_tmp5_ != NULL)) {
			break;
		}
		_tmp6_ = sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_DESTRUCTOR)) {
			result = TRUE;
			_vala_code_node_unref0 (sym);
			return result;
		}
		_tmp7_ = sym;
		_tmp8_ = vala_symbol_get_parent_symbol (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = _vala_code_node_ref0 (_tmp9_);
		_vala_code_node_unref0 (sym);
		sym = _tmp10_;
	}
	result = FALSE;
	_vala_code_node_unref0 (sym);
	return result;
}


ValaBlock* vala_ccode_base_module_next_closure_block (ValaCCodeBaseModule* self, ValaSymbol* sym) {
	ValaBlock* result = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (sym != NULL, NULL);
	while (TRUE) {
		ValaMethod* method = NULL;
		ValaSymbol* _tmp0_;
		gboolean _tmp1_ = FALSE;
		ValaMethod* _tmp2_;
		ValaBlock* block = NULL;
		ValaSymbol* _tmp6_;
		gboolean _tmp7_ = FALSE;
		ValaMethod* _tmp8_;
		gboolean _tmp10_ = FALSE;
		ValaBlock* _tmp11_;
		ValaSymbol* _tmp16_;
		ValaSymbol* _tmp17_;
		ValaSymbol* _tmp18_;
		_tmp0_ = sym;
		method = G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp0_) : NULL;
		_tmp2_ = method;
		if (_tmp2_ != NULL) {
			ValaMethod* _tmp3_;
			gboolean _tmp4_;
			gboolean _tmp5_;
			_tmp3_ = method;
			_tmp4_ = vala_method_get_closure (_tmp3_);
			_tmp5_ = _tmp4_;
			_tmp1_ = !_tmp5_;
		} else {
			_tmp1_ = FALSE;
		}
		if (_tmp1_) {
			break;
		}
		_tmp6_ = sym;
		block = G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_BLOCK) ? ((ValaBlock*) _tmp6_) : NULL;
		_tmp8_ = method;
		if (_tmp8_ == NULL) {
			ValaBlock* _tmp9_;
			_tmp9_ = block;
			_tmp7_ = _tmp9_ == NULL;
		} else {
			_tmp7_ = FALSE;
		}
		if (_tmp7_) {
			break;
		}
		_tmp11_ = block;
		if (_tmp11_ != NULL) {
			ValaBlock* _tmp12_;
			gboolean _tmp13_;
			gboolean _tmp14_;
			_tmp12_ = block;
			_tmp13_ = vala_block_get_captured (_tmp12_);
			_tmp14_ = _tmp13_;
			_tmp10_ = _tmp14_;
		} else {
			_tmp10_ = FALSE;
		}
		if (_tmp10_) {
			ValaBlock* _tmp15_;
			_tmp15_ = block;
			result = _tmp15_;
			return result;
		}
		_tmp16_ = sym;
		_tmp17_ = vala_symbol_get_parent_symbol (_tmp16_);
		_tmp18_ = _tmp17_;
		sym = _tmp18_;
	}
	result = NULL;
	return result;
}


ValaCCodeBaseModule* vala_ccode_base_module_construct (GType object_type) {
	ValaCCodeBaseModule* self = NULL;
	GHashFunc _tmp0_;
	GEqualFunc _tmp1_;
	ValaHashSet* _tmp2_;
	ValaSet* _tmp3_;
	ValaSet* _tmp4_;
	ValaSet* _tmp5_;
	ValaSet* _tmp6_;
	ValaSet* _tmp7_;
	ValaSet* _tmp8_;
	ValaSet* _tmp9_;
	ValaSet* _tmp10_;
	ValaSet* _tmp11_;
	ValaSet* _tmp12_;
	ValaSet* _tmp13_;
	ValaSet* _tmp14_;
	ValaSet* _tmp15_;
	ValaSet* _tmp16_;
	ValaSet* _tmp17_;
	ValaSet* _tmp18_;
	ValaSet* _tmp19_;
	ValaSet* _tmp20_;
	ValaSet* _tmp21_;
	ValaSet* _tmp22_;
	ValaSet* _tmp23_;
	GHashFunc _tmp24_;
	GEqualFunc _tmp25_;
	ValaHashSet* _tmp26_;
	ValaSet* _tmp27_;
	ValaSet* _tmp28_;
	ValaSet* _tmp29_;
	ValaSet* _tmp30_;
	ValaSet* _tmp31_;
	ValaSet* _tmp32_;
	ValaSet* _tmp33_;
	ValaSet* _tmp34_;
	ValaSet* _tmp35_;
	ValaSet* _tmp36_;
	ValaSet* _tmp37_;
	ValaSet* _tmp38_;
	ValaSet* _tmp39_;
	ValaSet* _tmp40_;
	ValaSet* _tmp41_;
	ValaSet* _tmp42_;
	ValaSet* _tmp43_;
	ValaSet* _tmp44_;
	ValaSet* _tmp45_;
	ValaSet* _tmp46_;
	ValaSet* _tmp47_;
	ValaSet* _tmp48_;
	ValaSet* _tmp49_;
	ValaSet* _tmp50_;
	ValaSet* _tmp51_;
	ValaSet* _tmp52_;
	ValaSet* _tmp53_;
	ValaSet* _tmp54_;
	ValaSet* _tmp55_;
	ValaSet* _tmp56_;
	ValaSet* _tmp57_;
	ValaSet* _tmp58_;
	ValaSet* _tmp59_;
	ValaSet* _tmp60_;
	ValaSet* _tmp61_;
	ValaSet* _tmp62_;
	ValaSet* _tmp63_;
	ValaSet* _tmp64_;
	ValaSet* _tmp65_;
	ValaSet* _tmp66_;
	ValaSet* _tmp67_;
	ValaSet* _tmp68_;
	ValaSet* _tmp69_;
	ValaSet* _tmp70_;
	ValaSet* _tmp71_;
	ValaSet* _tmp72_;
	ValaSet* _tmp73_;
	ValaSet* _tmp74_;
	ValaSet* _tmp75_;
	self = (ValaCCodeBaseModule*) vala_code_generator_construct (object_type);
	_tmp0_ = g_str_hash;
	_tmp1_ = g_str_equal;
	_tmp2_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp0_, _tmp1_);
	_vala_iterable_unref0 (self->predefined_marshal_set);
	self->predefined_marshal_set = (ValaSet*) _tmp2_;
	_tmp3_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp3_, "VOID:VOID");
	_tmp4_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp4_, "VOID:BOOLEAN");
	_tmp5_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp5_, "VOID:CHAR");
	_tmp6_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp6_, "VOID:UCHAR");
	_tmp7_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp7_, "VOID:INT");
	_tmp8_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp8_, "VOID:UINT");
	_tmp9_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp9_, "VOID:LONG");
	_tmp10_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp10_, "VOID:ULONG");
	_tmp11_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp11_, "VOID:ENUM");
	_tmp12_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp12_, "VOID:FLAGS");
	_tmp13_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp13_, "VOID:FLOAT");
	_tmp14_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp14_, "VOID:DOUBLE");
	_tmp15_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp15_, "VOID:STRING");
	_tmp16_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp16_, "VOID:POINTER");
	_tmp17_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp17_, "VOID:OBJECT");
	_tmp18_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp18_, "STRING:OBJECT,POINTER");
	_tmp19_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp19_, "VOID:UINT,POINTER");
	_tmp20_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp20_, "BOOLEAN:FLAGS");
	_tmp21_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp21_, "VOID:BOXED");
	_tmp22_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp22_, "VOID:VARIANT");
	_tmp23_ = self->predefined_marshal_set;
	vala_collection_add ((ValaCollection*) _tmp23_, "BOOLEAN:BOXED,BOXED");
	_tmp24_ = g_str_hash;
	_tmp25_ = g_str_equal;
	_tmp26_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp24_, _tmp25_);
	_vala_iterable_unref0 (self->priv->reserved_identifiers);
	self->priv->reserved_identifiers = (ValaSet*) _tmp26_;
	_tmp27_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp27_, "_Bool");
	_tmp28_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp28_, "_Complex");
	_tmp29_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp29_, "_Imaginary");
	_tmp30_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp30_, "asm");
	_tmp31_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp31_, "auto");
	_tmp32_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp32_, "break");
	_tmp33_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp33_, "case");
	_tmp34_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp34_, "char");
	_tmp35_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp35_, "const");
	_tmp36_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp36_, "continue");
	_tmp37_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp37_, "default");
	_tmp38_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp38_, "do");
	_tmp39_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp39_, "double");
	_tmp40_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp40_, "else");
	_tmp41_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp41_, "enum");
	_tmp42_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp42_, "extern");
	_tmp43_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp43_, "float");
	_tmp44_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp44_, "for");
	_tmp45_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp45_, "goto");
	_tmp46_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp46_, "if");
	_tmp47_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp47_, "inline");
	_tmp48_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp48_, "int");
	_tmp49_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp49_, "long");
	_tmp50_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp50_, "register");
	_tmp51_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp51_, "restrict");
	_tmp52_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp52_, "return");
	_tmp53_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp53_, "short");
	_tmp54_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp54_, "signed");
	_tmp55_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp55_, "sizeof");
	_tmp56_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp56_, "static");
	_tmp57_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp57_, "struct");
	_tmp58_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp58_, "switch");
	_tmp59_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp59_, "typedef");
	_tmp60_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp60_, "union");
	_tmp61_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp61_, "unsigned");
	_tmp62_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp62_, "void");
	_tmp63_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp63_, "volatile");
	_tmp64_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp64_, "while");
	_tmp65_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp65_, "_Alignas");
	_tmp66_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp66_, "_Alignof");
	_tmp67_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp67_, "_Atomic");
	_tmp68_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp68_, "_Generic");
	_tmp69_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp69_, "_Noreturn");
	_tmp70_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp70_, "_Static_assert");
	_tmp71_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp71_, "_Thread_local");
	_tmp72_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp72_, "cdecl");
	_tmp73_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp73_, "error");
	_tmp74_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp74_, "result");
	_tmp75_ = self->priv->reserved_identifiers;
	vala_collection_add ((ValaCollection*) _tmp75_, "self");
	return self;
}


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


static void vala_ccode_base_module_real_emit (ValaCodeGenerator* base, ValaCodeContext* context) {
	ValaCCodeBaseModule * self;
	ValaCodeContext* _tmp0_;
	ValaCodeContext* _tmp1_;
	ValaNamespace* _tmp2_;
	ValaNamespace* _tmp3_;
	ValaSymbol* _tmp4_;
	ValaSymbol* _tmp5_;
	ValaScope* _tmp6_;
	ValaScope* _tmp7_;
	ValaSymbol* _tmp8_;
	ValaStruct* _tmp9_;
	ValaBooleanType* _tmp10_;
	ValaSymbol* _tmp11_;
	ValaScope* _tmp12_;
	ValaScope* _tmp13_;
	ValaSymbol* _tmp14_;
	ValaStruct* _tmp15_;
	ValaIntegerType* _tmp16_;
	ValaSymbol* _tmp17_;
	ValaScope* _tmp18_;
	ValaScope* _tmp19_;
	ValaSymbol* _tmp20_;
	ValaStruct* _tmp21_;
	ValaIntegerType* _tmp22_;
	ValaSymbol* _tmp23_;
	ValaScope* _tmp24_;
	ValaScope* _tmp25_;
	ValaSymbol* _tmp26_;
	ValaStruct* _tmp27_;
	ValaIntegerType* _tmp28_;
	ValaSymbol* _tmp29_;
	ValaScope* _tmp30_;
	ValaScope* _tmp31_;
	ValaSymbol* _tmp32_;
	ValaStruct* _tmp33_;
	ValaIntegerType* _tmp34_;
	ValaSymbol* _tmp35_;
	ValaScope* _tmp36_;
	ValaScope* _tmp37_;
	ValaSymbol* _tmp38_;
	ValaStruct* _tmp39_;
	ValaIntegerType* _tmp40_;
	ValaSymbol* _tmp41_;
	ValaScope* _tmp42_;
	ValaScope* _tmp43_;
	ValaSymbol* _tmp44_;
	ValaStruct* _tmp45_;
	ValaIntegerType* _tmp46_;
	ValaSymbol* _tmp47_;
	ValaScope* _tmp48_;
	ValaScope* _tmp49_;
	ValaSymbol* _tmp50_;
	ValaStruct* _tmp51_;
	ValaIntegerType* _tmp52_;
	ValaSymbol* _tmp53_;
	ValaScope* _tmp54_;
	ValaScope* _tmp55_;
	ValaSymbol* _tmp56_;
	ValaStruct* _tmp57_;
	ValaIntegerType* _tmp58_;
	ValaSymbol* _tmp59_;
	ValaScope* _tmp60_;
	ValaScope* _tmp61_;
	ValaSymbol* _tmp62_;
	ValaStruct* _tmp63_;
	ValaIntegerType* _tmp64_;
	ValaSymbol* _tmp65_;
	ValaScope* _tmp66_;
	ValaScope* _tmp67_;
	ValaSymbol* _tmp68_;
	ValaStruct* _tmp69_;
	ValaIntegerType* _tmp70_;
	ValaSymbol* _tmp71_;
	ValaScope* _tmp72_;
	ValaScope* _tmp73_;
	ValaSymbol* _tmp74_;
	ValaStruct* _tmp75_;
	ValaIntegerType* _tmp76_;
	ValaSymbol* _tmp77_;
	ValaScope* _tmp78_;
	ValaScope* _tmp79_;
	ValaSymbol* _tmp80_;
	ValaStruct* _tmp81_;
	ValaIntegerType* _tmp82_;
	ValaSymbol* _tmp83_;
	ValaScope* _tmp84_;
	ValaScope* _tmp85_;
	ValaSymbol* _tmp86_;
	ValaStruct* _tmp87_;
	ValaIntegerType* _tmp88_;
	ValaSymbol* _tmp89_;
	ValaScope* _tmp90_;
	ValaScope* _tmp91_;
	ValaSymbol* _tmp92_;
	ValaStruct* _tmp93_;
	ValaIntegerType* _tmp94_;
	ValaSymbol* _tmp95_;
	ValaScope* _tmp96_;
	ValaScope* _tmp97_;
	ValaSymbol* _tmp98_;
	ValaStruct* _tmp99_;
	ValaIntegerType* _tmp100_;
	ValaSymbol* _tmp101_;
	ValaScope* _tmp102_;
	ValaScope* _tmp103_;
	ValaSymbol* _tmp104_;
	ValaStruct* _tmp105_;
	ValaIntegerType* _tmp106_;
	ValaSymbol* _tmp107_;
	ValaScope* _tmp108_;
	ValaScope* _tmp109_;
	ValaSymbol* _tmp110_;
	ValaStruct* _tmp111_;
	ValaFloatingType* _tmp112_;
	ValaSymbol* _tmp113_;
	ValaScope* _tmp114_;
	ValaScope* _tmp115_;
	ValaSymbol* _tmp116_;
	ValaStruct* _tmp117_;
	ValaFloatingType* _tmp118_;
	ValaSymbol* _tmp119_;
	ValaScope* _tmp120_;
	ValaScope* _tmp121_;
	ValaSymbol* _tmp122_;
	ValaClass* _tmp123_;
	ValaObjectType* _tmp124_;
	ValaStruct* unichar_struct = NULL;
	ValaSymbol* _tmp125_;
	ValaScope* _tmp126_;
	ValaScope* _tmp127_;
	ValaSymbol* _tmp128_;
	ValaStruct* _tmp129_;
	ValaSymbol* glib_ns = NULL;
	ValaSymbol* _tmp132_;
	ValaScope* _tmp133_;
	ValaScope* _tmp134_;
	ValaSymbol* _tmp135_;
	ValaSymbol* _tmp136_;
	ValaScope* _tmp137_;
	ValaScope* _tmp138_;
	ValaSymbol* _tmp139_;
	ValaSymbol* _tmp140_;
	ValaScope* _tmp141_;
	ValaScope* _tmp142_;
	ValaSymbol* _tmp143_;
	ValaErrorType* _tmp144_;
	ValaSymbol* _tmp145_;
	ValaScope* _tmp146_;
	ValaScope* _tmp147_;
	ValaSymbol* _tmp148_;
	ValaSymbol* _tmp149_;
	ValaScope* _tmp150_;
	ValaScope* _tmp151_;
	ValaSymbol* _tmp152_;
	ValaSymbol* _tmp153_;
	ValaScope* _tmp154_;
	ValaScope* _tmp155_;
	ValaSymbol* _tmp156_;
	ValaSymbol* _tmp157_;
	ValaScope* _tmp158_;
	ValaScope* _tmp159_;
	ValaSymbol* _tmp160_;
	ValaSymbol* _tmp161_;
	ValaScope* _tmp162_;
	ValaScope* _tmp163_;
	ValaSymbol* _tmp164_;
	ValaSymbol* _tmp165_;
	ValaScope* _tmp166_;
	ValaScope* _tmp167_;
	ValaSymbol* _tmp168_;
	ValaSymbol* _tmp169_;
	ValaScope* _tmp170_;
	ValaScope* _tmp171_;
	ValaSymbol* _tmp172_;
	ValaSymbol* _tmp173_;
	ValaScope* _tmp174_;
	ValaScope* _tmp175_;
	ValaSymbol* _tmp176_;
	ValaSymbol* _tmp177_;
	ValaScope* _tmp178_;
	ValaScope* _tmp179_;
	ValaSymbol* _tmp180_;
	ValaSymbol* _tmp181_;
	ValaScope* _tmp182_;
	ValaScope* _tmp183_;
	ValaSymbol* _tmp184_;
	ValaSymbol* _tmp185_;
	ValaScope* _tmp186_;
	ValaScope* _tmp187_;
	ValaSymbol* _tmp188_;
	ValaDelegate* _tmp189_;
	ValaDelegateType* _tmp190_;
	ValaSymbol* _tmp191_;
	ValaScope* _tmp192_;
	ValaScope* _tmp193_;
	ValaSymbol* _tmp194_;
	ValaStruct* _tmp195_;
	ValaIntegerType* _tmp196_;
	ValaSymbol* _tmp197_;
	ValaScope* _tmp198_;
	ValaScope* _tmp199_;
	ValaSymbol* _tmp200_;
	ValaSymbol* _tmp201_;
	ValaScope* _tmp202_;
	ValaScope* _tmp203_;
	ValaSymbol* _tmp204_;
	ValaSymbol* _tmp205_;
	ValaScope* _tmp206_;
	ValaScope* _tmp207_;
	ValaSymbol* _tmp208_;
	ValaSymbol* _tmp209_;
	ValaScope* _tmp210_;
	ValaScope* _tmp211_;
	ValaSymbol* _tmp212_;
	ValaSymbol* _tmp213_;
	ValaScope* _tmp214_;
	ValaScope* _tmp215_;
	ValaSymbol* _tmp216_;
	ValaSymbol* _tmp217_;
	ValaScope* _tmp218_;
	ValaScope* _tmp219_;
	ValaSymbol* _tmp220_;
	ValaSymbol* _tmp221_;
	ValaScope* _tmp222_;
	ValaScope* _tmp223_;
	ValaSymbol* _tmp224_;
	ValaStruct* _tmp225_;
	ValaStruct* _tmp226_;
	ValaSymbol* _tmp227_;
	ValaScope* _tmp228_;
	ValaScope* _tmp229_;
	ValaSymbol* _tmp230_;
	ValaSymbol* _tmp231_;
	ValaScope* _tmp232_;
	ValaScope* _tmp233_;
	ValaSymbol* _tmp234_;
	ValaSymbol* _tmp235_;
	ValaScope* _tmp236_;
	ValaScope* _tmp237_;
	ValaSymbol* _tmp238_;
	ValaClass* _tmp239_;
	ValaObjectType* _tmp240_;
	ValaCodeContext* _tmp241_;
	ValaMethod* _tmp242_;
	ValaMethod* _tmp243_;
	ValaSymbol* _tmp273_;
	ValaScope* _tmp274_;
	ValaScope* _tmp275_;
	ValaSymbol* _tmp276_;
	ValaSymbol* gtk_ns = NULL;
	ValaSymbol* _tmp277_;
	ValaScope* _tmp278_;
	ValaScope* _tmp279_;
	ValaSymbol* _tmp280_;
	ValaSymbol* _tmp281_;
	ValaCCodeFile* _tmp286_;
	ValaCCodeFile* _tmp287_;
	ValaCCodeFile* _tmp288_;
	ValaCCodeFile* _tmp289_;
	ValaList* source_files = NULL;
	ValaCodeContext* _tmp290_;
	ValaList* _tmp291_;
	ValaCodeContext* _tmp315_;
	const gchar* _tmp316_;
	const gchar* _tmp317_;
	ValaCodeContext* _tmp342_;
	const gchar* _tmp343_;
	const gchar* _tmp344_;
	ValaCodeContext* _tmp359_;
	const gchar* _tmp360_;
	const gchar* _tmp361_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (context != NULL);
	_tmp0_ = context;
	vala_ccode_base_module_set_context (self, _tmp0_);
	_tmp1_ = context;
	_tmp2_ = vala_code_context_get_root (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp3_);
	_vala_code_node_unref0 (self->root_symbol);
	self->root_symbol = _tmp4_;
	_tmp5_ = self->root_symbol;
	_tmp6_ = vala_symbol_get_scope (_tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = vala_scope_lookup (_tmp7_, "bool");
	_tmp9_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp10_ = vala_boolean_type_new (_tmp9_);
	_vala_code_node_unref0 (self->bool_type);
	self->bool_type = (ValaDataType*) _tmp10_;
	_vala_code_node_unref0 (_tmp9_);
	_tmp11_ = self->root_symbol;
	_tmp12_ = vala_symbol_get_scope (_tmp11_);
	_tmp13_ = _tmp12_;
	_tmp14_ = vala_scope_lookup (_tmp13_, "char");
	_tmp15_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp16_ = vala_integer_type_new (_tmp15_, NULL, NULL);
	_vala_code_node_unref0 (self->char_type);
	self->char_type = (ValaDataType*) _tmp16_;
	_vala_code_node_unref0 (_tmp15_);
	_tmp17_ = self->root_symbol;
	_tmp18_ = vala_symbol_get_scope (_tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = vala_scope_lookup (_tmp19_, "uchar");
	_tmp21_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp22_ = vala_integer_type_new (_tmp21_, NULL, NULL);
	_vala_code_node_unref0 (self->uchar_type);
	self->uchar_type = (ValaDataType*) _tmp22_;
	_vala_code_node_unref0 (_tmp21_);
	_tmp23_ = self->root_symbol;
	_tmp24_ = vala_symbol_get_scope (_tmp23_);
	_tmp25_ = _tmp24_;
	_tmp26_ = vala_scope_lookup (_tmp25_, "short");
	_tmp27_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp28_ = vala_integer_type_new (_tmp27_, NULL, NULL);
	_vala_code_node_unref0 (self->short_type);
	self->short_type = (ValaDataType*) _tmp28_;
	_vala_code_node_unref0 (_tmp27_);
	_tmp29_ = self->root_symbol;
	_tmp30_ = vala_symbol_get_scope (_tmp29_);
	_tmp31_ = _tmp30_;
	_tmp32_ = vala_scope_lookup (_tmp31_, "ushort");
	_tmp33_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp32_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp34_ = vala_integer_type_new (_tmp33_, NULL, NULL);
	_vala_code_node_unref0 (self->ushort_type);
	self->ushort_type = (ValaDataType*) _tmp34_;
	_vala_code_node_unref0 (_tmp33_);
	_tmp35_ = self->root_symbol;
	_tmp36_ = vala_symbol_get_scope (_tmp35_);
	_tmp37_ = _tmp36_;
	_tmp38_ = vala_scope_lookup (_tmp37_, "int");
	_tmp39_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp38_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp40_ = vala_integer_type_new (_tmp39_, NULL, NULL);
	_vala_code_node_unref0 (self->int_type);
	self->int_type = (ValaDataType*) _tmp40_;
	_vala_code_node_unref0 (_tmp39_);
	_tmp41_ = self->root_symbol;
	_tmp42_ = vala_symbol_get_scope (_tmp41_);
	_tmp43_ = _tmp42_;
	_tmp44_ = vala_scope_lookup (_tmp43_, "uint");
	_tmp45_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp44_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp46_ = vala_integer_type_new (_tmp45_, NULL, NULL);
	_vala_code_node_unref0 (self->uint_type);
	self->uint_type = (ValaDataType*) _tmp46_;
	_vala_code_node_unref0 (_tmp45_);
	_tmp47_ = self->root_symbol;
	_tmp48_ = vala_symbol_get_scope (_tmp47_);
	_tmp49_ = _tmp48_;
	_tmp50_ = vala_scope_lookup (_tmp49_, "long");
	_tmp51_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp50_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp52_ = vala_integer_type_new (_tmp51_, NULL, NULL);
	_vala_code_node_unref0 (self->long_type);
	self->long_type = (ValaDataType*) _tmp52_;
	_vala_code_node_unref0 (_tmp51_);
	_tmp53_ = self->root_symbol;
	_tmp54_ = vala_symbol_get_scope (_tmp53_);
	_tmp55_ = _tmp54_;
	_tmp56_ = vala_scope_lookup (_tmp55_, "ulong");
	_tmp57_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp56_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp58_ = vala_integer_type_new (_tmp57_, NULL, NULL);
	_vala_code_node_unref0 (self->ulong_type);
	self->ulong_type = (ValaDataType*) _tmp58_;
	_vala_code_node_unref0 (_tmp57_);
	_tmp59_ = self->root_symbol;
	_tmp60_ = vala_symbol_get_scope (_tmp59_);
	_tmp61_ = _tmp60_;
	_tmp62_ = vala_scope_lookup (_tmp61_, "int8");
	_tmp63_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp62_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp64_ = vala_integer_type_new (_tmp63_, NULL, NULL);
	_vala_code_node_unref0 (self->int8_type);
	self->int8_type = (ValaDataType*) _tmp64_;
	_vala_code_node_unref0 (_tmp63_);
	_tmp65_ = self->root_symbol;
	_tmp66_ = vala_symbol_get_scope (_tmp65_);
	_tmp67_ = _tmp66_;
	_tmp68_ = vala_scope_lookup (_tmp67_, "uint8");
	_tmp69_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp68_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp70_ = vala_integer_type_new (_tmp69_, NULL, NULL);
	_vala_code_node_unref0 (self->uint8_type);
	self->uint8_type = (ValaDataType*) _tmp70_;
	_vala_code_node_unref0 (_tmp69_);
	_tmp71_ = self->root_symbol;
	_tmp72_ = vala_symbol_get_scope (_tmp71_);
	_tmp73_ = _tmp72_;
	_tmp74_ = vala_scope_lookup (_tmp73_, "int16");
	_tmp75_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp74_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp76_ = vala_integer_type_new (_tmp75_, NULL, NULL);
	_vala_code_node_unref0 (self->int16_type);
	self->int16_type = (ValaDataType*) _tmp76_;
	_vala_code_node_unref0 (_tmp75_);
	_tmp77_ = self->root_symbol;
	_tmp78_ = vala_symbol_get_scope (_tmp77_);
	_tmp79_ = _tmp78_;
	_tmp80_ = vala_scope_lookup (_tmp79_, "uint16");
	_tmp81_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp80_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp82_ = vala_integer_type_new (_tmp81_, NULL, NULL);
	_vala_code_node_unref0 (self->uint16_type);
	self->uint16_type = (ValaDataType*) _tmp82_;
	_vala_code_node_unref0 (_tmp81_);
	_tmp83_ = self->root_symbol;
	_tmp84_ = vala_symbol_get_scope (_tmp83_);
	_tmp85_ = _tmp84_;
	_tmp86_ = vala_scope_lookup (_tmp85_, "int32");
	_tmp87_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp86_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp88_ = vala_integer_type_new (_tmp87_, NULL, NULL);
	_vala_code_node_unref0 (self->int32_type);
	self->int32_type = (ValaDataType*) _tmp88_;
	_vala_code_node_unref0 (_tmp87_);
	_tmp89_ = self->root_symbol;
	_tmp90_ = vala_symbol_get_scope (_tmp89_);
	_tmp91_ = _tmp90_;
	_tmp92_ = vala_scope_lookup (_tmp91_, "uint32");
	_tmp93_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp92_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp94_ = vala_integer_type_new (_tmp93_, NULL, NULL);
	_vala_code_node_unref0 (self->uint32_type);
	self->uint32_type = (ValaDataType*) _tmp94_;
	_vala_code_node_unref0 (_tmp93_);
	_tmp95_ = self->root_symbol;
	_tmp96_ = vala_symbol_get_scope (_tmp95_);
	_tmp97_ = _tmp96_;
	_tmp98_ = vala_scope_lookup (_tmp97_, "int64");
	_tmp99_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp98_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp100_ = vala_integer_type_new (_tmp99_, NULL, NULL);
	_vala_code_node_unref0 (self->int64_type);
	self->int64_type = (ValaDataType*) _tmp100_;
	_vala_code_node_unref0 (_tmp99_);
	_tmp101_ = self->root_symbol;
	_tmp102_ = vala_symbol_get_scope (_tmp101_);
	_tmp103_ = _tmp102_;
	_tmp104_ = vala_scope_lookup (_tmp103_, "uint64");
	_tmp105_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp104_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp106_ = vala_integer_type_new (_tmp105_, NULL, NULL);
	_vala_code_node_unref0 (self->uint64_type);
	self->uint64_type = (ValaDataType*) _tmp106_;
	_vala_code_node_unref0 (_tmp105_);
	_tmp107_ = self->root_symbol;
	_tmp108_ = vala_symbol_get_scope (_tmp107_);
	_tmp109_ = _tmp108_;
	_tmp110_ = vala_scope_lookup (_tmp109_, "float");
	_tmp111_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp110_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp112_ = vala_floating_type_new (_tmp111_);
	_vala_code_node_unref0 (self->float_type);
	self->float_type = (ValaDataType*) _tmp112_;
	_vala_code_node_unref0 (_tmp111_);
	_tmp113_ = self->root_symbol;
	_tmp114_ = vala_symbol_get_scope (_tmp113_);
	_tmp115_ = _tmp114_;
	_tmp116_ = vala_scope_lookup (_tmp115_, "double");
	_tmp117_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp116_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp118_ = vala_floating_type_new (_tmp117_);
	_vala_code_node_unref0 (self->double_type);
	self->double_type = (ValaDataType*) _tmp118_;
	_vala_code_node_unref0 (_tmp117_);
	_tmp119_ = self->root_symbol;
	_tmp120_ = vala_symbol_get_scope (_tmp119_);
	_tmp121_ = _tmp120_;
	_tmp122_ = vala_scope_lookup (_tmp121_, "string");
	_tmp123_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp122_, VALA_TYPE_CLASS, ValaClass);
	_tmp124_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp123_);
	_vala_code_node_unref0 (self->string_type);
	self->string_type = (ValaDataType*) _tmp124_;
	_vala_code_node_unref0 (_tmp123_);
	_tmp125_ = self->root_symbol;
	_tmp126_ = vala_symbol_get_scope (_tmp125_);
	_tmp127_ = _tmp126_;
	_tmp128_ = vala_scope_lookup (_tmp127_, "unichar");
	unichar_struct = G_TYPE_CHECK_INSTANCE_CAST (_tmp128_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp129_ = unichar_struct;
	if (_tmp129_ != NULL) {
		ValaStruct* _tmp130_;
		ValaIntegerType* _tmp131_;
		_tmp130_ = unichar_struct;
		_tmp131_ = vala_integer_type_new (_tmp130_, NULL, NULL);
		_vala_code_node_unref0 (self->unichar_type);
		self->unichar_type = (ValaDataType*) _tmp131_;
	}
	_tmp132_ = self->root_symbol;
	_tmp133_ = vala_symbol_get_scope (_tmp132_);
	_tmp134_ = _tmp133_;
	_tmp135_ = vala_scope_lookup (_tmp134_, "GLib");
	glib_ns = _tmp135_;
	_tmp136_ = glib_ns;
	_tmp137_ = vala_symbol_get_scope (_tmp136_);
	_tmp138_ = _tmp137_;
	_tmp139_ = vala_scope_lookup (_tmp138_, "Type");
	_vala_code_node_unref0 (self->gtype_type);
	self->gtype_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp139_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	_tmp140_ = glib_ns;
	_tmp141_ = vala_symbol_get_scope (_tmp140_);
	_tmp142_ = _tmp141_;
	_tmp143_ = vala_scope_lookup (_tmp142_, "Object");
	_vala_code_node_unref0 (self->gobject_type);
	self->gobject_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp143_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	_tmp144_ = vala_error_type_new (NULL, NULL, NULL);
	_vala_code_node_unref0 (self->gerror_type);
	self->gerror_type = _tmp144_;
	_tmp145_ = glib_ns;
	_tmp146_ = vala_symbol_get_scope (_tmp145_);
	_tmp147_ = _tmp146_;
	_tmp148_ = vala_scope_lookup (_tmp147_, "List");
	_vala_code_node_unref0 (self->glist_type);
	self->glist_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp148_, VALA_TYPE_CLASS, ValaClass);
	_tmp149_ = glib_ns;
	_tmp150_ = vala_symbol_get_scope (_tmp149_);
	_tmp151_ = _tmp150_;
	_tmp152_ = vala_scope_lookup (_tmp151_, "SList");
	_vala_code_node_unref0 (self->gslist_type);
	self->gslist_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp152_, VALA_TYPE_CLASS, ValaClass);
	_tmp153_ = glib_ns;
	_tmp154_ = vala_symbol_get_scope (_tmp153_);
	_tmp155_ = _tmp154_;
	_tmp156_ = vala_scope_lookup (_tmp155_, "Node");
	_vala_code_node_unref0 (self->gnode_type);
	self->gnode_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp156_, VALA_TYPE_CLASS, ValaClass);
	_tmp157_ = glib_ns;
	_tmp158_ = vala_symbol_get_scope (_tmp157_);
	_tmp159_ = _tmp158_;
	_tmp160_ = vala_scope_lookup (_tmp159_, "Queue");
	_vala_code_node_unref0 (self->gqueue_type);
	self->gqueue_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp160_, VALA_TYPE_CLASS, ValaClass);
	_tmp161_ = glib_ns;
	_tmp162_ = vala_symbol_get_scope (_tmp161_);
	_tmp163_ = _tmp162_;
	_tmp164_ = vala_scope_lookup (_tmp163_, "ValueArray");
	_vala_code_node_unref0 (self->gvaluearray_type);
	self->gvaluearray_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp164_, VALA_TYPE_CLASS, ValaClass);
	_tmp165_ = glib_ns;
	_tmp166_ = vala_symbol_get_scope (_tmp165_);
	_tmp167_ = _tmp166_;
	_tmp168_ = vala_scope_lookup (_tmp167_, "StringBuilder");
	_vala_code_node_unref0 (self->gstringbuilder_type);
	self->gstringbuilder_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp168_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	_tmp169_ = glib_ns;
	_tmp170_ = vala_symbol_get_scope (_tmp169_);
	_tmp171_ = _tmp170_;
	_tmp172_ = vala_scope_lookup (_tmp171_, "Array");
	_vala_code_node_unref0 (self->garray_type);
	self->garray_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp172_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	_tmp173_ = glib_ns;
	_tmp174_ = vala_symbol_get_scope (_tmp173_);
	_tmp175_ = _tmp174_;
	_tmp176_ = vala_scope_lookup (_tmp175_, "ByteArray");
	_vala_code_node_unref0 (self->gbytearray_type);
	self->gbytearray_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp176_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	_tmp177_ = glib_ns;
	_tmp178_ = vala_symbol_get_scope (_tmp177_);
	_tmp179_ = _tmp178_;
	_tmp180_ = vala_scope_lookup (_tmp179_, "PtrArray");
	_vala_code_node_unref0 (self->gptrarray_type);
	self->gptrarray_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp180_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	_tmp181_ = glib_ns;
	_tmp182_ = vala_symbol_get_scope (_tmp181_);
	_tmp183_ = _tmp182_;
	_tmp184_ = vala_scope_lookup (_tmp183_, "ThreadPool");
	_vala_code_node_unref0 (self->gthreadpool_type);
	self->gthreadpool_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp184_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	_tmp185_ = glib_ns;
	_tmp186_ = vala_symbol_get_scope (_tmp185_);
	_tmp187_ = _tmp186_;
	_tmp188_ = vala_scope_lookup (_tmp187_, "DestroyNotify");
	_tmp189_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp188_, VALA_TYPE_DELEGATE, ValaDelegate);
	_tmp190_ = vala_delegate_type_new (_tmp189_);
	_vala_code_node_unref0 (self->gdestroynotify_type);
	self->gdestroynotify_type = (ValaDataType*) _tmp190_;
	_vala_code_node_unref0 (_tmp189_);
	_tmp191_ = glib_ns;
	_tmp192_ = vala_symbol_get_scope (_tmp191_);
	_tmp193_ = _tmp192_;
	_tmp194_ = vala_scope_lookup (_tmp193_, "Quark");
	_tmp195_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp194_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp196_ = vala_integer_type_new (_tmp195_, NULL, NULL);
	_vala_code_node_unref0 (self->gquark_type);
	self->gquark_type = (ValaDataType*) _tmp196_;
	_vala_code_node_unref0 (_tmp195_);
	_tmp197_ = glib_ns;
	_tmp198_ = vala_symbol_get_scope (_tmp197_);
	_tmp199_ = _tmp198_;
	_tmp200_ = vala_scope_lookup (_tmp199_, "Value");
	_vala_code_node_unref0 (self->gvalue_type);
	self->gvalue_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp200_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp201_ = glib_ns;
	_tmp202_ = vala_symbol_get_scope (_tmp201_);
	_tmp203_ = _tmp202_;
	_tmp204_ = vala_scope_lookup (_tmp203_, "Variant");
	_vala_code_node_unref0 (self->gvariant_type);
	self->gvariant_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp204_, VALA_TYPE_CLASS, ValaClass);
	_tmp205_ = glib_ns;
	_tmp206_ = vala_symbol_get_scope (_tmp205_);
	_tmp207_ = _tmp206_;
	_tmp208_ = vala_scope_lookup (_tmp207_, "Source");
	_vala_code_node_unref0 (self->gsource_type);
	self->gsource_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp208_, VALA_TYPE_CLASS, ValaClass);
	_tmp209_ = glib_ns;
	_tmp210_ = vala_symbol_get_scope (_tmp209_);
	_tmp211_ = _tmp210_;
	_tmp212_ = vala_scope_lookup (_tmp211_, "Mutex");
	_vala_code_node_unref0 (self->gmutex_type);
	self->gmutex_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp212_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp213_ = glib_ns;
	_tmp214_ = vala_symbol_get_scope (_tmp213_);
	_tmp215_ = _tmp214_;
	_tmp216_ = vala_scope_lookup (_tmp215_, "RecMutex");
	_vala_code_node_unref0 (self->grecmutex_type);
	self->grecmutex_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp216_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp217_ = glib_ns;
	_tmp218_ = vala_symbol_get_scope (_tmp217_);
	_tmp219_ = _tmp218_;
	_tmp220_ = vala_scope_lookup (_tmp219_, "RWLock");
	_vala_code_node_unref0 (self->grwlock_type);
	self->grwlock_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp220_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp221_ = glib_ns;
	_tmp222_ = vala_symbol_get_scope (_tmp221_);
	_tmp223_ = _tmp222_;
	_tmp224_ = vala_scope_lookup (_tmp223_, "Cond");
	_vala_code_node_unref0 (self->gcond_type);
	self->gcond_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp224_, VALA_TYPE_STRUCT, ValaStruct);
	_tmp225_ = self->grecmutex_type;
	_tmp226_ = _vala_code_node_ref0 (_tmp225_);
	_vala_code_node_unref0 (self->mutex_type);
	self->mutex_type = _tmp226_;
	_tmp227_ = glib_ns;
	_tmp228_ = vala_symbol_get_scope (_tmp227_);
	_tmp229_ = _tmp228_;
	_tmp230_ = vala_scope_lookup (_tmp229_, "TypeModule");
	_vala_code_node_unref0 (self->type_module_type);
	self->type_module_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp230_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	_tmp231_ = self->root_symbol;
	_tmp232_ = vala_symbol_get_scope (_tmp231_);
	_tmp233_ = _tmp232_;
	_tmp234_ = vala_scope_lookup (_tmp233_, "GLib");
	_tmp235_ = _tmp234_;
	_tmp236_ = vala_symbol_get_scope (_tmp235_);
	_tmp237_ = _tmp236_;
	_tmp238_ = vala_scope_lookup (_tmp237_, "Regex");
	_tmp239_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp238_, VALA_TYPE_CLASS, ValaClass);
	_tmp240_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp239_);
	_vala_code_node_unref0 (self->regex_type);
	self->regex_type = (ValaDataType*) _tmp240_;
	_vala_code_node_unref0 (_tmp239_);
	_vala_code_node_unref0 (_tmp235_);
	_tmp241_ = context;
	_tmp242_ = vala_code_context_get_module_init_method (_tmp241_);
	_tmp243_ = _tmp242_;
	if (_tmp243_ != NULL) {
		gboolean _tmp267_;
		{
			ValaList* _parameter_list = NULL;
			ValaCodeContext* _tmp244_;
			ValaMethod* _tmp245_;
			ValaMethod* _tmp246_;
			ValaList* _tmp247_;
			gint _parameter_size = 0;
			ValaList* _tmp248_;
			gint _tmp249_;
			gint _tmp250_;
			gint _parameter_index = 0;
			_tmp244_ = context;
			_tmp245_ = vala_code_context_get_module_init_method (_tmp244_);
			_tmp246_ = _tmp245_;
			_tmp247_ = vala_callable_get_parameters ((ValaCallable*) _tmp246_);
			_parameter_list = _tmp247_;
			_tmp248_ = _parameter_list;
			_tmp249_ = vala_collection_get_size ((ValaCollection*) _tmp248_);
			_tmp250_ = _tmp249_;
			_parameter_size = _tmp250_;
			_parameter_index = -1;
			while (TRUE) {
				gint _tmp251_;
				gint _tmp252_;
				gint _tmp253_;
				ValaParameter* parameter = NULL;
				ValaList* _tmp254_;
				gint _tmp255_;
				gpointer _tmp256_;
				ValaParameter* _tmp257_;
				ValaDataType* _tmp258_;
				ValaDataType* _tmp259_;
				ValaTypeSymbol* _tmp260_;
				ValaTypeSymbol* _tmp261_;
				ValaTypeSymbol* _tmp262_;
				_tmp251_ = _parameter_index;
				_parameter_index = _tmp251_ + 1;
				_tmp252_ = _parameter_index;
				_tmp253_ = _parameter_size;
				if (!(_tmp252_ < _tmp253_)) {
					break;
				}
				_tmp254_ = _parameter_list;
				_tmp255_ = _parameter_index;
				_tmp256_ = vala_list_get (_tmp254_, _tmp255_);
				parameter = (ValaParameter*) _tmp256_;
				_tmp257_ = parameter;
				_tmp258_ = vala_variable_get_variable_type ((ValaVariable*) _tmp257_);
				_tmp259_ = _tmp258_;
				_tmp260_ = vala_data_type_get_data_type (_tmp259_);
				_tmp261_ = _tmp260_;
				_tmp262_ = self->type_module_type;
				if (_tmp261_ == _tmp262_) {
					ValaParameter* _tmp263_;
					const gchar* _tmp264_;
					const gchar* _tmp265_;
					gchar* _tmp266_;
					self->in_plugin = TRUE;
					_tmp263_ = parameter;
					_tmp264_ = vala_symbol_get_name ((ValaSymbol*) _tmp263_);
					_tmp265_ = _tmp264_;
					_tmp266_ = g_strdup (_tmp265_);
					_g_free0 (self->module_init_param_name);
					self->module_init_param_name = _tmp266_;
					_vala_code_node_unref0 (parameter);
					break;
				}
				_vala_code_node_unref0 (parameter);
			}
			_vala_iterable_unref0 (_parameter_list);
		}
		_tmp267_ = self->in_plugin;
		if (!_tmp267_) {
			ValaCodeContext* _tmp268_;
			ValaMethod* _tmp269_;
			ValaMethod* _tmp270_;
			ValaSourceReference* _tmp271_;
			ValaSourceReference* _tmp272_;
			_tmp268_ = context;
			_tmp269_ = vala_code_context_get_module_init_method (_tmp268_);
			_tmp270_ = _tmp269_;
			_tmp271_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp270_);
			_tmp272_ = _tmp271_;
			vala_report_error (_tmp272_, "[ModuleInit] requires a parameter of type `GLib.TypeModule'");
		}
	}
	_tmp273_ = glib_ns;
	_tmp274_ = vala_symbol_get_scope (_tmp273_);
	_tmp275_ = _tmp274_;
	_tmp276_ = vala_scope_lookup (_tmp275_, "DBusProxy");
	_vala_code_node_unref0 (self->dbus_proxy_type);
	self->dbus_proxy_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp276_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	_tmp277_ = self->root_symbol;
	_tmp278_ = vala_symbol_get_scope (_tmp277_);
	_tmp279_ = _tmp278_;
	_tmp280_ = vala_scope_lookup (_tmp279_, "Gtk");
	gtk_ns = _tmp280_;
	_tmp281_ = gtk_ns;
	if (_tmp281_ != NULL) {
		ValaSymbol* _tmp282_;
		ValaScope* _tmp283_;
		ValaScope* _tmp284_;
		ValaSymbol* _tmp285_;
		_tmp282_ = gtk_ns;
		_tmp283_ = vala_symbol_get_scope (_tmp282_);
		_tmp284_ = _tmp283_;
		_tmp285_ = vala_scope_lookup (_tmp284_, "Widget");
		_vala_code_node_unref0 (self->gtk_widget_type);
		self->gtk_widget_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp285_, VALA_TYPE_CLASS, ValaClass);
	}
	_tmp286_ = vala_ccode_file_new ();
	_vala_ccode_file_unref0 (self->header_file);
	self->header_file = _tmp286_;
	_tmp287_ = self->header_file;
	vala_ccode_file_set_is_header (_tmp287_, TRUE);
	_tmp288_ = vala_ccode_file_new ();
	_vala_ccode_file_unref0 (self->internal_header_file);
	self->internal_header_file = _tmp288_;
	_tmp289_ = self->internal_header_file;
	vala_ccode_file_set_is_header (_tmp289_, TRUE);
	_tmp290_ = context;
	_tmp291_ = vala_code_context_get_source_files (_tmp290_);
	source_files = _tmp291_;
	{
		ValaList* _file_list = NULL;
		ValaList* _tmp292_;
		ValaList* _tmp293_;
		gint _file_size = 0;
		ValaList* _tmp294_;
		gint _tmp295_;
		gint _tmp296_;
		gint _file_index = 0;
		_tmp292_ = source_files;
		_tmp293_ = _vala_iterable_ref0 (_tmp292_);
		_file_list = _tmp293_;
		_tmp294_ = _file_list;
		_tmp295_ = vala_collection_get_size ((ValaCollection*) _tmp294_);
		_tmp296_ = _tmp295_;
		_file_size = _tmp296_;
		_file_index = -1;
		while (TRUE) {
			gint _tmp297_;
			gint _tmp298_;
			gint _tmp299_;
			ValaSourceFile* file = NULL;
			ValaList* _tmp300_;
			gint _tmp301_;
			gpointer _tmp302_;
			gboolean _tmp303_ = FALSE;
			ValaSourceFile* _tmp304_;
			ValaSourceFileType _tmp305_;
			ValaSourceFileType _tmp306_;
			_tmp297_ = _file_index;
			_file_index = _tmp297_ + 1;
			_tmp298_ = _file_index;
			_tmp299_ = _file_size;
			if (!(_tmp298_ < _tmp299_)) {
				break;
			}
			_tmp300_ = _file_list;
			_tmp301_ = _file_index;
			_tmp302_ = vala_list_get (_tmp300_, _tmp301_);
			file = (ValaSourceFile*) _tmp302_;
			_tmp304_ = file;
			_tmp305_ = vala_source_file_get_file_type (_tmp304_);
			_tmp306_ = _tmp305_;
			if (_tmp306_ == VALA_SOURCE_FILE_TYPE_SOURCE) {
				_tmp303_ = TRUE;
			} else {
				gboolean _tmp307_ = FALSE;
				ValaCodeContext* _tmp308_;
				const gchar* _tmp309_;
				const gchar* _tmp310_;
				_tmp308_ = context;
				_tmp309_ = vala_code_context_get_header_filename (_tmp308_);
				_tmp310_ = _tmp309_;
				if (_tmp310_ != NULL) {
					ValaSourceFile* _tmp311_;
					ValaSourceFileType _tmp312_;
					ValaSourceFileType _tmp313_;
					_tmp311_ = file;
					_tmp312_ = vala_source_file_get_file_type (_tmp311_);
					_tmp313_ = _tmp312_;
					_tmp307_ = _tmp313_ == VALA_SOURCE_FILE_TYPE_FAST;
				} else {
					_tmp307_ = FALSE;
				}
				_tmp303_ = _tmp307_;
			}
			if (_tmp303_) {
				ValaSourceFile* _tmp314_;
				_tmp314_ = file;
				vala_source_file_accept (_tmp314_, (ValaCodeVisitor*) self);
			}
			_vala_source_file_unref0 (file);
		}
		_vala_iterable_unref0 (_file_list);
	}
	_tmp315_ = context;
	_tmp316_ = vala_code_context_get_symbols_filename (_tmp315_);
	_tmp317_ = _tmp316_;
	if (_tmp317_ != NULL) {
		FILE* stream = NULL;
		ValaCodeContext* _tmp318_;
		const gchar* _tmp319_;
		const gchar* _tmp320_;
		FILE* _tmp321_;
		FILE* _tmp322_;
		_tmp318_ = context;
		_tmp319_ = vala_code_context_get_symbols_filename (_tmp318_);
		_tmp320_ = _tmp319_;
		_tmp321_ = g_fopen (_tmp320_, "w");
		stream = _tmp321_;
		_tmp322_ = stream;
		if (_tmp322_ == NULL) {
			ValaCodeContext* _tmp323_;
			const gchar* _tmp324_;
			const gchar* _tmp325_;
			gchar* _tmp326_;
			gchar* _tmp327_;
			_tmp323_ = context;
			_tmp324_ = vala_code_context_get_symbols_filename (_tmp323_);
			_tmp325_ = _tmp324_;
			_tmp326_ = g_strdup_printf ("unable to open `%s' for writing", _tmp325_);
			_tmp327_ = _tmp326_;
			vala_report_error (NULL, _tmp327_);
			_g_free0 (_tmp327_);
			_fclose0 (stream);
			_vala_iterable_unref0 (source_files);
			_vala_code_node_unref0 (gtk_ns);
			_vala_code_node_unref0 (glib_ns);
			_vala_code_node_unref0 (unichar_struct);
			return;
		}
		{
			ValaList* _symbol_list = NULL;
			ValaCCodeFile* _tmp328_;
			ValaList* _tmp329_;
			gint _symbol_size = 0;
			ValaList* _tmp330_;
			gint _tmp331_;
			gint _tmp332_;
			gint _symbol_index = 0;
			_tmp328_ = self->header_file;
			_tmp329_ = vala_ccode_file_get_symbols (_tmp328_);
			_symbol_list = _tmp329_;
			_tmp330_ = _symbol_list;
			_tmp331_ = vala_collection_get_size ((ValaCollection*) _tmp330_);
			_tmp332_ = _tmp331_;
			_symbol_size = _tmp332_;
			_symbol_index = -1;
			while (TRUE) {
				gint _tmp333_;
				gint _tmp334_;
				gint _tmp335_;
				gchar* symbol = NULL;
				ValaList* _tmp336_;
				gint _tmp337_;
				gpointer _tmp338_;
				FILE* _tmp339_;
				const gchar* _tmp340_;
				FILE* _tmp341_;
				_tmp333_ = _symbol_index;
				_symbol_index = _tmp333_ + 1;
				_tmp334_ = _symbol_index;
				_tmp335_ = _symbol_size;
				if (!(_tmp334_ < _tmp335_)) {
					break;
				}
				_tmp336_ = _symbol_list;
				_tmp337_ = _symbol_index;
				_tmp338_ = vala_list_get (_tmp336_, _tmp337_);
				symbol = (gchar*) _tmp338_;
				_tmp339_ = stream;
				_tmp340_ = symbol;
				fputs (_tmp340_, _tmp339_);
				_tmp341_ = stream;
				fputc ('\n', _tmp341_);
				_g_free0 (symbol);
			}
			_vala_iterable_unref0 (_symbol_list);
		}
		_fclose0 (stream);
		stream = NULL;
		_fclose0 (stream);
	}
	_tmp342_ = context;
	_tmp343_ = vala_code_context_get_header_filename (_tmp342_);
	_tmp344_ = _tmp343_;
	if (_tmp344_ != NULL) {
		gboolean ret = FALSE;
		ValaCCodeFile* _tmp345_;
		ValaCodeContext* _tmp346_;
		const gchar* _tmp347_;
		const gchar* _tmp348_;
		ValaCodeContext* _tmp349_;
		gboolean _tmp350_;
		gboolean _tmp351_;
		gboolean _tmp352_;
		gboolean _tmp353_;
		_tmp345_ = self->header_file;
		_tmp346_ = context;
		_tmp347_ = vala_code_context_get_header_filename (_tmp346_);
		_tmp348_ = _tmp347_;
		_tmp349_ = context;
		_tmp350_ = vala_code_context_get_version_header (_tmp349_);
		_tmp351_ = _tmp350_;
		_tmp352_ = vala_ccode_file_store (_tmp345_, _tmp348_, NULL, _tmp351_, FALSE, "G_BEGIN_DECLS", "G_END_DECLS");
		ret = _tmp352_;
		_tmp353_ = ret;
		if (!_tmp353_) {
			ValaCodeContext* _tmp354_;
			const gchar* _tmp355_;
			const gchar* _tmp356_;
			gchar* _tmp357_;
			gchar* _tmp358_;
			_tmp354_ = context;
			_tmp355_ = vala_code_context_get_header_filename (_tmp354_);
			_tmp356_ = _tmp355_;
			_tmp357_ = g_strdup_printf ("unable to open `%s' for writing", _tmp356_);
			_tmp358_ = _tmp357_;
			vala_report_error (NULL, _tmp358_);
			_g_free0 (_tmp358_);
		}
	}
	_tmp359_ = context;
	_tmp360_ = vala_code_context_get_internal_header_filename (_tmp359_);
	_tmp361_ = _tmp360_;
	if (_tmp361_ != NULL) {
		gboolean ret = FALSE;
		ValaCCodeFile* _tmp362_;
		ValaCodeContext* _tmp363_;
		const gchar* _tmp364_;
		const gchar* _tmp365_;
		ValaCodeContext* _tmp366_;
		gboolean _tmp367_;
		gboolean _tmp368_;
		gboolean _tmp369_;
		gboolean _tmp370_;
		_tmp362_ = self->internal_header_file;
		_tmp363_ = context;
		_tmp364_ = vala_code_context_get_internal_header_filename (_tmp363_);
		_tmp365_ = _tmp364_;
		_tmp366_ = context;
		_tmp367_ = vala_code_context_get_version_header (_tmp366_);
		_tmp368_ = _tmp367_;
		_tmp369_ = vala_ccode_file_store (_tmp362_, _tmp365_, NULL, _tmp368_, FALSE, "G_BEGIN_DECLS", "G_END_DECLS");
		ret = _tmp369_;
		_tmp370_ = ret;
		if (!_tmp370_) {
			ValaCodeContext* _tmp371_;
			const gchar* _tmp372_;
			const gchar* _tmp373_;
			gchar* _tmp374_;
			gchar* _tmp375_;
			_tmp371_ = context;
			_tmp372_ = vala_code_context_get_internal_header_filename (_tmp371_);
			_tmp373_ = _tmp372_;
			_tmp374_ = g_strdup_printf ("unable to open `%s' for writing", _tmp373_);
			_tmp375_ = _tmp374_;
			vala_report_error (NULL, _tmp375_);
			_g_free0 (_tmp375_);
		}
	}
	_vala_iterable_unref0 (source_files);
	_vala_code_node_unref0 (gtk_ns);
	_vala_code_node_unref0 (glib_ns);
	_vala_code_node_unref0 (unichar_struct);
}


static gpointer _vala_ccode_base_module_emit_context_ref0 (gpointer self) {
	return self ? vala_ccode_base_module_emit_context_ref (self) : NULL;
}


void vala_ccode_base_module_push_context (ValaCCodeBaseModule* self, ValaCCodeBaseModuleEmitContext* emit_context) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaCCodeBaseModuleEmitContext* _tmp3_;
	ValaCCodeBaseModuleEmitContext* _tmp4_;
	ValaCCodeFunction* _tmp5_;
	ValaCCodeFunction* _tmp6_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (emit_context != NULL);
	_tmp0_ = self->emit_context;
	if (_tmp0_ != NULL) {
		ValaList* _tmp1_;
		ValaCCodeBaseModuleEmitContext* _tmp2_;
		_tmp1_ = self->priv->emit_context_stack;
		_tmp2_ = self->emit_context;
		vala_collection_add ((ValaCollection*) _tmp1_, _tmp2_);
	}
	_tmp3_ = emit_context;
	_tmp4_ = _vala_ccode_base_module_emit_context_ref0 (_tmp3_);
	_vala_ccode_base_module_emit_context_unref0 (self->emit_context);
	self->emit_context = _tmp4_;
	_tmp5_ = vala_ccode_base_module_get_ccode (self);
	_tmp6_ = _tmp5_;
	if (_tmp6_ != NULL) {
		ValaCCodeFunction* _tmp7_;
		ValaCCodeFunction* _tmp8_;
		ValaCCodeLineDirective* _tmp9_;
		_tmp7_ = vala_ccode_base_module_get_ccode (self);
		_tmp8_ = _tmp7_;
		_tmp9_ = self->current_line;
		vala_ccode_function_set_current_line (_tmp8_, _tmp9_);
	}
}


void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self) {
	ValaList* _tmp0_;
	gint _tmp1_;
	gint _tmp2_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->priv->emit_context_stack;
	_tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ > 0) {
		ValaList* _tmp3_;
		ValaList* _tmp4_;
		gint _tmp5_;
		gint _tmp6_;
		gpointer _tmp7_;
		ValaList* _tmp8_;
		ValaList* _tmp9_;
		gint _tmp10_;
		gint _tmp11_;
		ValaCCodeFunction* _tmp12_;
		ValaCCodeFunction* _tmp13_;
		_tmp3_ = self->priv->emit_context_stack;
		_tmp4_ = self->priv->emit_context_stack;
		_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = vala_list_get (_tmp3_, _tmp6_ - 1);
		_vala_ccode_base_module_emit_context_unref0 (self->emit_context);
		self->emit_context = (ValaCCodeBaseModuleEmitContext*) _tmp7_;
		_tmp8_ = self->priv->emit_context_stack;
		_tmp9_ = self->priv->emit_context_stack;
		_tmp10_ = vala_collection_get_size ((ValaCollection*) _tmp9_);
		_tmp11_ = _tmp10_;
		vala_list_remove_at (_tmp8_, _tmp11_ - 1);
		_tmp12_ = vala_ccode_base_module_get_ccode (self);
		_tmp13_ = _tmp12_;
		if (_tmp13_ != NULL) {
			ValaCCodeFunction* _tmp14_;
			ValaCCodeFunction* _tmp15_;
			ValaCCodeLineDirective* _tmp16_;
			_tmp14_ = vala_ccode_base_module_get_ccode (self);
			_tmp15_ = _tmp14_;
			_tmp16_ = self->current_line;
			vala_ccode_function_set_current_line (_tmp15_, _tmp16_);
		}
	} else {
		_vala_ccode_base_module_emit_context_unref0 (self->emit_context);
		self->emit_context = NULL;
	}
}


void vala_ccode_base_module_push_line (ValaCCodeBaseModule* self, ValaSourceReference* source_reference) {
	ValaList* _tmp0_;
	ValaCCodeLineDirective* _tmp1_;
	ValaSourceReference* _tmp2_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->priv->line_directive_stack;
	_tmp1_ = self->current_line;
	vala_collection_add ((ValaCollection*) _tmp0_, _tmp1_);
	_tmp2_ = source_reference;
	if (_tmp2_ != NULL) {
		ValaSourceReference* _tmp3_;
		ValaSourceFile* _tmp4_;
		ValaSourceFile* _tmp5_;
		const gchar* _tmp6_;
		const gchar* _tmp7_;
		ValaSourceReference* _tmp8_;
		ValaSourceLocation _tmp9_ = {0};
		ValaSourceLocation _tmp10_;
		gint _tmp11_;
		ValaCCodeLineDirective* _tmp12_;
		ValaCCodeFunction* _tmp13_;
		ValaCCodeFunction* _tmp14_;
		_tmp3_ = source_reference;
		_tmp4_ = vala_source_reference_get_file (_tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = vala_source_file_get_filename (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = source_reference;
		vala_source_reference_get_begin (_tmp8_, &_tmp9_);
		_tmp10_ = _tmp9_;
		_tmp11_ = _tmp10_.line;
		_tmp12_ = vala_ccode_line_directive_new (_tmp7_, _tmp11_);
		_vala_ccode_node_unref0 (self->current_line);
		self->current_line = _tmp12_;
		_tmp13_ = vala_ccode_base_module_get_ccode (self);
		_tmp14_ = _tmp13_;
		if (_tmp14_ != NULL) {
			ValaCCodeFunction* _tmp15_;
			ValaCCodeFunction* _tmp16_;
			ValaCCodeLineDirective* _tmp17_;
			_tmp15_ = vala_ccode_base_module_get_ccode (self);
			_tmp16_ = _tmp15_;
			_tmp17_ = self->current_line;
			vala_ccode_function_set_current_line (_tmp16_, _tmp17_);
		}
	}
}


void vala_ccode_base_module_pop_line (ValaCCodeBaseModule* self) {
	ValaList* _tmp0_;
	ValaList* _tmp1_;
	gint _tmp2_;
	gint _tmp3_;
	gpointer _tmp4_;
	ValaList* _tmp5_;
	ValaList* _tmp6_;
	gint _tmp7_;
	gint _tmp8_;
	ValaCCodeFunction* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->priv->line_directive_stack;
	_tmp1_ = self->priv->line_directive_stack;
	_tmp2_ = vala_collection_get_size ((ValaCollection*) _tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_list_get (_tmp0_, _tmp3_ - 1);
	_vala_ccode_node_unref0 (self->current_line);
	self->current_line = (ValaCCodeLineDirective*) _tmp4_;
	_tmp5_ = self->priv->line_directive_stack;
	_tmp6_ = self->priv->line_directive_stack;
	_tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);
	_tmp8_ = _tmp7_;
	vala_list_remove_at (_tmp5_, _tmp8_ - 1);
	_tmp9_ = vala_ccode_base_module_get_ccode (self);
	_tmp10_ = _tmp9_;
	if (_tmp10_ != NULL) {
		ValaCCodeFunction* _tmp11_;
		ValaCCodeFunction* _tmp12_;
		ValaCCodeLineDirective* _tmp13_;
		_tmp11_ = vala_ccode_base_module_get_ccode (self);
		_tmp12_ = _tmp11_;
		_tmp13_ = self->current_line;
		vala_ccode_function_set_current_line (_tmp12_, _tmp13_);
	}
}


static gpointer _vala_ccode_node_ref0 (gpointer self) {
	return self ? vala_ccode_node_ref (self) : NULL;
}


void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaArrayList* _tmp1_;
	ValaCCodeFunction* _tmp2_;
	ValaCCodeFunction* _tmp3_;
	ValaCCodeBaseModuleEmitContext* _tmp4_;
	ValaCCodeFunction* _tmp5_;
	ValaCCodeFunction* _tmp6_;
	ValaCCodeFunction* _tmp7_;
	ValaCCodeFunction* _tmp8_;
	ValaCCodeLineDirective* _tmp9_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (func != NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->ccode_stack;
	_tmp2_ = vala_ccode_base_module_get_ccode (self);
	_tmp3_ = _tmp2_;
	vala_collection_add ((ValaCollection*) _tmp1_, _tmp3_);
	_tmp4_ = self->emit_context;
	_tmp5_ = func;
	_tmp6_ = _vala_ccode_node_ref0 (_tmp5_);
	_vala_ccode_node_unref0 (_tmp4_->ccode);
	_tmp4_->ccode = _tmp6_;
	_tmp7_ = vala_ccode_base_module_get_ccode (self);
	_tmp8_ = _tmp7_;
	_tmp9_ = self->current_line;
	vala_ccode_function_set_current_line (_tmp8_, _tmp9_);
}


void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaCCodeBaseModuleEmitContext* _tmp1_;
	ValaArrayList* _tmp2_;
	ValaCCodeBaseModuleEmitContext* _tmp3_;
	ValaArrayList* _tmp4_;
	gint _tmp5_;
	gint _tmp6_;
	gpointer _tmp7_;
	ValaCCodeBaseModuleEmitContext* _tmp8_;
	ValaArrayList* _tmp9_;
	ValaCCodeBaseModuleEmitContext* _tmp10_;
	ValaArrayList* _tmp11_;
	gint _tmp12_;
	gint _tmp13_;
	ValaCCodeFunction* _tmp14_;
	ValaCCodeFunction* _tmp15_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = self->emit_context;
	_tmp2_ = _tmp1_->ccode_stack;
	_tmp3_ = self->emit_context;
	_tmp4_ = _tmp3_->ccode_stack;
	_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = vala_list_get ((ValaList*) _tmp2_, _tmp6_ - 1);
	_vala_ccode_node_unref0 (_tmp0_->ccode);
	_tmp0_->ccode = (ValaCCodeFunction*) _tmp7_;
	_tmp8_ = self->emit_context;
	_tmp9_ = _tmp8_->ccode_stack;
	_tmp10_ = self->emit_context;
	_tmp11_ = _tmp10_->ccode_stack;
	_tmp12_ = vala_collection_get_size ((ValaCollection*) _tmp11_);
	_tmp13_ = _tmp12_;
	vala_list_remove_at ((ValaList*) _tmp9_, _tmp13_ - 1);
	_tmp14_ = vala_ccode_base_module_get_ccode (self);
	_tmp15_ = _tmp14_;
	if (_tmp15_ != NULL) {
		ValaCCodeFunction* _tmp16_;
		ValaCCodeFunction* _tmp17_;
		ValaCCodeLineDirective* _tmp18_;
		_tmp16_ = vala_ccode_base_module_get_ccode (self);
		_tmp17_ = _tmp16_;
		_tmp18_ = self->current_line;
		vala_ccode_function_set_current_line (_tmp17_, _tmp18_);
	}
}


gboolean vala_ccode_base_module_add_symbol_declaration (ValaCCodeBaseModule* self, ValaCCodeFile* decl_space, ValaSymbol* sym, const gchar* name) {
	gboolean result = FALSE;
	ValaCCodeFile* _tmp0_;
	const gchar* _tmp1_;
	gboolean _tmp2_;
	ValaSymbol* _tmp3_;
	ValaSourceReference* _tmp4_;
	ValaSourceReference* _tmp5_;
	gboolean _tmp11_ = FALSE;
	ValaSymbol* _tmp12_;
	gboolean _tmp13_;
	gboolean _tmp14_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (decl_space != NULL, FALSE);
	g_return_val_if_fail (sym != NULL, FALSE);
	g_return_val_if_fail (name != NULL, FALSE);
	_tmp0_ = decl_space;
	_tmp1_ = name;
	_tmp2_ = vala_ccode_file_add_declaration (_tmp0_, _tmp1_);
	if (_tmp2_) {
		result = TRUE;
		return result;
	}
	_tmp3_ = sym;
	_tmp4_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp3_);
	_tmp5_ = _tmp4_;
	if (_tmp5_ != NULL) {
		ValaSymbol* _tmp6_;
		ValaSourceReference* _tmp7_;
		ValaSourceReference* _tmp8_;
		ValaSourceFile* _tmp9_;
		ValaSourceFile* _tmp10_;
		_tmp6_ = sym;
		_tmp7_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = vala_source_reference_get_file (_tmp8_);
		_tmp10_ = _tmp9_;
		vala_source_file_set_used (_tmp10_, TRUE);
	}
	_tmp12_ = sym;
	_tmp13_ = vala_symbol_get_external_package (_tmp12_);
	_tmp14_ = _tmp13_;
	if (_tmp14_) {
		_tmp11_ = TRUE;
	} else {
		gboolean _tmp15_ = FALSE;
		gboolean _tmp16_ = FALSE;
		ValaCCodeFile* _tmp17_;
		gboolean _tmp18_;
		gboolean _tmp19_;
		_tmp17_ = decl_space;
		_tmp18_ = vala_ccode_file_get_is_header (_tmp17_);
		_tmp19_ = _tmp18_;
		if (!_tmp19_) {
			ValaCodeContext* _tmp20_;
			ValaCodeContext* _tmp21_;
			gboolean _tmp22_;
			gboolean _tmp23_;
			_tmp20_ = vala_code_context_get ();
			_tmp21_ = _tmp20_;
			_tmp22_ = vala_code_context_get_use_header (_tmp21_);
			_tmp23_ = _tmp22_;
			_tmp16_ = _tmp23_;
			_vala_code_context_unref0 (_tmp21_);
		} else {
			_tmp16_ = FALSE;
		}
		if (_tmp16_) {
			ValaSymbol* _tmp24_;
			gboolean _tmp25_;
			_tmp24_ = sym;
			_tmp25_ = vala_symbol_is_internal_symbol (_tmp24_);
			_tmp15_ = !_tmp25_;
		} else {
			_tmp15_ = FALSE;
		}
		_tmp11_ = _tmp15_;
	}
	if (_tmp11_) {
		ValaSymbol* _tmp26_;
		gchar* _tmp27_;
		gchar* _tmp28_;
		gchar** _tmp29_;
		gchar** _tmp30_;
		gchar** _tmp31_;
		gint _tmp31__length1;
		_tmp26_ = sym;
		_tmp27_ = vala_ccode_base_module_get_ccode_header_filenames (_tmp26_);
		_tmp28_ = _tmp27_;
		_tmp30_ = _tmp29_ = g_strsplit (_tmp28_, ",", 0);
		_tmp31_ = _tmp30_;
		_tmp31__length1 = _vala_array_length (_tmp29_);
		_g_free0 (_tmp28_);
		{
			gchar** header_filename_collection = NULL;
			gint header_filename_collection_length1 = 0;
			gint _header_filename_collection_size_ = 0;
			gint header_filename_it = 0;
			header_filename_collection = _tmp31_;
			header_filename_collection_length1 = _tmp31__length1;
			for (header_filename_it = 0; header_filename_it < _tmp31__length1; header_filename_it = header_filename_it + 1) {
				const gchar* header_filename = NULL;
				header_filename = header_filename_collection[header_filename_it];
				{
					gboolean _tmp32_ = FALSE;
					ValaSymbol* _tmp33_;
					gboolean _tmp34_;
					gboolean _tmp35_;
					ValaCCodeFile* _tmp43_;
					const gchar* _tmp44_;
					_tmp33_ = sym;
					_tmp34_ = vala_symbol_get_external_package (_tmp33_);
					_tmp35_ = _tmp34_;
					if (!_tmp35_) {
						_tmp32_ = TRUE;
					} else {
						gboolean _tmp36_ = FALSE;
						ValaSymbol* _tmp37_;
						gboolean _tmp38_;
						gboolean _tmp39_;
						_tmp37_ = sym;
						_tmp38_ = vala_symbol_get_external_package (_tmp37_);
						_tmp39_ = _tmp38_;
						if (_tmp39_) {
							ValaSymbol* _tmp40_;
							gboolean _tmp41_;
							gboolean _tmp42_;
							_tmp40_ = sym;
							_tmp41_ = vala_symbol_get_from_commandline (_tmp40_);
							_tmp42_ = _tmp41_;
							_tmp36_ = _tmp42_;
						} else {
							_tmp36_ = FALSE;
						}
						_tmp32_ = _tmp36_;
					}
					_tmp43_ = decl_space;
					_tmp44_ = header_filename;
					vala_ccode_file_add_include (_tmp43_, _tmp44_, _tmp32_);
				}
			}
			header_filename_collection = (_vala_array_free (header_filename_collection, header_filename_collection_length1, (GDestroyNotify) g_free), NULL);
		}
		result = TRUE;
		return result;
	} else {
		result = FALSE;
		return result;
	}
}


ValaCCodeIdentifier* vala_ccode_base_module_get_value_setter_function (ValaCCodeBaseModule* self, ValaDataType* type_reference) {
	ValaCCodeIdentifier* result = NULL;
	ValaArrayType* array_type = NULL;
	ValaDataType* _tmp0_;
	ValaArrayType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaTypeSymbol* _tmp3_;
	ValaTypeSymbol* _tmp4_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type_reference != NULL, NULL);
	_tmp0_ = type_reference;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp0_) : NULL);
	array_type = _tmp1_;
	_tmp2_ = type_reference;
	_tmp3_ = vala_data_type_get_data_type (_tmp2_);
	_tmp4_ = _tmp3_;
	if (_tmp4_ != NULL) {
		ValaDataType* _tmp5_;
		ValaTypeSymbol* _tmp6_;
		ValaTypeSymbol* _tmp7_;
		gchar* _tmp8_;
		gchar* _tmp9_;
		ValaCCodeIdentifier* _tmp10_;
		ValaCCodeIdentifier* _tmp11_;
		_tmp5_ = type_reference;
		_tmp6_ = vala_data_type_get_data_type (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_ccode_base_module_get_ccode_set_value_function ((ValaCodeNode*) _tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_ccode_identifier_new (_tmp9_);
		_tmp11_ = _tmp10_;
		_g_free0 (_tmp9_);
		result = _tmp11_;
		_vala_code_node_unref0 (array_type);
		return result;
	} else {
		gboolean _tmp12_ = FALSE;
		ValaArrayType* _tmp13_;
		_tmp13_ = array_type;
		if (_tmp13_ != NULL) {
			ValaArrayType* _tmp14_;
			ValaDataType* _tmp15_;
			ValaDataType* _tmp16_;
			ValaTypeSymbol* _tmp17_;
			ValaTypeSymbol* _tmp18_;
			ValaDataType* _tmp19_;
			ValaTypeSymbol* _tmp20_;
			ValaTypeSymbol* _tmp21_;
			_tmp14_ = array_type;
			_tmp15_ = vala_array_type_get_element_type (_tmp14_);
			_tmp16_ = _tmp15_;
			_tmp17_ = vala_data_type_get_data_type (_tmp16_);
			_tmp18_ = _tmp17_;
			_tmp19_ = self->string_type;
			_tmp20_ = vala_data_type_get_data_type (_tmp19_);
			_tmp21_ = _tmp20_;
			_tmp12_ = _tmp18_ == _tmp21_;
		} else {
			_tmp12_ = FALSE;
		}
		if (_tmp12_) {
			ValaCCodeIdentifier* _tmp22_;
			_tmp22_ = vala_ccode_identifier_new ("g_value_set_boxed");
			result = _tmp22_;
			_vala_code_node_unref0 (array_type);
			return result;
		} else {
			ValaCCodeIdentifier* _tmp23_;
			_tmp23_ = vala_ccode_identifier_new ("g_value_set_pointer");
			result = _tmp23_;
			_vala_code_node_unref0 (array_type);
			return result;
		}
	}
	_vala_code_node_unref0 (array_type);
}


ValaCCodeIdentifier* vala_ccode_base_module_get_value_taker_function (ValaCCodeBaseModule* self, ValaDataType* type_reference) {
	ValaCCodeIdentifier* result = NULL;
	ValaArrayType* array_type = NULL;
	ValaDataType* _tmp0_;
	ValaArrayType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaTypeSymbol* _tmp3_;
	ValaTypeSymbol* _tmp4_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type_reference != NULL, NULL);
	_tmp0_ = type_reference;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp0_) : NULL);
	array_type = _tmp1_;
	_tmp2_ = type_reference;
	_tmp3_ = vala_data_type_get_data_type (_tmp2_);
	_tmp4_ = _tmp3_;
	if (_tmp4_ != NULL) {
		ValaDataType* _tmp5_;
		ValaTypeSymbol* _tmp6_;
		ValaTypeSymbol* _tmp7_;
		gchar* _tmp8_;
		gchar* _tmp9_;
		ValaCCodeIdentifier* _tmp10_;
		ValaCCodeIdentifier* _tmp11_;
		_tmp5_ = type_reference;
		_tmp6_ = vala_data_type_get_data_type (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_ccode_base_module_get_ccode_take_value_function ((ValaCodeNode*) _tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_ccode_identifier_new (_tmp9_);
		_tmp11_ = _tmp10_;
		_g_free0 (_tmp9_);
		result = _tmp11_;
		_vala_code_node_unref0 (array_type);
		return result;
	} else {
		gboolean _tmp12_ = FALSE;
		ValaArrayType* _tmp13_;
		_tmp13_ = array_type;
		if (_tmp13_ != NULL) {
			ValaArrayType* _tmp14_;
			ValaDataType* _tmp15_;
			ValaDataType* _tmp16_;
			ValaTypeSymbol* _tmp17_;
			ValaTypeSymbol* _tmp18_;
			ValaDataType* _tmp19_;
			ValaTypeSymbol* _tmp20_;
			ValaTypeSymbol* _tmp21_;
			_tmp14_ = array_type;
			_tmp15_ = vala_array_type_get_element_type (_tmp14_);
			_tmp16_ = _tmp15_;
			_tmp17_ = vala_data_type_get_data_type (_tmp16_);
			_tmp18_ = _tmp17_;
			_tmp19_ = self->string_type;
			_tmp20_ = vala_data_type_get_data_type (_tmp19_);
			_tmp21_ = _tmp20_;
			_tmp12_ = _tmp18_ == _tmp21_;
		} else {
			_tmp12_ = FALSE;
		}
		if (_tmp12_) {
			ValaCCodeIdentifier* _tmp22_;
			_tmp22_ = vala_ccode_identifier_new ("g_value_take_boxed");
			result = _tmp22_;
			_vala_code_node_unref0 (array_type);
			return result;
		} else {
			ValaCCodeIdentifier* _tmp23_;
			_tmp23_ = vala_ccode_identifier_new ("g_value_set_pointer");
			result = _tmp23_;
			_vala_code_node_unref0 (array_type);
			return result;
		}
	}
	_vala_code_node_unref0 (array_type);
}


static ValaCCodeIdentifier* vala_ccode_base_module_get_value_getter_function (ValaCCodeBaseModule* self, ValaDataType* type_reference) {
	ValaCCodeIdentifier* result = NULL;
	ValaArrayType* array_type = NULL;
	ValaDataType* _tmp0_;
	ValaArrayType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaTypeSymbol* _tmp3_;
	ValaTypeSymbol* _tmp4_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type_reference != NULL, NULL);
	_tmp0_ = type_reference;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp0_) : NULL);
	array_type = _tmp1_;
	_tmp2_ = type_reference;
	_tmp3_ = vala_data_type_get_data_type (_tmp2_);
	_tmp4_ = _tmp3_;
	if (_tmp4_ != NULL) {
		ValaDataType* _tmp5_;
		ValaTypeSymbol* _tmp6_;
		ValaTypeSymbol* _tmp7_;
		gchar* _tmp8_;
		gchar* _tmp9_;
		ValaCCodeIdentifier* _tmp10_;
		ValaCCodeIdentifier* _tmp11_;
		_tmp5_ = type_reference;
		_tmp6_ = vala_data_type_get_data_type (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_ccode_base_module_get_ccode_get_value_function ((ValaCodeNode*) _tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_ccode_identifier_new (_tmp9_);
		_tmp11_ = _tmp10_;
		_g_free0 (_tmp9_);
		result = _tmp11_;
		_vala_code_node_unref0 (array_type);
		return result;
	} else {
		gboolean _tmp12_ = FALSE;
		ValaArrayType* _tmp13_;
		_tmp13_ = array_type;
		if (_tmp13_ != NULL) {
			ValaArrayType* _tmp14_;
			ValaDataType* _tmp15_;
			ValaDataType* _tmp16_;
			ValaTypeSymbol* _tmp17_;
			ValaTypeSymbol* _tmp18_;
			ValaDataType* _tmp19_;
			ValaTypeSymbol* _tmp20_;
			ValaTypeSymbol* _tmp21_;
			_tmp14_ = array_type;
			_tmp15_ = vala_array_type_get_element_type (_tmp14_);
			_tmp16_ = _tmp15_;
			_tmp17_ = vala_data_type_get_data_type (_tmp16_);
			_tmp18_ = _tmp17_;
			_tmp19_ = self->string_type;
			_tmp20_ = vala_data_type_get_data_type (_tmp19_);
			_tmp21_ = _tmp20_;
			_tmp12_ = _tmp18_ == _tmp21_;
		} else {
			_tmp12_ = FALSE;
		}
		if (_tmp12_) {
			ValaCCodeIdentifier* _tmp22_;
			_tmp22_ = vala_ccode_identifier_new ("g_value_get_boxed");
			result = _tmp22_;
			_vala_code_node_unref0 (array_type);
			return result;
		} else {
			ValaCCodeIdentifier* _tmp23_;
			_tmp23_ = vala_ccode_identifier_new ("g_value_get_pointer");
			result = _tmp23_;
			_vala_code_node_unref0 (array_type);
			return result;
		}
	}
	_vala_code_node_unref0 (array_type);
}


static void vala_ccode_base_module_real_append_vala_array_free (ValaCCodeBaseModule* self) {
}


void vala_ccode_base_module_append_vala_array_free (ValaCCodeBaseModule* self) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->append_vala_array_free (self);
}


static void vala_ccode_base_module_real_append_vala_array_move (ValaCCodeBaseModule* self) {
}


void vala_ccode_base_module_append_vala_array_move (ValaCCodeBaseModule* self) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->append_vala_array_move (self);
}


static void vala_ccode_base_module_real_append_vala_array_length (ValaCCodeBaseModule* self) {
}


void vala_ccode_base_module_append_vala_array_length (ValaCCodeBaseModule* self) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->append_vala_array_length (self);
}


void vala_ccode_base_module_append_vala_clear_mutex (ValaCCodeBaseModule* self, const gchar* typename, const gchar* funcprefix) {
	ValaCCodeFile* _tmp0_;
	ValaCCodeFunction* fun = NULL;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	ValaCCodeFunction* _tmp4_;
	ValaCCodeFunction* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	ValaCCodeParameter* _tmp9_;
	ValaCCodeParameter* _tmp10_;
	ValaCCodeFunction* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	const gchar* _tmp13_;
	ValaCCodeConstant* _tmp14_;
	ValaCCodeConstant* _tmp15_;
	ValaCCodeVariableDeclarator* _tmp16_;
	ValaCCodeVariableDeclarator* _tmp17_;
	ValaCCodeFunctionCall* cmp = NULL;
	ValaCCodeIdentifier* _tmp18_;
	ValaCCodeIdentifier* _tmp19_;
	ValaCCodeFunctionCall* _tmp20_;
	ValaCCodeFunctionCall* _tmp21_;
	ValaCCodeIdentifier* _tmp22_;
	ValaCCodeIdentifier* _tmp23_;
	ValaCCodeIdentifier* _tmp24_;
	ValaCCodeIdentifier* _tmp25_;
	ValaCCodeUnaryExpression* _tmp26_;
	ValaCCodeUnaryExpression* _tmp27_;
	const gchar* _tmp28_;
	gchar* _tmp29_;
	gchar* _tmp30_;
	gchar* _tmp31_;
	gchar* _tmp32_;
	ValaCCodeIdentifier* _tmp33_;
	ValaCCodeIdentifier* _tmp34_;
	ValaCCodeFunction* _tmp35_;
	ValaCCodeFunction* _tmp36_;
	ValaCCodeFunctionCall* mutex_clear = NULL;
	const gchar* _tmp37_;
	gchar* _tmp38_;
	gchar* _tmp39_;
	ValaCCodeIdentifier* _tmp40_;
	ValaCCodeIdentifier* _tmp41_;
	ValaCCodeFunctionCall* _tmp42_;
	ValaCCodeFunctionCall* _tmp43_;
	ValaCCodeIdentifier* _tmp44_;
	ValaCCodeIdentifier* _tmp45_;
	ValaCCodeFunction* _tmp46_;
	ValaCCodeFunction* _tmp47_;
	ValaCCodeFunctionCall* mset = NULL;
	ValaCCodeIdentifier* _tmp48_;
	ValaCCodeIdentifier* _tmp49_;
	ValaCCodeFunctionCall* _tmp50_;
	ValaCCodeFunctionCall* _tmp51_;
	ValaCCodeIdentifier* _tmp52_;
	ValaCCodeIdentifier* _tmp53_;
	ValaCCodeConstant* _tmp54_;
	ValaCCodeConstant* _tmp55_;
	const gchar* _tmp56_;
	gchar* _tmp57_;
	gchar* _tmp58_;
	gchar* _tmp59_;
	gchar* _tmp60_;
	ValaCCodeIdentifier* _tmp61_;
	ValaCCodeIdentifier* _tmp62_;
	ValaCCodeFunction* _tmp63_;
	ValaCCodeFunction* _tmp64_;
	ValaCCodeFunction* _tmp65_;
	ValaCCodeFunction* _tmp66_;
	ValaCCodeFile* _tmp67_;
	ValaCCodeFile* _tmp68_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (typename != NULL);
	g_return_if_fail (funcprefix != NULL);
	_tmp0_ = self->cfile;
	vala_ccode_file_add_include (_tmp0_, "string.h", FALSE);
	_tmp1_ = typename;
	_tmp2_ = g_strconcat ("_vala_clear_", _tmp1_, NULL);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_function_new (_tmp3_, "void");
	_tmp5_ = _tmp4_;
	_g_free0 (_tmp3_);
	fun = _tmp5_;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) fun, VALA_CCODE_MODIFIERS_STATIC);
	_tmp6_ = typename;
	_tmp7_ = g_strconcat (_tmp6_, " *", NULL);
	_tmp8_ = _tmp7_;
	_tmp9_ = vala_ccode_parameter_new ("mutex", _tmp8_);
	_tmp10_ = _tmp9_;
	vala_ccode_function_add_parameter (fun, _tmp10_);
	_vala_ccode_node_unref0 (_tmp10_);
	_g_free0 (_tmp8_);
	vala_ccode_base_module_push_function (self, fun);
	_tmp11_ = vala_ccode_base_module_get_ccode (self);
	_tmp12_ = _tmp11_;
	_tmp13_ = typename;
	_tmp14_ = vala_ccode_constant_new ("{ 0 }");
	_tmp15_ = _tmp14_;
	_tmp16_ = vala_ccode_variable_declarator_new_zero ("zero_mutex", (ValaCCodeExpression*) _tmp15_, NULL);
	_tmp17_ = _tmp16_;
	vala_ccode_function_add_declaration (_tmp12_, _tmp13_, (ValaCCodeDeclarator*) _tmp17_, 0);
	_vala_ccode_node_unref0 (_tmp17_);
	_vala_ccode_node_unref0 (_tmp15_);
	_tmp18_ = vala_ccode_identifier_new ("memcmp");
	_tmp19_ = _tmp18_;
	_tmp20_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp19_);
	_tmp21_ = _tmp20_;
	_vala_ccode_node_unref0 (_tmp19_);
	cmp = _tmp21_;
	_tmp22_ = vala_ccode_identifier_new ("mutex");
	_tmp23_ = _tmp22_;
	vala_ccode_function_call_add_argument (cmp, (ValaCCodeExpression*) _tmp23_);
	_vala_ccode_node_unref0 (_tmp23_);
	_tmp24_ = vala_ccode_identifier_new ("zero_mutex");
	_tmp25_ = _tmp24_;
	_tmp26_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp25_);
	_tmp27_ = _tmp26_;
	vala_ccode_function_call_add_argument (cmp, (ValaCCodeExpression*) _tmp27_);
	_vala_ccode_node_unref0 (_tmp27_);
	_vala_ccode_node_unref0 (_tmp25_);
	_tmp28_ = typename;
	_tmp29_ = g_strconcat ("sizeof (", _tmp28_, NULL);
	_tmp30_ = _tmp29_;
	_tmp31_ = g_strconcat (_tmp30_, ")", NULL);
	_tmp32_ = _tmp31_;
	_tmp33_ = vala_ccode_identifier_new (_tmp32_);
	_tmp34_ = _tmp33_;
	vala_ccode_function_call_add_argument (cmp, (ValaCCodeExpression*) _tmp34_);
	_vala_ccode_node_unref0 (_tmp34_);
	_g_free0 (_tmp32_);
	_g_free0 (_tmp30_);
	_tmp35_ = vala_ccode_base_module_get_ccode (self);
	_tmp36_ = _tmp35_;
	vala_ccode_function_open_if (_tmp36_, (ValaCCodeExpression*) cmp);
	_tmp37_ = funcprefix;
	_tmp38_ = g_strconcat (_tmp37_, "_clear", NULL);
	_tmp39_ = _tmp38_;
	_tmp40_ = vala_ccode_identifier_new (_tmp39_);
	_tmp41_ = _tmp40_;
	_tmp42_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp41_);
	_tmp43_ = _tmp42_;
	_vala_ccode_node_unref0 (_tmp41_);
	_g_free0 (_tmp39_);
	mutex_clear = _tmp43_;
	_tmp44_ = vala_ccode_identifier_new ("mutex");
	_tmp45_ = _tmp44_;
	vala_ccode_function_call_add_argument (mutex_clear, (ValaCCodeExpression*) _tmp45_);
	_vala_ccode_node_unref0 (_tmp45_);
	_tmp46_ = vala_ccode_base_module_get_ccode (self);
	_tmp47_ = _tmp46_;
	vala_ccode_function_add_expression (_tmp47_, (ValaCCodeExpression*) mutex_clear);
	_tmp48_ = vala_ccode_identifier_new ("memset");
	_tmp49_ = _tmp48_;
	_tmp50_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp49_);
	_tmp51_ = _tmp50_;
	_vala_ccode_node_unref0 (_tmp49_);
	mset = _tmp51_;
	_tmp52_ = vala_ccode_identifier_new ("mutex");
	_tmp53_ = _tmp52_;
	vala_ccode_function_call_add_argument (mset, (ValaCCodeExpression*) _tmp53_);
	_vala_ccode_node_unref0 (_tmp53_);
	_tmp54_ = vala_ccode_constant_new ("0");
	_tmp55_ = _tmp54_;
	vala_ccode_function_call_add_argument (mset, (ValaCCodeExpression*) _tmp55_);
	_vala_ccode_node_unref0 (_tmp55_);
	_tmp56_ = typename;
	_tmp57_ = g_strconcat ("sizeof (", _tmp56_, NULL);
	_tmp58_ = _tmp57_;
	_tmp59_ = g_strconcat (_tmp58_, ")", NULL);
	_tmp60_ = _tmp59_;
	_tmp61_ = vala_ccode_identifier_new (_tmp60_);
	_tmp62_ = _tmp61_;
	vala_ccode_function_call_add_argument (mset, (ValaCCodeExpression*) _tmp62_);
	_vala_ccode_node_unref0 (_tmp62_);
	_g_free0 (_tmp60_);
	_g_free0 (_tmp58_);
	_tmp63_ = vala_ccode_base_module_get_ccode (self);
	_tmp64_ = _tmp63_;
	vala_ccode_function_add_expression (_tmp64_, (ValaCCodeExpression*) mset);
	_tmp65_ = vala_ccode_base_module_get_ccode (self);
	_tmp66_ = _tmp65_;
	vala_ccode_function_close (_tmp66_);
	vala_ccode_base_module_pop_function (self);
	_tmp67_ = self->cfile;
	vala_ccode_file_add_function_declaration (_tmp67_, fun);
	_tmp68_ = self->cfile;
	vala_ccode_file_add_function (_tmp68_, fun);
	_vala_ccode_node_unref0 (mset);
	_vala_ccode_node_unref0 (mutex_clear);
	_vala_ccode_node_unref0 (cmp);
	_vala_ccode_node_unref0 (fun);
}


static void vala_ccode_base_module_real_visit_source_file (ValaCodeVisitor* base, ValaSourceFile* source_file) {
	ValaCCodeBaseModule * self;
	ValaCCodeFile* _tmp0_;
	GHashFunc _tmp1_;
	GEqualFunc _tmp2_;
	ValaHashSet* _tmp3_;
	GHashFunc _tmp4_;
	GEqualFunc _tmp5_;
	ValaHashSet* _tmp6_;
	GHashFunc _tmp7_;
	GEqualFunc _tmp8_;
	ValaHashSet* _tmp9_;
	ValaCCodeFile* _tmp10_;
	ValaCCodeFile* _tmp11_;
	ValaCCodeFile* _tmp12_;
	ValaCCodeFile* _tmp13_;
	ValaSourceFile* _tmp14_;
	ValaCodeContext* _tmp15_;
	ValaReport* _tmp16_;
	ValaReport* _tmp17_;
	gint _tmp18_;
	ValaSourceFile* _tmp19_;
	ValaSourceFileType _tmp20_;
	ValaSourceFileType _tmp21_;
	gboolean _tmp22_;
	gboolean _tmp43_;
	gboolean _tmp44_;
	gboolean _tmp45_;
	gboolean _tmp46_;
	gboolean _tmp47_;
	ValaList* comments = NULL;
	ValaSourceFile* _tmp49_;
	ValaList* _tmp50_;
	ValaList* _tmp51_;
	ValaCCodeFile* _tmp69_;
	ValaSourceFile* _tmp70_;
	gchar* _tmp71_;
	gchar* _tmp72_;
	ValaSourceFile* _tmp73_;
	const gchar* _tmp74_;
	const gchar* _tmp75_;
	ValaCodeContext* _tmp76_;
	gboolean _tmp77_;
	gboolean _tmp78_;
	ValaCodeContext* _tmp79_;
	gboolean _tmp80_;
	gboolean _tmp81_;
	gboolean _tmp82_;
	gboolean _tmp83_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (source_file != NULL);
	_tmp0_ = vala_ccode_file_new ();
	_vala_ccode_file_unref0 (self->cfile);
	self->cfile = _tmp0_;
	_tmp1_ = g_str_hash;
	_tmp2_ = g_str_equal;
	_tmp3_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp1_, _tmp2_);
	_vala_iterable_unref0 (self->user_marshal_set);
	self->user_marshal_set = (ValaSet*) _tmp3_;
	self->next_regex_id = 0;
	self->gvaluecollector_h_needed = FALSE;
	self->requires_assert = FALSE;
	self->requires_array_free = FALSE;
	self->requires_array_move = FALSE;
	self->requires_array_length = FALSE;
	self->requires_clear_mutex = FALSE;
	_tmp4_ = g_str_hash;
	_tmp5_ = g_str_equal;
	_tmp6_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp4_, _tmp5_);
	_vala_iterable_unref0 (self->wrappers);
	self->wrappers = (ValaSet*) _tmp6_;
	_tmp7_ = g_direct_hash;
	_tmp8_ = g_direct_equal;
	_tmp9_ = vala_hash_set_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp7_, _tmp8_);
	_vala_iterable_unref0 (self->priv->generated_external_symbols);
	self->priv->generated_external_symbols = (ValaSet*) _tmp9_;
	_tmp10_ = self->header_file;
	vala_ccode_file_add_include (_tmp10_, "glib.h", FALSE);
	_tmp11_ = self->internal_header_file;
	vala_ccode_file_add_include (_tmp11_, "glib.h", FALSE);
	_tmp12_ = self->cfile;
	vala_ccode_file_add_include (_tmp12_, "glib.h", FALSE);
	_tmp13_ = self->cfile;
	vala_ccode_file_add_include (_tmp13_, "glib-object.h", FALSE);
	_tmp14_ = source_file;
	vala_source_file_accept_children (_tmp14_, (ValaCodeVisitor*) self);
	_tmp15_ = self->priv->_context;
	_tmp16_ = vala_code_context_get_report (_tmp15_);
	_tmp17_ = _tmp16_;
	_tmp18_ = vala_report_get_errors (_tmp17_);
	if (_tmp18_ > 0) {
		return;
	}
	_tmp19_ = source_file;
	_tmp20_ = vala_source_file_get_file_type (_tmp19_);
	_tmp21_ = _tmp20_;
	if (_tmp21_ == VALA_SOURCE_FILE_TYPE_FAST) {
		return;
	}
	_tmp22_ = self->requires_assert;
	if (_tmp22_) {
		ValaCCodeFile* _tmp23_;
		ValaCCodeConstant* _tmp24_;
		ValaCCodeConstant* _tmp25_;
		ValaCCodeMacroReplacement* _tmp26_;
		ValaCCodeMacroReplacement* _tmp27_;
		ValaCCodeFile* _tmp28_;
		ValaCCodeConstant* _tmp29_;
		ValaCCodeConstant* _tmp30_;
		ValaCCodeMacroReplacement* _tmp31_;
		ValaCCodeMacroReplacement* _tmp32_;
		ValaCCodeFile* _tmp33_;
		ValaCCodeConstant* _tmp34_;
		ValaCCodeConstant* _tmp35_;
		ValaCCodeMacroReplacement* _tmp36_;
		ValaCCodeMacroReplacement* _tmp37_;
		ValaCCodeFile* _tmp38_;
		ValaCCodeConstant* _tmp39_;
		ValaCCodeConstant* _tmp40_;
		ValaCCodeMacroReplacement* _tmp41_;
		ValaCCodeMacroReplacement* _tmp42_;
		_tmp23_ = self->cfile;
		_tmp24_ = vala_ccode_constant_new ("if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FI" \
"LE__, __LINE__, G_STRFUNC, msg);");
		_tmp25_ = _tmp24_;
		_tmp26_ = vala_ccode_macro_replacement_new_with_expression ("_vala_assert(expr, msg)", (ValaCCodeExpression*) _tmp25_);
		_tmp27_ = _tmp26_;
		vala_ccode_file_add_type_declaration (_tmp23_, (ValaCCodeNode*) _tmp27_);
		_vala_ccode_node_unref0 (_tmp27_);
		_vala_ccode_node_unref0 (_tmp25_);
		_tmp28_ = self->cfile;
		_tmp29_ = vala_ccode_constant_new ("if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_" \
"STRFUNC, msg); return; }");
		_tmp30_ = _tmp29_;
		_tmp31_ = vala_ccode_macro_replacement_new_with_expression ("_vala_return_if_fail(expr, msg)", (ValaCCodeExpression*) _tmp30_);
		_tmp32_ = _tmp31_;
		vala_ccode_file_add_type_declaration (_tmp28_, (ValaCCodeNode*) _tmp32_);
		_vala_ccode_node_unref0 (_tmp32_);
		_vala_ccode_node_unref0 (_tmp30_);
		_tmp33_ = self->cfile;
		_tmp34_ = vala_ccode_constant_new ("if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_" \
"STRFUNC, msg); return val; }");
		_tmp35_ = _tmp34_;
		_tmp36_ = vala_ccode_macro_replacement_new_with_expression ("_vala_return_val_if_fail(expr, msg, val)", (ValaCCodeExpression*) _tmp35_);
		_tmp37_ = _tmp36_;
		vala_ccode_file_add_type_declaration (_tmp33_, (ValaCCodeNode*) _tmp37_);
		_vala_ccode_node_unref0 (_tmp37_);
		_vala_ccode_node_unref0 (_tmp35_);
		_tmp38_ = self->cfile;
		_tmp39_ = vala_ccode_constant_new ("if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LI" \
"NE__, G_STRFUNC, msg);");
		_tmp40_ = _tmp39_;
		_tmp41_ = vala_ccode_macro_replacement_new_with_expression ("_vala_warn_if_fail(expr, msg)", (ValaCCodeExpression*) _tmp40_);
		_tmp42_ = _tmp41_;
		vala_ccode_file_add_type_declaration (_tmp38_, (ValaCCodeNode*) _tmp42_);
		_vala_ccode_node_unref0 (_tmp42_);
		_vala_ccode_node_unref0 (_tmp40_);
	}
	_tmp43_ = self->requires_array_free;
	if (_tmp43_) {
		vala_ccode_base_module_append_vala_array_free (self);
	}
	_tmp44_ = self->requires_array_move;
	if (_tmp44_) {
		vala_ccode_base_module_append_vala_array_move (self);
	}
	_tmp45_ = self->requires_array_length;
	if (_tmp45_) {
		vala_ccode_base_module_append_vala_array_length (self);
	}
	_tmp46_ = self->requires_clear_mutex;
	if (_tmp46_) {
		vala_ccode_base_module_append_vala_clear_mutex (self, "GMutex", "g_mutex");
		vala_ccode_base_module_append_vala_clear_mutex (self, "GRecMutex", "g_rec_mutex");
		vala_ccode_base_module_append_vala_clear_mutex (self, "GRWLock", "g_rw_lock");
		vala_ccode_base_module_append_vala_clear_mutex (self, "GCond", "g_cond");
	}
	_tmp47_ = self->gvaluecollector_h_needed;
	if (_tmp47_) {
		ValaCCodeFile* _tmp48_;
		_tmp48_ = self->cfile;
		vala_ccode_file_add_include (_tmp48_, "gobject/gvaluecollector.h", FALSE);
	}
	_tmp49_ = source_file;
	_tmp50_ = vala_source_file_get_comments (_tmp49_);
	comments = _tmp50_;
	_tmp51_ = comments;
	if (_tmp51_ != NULL) {
		{
			ValaList* _comment_list = NULL;
			ValaList* _tmp52_;
			ValaList* _tmp53_;
			gint _comment_size = 0;
			ValaList* _tmp54_;
			gint _tmp55_;
			gint _tmp56_;
			gint _comment_index = 0;
			_tmp52_ = comments;
			_tmp53_ = _vala_iterable_ref0 (_tmp52_);
			_comment_list = _tmp53_;
			_tmp54_ = _comment_list;
			_tmp55_ = vala_collection_get_size ((ValaCollection*) _tmp54_);
			_tmp56_ = _tmp55_;
			_comment_size = _tmp56_;
			_comment_index = -1;
			while (TRUE) {
				gint _tmp57_;
				gint _tmp58_;
				gint _tmp59_;
				ValaComment* comment = NULL;
				ValaList* _tmp60_;
				gint _tmp61_;
				gpointer _tmp62_;
				ValaCCodeComment* ccomment = NULL;
				ValaComment* _tmp63_;
				const gchar* _tmp64_;
				const gchar* _tmp65_;
				ValaCCodeComment* _tmp66_;
				ValaCCodeFile* _tmp67_;
				ValaCCodeComment* _tmp68_;
				_tmp57_ = _comment_index;
				_comment_index = _tmp57_ + 1;
				_tmp58_ = _comment_index;
				_tmp59_ = _comment_size;
				if (!(_tmp58_ < _tmp59_)) {
					break;
				}
				_tmp60_ = _comment_list;
				_tmp61_ = _comment_index;
				_tmp62_ = vala_list_get (_tmp60_, _tmp61_);
				comment = (ValaComment*) _tmp62_;
				_tmp63_ = comment;
				_tmp64_ = vala_comment_get_content (_tmp63_);
				_tmp65_ = _tmp64_;
				_tmp66_ = vala_ccode_comment_new (_tmp65_);
				ccomment = _tmp66_;
				_tmp67_ = self->cfile;
				_tmp68_ = ccomment;
				vala_ccode_file_add_comment (_tmp67_, _tmp68_);
				_vala_ccode_node_unref0 (ccomment);
				_vala_comment_unref0 (comment);
			}
			_vala_iterable_unref0 (_comment_list);
		}
	}
	_tmp69_ = self->cfile;
	_tmp70_ = source_file;
	_tmp71_ = vala_source_file_get_csource_filename (_tmp70_);
	_tmp72_ = _tmp71_;
	_tmp73_ = source_file;
	_tmp74_ = vala_source_file_get_filename (_tmp73_);
	_tmp75_ = _tmp74_;
	_tmp76_ = self->priv->_context;
	_tmp77_ = vala_code_context_get_version_header (_tmp76_);
	_tmp78_ = _tmp77_;
	_tmp79_ = self->priv->_context;
	_tmp80_ = vala_code_context_get_debug (_tmp79_);
	_tmp81_ = _tmp80_;
	_tmp82_ = vala_ccode_file_store (_tmp69_, _tmp72_, _tmp75_, _tmp78_, _tmp81_, NULL, NULL);
	_tmp83_ = !_tmp82_;
	_g_free0 (_tmp72_);
	if (_tmp83_) {
		ValaSourceFile* _tmp84_;
		gchar* _tmp85_;
		gchar* _tmp86_;
		gchar* _tmp87_;
		gchar* _tmp88_;
		_tmp84_ = source_file;
		_tmp85_ = vala_source_file_get_csource_filename (_tmp84_);
		_tmp86_ = _tmp85_;
		_tmp87_ = g_strdup_printf ("unable to open `%s' for writing", _tmp86_);
		_tmp88_ = _tmp87_;
		vala_report_error (NULL, _tmp88_);
		_g_free0 (_tmp88_);
		_g_free0 (_tmp86_);
	}
	_vala_ccode_file_unref0 (self->cfile);
	self->cfile = NULL;
	_vala_iterable_unref0 (comments);
}


static gboolean vala_ccode_base_module_real_generate_enum_declaration (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space) {
	gboolean result = FALSE;
	ValaCCodeFile* _tmp0_;
	ValaEnum* _tmp1_;
	ValaEnum* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gboolean _tmp5_;
	gboolean _tmp6_;
	ValaCCodeEnum* cenum = NULL;
	ValaEnum* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	ValaCCodeEnum* _tmp10_;
	ValaCCodeEnum* _tmp11_;
	ValaCCodeModifiers _tmp12_ = 0;
	ValaEnum* _tmp13_;
	ValaVersionAttribute* _tmp14_;
	ValaVersionAttribute* _tmp15_;
	gboolean _tmp16_;
	gboolean _tmp17_;
	ValaCCodeEnum* _tmp18_;
	ValaCCodeEnum* _tmp19_;
	ValaCCodeModifiers _tmp20_;
	ValaCCodeModifiers _tmp21_;
	gint flag_shift = 0;
	ValaCCodeFile* _tmp74_;
	ValaCCodeEnum* _tmp75_;
	ValaCCodeFile* _tmp76_;
	ValaCCodeNewline* _tmp77_;
	ValaCCodeNewline* _tmp78_;
	ValaEnum* _tmp79_;
	gboolean _tmp80_;
	ValaCCodeFile* _tmp81_;
	ValaCCodeNewline* _tmp82_;
	ValaCCodeNewline* _tmp83_;
	gchar* macro = NULL;
	ValaEnum* _tmp84_;
	gchar* _tmp85_;
	gchar* _tmp86_;
	gchar* _tmp87_;
	gchar* _tmp88_;
	ValaCCodeFile* _tmp89_;
	ValaEnum* _tmp90_;
	gchar* _tmp91_;
	gchar* _tmp92_;
	const gchar* _tmp93_;
	ValaCCodeMacroReplacement* _tmp94_;
	ValaCCodeMacroReplacement* _tmp95_;
	gchar* fun_name = NULL;
	ValaEnum* _tmp96_;
	gchar* _tmp97_;
	gchar* _tmp98_;
	gchar* _tmp99_;
	gchar* _tmp100_;
	ValaCCodeFunction* regfun = NULL;
	const gchar* _tmp101_;
	ValaCCodeFunction* _tmp102_;
	ValaCCodeFunction* _tmp103_;
	ValaEnum* _tmp104_;
	gboolean _tmp105_;
	ValaCCodeFile* _tmp120_;
	ValaCCodeFunction* _tmp121_;
	g_return_val_if_fail (en != NULL, FALSE);
	g_return_val_if_fail (decl_space != NULL, FALSE);
	_tmp0_ = decl_space;
	_tmp1_ = en;
	_tmp2_ = en;
	_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_ccode_base_module_add_symbol_declaration (self, _tmp0_, (ValaSymbol*) _tmp1_, _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	if (_tmp6_) {
		result = FALSE;
		return result;
	}
	_tmp7_ = en;
	_tmp8_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_ccode_enum_new (_tmp9_);
	_tmp11_ = _tmp10_;
	_g_free0 (_tmp9_);
	cenum = _tmp11_;
	_tmp13_ = en;
	_tmp14_ = vala_symbol_get_version ((ValaSymbol*) _tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = vala_version_attribute_get_deprecated (_tmp15_);
	_tmp17_ = _tmp16_;
	if (_tmp17_) {
		_tmp12_ = VALA_CCODE_MODIFIERS_DEPRECATED;
	} else {
		_tmp12_ = 0;
	}
	_tmp18_ = cenum;
	_tmp19_ = cenum;
	_tmp20_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp19_);
	_tmp21_ = _tmp20_;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp19_, _tmp21_ | _tmp12_);
	flag_shift = 0;
	{
		ValaList* _ev_list = NULL;
		ValaEnum* _tmp22_;
		ValaList* _tmp23_;
		gint _ev_size = 0;
		ValaList* _tmp24_;
		gint _tmp25_;
		gint _tmp26_;
		gint _ev_index = 0;
		_tmp22_ = en;
		_tmp23_ = vala_enum_get_values (_tmp22_);
		_ev_list = _tmp23_;
		_tmp24_ = _ev_list;
		_tmp25_ = vala_collection_get_size ((ValaCollection*) _tmp24_);
		_tmp26_ = _tmp25_;
		_ev_size = _tmp26_;
		_ev_index = -1;
		while (TRUE) {
			gint _tmp27_;
			gint _tmp28_;
			gint _tmp29_;
			ValaEnumValue* ev = NULL;
			ValaList* _tmp30_;
			gint _tmp31_;
			gpointer _tmp32_;
			ValaCCodeEnumValue* c_ev = NULL;
			ValaEnumValue* _tmp33_;
			ValaExpression* _tmp34_;
			ValaExpression* _tmp35_;
			ValaCCodeModifiers _tmp62_ = 0;
			ValaEnumValue* _tmp63_;
			ValaVersionAttribute* _tmp64_;
			ValaVersionAttribute* _tmp65_;
			gboolean _tmp66_;
			gboolean _tmp67_;
			ValaCCodeEnumValue* _tmp68_;
			ValaCCodeEnumValue* _tmp69_;
			ValaCCodeModifiers _tmp70_;
			ValaCCodeModifiers _tmp71_;
			ValaCCodeEnum* _tmp72_;
			ValaCCodeEnumValue* _tmp73_;
			_tmp27_ = _ev_index;
			_ev_index = _tmp27_ + 1;
			_tmp28_ = _ev_index;
			_tmp29_ = _ev_size;
			if (!(_tmp28_ < _tmp29_)) {
				break;
			}
			_tmp30_ = _ev_list;
			_tmp31_ = _ev_index;
			_tmp32_ = vala_list_get (_tmp30_, _tmp31_);
			ev = (ValaEnumValue*) _tmp32_;
			_tmp33_ = ev;
			_tmp34_ = vala_constant_get_value ((ValaConstant*) _tmp33_);
			_tmp35_ = _tmp34_;
			if (_tmp35_ == NULL) {
				ValaEnumValue* _tmp36_;
				gchar* _tmp37_;
				gchar* _tmp38_;
				ValaCCodeEnumValue* _tmp39_;
				ValaEnum* _tmp40_;
				gboolean _tmp41_;
				gboolean _tmp42_;
				_tmp36_ = ev;
				_tmp37_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp36_);
				_tmp38_ = _tmp37_;
				_tmp39_ = vala_ccode_enum_value_new (_tmp38_, NULL);
				_vala_ccode_node_unref0 (c_ev);
				c_ev = _tmp39_;
				_g_free0 (_tmp38_);
				_tmp40_ = en;
				_tmp41_ = vala_enum_get_is_flags (_tmp40_);
				_tmp42_ = _tmp41_;
				if (_tmp42_) {
					ValaCCodeEnumValue* _tmp43_;
					gint _tmp44_;
					gchar* _tmp45_;
					gchar* _tmp46_;
					ValaCCodeConstant* _tmp47_;
					ValaCCodeConstant* _tmp48_;
					gint _tmp49_;
					_tmp43_ = c_ev;
					_tmp44_ = flag_shift;
					_tmp45_ = g_strdup_printf ("1 << %d", _tmp44_);
					_tmp46_ = _tmp45_;
					_tmp47_ = vala_ccode_constant_new (_tmp46_);
					_tmp48_ = _tmp47_;
					vala_ccode_enum_value_set_value (_tmp43_, (ValaCCodeExpression*) _tmp48_);
					_vala_ccode_node_unref0 (_tmp48_);
					_g_free0 (_tmp46_);
					_tmp49_ = flag_shift;
					flag_shift = _tmp49_ + 1;
				}
			} else {
				ValaEnumValue* _tmp50_;
				ValaExpression* _tmp51_;
				ValaExpression* _tmp52_;
				ValaEnumValue* _tmp53_;
				gchar* _tmp54_;
				gchar* _tmp55_;
				ValaEnumValue* _tmp56_;
				ValaExpression* _tmp57_;
				ValaExpression* _tmp58_;
				ValaCCodeExpression* _tmp59_;
				ValaCCodeExpression* _tmp60_;
				ValaCCodeEnumValue* _tmp61_;
				_tmp50_ = ev;
				_tmp51_ = vala_constant_get_value ((ValaConstant*) _tmp50_);
				_tmp52_ = _tmp51_;
				vala_code_node_emit ((ValaCodeNode*) _tmp52_, (ValaCodeGenerator*) self);
				_tmp53_ = ev;
				_tmp54_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp53_);
				_tmp55_ = _tmp54_;
				_tmp56_ = ev;
				_tmp57_ = vala_constant_get_value ((ValaConstant*) _tmp56_);
				_tmp58_ = _tmp57_;
				_tmp59_ = vala_ccode_base_module_get_cvalue (self, _tmp58_);
				_tmp60_ = _tmp59_;
				_tmp61_ = vala_ccode_enum_value_new (_tmp55_, _tmp60_);
				_vala_ccode_node_unref0 (c_ev);
				c_ev = _tmp61_;
				_vala_ccode_node_unref0 (_tmp60_);
				_g_free0 (_tmp55_);
			}
			_tmp63_ = ev;
			_tmp64_ = vala_symbol_get_version ((ValaSymbol*) _tmp63_);
			_tmp65_ = _tmp64_;
			_tmp66_ = vala_version_attribute_get_deprecated (_tmp65_);
			_tmp67_ = _tmp66_;
			if (_tmp67_) {
				_tmp62_ = VALA_CCODE_MODIFIERS_DEPRECATED;
			} else {
				_tmp62_ = 0;
			}
			_tmp68_ = c_ev;
			_tmp69_ = c_ev;
			_tmp70_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp69_);
			_tmp71_ = _tmp70_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp69_, _tmp71_ | _tmp62_);
			_tmp72_ = cenum;
			_tmp73_ = c_ev;
			vala_ccode_enum_add_value (_tmp72_, _tmp73_);
			_vala_ccode_node_unref0 (c_ev);
			_vala_code_node_unref0 (ev);
		}
		_vala_iterable_unref0 (_ev_list);
	}
	_tmp74_ = decl_space;
	_tmp75_ = cenum;
	vala_ccode_file_add_type_definition (_tmp74_, (ValaCCodeNode*) _tmp75_);
	_tmp76_ = decl_space;
	_tmp77_ = vala_ccode_newline_new ();
	_tmp78_ = _tmp77_;
	vala_ccode_file_add_type_definition (_tmp76_, (ValaCCodeNode*) _tmp78_);
	_vala_ccode_node_unref0 (_tmp78_);
	_tmp79_ = en;
	_tmp80_ = vala_ccode_base_module_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp79_);
	if (!_tmp80_) {
		result = TRUE;
		_vala_ccode_node_unref0 (cenum);
		return result;
	}
	_tmp81_ = decl_space;
	_tmp82_ = vala_ccode_newline_new ();
	_tmp83_ = _tmp82_;
	vala_ccode_file_add_type_declaration (_tmp81_, (ValaCCodeNode*) _tmp83_);
	_vala_ccode_node_unref0 (_tmp83_);
	_tmp84_ = en;
	_tmp85_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp84_, NULL);
	_tmp86_ = _tmp85_;
	_tmp87_ = g_strdup_printf ("(%s_get_type ())", _tmp86_);
	_tmp88_ = _tmp87_;
	_g_free0 (_tmp86_);
	macro = _tmp88_;
	_tmp89_ = decl_space;
	_tmp90_ = en;
	_tmp91_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp90_);
	_tmp92_ = _tmp91_;
	_tmp93_ = macro;
	_tmp94_ = vala_ccode_macro_replacement_new (_tmp92_, _tmp93_);
	_tmp95_ = _tmp94_;
	vala_ccode_file_add_type_declaration (_tmp89_, (ValaCCodeNode*) _tmp95_);
	_vala_ccode_node_unref0 (_tmp95_);
	_g_free0 (_tmp92_);
	_tmp96_ = en;
	_tmp97_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp96_, NULL);
	_tmp98_ = _tmp97_;
	_tmp99_ = g_strdup_printf ("%s_get_type", _tmp98_);
	_tmp100_ = _tmp99_;
	_g_free0 (_tmp98_);
	fun_name = _tmp100_;
	_tmp101_ = fun_name;
	_tmp102_ = vala_ccode_function_new (_tmp101_, "GType");
	regfun = _tmp102_;
	_tmp103_ = regfun;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp103_, VALA_CCODE_MODIFIERS_CONST);
	_tmp104_ = en;
	_tmp105_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp104_);
	if (_tmp105_) {
		ValaCCodeFunction* _tmp106_;
		ValaCCodeFunction* _tmp107_;
		ValaCCodeModifiers _tmp108_;
		ValaCCodeModifiers _tmp109_;
		_tmp106_ = regfun;
		_tmp107_ = regfun;
		_tmp108_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp107_);
		_tmp109_ = _tmp108_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp107_, _tmp109_ | (VALA_CCODE_MODIFIERS_STATIC | VALA_CCODE_MODIFIERS_UNUSED));
	} else {
		gboolean _tmp110_ = FALSE;
		ValaCodeContext* _tmp111_;
		gboolean _tmp112_;
		gboolean _tmp113_;
		_tmp111_ = self->priv->_context;
		_tmp112_ = vala_code_context_get_hide_internal (_tmp111_);
		_tmp113_ = _tmp112_;
		if (_tmp113_) {
			ValaEnum* _tmp114_;
			gboolean _tmp115_;
			_tmp114_ = en;
			_tmp115_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp114_);
			_tmp110_ = _tmp115_;
		} else {
			_tmp110_ = FALSE;
		}
		if (_tmp110_) {
			ValaCCodeFunction* _tmp116_;
			ValaCCodeFunction* _tmp117_;
			ValaCCodeModifiers _tmp118_;
			ValaCCodeModifiers _tmp119_;
			_tmp116_ = regfun;
			_tmp117_ = regfun;
			_tmp118_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp117_);
			_tmp119_ = _tmp118_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp117_, _tmp119_ | VALA_CCODE_MODIFIERS_INTERNAL);
		}
	}
	_tmp120_ = decl_space;
	_tmp121_ = regfun;
	vala_ccode_file_add_function_declaration (_tmp120_, _tmp121_);
	result = TRUE;
	_vala_ccode_node_unref0 (regfun);
	_g_free0 (fun_name);
	_g_free0 (macro);
	_vala_ccode_node_unref0 (cenum);
	return result;
}


gboolean vala_ccode_base_module_generate_enum_declaration (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space) {
	g_return_val_if_fail (self != NULL, FALSE);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_enum_declaration (self, en, decl_space);
}


static void vala_ccode_base_module_real_visit_enum (ValaCodeVisitor* base, ValaEnum* en) {
	ValaCCodeBaseModule * self;
	ValaEnum* _tmp0_;
	ValaSourceReference* _tmp1_;
	ValaSourceReference* _tmp2_;
	ValaEnum* _tmp3_;
	ValaEnum* _tmp4_;
	ValaComment* _tmp5_;
	ValaComment* _tmp6_;
	ValaEnum* _tmp15_;
	ValaCCodeFile* _tmp16_;
	ValaEnum* _tmp17_;
	gboolean _tmp18_;
	ValaEnum* _tmp21_;
	gboolean _tmp22_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (en != NULL);
	_tmp0_ = en;
	_tmp1_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	vala_ccode_base_module_push_line (self, _tmp2_);
	_tmp3_ = en;
	vala_code_node_accept_children ((ValaCodeNode*) _tmp3_, (ValaCodeVisitor*) self);
	_tmp4_ = en;
	_tmp5_ = vala_symbol_get_comment ((ValaSymbol*) _tmp4_);
	_tmp6_ = _tmp5_;
	if (_tmp6_ != NULL) {
		ValaCCodeFile* _tmp7_;
		ValaEnum* _tmp8_;
		ValaComment* _tmp9_;
		ValaComment* _tmp10_;
		const gchar* _tmp11_;
		const gchar* _tmp12_;
		ValaCCodeComment* _tmp13_;
		ValaCCodeComment* _tmp14_;
		_tmp7_ = self->cfile;
		_tmp8_ = en;
		_tmp9_ = vala_symbol_get_comment ((ValaSymbol*) _tmp8_);
		_tmp10_ = _tmp9_;
		_tmp11_ = vala_comment_get_content (_tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = vala_ccode_comment_new (_tmp12_);
		_tmp14_ = _tmp13_;
		vala_ccode_file_add_type_member_definition (_tmp7_, (ValaCCodeNode*) _tmp14_);
		_vala_ccode_node_unref0 (_tmp14_);
	}
	_tmp15_ = en;
	_tmp16_ = self->cfile;
	vala_ccode_base_module_generate_enum_declaration (self, _tmp15_, _tmp16_);
	_tmp17_ = en;
	_tmp18_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp17_);
	if (!_tmp18_) {
		ValaEnum* _tmp19_;
		ValaCCodeFile* _tmp20_;
		_tmp19_ = en;
		_tmp20_ = self->header_file;
		vala_ccode_base_module_generate_enum_declaration (self, _tmp19_, _tmp20_);
	}
	_tmp21_ = en;
	_tmp22_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp21_);
	if (!_tmp22_) {
		ValaEnum* _tmp23_;
		ValaCCodeFile* _tmp24_;
		_tmp23_ = en;
		_tmp24_ = self->internal_header_file;
		vala_ccode_base_module_generate_enum_declaration (self, _tmp23_, _tmp24_);
	}
	vala_ccode_base_module_pop_line (self);
}


void vala_ccode_base_module_visit_member (ValaCCodeBaseModule* self, ValaSymbol* m) {
	gboolean _tmp0_ = FALSE;
	ValaSymbol* _tmp1_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (m != NULL);
	_tmp1_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_LOCKABLE)) {
		ValaSymbol* _tmp2_;
		gboolean _tmp3_;
		_tmp2_ = m;
		_tmp3_ = vala_lockable_get_lock_used (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_LOCKABLE, ValaLockable));
		_tmp0_ = _tmp3_;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		ValaCCodeExpression* l = NULL;
		ValaCCodeIdentifier* _tmp4_;
		ValaCCodeBaseModuleEmitContext* init_context = NULL;
		ValaCCodeBaseModuleEmitContext* _tmp5_;
		ValaCCodeBaseModuleEmitContext* _tmp6_;
		ValaCCodeBaseModuleEmitContext* finalize_context = NULL;
		ValaCCodeBaseModuleEmitContext* _tmp7_;
		ValaCCodeBaseModuleEmitContext* _tmp8_;
		ValaSymbol* _tmp9_;
		gboolean _tmp10_;
		ValaCCodeBaseModuleEmitContext* _tmp62_;
		ValaCCodeFunctionCall* initf = NULL;
		ValaStruct* _tmp63_;
		ValaMethod* _tmp64_;
		ValaMethod* _tmp65_;
		gchar* _tmp66_;
		gchar* _tmp67_;
		ValaCCodeIdentifier* _tmp68_;
		ValaCCodeIdentifier* _tmp69_;
		ValaCCodeFunctionCall* _tmp70_;
		ValaCCodeFunctionCall* _tmp71_;
		ValaCCodeFunctionCall* _tmp72_;
		ValaCCodeExpression* _tmp73_;
		ValaCCodeUnaryExpression* _tmp74_;
		ValaCCodeUnaryExpression* _tmp75_;
		ValaCCodeFunction* _tmp76_;
		ValaCCodeFunction* _tmp77_;
		ValaCCodeFunctionCall* _tmp78_;
		ValaCCodeBaseModuleEmitContext* _tmp79_;
		_tmp4_ = vala_ccode_identifier_new ("self");
		l = (ValaCCodeExpression*) _tmp4_;
		_tmp5_ = self->class_init_context;
		_tmp6_ = _vala_ccode_base_module_emit_context_ref0 (_tmp5_);
		init_context = _tmp6_;
		_tmp7_ = self->class_finalize_context;
		_tmp8_ = _vala_ccode_base_module_emit_context_ref0 (_tmp7_);
		finalize_context = _tmp8_;
		_tmp9_ = m;
		_tmp10_ = vala_symbol_is_instance_member (_tmp9_);
		if (_tmp10_) {
			ValaCCodeExpression* _tmp11_;
			ValaCCodeMemberAccess* _tmp12_;
			ValaCCodeMemberAccess* _tmp13_;
			ValaSymbol* _tmp14_;
			const gchar* _tmp15_;
			const gchar* _tmp16_;
			gchar* _tmp17_;
			gchar* _tmp18_;
			ValaCCodeMemberAccess* _tmp19_;
			ValaCCodeBaseModuleEmitContext* _tmp20_;
			ValaCCodeBaseModuleEmitContext* _tmp21_;
			ValaCCodeBaseModuleEmitContext* _tmp22_;
			ValaCCodeBaseModuleEmitContext* _tmp23_;
			_tmp11_ = l;
			_tmp12_ = vala_ccode_member_access_new_pointer (_tmp11_, "priv");
			_tmp13_ = _tmp12_;
			_tmp14_ = m;
			_tmp15_ = vala_symbol_get_name (_tmp14_);
			_tmp16_ = _tmp15_;
			_tmp17_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp16_);
			_tmp18_ = _tmp17_;
			_tmp19_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp13_, _tmp18_);
			_vala_ccode_node_unref0 (l);
			l = (ValaCCodeExpression*) _tmp19_;
			_g_free0 (_tmp18_);
			_vala_ccode_node_unref0 (_tmp13_);
			_tmp20_ = self->instance_init_context;
			_tmp21_ = _vala_ccode_base_module_emit_context_ref0 (_tmp20_);
			_vala_ccode_base_module_emit_context_unref0 (init_context);
			init_context = _tmp21_;
			_tmp22_ = self->instance_finalize_context;
			_tmp23_ = _vala_ccode_base_module_emit_context_ref0 (_tmp22_);
			_vala_ccode_base_module_emit_context_unref0 (finalize_context);
			finalize_context = _tmp23_;
		} else {
			ValaSymbol* _tmp24_;
			gboolean _tmp25_;
			_tmp24_ = m;
			_tmp25_ = vala_symbol_is_class_member (_tmp24_);
			if (_tmp25_) {
				ValaTypeSymbol* parent = NULL;
				ValaSymbol* _tmp26_;
				ValaSymbol* _tmp27_;
				ValaSymbol* _tmp28_;
				ValaTypeSymbol* _tmp29_;
				ValaCCodeFunctionCall* get_class_private_call = NULL;
				ValaTypeSymbol* _tmp30_;
				gchar* _tmp31_;
				gchar* _tmp32_;
				gchar* _tmp33_;
				gchar* _tmp34_;
				ValaCCodeIdentifier* _tmp35_;
				ValaCCodeIdentifier* _tmp36_;
				ValaCCodeFunctionCall* _tmp37_;
				ValaCCodeFunctionCall* _tmp38_;
				ValaCCodeFunctionCall* _tmp39_;
				ValaCCodeIdentifier* _tmp40_;
				ValaCCodeIdentifier* _tmp41_;
				ValaCCodeFunctionCall* _tmp42_;
				ValaSymbol* _tmp43_;
				const gchar* _tmp44_;
				const gchar* _tmp45_;
				gchar* _tmp46_;
				gchar* _tmp47_;
				ValaCCodeMemberAccess* _tmp48_;
				_tmp26_ = m;
				_tmp27_ = vala_symbol_get_parent_symbol (_tmp26_);
				_tmp28_ = _tmp27_;
				_tmp29_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp28_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
				parent = _tmp29_;
				_tmp30_ = parent;
				_tmp31_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp30_, NULL);
				_tmp32_ = _tmp31_;
				_tmp33_ = g_strdup_printf ("%s_GET_CLASS_PRIVATE", _tmp32_);
				_tmp34_ = _tmp33_;
				_tmp35_ = vala_ccode_identifier_new (_tmp34_);
				_tmp36_ = _tmp35_;
				_tmp37_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp36_);
				_tmp38_ = _tmp37_;
				_vala_ccode_node_unref0 (_tmp36_);
				_g_free0 (_tmp34_);
				_g_free0 (_tmp32_);
				get_class_private_call = _tmp38_;
				_tmp39_ = get_class_private_call;
				_tmp40_ = vala_ccode_identifier_new ("klass");
				_tmp41_ = _tmp40_;
				vala_ccode_function_call_add_argument (_tmp39_, (ValaCCodeExpression*) _tmp41_);
				_vala_ccode_node_unref0 (_tmp41_);
				_tmp42_ = get_class_private_call;
				_tmp43_ = m;
				_tmp44_ = vala_symbol_get_name (_tmp43_);
				_tmp45_ = _tmp44_;
				_tmp46_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp45_);
				_tmp47_ = _tmp46_;
				_tmp48_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp42_, _tmp47_);
				_vala_ccode_node_unref0 (l);
				l = (ValaCCodeExpression*) _tmp48_;
				_g_free0 (_tmp47_);
				_vala_ccode_node_unref0 (get_class_private_call);
				_vala_code_node_unref0 (parent);
			} else {
				ValaSymbol* _tmp49_;
				ValaSymbol* _tmp50_;
				ValaSymbol* _tmp51_;
				gchar* _tmp52_;
				gchar* _tmp53_;
				ValaSymbol* _tmp54_;
				const gchar* _tmp55_;
				const gchar* _tmp56_;
				gchar* _tmp57_;
				gchar* _tmp58_;
				gchar* _tmp59_;
				gchar* _tmp60_;
				ValaCCodeIdentifier* _tmp61_;
				_tmp49_ = m;
				_tmp50_ = vala_symbol_get_parent_symbol (_tmp49_);
				_tmp51_ = _tmp50_;
				_tmp52_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp51_, NULL);
				_tmp53_ = _tmp52_;
				_tmp54_ = m;
				_tmp55_ = vala_symbol_get_name (_tmp54_);
				_tmp56_ = _tmp55_;
				_tmp57_ = g_strdup_printf ("%s_%s", _tmp53_, _tmp56_);
				_tmp58_ = _tmp57_;
				_tmp59_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp58_);
				_tmp60_ = _tmp59_;
				_tmp61_ = vala_ccode_identifier_new (_tmp60_);
				_vala_ccode_node_unref0 (l);
				l = (ValaCCodeExpression*) _tmp61_;
				_g_free0 (_tmp60_);
				_g_free0 (_tmp58_);
				_g_free0 (_tmp53_);
			}
		}
		_tmp62_ = init_context;
		vala_ccode_base_module_push_context (self, _tmp62_);
		_tmp63_ = self->mutex_type;
		_tmp64_ = vala_struct_get_default_construction_method (_tmp63_);
		_tmp65_ = _tmp64_;
		_tmp66_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp65_);
		_tmp67_ = _tmp66_;
		_tmp68_ = vala_ccode_identifier_new (_tmp67_);
		_tmp69_ = _tmp68_;
		_tmp70_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp69_);
		_tmp71_ = _tmp70_;
		_vala_ccode_node_unref0 (_tmp69_);
		_g_free0 (_tmp67_);
		initf = _tmp71_;
		_tmp72_ = initf;
		_tmp73_ = l;
		_tmp74_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp73_);
		_tmp75_ = _tmp74_;
		vala_ccode_function_call_add_argument (_tmp72_, (ValaCCodeExpression*) _tmp75_);
		_vala_ccode_node_unref0 (_tmp75_);
		_tmp76_ = vala_ccode_base_module_get_ccode (self);
		_tmp77_ = _tmp76_;
		_tmp78_ = initf;
		vala_ccode_function_add_expression (_tmp77_, (ValaCCodeExpression*) _tmp78_);
		vala_ccode_base_module_pop_context (self);
		_tmp79_ = finalize_context;
		if (_tmp79_ != NULL) {
			ValaCCodeBaseModuleEmitContext* _tmp80_;
			ValaCCodeFunctionCall* fc = NULL;
			ValaCCodeIdentifier* _tmp81_;
			ValaCCodeIdentifier* _tmp82_;
			ValaCCodeFunctionCall* _tmp83_;
			ValaCCodeFunctionCall* _tmp84_;
			ValaCCodeFunctionCall* _tmp85_;
			ValaCCodeExpression* _tmp86_;
			ValaCCodeUnaryExpression* _tmp87_;
			ValaCCodeUnaryExpression* _tmp88_;
			ValaCCodeFunction* _tmp89_;
			ValaCCodeFunction* _tmp90_;
			ValaCCodeFunctionCall* _tmp91_;
			_tmp80_ = finalize_context;
			vala_ccode_base_module_push_context (self, _tmp80_);
			_tmp81_ = vala_ccode_identifier_new ("g_rec_mutex_clear");
			_tmp82_ = _tmp81_;
			_tmp83_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp82_);
			_tmp84_ = _tmp83_;
			_vala_ccode_node_unref0 (_tmp82_);
			fc = _tmp84_;
			_tmp85_ = fc;
			_tmp86_ = l;
			_tmp87_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp86_);
			_tmp88_ = _tmp87_;
			vala_ccode_function_call_add_argument (_tmp85_, (ValaCCodeExpression*) _tmp88_);
			_vala_ccode_node_unref0 (_tmp88_);
			_tmp89_ = vala_ccode_base_module_get_ccode (self);
			_tmp90_ = _tmp89_;
			_tmp91_ = fc;
			vala_ccode_function_add_expression (_tmp90_, (ValaCCodeExpression*) _tmp91_);
			vala_ccode_base_module_pop_context (self);
			_vala_ccode_node_unref0 (fc);
		}
		_vala_ccode_node_unref0 (initf);
		_vala_ccode_base_module_emit_context_unref0 (finalize_context);
		_vala_ccode_base_module_emit_context_unref0 (init_context);
		_vala_ccode_node_unref0 (l);
	}
}


void vala_ccode_base_module_generate_constant_declaration (ValaCCodeBaseModule* self, ValaConstant* c, ValaCCodeFile* decl_space, gboolean definition) {
	ValaConstant* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaCCodeFile* _tmp3_;
	ValaConstant* _tmp4_;
	ValaConstant* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gboolean _tmp8_;
	gboolean _tmp9_;
	ValaConstant* _tmp10_;
	gboolean _tmp11_;
	gboolean _tmp12_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (c != NULL);
	g_return_if_fail (decl_space != NULL);
	_tmp0_ = c;
	_tmp1_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_BLOCK)) {
		return;
	}
	_tmp3_ = decl_space;
	_tmp4_ = c;
	_tmp5_ = c;
	_tmp6_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = vala_ccode_base_module_add_symbol_declaration (self, _tmp3_, (ValaSymbol*) _tmp4_, _tmp7_);
	_tmp9_ = _tmp8_;
	_g_free0 (_tmp7_);
	if (_tmp9_) {
		return;
	}
	_tmp10_ = c;
	_tmp11_ = vala_symbol_get_external ((ValaSymbol*) _tmp10_);
	_tmp12_ = _tmp11_;
	if (!_tmp12_) {
		ValaConstant* _tmp13_;
		ValaDataType* _tmp14_;
		ValaDataType* _tmp15_;
		ValaCCodeFile* _tmp16_;
		ValaConstant* _tmp17_;
		ValaExpression* _tmp18_;
		ValaExpression* _tmp19_;
		ValaInitializerList* initializer_list = NULL;
		ValaConstant* _tmp20_;
		ValaExpression* _tmp21_;
		ValaExpression* _tmp22_;
		ValaInitializerList* _tmp23_;
		ValaInitializerList* _tmp24_;
		_tmp13_ = c;
		_tmp14_ = vala_constant_get_type_reference (_tmp13_);
		_tmp15_ = _tmp14_;
		_tmp16_ = decl_space;
		vala_ccode_base_module_generate_type_declaration (self, _tmp15_, _tmp16_);
		_tmp17_ = c;
		_tmp18_ = vala_constant_get_value (_tmp17_);
		_tmp19_ = _tmp18_;
		vala_code_node_emit ((ValaCodeNode*) _tmp19_, (ValaCodeGenerator*) self);
		_tmp20_ = c;
		_tmp21_ = vala_constant_get_value (_tmp20_);
		_tmp22_ = _tmp21_;
		_tmp23_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp22_, VALA_TYPE_INITIALIZER_LIST) ? ((ValaInitializerList*) _tmp22_) : NULL);
		initializer_list = _tmp23_;
		_tmp24_ = initializer_list;
		if (_tmp24_ != NULL) {
			ValaCCodeDeclaration* _cdecl_ = NULL;
			ValaConstant* _tmp25_;
			ValaDataType* _tmp26_;
			ValaDataType* _tmp27_;
			gchar* _tmp28_;
			gchar* _tmp29_;
			ValaCCodeDeclaration* _tmp30_;
			ValaCCodeDeclaration* _tmp31_;
			gchar* arr = NULL;
			gchar* _tmp32_;
			ValaConstant* _tmp33_;
			ValaDataType* _tmp34_;
			ValaDataType* _tmp35_;
			ValaCCodeExpression* cinitializer = NULL;
			ValaConstant* _tmp40_;
			ValaExpression* _tmp41_;
			ValaExpression* _tmp42_;
			ValaCCodeExpression* _tmp43_;
			gboolean _tmp44_;
			ValaCCodeDeclaration* _tmp45_;
			ValaConstant* _tmp46_;
			gchar* _tmp47_;
			gchar* _tmp48_;
			const gchar* _tmp49_;
			gchar* _tmp50_;
			gchar* _tmp51_;
			ValaCCodeExpression* _tmp52_;
			ValaCCodeVariableDeclarator* _tmp53_;
			ValaCCodeVariableDeclarator* _tmp54_;
			ValaConstant* _tmp55_;
			gboolean _tmp56_;
			ValaCCodeFile* _tmp59_;
			ValaCCodeDeclaration* _tmp60_;
			_tmp25_ = c;
			_tmp26_ = vala_constant_get_type_reference (_tmp25_);
			_tmp27_ = _tmp26_;
			_tmp28_ = vala_ccode_base_module_get_ccode_const_name ((ValaCodeNode*) _tmp27_);
			_tmp29_ = _tmp28_;
			_tmp30_ = vala_ccode_declaration_new (_tmp29_);
			_tmp31_ = _tmp30_;
			_g_free0 (_tmp29_);
			_cdecl_ = _tmp31_;
			_tmp32_ = g_strdup ("");
			arr = _tmp32_;
			_tmp33_ = c;
			_tmp34_ = vala_constant_get_type_reference (_tmp33_);
			_tmp35_ = _tmp34_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp35_, VALA_TYPE_ARRAY_TYPE)) {
				ValaInitializerList* _tmp36_;
				gint _tmp37_;
				gint _tmp38_;
				gchar* _tmp39_;
				_tmp36_ = initializer_list;
				_tmp37_ = vala_initializer_list_get_size (_tmp36_);
				_tmp38_ = _tmp37_;
				_tmp39_ = g_strdup_printf ("[%d]", _tmp38_);
				_g_free0 (arr);
				arr = _tmp39_;
			}
			_tmp40_ = c;
			_tmp41_ = vala_constant_get_value (_tmp40_);
			_tmp42_ = _tmp41_;
			_tmp43_ = vala_ccode_base_module_get_cvalue (self, _tmp42_);
			cinitializer = _tmp43_;
			_tmp44_ = definition;
			if (!_tmp44_) {
				_vala_ccode_node_unref0 (cinitializer);
				cinitializer = NULL;
			}
			_tmp45_ = _cdecl_;
			_tmp46_ = c;
			_tmp47_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp46_);
			_tmp48_ = _tmp47_;
			_tmp49_ = arr;
			_tmp50_ = g_strdup_printf ("%s%s", _tmp48_, _tmp49_);
			_tmp51_ = _tmp50_;
			_tmp52_ = cinitializer;
			_tmp53_ = vala_ccode_variable_declarator_new (_tmp51_, _tmp52_, NULL);
			_tmp54_ = _tmp53_;
			vala_ccode_declaration_add_declarator (_tmp45_, (ValaCCodeDeclarator*) _tmp54_);
			_vala_ccode_node_unref0 (_tmp54_);
			_g_free0 (_tmp51_);
			_g_free0 (_tmp48_);
			_tmp55_ = c;
			_tmp56_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp55_);
			if (_tmp56_) {
				ValaCCodeDeclaration* _tmp57_;
				_tmp57_ = _cdecl_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp57_, VALA_CCODE_MODIFIERS_STATIC);
			} else {
				ValaCCodeDeclaration* _tmp58_;
				_tmp58_ = _cdecl_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp58_, VALA_CCODE_MODIFIERS_EXTERN);
			}
			_tmp59_ = decl_space;
			_tmp60_ = _cdecl_;
			vala_ccode_file_add_constant_declaration (_tmp59_, (ValaCCodeNode*) _tmp60_);
			_vala_ccode_node_unref0 (cinitializer);
			_g_free0 (arr);
			_vala_ccode_node_unref0 (_cdecl_);
		} else {
			ValaCCodeMacroReplacement* cdefine = NULL;
			ValaConstant* _tmp61_;
			gchar* _tmp62_;
			gchar* _tmp63_;
			ValaConstant* _tmp64_;
			ValaExpression* _tmp65_;
			ValaExpression* _tmp66_;
			ValaCCodeExpression* _tmp67_;
			ValaCCodeExpression* _tmp68_;
			ValaCCodeMacroReplacement* _tmp69_;
			ValaCCodeMacroReplacement* _tmp70_;
			ValaCCodeFile* _tmp71_;
			ValaCCodeMacroReplacement* _tmp72_;
			_tmp61_ = c;
			_tmp62_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp61_);
			_tmp63_ = _tmp62_;
			_tmp64_ = c;
			_tmp65_ = vala_constant_get_value (_tmp64_);
			_tmp66_ = _tmp65_;
			_tmp67_ = vala_ccode_base_module_get_cvalue (self, _tmp66_);
			_tmp68_ = _tmp67_;
			_tmp69_ = vala_ccode_macro_replacement_new_with_expression (_tmp63_, _tmp68_);
			_tmp70_ = _tmp69_;
			_vala_ccode_node_unref0 (_tmp68_);
			_g_free0 (_tmp63_);
			cdefine = _tmp70_;
			_tmp71_ = decl_space;
			_tmp72_ = cdefine;
			vala_ccode_file_add_type_member_declaration (_tmp71_, (ValaCCodeNode*) _tmp72_);
			_vala_ccode_node_unref0 (cdefine);
		}
		_vala_code_node_unref0 (initializer_list);
	}
}


static void vala_ccode_base_module_real_visit_constant (ValaCodeVisitor* base, ValaConstant* c) {
	ValaCCodeBaseModule * self;
	ValaConstant* _tmp0_;
	ValaSourceReference* _tmp1_;
	ValaSourceReference* _tmp2_;
	ValaConstant* _tmp3_;
	ValaSymbol* _tmp4_;
	ValaSymbol* _tmp5_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (c != NULL);
	_tmp0_ = c;
	_tmp1_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	vala_ccode_base_module_push_line (self, _tmp2_);
	_tmp3_ = c;
	_tmp4_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp3_);
	_tmp5_ = _tmp4_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_BLOCK)) {
		ValaConstant* _tmp6_;
		ValaDataType* _tmp7_;
		ValaDataType* _tmp8_;
		ValaCCodeFile* _tmp9_;
		ValaConstant* _tmp10_;
		ValaExpression* _tmp11_;
		ValaExpression* _tmp12_;
		gchar* type_name = NULL;
		ValaConstant* _tmp13_;
		ValaDataType* _tmp14_;
		ValaDataType* _tmp15_;
		gchar* _tmp16_;
		gchar* arr = NULL;
		gchar* _tmp17_;
		ValaConstant* _tmp18_;
		ValaDataType* _tmp19_;
		ValaDataType* _tmp20_;
		ValaConstant* _tmp22_;
		ValaDataType* _tmp23_;
		ValaDataType* _tmp24_;
		ValaDataType* _tmp25_;
		gboolean _tmp26_;
		ValaCCodeExpression* cinitializer = NULL;
		ValaConstant* _tmp29_;
		ValaExpression* _tmp30_;
		ValaExpression* _tmp31_;
		ValaCCodeExpression* _tmp32_;
		ValaCCodeFunction* _tmp33_;
		ValaCCodeFunction* _tmp34_;
		const gchar* _tmp35_;
		ValaConstant* _tmp36_;
		gchar* _tmp37_;
		gchar* _tmp38_;
		const gchar* _tmp39_;
		gchar* _tmp40_;
		gchar* _tmp41_;
		ValaCCodeExpression* _tmp42_;
		ValaCCodeVariableDeclarator* _tmp43_;
		ValaCCodeVariableDeclarator* _tmp44_;
		_tmp6_ = c;
		_tmp7_ = vala_constant_get_type_reference (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = self->cfile;
		vala_ccode_base_module_generate_type_declaration (self, _tmp8_, _tmp9_);
		_tmp10_ = c;
		_tmp11_ = vala_constant_get_value (_tmp10_);
		_tmp12_ = _tmp11_;
		vala_code_node_emit ((ValaCodeNode*) _tmp12_, (ValaCodeGenerator*) self);
		_tmp13_ = c;
		_tmp14_ = vala_constant_get_type_reference (_tmp13_);
		_tmp15_ = _tmp14_;
		_tmp16_ = vala_ccode_base_module_get_ccode_const_name ((ValaCodeNode*) _tmp15_);
		type_name = _tmp16_;
		_tmp17_ = g_strdup ("");
		arr = _tmp17_;
		_tmp18_ = c;
		_tmp19_ = vala_constant_get_type_reference (_tmp18_);
		_tmp20_ = _tmp19_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp20_, VALA_TYPE_ARRAY_TYPE)) {
			gchar* _tmp21_;
			_tmp21_ = g_strdup ("[]");
			_g_free0 (arr);
			arr = _tmp21_;
		}
		_tmp22_ = c;
		_tmp23_ = vala_constant_get_type_reference (_tmp22_);
		_tmp24_ = _tmp23_;
		_tmp25_ = self->string_type;
		_tmp26_ = vala_data_type_compatible (_tmp24_, _tmp25_);
		if (_tmp26_) {
			gchar* _tmp27_;
			gchar* _tmp28_;
			_tmp27_ = g_strdup ("const char");
			_g_free0 (type_name);
			type_name = _tmp27_;
			_tmp28_ = g_strdup ("[]");
			_g_free0 (arr);
			arr = _tmp28_;
		}
		_tmp29_ = c;
		_tmp30_ = vala_constant_get_value (_tmp29_);
		_tmp31_ = _tmp30_;
		_tmp32_ = vala_ccode_base_module_get_cvalue (self, _tmp31_);
		cinitializer = _tmp32_;
		_tmp33_ = vala_ccode_base_module_get_ccode (self);
		_tmp34_ = _tmp33_;
		_tmp35_ = type_name;
		_tmp36_ = c;
		_tmp37_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp36_);
		_tmp38_ = _tmp37_;
		_tmp39_ = arr;
		_tmp40_ = g_strdup_printf ("%s%s", _tmp38_, _tmp39_);
		_tmp41_ = _tmp40_;
		_tmp42_ = cinitializer;
		_tmp43_ = vala_ccode_variable_declarator_new (_tmp41_, _tmp42_, NULL);
		_tmp44_ = _tmp43_;
		vala_ccode_function_add_declaration (_tmp34_, _tmp35_, (ValaCCodeDeclarator*) _tmp44_, VALA_CCODE_MODIFIERS_STATIC);
		_vala_ccode_node_unref0 (_tmp44_);
		_g_free0 (_tmp41_);
		_g_free0 (_tmp38_);
		_vala_ccode_node_unref0 (cinitializer);
		_g_free0 (arr);
		_g_free0 (type_name);
	} else {
		ValaConstant* _tmp45_;
		ValaCCodeFile* _tmp46_;
		ValaConstant* _tmp47_;
		gboolean _tmp48_;
		ValaConstant* _tmp51_;
		gboolean _tmp52_;
		_tmp45_ = c;
		_tmp46_ = self->cfile;
		vala_ccode_base_module_generate_constant_declaration (self, _tmp45_, _tmp46_, TRUE);
		_tmp47_ = c;
		_tmp48_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp47_);
		if (!_tmp48_) {
			ValaConstant* _tmp49_;
			ValaCCodeFile* _tmp50_;
			_tmp49_ = c;
			_tmp50_ = self->header_file;
			vala_ccode_base_module_generate_constant_declaration (self, _tmp49_, _tmp50_, FALSE);
		}
		_tmp51_ = c;
		_tmp52_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp51_);
		if (!_tmp52_) {
			ValaConstant* _tmp53_;
			ValaCCodeFile* _tmp54_;
			_tmp53_ = c;
			_tmp54_ = self->internal_header_file;
			vala_ccode_base_module_generate_constant_declaration (self, _tmp53_, _tmp54_, FALSE);
		}
	}
	vala_ccode_base_module_pop_line (self);
}


void vala_ccode_base_module_generate_field_declaration (ValaCCodeBaseModule* self, ValaField* f, ValaCCodeFile* decl_space) {
	ValaCCodeFile* _tmp0_;
	ValaField* _tmp1_;
	ValaField* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gboolean _tmp5_;
	gboolean _tmp6_;
	ValaField* _tmp7_;
	ValaDataType* _tmp8_;
	ValaDataType* _tmp9_;
	ValaCCodeFile* _tmp10_;
	ValaCCodeDeclaration* _cdecl_ = NULL;
	ValaField* _tmp11_;
	ValaDataType* _tmp12_;
	ValaDataType* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
	ValaCCodeDeclaration* _tmp16_;
	ValaCCodeDeclaration* _tmp17_;
	ValaCCodeDeclaration* _tmp18_;
	ValaField* _tmp19_;
	gchar* _tmp20_;
	gchar* _tmp21_;
	ValaField* _tmp22_;
	ValaDataType* _tmp23_;
	ValaDataType* _tmp24_;
	ValaCCodeDeclaratorSuffix* _tmp25_;
	ValaCCodeDeclaratorSuffix* _tmp26_;
	ValaCCodeVariableDeclarator* _tmp27_;
	ValaCCodeVariableDeclarator* _tmp28_;
	ValaField* _tmp29_;
	gboolean _tmp30_;
	ValaField* _tmp33_;
	ValaVersionAttribute* _tmp34_;
	ValaVersionAttribute* _tmp35_;
	gboolean _tmp36_;
	gboolean _tmp37_;
	ValaField* _tmp42_;
	gboolean _tmp43_;
	gboolean _tmp44_;
	ValaCCodeFile* _tmp49_;
	ValaCCodeDeclaration* _tmp50_;
	ValaField* _tmp51_;
	gboolean _tmp52_;
	gboolean _tmp82_ = FALSE;
	ValaField* _tmp83_;
	ValaDataType* _tmp84_;
	ValaDataType* _tmp85_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (f != NULL);
	g_return_if_fail (decl_space != NULL);
	_tmp0_ = decl_space;
	_tmp1_ = f;
	_tmp2_ = f;
	_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_ccode_base_module_add_symbol_declaration (self, _tmp0_, (ValaSymbol*) _tmp1_, _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	if (_tmp6_) {
		return;
	}
	_tmp7_ = f;
	_tmp8_ = vala_variable_get_variable_type ((ValaVariable*) _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = decl_space;
	vala_ccode_base_module_generate_type_declaration (self, _tmp9_, _tmp10_);
	_tmp11_ = f;
	_tmp12_ = vala_variable_get_variable_type ((ValaVariable*) _tmp11_);
	_tmp13_ = _tmp12_;
	_tmp14_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = vala_ccode_declaration_new (_tmp15_);
	_tmp17_ = _tmp16_;
	_g_free0 (_tmp15_);
	_cdecl_ = _tmp17_;
	_tmp18_ = _cdecl_;
	_tmp19_ = f;
	_tmp20_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp19_);
	_tmp21_ = _tmp20_;
	_tmp22_ = f;
	_tmp23_ = vala_variable_get_variable_type ((ValaVariable*) _tmp22_);
	_tmp24_ = _tmp23_;
	_tmp25_ = vala_ccode_base_module_get_ccode_declarator_suffix (self, _tmp24_);
	_tmp26_ = _tmp25_;
	_tmp27_ = vala_ccode_variable_declarator_new (_tmp21_, NULL, _tmp26_);
	_tmp28_ = _tmp27_;
	vala_ccode_declaration_add_declarator (_tmp18_, (ValaCCodeDeclarator*) _tmp28_);
	_vala_ccode_node_unref0 (_tmp28_);
	_vala_ccode_declarator_suffix_unref0 (_tmp26_);
	_g_free0 (_tmp21_);
	_tmp29_ = f;
	_tmp30_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp29_);
	if (_tmp30_) {
		ValaCCodeDeclaration* _tmp31_;
		_tmp31_ = _cdecl_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp31_, VALA_CCODE_MODIFIERS_STATIC);
	} else {
		ValaCCodeDeclaration* _tmp32_;
		_tmp32_ = _cdecl_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp32_, VALA_CCODE_MODIFIERS_EXTERN);
	}
	_tmp33_ = f;
	_tmp34_ = vala_symbol_get_version ((ValaSymbol*) _tmp33_);
	_tmp35_ = _tmp34_;
	_tmp36_ = vala_version_attribute_get_deprecated (_tmp35_);
	_tmp37_ = _tmp36_;
	if (_tmp37_) {
		ValaCCodeDeclaration* _tmp38_;
		ValaCCodeDeclaration* _tmp39_;
		ValaCCodeModifiers _tmp40_;
		ValaCCodeModifiers _tmp41_;
		_tmp38_ = _cdecl_;
		_tmp39_ = _cdecl_;
		_tmp40_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp39_);
		_tmp41_ = _tmp40_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp39_, _tmp41_ | VALA_CCODE_MODIFIERS_DEPRECATED);
	}
	_tmp42_ = f;
	_tmp43_ = vala_field_get_is_volatile (_tmp42_);
	_tmp44_ = _tmp43_;
	if (_tmp44_) {
		ValaCCodeDeclaration* _tmp45_;
		ValaCCodeDeclaration* _tmp46_;
		ValaCCodeModifiers _tmp47_;
		ValaCCodeModifiers _tmp48_;
		_tmp45_ = _cdecl_;
		_tmp46_ = _cdecl_;
		_tmp47_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp46_);
		_tmp48_ = _tmp47_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp46_, _tmp48_ | VALA_CCODE_MODIFIERS_VOLATILE);
	}
	_tmp49_ = decl_space;
	_tmp50_ = _cdecl_;
	vala_ccode_file_add_type_member_declaration (_tmp49_, (ValaCCodeNode*) _tmp50_);
	_tmp51_ = f;
	_tmp52_ = vala_lockable_get_lock_used ((ValaLockable*) _tmp51_);
	if (_tmp52_) {
		ValaCCodeDeclaration* flock = NULL;
		ValaStruct* _tmp53_;
		gchar* _tmp54_;
		gchar* _tmp55_;
		ValaCCodeDeclaration* _tmp56_;
		ValaCCodeDeclaration* _tmp57_;
		ValaCCodeVariableDeclarator* flock_decl = NULL;
		ValaField* _tmp58_;
		gchar* _tmp59_;
		gchar* _tmp60_;
		gchar* _tmp61_;
		gchar* _tmp62_;
		ValaCCodeConstant* _tmp63_;
		ValaCCodeConstant* _tmp64_;
		ValaCCodeVariableDeclarator* _tmp65_;
		ValaCCodeVariableDeclarator* _tmp66_;
		ValaCCodeDeclaration* _tmp67_;
		ValaCCodeVariableDeclarator* _tmp68_;
		ValaField* _tmp69_;
		gboolean _tmp70_;
		ValaCCodeFile* _tmp80_;
		ValaCCodeDeclaration* _tmp81_;
		_tmp53_ = self->mutex_type;
		_tmp54_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp53_);
		_tmp55_ = _tmp54_;
		_tmp56_ = vala_ccode_declaration_new (_tmp55_);
		_tmp57_ = _tmp56_;
		_g_free0 (_tmp55_);
		flock = _tmp57_;
		_tmp58_ = f;
		_tmp59_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp58_);
		_tmp60_ = _tmp59_;
		_tmp61_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp60_);
		_tmp62_ = _tmp61_;
		_tmp63_ = vala_ccode_constant_new ("{0}");
		_tmp64_ = _tmp63_;
		_tmp65_ = vala_ccode_variable_declarator_new (_tmp62_, (ValaCCodeExpression*) _tmp64_, NULL);
		_tmp66_ = _tmp65_;
		_vala_ccode_node_unref0 (_tmp64_);
		_g_free0 (_tmp62_);
		_g_free0 (_tmp60_);
		flock_decl = _tmp66_;
		_tmp67_ = flock;
		_tmp68_ = flock_decl;
		vala_ccode_declaration_add_declarator (_tmp67_, (ValaCCodeDeclarator*) _tmp68_);
		_tmp69_ = f;
		_tmp70_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp69_);
		if (_tmp70_) {
			ValaCCodeDeclaration* _tmp71_;
			_tmp71_ = flock;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp71_, VALA_CCODE_MODIFIERS_STATIC);
		} else {
			gboolean _tmp72_ = FALSE;
			ValaCodeContext* _tmp73_;
			gboolean _tmp74_;
			gboolean _tmp75_;
			_tmp73_ = self->priv->_context;
			_tmp74_ = vala_code_context_get_hide_internal (_tmp73_);
			_tmp75_ = _tmp74_;
			if (_tmp75_) {
				ValaField* _tmp76_;
				gboolean _tmp77_;
				_tmp76_ = f;
				_tmp77_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp76_);
				_tmp72_ = _tmp77_;
			} else {
				_tmp72_ = FALSE;
			}
			if (_tmp72_) {
				ValaCCodeDeclaration* _tmp78_;
				_tmp78_ = flock;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp78_, VALA_CCODE_MODIFIERS_INTERNAL);
			} else {
				ValaCCodeDeclaration* _tmp79_;
				_tmp79_ = flock;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp79_, VALA_CCODE_MODIFIERS_EXTERN);
			}
		}
		_tmp80_ = decl_space;
		_tmp81_ = flock;
		vala_ccode_file_add_type_member_declaration (_tmp80_, (ValaCCodeNode*) _tmp81_);
		_vala_ccode_node_unref0 (flock_decl);
		_vala_ccode_node_unref0 (flock);
	}
	_tmp83_ = f;
	_tmp84_ = vala_variable_get_variable_type ((ValaVariable*) _tmp83_);
	_tmp85_ = _tmp84_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp85_, VALA_TYPE_ARRAY_TYPE)) {
		ValaField* _tmp86_;
		gboolean _tmp87_;
		_tmp86_ = f;
		_tmp87_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp86_);
		_tmp82_ = _tmp87_;
	} else {
		_tmp82_ = FALSE;
	}
	if (_tmp82_) {
		ValaArrayType* array_type = NULL;
		ValaField* _tmp88_;
		ValaDataType* _tmp89_;
		ValaDataType* _tmp90_;
		ValaArrayType* _tmp91_;
		ValaArrayType* _tmp92_;
		gboolean _tmp93_;
		gboolean _tmp94_;
		_tmp88_ = f;
		_tmp89_ = vala_variable_get_variable_type ((ValaVariable*) _tmp88_);
		_tmp90_ = _tmp89_;
		_tmp91_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp90_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		array_type = _tmp91_;
		_tmp92_ = array_type;
		_tmp93_ = vala_array_type_get_fixed_length (_tmp92_);
		_tmp94_ = _tmp93_;
		if (!_tmp94_) {
			{
				gint dim = 0;
				dim = 1;
				{
					gboolean _tmp95_ = FALSE;
					_tmp95_ = TRUE;
					while (TRUE) {
						gint _tmp97_;
						ValaArrayType* _tmp98_;
						gint _tmp99_;
						gint _tmp100_;
						ValaDataType* len_type = NULL;
						ValaDataType* _tmp101_;
						ValaDataType* _tmp102_;
						ValaDataType* _tmp103_;
						gchar* _tmp104_;
						gchar* _tmp105_;
						ValaCCodeDeclaration* _tmp106_;
						ValaCCodeDeclaration* _tmp107_;
						ValaField* _tmp108_;
						gchar* _tmp109_;
						gchar* _tmp110_;
						gint _tmp111_;
						gchar* _tmp112_;
						gchar* _tmp113_;
						ValaCCodeVariableDeclarator* _tmp114_;
						ValaCCodeVariableDeclarator* _tmp115_;
						ValaField* _tmp116_;
						gboolean _tmp117_;
						ValaCCodeFile* _tmp127_;
						ValaCCodeDeclaration* _tmp128_;
						if (!_tmp95_) {
							gint _tmp96_;
							_tmp96_ = dim;
							dim = _tmp96_ + 1;
						}
						_tmp95_ = FALSE;
						_tmp97_ = dim;
						_tmp98_ = array_type;
						_tmp99_ = vala_array_type_get_rank (_tmp98_);
						_tmp100_ = _tmp99_;
						if (!(_tmp97_ <= _tmp100_)) {
							break;
						}
						_tmp101_ = self->int_type;
						_tmp102_ = vala_data_type_copy (_tmp101_);
						len_type = _tmp102_;
						_tmp103_ = len_type;
						_tmp104_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp103_);
						_tmp105_ = _tmp104_;
						_tmp106_ = vala_ccode_declaration_new (_tmp105_);
						_vala_ccode_node_unref0 (_cdecl_);
						_cdecl_ = _tmp106_;
						_g_free0 (_tmp105_);
						_tmp107_ = _cdecl_;
						_tmp108_ = f;
						_tmp109_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp108_);
						_tmp110_ = _tmp109_;
						_tmp111_ = dim;
						_tmp112_ = vala_ccode_base_module_get_array_length_cname (self, _tmp110_, _tmp111_);
						_tmp113_ = _tmp112_;
						_tmp114_ = vala_ccode_variable_declarator_new (_tmp113_, NULL, NULL);
						_tmp115_ = _tmp114_;
						vala_ccode_declaration_add_declarator (_tmp107_, (ValaCCodeDeclarator*) _tmp115_);
						_vala_ccode_node_unref0 (_tmp115_);
						_g_free0 (_tmp113_);
						_g_free0 (_tmp110_);
						_tmp116_ = f;
						_tmp117_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp116_);
						if (_tmp117_) {
							ValaCCodeDeclaration* _tmp118_;
							_tmp118_ = _cdecl_;
							vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp118_, VALA_CCODE_MODIFIERS_STATIC);
						} else {
							gboolean _tmp119_ = FALSE;
							ValaCodeContext* _tmp120_;
							gboolean _tmp121_;
							gboolean _tmp122_;
							_tmp120_ = self->priv->_context;
							_tmp121_ = vala_code_context_get_hide_internal (_tmp120_);
							_tmp122_ = _tmp121_;
							if (_tmp122_) {
								ValaField* _tmp123_;
								gboolean _tmp124_;
								_tmp123_ = f;
								_tmp124_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp123_);
								_tmp119_ = _tmp124_;
							} else {
								_tmp119_ = FALSE;
							}
							if (_tmp119_) {
								ValaCCodeDeclaration* _tmp125_;
								_tmp125_ = _cdecl_;
								vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp125_, VALA_CCODE_MODIFIERS_INTERNAL);
							} else {
								ValaCCodeDeclaration* _tmp126_;
								_tmp126_ = _cdecl_;
								vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp126_, VALA_CCODE_MODIFIERS_EXTERN);
							}
						}
						_tmp127_ = decl_space;
						_tmp128_ = _cdecl_;
						vala_ccode_file_add_type_member_declaration (_tmp127_, (ValaCCodeNode*) _tmp128_);
						_vala_code_node_unref0 (len_type);
					}
				}
			}
		}
		_vala_code_node_unref0 (array_type);
	} else {
		ValaField* _tmp129_;
		ValaDataType* _tmp130_;
		ValaDataType* _tmp131_;
		_tmp129_ = f;
		_tmp130_ = vala_variable_get_variable_type ((ValaVariable*) _tmp129_);
		_tmp131_ = _tmp130_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp131_, VALA_TYPE_DELEGATE_TYPE)) {
			ValaDelegateType* delegate_type = NULL;
			ValaField* _tmp132_;
			ValaDataType* _tmp133_;
			ValaDataType* _tmp134_;
			ValaDelegateType* _tmp135_;
			ValaDelegateType* _tmp136_;
			ValaDelegate* _tmp137_;
			ValaDelegate* _tmp138_;
			gboolean _tmp139_;
			gboolean _tmp140_;
			_tmp132_ = f;
			_tmp133_ = vala_variable_get_variable_type ((ValaVariable*) _tmp132_);
			_tmp134_ = _tmp133_;
			_tmp135_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp134_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
			delegate_type = _tmp135_;
			_tmp136_ = delegate_type;
			_tmp137_ = vala_delegate_type_get_delegate_symbol (_tmp136_);
			_tmp138_ = _tmp137_;
			_tmp139_ = vala_delegate_get_has_target (_tmp138_);
			_tmp140_ = _tmp139_;
			if (_tmp140_) {
				ValaCCodeDeclaration* _tmp141_;
				ValaCCodeDeclaration* _tmp142_;
				ValaField* _tmp143_;
				gchar* _tmp144_;
				gchar* _tmp145_;
				ValaCCodeVariableDeclarator* _tmp146_;
				ValaCCodeVariableDeclarator* _tmp147_;
				ValaField* _tmp148_;
				gboolean _tmp149_;
				ValaCCodeFile* _tmp159_;
				ValaCCodeDeclaration* _tmp160_;
				gboolean _tmp161_ = FALSE;
				ValaDelegateType* _tmp162_;
				gboolean _tmp163_;
				gboolean _tmp164_;
				_tmp141_ = vala_ccode_declaration_new ("gpointer");
				_vala_ccode_node_unref0 (_cdecl_);
				_cdecl_ = _tmp141_;
				_tmp142_ = _cdecl_;
				_tmp143_ = f;
				_tmp144_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp143_);
				_tmp145_ = _tmp144_;
				_tmp146_ = vala_ccode_variable_declarator_new (_tmp145_, NULL, NULL);
				_tmp147_ = _tmp146_;
				vala_ccode_declaration_add_declarator (_tmp142_, (ValaCCodeDeclarator*) _tmp147_);
				_vala_ccode_node_unref0 (_tmp147_);
				_g_free0 (_tmp145_);
				_tmp148_ = f;
				_tmp149_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp148_);
				if (_tmp149_) {
					ValaCCodeDeclaration* _tmp150_;
					_tmp150_ = _cdecl_;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp150_, VALA_CCODE_MODIFIERS_STATIC);
				} else {
					gboolean _tmp151_ = FALSE;
					ValaCodeContext* _tmp152_;
					gboolean _tmp153_;
					gboolean _tmp154_;
					_tmp152_ = self->priv->_context;
					_tmp153_ = vala_code_context_get_hide_internal (_tmp152_);
					_tmp154_ = _tmp153_;
					if (_tmp154_) {
						ValaField* _tmp155_;
						gboolean _tmp156_;
						_tmp155_ = f;
						_tmp156_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp155_);
						_tmp151_ = _tmp156_;
					} else {
						_tmp151_ = FALSE;
					}
					if (_tmp151_) {
						ValaCCodeDeclaration* _tmp157_;
						_tmp157_ = _cdecl_;
						vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp157_, VALA_CCODE_MODIFIERS_INTERNAL);
					} else {
						ValaCCodeDeclaration* _tmp158_;
						_tmp158_ = _cdecl_;
						vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp158_, VALA_CCODE_MODIFIERS_EXTERN);
					}
				}
				_tmp159_ = decl_space;
				_tmp160_ = _cdecl_;
				vala_ccode_file_add_type_member_declaration (_tmp159_, (ValaCCodeNode*) _tmp160_);
				_tmp162_ = delegate_type;
				_tmp163_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp162_);
				_tmp164_ = _tmp163_;
				if (_tmp164_) {
					ValaDelegateType* _tmp165_;
					gboolean _tmp166_;
					gboolean _tmp167_;
					_tmp165_ = delegate_type;
					_tmp166_ = vala_delegate_type_get_is_called_once (_tmp165_);
					_tmp167_ = _tmp166_;
					_tmp161_ = !_tmp167_;
				} else {
					_tmp161_ = FALSE;
				}
				if (_tmp161_) {
					ValaCCodeDeclaration* _tmp168_;
					ValaCCodeDeclaration* _tmp169_;
					ValaField* _tmp170_;
					gchar* _tmp171_;
					gchar* _tmp172_;
					gchar* _tmp173_;
					gchar* _tmp174_;
					ValaCCodeVariableDeclarator* _tmp175_;
					ValaCCodeVariableDeclarator* _tmp176_;
					ValaField* _tmp177_;
					gboolean _tmp178_;
					ValaCCodeFile* _tmp188_;
					ValaCCodeDeclaration* _tmp189_;
					_tmp168_ = vala_ccode_declaration_new ("GDestroyNotify");
					_vala_ccode_node_unref0 (_cdecl_);
					_cdecl_ = _tmp168_;
					_tmp169_ = _cdecl_;
					_tmp170_ = f;
					_tmp171_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp170_);
					_tmp172_ = _tmp171_;
					_tmp173_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp172_);
					_tmp174_ = _tmp173_;
					_tmp175_ = vala_ccode_variable_declarator_new (_tmp174_, NULL, NULL);
					_tmp176_ = _tmp175_;
					vala_ccode_declaration_add_declarator (_tmp169_, (ValaCCodeDeclarator*) _tmp176_);
					_vala_ccode_node_unref0 (_tmp176_);
					_g_free0 (_tmp174_);
					_g_free0 (_tmp172_);
					_tmp177_ = f;
					_tmp178_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp177_);
					if (_tmp178_) {
						ValaCCodeDeclaration* _tmp179_;
						_tmp179_ = _cdecl_;
						vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp179_, VALA_CCODE_MODIFIERS_STATIC);
					} else {
						gboolean _tmp180_ = FALSE;
						ValaCodeContext* _tmp181_;
						gboolean _tmp182_;
						gboolean _tmp183_;
						_tmp181_ = self->priv->_context;
						_tmp182_ = vala_code_context_get_hide_internal (_tmp181_);
						_tmp183_ = _tmp182_;
						if (_tmp183_) {
							ValaField* _tmp184_;
							gboolean _tmp185_;
							_tmp184_ = f;
							_tmp185_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp184_);
							_tmp180_ = _tmp185_;
						} else {
							_tmp180_ = FALSE;
						}
						if (_tmp180_) {
							ValaCCodeDeclaration* _tmp186_;
							_tmp186_ = _cdecl_;
							vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp186_, VALA_CCODE_MODIFIERS_INTERNAL);
						} else {
							ValaCCodeDeclaration* _tmp187_;
							_tmp187_ = _cdecl_;
							vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp187_, VALA_CCODE_MODIFIERS_EXTERN);
						}
					}
					_tmp188_ = decl_space;
					_tmp189_ = _cdecl_;
					vala_ccode_file_add_type_member_declaration (_tmp188_, (ValaCCodeNode*) _tmp189_);
				}
			}
			_vala_code_node_unref0 (delegate_type);
		}
	}
	_vala_ccode_node_unref0 (_cdecl_);
}


static gpointer _vala_target_value_ref0 (gpointer self) {
	return self ? vala_target_value_ref (self) : NULL;
}


static void vala_ccode_base_module_real_visit_field (ValaCodeVisitor* base, ValaField* f) {
	ValaCCodeBaseModule * self;
	ValaField* _tmp0_;
	ValaSourceReference* _tmp1_;
	ValaSourceReference* _tmp2_;
	ValaField* _tmp3_;
	ValaField* _tmp4_;
	ValaDataType* _tmp5_;
	ValaDataType* _tmp6_;
	ValaClass* cl = NULL;
	ValaField* _tmp7_;
	ValaSymbol* _tmp8_;
	ValaSymbol* _tmp9_;
	ValaClass* _tmp10_;
	gboolean _tmp11_ = FALSE;
	ValaClass* _tmp12_;
	gboolean is_gtypeinstance = FALSE;
	ValaCCodeExpression* lhs = NULL;
	ValaField* _tmp16_;
	ValaMemberBinding _tmp17_;
	ValaMemberBinding _tmp18_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (f != NULL);
	_tmp0_ = f;
	_tmp1_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	vala_ccode_base_module_push_line (self, _tmp2_);
	_tmp3_ = f;
	vala_ccode_base_module_visit_member (self, (ValaSymbol*) _tmp3_);
	_tmp4_ = f;
	_tmp5_ = vala_variable_get_variable_type ((ValaVariable*) _tmp4_);
	_tmp6_ = _tmp5_;
	vala_ccode_base_module_check_type (self, _tmp6_);
	_tmp7_ = f;
	_tmp8_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp9_) : NULL);
	cl = _tmp10_;
	_tmp12_ = cl;
	if (_tmp12_ != NULL) {
		ValaClass* _tmp13_;
		gboolean _tmp14_;
		gboolean _tmp15_;
		_tmp13_ = cl;
		_tmp14_ = vala_class_get_is_compact (_tmp13_);
		_tmp15_ = _tmp14_;
		_tmp11_ = !_tmp15_;
	} else {
		_tmp11_ = FALSE;
	}
	is_gtypeinstance = _tmp11_;
	lhs = NULL;
	_tmp16_ = f;
	_tmp17_ = vala_field_get_binding (_tmp16_);
	_tmp18_ = _tmp17_;
	if (_tmp18_ == VALA_MEMBER_BINDING_INSTANCE) {
		gboolean _tmp19_ = FALSE;
		gboolean _tmp20_;
		ValaField* _tmp38_;
		ValaExpression* _tmp39_;
		ValaExpression* _tmp40_;
		gboolean _tmp199_ = FALSE;
		ValaField* _tmp200_;
		ValaDataType* _tmp201_;
		ValaDataType* _tmp202_;
		gboolean _tmp203_;
		_tmp20_ = is_gtypeinstance;
		if (_tmp20_) {
			ValaField* _tmp21_;
			ValaSymbolAccessibility _tmp22_;
			ValaSymbolAccessibility _tmp23_;
			_tmp21_ = f;
			_tmp22_ = vala_symbol_get_access ((ValaSymbol*) _tmp21_);
			_tmp23_ = _tmp22_;
			_tmp19_ = _tmp23_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
		} else {
			_tmp19_ = FALSE;
		}
		if (_tmp19_) {
			ValaCCodeIdentifier* _tmp24_;
			ValaCCodeIdentifier* _tmp25_;
			ValaCCodeMemberAccess* _tmp26_;
			ValaCCodeMemberAccess* _tmp27_;
			ValaField* _tmp28_;
			gchar* _tmp29_;
			gchar* _tmp30_;
			ValaCCodeMemberAccess* _tmp31_;
			_tmp24_ = vala_ccode_identifier_new ("self");
			_tmp25_ = _tmp24_;
			_tmp26_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp25_, "priv");
			_tmp27_ = _tmp26_;
			_tmp28_ = f;
			_tmp29_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp28_);
			_tmp30_ = _tmp29_;
			_tmp31_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp27_, _tmp30_);
			_vala_ccode_node_unref0 (lhs);
			lhs = (ValaCCodeExpression*) _tmp31_;
			_g_free0 (_tmp30_);
			_vala_ccode_node_unref0 (_tmp27_);
			_vala_ccode_node_unref0 (_tmp25_);
		} else {
			ValaCCodeIdentifier* _tmp32_;
			ValaCCodeIdentifier* _tmp33_;
			ValaField* _tmp34_;
			gchar* _tmp35_;
			gchar* _tmp36_;
			ValaCCodeMemberAccess* _tmp37_;
			_tmp32_ = vala_ccode_identifier_new ("self");
			_tmp33_ = _tmp32_;
			_tmp34_ = f;
			_tmp35_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp34_);
			_tmp36_ = _tmp35_;
			_tmp37_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp33_, _tmp36_);
			_vala_ccode_node_unref0 (lhs);
			lhs = (ValaCCodeExpression*) _tmp37_;
			_g_free0 (_tmp36_);
			_vala_ccode_node_unref0 (_tmp33_);
		}
		_tmp38_ = f;
		_tmp39_ = vala_variable_get_initializer ((ValaVariable*) _tmp38_);
		_tmp40_ = _tmp39_;
		if (_tmp40_ != NULL) {
			ValaCCodeBaseModuleEmitContext* _tmp41_;
			ValaField* _tmp42_;
			ValaExpression* _tmp43_;
			ValaExpression* _tmp44_;
			ValaCCodeExpression* rhs = NULL;
			ValaField* _tmp45_;
			ValaExpression* _tmp46_;
			ValaExpression* _tmp47_;
			ValaCCodeExpression* _tmp48_;
			ValaField* _tmp49_;
			ValaField* _tmp50_;
			ValaExpression* _tmp51_;
			ValaExpression* _tmp52_;
			gboolean _tmp53_;
			ValaArrayList* _tmp197_;
			ValaArrayList* _tmp198_;
			_tmp41_ = self->instance_init_context;
			vala_ccode_base_module_push_context (self, _tmp41_);
			_tmp42_ = f;
			_tmp43_ = vala_variable_get_initializer ((ValaVariable*) _tmp42_);
			_tmp44_ = _tmp43_;
			vala_code_node_emit ((ValaCodeNode*) _tmp44_, (ValaCodeGenerator*) self);
			_tmp45_ = f;
			_tmp46_ = vala_variable_get_initializer ((ValaVariable*) _tmp45_);
			_tmp47_ = _tmp46_;
			_tmp48_ = vala_ccode_base_module_get_cvalue (self, _tmp47_);
			rhs = _tmp48_;
			_tmp49_ = f;
			_tmp50_ = f;
			_tmp51_ = vala_variable_get_initializer ((ValaVariable*) _tmp50_);
			_tmp52_ = _tmp51_;
			_tmp53_ = vala_ccode_base_module_is_simple_struct_creation (self, (ValaVariable*) _tmp49_, _tmp52_);
			if (!_tmp53_) {
				ValaCCodeFunction* _tmp54_;
				ValaCCodeFunction* _tmp55_;
				ValaCCodeExpression* _tmp56_;
				ValaCCodeExpression* _tmp57_;
				gboolean _tmp58_ = FALSE;
				ValaField* _tmp59_;
				ValaDataType* _tmp60_;
				ValaDataType* _tmp61_;
				_tmp54_ = vala_ccode_base_module_get_ccode (self);
				_tmp55_ = _tmp54_;
				_tmp56_ = lhs;
				_tmp57_ = rhs;
				vala_ccode_function_add_assignment (_tmp55_, _tmp56_, _tmp57_);
				_tmp59_ = f;
				_tmp60_ = vala_variable_get_variable_type ((ValaVariable*) _tmp59_);
				_tmp61_ = _tmp60_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp61_, VALA_TYPE_ARRAY_TYPE)) {
					ValaField* _tmp62_;
					gboolean _tmp63_;
					_tmp62_ = f;
					_tmp63_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp62_);
					_tmp58_ = _tmp63_;
				} else {
					_tmp58_ = FALSE;
				}
				if (_tmp58_) {
					ValaArrayType* array_type = NULL;
					ValaField* _tmp64_;
					ValaDataType* _tmp65_;
					ValaDataType* _tmp66_;
					ValaArrayType* _tmp67_;
					ValaTargetValue* field_value = NULL;
					ValaField* _tmp68_;
					ValaField* _tmp69_;
					ValaSymbol* _tmp70_;
					ValaSymbol* _tmp71_;
					ValaTargetValue* _tmp72_;
					ValaTargetValue* _tmp73_;
					ValaTargetValue* _tmp74_;
					ValaTargetValue* _tmp75_;
					ValaGLibValue* glib_value = NULL;
					ValaField* _tmp76_;
					ValaExpression* _tmp77_;
					ValaExpression* _tmp78_;
					ValaTargetValue* _tmp79_;
					ValaTargetValue* _tmp80_;
					ValaGLibValue* _tmp81_;
					ValaGLibValue* _tmp82_;
					ValaList* _tmp83_;
					gboolean _tmp130_ = FALSE;
					ValaArrayType* _tmp131_;
					gint _tmp132_;
					gint _tmp133_;
					_tmp64_ = f;
					_tmp65_ = vala_variable_get_variable_type ((ValaVariable*) _tmp64_);
					_tmp66_ = _tmp65_;
					_tmp67_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp66_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
					array_type = _tmp67_;
					_tmp68_ = f;
					_tmp69_ = f;
					_tmp70_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp69_);
					_tmp71_ = _tmp70_;
					_tmp72_ = vala_ccode_base_module_load_this_parameter (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp71_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
					_tmp73_ = _tmp72_;
					_tmp74_ = vala_ccode_base_module_get_field_cvalue (self, _tmp68_, _tmp73_);
					_tmp75_ = _tmp74_;
					_vala_target_value_unref0 (_tmp73_);
					field_value = _tmp75_;
					_tmp76_ = f;
					_tmp77_ = vala_variable_get_initializer ((ValaVariable*) _tmp76_);
					_tmp78_ = _tmp77_;
					_tmp79_ = vala_expression_get_target_value (_tmp78_);
					_tmp80_ = _tmp79_;
					_tmp81_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp80_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
					glib_value = _tmp81_;
					_tmp82_ = glib_value;
					_tmp83_ = _tmp82_->array_length_cvalues;
					if (_tmp83_ != NULL) {
						{
							gint dim = 0;
							dim = 1;
							{
								gboolean _tmp84_ = FALSE;
								_tmp84_ = TRUE;
								while (TRUE) {
									gint _tmp86_;
									ValaArrayType* _tmp87_;
									gint _tmp88_;
									gint _tmp89_;
									ValaCCodeExpression* array_len_lhs = NULL;
									ValaTargetValue* _tmp90_;
									gint _tmp91_;
									ValaCCodeExpression* _tmp92_;
									ValaCCodeFunction* _tmp93_;
									ValaCCodeFunction* _tmp94_;
									ValaCCodeExpression* _tmp95_;
									ValaGLibValue* _tmp96_;
									gint _tmp97_;
									ValaCCodeExpression* _tmp98_;
									ValaCCodeExpression* _tmp99_;
									if (!_tmp84_) {
										gint _tmp85_;
										_tmp85_ = dim;
										dim = _tmp85_ + 1;
									}
									_tmp84_ = FALSE;
									_tmp86_ = dim;
									_tmp87_ = array_type;
									_tmp88_ = vala_array_type_get_rank (_tmp87_);
									_tmp89_ = _tmp88_;
									if (!(_tmp86_ <= _tmp89_)) {
										break;
									}
									_tmp90_ = field_value;
									_tmp91_ = dim;
									_tmp92_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp90_, _tmp91_);
									array_len_lhs = _tmp92_;
									_tmp93_ = vala_ccode_base_module_get_ccode (self);
									_tmp94_ = _tmp93_;
									_tmp95_ = array_len_lhs;
									_tmp96_ = glib_value;
									_tmp97_ = dim;
									_tmp98_ = vala_ccode_base_module_get_array_length_cvalue (self, (ValaTargetValue*) _tmp96_, _tmp97_);
									_tmp99_ = _tmp98_;
									vala_ccode_function_add_assignment (_tmp94_, _tmp95_, _tmp99_);
									_vala_ccode_node_unref0 (_tmp99_);
									_vala_ccode_node_unref0 (array_len_lhs);
								}
							}
						}
					} else {
						ValaGLibValue* _tmp100_;
						gboolean _tmp101_;
						_tmp100_ = glib_value;
						_tmp101_ = _tmp100_->array_null_terminated;
						if (_tmp101_) {
							ValaCCodeFunctionCall* len_call = NULL;
							ValaCCodeIdentifier* _tmp102_;
							ValaCCodeIdentifier* _tmp103_;
							ValaCCodeFunctionCall* _tmp104_;
							ValaCCodeFunctionCall* _tmp105_;
							ValaCCodeFunctionCall* _tmp106_;
							ValaGLibValue* _tmp107_;
							ValaCCodeExpression* _tmp108_;
							ValaCCodeExpression* _tmp109_;
							ValaCCodeFunction* _tmp110_;
							ValaCCodeFunction* _tmp111_;
							ValaTargetValue* _tmp112_;
							ValaCCodeExpression* _tmp113_;
							ValaCCodeExpression* _tmp114_;
							ValaCCodeFunctionCall* _tmp115_;
							self->requires_array_length = TRUE;
							_tmp102_ = vala_ccode_identifier_new ("_vala_array_length");
							_tmp103_ = _tmp102_;
							_tmp104_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp103_);
							_tmp105_ = _tmp104_;
							_vala_ccode_node_unref0 (_tmp103_);
							len_call = _tmp105_;
							_tmp106_ = len_call;
							_tmp107_ = glib_value;
							_tmp108_ = vala_ccode_base_module_get_cvalue_ (self, (ValaTargetValue*) _tmp107_);
							_tmp109_ = _tmp108_;
							vala_ccode_function_call_add_argument (_tmp106_, _tmp109_);
							_vala_ccode_node_unref0 (_tmp109_);
							_tmp110_ = vala_ccode_base_module_get_ccode (self);
							_tmp111_ = _tmp110_;
							_tmp112_ = field_value;
							_tmp113_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp112_, 1);
							_tmp114_ = _tmp113_;
							_tmp115_ = len_call;
							vala_ccode_function_add_assignment (_tmp111_, _tmp114_, (ValaCCodeExpression*) _tmp115_);
							_vala_ccode_node_unref0 (_tmp114_);
							_vala_ccode_node_unref0 (len_call);
						} else {
							{
								gint dim = 0;
								dim = 1;
								{
									gboolean _tmp116_ = FALSE;
									_tmp116_ = TRUE;
									while (TRUE) {
										gint _tmp118_;
										ValaArrayType* _tmp119_;
										gint _tmp120_;
										gint _tmp121_;
										ValaCCodeFunction* _tmp122_;
										ValaCCodeFunction* _tmp123_;
										ValaTargetValue* _tmp124_;
										gint _tmp125_;
										ValaCCodeExpression* _tmp126_;
										ValaCCodeExpression* _tmp127_;
										ValaCCodeConstant* _tmp128_;
										ValaCCodeConstant* _tmp129_;
										if (!_tmp116_) {
											gint _tmp117_;
											_tmp117_ = dim;
											dim = _tmp117_ + 1;
										}
										_tmp116_ = FALSE;
										_tmp118_ = dim;
										_tmp119_ = array_type;
										_tmp120_ = vala_array_type_get_rank (_tmp119_);
										_tmp121_ = _tmp120_;
										if (!(_tmp118_ <= _tmp121_)) {
											break;
										}
										_tmp122_ = vala_ccode_base_module_get_ccode (self);
										_tmp123_ = _tmp122_;
										_tmp124_ = field_value;
										_tmp125_ = dim;
										_tmp126_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp124_, _tmp125_);
										_tmp127_ = _tmp126_;
										_tmp128_ = vala_ccode_constant_new ("-1");
										_tmp129_ = _tmp128_;
										vala_ccode_function_add_assignment (_tmp123_, _tmp127_, (ValaCCodeExpression*) _tmp129_);
										_vala_ccode_node_unref0 (_tmp129_);
										_vala_ccode_node_unref0 (_tmp127_);
									}
								}
							}
						}
					}
					_tmp131_ = array_type;
					_tmp132_ = vala_array_type_get_rank (_tmp131_);
					_tmp133_ = _tmp132_;
					if (_tmp133_ == 1) {
						ValaField* _tmp134_;
						gboolean _tmp135_;
						_tmp134_ = f;
						_tmp135_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp134_);
						_tmp130_ = _tmp135_;
					} else {
						_tmp130_ = FALSE;
					}
					if (_tmp130_) {
						ValaCCodeExpression* lhs_array_size = NULL;
						ValaTargetValue* _tmp136_;
						ValaCCodeExpression* _tmp137_;
						ValaCCodeExpression* rhs_array_len = NULL;
						ValaTargetValue* _tmp138_;
						ValaCCodeExpression* _tmp139_;
						ValaCCodeFunction* _tmp140_;
						ValaCCodeFunction* _tmp141_;
						ValaCCodeExpression* _tmp142_;
						ValaCCodeExpression* _tmp143_;
						_tmp136_ = field_value;
						_tmp137_ = vala_ccode_base_module_get_array_size_cvalue (self, _tmp136_);
						lhs_array_size = _tmp137_;
						_tmp138_ = field_value;
						_tmp139_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp138_, 1);
						rhs_array_len = _tmp139_;
						_tmp140_ = vala_ccode_base_module_get_ccode (self);
						_tmp141_ = _tmp140_;
						_tmp142_ = lhs_array_size;
						_tmp143_ = rhs_array_len;
						vala_ccode_function_add_assignment (_tmp141_, _tmp142_, _tmp143_);
						_vala_ccode_node_unref0 (rhs_array_len);
						_vala_ccode_node_unref0 (lhs_array_size);
					}
					_vala_target_value_unref0 (glib_value);
					_vala_target_value_unref0 (field_value);
					_vala_code_node_unref0 (array_type);
				} else {
					ValaField* _tmp144_;
					ValaDataType* _tmp145_;
					ValaDataType* _tmp146_;
					_tmp144_ = f;
					_tmp145_ = vala_variable_get_variable_type ((ValaVariable*) _tmp144_);
					_tmp146_ = _tmp145_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp146_, VALA_TYPE_DELEGATE_TYPE)) {
						ValaDelegateType* delegate_type = NULL;
						ValaField* _tmp147_;
						ValaDataType* _tmp148_;
						ValaDataType* _tmp149_;
						ValaDelegateType* _tmp150_;
						ValaDelegateType* _tmp151_;
						ValaDelegate* _tmp152_;
						ValaDelegate* _tmp153_;
						gboolean _tmp154_;
						gboolean _tmp155_;
						_tmp147_ = f;
						_tmp148_ = vala_variable_get_variable_type ((ValaVariable*) _tmp147_);
						_tmp149_ = _tmp148_;
						_tmp150_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp149_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
						delegate_type = _tmp150_;
						_tmp151_ = delegate_type;
						_tmp152_ = vala_delegate_type_get_delegate_symbol (_tmp151_);
						_tmp153_ = _tmp152_;
						_tmp154_ = vala_delegate_get_has_target (_tmp153_);
						_tmp155_ = _tmp154_;
						if (_tmp155_) {
							ValaTargetValue* field_value = NULL;
							ValaField* _tmp156_;
							ValaField* _tmp157_;
							ValaSymbol* _tmp158_;
							ValaSymbol* _tmp159_;
							ValaTargetValue* _tmp160_;
							ValaTargetValue* _tmp161_;
							ValaTargetValue* _tmp162_;
							ValaTargetValue* _tmp163_;
							ValaCCodeFunction* _tmp164_;
							ValaCCodeFunction* _tmp165_;
							ValaTargetValue* _tmp166_;
							ValaCCodeExpression* _tmp167_;
							ValaCCodeExpression* _tmp168_;
							ValaCCodeIdentifier* _tmp169_;
							ValaCCodeIdentifier* _tmp170_;
							ValaDelegateType* _tmp171_;
							gboolean _tmp172_;
							_tmp156_ = f;
							_tmp157_ = f;
							_tmp158_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp157_);
							_tmp159_ = _tmp158_;
							_tmp160_ = vala_ccode_base_module_load_this_parameter (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp159_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
							_tmp161_ = _tmp160_;
							_tmp162_ = vala_ccode_base_module_get_field_cvalue (self, _tmp156_, _tmp161_);
							_tmp163_ = _tmp162_;
							_vala_target_value_unref0 (_tmp161_);
							field_value = _tmp163_;
							_tmp164_ = vala_ccode_base_module_get_ccode (self);
							_tmp165_ = _tmp164_;
							_tmp166_ = field_value;
							_tmp167_ = vala_ccode_base_module_get_delegate_target_cvalue (self, _tmp166_);
							_tmp168_ = _tmp167_;
							_tmp169_ = vala_ccode_identifier_new ("self");
							_tmp170_ = _tmp169_;
							vala_ccode_function_add_assignment (_tmp165_, _tmp168_, (ValaCCodeExpression*) _tmp170_);
							_vala_ccode_node_unref0 (_tmp170_);
							_vala_ccode_node_unref0 (_tmp168_);
							_tmp171_ = delegate_type;
							_tmp172_ = vala_data_type_is_disposable ((ValaDataType*) _tmp171_);
							if (_tmp172_) {
								ValaCCodeFunction* _tmp173_;
								ValaCCodeFunction* _tmp174_;
								ValaTargetValue* _tmp175_;
								ValaCCodeExpression* _tmp176_;
								ValaCCodeExpression* _tmp177_;
								ValaCCodeIdentifier* _tmp178_;
								ValaCCodeIdentifier* _tmp179_;
								_tmp173_ = vala_ccode_base_module_get_ccode (self);
								_tmp174_ = _tmp173_;
								_tmp175_ = field_value;
								_tmp176_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp175_);
								_tmp177_ = _tmp176_;
								_tmp178_ = vala_ccode_identifier_new ("NULL");
								_tmp179_ = _tmp178_;
								vala_ccode_function_add_assignment (_tmp174_, _tmp177_, (ValaCCodeExpression*) _tmp179_);
								_vala_ccode_node_unref0 (_tmp179_);
								_vala_ccode_node_unref0 (_tmp177_);
							}
							_vala_target_value_unref0 (field_value);
						}
						_vala_code_node_unref0 (delegate_type);
					}
				}
			}
			{
				ValaArrayList* _value_list = NULL;
				ValaArrayList* _tmp180_;
				ValaArrayList* _tmp181_;
				ValaArrayList* _tmp182_;
				gint _value_size = 0;
				ValaArrayList* _tmp183_;
				gint _tmp184_;
				gint _tmp185_;
				gint _value_index = 0;
				_tmp180_ = vala_ccode_base_module_get_temp_ref_values (self);
				_tmp181_ = _tmp180_;
				_tmp182_ = _vala_iterable_ref0 (_tmp181_);
				_value_list = _tmp182_;
				_tmp183_ = _value_list;
				_tmp184_ = vala_collection_get_size ((ValaCollection*) _tmp183_);
				_tmp185_ = _tmp184_;
				_value_size = _tmp185_;
				_value_index = -1;
				while (TRUE) {
					gint _tmp186_;
					gint _tmp187_;
					gint _tmp188_;
					ValaTargetValue* value = NULL;
					ValaArrayList* _tmp189_;
					gint _tmp190_;
					gpointer _tmp191_;
					ValaCCodeFunction* _tmp192_;
					ValaCCodeFunction* _tmp193_;
					ValaTargetValue* _tmp194_;
					ValaCCodeExpression* _tmp195_;
					ValaCCodeExpression* _tmp196_;
					_tmp186_ = _value_index;
					_value_index = _tmp186_ + 1;
					_tmp187_ = _value_index;
					_tmp188_ = _value_size;
					if (!(_tmp187_ < _tmp188_)) {
						break;
					}
					_tmp189_ = _value_list;
					_tmp190_ = _value_index;
					_tmp191_ = vala_list_get ((ValaList*) _tmp189_, _tmp190_);
					value = (ValaTargetValue*) _tmp191_;
					_tmp192_ = vala_ccode_base_module_get_ccode (self);
					_tmp193_ = _tmp192_;
					_tmp194_ = value;
					_tmp195_ = vala_ccode_base_module_destroy_value (self, _tmp194_, FALSE);
					_tmp196_ = _tmp195_;
					vala_ccode_function_add_expression (_tmp193_, _tmp196_);
					_vala_ccode_node_unref0 (_tmp196_);
					_vala_target_value_unref0 (value);
				}
				_vala_iterable_unref0 (_value_list);
			}
			_tmp197_ = vala_ccode_base_module_get_temp_ref_values (self);
			_tmp198_ = _tmp197_;
			vala_collection_clear ((ValaCollection*) _tmp198_);
			vala_ccode_base_module_pop_context (self);
			_vala_ccode_node_unref0 (rhs);
		}
		_tmp200_ = f;
		_tmp201_ = vala_variable_get_variable_type ((ValaVariable*) _tmp200_);
		_tmp202_ = _tmp201_;
		_tmp203_ = vala_ccode_base_module_requires_destroy (self, _tmp202_);
		if (_tmp203_) {
			ValaCCodeBaseModuleEmitContext* _tmp204_;
			_tmp204_ = self->instance_finalize_context;
			_tmp199_ = _tmp204_ != NULL;
		} else {
			_tmp199_ = FALSE;
		}
		if (_tmp199_) {
			ValaCCodeBaseModuleEmitContext* _tmp205_;
			ValaCCodeFunction* _tmp206_;
			ValaCCodeFunction* _tmp207_;
			ValaField* _tmp208_;
			ValaField* _tmp209_;
			ValaSymbol* _tmp210_;
			ValaSymbol* _tmp211_;
			ValaTargetValue* _tmp212_;
			ValaTargetValue* _tmp213_;
			ValaCCodeExpression* _tmp214_;
			ValaCCodeExpression* _tmp215_;
			_tmp205_ = self->instance_finalize_context;
			vala_ccode_base_module_push_context (self, _tmp205_);
			_tmp206_ = vala_ccode_base_module_get_ccode (self);
			_tmp207_ = _tmp206_;
			_tmp208_ = f;
			_tmp209_ = f;
			_tmp210_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp209_);
			_tmp211_ = _tmp210_;
			_tmp212_ = vala_ccode_base_module_load_this_parameter (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp211_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
			_tmp213_ = _tmp212_;
			_tmp214_ = vala_ccode_base_module_destroy_field (self, _tmp208_, _tmp213_);
			_tmp215_ = _tmp214_;
			vala_ccode_function_add_expression (_tmp207_, _tmp215_);
			_vala_ccode_node_unref0 (_tmp215_);
			_vala_target_value_unref0 (_tmp213_);
			vala_ccode_base_module_pop_context (self);
		}
	} else {
		ValaField* _tmp216_;
		ValaMemberBinding _tmp217_;
		ValaMemberBinding _tmp218_;
		_tmp216_ = f;
		_tmp217_ = vala_field_get_binding (_tmp216_);
		_tmp218_ = _tmp217_;
		if (_tmp218_ == VALA_MEMBER_BINDING_CLASS) {
			gboolean _tmp219_;
			ValaField* _tmp224_;
			ValaSymbolAccessibility _tmp225_;
			ValaSymbolAccessibility _tmp226_;
			ValaField* _tmp250_;
			ValaExpression* _tmp251_;
			ValaExpression* _tmp252_;
			_tmp219_ = is_gtypeinstance;
			if (!_tmp219_) {
				ValaField* _tmp220_;
				ValaSourceReference* _tmp221_;
				ValaSourceReference* _tmp222_;
				ValaField* _tmp223_;
				_tmp220_ = f;
				_tmp221_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp220_);
				_tmp222_ = _tmp221_;
				vala_report_error (_tmp222_, "class fields are not supported in compact classes");
				_tmp223_ = f;
				vala_code_node_set_error ((ValaCodeNode*) _tmp223_, TRUE);
				_vala_ccode_node_unref0 (lhs);
				_vala_code_node_unref0 (cl);
				return;
			}
			_tmp224_ = f;
			_tmp225_ = vala_symbol_get_access ((ValaSymbol*) _tmp224_);
			_tmp226_ = _tmp225_;
			if (_tmp226_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) {
				ValaCCodeFunctionCall* ccall = NULL;
				ValaClass* _tmp227_;
				gchar* _tmp228_;
				gchar* _tmp229_;
				gchar* _tmp230_;
				gchar* _tmp231_;
				ValaCCodeIdentifier* _tmp232_;
				ValaCCodeIdentifier* _tmp233_;
				ValaCCodeFunctionCall* _tmp234_;
				ValaCCodeFunctionCall* _tmp235_;
				ValaCCodeFunctionCall* _tmp236_;
				ValaCCodeIdentifier* _tmp237_;
				ValaCCodeIdentifier* _tmp238_;
				ValaCCodeFunctionCall* _tmp239_;
				ValaField* _tmp240_;
				gchar* _tmp241_;
				gchar* _tmp242_;
				ValaCCodeMemberAccess* _tmp243_;
				_tmp227_ = cl;
				_tmp228_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp227_, NULL);
				_tmp229_ = _tmp228_;
				_tmp230_ = g_strdup_printf ("%s_GET_CLASS_PRIVATE", _tmp229_);
				_tmp231_ = _tmp230_;
				_tmp232_ = vala_ccode_identifier_new (_tmp231_);
				_tmp233_ = _tmp232_;
				_tmp234_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp233_);
				_tmp235_ = _tmp234_;
				_vala_ccode_node_unref0 (_tmp233_);
				_g_free0 (_tmp231_);
				_g_free0 (_tmp229_);
				ccall = _tmp235_;
				_tmp236_ = ccall;
				_tmp237_ = vala_ccode_identifier_new ("klass");
				_tmp238_ = _tmp237_;
				vala_ccode_function_call_add_argument (_tmp236_, (ValaCCodeExpression*) _tmp238_);
				_vala_ccode_node_unref0 (_tmp238_);
				_tmp239_ = ccall;
				_tmp240_ = f;
				_tmp241_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp240_);
				_tmp242_ = _tmp241_;
				_tmp243_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp239_, _tmp242_, TRUE);
				_vala_ccode_node_unref0 (lhs);
				lhs = (ValaCCodeExpression*) _tmp243_;
				_g_free0 (_tmp242_);
				_vala_ccode_node_unref0 (ccall);
			} else {
				ValaCCodeIdentifier* _tmp244_;
				ValaCCodeIdentifier* _tmp245_;
				ValaField* _tmp246_;
				gchar* _tmp247_;
				gchar* _tmp248_;
				ValaCCodeMemberAccess* _tmp249_;
				_tmp244_ = vala_ccode_identifier_new ("klass");
				_tmp245_ = _tmp244_;
				_tmp246_ = f;
				_tmp247_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp246_);
				_tmp248_ = _tmp247_;
				_tmp249_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp245_, _tmp248_, TRUE);
				_vala_ccode_node_unref0 (lhs);
				lhs = (ValaCCodeExpression*) _tmp249_;
				_g_free0 (_tmp248_);
				_vala_ccode_node_unref0 (_tmp245_);
			}
			_tmp250_ = f;
			_tmp251_ = vala_variable_get_initializer ((ValaVariable*) _tmp250_);
			_tmp252_ = _tmp251_;
			if (_tmp252_ != NULL) {
				ValaCCodeBaseModuleEmitContext* _tmp253_;
				ValaField* _tmp254_;
				ValaExpression* _tmp255_;
				ValaExpression* _tmp256_;
				ValaCCodeExpression* rhs = NULL;
				ValaField* _tmp257_;
				ValaExpression* _tmp258_;
				ValaExpression* _tmp259_;
				ValaCCodeExpression* _tmp260_;
				ValaCCodeFunction* _tmp261_;
				ValaCCodeFunction* _tmp262_;
				ValaCCodeExpression* _tmp263_;
				ValaCCodeExpression* _tmp264_;
				ValaArrayList* _tmp282_;
				ValaArrayList* _tmp283_;
				_tmp253_ = self->class_init_context;
				vala_ccode_base_module_push_context (self, _tmp253_);
				_tmp254_ = f;
				_tmp255_ = vala_variable_get_initializer ((ValaVariable*) _tmp254_);
				_tmp256_ = _tmp255_;
				vala_code_node_emit ((ValaCodeNode*) _tmp256_, (ValaCodeGenerator*) self);
				_tmp257_ = f;
				_tmp258_ = vala_variable_get_initializer ((ValaVariable*) _tmp257_);
				_tmp259_ = _tmp258_;
				_tmp260_ = vala_ccode_base_module_get_cvalue (self, _tmp259_);
				rhs = _tmp260_;
				_tmp261_ = vala_ccode_base_module_get_ccode (self);
				_tmp262_ = _tmp261_;
				_tmp263_ = lhs;
				_tmp264_ = rhs;
				vala_ccode_function_add_assignment (_tmp262_, _tmp263_, _tmp264_);
				{
					ValaArrayList* _value_list = NULL;
					ValaArrayList* _tmp265_;
					ValaArrayList* _tmp266_;
					ValaArrayList* _tmp267_;
					gint _value_size = 0;
					ValaArrayList* _tmp268_;
					gint _tmp269_;
					gint _tmp270_;
					gint _value_index = 0;
					_tmp265_ = vala_ccode_base_module_get_temp_ref_values (self);
					_tmp266_ = _tmp265_;
					_tmp267_ = _vala_iterable_ref0 (_tmp266_);
					_value_list = _tmp267_;
					_tmp268_ = _value_list;
					_tmp269_ = vala_collection_get_size ((ValaCollection*) _tmp268_);
					_tmp270_ = _tmp269_;
					_value_size = _tmp270_;
					_value_index = -1;
					while (TRUE) {
						gint _tmp271_;
						gint _tmp272_;
						gint _tmp273_;
						ValaTargetValue* value = NULL;
						ValaArrayList* _tmp274_;
						gint _tmp275_;
						gpointer _tmp276_;
						ValaCCodeFunction* _tmp277_;
						ValaCCodeFunction* _tmp278_;
						ValaTargetValue* _tmp279_;
						ValaCCodeExpression* _tmp280_;
						ValaCCodeExpression* _tmp281_;
						_tmp271_ = _value_index;
						_value_index = _tmp271_ + 1;
						_tmp272_ = _value_index;
						_tmp273_ = _value_size;
						if (!(_tmp272_ < _tmp273_)) {
							break;
						}
						_tmp274_ = _value_list;
						_tmp275_ = _value_index;
						_tmp276_ = vala_list_get ((ValaList*) _tmp274_, _tmp275_);
						value = (ValaTargetValue*) _tmp276_;
						_tmp277_ = vala_ccode_base_module_get_ccode (self);
						_tmp278_ = _tmp277_;
						_tmp279_ = value;
						_tmp280_ = vala_ccode_base_module_destroy_value (self, _tmp279_, FALSE);
						_tmp281_ = _tmp280_;
						vala_ccode_function_add_expression (_tmp278_, _tmp281_);
						_vala_ccode_node_unref0 (_tmp281_);
						_vala_target_value_unref0 (value);
					}
					_vala_iterable_unref0 (_value_list);
				}
				_tmp282_ = vala_ccode_base_module_get_temp_ref_values (self);
				_tmp283_ = _tmp282_;
				vala_collection_clear ((ValaCollection*) _tmp283_);
				vala_ccode_base_module_pop_context (self);
				_vala_ccode_node_unref0 (rhs);
			}
		} else {
			ValaField* _tmp284_;
			ValaCCodeFile* _tmp285_;
			ValaField* _tmp286_;
			gboolean _tmp287_;
			ValaField* _tmp290_;
			gboolean _tmp291_;
			ValaField* _tmp294_;
			gboolean _tmp295_;
			gboolean _tmp296_;
			_tmp284_ = f;
			_tmp285_ = self->cfile;
			vala_ccode_base_module_generate_field_declaration (self, _tmp284_, _tmp285_);
			_tmp286_ = f;
			_tmp287_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp286_);
			if (!_tmp287_) {
				ValaField* _tmp288_;
				ValaCCodeFile* _tmp289_;
				_tmp288_ = f;
				_tmp289_ = self->header_file;
				vala_ccode_base_module_generate_field_declaration (self, _tmp288_, _tmp289_);
			}
			_tmp290_ = f;
			_tmp291_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp290_);
			if (!_tmp291_) {
				ValaField* _tmp292_;
				ValaCCodeFile* _tmp293_;
				_tmp292_ = f;
				_tmp293_ = self->internal_header_file;
				vala_ccode_base_module_generate_field_declaration (self, _tmp292_, _tmp293_);
			}
			_tmp294_ = f;
			_tmp295_ = vala_symbol_get_external ((ValaSymbol*) _tmp294_);
			_tmp296_ = _tmp295_;
			if (!_tmp296_) {
				ValaField* _tmp297_;
				gchar* _tmp298_;
				gchar* _tmp299_;
				ValaCCodeIdentifier* _tmp300_;
				ValaCCodeVariableDeclarator* var_decl = NULL;
				ValaField* _tmp301_;
				gchar* _tmp302_;
				gchar* _tmp303_;
				ValaField* _tmp304_;
				ValaDataType* _tmp305_;
				ValaDataType* _tmp306_;
				ValaCCodeDeclaratorSuffix* _tmp307_;
				ValaCCodeDeclaratorSuffix* _tmp308_;
				ValaCCodeVariableDeclarator* _tmp309_;
				ValaCCodeVariableDeclarator* _tmp310_;
				ValaCCodeVariableDeclarator* _tmp311_;
				ValaField* _tmp312_;
				ValaDataType* _tmp313_;
				ValaDataType* _tmp314_;
				ValaCCodeExpression* _tmp315_;
				ValaCCodeExpression* _tmp316_;
				ValaCCodeBaseModuleEmitContext* _tmp317_;
				ValaField* _tmp321_;
				ValaExpression* _tmp322_;
				ValaExpression* _tmp323_;
				ValaCCodeDeclaration* var_def = NULL;
				ValaField* _tmp335_;
				ValaDataType* _tmp336_;
				ValaDataType* _tmp337_;
				gchar* _tmp338_;
				gchar* _tmp339_;
				ValaCCodeDeclaration* _tmp340_;
				ValaCCodeDeclaration* _tmp341_;
				ValaCCodeDeclaration* _tmp342_;
				ValaCCodeVariableDeclarator* _tmp343_;
				ValaField* _tmp344_;
				gboolean _tmp345_;
				ValaField* _tmp348_;
				ValaVersionAttribute* _tmp349_;
				ValaVersionAttribute* _tmp350_;
				gboolean _tmp351_;
				gboolean _tmp352_;
				ValaField* _tmp357_;
				gboolean _tmp358_;
				gboolean _tmp359_;
				ValaCCodeFile* _tmp364_;
				ValaCCodeDeclaration* _tmp365_;
				gboolean _tmp366_ = FALSE;
				ValaField* _tmp367_;
				ValaDataType* _tmp368_;
				ValaDataType* _tmp369_;
				ValaField* _tmp481_;
				ValaExpression* _tmp482_;
				ValaExpression* _tmp483_;
				_tmp297_ = f;
				_tmp298_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp297_);
				_tmp299_ = _tmp298_;
				_tmp300_ = vala_ccode_identifier_new (_tmp299_);
				_vala_ccode_node_unref0 (lhs);
				lhs = (ValaCCodeExpression*) _tmp300_;
				_g_free0 (_tmp299_);
				_tmp301_ = f;
				_tmp302_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp301_);
				_tmp303_ = _tmp302_;
				_tmp304_ = f;
				_tmp305_ = vala_variable_get_variable_type ((ValaVariable*) _tmp304_);
				_tmp306_ = _tmp305_;
				_tmp307_ = vala_ccode_base_module_get_ccode_declarator_suffix (self, _tmp306_);
				_tmp308_ = _tmp307_;
				_tmp309_ = vala_ccode_variable_declarator_new (_tmp303_, NULL, _tmp308_);
				_tmp310_ = _tmp309_;
				_vala_ccode_declarator_suffix_unref0 (_tmp308_);
				_g_free0 (_tmp303_);
				var_decl = _tmp310_;
				_tmp311_ = var_decl;
				_tmp312_ = f;
				_tmp313_ = vala_variable_get_variable_type ((ValaVariable*) _tmp312_);
				_tmp314_ = _tmp313_;
				_tmp315_ = vala_ccode_base_module_default_value_for_type (self, _tmp314_, TRUE);
				_tmp316_ = _tmp315_;
				vala_ccode_variable_declarator_set_initializer (_tmp311_, _tmp316_);
				_vala_ccode_node_unref0 (_tmp316_);
				_tmp317_ = self->class_init_context;
				if (_tmp317_ != NULL) {
					ValaCCodeBaseModuleEmitContext* _tmp318_;
					_tmp318_ = self->class_init_context;
					vala_ccode_base_module_push_context (self, _tmp318_);
				} else {
					ValaCCodeBaseModuleEmitContext* _tmp319_;
					ValaCCodeBaseModuleEmitContext* _tmp320_;
					_tmp319_ = vala_ccode_base_module_emit_context_new (NULL);
					_tmp320_ = _tmp319_;
					vala_ccode_base_module_push_context (self, _tmp320_);
					_vala_ccode_base_module_emit_context_unref0 (_tmp320_);
				}
				_tmp321_ = f;
				_tmp322_ = vala_variable_get_initializer ((ValaVariable*) _tmp321_);
				_tmp323_ = _tmp322_;
				if (_tmp323_ != NULL) {
					ValaField* _tmp324_;
					ValaExpression* _tmp325_;
					ValaExpression* _tmp326_;
					ValaCCodeExpression* init = NULL;
					ValaField* _tmp327_;
					ValaExpression* _tmp328_;
					ValaExpression* _tmp329_;
					ValaCCodeExpression* _tmp330_;
					ValaCCodeExpression* _tmp331_;
					gboolean _tmp332_;
					_tmp324_ = f;
					_tmp325_ = vala_variable_get_initializer ((ValaVariable*) _tmp324_);
					_tmp326_ = _tmp325_;
					vala_code_node_emit ((ValaCodeNode*) _tmp326_, (ValaCodeGenerator*) self);
					_tmp327_ = f;
					_tmp328_ = vala_variable_get_initializer ((ValaVariable*) _tmp327_);
					_tmp329_ = _tmp328_;
					_tmp330_ = vala_ccode_base_module_get_cvalue (self, _tmp329_);
					init = _tmp330_;
					_tmp331_ = init;
					_tmp332_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp331_);
					if (_tmp332_) {
						ValaCCodeVariableDeclarator* _tmp333_;
						ValaCCodeExpression* _tmp334_;
						_tmp333_ = var_decl;
						_tmp334_ = init;
						vala_ccode_variable_declarator_set_initializer (_tmp333_, _tmp334_);
					}
					_vala_ccode_node_unref0 (init);
				}
				_tmp335_ = f;
				_tmp336_ = vala_variable_get_variable_type ((ValaVariable*) _tmp335_);
				_tmp337_ = _tmp336_;
				_tmp338_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp337_);
				_tmp339_ = _tmp338_;
				_tmp340_ = vala_ccode_declaration_new (_tmp339_);
				_tmp341_ = _tmp340_;
				_g_free0 (_tmp339_);
				var_def = _tmp341_;
				_tmp342_ = var_def;
				_tmp343_ = var_decl;
				vala_ccode_declaration_add_declarator (_tmp342_, (ValaCCodeDeclarator*) _tmp343_);
				_tmp344_ = f;
				_tmp345_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp344_);
				if (!_tmp345_) {
					ValaCCodeDeclaration* _tmp346_;
					_tmp346_ = var_def;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp346_, VALA_CCODE_MODIFIERS_EXTERN);
				} else {
					ValaCCodeDeclaration* _tmp347_;
					_tmp347_ = var_def;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp347_, VALA_CCODE_MODIFIERS_STATIC);
				}
				_tmp348_ = f;
				_tmp349_ = vala_symbol_get_version ((ValaSymbol*) _tmp348_);
				_tmp350_ = _tmp349_;
				_tmp351_ = vala_version_attribute_get_deprecated (_tmp350_);
				_tmp352_ = _tmp351_;
				if (_tmp352_) {
					ValaCCodeDeclaration* _tmp353_;
					ValaCCodeDeclaration* _tmp354_;
					ValaCCodeModifiers _tmp355_;
					ValaCCodeModifiers _tmp356_;
					_tmp353_ = var_def;
					_tmp354_ = var_def;
					_tmp355_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp354_);
					_tmp356_ = _tmp355_;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp354_, _tmp356_ | VALA_CCODE_MODIFIERS_DEPRECATED);
				}
				_tmp357_ = f;
				_tmp358_ = vala_field_get_is_volatile (_tmp357_);
				_tmp359_ = _tmp358_;
				if (_tmp359_) {
					ValaCCodeDeclaration* _tmp360_;
					ValaCCodeDeclaration* _tmp361_;
					ValaCCodeModifiers _tmp362_;
					ValaCCodeModifiers _tmp363_;
					_tmp360_ = var_def;
					_tmp361_ = var_def;
					_tmp362_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp361_);
					_tmp363_ = _tmp362_;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp361_, _tmp363_ | VALA_CCODE_MODIFIERS_VOLATILE);
				}
				_tmp364_ = self->cfile;
				_tmp365_ = var_def;
				vala_ccode_file_add_type_member_declaration (_tmp364_, (ValaCCodeNode*) _tmp365_);
				_tmp367_ = f;
				_tmp368_ = vala_variable_get_variable_type ((ValaVariable*) _tmp367_);
				_tmp369_ = _tmp368_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp369_, VALA_TYPE_ARRAY_TYPE)) {
					ValaField* _tmp370_;
					gboolean _tmp371_;
					_tmp370_ = f;
					_tmp371_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp370_);
					_tmp366_ = _tmp371_;
				} else {
					_tmp366_ = FALSE;
				}
				if (_tmp366_) {
					ValaArrayType* array_type = NULL;
					ValaField* _tmp372_;
					ValaDataType* _tmp373_;
					ValaDataType* _tmp374_;
					ValaArrayType* _tmp375_;
					ValaArrayType* _tmp376_;
					gboolean _tmp377_;
					gboolean _tmp378_;
					_tmp372_ = f;
					_tmp373_ = vala_variable_get_variable_type ((ValaVariable*) _tmp372_);
					_tmp374_ = _tmp373_;
					_tmp375_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp374_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
					array_type = _tmp375_;
					_tmp376_ = array_type;
					_tmp377_ = vala_array_type_get_fixed_length (_tmp376_);
					_tmp378_ = _tmp377_;
					if (!_tmp378_) {
						gboolean _tmp409_ = FALSE;
						ValaArrayType* _tmp410_;
						gint _tmp411_;
						gint _tmp412_;
						{
							gint dim = 0;
							dim = 1;
							{
								gboolean _tmp379_ = FALSE;
								_tmp379_ = TRUE;
								while (TRUE) {
									gint _tmp381_;
									ValaArrayType* _tmp382_;
									gint _tmp383_;
									gint _tmp384_;
									ValaDataType* len_type = NULL;
									ValaDataType* _tmp385_;
									ValaDataType* _tmp386_;
									ValaCCodeDeclaration* len_def = NULL;
									ValaDataType* _tmp387_;
									gchar* _tmp388_;
									gchar* _tmp389_;
									ValaCCodeDeclaration* _tmp390_;
									ValaCCodeDeclaration* _tmp391_;
									ValaCCodeDeclaration* _tmp392_;
									ValaField* _tmp393_;
									gchar* _tmp394_;
									gchar* _tmp395_;
									gint _tmp396_;
									gchar* _tmp397_;
									gchar* _tmp398_;
									ValaCCodeConstant* _tmp399_;
									ValaCCodeConstant* _tmp400_;
									ValaCCodeVariableDeclarator* _tmp401_;
									ValaCCodeVariableDeclarator* _tmp402_;
									ValaField* _tmp403_;
									gboolean _tmp404_;
									ValaCCodeFile* _tmp407_;
									ValaCCodeDeclaration* _tmp408_;
									if (!_tmp379_) {
										gint _tmp380_;
										_tmp380_ = dim;
										dim = _tmp380_ + 1;
									}
									_tmp379_ = FALSE;
									_tmp381_ = dim;
									_tmp382_ = array_type;
									_tmp383_ = vala_array_type_get_rank (_tmp382_);
									_tmp384_ = _tmp383_;
									if (!(_tmp381_ <= _tmp384_)) {
										break;
									}
									_tmp385_ = self->int_type;
									_tmp386_ = vala_data_type_copy (_tmp385_);
									len_type = _tmp386_;
									_tmp387_ = len_type;
									_tmp388_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp387_);
									_tmp389_ = _tmp388_;
									_tmp390_ = vala_ccode_declaration_new (_tmp389_);
									_tmp391_ = _tmp390_;
									_g_free0 (_tmp389_);
									len_def = _tmp391_;
									_tmp392_ = len_def;
									_tmp393_ = f;
									_tmp394_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp393_);
									_tmp395_ = _tmp394_;
									_tmp396_ = dim;
									_tmp397_ = vala_ccode_base_module_get_array_length_cname (self, _tmp395_, _tmp396_);
									_tmp398_ = _tmp397_;
									_tmp399_ = vala_ccode_constant_new ("0");
									_tmp400_ = _tmp399_;
									_tmp401_ = vala_ccode_variable_declarator_new (_tmp398_, (ValaCCodeExpression*) _tmp400_, NULL);
									_tmp402_ = _tmp401_;
									vala_ccode_declaration_add_declarator (_tmp392_, (ValaCCodeDeclarator*) _tmp402_);
									_vala_ccode_node_unref0 (_tmp402_);
									_vala_ccode_node_unref0 (_tmp400_);
									_g_free0 (_tmp398_);
									_g_free0 (_tmp395_);
									_tmp403_ = f;
									_tmp404_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp403_);
									if (!_tmp404_) {
										ValaCCodeDeclaration* _tmp405_;
										_tmp405_ = len_def;
										vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp405_, VALA_CCODE_MODIFIERS_EXTERN);
									} else {
										ValaCCodeDeclaration* _tmp406_;
										_tmp406_ = len_def;
										vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp406_, VALA_CCODE_MODIFIERS_STATIC);
									}
									_tmp407_ = self->cfile;
									_tmp408_ = len_def;
									vala_ccode_file_add_type_member_declaration (_tmp407_, (ValaCCodeNode*) _tmp408_);
									_vala_ccode_node_unref0 (len_def);
									_vala_code_node_unref0 (len_type);
								}
							}
						}
						_tmp410_ = array_type;
						_tmp411_ = vala_array_type_get_rank (_tmp410_);
						_tmp412_ = _tmp411_;
						if (_tmp412_ == 1) {
							ValaField* _tmp413_;
							gboolean _tmp414_;
							_tmp413_ = f;
							_tmp414_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp413_);
							_tmp409_ = _tmp414_;
						} else {
							_tmp409_ = FALSE;
						}
						if (_tmp409_) {
							ValaDataType* len_type = NULL;
							ValaDataType* _tmp415_;
							ValaDataType* _tmp416_;
							ValaCCodeDeclaration* _cdecl_ = NULL;
							ValaDataType* _tmp417_;
							gchar* _tmp418_;
							gchar* _tmp419_;
							ValaCCodeDeclaration* _tmp420_;
							ValaCCodeDeclaration* _tmp421_;
							ValaCCodeDeclaration* _tmp422_;
							ValaField* _tmp423_;
							gchar* _tmp424_;
							gchar* _tmp425_;
							gchar* _tmp426_;
							gchar* _tmp427_;
							ValaCCodeConstant* _tmp428_;
							ValaCCodeConstant* _tmp429_;
							ValaCCodeVariableDeclarator* _tmp430_;
							ValaCCodeVariableDeclarator* _tmp431_;
							ValaCCodeDeclaration* _tmp432_;
							ValaCCodeFile* _tmp433_;
							ValaCCodeDeclaration* _tmp434_;
							_tmp415_ = self->int_type;
							_tmp416_ = vala_data_type_copy (_tmp415_);
							len_type = _tmp416_;
							_tmp417_ = len_type;
							_tmp418_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp417_);
							_tmp419_ = _tmp418_;
							_tmp420_ = vala_ccode_declaration_new (_tmp419_);
							_tmp421_ = _tmp420_;
							_g_free0 (_tmp419_);
							_cdecl_ = _tmp421_;
							_tmp422_ = _cdecl_;
							_tmp423_ = f;
							_tmp424_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp423_);
							_tmp425_ = _tmp424_;
							_tmp426_ = vala_ccode_base_module_get_array_size_cname (self, _tmp425_);
							_tmp427_ = _tmp426_;
							_tmp428_ = vala_ccode_constant_new ("0");
							_tmp429_ = _tmp428_;
							_tmp430_ = vala_ccode_variable_declarator_new (_tmp427_, (ValaCCodeExpression*) _tmp429_, NULL);
							_tmp431_ = _tmp430_;
							vala_ccode_declaration_add_declarator (_tmp422_, (ValaCCodeDeclarator*) _tmp431_);
							_vala_ccode_node_unref0 (_tmp431_);
							_vala_ccode_node_unref0 (_tmp429_);
							_g_free0 (_tmp427_);
							_g_free0 (_tmp425_);
							_tmp432_ = _cdecl_;
							vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp432_, VALA_CCODE_MODIFIERS_STATIC);
							_tmp433_ = self->cfile;
							_tmp434_ = _cdecl_;
							vala_ccode_file_add_type_member_declaration (_tmp433_, (ValaCCodeNode*) _tmp434_);
							_vala_ccode_node_unref0 (_cdecl_);
							_vala_code_node_unref0 (len_type);
						}
					}
					_vala_code_node_unref0 (array_type);
				} else {
					ValaField* _tmp435_;
					ValaDataType* _tmp436_;
					ValaDataType* _tmp437_;
					_tmp435_ = f;
					_tmp436_ = vala_variable_get_variable_type ((ValaVariable*) _tmp435_);
					_tmp437_ = _tmp436_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp437_, VALA_TYPE_DELEGATE_TYPE)) {
						ValaDelegateType* delegate_type = NULL;
						ValaField* _tmp438_;
						ValaDataType* _tmp439_;
						ValaDataType* _tmp440_;
						ValaDelegateType* _tmp441_;
						ValaDelegateType* _tmp442_;
						ValaDelegate* _tmp443_;
						ValaDelegate* _tmp444_;
						gboolean _tmp445_;
						gboolean _tmp446_;
						_tmp438_ = f;
						_tmp439_ = vala_variable_get_variable_type ((ValaVariable*) _tmp438_);
						_tmp440_ = _tmp439_;
						_tmp441_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp440_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
						delegate_type = _tmp441_;
						_tmp442_ = delegate_type;
						_tmp443_ = vala_delegate_type_get_delegate_symbol (_tmp442_);
						_tmp444_ = _tmp443_;
						_tmp445_ = vala_delegate_get_has_target (_tmp444_);
						_tmp446_ = _tmp445_;
						if (_tmp446_) {
							ValaCCodeDeclaration* target_def = NULL;
							ValaCCodeDeclaration* _tmp447_;
							ValaCCodeDeclaration* _tmp448_;
							ValaField* _tmp449_;
							gchar* _tmp450_;
							gchar* _tmp451_;
							ValaCCodeConstant* _tmp452_;
							ValaCCodeConstant* _tmp453_;
							ValaCCodeVariableDeclarator* _tmp454_;
							ValaCCodeVariableDeclarator* _tmp455_;
							ValaField* _tmp456_;
							gboolean _tmp457_;
							ValaCCodeFile* _tmp460_;
							ValaCCodeDeclaration* _tmp461_;
							ValaDelegateType* _tmp462_;
							gboolean _tmp463_;
							_tmp447_ = vala_ccode_declaration_new ("gpointer");
							target_def = _tmp447_;
							_tmp448_ = target_def;
							_tmp449_ = f;
							_tmp450_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp449_);
							_tmp451_ = _tmp450_;
							_tmp452_ = vala_ccode_constant_new ("NULL");
							_tmp453_ = _tmp452_;
							_tmp454_ = vala_ccode_variable_declarator_new (_tmp451_, (ValaCCodeExpression*) _tmp453_, NULL);
							_tmp455_ = _tmp454_;
							vala_ccode_declaration_add_declarator (_tmp448_, (ValaCCodeDeclarator*) _tmp455_);
							_vala_ccode_node_unref0 (_tmp455_);
							_vala_ccode_node_unref0 (_tmp453_);
							_g_free0 (_tmp451_);
							_tmp456_ = f;
							_tmp457_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp456_);
							if (!_tmp457_) {
								ValaCCodeDeclaration* _tmp458_;
								_tmp458_ = target_def;
								vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp458_, VALA_CCODE_MODIFIERS_EXTERN);
							} else {
								ValaCCodeDeclaration* _tmp459_;
								_tmp459_ = target_def;
								vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp459_, VALA_CCODE_MODIFIERS_STATIC);
							}
							_tmp460_ = self->cfile;
							_tmp461_ = target_def;
							vala_ccode_file_add_type_member_declaration (_tmp460_, (ValaCCodeNode*) _tmp461_);
							_tmp462_ = delegate_type;
							_tmp463_ = vala_data_type_is_disposable ((ValaDataType*) _tmp462_);
							if (_tmp463_) {
								ValaCCodeDeclaration* target_destroy_notify_def = NULL;
								ValaCCodeDeclaration* _tmp464_;
								ValaCCodeDeclaration* _tmp465_;
								ValaField* _tmp466_;
								gchar* _tmp467_;
								gchar* _tmp468_;
								gchar* _tmp469_;
								gchar* _tmp470_;
								ValaCCodeConstant* _tmp471_;
								ValaCCodeConstant* _tmp472_;
								ValaCCodeVariableDeclarator* _tmp473_;
								ValaCCodeVariableDeclarator* _tmp474_;
								ValaField* _tmp475_;
								gboolean _tmp476_;
								ValaCCodeFile* _tmp479_;
								ValaCCodeDeclaration* _tmp480_;
								_tmp464_ = vala_ccode_declaration_new ("GDestroyNotify");
								target_destroy_notify_def = _tmp464_;
								_tmp465_ = target_destroy_notify_def;
								_tmp466_ = f;
								_tmp467_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp466_);
								_tmp468_ = _tmp467_;
								_tmp469_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp468_);
								_tmp470_ = _tmp469_;
								_tmp471_ = vala_ccode_constant_new ("NULL");
								_tmp472_ = _tmp471_;
								_tmp473_ = vala_ccode_variable_declarator_new (_tmp470_, (ValaCCodeExpression*) _tmp472_, NULL);
								_tmp474_ = _tmp473_;
								vala_ccode_declaration_add_declarator (_tmp465_, (ValaCCodeDeclarator*) _tmp474_);
								_vala_ccode_node_unref0 (_tmp474_);
								_vala_ccode_node_unref0 (_tmp472_);
								_g_free0 (_tmp470_);
								_g_free0 (_tmp468_);
								_tmp475_ = f;
								_tmp476_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp475_);
								if (!_tmp476_) {
									ValaCCodeDeclaration* _tmp477_;
									_tmp477_ = target_destroy_notify_def;
									vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp477_, VALA_CCODE_MODIFIERS_EXTERN);
								} else {
									ValaCCodeDeclaration* _tmp478_;
									_tmp478_ = target_destroy_notify_def;
									vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp478_, VALA_CCODE_MODIFIERS_STATIC);
								}
								_tmp479_ = self->cfile;
								_tmp480_ = target_destroy_notify_def;
								vala_ccode_file_add_type_member_declaration (_tmp479_, (ValaCCodeNode*) _tmp480_);
								_vala_ccode_node_unref0 (target_destroy_notify_def);
							}
							_vala_ccode_node_unref0 (target_def);
						}
						_vala_code_node_unref0 (delegate_type);
					}
				}
				_tmp481_ = f;
				_tmp482_ = vala_variable_get_initializer ((ValaVariable*) _tmp481_);
				_tmp483_ = _tmp482_;
				if (_tmp483_ != NULL) {
					ValaCCodeExpression* rhs = NULL;
					ValaField* _tmp484_;
					ValaExpression* _tmp485_;
					ValaExpression* _tmp486_;
					ValaCCodeExpression* _tmp487_;
					ValaCCodeExpression* _tmp488_;
					gboolean _tmp489_;
					_tmp484_ = f;
					_tmp485_ = vala_variable_get_initializer ((ValaVariable*) _tmp484_);
					_tmp486_ = _tmp485_;
					_tmp487_ = vala_ccode_base_module_get_cvalue (self, _tmp486_);
					rhs = _tmp487_;
					_tmp488_ = rhs;
					_tmp489_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp488_);
					if (!_tmp489_) {
						gboolean _tmp490_;
						_tmp490_ = is_gtypeinstance;
						if (_tmp490_) {
							ValaField* _tmp491_;
							ValaExpression* _tmp492_;
							ValaExpression* _tmp493_;
							gboolean _tmp530_ = FALSE;
							ValaField* _tmp531_;
							ValaDataType* _tmp532_;
							ValaDataType* _tmp533_;
							_tmp491_ = f;
							_tmp492_ = vala_variable_get_initializer ((ValaVariable*) _tmp491_);
							_tmp493_ = _tmp492_;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp493_, VALA_TYPE_INITIALIZER_LIST)) {
								ValaCCodeFunction* _tmp494_;
								ValaCCodeFunction* _tmp495_;
								ValaLocalVariable* temp_decl = NULL;
								ValaField* _tmp496_;
								ValaDataType* _tmp497_;
								ValaDataType* _tmp498_;
								ValaLocalVariable* _tmp499_;
								ValaCCodeVariableDeclarator* vardecl = NULL;
								ValaLocalVariable* _tmp500_;
								const gchar* _tmp501_;
								const gchar* _tmp502_;
								ValaCCodeExpression* _tmp503_;
								ValaCCodeVariableDeclarator* _tmp504_;
								ValaCCodeFunction* _tmp505_;
								ValaCCodeFunction* _tmp506_;
								ValaLocalVariable* _tmp507_;
								ValaDataType* _tmp508_;
								ValaDataType* _tmp509_;
								gchar* _tmp510_;
								gchar* _tmp511_;
								ValaCCodeVariableDeclarator* _tmp512_;
								ValaCCodeExpression* tmp = NULL;
								ValaLocalVariable* _tmp513_;
								const gchar* _tmp514_;
								const gchar* _tmp515_;
								gchar* _tmp516_;
								gchar* _tmp517_;
								ValaCCodeExpression* _tmp518_;
								ValaCCodeExpression* _tmp519_;
								ValaCCodeFunction* _tmp520_;
								ValaCCodeFunction* _tmp521_;
								ValaCCodeExpression* _tmp522_;
								ValaCCodeExpression* _tmp523_;
								ValaCCodeFunction* _tmp524_;
								ValaCCodeFunction* _tmp525_;
								_tmp494_ = vala_ccode_base_module_get_ccode (self);
								_tmp495_ = _tmp494_;
								vala_ccode_function_open_block (_tmp495_);
								_tmp496_ = f;
								_tmp497_ = vala_variable_get_variable_type ((ValaVariable*) _tmp496_);
								_tmp498_ = _tmp497_;
								_tmp499_ = vala_ccode_base_module_get_temp_variable (self, _tmp498_, TRUE, NULL, FALSE);
								temp_decl = _tmp499_;
								_tmp500_ = temp_decl;
								_tmp501_ = vala_symbol_get_name ((ValaSymbol*) _tmp500_);
								_tmp502_ = _tmp501_;
								_tmp503_ = rhs;
								_tmp504_ = vala_ccode_variable_declarator_new_zero (_tmp502_, _tmp503_, NULL);
								vardecl = _tmp504_;
								_tmp505_ = vala_ccode_base_module_get_ccode (self);
								_tmp506_ = _tmp505_;
								_tmp507_ = temp_decl;
								_tmp508_ = vala_variable_get_variable_type ((ValaVariable*) _tmp507_);
								_tmp509_ = _tmp508_;
								_tmp510_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp509_);
								_tmp511_ = _tmp510_;
								_tmp512_ = vardecl;
								vala_ccode_function_add_declaration (_tmp506_, _tmp511_, (ValaCCodeDeclarator*) _tmp512_, 0);
								_g_free0 (_tmp511_);
								_tmp513_ = temp_decl;
								_tmp514_ = vala_symbol_get_name ((ValaSymbol*) _tmp513_);
								_tmp515_ = _tmp514_;
								_tmp516_ = vala_ccode_base_module_get_variable_cname (self, _tmp515_);
								_tmp517_ = _tmp516_;
								_tmp518_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp517_);
								_tmp519_ = _tmp518_;
								_g_free0 (_tmp517_);
								tmp = _tmp519_;
								_tmp520_ = vala_ccode_base_module_get_ccode (self);
								_tmp521_ = _tmp520_;
								_tmp522_ = lhs;
								_tmp523_ = tmp;
								vala_ccode_function_add_assignment (_tmp521_, _tmp522_, _tmp523_);
								_tmp524_ = vala_ccode_base_module_get_ccode (self);
								_tmp525_ = _tmp524_;
								vala_ccode_function_close (_tmp525_);
								_vala_ccode_node_unref0 (tmp);
								_vala_ccode_node_unref0 (vardecl);
								_vala_code_node_unref0 (temp_decl);
							} else {
								ValaCCodeFunction* _tmp526_;
								ValaCCodeFunction* _tmp527_;
								ValaCCodeExpression* _tmp528_;
								ValaCCodeExpression* _tmp529_;
								_tmp526_ = vala_ccode_base_module_get_ccode (self);
								_tmp527_ = _tmp526_;
								_tmp528_ = lhs;
								_tmp529_ = rhs;
								vala_ccode_function_add_assignment (_tmp527_, _tmp528_, _tmp529_);
							}
							_tmp531_ = f;
							_tmp532_ = vala_variable_get_variable_type ((ValaVariable*) _tmp531_);
							_tmp533_ = _tmp532_;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp533_, VALA_TYPE_ARRAY_TYPE)) {
								ValaField* _tmp534_;
								gboolean _tmp535_;
								_tmp534_ = f;
								_tmp535_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp534_);
								_tmp530_ = _tmp535_;
							} else {
								_tmp530_ = FALSE;
							}
							if (_tmp530_) {
								ValaArrayType* array_type = NULL;
								ValaField* _tmp536_;
								ValaDataType* _tmp537_;
								ValaDataType* _tmp538_;
								ValaArrayType* _tmp539_;
								ValaTargetValue* field_value = NULL;
								ValaField* _tmp540_;
								ValaTargetValue* _tmp541_;
								ValaGLibValue* glib_value = NULL;
								ValaField* _tmp542_;
								ValaExpression* _tmp543_;
								ValaExpression* _tmp544_;
								ValaTargetValue* _tmp545_;
								ValaTargetValue* _tmp546_;
								ValaGLibValue* _tmp547_;
								ValaGLibValue* _tmp548_;
								ValaList* _tmp549_;
								_tmp536_ = f;
								_tmp537_ = vala_variable_get_variable_type ((ValaVariable*) _tmp536_);
								_tmp538_ = _tmp537_;
								_tmp539_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp538_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
								array_type = _tmp539_;
								_tmp540_ = f;
								_tmp541_ = vala_ccode_base_module_get_field_cvalue (self, _tmp540_, NULL);
								field_value = _tmp541_;
								_tmp542_ = f;
								_tmp543_ = vala_variable_get_initializer ((ValaVariable*) _tmp542_);
								_tmp544_ = _tmp543_;
								_tmp545_ = vala_expression_get_target_value (_tmp544_);
								_tmp546_ = _tmp545_;
								_tmp547_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp546_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
								glib_value = _tmp547_;
								_tmp548_ = glib_value;
								_tmp549_ = _tmp548_->array_length_cvalues;
								if (_tmp549_ != NULL) {
									{
										gint dim = 0;
										dim = 1;
										{
											gboolean _tmp550_ = FALSE;
											_tmp550_ = TRUE;
											while (TRUE) {
												gint _tmp552_;
												ValaArrayType* _tmp553_;
												gint _tmp554_;
												gint _tmp555_;
												ValaCCodeExpression* array_len_lhs = NULL;
												ValaTargetValue* _tmp556_;
												gint _tmp557_;
												ValaCCodeExpression* _tmp558_;
												ValaCCodeFunction* _tmp559_;
												ValaCCodeFunction* _tmp560_;
												ValaCCodeExpression* _tmp561_;
												ValaGLibValue* _tmp562_;
												gint _tmp563_;
												ValaCCodeExpression* _tmp564_;
												ValaCCodeExpression* _tmp565_;
												if (!_tmp550_) {
													gint _tmp551_;
													_tmp551_ = dim;
													dim = _tmp551_ + 1;
												}
												_tmp550_ = FALSE;
												_tmp552_ = dim;
												_tmp553_ = array_type;
												_tmp554_ = vala_array_type_get_rank (_tmp553_);
												_tmp555_ = _tmp554_;
												if (!(_tmp552_ <= _tmp555_)) {
													break;
												}
												_tmp556_ = field_value;
												_tmp557_ = dim;
												_tmp558_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp556_, _tmp557_);
												array_len_lhs = _tmp558_;
												_tmp559_ = vala_ccode_base_module_get_ccode (self);
												_tmp560_ = _tmp559_;
												_tmp561_ = array_len_lhs;
												_tmp562_ = glib_value;
												_tmp563_ = dim;
												_tmp564_ = vala_ccode_base_module_get_array_length_cvalue (self, (ValaTargetValue*) _tmp562_, _tmp563_);
												_tmp565_ = _tmp564_;
												vala_ccode_function_add_assignment (_tmp560_, _tmp561_, _tmp565_);
												_vala_ccode_node_unref0 (_tmp565_);
												_vala_ccode_node_unref0 (array_len_lhs);
											}
										}
									}
								} else {
									ValaGLibValue* _tmp566_;
									gboolean _tmp567_;
									_tmp566_ = glib_value;
									_tmp567_ = _tmp566_->array_null_terminated;
									if (_tmp567_) {
										ValaCCodeFunctionCall* len_call = NULL;
										ValaCCodeIdentifier* _tmp568_;
										ValaCCodeIdentifier* _tmp569_;
										ValaCCodeFunctionCall* _tmp570_;
										ValaCCodeFunctionCall* _tmp571_;
										ValaCCodeFunctionCall* _tmp572_;
										ValaGLibValue* _tmp573_;
										ValaCCodeExpression* _tmp574_;
										ValaCCodeExpression* _tmp575_;
										ValaCCodeFunction* _tmp576_;
										ValaCCodeFunction* _tmp577_;
										ValaTargetValue* _tmp578_;
										ValaCCodeExpression* _tmp579_;
										ValaCCodeExpression* _tmp580_;
										ValaCCodeFunctionCall* _tmp581_;
										self->requires_array_length = TRUE;
										_tmp568_ = vala_ccode_identifier_new ("_vala_array_length");
										_tmp569_ = _tmp568_;
										_tmp570_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp569_);
										_tmp571_ = _tmp570_;
										_vala_ccode_node_unref0 (_tmp569_);
										len_call = _tmp571_;
										_tmp572_ = len_call;
										_tmp573_ = glib_value;
										_tmp574_ = vala_ccode_base_module_get_cvalue_ (self, (ValaTargetValue*) _tmp573_);
										_tmp575_ = _tmp574_;
										vala_ccode_function_call_add_argument (_tmp572_, _tmp575_);
										_vala_ccode_node_unref0 (_tmp575_);
										_tmp576_ = vala_ccode_base_module_get_ccode (self);
										_tmp577_ = _tmp576_;
										_tmp578_ = field_value;
										_tmp579_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp578_, 1);
										_tmp580_ = _tmp579_;
										_tmp581_ = len_call;
										vala_ccode_function_add_assignment (_tmp577_, _tmp580_, (ValaCCodeExpression*) _tmp581_);
										_vala_ccode_node_unref0 (_tmp580_);
										_vala_ccode_node_unref0 (len_call);
									} else {
										{
											gint dim = 0;
											dim = 1;
											{
												gboolean _tmp582_ = FALSE;
												_tmp582_ = TRUE;
												while (TRUE) {
													gint _tmp584_;
													ValaArrayType* _tmp585_;
													gint _tmp586_;
													gint _tmp587_;
													ValaCCodeFunction* _tmp588_;
													ValaCCodeFunction* _tmp589_;
													ValaTargetValue* _tmp590_;
													gint _tmp591_;
													ValaCCodeExpression* _tmp592_;
													ValaCCodeExpression* _tmp593_;
													ValaCCodeConstant* _tmp594_;
													ValaCCodeConstant* _tmp595_;
													if (!_tmp582_) {
														gint _tmp583_;
														_tmp583_ = dim;
														dim = _tmp583_ + 1;
													}
													_tmp582_ = FALSE;
													_tmp584_ = dim;
													_tmp585_ = array_type;
													_tmp586_ = vala_array_type_get_rank (_tmp585_);
													_tmp587_ = _tmp586_;
													if (!(_tmp584_ <= _tmp587_)) {
														break;
													}
													_tmp588_ = vala_ccode_base_module_get_ccode (self);
													_tmp589_ = _tmp588_;
													_tmp590_ = field_value;
													_tmp591_ = dim;
													_tmp592_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp590_, _tmp591_);
													_tmp593_ = _tmp592_;
													_tmp594_ = vala_ccode_constant_new ("-1");
													_tmp595_ = _tmp594_;
													vala_ccode_function_add_assignment (_tmp589_, _tmp593_, (ValaCCodeExpression*) _tmp595_);
													_vala_ccode_node_unref0 (_tmp595_);
													_vala_ccode_node_unref0 (_tmp593_);
												}
											}
										}
									}
								}
								_vala_target_value_unref0 (glib_value);
								_vala_target_value_unref0 (field_value);
								_vala_code_node_unref0 (array_type);
							}
						} else {
							ValaField* _tmp596_;
							ValaField* _tmp597_;
							ValaSourceReference* _tmp598_;
							ValaSourceReference* _tmp599_;
							_tmp596_ = f;
							vala_code_node_set_error ((ValaCodeNode*) _tmp596_, TRUE);
							_tmp597_ = f;
							_tmp598_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp597_);
							_tmp599_ = _tmp598_;
							vala_report_error (_tmp599_, "Non-constant field initializers not supported in this context");
							_vala_ccode_node_unref0 (rhs);
							_vala_ccode_node_unref0 (var_def);
							_vala_ccode_node_unref0 (var_decl);
							_vala_ccode_node_unref0 (lhs);
							_vala_code_node_unref0 (cl);
							return;
						}
					}
					_vala_ccode_node_unref0 (rhs);
				}
				vala_ccode_base_module_pop_context (self);
				_vala_ccode_node_unref0 (var_def);
				_vala_ccode_node_unref0 (var_decl);
			}
		}
	}
	vala_ccode_base_module_pop_line (self);
	_vala_ccode_node_unref0 (lhs);
	_vala_code_node_unref0 (cl);
}


gboolean vala_ccode_base_module_is_constant_ccode_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr) {
	gboolean result = FALSE;
	ValaCCodeExpression* _tmp0_;
	ValaCCodeParenthesizedExpression* cparenthesized = NULL;
	ValaCCodeExpression* _tmp30_;
	ValaCCodeParenthesizedExpression* _tmp31_;
	gboolean _tmp32_ = FALSE;
	ValaCCodeParenthesizedExpression* _tmp33_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (cexpr != NULL, FALSE);
	_tmp0_ = cexpr;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CCODE_CONSTANT)) {
		result = TRUE;
		return result;
	} else {
		ValaCCodeExpression* _tmp1_;
		_tmp1_ = cexpr;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CCODE_CAST_EXPRESSION)) {
			ValaCCodeCastExpression* ccast = NULL;
			ValaCCodeExpression* _tmp2_;
			ValaCCodeCastExpression* _tmp3_;
			ValaCCodeCastExpression* _tmp4_;
			ValaCCodeExpression* _tmp5_;
			ValaCCodeExpression* _tmp6_;
			gboolean _tmp7_;
			_tmp2_ = cexpr;
			_tmp3_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_CCODE_CAST_EXPRESSION, ValaCCodeCastExpression));
			ccast = _tmp3_;
			_tmp4_ = ccast;
			_tmp5_ = vala_ccode_cast_expression_get_inner (_tmp4_);
			_tmp6_ = _tmp5_;
			_tmp7_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp6_);
			result = _tmp7_;
			_vala_ccode_node_unref0 (ccast);
			return result;
		} else {
			ValaCCodeExpression* _tmp8_;
			_tmp8_ = cexpr;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_CCODE_UNARY_EXPRESSION)) {
				ValaCCodeUnaryExpression* cunary = NULL;
				ValaCCodeExpression* _tmp9_;
				ValaCCodeUnaryExpression* _tmp10_;
				ValaCCodeUnaryExpression* _tmp11_;
				ValaCCodeUnaryOperator _tmp12_;
				ValaCCodeUnaryOperator _tmp13_;
				ValaCCodeUnaryExpression* _tmp14_;
				ValaCCodeExpression* _tmp15_;
				ValaCCodeExpression* _tmp16_;
				gboolean _tmp17_;
				_tmp9_ = cexpr;
				_tmp10_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_CCODE_UNARY_EXPRESSION, ValaCCodeUnaryExpression));
				cunary = _tmp10_;
				_tmp11_ = cunary;
				_tmp12_ = vala_ccode_unary_expression_get_operator (_tmp11_);
				_tmp13_ = _tmp12_;
				switch (_tmp13_) {
					case VALA_CCODE_UNARY_OPERATOR_PREFIX_INCREMENT:
					case VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT:
					case VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT:
					case VALA_CCODE_UNARY_OPERATOR_POSTFIX_DECREMENT:
					{
						result = FALSE;
						_vala_ccode_node_unref0 (cunary);
						return result;
					}
					default:
					break;
				}
				_tmp14_ = cunary;
				_tmp15_ = vala_ccode_unary_expression_get_inner (_tmp14_);
				_tmp16_ = _tmp15_;
				_tmp17_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp16_);
				result = _tmp17_;
				_vala_ccode_node_unref0 (cunary);
				return result;
			} else {
				ValaCCodeExpression* _tmp18_;
				_tmp18_ = cexpr;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp18_, VALA_TYPE_CCODE_BINARY_EXPRESSION)) {
					ValaCCodeBinaryExpression* cbinary = NULL;
					ValaCCodeExpression* _tmp19_;
					ValaCCodeBinaryExpression* _tmp20_;
					gboolean _tmp21_ = FALSE;
					ValaCCodeBinaryExpression* _tmp22_;
					ValaCCodeExpression* _tmp23_;
					ValaCCodeExpression* _tmp24_;
					gboolean _tmp25_;
					_tmp19_ = cexpr;
					_tmp20_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, VALA_TYPE_CCODE_BINARY_EXPRESSION, ValaCCodeBinaryExpression));
					cbinary = _tmp20_;
					_tmp22_ = cbinary;
					_tmp23_ = vala_ccode_binary_expression_get_left (_tmp22_);
					_tmp24_ = _tmp23_;
					_tmp25_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp24_);
					if (_tmp25_) {
						ValaCCodeBinaryExpression* _tmp26_;
						ValaCCodeExpression* _tmp27_;
						ValaCCodeExpression* _tmp28_;
						gboolean _tmp29_;
						_tmp26_ = cbinary;
						_tmp27_ = vala_ccode_binary_expression_get_right (_tmp26_);
						_tmp28_ = _tmp27_;
						_tmp29_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp28_);
						_tmp21_ = _tmp29_;
					} else {
						_tmp21_ = FALSE;
					}
					result = _tmp21_;
					_vala_ccode_node_unref0 (cbinary);
					return result;
				}
			}
		}
	}
	_tmp30_ = cexpr;
	_tmp31_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp30_, VALA_TYPE_CCODE_PARENTHESIZED_EXPRESSION) ? ((ValaCCodeParenthesizedExpression*) _tmp30_) : NULL);
	cparenthesized = _tmp31_;
	_tmp33_ = cparenthesized;
	if (NULL != _tmp33_) {
		ValaCCodeParenthesizedExpression* _tmp34_;
		ValaCCodeExpression* _tmp35_;
		ValaCCodeExpression* _tmp36_;
		gboolean _tmp37_;
		_tmp34_ = cparenthesized;
		_tmp35_ = vala_ccode_parenthesized_expression_get_inner (_tmp34_);
		_tmp36_ = _tmp35_;
		_tmp37_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp36_);
		_tmp32_ = _tmp37_;
	} else {
		_tmp32_ = FALSE;
	}
	result = _tmp32_;
	_vala_ccode_node_unref0 (cparenthesized);
	return result;
}


/**
 * Returns whether the passed cexpr is a pure expression, i.e. an
 * expression without side-effects.
 */
gboolean vala_ccode_base_module_is_pure_ccode_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr) {
	gboolean result = FALSE;
	gboolean _tmp0_ = FALSE;
	ValaCCodeExpression* _tmp1_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (cexpr != NULL, FALSE);
	_tmp1_ = cexpr;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CCODE_CONSTANT)) {
		_tmp0_ = TRUE;
	} else {
		ValaCCodeExpression* _tmp2_;
		_tmp2_ = cexpr;
		_tmp0_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CCODE_IDENTIFIER);
	}
	if (_tmp0_) {
		result = TRUE;
		return result;
	} else {
		ValaCCodeExpression* _tmp3_;
		_tmp3_ = cexpr;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_CCODE_BINARY_EXPRESSION)) {
			ValaCCodeBinaryExpression* cbinary = NULL;
			ValaCCodeExpression* _tmp4_;
			ValaCCodeBinaryExpression* _tmp5_;
			gboolean _tmp6_ = FALSE;
			ValaCCodeBinaryExpression* _tmp7_;
			ValaCCodeExpression* _tmp8_;
			ValaCCodeExpression* _tmp9_;
			gboolean _tmp10_;
			_tmp4_ = cexpr;
			_tmp5_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_CCODE_BINARY_EXPRESSION, ValaCCodeBinaryExpression));
			cbinary = _tmp5_;
			_tmp7_ = cbinary;
			_tmp8_ = vala_ccode_binary_expression_get_left (_tmp7_);
			_tmp9_ = _tmp8_;
			_tmp10_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp9_);
			if (_tmp10_) {
				ValaCCodeBinaryExpression* _tmp11_;
				ValaCCodeExpression* _tmp12_;
				ValaCCodeExpression* _tmp13_;
				gboolean _tmp14_;
				_tmp11_ = cbinary;
				_tmp12_ = vala_ccode_binary_expression_get_right (_tmp11_);
				_tmp13_ = _tmp12_;
				_tmp14_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp13_);
				_tmp6_ = _tmp14_;
			} else {
				_tmp6_ = FALSE;
			}
			result = _tmp6_;
			_vala_ccode_node_unref0 (cbinary);
			return result;
		} else {
			ValaCCodeExpression* _tmp15_;
			_tmp15_ = cexpr;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_CCODE_UNARY_EXPRESSION)) {
				ValaCCodeUnaryExpression* cunary = NULL;
				ValaCCodeExpression* _tmp16_;
				ValaCCodeUnaryExpression* _tmp17_;
				ValaCCodeUnaryExpression* _tmp18_;
				ValaCCodeUnaryOperator _tmp19_;
				ValaCCodeUnaryOperator _tmp20_;
				_tmp16_ = cexpr;
				_tmp17_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp16_, VALA_TYPE_CCODE_UNARY_EXPRESSION, ValaCCodeUnaryExpression));
				cunary = _tmp17_;
				_tmp18_ = cunary;
				_tmp19_ = vala_ccode_unary_expression_get_operator (_tmp18_);
				_tmp20_ = _tmp19_;
				switch (_tmp20_) {
					case VALA_CCODE_UNARY_OPERATOR_PREFIX_INCREMENT:
					case VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT:
					case VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT:
					case VALA_CCODE_UNARY_OPERATOR_POSTFIX_DECREMENT:
					{
						result = FALSE;
						_vala_ccode_node_unref0 (cunary);
						return result;
					}
					default:
					{
						ValaCCodeUnaryExpression* _tmp21_;
						ValaCCodeExpression* _tmp22_;
						ValaCCodeExpression* _tmp23_;
						gboolean _tmp24_;
						_tmp21_ = cunary;
						_tmp22_ = vala_ccode_unary_expression_get_inner (_tmp21_);
						_tmp23_ = _tmp22_;
						_tmp24_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp23_);
						result = _tmp24_;
						_vala_ccode_node_unref0 (cunary);
						return result;
					}
				}
				_vala_ccode_node_unref0 (cunary);
			} else {
				ValaCCodeExpression* _tmp25_;
				_tmp25_ = cexpr;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_CCODE_MEMBER_ACCESS)) {
					ValaCCodeMemberAccess* cma = NULL;
					ValaCCodeExpression* _tmp26_;
					ValaCCodeMemberAccess* _tmp27_;
					ValaCCodeMemberAccess* _tmp28_;
					ValaCCodeExpression* _tmp29_;
					ValaCCodeExpression* _tmp30_;
					gboolean _tmp31_;
					_tmp26_ = cexpr;
					_tmp27_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_CCODE_MEMBER_ACCESS, ValaCCodeMemberAccess));
					cma = _tmp27_;
					_tmp28_ = cma;
					_tmp29_ = vala_ccode_member_access_get_inner (_tmp28_);
					_tmp30_ = _tmp29_;
					_tmp31_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp30_);
					result = _tmp31_;
					_vala_ccode_node_unref0 (cma);
					return result;
				} else {
					ValaCCodeExpression* _tmp32_;
					_tmp32_ = cexpr;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_CCODE_ELEMENT_ACCESS)) {
						ValaCCodeElementAccess* cea = NULL;
						ValaCCodeExpression* _tmp33_;
						ValaCCodeElementAccess* _tmp34_;
						gboolean _tmp35_ = FALSE;
						ValaCCodeElementAccess* _tmp36_;
						ValaCCodeExpression* _tmp37_;
						ValaCCodeExpression* _tmp38_;
						gboolean _tmp39_;
						_tmp33_ = cexpr;
						_tmp34_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_CCODE_ELEMENT_ACCESS, ValaCCodeElementAccess));
						cea = _tmp34_;
						_tmp36_ = cea;
						_tmp37_ = vala_ccode_element_access_get_container (_tmp36_);
						_tmp38_ = _tmp37_;
						_tmp39_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp38_);
						if (_tmp39_) {
							ValaCCodeElementAccess* _tmp40_;
							ValaCCodeExpression* _tmp41_;
							ValaCCodeExpression* _tmp42_;
							gboolean _tmp43_;
							_tmp40_ = cea;
							_tmp41_ = vala_ccode_element_access_get_index (_tmp40_);
							_tmp42_ = _tmp41_;
							_tmp43_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp42_);
							_tmp35_ = _tmp43_;
						} else {
							_tmp35_ = FALSE;
						}
						result = _tmp35_;
						_vala_ccode_node_unref0 (cea);
						return result;
					} else {
						ValaCCodeExpression* _tmp44_;
						_tmp44_ = cexpr;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp44_, VALA_TYPE_CCODE_CAST_EXPRESSION)) {
							ValaCCodeCastExpression* ccast = NULL;
							ValaCCodeExpression* _tmp45_;
							ValaCCodeCastExpression* _tmp46_;
							ValaCCodeCastExpression* _tmp47_;
							ValaCCodeExpression* _tmp48_;
							ValaCCodeExpression* _tmp49_;
							gboolean _tmp50_;
							_tmp45_ = cexpr;
							_tmp46_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp45_, VALA_TYPE_CCODE_CAST_EXPRESSION, ValaCCodeCastExpression));
							ccast = _tmp46_;
							_tmp47_ = ccast;
							_tmp48_ = vala_ccode_cast_expression_get_inner (_tmp47_);
							_tmp49_ = _tmp48_;
							_tmp50_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp49_);
							result = _tmp50_;
							_vala_ccode_node_unref0 (ccast);
							return result;
						} else {
							ValaCCodeExpression* _tmp51_;
							_tmp51_ = cexpr;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp51_, VALA_TYPE_CCODE_PARENTHESIZED_EXPRESSION)) {
								ValaCCodeParenthesizedExpression* cparenthesized = NULL;
								ValaCCodeExpression* _tmp52_;
								ValaCCodeParenthesizedExpression* _tmp53_;
								ValaCCodeParenthesizedExpression* _tmp54_;
								ValaCCodeExpression* _tmp55_;
								ValaCCodeExpression* _tmp56_;
								gboolean _tmp57_;
								_tmp52_ = cexpr;
								_tmp53_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp52_, VALA_TYPE_CCODE_PARENTHESIZED_EXPRESSION, ValaCCodeParenthesizedExpression));
								cparenthesized = _tmp53_;
								_tmp54_ = cparenthesized;
								_tmp55_ = vala_ccode_parenthesized_expression_get_inner (_tmp54_);
								_tmp56_ = _tmp55_;
								_tmp57_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp56_);
								result = _tmp57_;
								_vala_ccode_node_unref0 (cparenthesized);
								return result;
							}
						}
					}
				}
			}
		}
	}
	result = FALSE;
	return result;
}


static void vala_ccode_base_module_real_visit_formal_parameter (ValaCodeVisitor* base, ValaParameter* p) {
	ValaCCodeBaseModule * self;
	ValaParameter* _tmp0_;
	gboolean _tmp1_;
	gboolean _tmp2_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (p != NULL);
	_tmp0_ = p;
	_tmp1_ = vala_parameter_get_ellipsis (_tmp0_);
	_tmp2_ = _tmp1_;
	if (!_tmp2_) {
		ValaParameter* _tmp3_;
		ValaDataType* _tmp4_;
		ValaDataType* _tmp5_;
		_tmp3_ = p;
		_tmp4_ = vala_variable_get_variable_type ((ValaVariable*) _tmp3_);
		_tmp5_ = _tmp4_;
		vala_ccode_base_module_check_type (self, _tmp5_);
	}
}


static void vala_ccode_base_module_real_visit_property (ValaCodeVisitor* base, ValaProperty* prop) {
	ValaCCodeBaseModule * self;
	ValaProperty* _tmp0_;
	ValaProperty* _tmp1_;
	ValaDataType* _tmp2_;
	ValaDataType* _tmp3_;
	ValaProperty* _tmp4_;
	ValaPropertyAccessor* _tmp5_;
	ValaPropertyAccessor* _tmp6_;
	ValaProperty* _tmp10_;
	ValaPropertyAccessor* _tmp11_;
	ValaPropertyAccessor* _tmp12_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (prop != NULL);
	_tmp0_ = prop;
	vala_ccode_base_module_visit_member (self, (ValaSymbol*) _tmp0_);
	_tmp1_ = prop;
	_tmp2_ = vala_property_get_property_type (_tmp1_);
	_tmp3_ = _tmp2_;
	vala_ccode_base_module_check_type (self, _tmp3_);
	_tmp4_ = prop;
	_tmp5_ = vala_property_get_get_accessor (_tmp4_);
	_tmp6_ = _tmp5_;
	if (_tmp6_ != NULL) {
		ValaProperty* _tmp7_;
		ValaPropertyAccessor* _tmp8_;
		ValaPropertyAccessor* _tmp9_;
		_tmp7_ = prop;
		_tmp8_ = vala_property_get_get_accessor (_tmp7_);
		_tmp9_ = _tmp8_;
		vala_code_node_accept ((ValaCodeNode*) _tmp9_, (ValaCodeVisitor*) self);
	}
	_tmp10_ = prop;
	_tmp11_ = vala_property_get_set_accessor (_tmp10_);
	_tmp12_ = _tmp11_;
	if (_tmp12_ != NULL) {
		ValaProperty* _tmp13_;
		ValaPropertyAccessor* _tmp14_;
		ValaPropertyAccessor* _tmp15_;
		_tmp13_ = prop;
		_tmp14_ = vala_property_get_set_accessor (_tmp13_);
		_tmp15_ = _tmp14_;
		vala_code_node_accept ((ValaCodeNode*) _tmp15_, (ValaCodeVisitor*) self);
	}
}


void vala_ccode_base_module_generate_type_declaration (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeFile* decl_space) {
	ValaDataType* _tmp0_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (type != NULL);
	g_return_if_fail (decl_space != NULL);
	_tmp0_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_OBJECT_TYPE)) {
		ValaObjectType* object_type = NULL;
		ValaDataType* _tmp1_;
		ValaObjectType* _tmp2_;
		ValaObjectType* _tmp3_;
		ValaObjectTypeSymbol* _tmp4_;
		ValaObjectTypeSymbol* _tmp5_;
		_tmp1_ = type;
		_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));
		object_type = _tmp2_;
		_tmp3_ = object_type;
		_tmp4_ = vala_object_type_get_type_symbol (_tmp3_);
		_tmp5_ = _tmp4_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_CLASS)) {
			ValaObjectType* _tmp6_;
			ValaObjectTypeSymbol* _tmp7_;
			ValaObjectTypeSymbol* _tmp8_;
			ValaCCodeFile* _tmp9_;
			_tmp6_ = object_type;
			_tmp7_ = vala_object_type_get_type_symbol (_tmp6_);
			_tmp8_ = _tmp7_;
			_tmp9_ = decl_space;
			vala_ccode_base_module_generate_class_declaration (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_CLASS, ValaClass), _tmp9_);
		} else {
			ValaObjectType* _tmp10_;
			ValaObjectTypeSymbol* _tmp11_;
			ValaObjectTypeSymbol* _tmp12_;
			_tmp10_ = object_type;
			_tmp11_ = vala_object_type_get_type_symbol (_tmp10_);
			_tmp12_ = _tmp11_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_INTERFACE)) {
				ValaObjectType* _tmp13_;
				ValaObjectTypeSymbol* _tmp14_;
				ValaObjectTypeSymbol* _tmp15_;
				ValaCCodeFile* _tmp16_;
				_tmp13_ = object_type;
				_tmp14_ = vala_object_type_get_type_symbol (_tmp13_);
				_tmp15_ = _tmp14_;
				_tmp16_ = decl_space;
				vala_ccode_base_module_generate_interface_declaration (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp15_, VALA_TYPE_INTERFACE, ValaInterface), _tmp16_);
			}
		}
		_vala_code_node_unref0 (object_type);
	} else {
		ValaDataType* _tmp17_;
		_tmp17_ = type;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_DELEGATE_TYPE)) {
			ValaDelegateType* deleg_type = NULL;
			ValaDataType* _tmp18_;
			ValaDelegateType* _tmp19_;
			ValaDelegate* d = NULL;
			ValaDelegateType* _tmp20_;
			ValaDelegate* _tmp21_;
			ValaDelegate* _tmp22_;
			ValaDelegate* _tmp23_;
			ValaDelegate* _tmp24_;
			ValaCCodeFile* _tmp25_;
			_tmp18_ = type;
			_tmp19_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp18_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
			deleg_type = _tmp19_;
			_tmp20_ = deleg_type;
			_tmp21_ = vala_delegate_type_get_delegate_symbol (_tmp20_);
			_tmp22_ = _tmp21_;
			_tmp23_ = _vala_code_node_ref0 (_tmp22_);
			d = _tmp23_;
			_tmp24_ = d;
			_tmp25_ = decl_space;
			vala_ccode_base_module_generate_delegate_declaration (self, _tmp24_, _tmp25_);
			_vala_code_node_unref0 (d);
			_vala_code_node_unref0 (deleg_type);
		} else {
			ValaDataType* _tmp26_;
			ValaTypeSymbol* _tmp27_;
			ValaTypeSymbol* _tmp28_;
			_tmp26_ = type;
			_tmp27_ = vala_data_type_get_data_type (_tmp26_);
			_tmp28_ = _tmp27_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp28_, VALA_TYPE_ENUM)) {
				ValaEnum* en = NULL;
				ValaDataType* _tmp29_;
				ValaTypeSymbol* _tmp30_;
				ValaTypeSymbol* _tmp31_;
				ValaEnum* _tmp32_;
				ValaEnum* _tmp33_;
				ValaCCodeFile* _tmp34_;
				_tmp29_ = type;
				_tmp30_ = vala_data_type_get_data_type (_tmp29_);
				_tmp31_ = _tmp30_;
				_tmp32_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp31_, VALA_TYPE_ENUM, ValaEnum));
				en = _tmp32_;
				_tmp33_ = en;
				_tmp34_ = decl_space;
				vala_ccode_base_module_generate_enum_declaration (self, _tmp33_, _tmp34_);
				_vala_code_node_unref0 (en);
			} else {
				ValaDataType* _tmp35_;
				_tmp35_ = type;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp35_, VALA_TYPE_VALUE_TYPE)) {
					ValaValueType* value_type = NULL;
					ValaDataType* _tmp36_;
					ValaValueType* _tmp37_;
					ValaValueType* _tmp38_;
					ValaTypeSymbol* _tmp39_;
					ValaTypeSymbol* _tmp40_;
					ValaCCodeFile* _tmp41_;
					_tmp36_ = type;
					_tmp37_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp36_, VALA_TYPE_VALUE_TYPE, ValaValueType));
					value_type = _tmp37_;
					_tmp38_ = value_type;
					_tmp39_ = vala_value_type_get_type_symbol (_tmp38_);
					_tmp40_ = _tmp39_;
					_tmp41_ = decl_space;
					vala_ccode_base_module_generate_struct_declaration (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp40_, VALA_TYPE_STRUCT, ValaStruct), _tmp41_);
					_vala_code_node_unref0 (value_type);
				} else {
					ValaDataType* _tmp42_;
					_tmp42_ = type;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp42_, VALA_TYPE_ARRAY_TYPE)) {
						ValaArrayType* array_type = NULL;
						ValaDataType* _tmp43_;
						ValaArrayType* _tmp44_;
						ValaArrayType* _tmp45_;
						ValaDataType* _tmp46_;
						ValaDataType* _tmp47_;
						ValaCCodeFile* _tmp48_;
						_tmp43_ = type;
						_tmp44_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp43_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
						array_type = _tmp44_;
						_tmp45_ = array_type;
						_tmp46_ = vala_array_type_get_element_type (_tmp45_);
						_tmp47_ = _tmp46_;
						_tmp48_ = decl_space;
						vala_ccode_base_module_generate_type_declaration (self, _tmp47_, _tmp48_);
						_vala_code_node_unref0 (array_type);
					} else {
						ValaDataType* _tmp49_;
						_tmp49_ = type;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp49_, VALA_TYPE_ERROR_TYPE)) {
							ValaErrorType* error_type = NULL;
							ValaDataType* _tmp50_;
							ValaErrorType* _tmp51_;
							ValaErrorType* _tmp52_;
							ValaErrorDomain* _tmp53_;
							ValaErrorDomain* _tmp54_;
							_tmp50_ = type;
							_tmp51_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp50_, VALA_TYPE_ERROR_TYPE, ValaErrorType));
							error_type = _tmp51_;
							_tmp52_ = error_type;
							_tmp53_ = vala_error_type_get_error_domain (_tmp52_);
							_tmp54_ = _tmp53_;
							if (_tmp54_ != NULL) {
								ValaErrorType* _tmp55_;
								ValaErrorDomain* _tmp56_;
								ValaErrorDomain* _tmp57_;
								ValaCCodeFile* _tmp58_;
								_tmp55_ = error_type;
								_tmp56_ = vala_error_type_get_error_domain (_tmp55_);
								_tmp57_ = _tmp56_;
								_tmp58_ = decl_space;
								vala_ccode_base_module_generate_error_domain_declaration (self, _tmp57_, _tmp58_);
							}
							_vala_code_node_unref0 (error_type);
						} else {
							ValaDataType* _tmp59_;
							_tmp59_ = type;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp59_, VALA_TYPE_POINTER_TYPE)) {
								ValaPointerType* pointer_type = NULL;
								ValaDataType* _tmp60_;
								ValaPointerType* _tmp61_;
								ValaPointerType* _tmp62_;
								ValaDataType* _tmp63_;
								ValaDataType* _tmp64_;
								ValaCCodeFile* _tmp65_;
								_tmp60_ = type;
								_tmp61_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp60_, VALA_TYPE_POINTER_TYPE, ValaPointerType));
								pointer_type = _tmp61_;
								_tmp62_ = pointer_type;
								_tmp63_ = vala_pointer_type_get_base_type (_tmp62_);
								_tmp64_ = _tmp63_;
								_tmp65_ = decl_space;
								vala_ccode_base_module_generate_type_declaration (self, _tmp64_, _tmp65_);
								_vala_code_node_unref0 (pointer_type);
							}
						}
					}
				}
			}
		}
	}
	{
		ValaList* _type_arg_list = NULL;
		ValaDataType* _tmp66_;
		ValaList* _tmp67_;
		gint _type_arg_size = 0;
		ValaList* _tmp68_;
		gint _tmp69_;
		gint _tmp70_;
		gint _type_arg_index = 0;
		_tmp66_ = type;
		_tmp67_ = vala_data_type_get_type_arguments (_tmp66_);
		_type_arg_list = _tmp67_;
		_tmp68_ = _type_arg_list;
		_tmp69_ = vala_collection_get_size ((ValaCollection*) _tmp68_);
		_tmp70_ = _tmp69_;
		_type_arg_size = _tmp70_;
		_type_arg_index = -1;
		while (TRUE) {
			gint _tmp71_;
			gint _tmp72_;
			gint _tmp73_;
			ValaDataType* type_arg = NULL;
			ValaList* _tmp74_;
			gint _tmp75_;
			gpointer _tmp76_;
			ValaDataType* _tmp77_;
			ValaCCodeFile* _tmp78_;
			_tmp71_ = _type_arg_index;
			_type_arg_index = _tmp71_ + 1;
			_tmp72_ = _type_arg_index;
			_tmp73_ = _type_arg_size;
			if (!(_tmp72_ < _tmp73_)) {
				break;
			}
			_tmp74_ = _type_arg_list;
			_tmp75_ = _type_arg_index;
			_tmp76_ = vala_list_get (_tmp74_, _tmp75_);
			type_arg = (ValaDataType*) _tmp76_;
			_tmp77_ = type_arg;
			_tmp78_ = decl_space;
			vala_ccode_base_module_generate_type_declaration (self, _tmp77_, _tmp78_);
			_vala_code_node_unref0 (type_arg);
		}
		_vala_iterable_unref0 (_type_arg_list);
	}
}


static void vala_ccode_base_module_real_generate_class_struct_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space) {
	g_return_if_fail (cl != NULL);
	g_return_if_fail (decl_space != NULL);
}


void vala_ccode_base_module_generate_class_struct_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_class_struct_declaration (self, cl, decl_space);
}


static void vala_ccode_base_module_real_generate_struct_declaration (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space) {
	g_return_if_fail (st != NULL);
	g_return_if_fail (decl_space != NULL);
}


void vala_ccode_base_module_generate_struct_declaration (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_struct_declaration (self, st, decl_space);
}


static void vala_ccode_base_module_real_generate_delegate_declaration (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space) {
	g_return_if_fail (d != NULL);
	g_return_if_fail (decl_space != NULL);
}


void vala_ccode_base_module_generate_delegate_declaration (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_delegate_declaration (self, d, decl_space);
}


static void vala_ccode_base_module_real_generate_cparameters (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction) {
	g_return_if_fail (m != NULL);
	g_return_if_fail (decl_space != NULL);
	g_return_if_fail (cparam_map != NULL);
	g_return_if_fail (func != NULL);
}


void vala_ccode_base_module_generate_cparameters (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_cparameters (self, m, decl_space, cparam_map, func, vdeclarator, carg_map, vcall, direction);
}


void vala_ccode_base_module_generate_property_accessor_declaration (ValaCCodeBaseModule* self, ValaPropertyAccessor* acc, ValaCCodeFile* decl_space) {
	ValaCCodeFile* _tmp0_;
	ValaPropertyAccessor* _tmp1_;
	ValaPropertyAccessor* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gboolean _tmp5_;
	gboolean _tmp6_;
	ValaProperty* prop = NULL;
	ValaPropertyAccessor* _tmp7_;
	ValaProperty* _tmp8_;
	ValaProperty* _tmp9_;
	ValaProperty* _tmp10_;
	gboolean _tmp11_ = FALSE;
	ValaPropertyAccessor* _tmp12_;
	gboolean _tmp13_;
	gboolean _tmp14_;
	gboolean returns_real_struct = FALSE;
	ValaCCodeParameter* cvalueparam = NULL;
	gboolean _tmp19_;
	ValaPropertyAccessor* _tmp50_;
	ValaDataType* _tmp51_;
	ValaDataType* _tmp52_;
	ValaCCodeFile* _tmp53_;
	ValaCCodeFunction* function = NULL;
	gboolean _tmp54_ = FALSE;
	ValaPropertyAccessor* _tmp55_;
	gboolean _tmp56_;
	gboolean _tmp57_;
	ValaProperty* _tmp72_;
	ValaMemberBinding _tmp73_;
	ValaMemberBinding _tmp74_;
	gboolean _tmp100_ = FALSE;
	gboolean _tmp101_ = FALSE;
	ValaPropertyAccessor* _tmp102_;
	gboolean _tmp103_;
	gboolean _tmp104_;
	ValaPropertyAccessor* _tmp111_;
	ValaDataType* _tmp112_;
	ValaDataType* _tmp113_;
	ValaProperty* _tmp176_;
	ValaVersionAttribute* _tmp177_;
	ValaVersionAttribute* _tmp178_;
	gboolean _tmp179_;
	gboolean _tmp180_;
	gboolean _tmp185_ = FALSE;
	ValaProperty* _tmp186_;
	gboolean _tmp187_;
	gboolean _tmp188_;
	ValaCCodeFile* _tmp221_;
	ValaCCodeFunction* _tmp222_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (acc != NULL);
	g_return_if_fail (decl_space != NULL);
	_tmp0_ = decl_space;
	_tmp1_ = acc;
	_tmp2_ = acc;
	_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_ccode_base_module_add_symbol_declaration (self, _tmp0_, (ValaSymbol*) _tmp1_, _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	if (_tmp6_) {
		return;
	}
	_tmp7_ = acc;
	_tmp8_ = vala_property_accessor_get_prop (_tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_PROPERTY, ValaProperty));
	prop = _tmp10_;
	_tmp12_ = acc;
	_tmp13_ = vala_property_accessor_get_readable (_tmp12_);
	_tmp14_ = _tmp13_;
	if (_tmp14_) {
		ValaProperty* _tmp15_;
		ValaDataType* _tmp16_;
		ValaDataType* _tmp17_;
		gboolean _tmp18_;
		_tmp15_ = prop;
		_tmp16_ = vala_property_get_property_type (_tmp15_);
		_tmp17_ = _tmp16_;
		_tmp18_ = vala_data_type_is_real_non_null_struct_type (_tmp17_);
		_tmp11_ = _tmp18_;
	} else {
		_tmp11_ = FALSE;
	}
	returns_real_struct = _tmp11_;
	_tmp19_ = returns_real_struct;
	if (_tmp19_) {
		ValaPropertyAccessor* _tmp20_;
		ValaDataType* _tmp21_;
		ValaDataType* _tmp22_;
		gchar* _tmp23_;
		gchar* _tmp24_;
		gchar* _tmp25_;
		gchar* _tmp26_;
		ValaCCodeParameter* _tmp27_;
		_tmp20_ = acc;
		_tmp21_ = vala_property_accessor_get_value_type (_tmp20_);
		_tmp22_ = _tmp21_;
		_tmp23_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp22_);
		_tmp24_ = _tmp23_;
		_tmp25_ = g_strdup_printf ("%s *", _tmp24_);
		_tmp26_ = _tmp25_;
		_tmp27_ = vala_ccode_parameter_new ("result", _tmp26_);
		_vala_ccode_node_unref0 (cvalueparam);
		cvalueparam = _tmp27_;
		_g_free0 (_tmp26_);
		_g_free0 (_tmp24_);
	} else {
		gboolean _tmp28_ = FALSE;
		ValaPropertyAccessor* _tmp29_;
		gboolean _tmp30_;
		gboolean _tmp31_;
		_tmp29_ = acc;
		_tmp30_ = vala_property_accessor_get_readable (_tmp29_);
		_tmp31_ = _tmp30_;
		if (!_tmp31_) {
			ValaProperty* _tmp32_;
			ValaDataType* _tmp33_;
			ValaDataType* _tmp34_;
			gboolean _tmp35_;
			_tmp32_ = prop;
			_tmp33_ = vala_property_get_property_type (_tmp32_);
			_tmp34_ = _tmp33_;
			_tmp35_ = vala_data_type_is_real_non_null_struct_type (_tmp34_);
			_tmp28_ = _tmp35_;
		} else {
			_tmp28_ = FALSE;
		}
		if (_tmp28_) {
			ValaPropertyAccessor* _tmp36_;
			ValaDataType* _tmp37_;
			ValaDataType* _tmp38_;
			gchar* _tmp39_;
			gchar* _tmp40_;
			gchar* _tmp41_;
			gchar* _tmp42_;
			ValaCCodeParameter* _tmp43_;
			_tmp36_ = acc;
			_tmp37_ = vala_property_accessor_get_value_type (_tmp36_);
			_tmp38_ = _tmp37_;
			_tmp39_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp38_);
			_tmp40_ = _tmp39_;
			_tmp41_ = g_strdup_printf ("%s *", _tmp40_);
			_tmp42_ = _tmp41_;
			_tmp43_ = vala_ccode_parameter_new ("value", _tmp42_);
			_vala_ccode_node_unref0 (cvalueparam);
			cvalueparam = _tmp43_;
			_g_free0 (_tmp42_);
			_g_free0 (_tmp40_);
		} else {
			ValaPropertyAccessor* _tmp44_;
			ValaDataType* _tmp45_;
			ValaDataType* _tmp46_;
			gchar* _tmp47_;
			gchar* _tmp48_;
			ValaCCodeParameter* _tmp49_;
			_tmp44_ = acc;
			_tmp45_ = vala_property_accessor_get_value_type (_tmp44_);
			_tmp46_ = _tmp45_;
			_tmp47_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp46_);
			_tmp48_ = _tmp47_;
			_tmp49_ = vala_ccode_parameter_new ("value", _tmp48_);
			_vala_ccode_node_unref0 (cvalueparam);
			cvalueparam = _tmp49_;
			_g_free0 (_tmp48_);
		}
	}
	_tmp50_ = acc;
	_tmp51_ = vala_property_accessor_get_value_type (_tmp50_);
	_tmp52_ = _tmp51_;
	_tmp53_ = decl_space;
	vala_ccode_base_module_generate_type_declaration (self, _tmp52_, _tmp53_);
	_tmp55_ = acc;
	_tmp56_ = vala_property_accessor_get_readable (_tmp55_);
	_tmp57_ = _tmp56_;
	if (_tmp57_) {
		gboolean _tmp58_;
		_tmp58_ = returns_real_struct;
		_tmp54_ = !_tmp58_;
	} else {
		_tmp54_ = FALSE;
	}
	if (_tmp54_) {
		ValaPropertyAccessor* _tmp59_;
		gchar* _tmp60_;
		gchar* _tmp61_;
		ValaPropertyAccessor* _tmp62_;
		ValaDataType* _tmp63_;
		ValaDataType* _tmp64_;
		gchar* _tmp65_;
		gchar* _tmp66_;
		ValaCCodeFunction* _tmp67_;
		_tmp59_ = acc;
		_tmp60_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp59_);
		_tmp61_ = _tmp60_;
		_tmp62_ = acc;
		_tmp63_ = vala_property_accessor_get_value_type (_tmp62_);
		_tmp64_ = _tmp63_;
		_tmp65_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp64_);
		_tmp66_ = _tmp65_;
		_tmp67_ = vala_ccode_function_new (_tmp61_, _tmp66_);
		_vala_ccode_node_unref0 (function);
		function = _tmp67_;
		_g_free0 (_tmp66_);
		_g_free0 (_tmp61_);
	} else {
		ValaPropertyAccessor* _tmp68_;
		gchar* _tmp69_;
		gchar* _tmp70_;
		ValaCCodeFunction* _tmp71_;
		_tmp68_ = acc;
		_tmp69_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp68_);
		_tmp70_ = _tmp69_;
		_tmp71_ = vala_ccode_function_new (_tmp70_, "void");
		_vala_ccode_node_unref0 (function);
		function = _tmp71_;
		_g_free0 (_tmp70_);
	}
	_tmp72_ = prop;
	_tmp73_ = vala_property_get_binding (_tmp72_);
	_tmp74_ = _tmp73_;
	if (_tmp74_ == VALA_MEMBER_BINDING_INSTANCE) {
		ValaTypeSymbol* t = NULL;
		ValaProperty* _tmp75_;
		ValaSymbol* _tmp76_;
		ValaSymbol* _tmp77_;
		ValaTypeSymbol* _tmp78_;
		ValaDataType* this_type = NULL;
		ValaTypeSymbol* _tmp79_;
		ValaDataType* _tmp80_;
		ValaDataType* _tmp81_;
		ValaCCodeFile* _tmp82_;
		ValaCCodeParameter* cselfparam = NULL;
		ValaDataType* _tmp83_;
		gchar* _tmp84_;
		gchar* _tmp85_;
		ValaCCodeParameter* _tmp86_;
		ValaCCodeParameter* _tmp87_;
		gboolean _tmp88_ = FALSE;
		ValaTypeSymbol* _tmp89_;
		ValaCCodeFunction* _tmp98_;
		ValaCCodeParameter* _tmp99_;
		_tmp75_ = prop;
		_tmp76_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp75_);
		_tmp77_ = _tmp76_;
		_tmp78_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp77_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
		t = _tmp78_;
		_tmp79_ = t;
		_tmp80_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp79_);
		this_type = _tmp80_;
		_tmp81_ = this_type;
		_tmp82_ = decl_space;
		vala_ccode_base_module_generate_type_declaration (self, _tmp81_, _tmp82_);
		_tmp83_ = this_type;
		_tmp84_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp83_);
		_tmp85_ = _tmp84_;
		_tmp86_ = vala_ccode_parameter_new ("self", _tmp85_);
		_tmp87_ = _tmp86_;
		_g_free0 (_tmp85_);
		cselfparam = _tmp87_;
		_tmp89_ = t;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp89_, VALA_TYPE_STRUCT)) {
			ValaTypeSymbol* _tmp90_;
			gboolean _tmp91_;
			_tmp90_ = t;
			_tmp91_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp90_, VALA_TYPE_STRUCT, ValaStruct));
			_tmp88_ = !_tmp91_;
		} else {
			_tmp88_ = FALSE;
		}
		if (_tmp88_) {
			ValaCCodeParameter* _tmp92_;
			ValaCCodeParameter* _tmp93_;
			const gchar* _tmp94_;
			const gchar* _tmp95_;
			gchar* _tmp96_;
			gchar* _tmp97_;
			_tmp92_ = cselfparam;
			_tmp93_ = cselfparam;
			_tmp94_ = vala_ccode_parameter_get_type_name (_tmp93_);
			_tmp95_ = _tmp94_;
			_tmp96_ = g_strconcat (_tmp95_, "*", NULL);
			_tmp97_ = _tmp96_;
			vala_ccode_parameter_set_type_name (_tmp93_, _tmp97_);
			_g_free0 (_tmp97_);
		}
		_tmp98_ = function;
		_tmp99_ = cselfparam;
		vala_ccode_function_add_parameter (_tmp98_, _tmp99_);
		_vala_ccode_node_unref0 (cselfparam);
		_vala_code_node_unref0 (this_type);
		_vala_code_node_unref0 (t);
	}
	_tmp102_ = acc;
	_tmp103_ = vala_property_accessor_get_writable (_tmp102_);
	_tmp104_ = _tmp103_;
	if (_tmp104_) {
		_tmp101_ = TRUE;
	} else {
		ValaPropertyAccessor* _tmp105_;
		gboolean _tmp106_;
		gboolean _tmp107_;
		_tmp105_ = acc;
		_tmp106_ = vala_property_accessor_get_construction (_tmp105_);
		_tmp107_ = _tmp106_;
		_tmp101_ = _tmp107_;
	}
	if (_tmp101_) {
		_tmp100_ = TRUE;
	} else {
		gboolean _tmp108_;
		_tmp108_ = returns_real_struct;
		_tmp100_ = _tmp108_;
	}
	if (_tmp100_) {
		ValaCCodeFunction* _tmp109_;
		ValaCCodeParameter* _tmp110_;
		_tmp109_ = function;
		_tmp110_ = cvalueparam;
		vala_ccode_function_add_parameter (_tmp109_, _tmp110_);
	}
	_tmp111_ = acc;
	_tmp112_ = vala_property_accessor_get_value_type (_tmp111_);
	_tmp113_ = _tmp112_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp113_, VALA_TYPE_ARRAY_TYPE)) {
		ValaArrayType* array_type = NULL;
		ValaPropertyAccessor* _tmp114_;
		ValaDataType* _tmp115_;
		ValaDataType* _tmp116_;
		ValaArrayType* _tmp117_;
		_tmp114_ = acc;
		_tmp115_ = vala_property_accessor_get_value_type (_tmp114_);
		_tmp116_ = _tmp115_;
		_tmp117_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp116_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		array_type = _tmp117_;
		{
			gint dim = 0;
			dim = 1;
			{
				gboolean _tmp118_ = FALSE;
				_tmp118_ = TRUE;
				while (TRUE) {
					gint _tmp120_;
					ValaArrayType* _tmp121_;
					gint _tmp122_;
					gint _tmp123_;
					const gchar* _tmp124_ = NULL;
					ValaPropertyAccessor* _tmp125_;
					gboolean _tmp126_;
					gboolean _tmp127_;
					const gchar* _tmp128_ = NULL;
					ValaPropertyAccessor* _tmp129_;
					gboolean _tmp130_;
					gboolean _tmp131_;
					ValaCCodeFunction* _tmp132_;
					gint _tmp133_;
					gchar* _tmp134_;
					gchar* _tmp135_;
					ValaCCodeParameter* _tmp136_;
					ValaCCodeParameter* _tmp137_;
					if (!_tmp118_) {
						gint _tmp119_;
						_tmp119_ = dim;
						dim = _tmp119_ + 1;
					}
					_tmp118_ = FALSE;
					_tmp120_ = dim;
					_tmp121_ = array_type;
					_tmp122_ = vala_array_type_get_rank (_tmp121_);
					_tmp123_ = _tmp122_;
					if (!(_tmp120_ <= _tmp123_)) {
						break;
					}
					_tmp125_ = acc;
					_tmp126_ = vala_property_accessor_get_readable (_tmp125_);
					_tmp127_ = _tmp126_;
					if (_tmp127_) {
						_tmp124_ = "result";
					} else {
						_tmp124_ = "value";
					}
					_tmp129_ = acc;
					_tmp130_ = vala_property_accessor_get_readable (_tmp129_);
					_tmp131_ = _tmp130_;
					if (_tmp131_) {
						_tmp128_ = "int*";
					} else {
						_tmp128_ = "int";
					}
					_tmp132_ = function;
					_tmp133_ = dim;
					_tmp134_ = vala_ccode_base_module_get_array_length_cname (self, _tmp124_, _tmp133_);
					_tmp135_ = _tmp134_;
					_tmp136_ = vala_ccode_parameter_new (_tmp135_, _tmp128_);
					_tmp137_ = _tmp136_;
					vala_ccode_function_add_parameter (_tmp132_, _tmp137_);
					_vala_ccode_node_unref0 (_tmp137_);
					_g_free0 (_tmp135_);
				}
			}
		}
		_vala_code_node_unref0 (array_type);
	} else {
		gboolean _tmp138_ = FALSE;
		ValaPropertyAccessor* _tmp139_;
		ValaDataType* _tmp140_;
		ValaDataType* _tmp141_;
		_tmp139_ = acc;
		_tmp140_ = vala_property_accessor_get_value_type (_tmp139_);
		_tmp141_ = _tmp140_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp141_, VALA_TYPE_DELEGATE_TYPE)) {
			ValaPropertyAccessor* _tmp142_;
			ValaDataType* _tmp143_;
			ValaDataType* _tmp144_;
			ValaDelegate* _tmp145_;
			ValaDelegate* _tmp146_;
			gboolean _tmp147_;
			gboolean _tmp148_;
			_tmp142_ = acc;
			_tmp143_ = vala_property_accessor_get_value_type (_tmp142_);
			_tmp144_ = _tmp143_;
			_tmp145_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp144_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
			_tmp146_ = _tmp145_;
			_tmp147_ = vala_delegate_get_has_target (_tmp146_);
			_tmp148_ = _tmp147_;
			_tmp138_ = _tmp148_;
		} else {
			_tmp138_ = FALSE;
		}
		if (_tmp138_) {
			const gchar* _tmp149_ = NULL;
			ValaPropertyAccessor* _tmp150_;
			gboolean _tmp151_;
			gboolean _tmp152_;
			const gchar* _tmp153_ = NULL;
			ValaPropertyAccessor* _tmp154_;
			gboolean _tmp155_;
			gboolean _tmp156_;
			ValaCCodeFunction* _tmp157_;
			gchar* _tmp158_;
			gchar* _tmp159_;
			ValaCCodeParameter* _tmp160_;
			ValaCCodeParameter* _tmp161_;
			gboolean _tmp162_ = FALSE;
			ValaPropertyAccessor* _tmp163_;
			gboolean _tmp164_;
			gboolean _tmp165_;
			_tmp150_ = acc;
			_tmp151_ = vala_property_accessor_get_readable (_tmp150_);
			_tmp152_ = _tmp151_;
			if (_tmp152_) {
				_tmp149_ = "result";
			} else {
				_tmp149_ = "value";
			}
			_tmp154_ = acc;
			_tmp155_ = vala_property_accessor_get_readable (_tmp154_);
			_tmp156_ = _tmp155_;
			if (_tmp156_) {
				_tmp153_ = "gpointer*";
			} else {
				_tmp153_ = "gpointer";
			}
			_tmp157_ = function;
			_tmp158_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp149_);
			_tmp159_ = _tmp158_;
			_tmp160_ = vala_ccode_parameter_new (_tmp159_, _tmp153_);
			_tmp161_ = _tmp160_;
			vala_ccode_function_add_parameter (_tmp157_, _tmp161_);
			_vala_ccode_node_unref0 (_tmp161_);
			_g_free0 (_tmp159_);
			_tmp163_ = acc;
			_tmp164_ = vala_property_accessor_get_readable (_tmp163_);
			_tmp165_ = _tmp164_;
			if (!_tmp165_) {
				ValaPropertyAccessor* _tmp166_;
				ValaDataType* _tmp167_;
				ValaDataType* _tmp168_;
				gboolean _tmp169_;
				gboolean _tmp170_;
				_tmp166_ = acc;
				_tmp167_ = vala_property_accessor_get_value_type (_tmp166_);
				_tmp168_ = _tmp167_;
				_tmp169_ = vala_data_type_get_value_owned (_tmp168_);
				_tmp170_ = _tmp169_;
				_tmp162_ = _tmp170_;
			} else {
				_tmp162_ = FALSE;
			}
			if (_tmp162_) {
				ValaCCodeFunction* _tmp171_;
				gchar* _tmp172_;
				gchar* _tmp173_;
				ValaCCodeParameter* _tmp174_;
				ValaCCodeParameter* _tmp175_;
				_tmp171_ = function;
				_tmp172_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, "value");
				_tmp173_ = _tmp172_;
				_tmp174_ = vala_ccode_parameter_new (_tmp173_, "GDestroyNotify");
				_tmp175_ = _tmp174_;
				vala_ccode_function_add_parameter (_tmp171_, _tmp175_);
				_vala_ccode_node_unref0 (_tmp175_);
				_g_free0 (_tmp173_);
			}
		}
	}
	_tmp176_ = prop;
	_tmp177_ = vala_symbol_get_version ((ValaSymbol*) _tmp176_);
	_tmp178_ = _tmp177_;
	_tmp179_ = vala_version_attribute_get_deprecated (_tmp178_);
	_tmp180_ = _tmp179_;
	if (_tmp180_) {
		ValaCCodeFunction* _tmp181_;
		ValaCCodeFunction* _tmp182_;
		ValaCCodeModifiers _tmp183_;
		ValaCCodeModifiers _tmp184_;
		_tmp181_ = function;
		_tmp182_ = function;
		_tmp183_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp182_);
		_tmp184_ = _tmp183_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp182_, _tmp184_ | VALA_CCODE_MODIFIERS_DEPRECATED);
	}
	_tmp186_ = prop;
	_tmp187_ = vala_property_get_is_abstract (_tmp186_);
	_tmp188_ = _tmp187_;
	if (!_tmp188_) {
		gboolean _tmp189_ = FALSE;
		gboolean _tmp190_ = FALSE;
		ValaProperty* _tmp191_;
		gboolean _tmp192_;
		_tmp191_ = prop;
		_tmp192_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp191_);
		if (_tmp192_) {
			_tmp190_ = TRUE;
		} else {
			gboolean _tmp193_ = FALSE;
			ValaPropertyAccessor* _tmp194_;
			gboolean _tmp195_;
			gboolean _tmp196_;
			_tmp194_ = acc;
			_tmp195_ = vala_property_accessor_get_readable (_tmp194_);
			_tmp196_ = _tmp195_;
			if (!_tmp196_) {
				ValaPropertyAccessor* _tmp197_;
				gboolean _tmp198_;
				gboolean _tmp199_;
				_tmp197_ = acc;
				_tmp198_ = vala_property_accessor_get_writable (_tmp197_);
				_tmp199_ = _tmp198_;
				_tmp193_ = !_tmp199_;
			} else {
				_tmp193_ = FALSE;
			}
			_tmp190_ = _tmp193_;
		}
		if (_tmp190_) {
			_tmp189_ = TRUE;
		} else {
			ValaPropertyAccessor* _tmp200_;
			ValaSymbolAccessibility _tmp201_;
			ValaSymbolAccessibility _tmp202_;
			_tmp200_ = acc;
			_tmp201_ = vala_symbol_get_access ((ValaSymbol*) _tmp200_);
			_tmp202_ = _tmp201_;
			_tmp189_ = _tmp202_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
		}
		_tmp185_ = _tmp189_;
	} else {
		_tmp185_ = FALSE;
	}
	if (_tmp185_) {
		ValaCCodeFunction* _tmp203_;
		ValaCCodeFunction* _tmp204_;
		ValaCCodeModifiers _tmp205_;
		ValaCCodeModifiers _tmp206_;
		_tmp203_ = function;
		_tmp204_ = function;
		_tmp205_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp204_);
		_tmp206_ = _tmp205_;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp204_, _tmp206_ | VALA_CCODE_MODIFIERS_STATIC);
	} else {
		gboolean _tmp207_ = FALSE;
		ValaCodeContext* _tmp208_;
		gboolean _tmp209_;
		gboolean _tmp210_;
		_tmp208_ = self->priv->_context;
		_tmp209_ = vala_code_context_get_hide_internal (_tmp208_);
		_tmp210_ = _tmp209_;
		if (_tmp210_) {
			gboolean _tmp211_ = FALSE;
			ValaProperty* _tmp212_;
			gboolean _tmp213_;
			_tmp212_ = prop;
			_tmp213_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp212_);
			if (_tmp213_) {
				_tmp211_ = TRUE;
			} else {
				ValaPropertyAccessor* _tmp214_;
				ValaSymbolAccessibility _tmp215_;
				ValaSymbolAccessibility _tmp216_;
				_tmp214_ = acc;
				_tmp215_ = vala_symbol_get_access ((ValaSymbol*) _tmp214_);
				_tmp216_ = _tmp215_;
				_tmp211_ = _tmp216_ == VALA_SYMBOL_ACCESSIBILITY_INTERNAL;
			}
			_tmp207_ = _tmp211_;
		} else {
			_tmp207_ = FALSE;
		}
		if (_tmp207_) {
			ValaCCodeFunction* _tmp217_;
			ValaCCodeFunction* _tmp218_;
			ValaCCodeModifiers _tmp219_;
			ValaCCodeModifiers _tmp220_;
			_tmp217_ = function;
			_tmp218_ = function;
			_tmp219_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp218_);
			_tmp220_ = _tmp219_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp218_, _tmp220_ | VALA_CCODE_MODIFIERS_INTERNAL);
		}
	}
	_tmp221_ = decl_space;
	_tmp222_ = function;
	vala_ccode_file_add_function_declaration (_tmp221_, _tmp222_);
	_vala_ccode_node_unref0 (function);
	_vala_ccode_node_unref0 (cvalueparam);
	_vala_code_node_unref0 (prop);
}


static void vala_ccode_base_module_real_visit_property_accessor (ValaCodeVisitor* base, ValaPropertyAccessor* acc) {
	ValaCCodeBaseModule * self;
	ValaPropertyAccessor* _tmp0_;
	ValaCCodeBaseModuleEmitContext* _tmp1_;
	ValaCCodeBaseModuleEmitContext* _tmp2_;
	ValaPropertyAccessor* _tmp3_;
	ValaSourceReference* _tmp4_;
	ValaSourceReference* _tmp5_;
	ValaProperty* prop = NULL;
	ValaPropertyAccessor* _tmp6_;
	ValaProperty* _tmp7_;
	ValaProperty* _tmp8_;
	ValaProperty* _tmp9_;
	ValaPropertyAccessor* _tmp10_;
	ValaComment* _tmp11_;
	ValaComment* _tmp12_;
	gboolean _tmp21_ = FALSE;
	ValaPropertyAccessor* _tmp22_;
	gboolean _tmp23_;
	gboolean _tmp24_;
	gboolean returns_real_struct = FALSE;
	ValaPropertyAccessor* _tmp29_;
	ValaLocalVariable* _tmp30_;
	ValaLocalVariable* _tmp31_;
	ValaTypeSymbol* t = NULL;
	ValaProperty* _tmp35_;
	ValaSymbol* _tmp36_;
	ValaSymbol* _tmp37_;
	ValaTypeSymbol* _tmp38_;
	gboolean _tmp39_ = FALSE;
	ValaPropertyAccessor* _tmp40_;
	gboolean _tmp41_;
	gboolean _tmp42_;
	gboolean _tmp60_ = FALSE;
	gboolean _tmp61_ = FALSE;
	ValaProperty* _tmp62_;
	gboolean _tmp63_;
	gboolean _tmp64_;
	ValaPropertyAccessor* _tmp104_;
	ValaSourceFileType _tmp105_;
	ValaSourceFileType _tmp106_;
	ValaDataType* this_type = NULL;
	ValaTypeSymbol* _tmp107_;
	ValaDataType* _tmp108_;
	ValaCCodeParameter* cselfparam = NULL;
	ValaDataType* _tmp109_;
	gchar* _tmp110_;
	gchar* _tmp111_;
	ValaCCodeParameter* _tmp112_;
	ValaCCodeParameter* _tmp113_;
	gboolean _tmp114_ = FALSE;
	ValaTypeSymbol* _tmp115_;
	ValaCCodeParameter* cvalueparam = NULL;
	gboolean _tmp124_;
	gboolean _tmp155_ = FALSE;
	ValaProperty* _tmp156_;
	gboolean _tmp157_;
	gboolean _tmp158_;
	gboolean _tmp469_ = FALSE;
	ValaProperty* _tmp470_;
	gboolean _tmp471_;
	gboolean _tmp472_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (acc != NULL);
	_tmp0_ = acc;
	_tmp1_ = vala_ccode_base_module_emit_context_new ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	vala_ccode_base_module_push_context (self, _tmp2_);
	_vala_ccode_base_module_emit_context_unref0 (_tmp2_);
	_tmp3_ = acc;
	_tmp4_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp3_);
	_tmp5_ = _tmp4_;
	vala_ccode_base_module_push_line (self, _tmp5_);
	_tmp6_ = acc;
	_tmp7_ = vala_property_accessor_get_prop (_tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_PROPERTY, ValaProperty));
	prop = _tmp9_;
	_tmp10_ = acc;
	_tmp11_ = vala_symbol_get_comment ((ValaSymbol*) _tmp10_);
	_tmp12_ = _tmp11_;
	if (_tmp12_ != NULL) {
		ValaCCodeFile* _tmp13_;
		ValaPropertyAccessor* _tmp14_;
		ValaComment* _tmp15_;
		ValaComment* _tmp16_;
		const gchar* _tmp17_;
		const gchar* _tmp18_;
		ValaCCodeComment* _tmp19_;
		ValaCCodeComment* _tmp20_;
		_tmp13_ = self->cfile;
		_tmp14_ = acc;
		_tmp15_ = vala_symbol_get_comment ((ValaSymbol*) _tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = vala_comment_get_content (_tmp16_);
		_tmp18_ = _tmp17_;
		_tmp19_ = vala_ccode_comment_new (_tmp18_);
		_tmp20_ = _tmp19_;
		vala_ccode_file_add_type_member_definition (_tmp13_, (ValaCCodeNode*) _tmp20_);
		_vala_ccode_node_unref0 (_tmp20_);
	}
	_tmp22_ = acc;
	_tmp23_ = vala_property_accessor_get_readable (_tmp22_);
	_tmp24_ = _tmp23_;
	if (_tmp24_) {
		ValaProperty* _tmp25_;
		ValaDataType* _tmp26_;
		ValaDataType* _tmp27_;
		gboolean _tmp28_;
		_tmp25_ = prop;
		_tmp26_ = vala_property_get_property_type (_tmp25_);
		_tmp27_ = _tmp26_;
		_tmp28_ = vala_data_type_is_real_non_null_struct_type (_tmp27_);
		_tmp21_ = _tmp28_;
	} else {
		_tmp21_ = FALSE;
	}
	returns_real_struct = _tmp21_;
	_tmp29_ = acc;
	_tmp30_ = vala_subroutine_get_result_var ((ValaSubroutine*) _tmp29_);
	_tmp31_ = _tmp30_;
	if (_tmp31_ != NULL) {
		ValaPropertyAccessor* _tmp32_;
		ValaLocalVariable* _tmp33_;
		ValaLocalVariable* _tmp34_;
		_tmp32_ = acc;
		_tmp33_ = vala_subroutine_get_result_var ((ValaSubroutine*) _tmp32_);
		_tmp34_ = _tmp33_;
		vala_code_node_accept ((ValaCodeNode*) _tmp34_, (ValaCodeVisitor*) self);
	}
	_tmp35_ = prop;
	_tmp36_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp35_);
	_tmp37_ = _tmp36_;
	_tmp38_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp37_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
	t = _tmp38_;
	_tmp40_ = acc;
	_tmp41_ = vala_property_accessor_get_construction (_tmp40_);
	_tmp42_ = _tmp41_;
	if (_tmp42_) {
		ValaTypeSymbol* _tmp43_;
		ValaTypeSymbol* _tmp44_;
		gboolean _tmp45_;
		_tmp43_ = t;
		_tmp44_ = self->gobject_type;
		_tmp45_ = vala_typesymbol_is_subtype_of (_tmp43_, _tmp44_);
		_tmp39_ = !_tmp45_;
	} else {
		_tmp39_ = FALSE;
	}
	if (_tmp39_) {
		ValaPropertyAccessor* _tmp46_;
		ValaSourceReference* _tmp47_;
		ValaSourceReference* _tmp48_;
		ValaPropertyAccessor* _tmp49_;
		_tmp46_ = acc;
		_tmp47_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp46_);
		_tmp48_ = _tmp47_;
		vala_report_error (_tmp48_, "construct properties require GLib.Object");
		_tmp49_ = acc;
		vala_code_node_set_error ((ValaCodeNode*) _tmp49_, TRUE);
		_vala_code_node_unref0 (t);
		_vala_code_node_unref0 (prop);
		return;
	} else {
		gboolean _tmp50_ = FALSE;
		ValaPropertyAccessor* _tmp51_;
		gboolean _tmp52_;
		gboolean _tmp53_;
		_tmp51_ = acc;
		_tmp52_ = vala_property_accessor_get_construction (_tmp51_);
		_tmp53_ = _tmp52_;
		if (_tmp53_) {
			ValaProperty* _tmp54_;
			gboolean _tmp55_;
			_tmp54_ = prop;
			_tmp55_ = vala_ccode_base_module_is_gobject_property (self, _tmp54_);
			_tmp50_ = !_tmp55_;
		} else {
			_tmp50_ = FALSE;
		}
		if (_tmp50_) {
			ValaPropertyAccessor* _tmp56_;
			ValaSourceReference* _tmp57_;
			ValaSourceReference* _tmp58_;
			ValaPropertyAccessor* _tmp59_;
			_tmp56_ = acc;
			_tmp57_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp56_);
			_tmp58_ = _tmp57_;
			vala_report_error (_tmp58_, "construct properties not supported for specified property type");
			_tmp59_ = acc;
			vala_code_node_set_error ((ValaCodeNode*) _tmp59_, TRUE);
			_vala_code_node_unref0 (t);
			_vala_code_node_unref0 (prop);
			return;
		}
	}
	_tmp62_ = prop;
	_tmp63_ = vala_property_get_is_abstract (_tmp62_);
	_tmp64_ = _tmp63_;
	if (_tmp64_) {
		_tmp61_ = TRUE;
	} else {
		ValaProperty* _tmp65_;
		gboolean _tmp66_;
		gboolean _tmp67_;
		_tmp65_ = prop;
		_tmp66_ = vala_property_get_is_virtual (_tmp65_);
		_tmp67_ = _tmp66_;
		_tmp61_ = _tmp67_;
	}
	if (_tmp61_) {
		_tmp60_ = TRUE;
	} else {
		gboolean _tmp68_ = FALSE;
		ValaProperty* _tmp69_;
		ValaProperty* _tmp70_;
		ValaProperty* _tmp71_;
		_tmp69_ = prop;
		_tmp70_ = vala_property_get_base_property (_tmp69_);
		_tmp71_ = _tmp70_;
		if (_tmp71_ == NULL) {
			ValaProperty* _tmp72_;
			ValaProperty* _tmp73_;
			ValaProperty* _tmp74_;
			_tmp72_ = prop;
			_tmp73_ = vala_property_get_base_interface_property (_tmp72_);
			_tmp74_ = _tmp73_;
			_tmp68_ = _tmp74_ == NULL;
		} else {
			_tmp68_ = FALSE;
		}
		_tmp60_ = _tmp68_;
	}
	if (_tmp60_) {
		ValaPropertyAccessor* _tmp75_;
		ValaCCodeFile* _tmp76_;
		gboolean _tmp77_ = FALSE;
		ValaPropertyAccessor* _tmp78_;
		gboolean _tmp79_;
		gboolean _tmp80_;
		_tmp75_ = acc;
		_tmp76_ = self->cfile;
		vala_ccode_base_module_generate_property_accessor_declaration (self, _tmp75_, _tmp76_);
		_tmp78_ = acc;
		_tmp79_ = vala_property_accessor_get_readable (_tmp78_);
		_tmp80_ = _tmp79_;
		if (_tmp80_) {
			_tmp77_ = TRUE;
		} else {
			ValaPropertyAccessor* _tmp81_;
			gboolean _tmp82_;
			gboolean _tmp83_;
			_tmp81_ = acc;
			_tmp82_ = vala_property_accessor_get_writable (_tmp81_);
			_tmp83_ = _tmp82_;
			_tmp77_ = _tmp83_;
		}
		if (_tmp77_) {
			gboolean _tmp84_ = FALSE;
			ValaProperty* _tmp85_;
			gboolean _tmp86_;
			gboolean _tmp96_ = FALSE;
			ValaProperty* _tmp97_;
			gboolean _tmp98_;
			_tmp85_ = prop;
			_tmp86_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp85_);
			if (!_tmp86_) {
				gboolean _tmp87_ = FALSE;
				ValaPropertyAccessor* _tmp88_;
				ValaSymbolAccessibility _tmp89_;
				ValaSymbolAccessibility _tmp90_;
				_tmp88_ = acc;
				_tmp89_ = vala_symbol_get_access ((ValaSymbol*) _tmp88_);
				_tmp90_ = _tmp89_;
				if (_tmp90_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {
					_tmp87_ = TRUE;
				} else {
					ValaPropertyAccessor* _tmp91_;
					ValaSymbolAccessibility _tmp92_;
					ValaSymbolAccessibility _tmp93_;
					_tmp91_ = acc;
					_tmp92_ = vala_symbol_get_access ((ValaSymbol*) _tmp91_);
					_tmp93_ = _tmp92_;
					_tmp87_ = _tmp93_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED;
				}
				_tmp84_ = _tmp87_;
			} else {
				_tmp84_ = FALSE;
			}
			if (_tmp84_) {
				ValaPropertyAccessor* _tmp94_;
				ValaCCodeFile* _tmp95_;
				_tmp94_ = acc;
				_tmp95_ = self->header_file;
				vala_ccode_base_module_generate_property_accessor_declaration (self, _tmp94_, _tmp95_);
			}
			_tmp97_ = prop;
			_tmp98_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp97_);
			if (!_tmp98_) {
				ValaPropertyAccessor* _tmp99_;
				ValaSymbolAccessibility _tmp100_;
				ValaSymbolAccessibility _tmp101_;
				_tmp99_ = acc;
				_tmp100_ = vala_symbol_get_access ((ValaSymbol*) _tmp99_);
				_tmp101_ = _tmp100_;
				_tmp96_ = _tmp101_ != VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
			} else {
				_tmp96_ = FALSE;
			}
			if (_tmp96_) {
				ValaPropertyAccessor* _tmp102_;
				ValaCCodeFile* _tmp103_;
				_tmp102_ = acc;
				_tmp103_ = self->internal_header_file;
				vala_ccode_base_module_generate_property_accessor_declaration (self, _tmp102_, _tmp103_);
			}
		}
	}
	_tmp104_ = acc;
	_tmp105_ = vala_symbol_get_source_type ((ValaSymbol*) _tmp104_);
	_tmp106_ = _tmp105_;
	if (_tmp106_ == VALA_SOURCE_FILE_TYPE_FAST) {
		vala_ccode_base_module_pop_line (self);
		_vala_code_node_unref0 (t);
		_vala_code_node_unref0 (prop);
		return;
	}
	_tmp107_ = t;
	_tmp108_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp107_);
	this_type = _tmp108_;
	_tmp109_ = this_type;
	_tmp110_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp109_);
	_tmp111_ = _tmp110_;
	_tmp112_ = vala_ccode_parameter_new ("self", _tmp111_);
	_tmp113_ = _tmp112_;
	_g_free0 (_tmp111_);
	cselfparam = _tmp113_;
	_tmp115_ = t;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp115_, VALA_TYPE_STRUCT)) {
		ValaTypeSymbol* _tmp116_;
		gboolean _tmp117_;
		_tmp116_ = t;
		_tmp117_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp116_, VALA_TYPE_STRUCT, ValaStruct));
		_tmp114_ = !_tmp117_;
	} else {
		_tmp114_ = FALSE;
	}
	if (_tmp114_) {
		ValaCCodeParameter* _tmp118_;
		ValaCCodeParameter* _tmp119_;
		const gchar* _tmp120_;
		const gchar* _tmp121_;
		gchar* _tmp122_;
		gchar* _tmp123_;
		_tmp118_ = cselfparam;
		_tmp119_ = cselfparam;
		_tmp120_ = vala_ccode_parameter_get_type_name (_tmp119_);
		_tmp121_ = _tmp120_;
		_tmp122_ = g_strconcat (_tmp121_, "*", NULL);
		_tmp123_ = _tmp122_;
		vala_ccode_parameter_set_type_name (_tmp119_, _tmp123_);
		_g_free0 (_tmp123_);
	}
	_tmp124_ = returns_real_struct;
	if (_tmp124_) {
		ValaPropertyAccessor* _tmp125_;
		ValaDataType* _tmp126_;
		ValaDataType* _tmp127_;
		gchar* _tmp128_;
		gchar* _tmp129_;
		gchar* _tmp130_;
		gchar* _tmp131_;
		ValaCCodeParameter* _tmp132_;
		_tmp125_ = acc;
		_tmp126_ = vala_property_accessor_get_value_type (_tmp125_);
		_tmp127_ = _tmp126_;
		_tmp128_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp127_);
		_tmp129_ = _tmp128_;
		_tmp130_ = g_strdup_printf ("%s *", _tmp129_);
		_tmp131_ = _tmp130_;
		_tmp132_ = vala_ccode_parameter_new ("result", _tmp131_);
		_vala_ccode_node_unref0 (cvalueparam);
		cvalueparam = _tmp132_;
		_g_free0 (_tmp131_);
		_g_free0 (_tmp129_);
	} else {
		gboolean _tmp133_ = FALSE;
		ValaPropertyAccessor* _tmp134_;
		gboolean _tmp135_;
		gboolean _tmp136_;
		_tmp134_ = acc;
		_tmp135_ = vala_property_accessor_get_readable (_tmp134_);
		_tmp136_ = _tmp135_;
		if (!_tmp136_) {
			ValaProperty* _tmp137_;
			ValaDataType* _tmp138_;
			ValaDataType* _tmp139_;
			gboolean _tmp140_;
			_tmp137_ = prop;
			_tmp138_ = vala_property_get_property_type (_tmp137_);
			_tmp139_ = _tmp138_;
			_tmp140_ = vala_data_type_is_real_non_null_struct_type (_tmp139_);
			_tmp133_ = _tmp140_;
		} else {
			_tmp133_ = FALSE;
		}
		if (_tmp133_) {
			ValaPropertyAccessor* _tmp141_;
			ValaDataType* _tmp142_;
			ValaDataType* _tmp143_;
			gchar* _tmp144_;
			gchar* _tmp145_;
			gchar* _tmp146_;
			gchar* _tmp147_;
			ValaCCodeParameter* _tmp148_;
			_tmp141_ = acc;
			_tmp142_ = vala_property_accessor_get_value_type (_tmp141_);
			_tmp143_ = _tmp142_;
			_tmp144_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp143_);
			_tmp145_ = _tmp144_;
			_tmp146_ = g_strdup_printf ("%s *", _tmp145_);
			_tmp147_ = _tmp146_;
			_tmp148_ = vala_ccode_parameter_new ("value", _tmp147_);
			_vala_ccode_node_unref0 (cvalueparam);
			cvalueparam = _tmp148_;
			_g_free0 (_tmp147_);
			_g_free0 (_tmp145_);
		} else {
			ValaPropertyAccessor* _tmp149_;
			ValaDataType* _tmp150_;
			ValaDataType* _tmp151_;
			gchar* _tmp152_;
			gchar* _tmp153_;
			ValaCCodeParameter* _tmp154_;
			_tmp149_ = acc;
			_tmp150_ = vala_property_accessor_get_value_type (_tmp149_);
			_tmp151_ = _tmp150_;
			_tmp152_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp151_);
			_tmp153_ = _tmp152_;
			_tmp154_ = vala_ccode_parameter_new ("value", _tmp153_);
			_vala_ccode_node_unref0 (cvalueparam);
			cvalueparam = _tmp154_;
			_g_free0 (_tmp153_);
		}
	}
	_tmp156_ = prop;
	_tmp157_ = vala_property_get_is_abstract (_tmp156_);
	_tmp158_ = _tmp157_;
	if (_tmp158_) {
		_tmp155_ = TRUE;
	} else {
		ValaProperty* _tmp159_;
		gboolean _tmp160_;
		gboolean _tmp161_;
		_tmp159_ = prop;
		_tmp160_ = vala_property_get_is_virtual (_tmp159_);
		_tmp161_ = _tmp160_;
		_tmp155_ = _tmp161_;
	}
	if (_tmp155_) {
		ValaCCodeFunction* function = NULL;
		gboolean _tmp162_ = FALSE;
		ValaPropertyAccessor* _tmp163_;
		gboolean _tmp164_;
		gboolean _tmp165_;
		ValaCCodeFunction* _tmp179_;
		ValaCCodeParameter* _tmp180_;
		gboolean _tmp181_ = FALSE;
		gboolean _tmp182_ = FALSE;
		ValaPropertyAccessor* _tmp183_;
		gboolean _tmp184_;
		gboolean _tmp185_;
		ValaPropertyAccessor* _tmp192_;
		ValaDataType* _tmp193_;
		ValaDataType* _tmp194_;
		gboolean _tmp257_ = FALSE;
		ValaProperty* _tmp258_;
		gboolean _tmp259_;
		gboolean _tmp260_;
		ValaCCodeFunction* _tmp293_;
		ValaProperty* _tmp294_;
		ValaMemberBinding _tmp295_;
		ValaMemberBinding _tmp296_;
		ValaCCodeFunctionCall* vcast = NULL;
		ValaProperty* _tmp306_;
		ValaSymbol* _tmp307_;
		ValaSymbol* _tmp308_;
		ValaCCodeFunctionCall* _tmp333_;
		ValaCCodeIdentifier* _tmp334_;
		ValaCCodeIdentifier* _tmp335_;
		ValaPropertyAccessor* _tmp336_;
		gboolean _tmp337_;
		gboolean _tmp338_;
		ValaCCodeFile* _tmp467_;
		ValaCCodeFunction* _tmp468_;
		_tmp163_ = acc;
		_tmp164_ = vala_property_accessor_get_readable (_tmp163_);
		_tmp165_ = _tmp164_;
		if (_tmp165_) {
			gboolean _tmp166_;
			_tmp166_ = returns_real_struct;
			_tmp162_ = !_tmp166_;
		} else {
			_tmp162_ = FALSE;
		}
		if (_tmp162_) {
			ValaPropertyAccessor* _tmp167_;
			gchar* _tmp168_;
			gchar* _tmp169_;
			ValaDataType* _tmp170_;
			ValaDataType* _tmp171_;
			gchar* _tmp172_;
			gchar* _tmp173_;
			ValaCCodeFunction* _tmp174_;
			_tmp167_ = acc;
			_tmp168_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp167_);
			_tmp169_ = _tmp168_;
			_tmp170_ = vala_ccode_base_module_get_current_return_type (self);
			_tmp171_ = _tmp170_;
			_tmp172_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp171_);
			_tmp173_ = _tmp172_;
			_tmp174_ = vala_ccode_function_new (_tmp169_, _tmp173_);
			_vala_ccode_node_unref0 (function);
			function = _tmp174_;
			_g_free0 (_tmp173_);
			_g_free0 (_tmp169_);
		} else {
			ValaPropertyAccessor* _tmp175_;
			gchar* _tmp176_;
			gchar* _tmp177_;
			ValaCCodeFunction* _tmp178_;
			_tmp175_ = acc;
			_tmp176_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp175_);
			_tmp177_ = _tmp176_;
			_tmp178_ = vala_ccode_function_new (_tmp177_, "void");
			_vala_ccode_node_unref0 (function);
			function = _tmp178_;
			_g_free0 (_tmp177_);
		}
		_tmp179_ = function;
		_tmp180_ = cselfparam;
		vala_ccode_function_add_parameter (_tmp179_, _tmp180_);
		_tmp183_ = acc;
		_tmp184_ = vala_property_accessor_get_writable (_tmp183_);
		_tmp185_ = _tmp184_;
		if (_tmp185_) {
			_tmp182_ = TRUE;
		} else {
			ValaPropertyAccessor* _tmp186_;
			gboolean _tmp187_;
			gboolean _tmp188_;
			_tmp186_ = acc;
			_tmp187_ = vala_property_accessor_get_construction (_tmp186_);
			_tmp188_ = _tmp187_;
			_tmp182_ = _tmp188_;
		}
		if (_tmp182_) {
			_tmp181_ = TRUE;
		} else {
			gboolean _tmp189_;
			_tmp189_ = returns_real_struct;
			_tmp181_ = _tmp189_;
		}
		if (_tmp181_) {
			ValaCCodeFunction* _tmp190_;
			ValaCCodeParameter* _tmp191_;
			_tmp190_ = function;
			_tmp191_ = cvalueparam;
			vala_ccode_function_add_parameter (_tmp190_, _tmp191_);
		}
		_tmp192_ = acc;
		_tmp193_ = vala_property_accessor_get_value_type (_tmp192_);
		_tmp194_ = _tmp193_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp194_, VALA_TYPE_ARRAY_TYPE)) {
			ValaArrayType* array_type = NULL;
			ValaPropertyAccessor* _tmp195_;
			ValaDataType* _tmp196_;
			ValaDataType* _tmp197_;
			ValaArrayType* _tmp198_;
			_tmp195_ = acc;
			_tmp196_ = vala_property_accessor_get_value_type (_tmp195_);
			_tmp197_ = _tmp196_;
			_tmp198_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp197_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			array_type = _tmp198_;
			{
				gint dim = 0;
				dim = 1;
				{
					gboolean _tmp199_ = FALSE;
					_tmp199_ = TRUE;
					while (TRUE) {
						gint _tmp201_;
						ValaArrayType* _tmp202_;
						gint _tmp203_;
						gint _tmp204_;
						const gchar* _tmp205_ = NULL;
						ValaPropertyAccessor* _tmp206_;
						gboolean _tmp207_;
						gboolean _tmp208_;
						const gchar* _tmp209_ = NULL;
						ValaPropertyAccessor* _tmp210_;
						gboolean _tmp211_;
						gboolean _tmp212_;
						ValaCCodeFunction* _tmp213_;
						gint _tmp214_;
						gchar* _tmp215_;
						gchar* _tmp216_;
						ValaCCodeParameter* _tmp217_;
						ValaCCodeParameter* _tmp218_;
						if (!_tmp199_) {
							gint _tmp200_;
							_tmp200_ = dim;
							dim = _tmp200_ + 1;
						}
						_tmp199_ = FALSE;
						_tmp201_ = dim;
						_tmp202_ = array_type;
						_tmp203_ = vala_array_type_get_rank (_tmp202_);
						_tmp204_ = _tmp203_;
						if (!(_tmp201_ <= _tmp204_)) {
							break;
						}
						_tmp206_ = acc;
						_tmp207_ = vala_property_accessor_get_readable (_tmp206_);
						_tmp208_ = _tmp207_;
						if (_tmp208_) {
							_tmp205_ = "result";
						} else {
							_tmp205_ = "value";
						}
						_tmp210_ = acc;
						_tmp211_ = vala_property_accessor_get_readable (_tmp210_);
						_tmp212_ = _tmp211_;
						if (_tmp212_) {
							_tmp209_ = "int*";
						} else {
							_tmp209_ = "int";
						}
						_tmp213_ = function;
						_tmp214_ = dim;
						_tmp215_ = vala_ccode_base_module_get_array_length_cname (self, _tmp205_, _tmp214_);
						_tmp216_ = _tmp215_;
						_tmp217_ = vala_ccode_parameter_new (_tmp216_, _tmp209_);
						_tmp218_ = _tmp217_;
						vala_ccode_function_add_parameter (_tmp213_, _tmp218_);
						_vala_ccode_node_unref0 (_tmp218_);
						_g_free0 (_tmp216_);
					}
				}
			}
			_vala_code_node_unref0 (array_type);
		} else {
			gboolean _tmp219_ = FALSE;
			ValaPropertyAccessor* _tmp220_;
			ValaDataType* _tmp221_;
			ValaDataType* _tmp222_;
			_tmp220_ = acc;
			_tmp221_ = vala_property_accessor_get_value_type (_tmp220_);
			_tmp222_ = _tmp221_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp222_, VALA_TYPE_DELEGATE_TYPE)) {
				ValaPropertyAccessor* _tmp223_;
				ValaDataType* _tmp224_;
				ValaDataType* _tmp225_;
				ValaDelegate* _tmp226_;
				ValaDelegate* _tmp227_;
				gboolean _tmp228_;
				gboolean _tmp229_;
				_tmp223_ = acc;
				_tmp224_ = vala_property_accessor_get_value_type (_tmp223_);
				_tmp225_ = _tmp224_;
				_tmp226_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp225_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
				_tmp227_ = _tmp226_;
				_tmp228_ = vala_delegate_get_has_target (_tmp227_);
				_tmp229_ = _tmp228_;
				_tmp219_ = _tmp229_;
			} else {
				_tmp219_ = FALSE;
			}
			if (_tmp219_) {
				const gchar* _tmp230_ = NULL;
				ValaPropertyAccessor* _tmp231_;
				gboolean _tmp232_;
				gboolean _tmp233_;
				const gchar* _tmp234_ = NULL;
				ValaPropertyAccessor* _tmp235_;
				gboolean _tmp236_;
				gboolean _tmp237_;
				ValaCCodeFunction* _tmp238_;
				gchar* _tmp239_;
				gchar* _tmp240_;
				ValaCCodeParameter* _tmp241_;
				ValaCCodeParameter* _tmp242_;
				gboolean _tmp243_ = FALSE;
				ValaPropertyAccessor* _tmp244_;
				gboolean _tmp245_;
				gboolean _tmp246_;
				_tmp231_ = acc;
				_tmp232_ = vala_property_accessor_get_readable (_tmp231_);
				_tmp233_ = _tmp232_;
				if (_tmp233_) {
					_tmp230_ = "result";
				} else {
					_tmp230_ = "value";
				}
				_tmp235_ = acc;
				_tmp236_ = vala_property_accessor_get_readable (_tmp235_);
				_tmp237_ = _tmp236_;
				if (_tmp237_) {
					_tmp234_ = "gpointer*";
				} else {
					_tmp234_ = "gpointer";
				}
				_tmp238_ = function;
				_tmp239_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp230_);
				_tmp240_ = _tmp239_;
				_tmp241_ = vala_ccode_parameter_new (_tmp240_, _tmp234_);
				_tmp242_ = _tmp241_;
				vala_ccode_function_add_parameter (_tmp238_, _tmp242_);
				_vala_ccode_node_unref0 (_tmp242_);
				_g_free0 (_tmp240_);
				_tmp244_ = acc;
				_tmp245_ = vala_property_accessor_get_readable (_tmp244_);
				_tmp246_ = _tmp245_;
				if (!_tmp246_) {
					ValaPropertyAccessor* _tmp247_;
					ValaDataType* _tmp248_;
					ValaDataType* _tmp249_;
					gboolean _tmp250_;
					gboolean _tmp251_;
					_tmp247_ = acc;
					_tmp248_ = vala_property_accessor_get_value_type (_tmp247_);
					_tmp249_ = _tmp248_;
					_tmp250_ = vala_data_type_get_value_owned (_tmp249_);
					_tmp251_ = _tmp250_;
					_tmp243_ = _tmp251_;
				} else {
					_tmp243_ = FALSE;
				}
				if (_tmp243_) {
					ValaCCodeFunction* _tmp252_;
					gchar* _tmp253_;
					gchar* _tmp254_;
					ValaCCodeParameter* _tmp255_;
					ValaCCodeParameter* _tmp256_;
					_tmp252_ = function;
					_tmp253_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, "value");
					_tmp254_ = _tmp253_;
					_tmp255_ = vala_ccode_parameter_new (_tmp254_, "GDestroyNotify");
					_tmp256_ = _tmp255_;
					vala_ccode_function_add_parameter (_tmp252_, _tmp256_);
					_vala_ccode_node_unref0 (_tmp256_);
					_g_free0 (_tmp254_);
				}
			}
		}
		_tmp258_ = prop;
		_tmp259_ = vala_property_get_is_abstract (_tmp258_);
		_tmp260_ = _tmp259_;
		if (!_tmp260_) {
			gboolean _tmp261_ = FALSE;
			gboolean _tmp262_ = FALSE;
			ValaProperty* _tmp263_;
			gboolean _tmp264_;
			_tmp263_ = prop;
			_tmp264_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp263_);
			if (_tmp264_) {
				_tmp262_ = TRUE;
			} else {
				gboolean _tmp265_ = FALSE;
				ValaPropertyAccessor* _tmp266_;
				gboolean _tmp267_;
				gboolean _tmp268_;
				_tmp266_ = acc;
				_tmp267_ = vala_property_accessor_get_readable (_tmp266_);
				_tmp268_ = _tmp267_;
				if (_tmp268_) {
					_tmp265_ = TRUE;
				} else {
					ValaPropertyAccessor* _tmp269_;
					gboolean _tmp270_;
					gboolean _tmp271_;
					_tmp269_ = acc;
					_tmp270_ = vala_property_accessor_get_writable (_tmp269_);
					_tmp271_ = _tmp270_;
					_tmp265_ = _tmp271_;
				}
				_tmp262_ = !_tmp265_;
			}
			if (_tmp262_) {
				_tmp261_ = TRUE;
			} else {
				ValaPropertyAccessor* _tmp272_;
				ValaSymbolAccessibility _tmp273_;
				ValaSymbolAccessibility _tmp274_;
				_tmp272_ = acc;
				_tmp273_ = vala_symbol_get_access ((ValaSymbol*) _tmp272_);
				_tmp274_ = _tmp273_;
				_tmp261_ = _tmp274_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
			}
			_tmp257_ = _tmp261_;
		} else {
			_tmp257_ = FALSE;
		}
		if (_tmp257_) {
			ValaCCodeFunction* _tmp275_;
			ValaCCodeFunction* _tmp276_;
			ValaCCodeModifiers _tmp277_;
			ValaCCodeModifiers _tmp278_;
			_tmp275_ = function;
			_tmp276_ = function;
			_tmp277_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp276_);
			_tmp278_ = _tmp277_;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp276_, _tmp278_ | VALA_CCODE_MODIFIERS_STATIC);
		} else {
			gboolean _tmp279_ = FALSE;
			ValaCodeContext* _tmp280_;
			gboolean _tmp281_;
			gboolean _tmp282_;
			_tmp280_ = self->priv->_context;
			_tmp281_ = vala_code_context_get_hide_internal (_tmp280_);
			_tmp282_ = _tmp281_;
			if (_tmp282_) {
				gboolean _tmp283_ = FALSE;
				ValaProperty* _tmp284_;
				gboolean _tmp285_;
				_tmp284_ = prop;
				_tmp285_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp284_);
				if (_tmp285_) {
					_tmp283_ = TRUE;
				} else {
					ValaPropertyAccessor* _tmp286_;
					ValaSymbolAccessibility _tmp287_;
					ValaSymbolAccessibility _tmp288_;
					_tmp286_ = acc;
					_tmp287_ = vala_symbol_get_access ((ValaSymbol*) _tmp286_);
					_tmp288_ = _tmp287_;
					_tmp283_ = _tmp288_ == VALA_SYMBOL_ACCESSIBILITY_INTERNAL;
				}
				_tmp279_ = _tmp283_;
			} else {
				_tmp279_ = FALSE;
			}
			if (_tmp279_) {
				ValaCCodeFunction* _tmp289_;
				ValaCCodeFunction* _tmp290_;
				ValaCCodeModifiers _tmp291_;
				ValaCCodeModifiers _tmp292_;
				_tmp289_ = function;
				_tmp290_ = function;
				_tmp291_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp290_);
				_tmp292_ = _tmp291_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp290_, _tmp292_ | VALA_CCODE_MODIFIERS_INTERNAL);
			}
		}
		_tmp293_ = function;
		vala_ccode_base_module_push_function (self, _tmp293_);
		_tmp294_ = prop;
		_tmp295_ = vala_property_get_binding (_tmp294_);
		_tmp296_ = _tmp295_;
		if (_tmp296_ == VALA_MEMBER_BINDING_INSTANCE) {
			gboolean _tmp297_ = FALSE;
			ValaPropertyAccessor* _tmp298_;
			gboolean _tmp299_;
			gboolean _tmp300_;
			_tmp298_ = acc;
			_tmp299_ = vala_property_accessor_get_readable (_tmp298_);
			_tmp300_ = _tmp299_;
			if (!_tmp300_) {
				_tmp297_ = TRUE;
			} else {
				gboolean _tmp301_;
				_tmp301_ = returns_real_struct;
				_tmp297_ = _tmp301_;
			}
			if (_tmp297_) {
				ValaProperty* _tmp302_;
				ValaTypeSymbol* _tmp303_;
				_tmp302_ = prop;
				_tmp303_ = t;
				vala_ccode_base_module_create_property_type_check_statement (self, _tmp302_, FALSE, _tmp303_, TRUE, "self");
			} else {
				ValaProperty* _tmp304_;
				ValaTypeSymbol* _tmp305_;
				_tmp304_ = prop;
				_tmp305_ = t;
				vala_ccode_base_module_create_property_type_check_statement (self, _tmp304_, TRUE, _tmp305_, TRUE, "self");
			}
		}
		vcast = NULL;
		_tmp306_ = prop;
		_tmp307_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp306_);
		_tmp308_ = _tmp307_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp308_, VALA_TYPE_INTERFACE)) {
			ValaInterface* iface = NULL;
			ValaProperty* _tmp309_;
			ValaSymbol* _tmp310_;
			ValaSymbol* _tmp311_;
			ValaInterface* _tmp312_;
			ValaInterface* _tmp313_;
			gchar* _tmp314_;
			gchar* _tmp315_;
			gchar* _tmp316_;
			gchar* _tmp317_;
			ValaCCodeIdentifier* _tmp318_;
			ValaCCodeIdentifier* _tmp319_;
			ValaCCodeFunctionCall* _tmp320_;
			_tmp309_ = prop;
			_tmp310_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp309_);
			_tmp311_ = _tmp310_;
			_tmp312_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp311_, VALA_TYPE_INTERFACE, ValaInterface));
			iface = _tmp312_;
			_tmp313_ = iface;
			_tmp314_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp313_, NULL);
			_tmp315_ = _tmp314_;
			_tmp316_ = g_strdup_printf ("%s_GET_INTERFACE", _tmp315_);
			_tmp317_ = _tmp316_;
			_tmp318_ = vala_ccode_identifier_new (_tmp317_);
			_tmp319_ = _tmp318_;
			_tmp320_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp319_);
			_vala_ccode_node_unref0 (vcast);
			vcast = _tmp320_;
			_vala_ccode_node_unref0 (_tmp319_);
			_g_free0 (_tmp317_);
			_g_free0 (_tmp315_);
			_vala_code_node_unref0 (iface);
		} else {
			ValaClass* cl = NULL;
			ValaProperty* _tmp321_;
			ValaSymbol* _tmp322_;
			ValaSymbol* _tmp323_;
			ValaClass* _tmp324_;
			ValaClass* _tmp325_;
			gchar* _tmp326_;
			gchar* _tmp327_;
			gchar* _tmp328_;
			gchar* _tmp329_;
			ValaCCodeIdentifier* _tmp330_;
			ValaCCodeIdentifier* _tmp331_;
			ValaCCodeFunctionCall* _tmp332_;
			_tmp321_ = prop;
			_tmp322_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp321_);
			_tmp323_ = _tmp322_;
			_tmp324_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp323_, VALA_TYPE_CLASS, ValaClass));
			cl = _tmp324_;
			_tmp325_ = cl;
			_tmp326_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp325_, NULL);
			_tmp327_ = _tmp326_;
			_tmp328_ = g_strdup_printf ("%s_GET_CLASS", _tmp327_);
			_tmp329_ = _tmp328_;
			_tmp330_ = vala_ccode_identifier_new (_tmp329_);
			_tmp331_ = _tmp330_;
			_tmp332_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp331_);
			_vala_ccode_node_unref0 (vcast);
			vcast = _tmp332_;
			_vala_ccode_node_unref0 (_tmp331_);
			_g_free0 (_tmp329_);
			_g_free0 (_tmp327_);
			_vala_code_node_unref0 (cl);
		}
		_tmp333_ = vcast;
		_tmp334_ = vala_ccode_identifier_new ("self");
		_tmp335_ = _tmp334_;
		vala_ccode_function_call_add_argument (_tmp333_, (ValaCCodeExpression*) _tmp335_);
		_vala_ccode_node_unref0 (_tmp335_);
		_tmp336_ = acc;
		_tmp337_ = vala_property_accessor_get_readable (_tmp336_);
		_tmp338_ = _tmp337_;
		if (_tmp338_) {
			ValaCCodeFunctionCall* vcall = NULL;
			ValaCCodeFunctionCall* _tmp339_;
			ValaProperty* _tmp340_;
			const gchar* _tmp341_;
			const gchar* _tmp342_;
			gchar* _tmp343_;
			gchar* _tmp344_;
			ValaCCodeMemberAccess* _tmp345_;
			ValaCCodeMemberAccess* _tmp346_;
			ValaCCodeFunctionCall* _tmp347_;
			ValaCCodeFunctionCall* _tmp348_;
			ValaCCodeFunctionCall* _tmp349_;
			ValaCCodeIdentifier* _tmp350_;
			ValaCCodeIdentifier* _tmp351_;
			gboolean _tmp352_;
			_tmp339_ = vcast;
			_tmp340_ = prop;
			_tmp341_ = vala_symbol_get_name ((ValaSymbol*) _tmp340_);
			_tmp342_ = _tmp341_;
			_tmp343_ = g_strdup_printf ("get_%s", _tmp342_);
			_tmp344_ = _tmp343_;
			_tmp345_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp339_, _tmp344_);
			_tmp346_ = _tmp345_;
			_tmp347_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp346_);
			_tmp348_ = _tmp347_;
			_vala_ccode_node_unref0 (_tmp346_);
			_g_free0 (_tmp344_);
			vcall = _tmp348_;
			_tmp349_ = vcall;
			_tmp350_ = vala_ccode_identifier_new ("self");
			_tmp351_ = _tmp350_;
			vala_ccode_function_call_add_argument (_tmp349_, (ValaCCodeExpression*) _tmp351_);
			_vala_ccode_node_unref0 (_tmp351_);
			_tmp352_ = returns_real_struct;
			if (_tmp352_) {
				ValaCCodeFunctionCall* _tmp353_;
				ValaCCodeIdentifier* _tmp354_;
				ValaCCodeIdentifier* _tmp355_;
				ValaCCodeFunction* _tmp356_;
				ValaCCodeFunction* _tmp357_;
				ValaCCodeFunctionCall* _tmp358_;
				_tmp353_ = vcall;
				_tmp354_ = vala_ccode_identifier_new ("result");
				_tmp355_ = _tmp354_;
				vala_ccode_function_call_add_argument (_tmp353_, (ValaCCodeExpression*) _tmp355_);
				_vala_ccode_node_unref0 (_tmp355_);
				_tmp356_ = vala_ccode_base_module_get_ccode (self);
				_tmp357_ = _tmp356_;
				_tmp358_ = vcall;
				vala_ccode_function_add_expression (_tmp357_, (ValaCCodeExpression*) _tmp358_);
			} else {
				ValaPropertyAccessor* _tmp359_;
				ValaDataType* _tmp360_;
				ValaDataType* _tmp361_;
				ValaCCodeFunction* _tmp395_;
				ValaCCodeFunction* _tmp396_;
				ValaCCodeFunctionCall* _tmp397_;
				_tmp359_ = acc;
				_tmp360_ = vala_property_accessor_get_value_type (_tmp359_);
				_tmp361_ = _tmp360_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp361_, VALA_TYPE_ARRAY_TYPE)) {
					ValaArrayType* array_type = NULL;
					ValaPropertyAccessor* _tmp362_;
					ValaDataType* _tmp363_;
					ValaDataType* _tmp364_;
					ValaArrayType* _tmp365_;
					_tmp362_ = acc;
					_tmp363_ = vala_property_accessor_get_value_type (_tmp362_);
					_tmp364_ = _tmp363_;
					_tmp365_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp364_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
					array_type = _tmp365_;
					{
						gint dim = 0;
						dim = 1;
						{
							gboolean _tmp366_ = FALSE;
							_tmp366_ = TRUE;
							while (TRUE) {
								gint _tmp368_;
								ValaArrayType* _tmp369_;
								gint _tmp370_;
								gint _tmp371_;
								ValaCCodeIdentifier* len_expr = NULL;
								gint _tmp372_;
								gchar* _tmp373_;
								gchar* _tmp374_;
								ValaCCodeIdentifier* _tmp375_;
								ValaCCodeIdentifier* _tmp376_;
								ValaCCodeFunctionCall* _tmp377_;
								ValaCCodeIdentifier* _tmp378_;
								if (!_tmp366_) {
									gint _tmp367_;
									_tmp367_ = dim;
									dim = _tmp367_ + 1;
								}
								_tmp366_ = FALSE;
								_tmp368_ = dim;
								_tmp369_ = array_type;
								_tmp370_ = vala_array_type_get_rank (_tmp369_);
								_tmp371_ = _tmp370_;
								if (!(_tmp368_ <= _tmp371_)) {
									break;
								}
								_tmp372_ = dim;
								_tmp373_ = vala_ccode_base_module_get_array_length_cname (self, "result", _tmp372_);
								_tmp374_ = _tmp373_;
								_tmp375_ = vala_ccode_identifier_new (_tmp374_);
								_tmp376_ = _tmp375_;
								_g_free0 (_tmp374_);
								len_expr = _tmp376_;
								_tmp377_ = vcall;
								_tmp378_ = len_expr;
								vala_ccode_function_call_add_argument (_tmp377_, (ValaCCodeExpression*) _tmp378_);
								_vala_ccode_node_unref0 (len_expr);
							}
						}
					}
					_vala_code_node_unref0 (array_type);
				} else {
					gboolean _tmp379_ = FALSE;
					ValaPropertyAccessor* _tmp380_;
					ValaDataType* _tmp381_;
					ValaDataType* _tmp382_;
					_tmp380_ = acc;
					_tmp381_ = vala_property_accessor_get_value_type (_tmp380_);
					_tmp382_ = _tmp381_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp382_, VALA_TYPE_DELEGATE_TYPE)) {
						ValaPropertyAccessor* _tmp383_;
						ValaDataType* _tmp384_;
						ValaDataType* _tmp385_;
						ValaDelegate* _tmp386_;
						ValaDelegate* _tmp387_;
						gboolean _tmp388_;
						gboolean _tmp389_;
						_tmp383_ = acc;
						_tmp384_ = vala_property_accessor_get_value_type (_tmp383_);
						_tmp385_ = _tmp384_;
						_tmp386_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp385_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
						_tmp387_ = _tmp386_;
						_tmp388_ = vala_delegate_get_has_target (_tmp387_);
						_tmp389_ = _tmp388_;
						_tmp379_ = _tmp389_;
					} else {
						_tmp379_ = FALSE;
					}
					if (_tmp379_) {
						ValaCCodeFunctionCall* _tmp390_;
						gchar* _tmp391_;
						gchar* _tmp392_;
						ValaCCodeIdentifier* _tmp393_;
						ValaCCodeIdentifier* _tmp394_;
						_tmp390_ = vcall;
						_tmp391_ = vala_ccode_base_module_get_delegate_target_cname (self, "result");
						_tmp392_ = _tmp391_;
						_tmp393_ = vala_ccode_identifier_new (_tmp392_);
						_tmp394_ = _tmp393_;
						vala_ccode_function_call_add_argument (_tmp390_, (ValaCCodeExpression*) _tmp394_);
						_vala_ccode_node_unref0 (_tmp394_);
						_g_free0 (_tmp392_);
					}
				}
				_tmp395_ = vala_ccode_base_module_get_ccode (self);
				_tmp396_ = _tmp395_;
				_tmp397_ = vcall;
				vala_ccode_function_add_return (_tmp396_, (ValaCCodeExpression*) _tmp397_);
			}
			_vala_ccode_node_unref0 (vcall);
		} else {
			ValaCCodeFunctionCall* vcall = NULL;
			ValaCCodeFunctionCall* _tmp398_;
			ValaProperty* _tmp399_;
			const gchar* _tmp400_;
			const gchar* _tmp401_;
			gchar* _tmp402_;
			gchar* _tmp403_;
			ValaCCodeMemberAccess* _tmp404_;
			ValaCCodeMemberAccess* _tmp405_;
			ValaCCodeFunctionCall* _tmp406_;
			ValaCCodeFunctionCall* _tmp407_;
			ValaCCodeFunctionCall* _tmp408_;
			ValaCCodeIdentifier* _tmp409_;
			ValaCCodeIdentifier* _tmp410_;
			ValaCCodeFunctionCall* _tmp411_;
			ValaCCodeIdentifier* _tmp412_;
			ValaCCodeIdentifier* _tmp413_;
			ValaPropertyAccessor* _tmp414_;
			ValaDataType* _tmp415_;
			ValaDataType* _tmp416_;
			ValaCCodeFunction* _tmp464_;
			ValaCCodeFunction* _tmp465_;
			ValaCCodeFunctionCall* _tmp466_;
			_tmp398_ = vcast;
			_tmp399_ = prop;
			_tmp400_ = vala_symbol_get_name ((ValaSymbol*) _tmp399_);
			_tmp401_ = _tmp400_;
			_tmp402_ = g_strdup_printf ("set_%s", _tmp401_);
			_tmp403_ = _tmp402_;
			_tmp404_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp398_, _tmp403_);
			_tmp405_ = _tmp404_;
			_tmp406_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp405_);
			_tmp407_ = _tmp406_;
			_vala_ccode_node_unref0 (_tmp405_);
			_g_free0 (_tmp403_);
			vcall = _tmp407_;
			_tmp408_ = vcall;
			_tmp409_ = vala_ccode_identifier_new ("self");
			_tmp410_ = _tmp409_;
			vala_ccode_function_call_add_argument (_tmp408_, (ValaCCodeExpression*) _tmp410_);
			_vala_ccode_node_unref0 (_tmp410_);
			_tmp411_ = vcall;
			_tmp412_ = vala_ccode_identifier_new ("value");
			_tmp413_ = _tmp412_;
			vala_ccode_function_call_add_argument (_tmp411_, (ValaCCodeExpression*) _tmp413_);
			_vala_ccode_node_unref0 (_tmp413_);
			_tmp414_ = acc;
			_tmp415_ = vala_property_accessor_get_value_type (_tmp414_);
			_tmp416_ = _tmp415_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp416_, VALA_TYPE_ARRAY_TYPE)) {
				ValaArrayType* array_type = NULL;
				ValaPropertyAccessor* _tmp417_;
				ValaDataType* _tmp418_;
				ValaDataType* _tmp419_;
				ValaArrayType* _tmp420_;
				_tmp417_ = acc;
				_tmp418_ = vala_property_accessor_get_value_type (_tmp417_);
				_tmp419_ = _tmp418_;
				_tmp420_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp419_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
				array_type = _tmp420_;
				{
					gint dim = 0;
					dim = 1;
					{
						gboolean _tmp421_ = FALSE;
						_tmp421_ = TRUE;
						while (TRUE) {
							gint _tmp423_;
							ValaArrayType* _tmp424_;
							gint _tmp425_;
							gint _tmp426_;
							ValaCCodeIdentifier* len_expr = NULL;
							gint _tmp427_;
							gchar* _tmp428_;
							gchar* _tmp429_;
							ValaCCodeIdentifier* _tmp430_;
							ValaCCodeIdentifier* _tmp431_;
							ValaCCodeFunctionCall* _tmp432_;
							ValaCCodeIdentifier* _tmp433_;
							if (!_tmp421_) {
								gint _tmp422_;
								_tmp422_ = dim;
								dim = _tmp422_ + 1;
							}
							_tmp421_ = FALSE;
							_tmp423_ = dim;
							_tmp424_ = array_type;
							_tmp425_ = vala_array_type_get_rank (_tmp424_);
							_tmp426_ = _tmp425_;
							if (!(_tmp423_ <= _tmp426_)) {
								break;
							}
							_tmp427_ = dim;
							_tmp428_ = vala_ccode_base_module_get_array_length_cname (self, "value", _tmp427_);
							_tmp429_ = _tmp428_;
							_tmp430_ = vala_ccode_identifier_new (_tmp429_);
							_tmp431_ = _tmp430_;
							_g_free0 (_tmp429_);
							len_expr = _tmp431_;
							_tmp432_ = vcall;
							_tmp433_ = len_expr;
							vala_ccode_function_call_add_argument (_tmp432_, (ValaCCodeExpression*) _tmp433_);
							_vala_ccode_node_unref0 (len_expr);
						}
					}
				}
				_vala_code_node_unref0 (array_type);
			} else {
				gboolean _tmp434_ = FALSE;
				ValaPropertyAccessor* _tmp435_;
				ValaDataType* _tmp436_;
				ValaDataType* _tmp437_;
				_tmp435_ = acc;
				_tmp436_ = vala_property_accessor_get_value_type (_tmp435_);
				_tmp437_ = _tmp436_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp437_, VALA_TYPE_DELEGATE_TYPE)) {
					ValaPropertyAccessor* _tmp438_;
					ValaDataType* _tmp439_;
					ValaDataType* _tmp440_;
					ValaDelegate* _tmp441_;
					ValaDelegate* _tmp442_;
					gboolean _tmp443_;
					gboolean _tmp444_;
					_tmp438_ = acc;
					_tmp439_ = vala_property_accessor_get_value_type (_tmp438_);
					_tmp440_ = _tmp439_;
					_tmp441_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp440_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
					_tmp442_ = _tmp441_;
					_tmp443_ = vala_delegate_get_has_target (_tmp442_);
					_tmp444_ = _tmp443_;
					_tmp434_ = _tmp444_;
				} else {
					_tmp434_ = FALSE;
				}
				if (_tmp434_) {
					ValaCCodeFunctionCall* _tmp445_;
					gchar* _tmp446_;
					gchar* _tmp447_;
					ValaCCodeIdentifier* _tmp448_;
					ValaCCodeIdentifier* _tmp449_;
					gboolean _tmp450_ = FALSE;
					ValaPropertyAccessor* _tmp451_;
					gboolean _tmp452_;
					gboolean _tmp453_;
					_tmp445_ = vcall;
					_tmp446_ = vala_ccode_base_module_get_delegate_target_cname (self, "value");
					_tmp447_ = _tmp446_;
					_tmp448_ = vala_ccode_identifier_new (_tmp447_);
					_tmp449_ = _tmp448_;
					vala_ccode_function_call_add_argument (_tmp445_, (ValaCCodeExpression*) _tmp449_);
					_vala_ccode_node_unref0 (_tmp449_);
					_g_free0 (_tmp447_);
					_tmp451_ = acc;
					_tmp452_ = vala_property_accessor_get_readable (_tmp451_);
					_tmp453_ = _tmp452_;
					if (!_tmp453_) {
						ValaPropertyAccessor* _tmp454_;
						ValaDataType* _tmp455_;
						ValaDataType* _tmp456_;
						gboolean _tmp457_;
						gboolean _tmp458_;
						_tmp454_ = acc;
						_tmp455_ = vala_property_accessor_get_value_type (_tmp454_);
						_tmp456_ = _tmp455_;
						_tmp457_ = vala_data_type_get_value_owned (_tmp456_);
						_tmp458_ = _tmp457_;
						_tmp450_ = _tmp458_;
					} else {
						_tmp450_ = FALSE;
					}
					if (_tmp450_) {
						ValaCCodeFunctionCall* _tmp459_;
						gchar* _tmp460_;
						gchar* _tmp461_;
						ValaCCodeIdentifier* _tmp462_;
						ValaCCodeIdentifier* _tmp463_;
						_tmp459_ = vcall;
						_tmp460_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, "value");
						_tmp461_ = _tmp460_;
						_tmp462_ = vala_ccode_identifier_new (_tmp461_);
						_tmp463_ = _tmp462_;
						vala_ccode_function_call_add_argument (_tmp459_, (ValaCCodeExpression*) _tmp463_);
						_vala_ccode_node_unref0 (_tmp463_);
						_g_free0 (_tmp461_);
					}
				}
			}
			_tmp464_ = vala_ccode_base_module_get_ccode (self);
			_tmp465_ = _tmp464_;
			_tmp466_ = vcall;
			vala_ccode_function_add_expression (_tmp465_, (ValaCCodeExpression*) _tmp466_);
			_vala_ccode_node_unref0 (vcall);
		}
		vala_ccode_base_module_pop_function (self);
		_tmp467_ = self->cfile;
		_tmp468_ = function;
		vala_ccode_file_add_function (_tmp467_, _tmp468_);
		_vala_ccode_node_unref0 (vcast);
		_vala_ccode_node_unref0 (function);
	}
	_tmp470_ = prop;
	_tmp471_ = vala_property_get_is_abstract (_tmp470_);
	_tmp472_ = _tmp471_;
	if (!_tmp472_) {
		ValaPropertyAccessor* _tmp473_;
		ValaBlock* _tmp474_;
		ValaBlock* _tmp475_;
		_tmp473_ = acc;
		_tmp474_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp473_);
		_tmp475_ = _tmp474_;
		_tmp469_ = _tmp475_ != NULL;
	} else {
		_tmp469_ = FALSE;
	}
	if (_tmp469_) {
		gboolean _tmp476_ = FALSE;
		ValaProperty* _tmp477_;
		ValaProperty* _tmp478_;
		ValaProperty* _tmp479_;
		gboolean is_virtual = FALSE;
		gchar* cname = NULL;
		ValaPropertyAccessor* _tmp483_;
		gchar* _tmp484_;
		ValaCCodeFunction* function = NULL;
		gboolean _tmp485_ = FALSE;
		gboolean _tmp486_ = FALSE;
		ValaPropertyAccessor* _tmp487_;
		gboolean _tmp488_;
		gboolean _tmp489_;
		ValaObjectType* base_type = NULL;
		ValaProperty* _tmp503_;
		ValaMemberBinding _tmp504_;
		ValaMemberBinding _tmp505_;
		gboolean _tmp537_ = FALSE;
		gboolean _tmp538_ = FALSE;
		ValaPropertyAccessor* _tmp539_;
		gboolean _tmp540_;
		gboolean _tmp541_;
		ValaPropertyAccessor* _tmp548_;
		ValaDataType* _tmp549_;
		ValaDataType* _tmp550_;
		gboolean _tmp613_;
		ValaCCodeFunction* _tmp646_;
		gboolean _tmp647_ = FALSE;
		ValaProperty* _tmp648_;
		ValaMemberBinding _tmp649_;
		ValaMemberBinding _tmp650_;
		gboolean _tmp661_ = FALSE;
		ValaPropertyAccessor* _tmp662_;
		gboolean _tmp663_;
		gboolean _tmp664_;
		gboolean _tmp686_;
		gboolean _tmp709_ = FALSE;
		gboolean _tmp710_ = FALSE;
		ValaProperty* _tmp711_;
		gboolean _tmp712_;
		gboolean _tmp863_;
		gboolean _tmp864_;
		ValaCCodeFile* _tmp871_;
		ValaCCodeFunction* _tmp872_;
		_tmp477_ = prop;
		_tmp478_ = vala_property_get_base_property (_tmp477_);
		_tmp479_ = _tmp478_;
		if (_tmp479_ != NULL) {
			_tmp476_ = TRUE;
		} else {
			ValaProperty* _tmp480_;
			ValaProperty* _tmp481_;
			ValaProperty* _tmp482_;
			_tmp480_ = prop;
			_tmp481_ = vala_property_get_base_interface_property (_tmp480_);
			_tmp482_ = _tmp481_;
			_tmp476_ = _tmp482_ != NULL;
		}
		is_virtual = _tmp476_;
		_tmp483_ = acc;
		_tmp484_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp483_);
		cname = _tmp484_;
		_tmp487_ = acc;
		_tmp488_ = vala_property_accessor_get_writable (_tmp487_);
		_tmp489_ = _tmp488_;
		if (_tmp489_) {
			_tmp486_ = TRUE;
		} else {
			ValaPropertyAccessor* _tmp490_;
			gboolean _tmp491_;
			gboolean _tmp492_;
			_tmp490_ = acc;
			_tmp491_ = vala_property_accessor_get_construction (_tmp490_);
			_tmp492_ = _tmp491_;
			_tmp486_ = _tmp492_;
		}
		if (_tmp486_) {
			_tmp485_ = TRUE;
		} else {
			gboolean _tmp493_;
			_tmp493_ = returns_real_struct;
			_tmp485_ = _tmp493_;
		}
		if (_tmp485_) {
			const gchar* _tmp494_;
			ValaCCodeFunction* _tmp495_;
			_tmp494_ = cname;
			_tmp495_ = vala_ccode_function_new (_tmp494_, "void");
			_vala_ccode_node_unref0 (function);
			function = _tmp495_;
		} else {
			const gchar* _tmp496_;
			ValaPropertyAccessor* _tmp497_;
			ValaDataType* _tmp498_;
			ValaDataType* _tmp499_;
			gchar* _tmp500_;
			gchar* _tmp501_;
			ValaCCodeFunction* _tmp502_;
			_tmp496_ = cname;
			_tmp497_ = acc;
			_tmp498_ = vala_property_accessor_get_value_type (_tmp497_);
			_tmp499_ = _tmp498_;
			_tmp500_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp499_);
			_tmp501_ = _tmp500_;
			_tmp502_ = vala_ccode_function_new (_tmp496_, _tmp501_);
			_vala_ccode_node_unref0 (function);
			function = _tmp502_;
			_g_free0 (_tmp501_);
		}
		base_type = NULL;
		_tmp503_ = prop;
		_tmp504_ = vala_property_get_binding (_tmp503_);
		_tmp505_ = _tmp504_;
		if (_tmp505_ == VALA_MEMBER_BINDING_INSTANCE) {
			gboolean _tmp506_;
			_tmp506_ = is_virtual;
			if (_tmp506_) {
				ValaProperty* _tmp507_;
				ValaProperty* _tmp508_;
				ValaProperty* _tmp509_;
				ValaCCodeFunction* _tmp525_;
				ValaCCodeFunction* _tmp526_;
				ValaCCodeModifiers _tmp527_;
				ValaCCodeModifiers _tmp528_;
				ValaCCodeFunction* _tmp529_;
				ValaObjectType* _tmp530_;
				gchar* _tmp531_;
				gchar* _tmp532_;
				ValaCCodeParameter* _tmp533_;
				ValaCCodeParameter* _tmp534_;
				_tmp507_ = prop;
				_tmp508_ = vala_property_get_base_property (_tmp507_);
				_tmp509_ = _tmp508_;
				if (_tmp509_ != NULL) {
					ValaProperty* _tmp510_;
					ValaProperty* _tmp511_;
					ValaProperty* _tmp512_;
					ValaSymbol* _tmp513_;
					ValaSymbol* _tmp514_;
					ValaObjectType* _tmp515_;
					_tmp510_ = prop;
					_tmp511_ = vala_property_get_base_property (_tmp510_);
					_tmp512_ = _tmp511_;
					_tmp513_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp512_);
					_tmp514_ = _tmp513_;
					_tmp515_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp514_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
					_vala_code_node_unref0 (base_type);
					base_type = _tmp515_;
				} else {
					ValaProperty* _tmp516_;
					ValaProperty* _tmp517_;
					ValaProperty* _tmp518_;
					_tmp516_ = prop;
					_tmp517_ = vala_property_get_base_interface_property (_tmp516_);
					_tmp518_ = _tmp517_;
					if (_tmp518_ != NULL) {
						ValaProperty* _tmp519_;
						ValaProperty* _tmp520_;
						ValaProperty* _tmp521_;
						ValaSymbol* _tmp522_;
						ValaSymbol* _tmp523_;
						ValaObjectType* _tmp524_;
						_tmp519_ = prop;
						_tmp520_ = vala_property_get_base_interface_property (_tmp519_);
						_tmp521_ = _tmp520_;
						_tmp522_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp521_);
						_tmp523_ = _tmp522_;
						_tmp524_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp523_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
						_vala_code_node_unref0 (base_type);
						base_type = _tmp524_;
					}
				}
				_tmp525_ = function;
				_tmp526_ = function;
				_tmp527_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp526_);
				_tmp528_ = _tmp527_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp526_, _tmp528_ | VALA_CCODE_MODIFIERS_STATIC);
				_tmp529_ = function;
				_tmp530_ = base_type;
				_tmp531_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp530_);
				_tmp532_ = _tmp531_;
				_tmp533_ = vala_ccode_parameter_new ("base", _tmp532_);
				_tmp534_ = _tmp533_;
				vala_ccode_function_add_parameter (_tmp529_, _tmp534_);
				_vala_ccode_node_unref0 (_tmp534_);
				_g_free0 (_tmp532_);
			} else {
				ValaCCodeFunction* _tmp535_;
				ValaCCodeParameter* _tmp536_;
				_tmp535_ = function;
				_tmp536_ = cselfparam;
				vala_ccode_function_add_parameter (_tmp535_, _tmp536_);
			}
		}
		_tmp539_ = acc;
		_tmp540_ = vala_property_accessor_get_writable (_tmp539_);
		_tmp541_ = _tmp540_;
		if (_tmp541_) {
			_tmp538_ = TRUE;
		} else {
			ValaPropertyAccessor* _tmp542_;
			gboolean _tmp543_;
			gboolean _tmp544_;
			_tmp542_ = acc;
			_tmp543_ = vala_property_accessor_get_construction (_tmp542_);
			_tmp544_ = _tmp543_;
			_tmp538_ = _tmp544_;
		}
		if (_tmp538_) {
			_tmp537_ = TRUE;
		} else {
			gboolean _tmp545_;
			_tmp545_ = returns_real_struct;
			_tmp537_ = _tmp545_;
		}
		if (_tmp537_) {
			ValaCCodeFunction* _tmp546_;
			ValaCCodeParameter* _tmp547_;
			_tmp546_ = function;
			_tmp547_ = cvalueparam;
			vala_ccode_function_add_parameter (_tmp546_, _tmp547_);
		}
		_tmp548_ = acc;
		_tmp549_ = vala_property_accessor_get_value_type (_tmp548_);
		_tmp550_ = _tmp549_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp550_, VALA_TYPE_ARRAY_TYPE)) {
			ValaArrayType* array_type = NULL;
			ValaPropertyAccessor* _tmp551_;
			ValaDataType* _tmp552_;
			ValaDataType* _tmp553_;
			ValaArrayType* _tmp554_;
			_tmp551_ = acc;
			_tmp552_ = vala_property_accessor_get_value_type (_tmp551_);
			_tmp553_ = _tmp552_;
			_tmp554_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp553_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			array_type = _tmp554_;
			{
				gint dim = 0;
				dim = 1;
				{
					gboolean _tmp555_ = FALSE;
					_tmp555_ = TRUE;
					while (TRUE) {
						gint _tmp557_;
						ValaArrayType* _tmp558_;
						gint _tmp559_;
						gint _tmp560_;
						const gchar* _tmp561_ = NULL;
						ValaPropertyAccessor* _tmp562_;
						gboolean _tmp563_;
						gboolean _tmp564_;
						const gchar* _tmp565_ = NULL;
						ValaPropertyAccessor* _tmp566_;
						gboolean _tmp567_;
						gboolean _tmp568_;
						ValaCCodeFunction* _tmp569_;
						gint _tmp570_;
						gchar* _tmp571_;
						gchar* _tmp572_;
						ValaCCodeParameter* _tmp573_;
						ValaCCodeParameter* _tmp574_;
						if (!_tmp555_) {
							gint _tmp556_;
							_tmp556_ = dim;
							dim = _tmp556_ + 1;
						}
						_tmp555_ = FALSE;
						_tmp557_ = dim;
						_tmp558_ = array_type;
						_tmp559_ = vala_array_type_get_rank (_tmp558_);
						_tmp560_ = _tmp559_;
						if (!(_tmp557_ <= _tmp560_)) {
							break;
						}
						_tmp562_ = acc;
						_tmp563_ = vala_property_accessor_get_readable (_tmp562_);
						_tmp564_ = _tmp563_;
						if (_tmp564_) {
							_tmp561_ = "result";
						} else {
							_tmp561_ = "value";
						}
						_tmp566_ = acc;
						_tmp567_ = vala_property_accessor_get_readable (_tmp566_);
						_tmp568_ = _tmp567_;
						if (_tmp568_) {
							_tmp565_ = "int*";
						} else {
							_tmp565_ = "int";
						}
						_tmp569_ = function;
						_tmp570_ = dim;
						_tmp571_ = vala_ccode_base_module_get_array_length_cname (self, _tmp561_, _tmp570_);
						_tmp572_ = _tmp571_;
						_tmp573_ = vala_ccode_parameter_new (_tmp572_, _tmp565_);
						_tmp574_ = _tmp573_;
						vala_ccode_function_add_parameter (_tmp569_, _tmp574_);
						_vala_ccode_node_unref0 (_tmp574_);
						_g_free0 (_tmp572_);
					}
				}
			}
			_vala_code_node_unref0 (array_type);
		} else {
			gboolean _tmp575_ = FALSE;
			ValaPropertyAccessor* _tmp576_;
			ValaDataType* _tmp577_;
			ValaDataType* _tmp578_;
			_tmp576_ = acc;
			_tmp577_ = vala_property_accessor_get_value_type (_tmp576_);
			_tmp578_ = _tmp577_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp578_, VALA_TYPE_DELEGATE_TYPE)) {
				ValaPropertyAccessor* _tmp579_;
				ValaDataType* _tmp580_;
				ValaDataType* _tmp581_;
				ValaDelegate* _tmp582_;
				ValaDelegate* _tmp583_;
				gboolean _tmp584_;
				gboolean _tmp585_;
				_tmp579_ = acc;
				_tmp580_ = vala_property_accessor_get_value_type (_tmp579_);
				_tmp581_ = _tmp580_;
				_tmp582_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp581_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
				_tmp583_ = _tmp582_;
				_tmp584_ = vala_delegate_get_has_target (_tmp583_);
				_tmp585_ = _tmp584_;
				_tmp575_ = _tmp585_;
			} else {
				_tmp575_ = FALSE;
			}
			if (_tmp575_) {
				const gchar* _tmp586_ = NULL;
				ValaPropertyAccessor* _tmp587_;
				gboolean _tmp588_;
				gboolean _tmp589_;
				const gchar* _tmp590_ = NULL;
				ValaPropertyAccessor* _tmp591_;
				gboolean _tmp592_;
				gboolean _tmp593_;
				ValaCCodeFunction* _tmp594_;
				gchar* _tmp595_;
				gchar* _tmp596_;
				ValaCCodeParameter* _tmp597_;
				ValaCCodeParameter* _tmp598_;
				gboolean _tmp599_ = FALSE;
				ValaPropertyAccessor* _tmp600_;
				gboolean _tmp601_;
				gboolean _tmp602_;
				_tmp587_ = acc;
				_tmp588_ = vala_property_accessor_get_readable (_tmp587_);
				_tmp589_ = _tmp588_;
				if (_tmp589_) {
					_tmp586_ = "result";
				} else {
					_tmp586_ = "value";
				}
				_tmp591_ = acc;
				_tmp592_ = vala_property_accessor_get_readable (_tmp591_);
				_tmp593_ = _tmp592_;
				if (_tmp593_) {
					_tmp590_ = "gpointer*";
				} else {
					_tmp590_ = "gpointer";
				}
				_tmp594_ = function;
				_tmp595_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp586_);
				_tmp596_ = _tmp595_;
				_tmp597_ = vala_ccode_parameter_new (_tmp596_, _tmp590_);
				_tmp598_ = _tmp597_;
				vala_ccode_function_add_parameter (_tmp594_, _tmp598_);
				_vala_ccode_node_unref0 (_tmp598_);
				_g_free0 (_tmp596_);
				_tmp600_ = acc;
				_tmp601_ = vala_property_accessor_get_readable (_tmp600_);
				_tmp602_ = _tmp601_;
				if (!_tmp602_) {
					ValaPropertyAccessor* _tmp603_;
					ValaDataType* _tmp604_;
					ValaDataType* _tmp605_;
					gboolean _tmp606_;
					gboolean _tmp607_;
					_tmp603_ = acc;
					_tmp604_ = vala_property_accessor_get_value_type (_tmp603_);
					_tmp605_ = _tmp604_;
					_tmp606_ = vala_data_type_get_value_owned (_tmp605_);
					_tmp607_ = _tmp606_;
					_tmp599_ = _tmp607_;
				} else {
					_tmp599_ = FALSE;
				}
				if (_tmp599_) {
					ValaCCodeFunction* _tmp608_;
					gchar* _tmp609_;
					gchar* _tmp610_;
					ValaCCodeParameter* _tmp611_;
					ValaCCodeParameter* _tmp612_;
					_tmp608_ = function;
					_tmp609_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, "value");
					_tmp610_ = _tmp609_;
					_tmp611_ = vala_ccode_parameter_new (_tmp610_, "GDestroyNotify");
					_tmp612_ = _tmp611_;
					vala_ccode_function_add_parameter (_tmp608_, _tmp612_);
					_vala_ccode_node_unref0 (_tmp612_);
					_g_free0 (_tmp610_);
				}
			}
		}
		_tmp613_ = is_virtual;
		if (!_tmp613_) {
			gboolean _tmp614_ = FALSE;
			gboolean _tmp615_ = FALSE;
			ValaProperty* _tmp616_;
			gboolean _tmp617_;
			_tmp616_ = prop;
			_tmp617_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp616_);
			if (_tmp617_) {
				_tmp615_ = TRUE;
			} else {
				gboolean _tmp618_ = FALSE;
				ValaPropertyAccessor* _tmp619_;
				gboolean _tmp620_;
				gboolean _tmp621_;
				_tmp619_ = acc;
				_tmp620_ = vala_property_accessor_get_readable (_tmp619_);
				_tmp621_ = _tmp620_;
				if (_tmp621_) {
					_tmp618_ = TRUE;
				} else {
					ValaPropertyAccessor* _tmp622_;
					gboolean _tmp623_;
					gboolean _tmp624_;
					_tmp622_ = acc;
					_tmp623_ = vala_property_accessor_get_writable (_tmp622_);
					_tmp624_ = _tmp623_;
					_tmp618_ = _tmp624_;
				}
				_tmp615_ = !_tmp618_;
			}
			if (_tmp615_) {
				_tmp614_ = TRUE;
			} else {
				ValaPropertyAccessor* _tmp625_;
				ValaSymbolAccessibility _tmp626_;
				ValaSymbolAccessibility _tmp627_;
				_tmp625_ = acc;
				_tmp626_ = vala_symbol_get_access ((ValaSymbol*) _tmp625_);
				_tmp627_ = _tmp626_;
				_tmp614_ = _tmp627_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
			}
			if (_tmp614_) {
				ValaCCodeFunction* _tmp628_;
				ValaCCodeFunction* _tmp629_;
				ValaCCodeModifiers _tmp630_;
				ValaCCodeModifiers _tmp631_;
				_tmp628_ = function;
				_tmp629_ = function;
				_tmp630_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp629_);
				_tmp631_ = _tmp630_;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp629_, _tmp631_ | VALA_CCODE_MODIFIERS_STATIC);
			} else {
				gboolean _tmp632_ = FALSE;
				ValaCodeContext* _tmp633_;
				gboolean _tmp634_;
				gboolean _tmp635_;
				_tmp633_ = self->priv->_context;
				_tmp634_ = vala_code_context_get_hide_internal (_tmp633_);
				_tmp635_ = _tmp634_;
				if (_tmp635_) {
					gboolean _tmp636_ = FALSE;
					ValaProperty* _tmp637_;
					gboolean _tmp638_;
					_tmp637_ = prop;
					_tmp638_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp637_);
					if (_tmp638_) {
						_tmp636_ = TRUE;
					} else {
						ValaPropertyAccessor* _tmp639_;
						ValaSymbolAccessibility _tmp640_;
						ValaSymbolAccessibility _tmp641_;
						_tmp639_ = acc;
						_tmp640_ = vala_symbol_get_access ((ValaSymbol*) _tmp639_);
						_tmp641_ = _tmp640_;
						_tmp636_ = _tmp641_ == VALA_SYMBOL_ACCESSIBILITY_INTERNAL;
					}
					_tmp632_ = _tmp636_;
				} else {
					_tmp632_ = FALSE;
				}
				if (_tmp632_) {
					ValaCCodeFunction* _tmp642_;
					ValaCCodeFunction* _tmp643_;
					ValaCCodeModifiers _tmp644_;
					ValaCCodeModifiers _tmp645_;
					_tmp642_ = function;
					_tmp643_ = function;
					_tmp644_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp643_);
					_tmp645_ = _tmp644_;
					vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp643_, _tmp645_ | VALA_CCODE_MODIFIERS_INTERNAL);
				}
			}
		}
		_tmp646_ = function;
		vala_ccode_base_module_push_function (self, _tmp646_);
		_tmp648_ = prop;
		_tmp649_ = vala_property_get_binding (_tmp648_);
		_tmp650_ = _tmp649_;
		if (_tmp650_ == VALA_MEMBER_BINDING_INSTANCE) {
			gboolean _tmp651_;
			_tmp651_ = is_virtual;
			_tmp647_ = !_tmp651_;
		} else {
			_tmp647_ = FALSE;
		}
		if (_tmp647_) {
			gboolean _tmp652_ = FALSE;
			ValaPropertyAccessor* _tmp653_;
			gboolean _tmp654_;
			gboolean _tmp655_;
			_tmp653_ = acc;
			_tmp654_ = vala_property_accessor_get_readable (_tmp653_);
			_tmp655_ = _tmp654_;
			if (!_tmp655_) {
				_tmp652_ = TRUE;
			} else {
				gboolean _tmp656_;
				_tmp656_ = returns_real_struct;
				_tmp652_ = _tmp656_;
			}
			if (_tmp652_) {
				ValaProperty* _tmp657_;
				ValaTypeSymbol* _tmp658_;
				_tmp657_ = prop;
				_tmp658_ = t;
				vala_ccode_base_module_create_property_type_check_statement (self, _tmp657_, FALSE, _tmp658_, TRUE, "self");
			} else {
				ValaProperty* _tmp659_;
				ValaTypeSymbol* _tmp660_;
				_tmp659_ = prop;
				_tmp660_ = t;
				vala_ccode_base_module_create_property_type_check_statement (self, _tmp659_, TRUE, _tmp660_, TRUE, "self");
			}
		}
		_tmp662_ = acc;
		_tmp663_ = vala_property_accessor_get_readable (_tmp662_);
		_tmp664_ = _tmp663_;
		if (_tmp664_) {
			gboolean _tmp665_;
			_tmp665_ = returns_real_struct;
			_tmp661_ = !_tmp665_;
		} else {
			_tmp661_ = FALSE;
		}
		if (_tmp661_) {
			gboolean _tmp666_ = FALSE;
			ValaPropertyAccessor* _tmp667_;
			ValaBasicBlock* _tmp668_;
			ValaBasicBlock* _tmp669_;
			_tmp667_ = acc;
			_tmp668_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp667_);
			_tmp669_ = _tmp668_;
			if (_tmp669_ == NULL) {
				_tmp666_ = TRUE;
			} else {
				ValaPropertyAccessor* _tmp670_;
				ValaBasicBlock* _tmp671_;
				ValaBasicBlock* _tmp672_;
				ValaList* _tmp673_;
				ValaList* _tmp674_;
				gint _tmp675_;
				gint _tmp676_;
				_tmp670_ = acc;
				_tmp671_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp670_);
				_tmp672_ = _tmp671_;
				_tmp673_ = vala_basic_block_get_predecessors (_tmp672_);
				_tmp674_ = _tmp673_;
				_tmp675_ = vala_collection_get_size ((ValaCollection*) _tmp674_);
				_tmp676_ = _tmp675_;
				_tmp666_ = _tmp676_ > 0;
				_vala_iterable_unref0 (_tmp674_);
			}
			if (_tmp666_) {
				ValaCCodeFunction* _tmp677_;
				ValaCCodeFunction* _tmp678_;
				ValaPropertyAccessor* _tmp679_;
				ValaDataType* _tmp680_;
				ValaDataType* _tmp681_;
				gchar* _tmp682_;
				gchar* _tmp683_;
				ValaCCodeVariableDeclarator* _tmp684_;
				ValaCCodeVariableDeclarator* _tmp685_;
				_tmp677_ = vala_ccode_base_module_get_ccode (self);
				_tmp678_ = _tmp677_;
				_tmp679_ = acc;
				_tmp680_ = vala_property_accessor_get_value_type (_tmp679_);
				_tmp681_ = _tmp680_;
				_tmp682_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp681_);
				_tmp683_ = _tmp682_;
				_tmp684_ = vala_ccode_variable_declarator_new ("result", NULL, NULL);
				_tmp685_ = _tmp684_;
				vala_ccode_function_add_declaration (_tmp678_, _tmp683_, (ValaCCodeDeclarator*) _tmp685_, 0);
				_vala_ccode_node_unref0 (_tmp685_);
				_g_free0 (_tmp683_);
			}
		}
		_tmp686_ = is_virtual;
		if (_tmp686_) {
			ValaCCodeFunction* _tmp687_;
			ValaCCodeFunction* _tmp688_;
			ValaDataType* _tmp689_;
			gchar* _tmp690_;
			gchar* _tmp691_;
			ValaCCodeVariableDeclarator* _tmp692_;
			ValaCCodeVariableDeclarator* _tmp693_;
			ValaCCodeFunction* _tmp694_;
			ValaCCodeFunction* _tmp695_;
			ValaCCodeIdentifier* _tmp696_;
			ValaCCodeIdentifier* _tmp697_;
			ValaObjectType* _tmp698_;
			ValaCCodeIdentifier* _tmp699_;
			ValaCCodeIdentifier* _tmp700_;
			ValaGLibValue* _tmp701_;
			ValaGLibValue* _tmp702_;
			ValaDataType* _tmp703_;
			ValaPropertyAccessor* _tmp704_;
			ValaTargetValue* _tmp705_;
			ValaTargetValue* _tmp706_;
			ValaCCodeExpression* _tmp707_;
			ValaCCodeExpression* _tmp708_;
			_tmp687_ = vala_ccode_base_module_get_ccode (self);
			_tmp688_ = _tmp687_;
			_tmp689_ = this_type;
			_tmp690_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp689_);
			_tmp691_ = _tmp690_;
			_tmp692_ = vala_ccode_variable_declarator_new ("self", NULL, NULL);
			_tmp693_ = _tmp692_;
			vala_ccode_function_add_declaration (_tmp688_, _tmp691_, (ValaCCodeDeclarator*) _tmp693_, 0);
			_vala_ccode_node_unref0 (_tmp693_);
			_g_free0 (_tmp691_);
			_tmp694_ = vala_ccode_base_module_get_ccode (self);
			_tmp695_ = _tmp694_;
			_tmp696_ = vala_ccode_identifier_new ("self");
			_tmp697_ = _tmp696_;
			_tmp698_ = base_type;
			_tmp699_ = vala_ccode_identifier_new ("base");
			_tmp700_ = _tmp699_;
			_tmp701_ = vala_glib_value_new ((ValaDataType*) _tmp698_, (ValaCCodeExpression*) _tmp700_, TRUE);
			_tmp702_ = _tmp701_;
			_tmp703_ = this_type;
			_tmp704_ = acc;
			_tmp705_ = vala_ccode_base_module_transform_value (self, (ValaTargetValue*) _tmp702_, _tmp703_, (ValaCodeNode*) _tmp704_);
			_tmp706_ = _tmp705_;
			_tmp707_ = vala_ccode_base_module_get_cvalue_ (self, _tmp706_);
			_tmp708_ = _tmp707_;
			vala_ccode_function_add_assignment (_tmp695_, (ValaCCodeExpression*) _tmp697_, _tmp708_);
			_vala_ccode_node_unref0 (_tmp708_);
			_vala_target_value_unref0 (_tmp706_);
			_vala_target_value_unref0 (_tmp702_);
			_vala_ccode_node_unref0 (_tmp700_);
			_vala_ccode_node_unref0 (_tmp697_);
		}
		_tmp711_ = prop;
		_tmp712_ = vala_ccode_base_module_is_gobject_property (self, _tmp711_);
		if (_tmp712_) {
			ValaProperty* _tmp713_;
			gboolean _tmp714_;
			gboolean _tmp715_;
			_tmp713_ = prop;
			_tmp714_ = vala_property_get_notify (_tmp713_);
			_tmp715_ = _tmp714_;
			_tmp710_ = _tmp715_;
		} else {
			_tmp710_ = FALSE;
		}
		if (_tmp710_) {
			gboolean _tmp716_ = FALSE;
			ValaPropertyAccessor* _tmp717_;
			gboolean _tmp718_;
			gboolean _tmp719_;
			_tmp717_ = acc;
			_tmp718_ = vala_property_accessor_get_writable (_tmp717_);
			_tmp719_ = _tmp718_;
			if (_tmp719_) {
				_tmp716_ = TRUE;
			} else {
				ValaPropertyAccessor* _tmp720_;
				gboolean _tmp721_;
				gboolean _tmp722_;
				_tmp720_ = acc;
				_tmp721_ = vala_property_accessor_get_construction (_tmp720_);
				_tmp722_ = _tmp721_;
				_tmp716_ = _tmp722_;
			}
			_tmp709_ = _tmp716_;
		} else {
			_tmp709_ = FALSE;
		}
		if (_tmp709_) {
			ValaCCodeFunctionCall* notify_call = NULL;
			ValaCCodeIdentifier* _tmp723_;
			ValaCCodeIdentifier* _tmp724_;
			ValaCCodeFunctionCall* _tmp725_;
			ValaCCodeFunctionCall* _tmp726_;
			ValaCCodeFunctionCall* _tmp727_;
			ValaCCodeIdentifier* _tmp728_;
			ValaCCodeIdentifier* _tmp729_;
			ValaCCodeCastExpression* _tmp730_;
			ValaCCodeCastExpression* _tmp731_;
			ValaCCodeFunctionCall* _tmp732_;
			ValaProperty* _tmp733_;
			ValaCCodeConstant* _tmp734_;
			ValaCCodeConstant* _tmp735_;
			ValaPropertyAccessor* get_accessor = NULL;
			ValaProperty* _tmp736_;
			ValaPropertyAccessor* _tmp737_;
			ValaPropertyAccessor* _tmp738_;
			ValaPropertyAccessor* _tmp739_;
			gboolean _tmp740_ = FALSE;
			ValaPropertyAccessor* _tmp741_;
			_tmp723_ = vala_ccode_identifier_new ("g_object_notify");
			_tmp724_ = _tmp723_;
			_tmp725_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp724_);
			_tmp726_ = _tmp725_;
			_vala_ccode_node_unref0 (_tmp724_);
			notify_call = _tmp726_;
			_tmp727_ = notify_call;
			_tmp728_ = vala_ccode_identifier_new ("self");
			_tmp729_ = _tmp728_;
			_tmp730_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp729_, "GObject *");
			_tmp731_ = _tmp730_;
			vala_ccode_function_call_add_argument (_tmp727_, (ValaCCodeExpression*) _tmp731_);
			_vala_ccode_node_unref0 (_tmp731_);
			_vala_ccode_node_unref0 (_tmp729_);
			_tmp732_ = notify_call;
			_tmp733_ = prop;
			_tmp734_ = vala_ccode_base_module_get_property_canonical_cconstant (self, _tmp733_);
			_tmp735_ = _tmp734_;
			vala_ccode_function_call_add_argument (_tmp732_, (ValaCCodeExpression*) _tmp735_);
			_vala_ccode_node_unref0 (_tmp735_);
			_tmp736_ = prop;
			_tmp737_ = vala_property_get_get_accessor (_tmp736_);
			_tmp738_ = _tmp737_;
			_tmp739_ = _vala_code_node_ref0 (_tmp738_);
			get_accessor = _tmp739_;
			_tmp741_ = get_accessor;
			if (_tmp741_ != NULL) {
				ValaPropertyAccessor* _tmp742_;
				gboolean _tmp743_;
				gboolean _tmp744_;
				_tmp742_ = get_accessor;
				_tmp743_ = vala_property_accessor_get_automatic_body (_tmp742_);
				_tmp744_ = _tmp743_;
				_tmp740_ = _tmp744_;
			} else {
				_tmp740_ = FALSE;
			}
			if (_tmp740_) {
				ValaDataType* property_type = NULL;
				ValaProperty* _tmp745_;
				ValaDataType* _tmp746_;
				ValaDataType* _tmp747_;
				ValaDataType* _tmp748_;
				ValaCCodeFunctionCall* get_call = NULL;
				ValaPropertyAccessor* _tmp749_;
				gchar* _tmp750_;
				gchar* _tmp751_;
				ValaCCodeIdentifier* _tmp752_;
				ValaCCodeIdentifier* _tmp753_;
				ValaCCodeFunctionCall* _tmp754_;
				ValaCCodeFunctionCall* _tmp755_;
				const gchar* _tmp756_ = NULL;
				gboolean _tmp757_;
				ValaCCodeFunctionCall* _tmp758_;
				ValaCCodeIdentifier* _tmp759_;
				ValaCCodeIdentifier* _tmp760_;
				ValaDataType* _tmp761_;
				ValaPropertyAccessor* _tmp846_;
				ValaBlock* _tmp847_;
				ValaBlock* _tmp848_;
				ValaCCodeFunction* _tmp849_;
				ValaCCodeFunction* _tmp850_;
				ValaCCodeFunctionCall* _tmp851_;
				ValaCCodeFunction* _tmp852_;
				ValaCCodeFunction* _tmp853_;
				_tmp745_ = prop;
				_tmp746_ = vala_property_get_property_type (_tmp745_);
				_tmp747_ = _tmp746_;
				_tmp748_ = _vala_code_node_ref0 (_tmp747_);
				property_type = _tmp748_;
				_tmp749_ = get_accessor;
				_tmp750_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp749_);
				_tmp751_ = _tmp750_;
				_tmp752_ = vala_ccode_identifier_new (_tmp751_);
				_tmp753_ = _tmp752_;
				_tmp754_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp753_);
				_tmp755_ = _tmp754_;
				_vala_ccode_node_unref0 (_tmp753_);
				_g_free0 (_tmp751_);
				get_call = _tmp755_;
				_tmp757_ = is_virtual;
				if (_tmp757_) {
					_tmp756_ = "base";
				} else {
					_tmp756_ = "self";
				}
				_tmp758_ = get_call;
				_tmp759_ = vala_ccode_identifier_new (_tmp756_);
				_tmp760_ = _tmp759_;
				vala_ccode_function_call_add_argument (_tmp758_, (ValaCCodeExpression*) _tmp760_);
				_vala_ccode_node_unref0 (_tmp760_);
				_tmp761_ = property_type;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp761_, VALA_TYPE_ARRAY_TYPE)) {
					ValaCCodeFunction* _tmp762_;
					ValaCCodeFunction* _tmp763_;
					ValaCCodeVariableDeclarator* _tmp764_;
					ValaCCodeVariableDeclarator* _tmp765_;
					ValaCCodeFunctionCall* _tmp766_;
					ValaCCodeIdentifier* _tmp767_;
					ValaCCodeIdentifier* _tmp768_;
					ValaCCodeUnaryExpression* _tmp769_;
					ValaCCodeUnaryExpression* _tmp770_;
					ValaCCodeFunction* _tmp771_;
					ValaCCodeFunction* _tmp772_;
					ValaCCodeFunctionCall* _tmp773_;
					ValaCCodeIdentifier* _tmp774_;
					ValaCCodeIdentifier* _tmp775_;
					ValaCCodeBinaryExpression* _tmp776_;
					ValaCCodeBinaryExpression* _tmp777_;
					_tmp762_ = vala_ccode_base_module_get_ccode (self);
					_tmp763_ = _tmp762_;
					_tmp764_ = vala_ccode_variable_declarator_new ("old_value_length", NULL, NULL);
					_tmp765_ = _tmp764_;
					vala_ccode_function_add_declaration (_tmp763_, "int", (ValaCCodeDeclarator*) _tmp765_, 0);
					_vala_ccode_node_unref0 (_tmp765_);
					_tmp766_ = get_call;
					_tmp767_ = vala_ccode_identifier_new ("old_value_length");
					_tmp768_ = _tmp767_;
					_tmp769_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp768_);
					_tmp770_ = _tmp769_;
					vala_ccode_function_call_add_argument (_tmp766_, (ValaCCodeExpression*) _tmp770_);
					_vala_ccode_node_unref0 (_tmp770_);
					_vala_ccode_node_unref0 (_tmp768_);
					_tmp771_ = vala_ccode_base_module_get_ccode (self);
					_tmp772_ = _tmp771_;
					_tmp773_ = get_call;
					_tmp774_ = vala_ccode_identifier_new ("value");
					_tmp775_ = _tmp774_;
					_tmp776_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) _tmp773_, (ValaCCodeExpression*) _tmp775_);
					_tmp777_ = _tmp776_;
					vala_ccode_function_open_if (_tmp772_, (ValaCCodeExpression*) _tmp777_);
					_vala_ccode_node_unref0 (_tmp777_);
					_vala_ccode_node_unref0 (_tmp775_);
				} else {
					ValaDataType* _tmp778_;
					ValaDataType* _tmp779_;
					gboolean _tmp780_;
					_tmp778_ = property_type;
					_tmp779_ = self->string_type;
					_tmp780_ = vala_data_type_compatible (_tmp778_, _tmp779_);
					if (_tmp780_) {
						ValaCCodeFunctionCall* ccall = NULL;
						ValaCCodeIdentifier* _tmp781_;
						ValaCCodeIdentifier* _tmp782_;
						ValaCCodeFunctionCall* _tmp783_;
						ValaCCodeFunctionCall* _tmp784_;
						ValaCCodeFunctionCall* _tmp785_;
						ValaCCodeIdentifier* _tmp786_;
						ValaCCodeIdentifier* _tmp787_;
						ValaCCodeFunctionCall* _tmp788_;
						ValaCCodeFunctionCall* _tmp789_;
						ValaCCodeFunction* _tmp790_;
						ValaCCodeFunction* _tmp791_;
						ValaCCodeFunctionCall* _tmp792_;
						ValaCCodeConstant* _tmp793_;
						ValaCCodeConstant* _tmp794_;
						ValaCCodeBinaryExpression* _tmp795_;
						ValaCCodeBinaryExpression* _tmp796_;
						_tmp781_ = vala_ccode_identifier_new ("g_strcmp0");
						_tmp782_ = _tmp781_;
						_tmp783_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp782_);
						_tmp784_ = _tmp783_;
						_vala_ccode_node_unref0 (_tmp782_);
						ccall = _tmp784_;
						_tmp785_ = ccall;
						_tmp786_ = vala_ccode_identifier_new ("value");
						_tmp787_ = _tmp786_;
						vala_ccode_function_call_add_argument (_tmp785_, (ValaCCodeExpression*) _tmp787_);
						_vala_ccode_node_unref0 (_tmp787_);
						_tmp788_ = ccall;
						_tmp789_ = get_call;
						vala_ccode_function_call_add_argument (_tmp788_, (ValaCCodeExpression*) _tmp789_);
						_tmp790_ = vala_ccode_base_module_get_ccode (self);
						_tmp791_ = _tmp790_;
						_tmp792_ = ccall;
						_tmp793_ = vala_ccode_constant_new ("0");
						_tmp794_ = _tmp793_;
						_tmp795_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) _tmp792_, (ValaCCodeExpression*) _tmp794_);
						_tmp796_ = _tmp795_;
						vala_ccode_function_open_if (_tmp791_, (ValaCCodeExpression*) _tmp796_);
						_vala_ccode_node_unref0 (_tmp796_);
						_vala_ccode_node_unref0 (_tmp794_);
						_vala_ccode_node_unref0 (ccall);
					} else {
						ValaDataType* _tmp797_;
						_tmp797_ = property_type;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp797_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
							ValaCCodeFunction* _tmp798_;
							ValaCCodeFunction* _tmp799_;
							ValaDataType* _tmp800_;
							gchar* _tmp801_;
							gchar* _tmp802_;
							ValaCCodeVariableDeclarator* _tmp803_;
							ValaCCodeVariableDeclarator* _tmp804_;
							ValaCCodeFunctionCall* _tmp805_;
							ValaCCodeIdentifier* _tmp806_;
							ValaCCodeIdentifier* _tmp807_;
							ValaCCodeUnaryExpression* _tmp808_;
							ValaCCodeUnaryExpression* _tmp809_;
							ValaCCodeCommaExpression* get_expr = NULL;
							ValaCCodeCommaExpression* _tmp810_;
							ValaCCodeCommaExpression* _tmp811_;
							ValaCCodeFunctionCall* _tmp812_;
							ValaCCodeCommaExpression* _tmp813_;
							ValaCCodeIdentifier* _tmp814_;
							ValaCCodeIdentifier* _tmp815_;
							ValaCCodeUnaryExpression* _tmp816_;
							ValaCCodeUnaryExpression* _tmp817_;
							gchar* equalfunc = NULL;
							ValaDataType* _tmp818_;
							ValaTypeSymbol* _tmp819_;
							ValaTypeSymbol* _tmp820_;
							gchar* _tmp821_;
							ValaCCodeFunctionCall* ccall = NULL;
							const gchar* _tmp822_;
							ValaCCodeIdentifier* _tmp823_;
							ValaCCodeIdentifier* _tmp824_;
							ValaCCodeFunctionCall* _tmp825_;
							ValaCCodeFunctionCall* _tmp826_;
							ValaCCodeFunctionCall* _tmp827_;
							ValaCCodeIdentifier* _tmp828_;
							ValaCCodeIdentifier* _tmp829_;
							ValaCCodeFunctionCall* _tmp830_;
							ValaCCodeCommaExpression* _tmp831_;
							ValaCCodeFunction* _tmp832_;
							ValaCCodeFunction* _tmp833_;
							ValaCCodeFunctionCall* _tmp834_;
							ValaCCodeConstant* _tmp835_;
							ValaCCodeConstant* _tmp836_;
							ValaCCodeBinaryExpression* _tmp837_;
							ValaCCodeBinaryExpression* _tmp838_;
							_tmp798_ = vala_ccode_base_module_get_ccode (self);
							_tmp799_ = _tmp798_;
							_tmp800_ = property_type;
							_tmp801_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp800_);
							_tmp802_ = _tmp801_;
							_tmp803_ = vala_ccode_variable_declarator_new ("old_value", NULL, NULL);
							_tmp804_ = _tmp803_;
							vala_ccode_function_add_declaration (_tmp799_, _tmp802_, (ValaCCodeDeclarator*) _tmp804_, 0);
							_vala_ccode_node_unref0 (_tmp804_);
							_g_free0 (_tmp802_);
							_tmp805_ = get_call;
							_tmp806_ = vala_ccode_identifier_new ("old_value");
							_tmp807_ = _tmp806_;
							_tmp808_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp807_);
							_tmp809_ = _tmp808_;
							vala_ccode_function_call_add_argument (_tmp805_, (ValaCCodeExpression*) _tmp809_);
							_vala_ccode_node_unref0 (_tmp809_);
							_vala_ccode_node_unref0 (_tmp807_);
							_tmp810_ = vala_ccode_comma_expression_new ();
							get_expr = _tmp810_;
							_tmp811_ = get_expr;
							_tmp812_ = get_call;
							vala_ccode_comma_expression_append_expression (_tmp811_, (ValaCCodeExpression*) _tmp812_);
							_tmp813_ = get_expr;
							_tmp814_ = vala_ccode_identifier_new ("old_value");
							_tmp815_ = _tmp814_;
							_tmp816_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp815_);
							_tmp817_ = _tmp816_;
							vala_ccode_comma_expression_append_expression (_tmp813_, (ValaCCodeExpression*) _tmp817_);
							_vala_ccode_node_unref0 (_tmp817_);
							_vala_ccode_node_unref0 (_tmp815_);
							_tmp818_ = property_type;
							_tmp819_ = vala_data_type_get_data_type (_tmp818_);
							_tmp820_ = _tmp819_;
							_tmp821_ = vala_ccode_base_module_generate_struct_equal_function (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp820_, VALA_TYPE_STRUCT, ValaStruct));
							equalfunc = _tmp821_;
							_tmp822_ = equalfunc;
							_tmp823_ = vala_ccode_identifier_new (_tmp822_);
							_tmp824_ = _tmp823_;
							_tmp825_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp824_);
							_tmp826_ = _tmp825_;
							_vala_ccode_node_unref0 (_tmp824_);
							ccall = _tmp826_;
							_tmp827_ = ccall;
							_tmp828_ = vala_ccode_identifier_new ("value");
							_tmp829_ = _tmp828_;
							vala_ccode_function_call_add_argument (_tmp827_, (ValaCCodeExpression*) _tmp829_);
							_vala_ccode_node_unref0 (_tmp829_);
							_tmp830_ = ccall;
							_tmp831_ = get_expr;
							vala_ccode_function_call_add_argument (_tmp830_, (ValaCCodeExpression*) _tmp831_);
							_tmp832_ = vala_ccode_base_module_get_ccode (self);
							_tmp833_ = _tmp832_;
							_tmp834_ = ccall;
							_tmp835_ = vala_ccode_constant_new ("TRUE");
							_tmp836_ = _tmp835_;
							_tmp837_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) _tmp834_, (ValaCCodeExpression*) _tmp836_);
							_tmp838_ = _tmp837_;
							vala_ccode_function_open_if (_tmp833_, (ValaCCodeExpression*) _tmp838_);
							_vala_ccode_node_unref0 (_tmp838_);
							_vala_ccode_node_unref0 (_tmp836_);
							_vala_ccode_node_unref0 (ccall);
							_g_free0 (equalfunc);
							_vala_ccode_node_unref0 (get_expr);
						} else {
							ValaCCodeFunction* _tmp839_;
							ValaCCodeFunction* _tmp840_;
							ValaCCodeFunctionCall* _tmp841_;
							ValaCCodeIdentifier* _tmp842_;
							ValaCCodeIdentifier* _tmp843_;
							ValaCCodeBinaryExpression* _tmp844_;
							ValaCCodeBinaryExpression* _tmp845_;
							_tmp839_ = vala_ccode_base_module_get_ccode (self);
							_tmp840_ = _tmp839_;
							_tmp841_ = get_call;
							_tmp842_ = vala_ccode_identifier_new ("value");
							_tmp843_ = _tmp842_;
							_tmp844_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, (ValaCCodeExpression*) _tmp841_, (ValaCCodeExpression*) _tmp843_);
							_tmp845_ = _tmp844_;
							vala_ccode_function_open_if (_tmp840_, (ValaCCodeExpression*) _tmp845_);
							_vala_ccode_node_unref0 (_tmp845_);
							_vala_ccode_node_unref0 (_tmp843_);
						}
					}
				}
				_tmp846_ = acc;
				_tmp847_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp846_);
				_tmp848_ = _tmp847_;
				vala_code_node_emit ((ValaCodeNode*) _tmp848_, (ValaCodeGenerator*) self);
				_tmp849_ = vala_ccode_base_module_get_ccode (self);
				_tmp850_ = _tmp849_;
				_tmp851_ = notify_call;
				vala_ccode_function_add_expression (_tmp850_, (ValaCCodeExpression*) _tmp851_);
				_tmp852_ = vala_ccode_base_module_get_ccode (self);
				_tmp853_ = _tmp852_;
				vala_ccode_function_close (_tmp853_);
				_vala_ccode_node_unref0 (get_call);
				_vala_code_node_unref0 (property_type);
			} else {
				ValaPropertyAccessor* _tmp854_;
				ValaBlock* _tmp855_;
				ValaBlock* _tmp856_;
				ValaCCodeFunction* _tmp857_;
				ValaCCodeFunction* _tmp858_;
				ValaCCodeFunctionCall* _tmp859_;
				_tmp854_ = acc;
				_tmp855_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp854_);
				_tmp856_ = _tmp855_;
				vala_code_node_emit ((ValaCodeNode*) _tmp856_, (ValaCodeGenerator*) self);
				_tmp857_ = vala_ccode_base_module_get_ccode (self);
				_tmp858_ = _tmp857_;
				_tmp859_ = notify_call;
				vala_ccode_function_add_expression (_tmp858_, (ValaCCodeExpression*) _tmp859_);
			}
			_vala_code_node_unref0 (get_accessor);
			_vala_ccode_node_unref0 (notify_call);
		} else {
			ValaPropertyAccessor* _tmp860_;
			ValaBlock* _tmp861_;
			ValaBlock* _tmp862_;
			_tmp860_ = acc;
			_tmp861_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp860_);
			_tmp862_ = _tmp861_;
			vala_code_node_emit ((ValaCodeNode*) _tmp862_, (ValaCodeGenerator*) self);
		}
		_tmp863_ = vala_ccode_base_module_get_current_method_inner_error (self);
		_tmp864_ = _tmp863_;
		if (_tmp864_) {
			ValaCCodeFunction* _tmp865_;
			ValaCCodeFunction* _tmp866_;
			ValaCCodeConstant* _tmp867_;
			ValaCCodeConstant* _tmp868_;
			ValaCCodeVariableDeclarator* _tmp869_;
			ValaCCodeVariableDeclarator* _tmp870_;
			_tmp865_ = vala_ccode_base_module_get_ccode (self);
			_tmp866_ = _tmp865_;
			_tmp867_ = vala_ccode_constant_new ("NULL");
			_tmp868_ = _tmp867_;
			_tmp869_ = vala_ccode_variable_declarator_new_zero ("_inner_error_", (ValaCCodeExpression*) _tmp868_, NULL);
			_tmp870_ = _tmp869_;
			vala_ccode_function_add_declaration (_tmp866_, "GError *", (ValaCCodeDeclarator*) _tmp870_, 0);
			_vala_ccode_node_unref0 (_tmp870_);
			_vala_ccode_node_unref0 (_tmp868_);
		}
		_tmp871_ = self->cfile;
		_tmp872_ = function;
		vala_ccode_file_add_function (_tmp871_, _tmp872_);
		_vala_code_node_unref0 (base_type);
		_vala_ccode_node_unref0 (function);
		_g_free0 (cname);
	}
	vala_ccode_base_module_pop_line (self);
	vala_ccode_base_module_pop_context (self);
	_vala_ccode_node_unref0 (cvalueparam);
	_vala_ccode_node_unref0 (cselfparam);
	_vala_code_node_unref0 (this_type);
	_vala_code_node_unref0 (t);
	_vala_code_node_unref0 (prop);
}


static void vala_ccode_base_module_real_visit_destructor (ValaCodeVisitor* base, ValaDestructor* d) {
	ValaCCodeBaseModule * self;
	gboolean _tmp0_ = FALSE;
	ValaDestructor* _tmp1_;
	ValaMemberBinding _tmp2_;
	ValaMemberBinding _tmp3_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (d != NULL);
	_tmp1_ = d;
	_tmp2_ = vala_destructor_get_binding (_tmp1_);
	_tmp3_ = _tmp2_;
	if (_tmp3_ == VALA_MEMBER_BINDING_STATIC) {
		gboolean _tmp4_;
		_tmp4_ = self->in_plugin;
		_tmp0_ = !_tmp4_;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		ValaDestructor* _tmp5_;
		ValaSourceReference* _tmp6_;
		ValaSourceReference* _tmp7_;
		ValaDestructor* _tmp8_;
		_tmp5_ = d;
		_tmp6_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp5_);
		_tmp7_ = _tmp6_;
		vala_report_error (_tmp7_, "static destructors are only supported for dynamic types");
		_tmp8_ = d;
		vala_code_node_set_error ((ValaCodeNode*) _tmp8_, TRUE);
		return;
	}
}


gint vala_ccode_base_module_get_block_id (ValaCCodeBaseModule* self, ValaBlock* b) {
	gint result = 0;
	gint _result_ = 0;
	ValaMap* _tmp0_;
	ValaBlock* _tmp1_;
	gpointer _tmp2_;
	gint _tmp3_;
	g_return_val_if_fail (self != NULL, 0);
	g_return_val_if_fail (b != NULL, 0);
	_tmp0_ = self->priv->block_map;
	_tmp1_ = b;
	_tmp2_ = vala_map_get (_tmp0_, _tmp1_);
	_result_ = (gint) ((gintptr) _tmp2_);
	_tmp3_ = _result_;
	if (_tmp3_ == 0) {
		gint _tmp4_;
		gint _tmp5_;
		ValaMap* _tmp6_;
		ValaBlock* _tmp7_;
		gint _tmp8_;
		_tmp4_ = self->priv->next_block_id;
		self->priv->next_block_id = _tmp4_ + 1;
		_tmp5_ = self->priv->next_block_id;
		_result_ = _tmp5_;
		_tmp6_ = self->priv->block_map;
		_tmp7_ = b;
		_tmp8_ = _result_;
		vala_map_set (_tmp6_, _tmp7_, (gpointer) ((gintptr) _tmp8_));
	}
	result = _result_;
	return result;
}


gboolean vala_ccode_base_module_no_implicit_copy (ValaCCodeBaseModule* self, ValaDataType* type) {
	gboolean result = FALSE;
	ValaClass* cl = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	ValaClass* _tmp3_;
	gboolean _tmp4_ = FALSE;
	gboolean _tmp5_ = FALSE;
	ValaDataType* _tmp6_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type != NULL, FALSE);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp2_) : NULL);
	cl = _tmp3_;
	_tmp6_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_DELEGATE_TYPE)) {
		_tmp5_ = TRUE;
	} else {
		ValaDataType* _tmp7_;
		gboolean _tmp8_;
		_tmp7_ = type;
		_tmp8_ = vala_data_type_is_array (_tmp7_);
		_tmp5_ = _tmp8_;
	}
	if (_tmp5_) {
		_tmp4_ = TRUE;
	} else {
		gboolean _tmp9_ = FALSE;
		gboolean _tmp10_ = FALSE;
		gboolean _tmp11_ = FALSE;
		ValaClass* _tmp12_;
		_tmp12_ = cl;
		if (_tmp12_ != NULL) {
			ValaClass* _tmp13_;
			gboolean _tmp14_;
			gboolean _tmp15_;
			_tmp13_ = cl;
			_tmp14_ = vala_class_get_is_immutable (_tmp13_);
			_tmp15_ = _tmp14_;
			_tmp11_ = !_tmp15_;
		} else {
			_tmp11_ = FALSE;
		}
		if (_tmp11_) {
			ValaClass* _tmp16_;
			gboolean _tmp17_;
			_tmp16_ = cl;
			_tmp17_ = vala_ccode_base_module_is_reference_counting ((ValaTypeSymbol*) _tmp16_);
			_tmp10_ = !_tmp17_;
		} else {
			_tmp10_ = FALSE;
		}
		if (_tmp10_) {
			ValaClass* _tmp18_;
			gboolean _tmp19_;
			_tmp18_ = cl;
			_tmp19_ = vala_ccode_base_module_get_ccode_is_gboxed ((ValaTypeSymbol*) _tmp18_);
			_tmp9_ = !_tmp19_;
		} else {
			_tmp9_ = FALSE;
		}
		_tmp4_ = _tmp9_;
	}
	result = _tmp4_;
	_vala_code_node_unref0 (cl);
	return result;
}


static void vala_ccode_base_module_capture_parameter (ValaCCodeBaseModule* self, ValaParameter* param, ValaCCodeStruct* data, gint block_id) {
	ValaParameter* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaCCodeFile* _tmp3_;
	ValaDataType* param_type = NULL;
	ValaParameter* _tmp4_;
	ValaDataType* _tmp5_;
	ValaDataType* _tmp6_;
	ValaDataType* _tmp7_;
	ValaParameter* _tmp8_;
	ValaDataType* _tmp9_;
	ValaDataType* _tmp10_;
	gboolean _tmp11_;
	gboolean _tmp12_;
	ValaCCodeStruct* _tmp18_;
	ValaDataType* _tmp19_;
	gchar* _tmp20_;
	gchar* _tmp21_;
	ValaParameter* _tmp22_;
	const gchar* _tmp23_;
	const gchar* _tmp24_;
	gchar* _tmp25_;
	gchar* _tmp26_;
	ValaParameter* _tmp27_;
	ValaTargetValue* value = NULL;
	ValaParameter* _tmp28_;
	ValaTargetValue* _tmp29_;
	ValaArrayType* array_type = NULL;
	ValaParameter* _tmp30_;
	ValaDataType* _tmp31_;
	ValaDataType* _tmp32_;
	ValaArrayType* _tmp33_;
	ValaDelegateType* deleg_type = NULL;
	ValaParameter* _tmp34_;
	ValaDataType* _tmp35_;
	ValaDataType* _tmp36_;
	ValaDelegateType* _tmp37_;
	gboolean _tmp38_ = FALSE;
	ValaArrayType* _tmp39_;
	ValaParameter* _tmp81_;
	ValaParameter* _tmp82_;
	ValaTargetValue* _tmp83_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (param != NULL);
	g_return_if_fail (data != NULL);
	_tmp0_ = param;
	_tmp1_ = vala_variable_get_variable_type ((ValaVariable*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->cfile;
	vala_ccode_base_module_generate_type_declaration (self, _tmp2_, _tmp3_);
	_tmp4_ = param;
	_tmp5_ = vala_variable_get_variable_type ((ValaVariable*) _tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = vala_data_type_copy (_tmp6_);
	param_type = _tmp7_;
	_tmp8_ = param;
	_tmp9_ = vala_variable_get_variable_type ((ValaVariable*) _tmp8_);
	_tmp10_ = _tmp9_;
	_tmp11_ = vala_data_type_get_value_owned (_tmp10_);
	_tmp12_ = _tmp11_;
	if (!_tmp12_) {
		ValaDataType* _tmp13_;
		ValaParameter* _tmp14_;
		ValaDataType* _tmp15_;
		ValaDataType* _tmp16_;
		gboolean _tmp17_;
		_tmp13_ = param_type;
		_tmp14_ = param;
		_tmp15_ = vala_variable_get_variable_type ((ValaVariable*) _tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = vala_ccode_base_module_no_implicit_copy (self, _tmp16_);
		vala_data_type_set_value_owned (_tmp13_, !_tmp17_);
	}
	_tmp18_ = data;
	_tmp19_ = param_type;
	_tmp20_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp19_);
	_tmp21_ = _tmp20_;
	_tmp22_ = param;
	_tmp23_ = vala_symbol_get_name ((ValaSymbol*) _tmp22_);
	_tmp24_ = _tmp23_;
	_tmp25_ = vala_ccode_base_module_get_variable_cname (self, _tmp24_);
	_tmp26_ = _tmp25_;
	vala_ccode_struct_add_field (_tmp18_, _tmp21_, _tmp26_, 0, NULL);
	_g_free0 (_tmp26_);
	_g_free0 (_tmp21_);
	_tmp27_ = param;
	vala_parameter_set_captured (_tmp27_, FALSE);
	_tmp28_ = param;
	_tmp29_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, _tmp28_);
	value = _tmp29_;
	_tmp30_ = param;
	_tmp31_ = vala_variable_get_variable_type ((ValaVariable*) _tmp30_);
	_tmp32_ = _tmp31_;
	_tmp33_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp32_) : NULL);
	array_type = _tmp33_;
	_tmp34_ = param;
	_tmp35_ = vala_variable_get_variable_type ((ValaVariable*) _tmp34_);
	_tmp36_ = _tmp35_;
	_tmp37_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp36_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp36_) : NULL);
	deleg_type = _tmp37_;
	_tmp39_ = array_type;
	if (_tmp39_ != NULL) {
		ValaParameter* _tmp40_;
		gboolean _tmp41_;
		_tmp40_ = param;
		_tmp41_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp40_);
		_tmp38_ = _tmp41_;
	} else {
		_tmp38_ = FALSE;
	}
	if (_tmp38_) {
		{
			gint dim = 0;
			dim = 1;
			{
				gboolean _tmp42_ = FALSE;
				_tmp42_ = TRUE;
				while (TRUE) {
					gint _tmp44_;
					ValaArrayType* _tmp45_;
					gint _tmp46_;
					gint _tmp47_;
					ValaCCodeStruct* _tmp48_;
					ValaParameter* _tmp49_;
					gint _tmp50_;
					gchar* _tmp51_;
					gchar* _tmp52_;
					if (!_tmp42_) {
						gint _tmp43_;
						_tmp43_ = dim;
						dim = _tmp43_ + 1;
					}
					_tmp42_ = FALSE;
					_tmp44_ = dim;
					_tmp45_ = array_type;
					_tmp46_ = vala_array_type_get_rank (_tmp45_);
					_tmp47_ = _tmp46_;
					if (!(_tmp44_ <= _tmp47_)) {
						break;
					}
					_tmp48_ = data;
					_tmp49_ = param;
					_tmp50_ = dim;
					_tmp51_ = vala_ccode_base_module_get_parameter_array_length_cname (self, _tmp49_, _tmp50_);
					_tmp52_ = _tmp51_;
					vala_ccode_struct_add_field (_tmp48_, "gint", _tmp52_, 0, NULL);
					_g_free0 (_tmp52_);
				}
			}
		}
	} else {
		gboolean _tmp53_ = FALSE;
		ValaDelegateType* _tmp54_;
		_tmp54_ = deleg_type;
		if (_tmp54_ != NULL) {
			ValaDelegateType* _tmp55_;
			ValaDelegate* _tmp56_;
			ValaDelegate* _tmp57_;
			gboolean _tmp58_;
			gboolean _tmp59_;
			_tmp55_ = deleg_type;
			_tmp56_ = vala_delegate_type_get_delegate_symbol (_tmp55_);
			_tmp57_ = _tmp56_;
			_tmp58_ = vala_delegate_get_has_target (_tmp57_);
			_tmp59_ = _tmp58_;
			_tmp53_ = _tmp59_;
		} else {
			_tmp53_ = FALSE;
		}
		if (_tmp53_) {
			ValaCCodeStruct* _tmp60_;
			ValaParameter* _tmp61_;
			gchar* _tmp62_;
			gchar* _tmp63_;
			ValaParameter* _tmp64_;
			ValaDataType* _tmp65_;
			ValaDataType* _tmp66_;
			gboolean _tmp67_;
			_tmp60_ = data;
			_tmp61_ = param;
			_tmp62_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp61_);
			_tmp63_ = _tmp62_;
			vala_ccode_struct_add_field (_tmp60_, "gpointer", _tmp63_, 0, NULL);
			_g_free0 (_tmp63_);
			_tmp64_ = param;
			_tmp65_ = vala_variable_get_variable_type ((ValaVariable*) _tmp64_);
			_tmp66_ = _tmp65_;
			_tmp67_ = vala_data_type_is_disposable (_tmp66_);
			if (_tmp67_) {
				ValaCCodeStruct* _tmp68_;
				ValaParameter* _tmp69_;
				const gchar* _tmp70_;
				const gchar* _tmp71_;
				gchar* _tmp72_;
				gchar* _tmp73_;
				gchar* _tmp74_;
				gchar* _tmp75_;
				ValaTargetValue* lvalue = NULL;
				ValaParameter* _tmp76_;
				ValaTargetValue* _tmp77_;
				ValaTargetValue* _tmp78_;
				ValaTargetValue* _tmp79_;
				ValaCCodeExpression* _tmp80_;
				_tmp68_ = data;
				_tmp69_ = param;
				_tmp70_ = vala_symbol_get_name ((ValaSymbol*) _tmp69_);
				_tmp71_ = _tmp70_;
				_tmp72_ = vala_ccode_base_module_get_variable_cname (self, _tmp71_);
				_tmp73_ = _tmp72_;
				_tmp74_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp73_);
				_tmp75_ = _tmp74_;
				vala_ccode_struct_add_field (_tmp68_, "GDestroyNotify", _tmp75_, 0, NULL);
				_g_free0 (_tmp75_);
				_g_free0 (_tmp73_);
				_tmp76_ = param;
				_tmp77_ = vala_ccode_base_module_get_parameter_cvalue (self, _tmp76_);
				lvalue = _tmp77_;
				_tmp78_ = value;
				_tmp79_ = lvalue;
				_tmp80_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp79_);
				_vala_ccode_node_unref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp78_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->delegate_target_destroy_notify_cvalue);
				G_TYPE_CHECK_INSTANCE_CAST (_tmp78_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->delegate_target_destroy_notify_cvalue = _tmp80_;
				_vala_target_value_unref0 (lvalue);
			}
		}
	}
	_tmp81_ = param;
	vala_parameter_set_captured (_tmp81_, TRUE);
	_tmp82_ = param;
	_tmp83_ = value;
	vala_code_generator_store_parameter ((ValaCodeGenerator*) self, _tmp82_, _tmp83_, TRUE);
	_vala_code_node_unref0 (deleg_type);
	_vala_code_node_unref0 (array_type);
	_vala_target_value_unref0 (value);
	_vala_code_node_unref0 (param_type);
}


static void vala_ccode_base_module_real_visit_block (ValaCodeVisitor* base, ValaBlock* b) {
	ValaCCodeBaseModule * self;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaBlock* _tmp1_;
	ValaList* local_vars = NULL;
	ValaBlock* _tmp2_;
	ValaList* _tmp3_;
	gboolean _tmp4_ = FALSE;
	gboolean _tmp5_ = FALSE;
	ValaBlock* _tmp6_;
	ValaCodeNode* _tmp7_;
	ValaCodeNode* _tmp8_;
	ValaBlock* _tmp17_;
	gboolean _tmp18_;
	gboolean _tmp19_;
	ValaBlock* _tmp887_;
	ValaSymbol* _tmp888_;
	ValaSymbol* _tmp889_;
	ValaBlock* _tmp976_;
	gboolean _tmp977_;
	gboolean _tmp978_;
	gboolean _tmp1006_ = FALSE;
	gboolean _tmp1007_ = FALSE;
	ValaBlock* _tmp1008_;
	ValaCodeNode* _tmp1009_;
	ValaCodeNode* _tmp1010_;
	ValaCCodeBaseModuleEmitContext* _tmp1019_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (b != NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = b;
	vala_ccode_base_module_emit_context_push_symbol (_tmp0_, (ValaSymbol*) _tmp1_);
	_tmp2_ = b;
	_tmp3_ = vala_block_get_local_variables (_tmp2_);
	local_vars = _tmp3_;
	_tmp6_ = b;
	_tmp7_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp6_);
	_tmp8_ = _tmp7_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_BLOCK)) {
		_tmp5_ = TRUE;
	} else {
		ValaBlock* _tmp9_;
		ValaCodeNode* _tmp10_;
		ValaCodeNode* _tmp11_;
		_tmp9_ = b;
		_tmp10_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp9_);
		_tmp11_ = _tmp10_;
		_tmp5_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp11_, VALA_TYPE_SWITCH_STATEMENT);
	}
	if (_tmp5_) {
		_tmp4_ = TRUE;
	} else {
		ValaBlock* _tmp12_;
		ValaCodeNode* _tmp13_;
		ValaCodeNode* _tmp14_;
		_tmp12_ = b;
		_tmp13_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp12_);
		_tmp14_ = _tmp13_;
		_tmp4_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp14_, VALA_TYPE_TRY_STATEMENT);
	}
	if (_tmp4_) {
		ValaCCodeFunction* _tmp15_;
		ValaCCodeFunction* _tmp16_;
		_tmp15_ = vala_ccode_base_module_get_ccode (self);
		_tmp16_ = _tmp15_;
		vala_ccode_function_open_block (_tmp16_);
	}
	_tmp17_ = b;
	_tmp18_ = vala_block_get_captured (_tmp17_);
	_tmp19_ = _tmp18_;
	if (_tmp19_) {
		ValaBlock* parent_block = NULL;
		ValaBlock* _tmp20_;
		ValaSymbol* _tmp21_;
		ValaSymbol* _tmp22_;
		ValaBlock* _tmp23_;
		ValaBlock* _tmp24_;
		gint block_id = 0;
		ValaBlock* _tmp25_;
		gint _tmp26_;
		gchar* struct_name = NULL;
		gint _tmp27_;
		gchar* _tmp28_;
		ValaCCodeStruct* data = NULL;
		const gchar* _tmp29_;
		gchar* _tmp30_;
		gchar* _tmp31_;
		ValaCCodeStruct* _tmp32_;
		ValaCCodeStruct* _tmp33_;
		ValaCCodeStruct* _tmp34_;
		ValaBlock* _tmp35_;
		ValaCCodeFunctionCall* data_alloc = NULL;
		ValaCCodeIdentifier* _tmp171_;
		ValaCCodeIdentifier* _tmp172_;
		ValaCCodeFunctionCall* _tmp173_;
		ValaCCodeFunctionCall* _tmp174_;
		ValaCCodeFunctionCall* _tmp175_;
		const gchar* _tmp176_;
		ValaCCodeIdentifier* _tmp177_;
		ValaCCodeIdentifier* _tmp178_;
		gboolean _tmp179_;
		ValaCCodeFunction* _tmp197_;
		ValaCCodeFunction* _tmp198_;
		gint _tmp199_;
		gchar* _tmp200_;
		gchar* _tmp201_;
		ValaCCodeExpression* _tmp202_;
		ValaCCodeExpression* _tmp203_;
		ValaCCodeFunctionCall* _tmp204_;
		ValaCCodeFunction* _tmp205_;
		ValaCCodeFunction* _tmp206_;
		gint _tmp207_;
		gchar* _tmp208_;
		gchar* _tmp209_;
		ValaCCodeExpression* _tmp210_;
		ValaCCodeExpression* _tmp211_;
		ValaCCodeMemberAccess* _tmp212_;
		ValaCCodeMemberAccess* _tmp213_;
		ValaCCodeIdentifier* _tmp214_;
		ValaCCodeIdentifier* _tmp215_;
		ValaBlock* _tmp216_;
		ValaBlock* _tmp337_;
		ValaSymbol* _tmp338_;
		ValaSymbol* _tmp339_;
		ValaCCodeTypeDefinition* _typedef_ = NULL;
		const gchar* _tmp434_;
		gchar* _tmp435_;
		gchar* _tmp436_;
		const gchar* _tmp437_;
		ValaCCodeVariableDeclarator* _tmp438_;
		ValaCCodeVariableDeclarator* _tmp439_;
		ValaCCodeTypeDefinition* _tmp440_;
		ValaCCodeTypeDefinition* _tmp441_;
		ValaCCodeFile* _tmp442_;
		ValaCCodeTypeDefinition* _tmp443_;
		ValaCCodeFile* _tmp444_;
		ValaCCodeStruct* _tmp445_;
		ValaCCodeFunction* ref_fun = NULL;
		gint _tmp446_;
		gchar* _tmp447_;
		gchar* _tmp448_;
		const gchar* _tmp449_;
		gchar* _tmp450_;
		gchar* _tmp451_;
		ValaCCodeFunction* _tmp452_;
		ValaCCodeFunction* _tmp453_;
		ValaCCodeFunction* _tmp454_;
		gint _tmp455_;
		gchar* _tmp456_;
		gchar* _tmp457_;
		const gchar* _tmp458_;
		gchar* _tmp459_;
		gchar* _tmp460_;
		ValaCCodeParameter* _tmp461_;
		ValaCCodeParameter* _tmp462_;
		ValaCCodeFunction* _tmp463_;
		ValaCCodeFunction* _tmp464_;
		ValaCCodeFunctionCall* ccall = NULL;
		ValaCCodeIdentifier* _tmp465_;
		ValaCCodeIdentifier* _tmp466_;
		ValaCCodeFunctionCall* _tmp467_;
		ValaCCodeFunctionCall* _tmp468_;
		ValaCCodeFunctionCall* _tmp469_;
		gint _tmp470_;
		gchar* _tmp471_;
		gchar* _tmp472_;
		ValaCCodeIdentifier* _tmp473_;
		ValaCCodeIdentifier* _tmp474_;
		ValaCCodeMemberAccess* _tmp475_;
		ValaCCodeMemberAccess* _tmp476_;
		ValaCCodeUnaryExpression* _tmp477_;
		ValaCCodeUnaryExpression* _tmp478_;
		ValaCCodeFunction* _tmp479_;
		ValaCCodeFunction* _tmp480_;
		ValaCCodeFunctionCall* _tmp481_;
		ValaCCodeFunction* _tmp482_;
		ValaCCodeFunction* _tmp483_;
		gint _tmp484_;
		gchar* _tmp485_;
		gchar* _tmp486_;
		ValaCCodeIdentifier* _tmp487_;
		ValaCCodeIdentifier* _tmp488_;
		ValaCCodeFile* _tmp489_;
		ValaCCodeFunction* _tmp490_;
		ValaCCodeFile* _tmp491_;
		ValaCCodeFunction* _tmp492_;
		ValaCCodeFunction* unref_fun = NULL;
		gint _tmp493_;
		gchar* _tmp494_;
		gchar* _tmp495_;
		ValaCCodeFunction* _tmp496_;
		ValaCCodeFunction* _tmp497_;
		ValaCCodeFunction* _tmp498_;
		ValaCCodeParameter* _tmp499_;
		ValaCCodeParameter* _tmp500_;
		ValaCCodeFunction* _tmp501_;
		ValaCCodeFunction* _tmp502_;
		ValaCCodeFunction* _tmp503_;
		ValaCCodeFunction* _tmp504_;
		const gchar* _tmp505_;
		gchar* _tmp506_;
		gchar* _tmp507_;
		gint _tmp508_;
		gchar* _tmp509_;
		gchar* _tmp510_;
		ValaCCodeIdentifier* _tmp511_;
		ValaCCodeIdentifier* _tmp512_;
		const gchar* _tmp513_;
		gchar* _tmp514_;
		gchar* _tmp515_;
		ValaCCodeCastExpression* _tmp516_;
		ValaCCodeCastExpression* _tmp517_;
		ValaCCodeVariableDeclarator* _tmp518_;
		ValaCCodeVariableDeclarator* _tmp519_;
		ValaCCodeIdentifier* _tmp520_;
		ValaCCodeIdentifier* _tmp521_;
		ValaCCodeFunctionCall* _tmp522_;
		ValaCCodeFunctionCall* _tmp523_;
		gint _tmp524_;
		gchar* _tmp525_;
		gchar* _tmp526_;
		ValaCCodeIdentifier* _tmp527_;
		ValaCCodeIdentifier* _tmp528_;
		ValaCCodeMemberAccess* _tmp529_;
		ValaCCodeMemberAccess* _tmp530_;
		ValaCCodeUnaryExpression* _tmp531_;
		ValaCCodeUnaryExpression* _tmp532_;
		ValaCCodeFunction* _tmp533_;
		ValaCCodeFunction* _tmp534_;
		ValaCCodeFunctionCall* _tmp535_;
		ValaCCodeExpression* outer_block = NULL;
		gint _tmp536_;
		gchar* _tmp537_;
		gchar* _tmp538_;
		ValaCCodeIdentifier* _tmp539_;
		ValaCCodeExpression* _tmp540_;
		ValaBlock* parent_closure_block = NULL;
		ValaBlock* _tmp541_;
		ValaDataType* _tmp554_;
		ValaDataType* _tmp555_;
		gboolean _tmp556_;
		ValaMethod* _tmp574_;
		ValaMethod* _tmp575_;
		ValaBlock* _tmp680_;
		ValaSymbol* _tmp681_;
		ValaSymbol* _tmp682_;
		ValaBlock* _tmp762_;
		ValaCCodeFunctionCall* data_free = NULL;
		ValaCCodeIdentifier* _tmp822_;
		ValaCCodeIdentifier* _tmp823_;
		ValaCCodeFunctionCall* _tmp824_;
		ValaCCodeFunctionCall* _tmp825_;
		ValaCCodeFunctionCall* _tmp826_;
		const gchar* _tmp827_;
		ValaCCodeIdentifier* _tmp828_;
		ValaCCodeIdentifier* _tmp829_;
		ValaCCodeFunctionCall* _tmp830_;
		gint _tmp831_;
		gchar* _tmp832_;
		gchar* _tmp833_;
		ValaCCodeIdentifier* _tmp834_;
		ValaCCodeIdentifier* _tmp835_;
		ValaCCodeFunction* _tmp836_;
		ValaCCodeFunction* _tmp837_;
		ValaCCodeFunctionCall* _tmp838_;
		ValaCCodeFunction* _tmp839_;
		ValaCCodeFunction* _tmp840_;
		ValaCCodeFile* _tmp841_;
		ValaCCodeFunction* _tmp842_;
		ValaCCodeFile* _tmp843_;
		ValaCCodeFunction* _tmp844_;
		_tmp20_ = b;
		_tmp21_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp20_);
		_tmp22_ = _tmp21_;
		_tmp23_ = vala_ccode_base_module_next_closure_block (self, _tmp22_);
		_tmp24_ = _vala_code_node_ref0 (_tmp23_);
		parent_block = _tmp24_;
		_tmp25_ = b;
		_tmp26_ = vala_ccode_base_module_get_block_id (self, _tmp25_);
		block_id = _tmp26_;
		_tmp27_ = block_id;
		_tmp28_ = g_strdup_printf ("Block%dData", _tmp27_);
		struct_name = _tmp28_;
		_tmp29_ = struct_name;
		_tmp30_ = g_strconcat ("_", _tmp29_, NULL);
		_tmp31_ = _tmp30_;
		_tmp32_ = vala_ccode_struct_new (_tmp31_);
		_tmp33_ = _tmp32_;
		_g_free0 (_tmp31_);
		data = _tmp33_;
		_tmp34_ = data;
		vala_ccode_struct_add_field (_tmp34_, "int", "_ref_count_", 0, NULL);
		_tmp35_ = parent_block;
		if (_tmp35_ != NULL) {
			gint parent_block_id = 0;
			ValaBlock* _tmp36_;
			gint _tmp37_;
			ValaCCodeStruct* _tmp38_;
			gint _tmp39_;
			gchar* _tmp40_;
			gchar* _tmp41_;
			gint _tmp42_;
			gchar* _tmp43_;
			gchar* _tmp44_;
			_tmp36_ = parent_block;
			_tmp37_ = vala_ccode_base_module_get_block_id (self, _tmp36_);
			parent_block_id = _tmp37_;
			_tmp38_ = data;
			_tmp39_ = parent_block_id;
			_tmp40_ = g_strdup_printf ("Block%dData *", _tmp39_);
			_tmp41_ = _tmp40_;
			_tmp42_ = parent_block_id;
			_tmp43_ = g_strdup_printf ("_data%d_", _tmp42_);
			_tmp44_ = _tmp43_;
			vala_ccode_struct_add_field (_tmp38_, _tmp41_, _tmp44_, 0, NULL);
			_g_free0 (_tmp44_);
			_g_free0 (_tmp41_);
		} else {
			ValaDataType* _tmp45_;
			ValaDataType* _tmp46_;
			gboolean _tmp47_;
			ValaMethod* _tmp55_;
			ValaMethod* _tmp56_;
			_tmp45_ = vala_ccode_base_module_get_this_type (self);
			_tmp46_ = _tmp45_;
			_tmp47_ = _tmp46_ != NULL;
			_vala_code_node_unref0 (_tmp46_);
			if (_tmp47_) {
				ValaCCodeStruct* _tmp48_;
				ValaTypeSymbol* _tmp49_;
				ValaTypeSymbol* _tmp50_;
				ValaDataType* _tmp51_;
				ValaDataType* _tmp52_;
				gchar* _tmp53_;
				gchar* _tmp54_;
				_tmp48_ = data;
				_tmp49_ = vala_ccode_base_module_get_current_type_symbol (self);
				_tmp50_ = _tmp49_;
				_tmp51_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp50_);
				_tmp52_ = _tmp51_;
				_tmp53_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp52_);
				_tmp54_ = _tmp53_;
				vala_ccode_struct_add_field (_tmp48_, _tmp54_, "self", 0, NULL);
				_g_free0 (_tmp54_);
				_vala_code_node_unref0 (_tmp52_);
			}
			_tmp55_ = vala_ccode_base_module_get_current_method (self);
			_tmp56_ = _tmp55_;
			if (_tmp56_ != NULL) {
				{
					ValaList* _type_param_list = NULL;
					ValaMethod* _tmp57_;
					ValaMethod* _tmp58_;
					ValaList* _tmp59_;
					gint _type_param_size = 0;
					ValaList* _tmp60_;
					gint _tmp61_;
					gint _tmp62_;
					gint _type_param_index = 0;
					_tmp57_ = vala_ccode_base_module_get_current_method (self);
					_tmp58_ = _tmp57_;
					_tmp59_ = vala_method_get_type_parameters (_tmp58_);
					_type_param_list = _tmp59_;
					_tmp60_ = _type_param_list;
					_tmp61_ = vala_collection_get_size ((ValaCollection*) _tmp60_);
					_tmp62_ = _tmp61_;
					_type_param_size = _tmp62_;
					_type_param_index = -1;
					while (TRUE) {
						gint _tmp63_;
						gint _tmp64_;
						gint _tmp65_;
						ValaTypeParameter* type_param = NULL;
						ValaList* _tmp66_;
						gint _tmp67_;
						gpointer _tmp68_;
						gchar* func_name = NULL;
						ValaTypeParameter* _tmp69_;
						const gchar* _tmp70_;
						const gchar* _tmp71_;
						gchar* _tmp72_;
						gchar* _tmp73_;
						gchar* _tmp74_;
						ValaCCodeStruct* _tmp75_;
						const gchar* _tmp76_;
						ValaTypeParameter* _tmp77_;
						const gchar* _tmp78_;
						const gchar* _tmp79_;
						gchar* _tmp80_;
						gchar* _tmp81_;
						gchar* _tmp82_;
						ValaCCodeStruct* _tmp83_;
						const gchar* _tmp84_;
						ValaTypeParameter* _tmp85_;
						const gchar* _tmp86_;
						const gchar* _tmp87_;
						gchar* _tmp88_;
						gchar* _tmp89_;
						gchar* _tmp90_;
						ValaCCodeStruct* _tmp91_;
						const gchar* _tmp92_;
						_tmp63_ = _type_param_index;
						_type_param_index = _tmp63_ + 1;
						_tmp64_ = _type_param_index;
						_tmp65_ = _type_param_size;
						if (!(_tmp64_ < _tmp65_)) {
							break;
						}
						_tmp66_ = _type_param_list;
						_tmp67_ = _type_param_index;
						_tmp68_ = vala_list_get (_tmp66_, _tmp67_);
						type_param = (ValaTypeParameter*) _tmp68_;
						_tmp69_ = type_param;
						_tmp70_ = vala_symbol_get_name ((ValaSymbol*) _tmp69_);
						_tmp71_ = _tmp70_;
						_tmp72_ = g_utf8_strdown (_tmp71_, (gssize) -1);
						_tmp73_ = _tmp72_;
						_tmp74_ = g_strdup_printf ("%s_type", _tmp73_);
						_g_free0 (func_name);
						func_name = _tmp74_;
						_g_free0 (_tmp73_);
						_tmp75_ = data;
						_tmp76_ = func_name;
						vala_ccode_struct_add_field (_tmp75_, "GType", _tmp76_, 0, NULL);
						_tmp77_ = type_param;
						_tmp78_ = vala_symbol_get_name ((ValaSymbol*) _tmp77_);
						_tmp79_ = _tmp78_;
						_tmp80_ = g_utf8_strdown (_tmp79_, (gssize) -1);
						_tmp81_ = _tmp80_;
						_tmp82_ = g_strdup_printf ("%s_dup_func", _tmp81_);
						_g_free0 (func_name);
						func_name = _tmp82_;
						_g_free0 (_tmp81_);
						_tmp83_ = data;
						_tmp84_ = func_name;
						vala_ccode_struct_add_field (_tmp83_, "GBoxedCopyFunc", _tmp84_, 0, NULL);
						_tmp85_ = type_param;
						_tmp86_ = vala_symbol_get_name ((ValaSymbol*) _tmp85_);
						_tmp87_ = _tmp86_;
						_tmp88_ = g_utf8_strdown (_tmp87_, (gssize) -1);
						_tmp89_ = _tmp88_;
						_tmp90_ = g_strdup_printf ("%s_destroy_func", _tmp89_);
						_g_free0 (func_name);
						func_name = _tmp90_;
						_g_free0 (_tmp89_);
						_tmp91_ = data;
						_tmp92_ = func_name;
						vala_ccode_struct_add_field (_tmp91_, "GDestroyNotify", _tmp92_, 0, NULL);
						_g_free0 (func_name);
						_vala_code_node_unref0 (type_param);
					}
					_vala_iterable_unref0 (_type_param_list);
				}
			}
		}
		{
			ValaList* _local_list = NULL;
			ValaList* _tmp93_;
			ValaList* _tmp94_;
			gint _local_size = 0;
			ValaList* _tmp95_;
			gint _tmp96_;
			gint _tmp97_;
			gint _local_index = 0;
			_tmp93_ = local_vars;
			_tmp94_ = _vala_iterable_ref0 (_tmp93_);
			_local_list = _tmp94_;
			_tmp95_ = _local_list;
			_tmp96_ = vala_collection_get_size ((ValaCollection*) _tmp95_);
			_tmp97_ = _tmp96_;
			_local_size = _tmp97_;
			_local_index = -1;
			while (TRUE) {
				gint _tmp98_;
				gint _tmp99_;
				gint _tmp100_;
				ValaLocalVariable* local = NULL;
				ValaList* _tmp101_;
				gint _tmp102_;
				gpointer _tmp103_;
				ValaLocalVariable* _tmp104_;
				gboolean _tmp105_;
				gboolean _tmp106_;
				_tmp98_ = _local_index;
				_local_index = _tmp98_ + 1;
				_tmp99_ = _local_index;
				_tmp100_ = _local_size;
				if (!(_tmp99_ < _tmp100_)) {
					break;
				}
				_tmp101_ = _local_list;
				_tmp102_ = _local_index;
				_tmp103_ = vala_list_get (_tmp101_, _tmp102_);
				local = (ValaLocalVariable*) _tmp103_;
				_tmp104_ = local;
				_tmp105_ = vala_local_variable_get_captured (_tmp104_);
				_tmp106_ = _tmp105_;
				if (_tmp106_) {
					ValaLocalVariable* _tmp107_;
					ValaDataType* _tmp108_;
					ValaDataType* _tmp109_;
					ValaCCodeFile* _tmp110_;
					ValaCCodeStruct* _tmp111_;
					ValaLocalVariable* _tmp112_;
					ValaDataType* _tmp113_;
					ValaDataType* _tmp114_;
					gchar* _tmp115_;
					gchar* _tmp116_;
					ValaLocalVariable* _tmp117_;
					gchar* _tmp118_;
					gchar* _tmp119_;
					ValaLocalVariable* _tmp120_;
					ValaDataType* _tmp121_;
					ValaDataType* _tmp122_;
					ValaCCodeDeclaratorSuffix* _tmp123_;
					ValaCCodeDeclaratorSuffix* _tmp124_;
					ValaLocalVariable* _tmp125_;
					ValaDataType* _tmp126_;
					ValaDataType* _tmp127_;
					_tmp107_ = local;
					_tmp108_ = vala_variable_get_variable_type ((ValaVariable*) _tmp107_);
					_tmp109_ = _tmp108_;
					_tmp110_ = self->cfile;
					vala_ccode_base_module_generate_type_declaration (self, _tmp109_, _tmp110_);
					_tmp111_ = data;
					_tmp112_ = local;
					_tmp113_ = vala_variable_get_variable_type ((ValaVariable*) _tmp112_);
					_tmp114_ = _tmp113_;
					_tmp115_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp114_);
					_tmp116_ = _tmp115_;
					_tmp117_ = local;
					_tmp118_ = vala_ccode_base_module_get_local_cname (self, _tmp117_);
					_tmp119_ = _tmp118_;
					_tmp120_ = local;
					_tmp121_ = vala_variable_get_variable_type ((ValaVariable*) _tmp120_);
					_tmp122_ = _tmp121_;
					_tmp123_ = vala_ccode_base_module_get_ccode_declarator_suffix (self, _tmp122_);
					_tmp124_ = _tmp123_;
					vala_ccode_struct_add_field (_tmp111_, _tmp116_, _tmp119_, 0, _tmp124_);
					_vala_ccode_declarator_suffix_unref0 (_tmp124_);
					_g_free0 (_tmp119_);
					_g_free0 (_tmp116_);
					_tmp125_ = local;
					_tmp126_ = vala_variable_get_variable_type ((ValaVariable*) _tmp125_);
					_tmp127_ = _tmp126_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp127_, VALA_TYPE_ARRAY_TYPE)) {
						ValaArrayType* array_type = NULL;
						ValaLocalVariable* _tmp128_;
						ValaDataType* _tmp129_;
						ValaDataType* _tmp130_;
						ValaArrayType* _tmp131_;
						ValaCCodeStruct* _tmp145_;
						ValaLocalVariable* _tmp146_;
						gchar* _tmp147_;
						gchar* _tmp148_;
						gchar* _tmp149_;
						gchar* _tmp150_;
						_tmp128_ = local;
						_tmp129_ = vala_variable_get_variable_type ((ValaVariable*) _tmp128_);
						_tmp130_ = _tmp129_;
						_tmp131_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp130_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
						array_type = _tmp131_;
						{
							gint dim = 0;
							dim = 1;
							{
								gboolean _tmp132_ = FALSE;
								_tmp132_ = TRUE;
								while (TRUE) {
									gint _tmp134_;
									ValaArrayType* _tmp135_;
									gint _tmp136_;
									gint _tmp137_;
									ValaCCodeStruct* _tmp138_;
									ValaLocalVariable* _tmp139_;
									gchar* _tmp140_;
									gchar* _tmp141_;
									gint _tmp142_;
									gchar* _tmp143_;
									gchar* _tmp144_;
									if (!_tmp132_) {
										gint _tmp133_;
										_tmp133_ = dim;
										dim = _tmp133_ + 1;
									}
									_tmp132_ = FALSE;
									_tmp134_ = dim;
									_tmp135_ = array_type;
									_tmp136_ = vala_array_type_get_rank (_tmp135_);
									_tmp137_ = _tmp136_;
									if (!(_tmp134_ <= _tmp137_)) {
										break;
									}
									_tmp138_ = data;
									_tmp139_ = local;
									_tmp140_ = vala_ccode_base_module_get_local_cname (self, _tmp139_);
									_tmp141_ = _tmp140_;
									_tmp142_ = dim;
									_tmp143_ = vala_ccode_base_module_get_array_length_cname (self, _tmp141_, _tmp142_);
									_tmp144_ = _tmp143_;
									vala_ccode_struct_add_field (_tmp138_, "gint", _tmp144_, 0, NULL);
									_g_free0 (_tmp144_);
									_g_free0 (_tmp141_);
								}
							}
						}
						_tmp145_ = data;
						_tmp146_ = local;
						_tmp147_ = vala_ccode_base_module_get_local_cname (self, _tmp146_);
						_tmp148_ = _tmp147_;
						_tmp149_ = vala_ccode_base_module_get_array_size_cname (self, _tmp148_);
						_tmp150_ = _tmp149_;
						vala_ccode_struct_add_field (_tmp145_, "gint", _tmp150_, 0, NULL);
						_g_free0 (_tmp150_);
						_g_free0 (_tmp148_);
						_vala_code_node_unref0 (array_type);
					} else {
						ValaLocalVariable* _tmp151_;
						ValaDataType* _tmp152_;
						ValaDataType* _tmp153_;
						_tmp151_ = local;
						_tmp152_ = vala_variable_get_variable_type ((ValaVariable*) _tmp151_);
						_tmp153_ = _tmp152_;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp153_, VALA_TYPE_DELEGATE_TYPE)) {
							ValaCCodeStruct* _tmp154_;
							ValaLocalVariable* _tmp155_;
							gchar* _tmp156_;
							gchar* _tmp157_;
							gchar* _tmp158_;
							gchar* _tmp159_;
							ValaLocalVariable* _tmp160_;
							ValaDataType* _tmp161_;
							ValaDataType* _tmp162_;
							gboolean _tmp163_;
							gboolean _tmp164_;
							_tmp154_ = data;
							_tmp155_ = local;
							_tmp156_ = vala_ccode_base_module_get_local_cname (self, _tmp155_);
							_tmp157_ = _tmp156_;
							_tmp158_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp157_);
							_tmp159_ = _tmp158_;
							vala_ccode_struct_add_field (_tmp154_, "gpointer", _tmp159_, 0, NULL);
							_g_free0 (_tmp159_);
							_g_free0 (_tmp157_);
							_tmp160_ = local;
							_tmp161_ = vala_variable_get_variable_type ((ValaVariable*) _tmp160_);
							_tmp162_ = _tmp161_;
							_tmp163_ = vala_data_type_get_value_owned (_tmp162_);
							_tmp164_ = _tmp163_;
							if (_tmp164_) {
								ValaCCodeStruct* _tmp165_;
								ValaLocalVariable* _tmp166_;
								gchar* _tmp167_;
								gchar* _tmp168_;
								gchar* _tmp169_;
								gchar* _tmp170_;
								_tmp165_ = data;
								_tmp166_ = local;
								_tmp167_ = vala_ccode_base_module_get_local_cname (self, _tmp166_);
								_tmp168_ = _tmp167_;
								_tmp169_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp168_);
								_tmp170_ = _tmp169_;
								vala_ccode_struct_add_field (_tmp165_, "GDestroyNotify", _tmp170_, 0, NULL);
								_g_free0 (_tmp170_);
								_g_free0 (_tmp168_);
							}
						}
					}
				}
				_vala_code_node_unref0 (local);
			}
			_vala_iterable_unref0 (_local_list);
		}
		_tmp171_ = vala_ccode_identifier_new ("g_slice_new0");
		_tmp172_ = _tmp171_;
		_tmp173_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp172_);
		_tmp174_ = _tmp173_;
		_vala_ccode_node_unref0 (_tmp172_);
		data_alloc = _tmp174_;
		_tmp175_ = data_alloc;
		_tmp176_ = struct_name;
		_tmp177_ = vala_ccode_identifier_new (_tmp176_);
		_tmp178_ = _tmp177_;
		vala_ccode_function_call_add_argument (_tmp175_, (ValaCCodeExpression*) _tmp178_);
		_vala_ccode_node_unref0 (_tmp178_);
		_tmp179_ = vala_ccode_base_module_is_in_coroutine (self);
		if (_tmp179_) {
			ValaCCodeStruct* _tmp180_;
			const gchar* _tmp181_;
			gchar* _tmp182_;
			gchar* _tmp183_;
			gint _tmp184_;
			gchar* _tmp185_;
			gchar* _tmp186_;
			_tmp180_ = self->closure_struct;
			_tmp181_ = struct_name;
			_tmp182_ = g_strconcat (_tmp181_, "*", NULL);
			_tmp183_ = _tmp182_;
			_tmp184_ = block_id;
			_tmp185_ = g_strdup_printf ("_data%d_", _tmp184_);
			_tmp186_ = _tmp185_;
			vala_ccode_struct_add_field (_tmp180_, _tmp183_, _tmp186_, 0, NULL);
			_g_free0 (_tmp186_);
			_g_free0 (_tmp183_);
		} else {
			ValaCCodeFunction* _tmp187_;
			ValaCCodeFunction* _tmp188_;
			const gchar* _tmp189_;
			gchar* _tmp190_;
			gchar* _tmp191_;
			gint _tmp192_;
			gchar* _tmp193_;
			gchar* _tmp194_;
			ValaCCodeVariableDeclarator* _tmp195_;
			ValaCCodeVariableDeclarator* _tmp196_;
			_tmp187_ = vala_ccode_base_module_get_ccode (self);
			_tmp188_ = _tmp187_;
			_tmp189_ = struct_name;
			_tmp190_ = g_strconcat (_tmp189_, "*", NULL);
			_tmp191_ = _tmp190_;
			_tmp192_ = block_id;
			_tmp193_ = g_strdup_printf ("_data%d_", _tmp192_);
			_tmp194_ = _tmp193_;
			_tmp195_ = vala_ccode_variable_declarator_new (_tmp194_, NULL, NULL);
			_tmp196_ = _tmp195_;
			vala_ccode_function_add_declaration (_tmp188_, _tmp191_, (ValaCCodeDeclarator*) _tmp196_, 0);
			_vala_ccode_node_unref0 (_tmp196_);
			_g_free0 (_tmp194_);
			_g_free0 (_tmp191_);
		}
		_tmp197_ = vala_ccode_base_module_get_ccode (self);
		_tmp198_ = _tmp197_;
		_tmp199_ = block_id;
		_tmp200_ = g_strdup_printf ("_data%d_", _tmp199_);
		_tmp201_ = _tmp200_;
		_tmp202_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp201_);
		_tmp203_ = _tmp202_;
		_tmp204_ = data_alloc;
		vala_ccode_function_add_assignment (_tmp198_, _tmp203_, (ValaCCodeExpression*) _tmp204_);
		_vala_ccode_node_unref0 (_tmp203_);
		_g_free0 (_tmp201_);
		_tmp205_ = vala_ccode_base_module_get_ccode (self);
		_tmp206_ = _tmp205_;
		_tmp207_ = block_id;
		_tmp208_ = g_strdup_printf ("_data%d_", _tmp207_);
		_tmp209_ = _tmp208_;
		_tmp210_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp209_);
		_tmp211_ = _tmp210_;
		_tmp212_ = vala_ccode_member_access_new_pointer (_tmp211_, "_ref_count_");
		_tmp213_ = _tmp212_;
		_tmp214_ = vala_ccode_identifier_new ("1");
		_tmp215_ = _tmp214_;
		vala_ccode_function_add_assignment (_tmp206_, (ValaCCodeExpression*) _tmp213_, (ValaCCodeExpression*) _tmp215_);
		_vala_ccode_node_unref0 (_tmp215_);
		_vala_ccode_node_unref0 (_tmp213_);
		_vala_ccode_node_unref0 (_tmp211_);
		_g_free0 (_tmp209_);
		_tmp216_ = parent_block;
		if (_tmp216_ != NULL) {
			gint parent_block_id = 0;
			ValaBlock* _tmp217_;
			gint _tmp218_;
			ValaCCodeFunctionCall* ref_call = NULL;
			gint _tmp219_;
			gchar* _tmp220_;
			gchar* _tmp221_;
			ValaCCodeIdentifier* _tmp222_;
			ValaCCodeIdentifier* _tmp223_;
			ValaCCodeFunctionCall* _tmp224_;
			ValaCCodeFunctionCall* _tmp225_;
			ValaCCodeFunctionCall* _tmp226_;
			gint _tmp227_;
			gchar* _tmp228_;
			gchar* _tmp229_;
			ValaCCodeExpression* _tmp230_;
			ValaCCodeExpression* _tmp231_;
			ValaCCodeFunction* _tmp232_;
			ValaCCodeFunction* _tmp233_;
			gint _tmp234_;
			gchar* _tmp235_;
			gchar* _tmp236_;
			ValaCCodeExpression* _tmp237_;
			ValaCCodeExpression* _tmp238_;
			gint _tmp239_;
			gchar* _tmp240_;
			gchar* _tmp241_;
			ValaCCodeMemberAccess* _tmp242_;
			ValaCCodeMemberAccess* _tmp243_;
			ValaCCodeFunctionCall* _tmp244_;
			_tmp217_ = parent_block;
			_tmp218_ = vala_ccode_base_module_get_block_id (self, _tmp217_);
			parent_block_id = _tmp218_;
			_tmp219_ = parent_block_id;
			_tmp220_ = g_strdup_printf ("block%d_data_ref", _tmp219_);
			_tmp221_ = _tmp220_;
			_tmp222_ = vala_ccode_identifier_new (_tmp221_);
			_tmp223_ = _tmp222_;
			_tmp224_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp223_);
			_tmp225_ = _tmp224_;
			_vala_ccode_node_unref0 (_tmp223_);
			_g_free0 (_tmp221_);
			ref_call = _tmp225_;
			_tmp226_ = ref_call;
			_tmp227_ = parent_block_id;
			_tmp228_ = g_strdup_printf ("_data%d_", _tmp227_);
			_tmp229_ = _tmp228_;
			_tmp230_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp229_);
			_tmp231_ = _tmp230_;
			vala_ccode_function_call_add_argument (_tmp226_, _tmp231_);
			_vala_ccode_node_unref0 (_tmp231_);
			_g_free0 (_tmp229_);
			_tmp232_ = vala_ccode_base_module_get_ccode (self);
			_tmp233_ = _tmp232_;
			_tmp234_ = block_id;
			_tmp235_ = g_strdup_printf ("_data%d_", _tmp234_);
			_tmp236_ = _tmp235_;
			_tmp237_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp236_);
			_tmp238_ = _tmp237_;
			_tmp239_ = parent_block_id;
			_tmp240_ = g_strdup_printf ("_data%d_", _tmp239_);
			_tmp241_ = _tmp240_;
			_tmp242_ = vala_ccode_member_access_new_pointer (_tmp238_, _tmp241_);
			_tmp243_ = _tmp242_;
			_tmp244_ = ref_call;
			vala_ccode_function_add_assignment (_tmp233_, (ValaCCodeExpression*) _tmp243_, (ValaCCodeExpression*) _tmp244_);
			_vala_ccode_node_unref0 (_tmp243_);
			_g_free0 (_tmp241_);
			_vala_ccode_node_unref0 (_tmp238_);
			_g_free0 (_tmp236_);
			_vala_ccode_node_unref0 (ref_call);
		} else {
			gboolean _tmp245_ = FALSE;
			gboolean _tmp246_ = FALSE;
			ValaMethod* _tmp247_;
			ValaMethod* _tmp248_;
			gboolean in_creation_method_with_chainup = FALSE;
			gboolean _tmp255_ = FALSE;
			ValaDataType* _tmp256_;
			ValaDataType* _tmp257_;
			gboolean _tmp258_;
			ValaMethod* _tmp296_;
			ValaMethod* _tmp297_;
			_tmp247_ = vala_ccode_base_module_get_current_method (self);
			_tmp248_ = _tmp247_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp248_, VALA_TYPE_CREATION_METHOD)) {
				ValaClass* _tmp249_;
				ValaClass* _tmp250_;
				_tmp249_ = vala_ccode_base_module_get_current_class (self);
				_tmp250_ = _tmp249_;
				_tmp246_ = _tmp250_ != NULL;
			} else {
				_tmp246_ = FALSE;
			}
			if (_tmp246_) {
				ValaClass* _tmp251_;
				ValaClass* _tmp252_;
				ValaClass* _tmp253_;
				ValaClass* _tmp254_;
				_tmp251_ = vala_ccode_base_module_get_current_class (self);
				_tmp252_ = _tmp251_;
				_tmp253_ = vala_class_get_base_class (_tmp252_);
				_tmp254_ = _tmp253_;
				_tmp245_ = _tmp254_ != NULL;
			} else {
				_tmp245_ = FALSE;
			}
			in_creation_method_with_chainup = _tmp245_;
			_tmp256_ = vala_ccode_base_module_get_this_type (self);
			_tmp257_ = _tmp256_;
			_tmp258_ = _tmp257_ != NULL;
			_vala_code_node_unref0 (_tmp257_);
			if (_tmp258_) {
				gboolean _tmp259_ = FALSE;
				gboolean _tmp260_;
				_tmp260_ = in_creation_method_with_chainup;
				if (!_tmp260_) {
					_tmp259_ = TRUE;
				} else {
					ValaMethod* _tmp261_;
					ValaMethod* _tmp262_;
					ValaBlock* _tmp263_;
					ValaBlock* _tmp264_;
					ValaBlock* _tmp265_;
					_tmp261_ = vala_ccode_base_module_get_current_method (self);
					_tmp262_ = _tmp261_;
					_tmp263_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp262_);
					_tmp264_ = _tmp263_;
					_tmp265_ = b;
					_tmp259_ = _tmp264_ != _tmp265_;
				}
				_tmp255_ = _tmp259_;
			} else {
				_tmp255_ = FALSE;
			}
			if (_tmp255_) {
				ValaCCodeFunctionCall* ref_call = NULL;
				ValaTypeSymbol* _tmp266_;
				ValaTypeSymbol* _tmp267_;
				ValaDataType* _tmp268_;
				ValaDataType* _tmp269_;
				ValaBlock* _tmp270_;
				ValaSourceReference* _tmp271_;
				ValaSourceReference* _tmp272_;
				ValaCCodeExpression* _tmp273_;
				ValaCCodeExpression* _tmp274_;
				ValaCCodeFunctionCall* _tmp275_;
				ValaCCodeFunctionCall* _tmp276_;
				ValaCCodeFunctionCall* _tmp277_;
				ValaCCodeExpression* _tmp278_;
				ValaCCodeExpression* _tmp279_;
				ValaCCodeExpression* _tmp280_ = NULL;
				gboolean _tmp281_;
				ValaCCodeExpression* instance = NULL;
				ValaCCodeExpression* _tmp285_;
				ValaCCodeFunction* _tmp286_;
				ValaCCodeFunction* _tmp287_;
				gint _tmp288_;
				gchar* _tmp289_;
				gchar* _tmp290_;
				ValaCCodeExpression* _tmp291_;
				ValaCCodeExpression* _tmp292_;
				ValaCCodeMemberAccess* _tmp293_;
				ValaCCodeMemberAccess* _tmp294_;
				ValaCCodeExpression* _tmp295_;
				_tmp266_ = vala_ccode_base_module_get_current_type_symbol (self);
				_tmp267_ = _tmp266_;
				_tmp268_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp267_);
				_tmp269_ = _tmp268_;
				_tmp270_ = b;
				_tmp271_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp270_);
				_tmp272_ = _tmp271_;
				_tmp273_ = vala_ccode_base_module_get_dup_func_expression (self, _tmp269_, _tmp272_, FALSE);
				_tmp274_ = _tmp273_;
				_tmp275_ = vala_ccode_function_call_new (_tmp274_);
				_tmp276_ = _tmp275_;
				_vala_ccode_node_unref0 (_tmp274_);
				_vala_code_node_unref0 (_tmp269_);
				ref_call = _tmp276_;
				_tmp277_ = ref_call;
				_tmp278_ = vala_ccode_base_module_get_result_cexpression (self, "self");
				_tmp279_ = _tmp278_;
				vala_ccode_function_call_add_argument (_tmp277_, _tmp279_);
				_vala_ccode_node_unref0 (_tmp279_);
				_tmp281_ = vala_ccode_base_module_is_in_destructor (self);
				if (_tmp281_) {
					ValaCCodeIdentifier* _tmp282_;
					_tmp282_ = vala_ccode_identifier_new ("self");
					_vala_ccode_node_unref0 (_tmp280_);
					_tmp280_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp282_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression);
				} else {
					ValaCCodeFunctionCall* _tmp283_;
					ValaCCodeExpression* _tmp284_;
					_tmp283_ = ref_call;
					_tmp284_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp283_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression));
					_vala_ccode_node_unref0 (_tmp280_);
					_tmp280_ = _tmp284_;
				}
				_tmp285_ = _vala_ccode_node_ref0 (_tmp280_);
				instance = _tmp285_;
				_tmp286_ = vala_ccode_base_module_get_ccode (self);
				_tmp287_ = _tmp286_;
				_tmp288_ = block_id;
				_tmp289_ = g_strdup_printf ("_data%d_", _tmp288_);
				_tmp290_ = _tmp289_;
				_tmp291_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp290_);
				_tmp292_ = _tmp291_;
				_tmp293_ = vala_ccode_member_access_new_pointer (_tmp292_, "self");
				_tmp294_ = _tmp293_;
				_tmp295_ = instance;
				vala_ccode_function_add_assignment (_tmp287_, (ValaCCodeExpression*) _tmp294_, _tmp295_);
				_vala_ccode_node_unref0 (_tmp294_);
				_vala_ccode_node_unref0 (_tmp292_);
				_g_free0 (_tmp290_);
				_vala_ccode_node_unref0 (instance);
				_vala_ccode_node_unref0 (_tmp280_);
				_vala_ccode_node_unref0 (ref_call);
			}
			_tmp296_ = vala_ccode_base_module_get_current_method (self);
			_tmp297_ = _tmp296_;
			if (_tmp297_ != NULL) {
				gchar** suffices = NULL;
				gchar* _tmp298_;
				gchar* _tmp299_;
				gchar* _tmp300_;
				gchar** _tmp301_;
				gint suffices_length1;
				gint _suffices_size_;
				_tmp298_ = g_strdup ("type");
				_tmp299_ = g_strdup ("dup_func");
				_tmp300_ = g_strdup ("destroy_func");
				_tmp301_ = g_new0 (gchar*, 3 + 1);
				_tmp301_[0] = _tmp298_;
				_tmp301_[1] = _tmp299_;
				_tmp301_[2] = _tmp300_;
				suffices = _tmp301_;
				suffices_length1 = 3;
				_suffices_size_ = suffices_length1;
				{
					ValaList* _type_param_list = NULL;
					ValaMethod* _tmp302_;
					ValaMethod* _tmp303_;
					ValaList* _tmp304_;
					gint _type_param_size = 0;
					ValaList* _tmp305_;
					gint _tmp306_;
					gint _tmp307_;
					gint _type_param_index = 0;
					_tmp302_ = vala_ccode_base_module_get_current_method (self);
					_tmp303_ = _tmp302_;
					_tmp304_ = vala_method_get_type_parameters (_tmp303_);
					_type_param_list = _tmp304_;
					_tmp305_ = _type_param_list;
					_tmp306_ = vala_collection_get_size ((ValaCollection*) _tmp305_);
					_tmp307_ = _tmp306_;
					_type_param_size = _tmp307_;
					_type_param_index = -1;
					while (TRUE) {
						gint _tmp308_;
						gint _tmp309_;
						gint _tmp310_;
						ValaTypeParameter* type_param = NULL;
						ValaList* _tmp311_;
						gint _tmp312_;
						gpointer _tmp313_;
						gchar** _tmp314_;
						gint _tmp314__length1;
						_tmp308_ = _type_param_index;
						_type_param_index = _tmp308_ + 1;
						_tmp309_ = _type_param_index;
						_tmp310_ = _type_param_size;
						if (!(_tmp309_ < _tmp310_)) {
							break;
						}
						_tmp311_ = _type_param_list;
						_tmp312_ = _type_param_index;
						_tmp313_ = vala_list_get (_tmp311_, _tmp312_);
						type_param = (ValaTypeParameter*) _tmp313_;
						_tmp314_ = suffices;
						_tmp314__length1 = suffices_length1;
						{
							gchar** suffix_collection = NULL;
							gint suffix_collection_length1 = 0;
							gint _suffix_collection_size_ = 0;
							gint suffix_it = 0;
							suffix_collection = _tmp314_;
							suffix_collection_length1 = _tmp314__length1;
							for (suffix_it = 0; suffix_it < _tmp314__length1; suffix_it = suffix_it + 1) {
								gchar* _tmp315_;
								gchar* suffix = NULL;
								_tmp315_ = g_strdup (suffix_collection[suffix_it]);
								suffix = _tmp315_;
								{
									gchar* func_name = NULL;
									ValaTypeParameter* _tmp316_;
									const gchar* _tmp317_;
									const gchar* _tmp318_;
									gchar* _tmp319_;
									gchar* _tmp320_;
									const gchar* _tmp321_;
									gchar* _tmp322_;
									gchar* _tmp323_;
									ValaCCodeFunction* _tmp324_;
									ValaCCodeFunction* _tmp325_;
									gint _tmp326_;
									gchar* _tmp327_;
									gchar* _tmp328_;
									ValaCCodeExpression* _tmp329_;
									ValaCCodeExpression* _tmp330_;
									const gchar* _tmp331_;
									ValaCCodeMemberAccess* _tmp332_;
									ValaCCodeMemberAccess* _tmp333_;
									const gchar* _tmp334_;
									ValaCCodeExpression* _tmp335_;
									ValaCCodeExpression* _tmp336_;
									_tmp316_ = type_param;
									_tmp317_ = vala_symbol_get_name ((ValaSymbol*) _tmp316_);
									_tmp318_ = _tmp317_;
									_tmp319_ = g_utf8_strdown (_tmp318_, (gssize) -1);
									_tmp320_ = _tmp319_;
									_tmp321_ = suffix;
									_tmp322_ = g_strdup_printf ("%s_%s", _tmp320_, _tmp321_);
									_tmp323_ = _tmp322_;
									_g_free0 (_tmp320_);
									func_name = _tmp323_;
									_tmp324_ = vala_ccode_base_module_get_ccode (self);
									_tmp325_ = _tmp324_;
									_tmp326_ = block_id;
									_tmp327_ = g_strdup_printf ("_data%d_", _tmp326_);
									_tmp328_ = _tmp327_;
									_tmp329_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp328_);
									_tmp330_ = _tmp329_;
									_tmp331_ = func_name;
									_tmp332_ = vala_ccode_member_access_new_pointer (_tmp330_, _tmp331_);
									_tmp333_ = _tmp332_;
									_tmp334_ = func_name;
									_tmp335_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp334_);
									_tmp336_ = _tmp335_;
									vala_ccode_function_add_assignment (_tmp325_, (ValaCCodeExpression*) _tmp333_, _tmp336_);
									_vala_ccode_node_unref0 (_tmp336_);
									_vala_ccode_node_unref0 (_tmp333_);
									_vala_ccode_node_unref0 (_tmp330_);
									_g_free0 (_tmp328_);
									_g_free0 (func_name);
									_g_free0 (suffix);
								}
							}
						}
						_vala_code_node_unref0 (type_param);
					}
					_vala_iterable_unref0 (_type_param_list);
				}
				suffices = (_vala_array_free (suffices, suffices_length1, (GDestroyNotify) g_free), NULL);
			}
		}
		_tmp337_ = b;
		_tmp338_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp337_);
		_tmp339_ = _tmp338_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp339_, VALA_TYPE_METHOD)) {
			ValaMethod* m = NULL;
			ValaBlock* _tmp340_;
			ValaSymbol* _tmp341_;
			ValaSymbol* _tmp342_;
			ValaMethod* _tmp343_;
			ValaMethod* _tmp361_;
			gboolean _tmp362_;
			gboolean _tmp363_;
			_tmp340_ = b;
			_tmp341_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp340_);
			_tmp342_ = _tmp341_;
			_tmp343_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp342_, VALA_TYPE_METHOD, ValaMethod));
			m = _tmp343_;
			{
				ValaList* _param_list = NULL;
				ValaMethod* _tmp344_;
				ValaList* _tmp345_;
				gint _param_size = 0;
				ValaList* _tmp346_;
				gint _tmp347_;
				gint _tmp348_;
				gint _param_index = 0;
				_tmp344_ = m;
				_tmp345_ = vala_callable_get_parameters ((ValaCallable*) _tmp344_);
				_param_list = _tmp345_;
				_tmp346_ = _param_list;
				_tmp347_ = vala_collection_get_size ((ValaCollection*) _tmp346_);
				_tmp348_ = _tmp347_;
				_param_size = _tmp348_;
				_param_index = -1;
				while (TRUE) {
					gint _tmp349_;
					gint _tmp350_;
					gint _tmp351_;
					ValaParameter* param = NULL;
					ValaList* _tmp352_;
					gint _tmp353_;
					gpointer _tmp354_;
					ValaParameter* _tmp355_;
					gboolean _tmp356_;
					gboolean _tmp357_;
					_tmp349_ = _param_index;
					_param_index = _tmp349_ + 1;
					_tmp350_ = _param_index;
					_tmp351_ = _param_size;
					if (!(_tmp350_ < _tmp351_)) {
						break;
					}
					_tmp352_ = _param_list;
					_tmp353_ = _param_index;
					_tmp354_ = vala_list_get (_tmp352_, _tmp353_);
					param = (ValaParameter*) _tmp354_;
					_tmp355_ = param;
					_tmp356_ = vala_parameter_get_captured (_tmp355_);
					_tmp357_ = _tmp356_;
					if (_tmp357_) {
						ValaParameter* _tmp358_;
						ValaCCodeStruct* _tmp359_;
						gint _tmp360_;
						_tmp358_ = param;
						_tmp359_ = data;
						_tmp360_ = block_id;
						vala_ccode_base_module_capture_parameter (self, _tmp358_, _tmp359_, _tmp360_);
					}
					_vala_code_node_unref0 (param);
				}
				_vala_iterable_unref0 (_param_list);
			}
			_tmp361_ = m;
			_tmp362_ = vala_method_get_coroutine (_tmp361_);
			_tmp363_ = _tmp362_;
			if (_tmp363_) {
				ValaCCodeStruct* _tmp364_;
				ValaCCodeFunction* _tmp365_;
				ValaCCodeFunction* _tmp366_;
				gint _tmp367_;
				gchar* _tmp368_;
				gchar* _tmp369_;
				ValaCCodeExpression* _tmp370_;
				ValaCCodeExpression* _tmp371_;
				ValaCCodeMemberAccess* _tmp372_;
				ValaCCodeMemberAccess* _tmp373_;
				ValaCCodeIdentifier* _tmp374_;
				ValaCCodeIdentifier* _tmp375_;
				_tmp364_ = data;
				vala_ccode_struct_add_field (_tmp364_, "gpointer", "_async_data_", 0, NULL);
				_tmp365_ = vala_ccode_base_module_get_ccode (self);
				_tmp366_ = _tmp365_;
				_tmp367_ = block_id;
				_tmp368_ = g_strdup_printf ("_data%d_", _tmp367_);
				_tmp369_ = _tmp368_;
				_tmp370_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp369_);
				_tmp371_ = _tmp370_;
				_tmp372_ = vala_ccode_member_access_new_pointer (_tmp371_, "_async_data_");
				_tmp373_ = _tmp372_;
				_tmp374_ = vala_ccode_identifier_new ("_data_");
				_tmp375_ = _tmp374_;
				vala_ccode_function_add_assignment (_tmp366_, (ValaCCodeExpression*) _tmp373_, (ValaCCodeExpression*) _tmp375_);
				_vala_ccode_node_unref0 (_tmp375_);
				_vala_ccode_node_unref0 (_tmp373_);
				_vala_ccode_node_unref0 (_tmp371_);
				_g_free0 (_tmp369_);
			}
			_vala_code_node_unref0 (m);
		} else {
			ValaBlock* _tmp376_;
			ValaSymbol* _tmp377_;
			ValaSymbol* _tmp378_;
			_tmp376_ = b;
			_tmp377_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp376_);
			_tmp378_ = _tmp377_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp378_, VALA_TYPE_PROPERTY_ACCESSOR)) {
				ValaPropertyAccessor* acc = NULL;
				ValaBlock* _tmp379_;
				ValaSymbol* _tmp380_;
				ValaSymbol* _tmp381_;
				ValaPropertyAccessor* _tmp382_;
				gboolean _tmp383_ = FALSE;
				ValaPropertyAccessor* _tmp384_;
				gboolean _tmp385_;
				gboolean _tmp386_;
				_tmp379_ = b;
				_tmp380_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp379_);
				_tmp381_ = _tmp380_;
				_tmp382_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp381_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
				acc = _tmp382_;
				_tmp384_ = acc;
				_tmp385_ = vala_property_accessor_get_readable (_tmp384_);
				_tmp386_ = _tmp385_;
				if (!_tmp386_) {
					ValaPropertyAccessor* _tmp387_;
					ValaParameter* _tmp388_;
					ValaParameter* _tmp389_;
					gboolean _tmp390_;
					gboolean _tmp391_;
					_tmp387_ = acc;
					_tmp388_ = vala_property_accessor_get_value_parameter (_tmp387_);
					_tmp389_ = _tmp388_;
					_tmp390_ = vala_parameter_get_captured (_tmp389_);
					_tmp391_ = _tmp390_;
					_tmp383_ = _tmp391_;
				} else {
					_tmp383_ = FALSE;
				}
				if (_tmp383_) {
					ValaPropertyAccessor* _tmp392_;
					ValaParameter* _tmp393_;
					ValaParameter* _tmp394_;
					ValaCCodeStruct* _tmp395_;
					gint _tmp396_;
					_tmp392_ = acc;
					_tmp393_ = vala_property_accessor_get_value_parameter (_tmp392_);
					_tmp394_ = _tmp393_;
					_tmp395_ = data;
					_tmp396_ = block_id;
					vala_ccode_base_module_capture_parameter (self, _tmp394_, _tmp395_, _tmp396_);
				}
				_vala_code_node_unref0 (acc);
			} else {
				ValaBlock* _tmp397_;
				ValaSymbol* _tmp398_;
				ValaSymbol* _tmp399_;
				_tmp397_ = b;
				_tmp398_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp397_);
				_tmp399_ = _tmp398_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp399_, VALA_TYPE_FOREACH_STATEMENT)) {
					ValaForeachStatement* stmt = NULL;
					ValaBlock* _tmp400_;
					ValaSymbol* _tmp401_;
					ValaSymbol* _tmp402_;
					ValaForeachStatement* _tmp403_;
					gboolean _tmp404_ = FALSE;
					ValaForeachStatement* _tmp405_;
					gboolean _tmp406_;
					gboolean _tmp407_;
					_tmp400_ = b;
					_tmp401_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp400_);
					_tmp402_ = _tmp401_;
					_tmp403_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp402_, VALA_TYPE_FOREACH_STATEMENT, ValaForeachStatement));
					stmt = _tmp403_;
					_tmp405_ = stmt;
					_tmp406_ = vala_foreach_statement_get_use_iterator (_tmp405_);
					_tmp407_ = _tmp406_;
					if (!_tmp407_) {
						ValaForeachStatement* _tmp408_;
						ValaLocalVariable* _tmp409_;
						ValaLocalVariable* _tmp410_;
						gboolean _tmp411_;
						gboolean _tmp412_;
						_tmp408_ = stmt;
						_tmp409_ = vala_foreach_statement_get_element_variable (_tmp408_);
						_tmp410_ = _tmp409_;
						_tmp411_ = vala_local_variable_get_captured (_tmp410_);
						_tmp412_ = _tmp411_;
						_tmp404_ = _tmp412_;
					} else {
						_tmp404_ = FALSE;
					}
					if (_tmp404_) {
						ValaCCodeFunction* _tmp413_;
						ValaCCodeFunction* _tmp414_;
						gint _tmp415_;
						gchar* _tmp416_;
						gchar* _tmp417_;
						ValaCCodeExpression* _tmp418_;
						ValaCCodeExpression* _tmp419_;
						ValaForeachStatement* _tmp420_;
						ValaLocalVariable* _tmp421_;
						ValaLocalVariable* _tmp422_;
						gchar* _tmp423_;
						gchar* _tmp424_;
						ValaCCodeMemberAccess* _tmp425_;
						ValaCCodeMemberAccess* _tmp426_;
						ValaForeachStatement* _tmp427_;
						ValaLocalVariable* _tmp428_;
						ValaLocalVariable* _tmp429_;
						gchar* _tmp430_;
						gchar* _tmp431_;
						ValaCCodeExpression* _tmp432_;
						ValaCCodeExpression* _tmp433_;
						_tmp413_ = vala_ccode_base_module_get_ccode (self);
						_tmp414_ = _tmp413_;
						_tmp415_ = block_id;
						_tmp416_ = g_strdup_printf ("_data%d_", _tmp415_);
						_tmp417_ = _tmp416_;
						_tmp418_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp417_);
						_tmp419_ = _tmp418_;
						_tmp420_ = stmt;
						_tmp421_ = vala_foreach_statement_get_element_variable (_tmp420_);
						_tmp422_ = _tmp421_;
						_tmp423_ = vala_ccode_base_module_get_local_cname (self, _tmp422_);
						_tmp424_ = _tmp423_;
						_tmp425_ = vala_ccode_member_access_new_pointer (_tmp419_, _tmp424_);
						_tmp426_ = _tmp425_;
						_tmp427_ = stmt;
						_tmp428_ = vala_foreach_statement_get_element_variable (_tmp427_);
						_tmp429_ = _tmp428_;
						_tmp430_ = vala_ccode_base_module_get_local_cname (self, _tmp429_);
						_tmp431_ = _tmp430_;
						_tmp432_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp431_);
						_tmp433_ = _tmp432_;
						vala_ccode_function_add_assignment (_tmp414_, (ValaCCodeExpression*) _tmp426_, _tmp433_);
						_vala_ccode_node_unref0 (_tmp433_);
						_g_free0 (_tmp431_);
						_vala_ccode_node_unref0 (_tmp426_);
						_g_free0 (_tmp424_);
						_vala_ccode_node_unref0 (_tmp419_);
						_g_free0 (_tmp417_);
					}
					_vala_code_node_unref0 (stmt);
				}
			}
		}
		_tmp434_ = struct_name;
		_tmp435_ = g_strconcat ("struct _", _tmp434_, NULL);
		_tmp436_ = _tmp435_;
		_tmp437_ = struct_name;
		_tmp438_ = vala_ccode_variable_declarator_new (_tmp437_, NULL, NULL);
		_tmp439_ = _tmp438_;
		_tmp440_ = vala_ccode_type_definition_new (_tmp436_, (ValaCCodeDeclarator*) _tmp439_);
		_tmp441_ = _tmp440_;
		_vala_ccode_node_unref0 (_tmp439_);
		_g_free0 (_tmp436_);
		_typedef_ = _tmp441_;
		_tmp442_ = self->cfile;
		_tmp443_ = _typedef_;
		vala_ccode_file_add_type_declaration (_tmp442_, (ValaCCodeNode*) _tmp443_);
		_tmp444_ = self->cfile;
		_tmp445_ = data;
		vala_ccode_file_add_type_definition (_tmp444_, (ValaCCodeNode*) _tmp445_);
		_tmp446_ = block_id;
		_tmp447_ = g_strdup_printf ("block%d_data_ref", _tmp446_);
		_tmp448_ = _tmp447_;
		_tmp449_ = struct_name;
		_tmp450_ = g_strconcat (_tmp449_, "*", NULL);
		_tmp451_ = _tmp450_;
		_tmp452_ = vala_ccode_function_new (_tmp448_, _tmp451_);
		_tmp453_ = _tmp452_;
		_g_free0 (_tmp451_);
		_g_free0 (_tmp448_);
		ref_fun = _tmp453_;
		_tmp454_ = ref_fun;
		_tmp455_ = block_id;
		_tmp456_ = g_strdup_printf ("_data%d_", _tmp455_);
		_tmp457_ = _tmp456_;
		_tmp458_ = struct_name;
		_tmp459_ = g_strconcat (_tmp458_, "*", NULL);
		_tmp460_ = _tmp459_;
		_tmp461_ = vala_ccode_parameter_new (_tmp457_, _tmp460_);
		_tmp462_ = _tmp461_;
		vala_ccode_function_add_parameter (_tmp454_, _tmp462_);
		_vala_ccode_node_unref0 (_tmp462_);
		_g_free0 (_tmp460_);
		_g_free0 (_tmp457_);
		_tmp463_ = ref_fun;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp463_, VALA_CCODE_MODIFIERS_STATIC);
		_tmp464_ = ref_fun;
		vala_ccode_base_module_push_function (self, _tmp464_);
		_tmp465_ = vala_ccode_identifier_new ("g_atomic_int_inc");
		_tmp466_ = _tmp465_;
		_tmp467_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp466_);
		_tmp468_ = _tmp467_;
		_vala_ccode_node_unref0 (_tmp466_);
		ccall = _tmp468_;
		_tmp469_ = ccall;
		_tmp470_ = block_id;
		_tmp471_ = g_strdup_printf ("_data%d_", _tmp470_);
		_tmp472_ = _tmp471_;
		_tmp473_ = vala_ccode_identifier_new (_tmp472_);
		_tmp474_ = _tmp473_;
		_tmp475_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp474_, "_ref_count_");
		_tmp476_ = _tmp475_;
		_tmp477_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp476_);
		_tmp478_ = _tmp477_;
		vala_ccode_function_call_add_argument (_tmp469_, (ValaCCodeExpression*) _tmp478_);
		_vala_ccode_node_unref0 (_tmp478_);
		_vala_ccode_node_unref0 (_tmp476_);
		_vala_ccode_node_unref0 (_tmp474_);
		_g_free0 (_tmp472_);
		_tmp479_ = vala_ccode_base_module_get_ccode (self);
		_tmp480_ = _tmp479_;
		_tmp481_ = ccall;
		vala_ccode_function_add_expression (_tmp480_, (ValaCCodeExpression*) _tmp481_);
		_tmp482_ = vala_ccode_base_module_get_ccode (self);
		_tmp483_ = _tmp482_;
		_tmp484_ = block_id;
		_tmp485_ = g_strdup_printf ("_data%d_", _tmp484_);
		_tmp486_ = _tmp485_;
		_tmp487_ = vala_ccode_identifier_new (_tmp486_);
		_tmp488_ = _tmp487_;
		vala_ccode_function_add_return (_tmp483_, (ValaCCodeExpression*) _tmp488_);
		_vala_ccode_node_unref0 (_tmp488_);
		_g_free0 (_tmp486_);
		vala_ccode_base_module_pop_function (self);
		_tmp489_ = self->cfile;
		_tmp490_ = ref_fun;
		vala_ccode_file_add_function_declaration (_tmp489_, _tmp490_);
		_tmp491_ = self->cfile;
		_tmp492_ = ref_fun;
		vala_ccode_file_add_function (_tmp491_, _tmp492_);
		_tmp493_ = block_id;
		_tmp494_ = g_strdup_printf ("block%d_data_unref", _tmp493_);
		_tmp495_ = _tmp494_;
		_tmp496_ = vala_ccode_function_new (_tmp495_, "void");
		_tmp497_ = _tmp496_;
		_g_free0 (_tmp495_);
		unref_fun = _tmp497_;
		_tmp498_ = unref_fun;
		_tmp499_ = vala_ccode_parameter_new ("_userdata_", "void *");
		_tmp500_ = _tmp499_;
		vala_ccode_function_add_parameter (_tmp498_, _tmp500_);
		_vala_ccode_node_unref0 (_tmp500_);
		_tmp501_ = unref_fun;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp501_, VALA_CCODE_MODIFIERS_STATIC);
		_tmp502_ = unref_fun;
		vala_ccode_base_module_push_function (self, _tmp502_);
		_tmp503_ = vala_ccode_base_module_get_ccode (self);
		_tmp504_ = _tmp503_;
		_tmp505_ = struct_name;
		_tmp506_ = g_strconcat (_tmp505_, "*", NULL);
		_tmp507_ = _tmp506_;
		_tmp508_ = block_id;
		_tmp509_ = g_strdup_printf ("_data%d_", _tmp508_);
		_tmp510_ = _tmp509_;
		_tmp511_ = vala_ccode_identifier_new ("_userdata_");
		_tmp512_ = _tmp511_;
		_tmp513_ = struct_name;
		_tmp514_ = g_strconcat (_tmp513_, "*", NULL);
		_tmp515_ = _tmp514_;
		_tmp516_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp512_, _tmp515_);
		_tmp517_ = _tmp516_;
		_tmp518_ = vala_ccode_variable_declarator_new (_tmp510_, (ValaCCodeExpression*) _tmp517_, NULL);
		_tmp519_ = _tmp518_;
		vala_ccode_function_add_declaration (_tmp504_, _tmp507_, (ValaCCodeDeclarator*) _tmp519_, 0);
		_vala_ccode_node_unref0 (_tmp519_);
		_vala_ccode_node_unref0 (_tmp517_);
		_g_free0 (_tmp515_);
		_vala_ccode_node_unref0 (_tmp512_);
		_g_free0 (_tmp510_);
		_g_free0 (_tmp507_);
		_tmp520_ = vala_ccode_identifier_new ("g_atomic_int_dec_and_test");
		_tmp521_ = _tmp520_;
		_tmp522_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp521_);
		_vala_ccode_node_unref0 (ccall);
		ccall = _tmp522_;
		_vala_ccode_node_unref0 (_tmp521_);
		_tmp523_ = ccall;
		_tmp524_ = block_id;
		_tmp525_ = g_strdup_printf ("_data%d_", _tmp524_);
		_tmp526_ = _tmp525_;
		_tmp527_ = vala_ccode_identifier_new (_tmp526_);
		_tmp528_ = _tmp527_;
		_tmp529_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp528_, "_ref_count_");
		_tmp530_ = _tmp529_;
		_tmp531_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp530_);
		_tmp532_ = _tmp531_;
		vala_ccode_function_call_add_argument (_tmp523_, (ValaCCodeExpression*) _tmp532_);
		_vala_ccode_node_unref0 (_tmp532_);
		_vala_ccode_node_unref0 (_tmp530_);
		_vala_ccode_node_unref0 (_tmp528_);
		_g_free0 (_tmp526_);
		_tmp533_ = vala_ccode_base_module_get_ccode (self);
		_tmp534_ = _tmp533_;
		_tmp535_ = ccall;
		vala_ccode_function_open_if (_tmp534_, (ValaCCodeExpression*) _tmp535_);
		_tmp536_ = block_id;
		_tmp537_ = g_strdup_printf ("_data%d_", _tmp536_);
		_tmp538_ = _tmp537_;
		_tmp539_ = vala_ccode_identifier_new (_tmp538_);
		_tmp540_ = (ValaCCodeExpression*) _tmp539_;
		_g_free0 (_tmp538_);
		outer_block = _tmp540_;
		_tmp541_ = b;
		parent_closure_block = _tmp541_;
		while (TRUE) {
			ValaBlock* _tmp542_;
			ValaSymbol* _tmp543_;
			ValaSymbol* _tmp544_;
			ValaBlock* _tmp545_;
			ValaBlock* _tmp546_;
			gint parent_block_id = 0;
			ValaBlock* _tmp547_;
			gint _tmp548_;
			ValaCCodeExpression* _tmp549_;
			gint _tmp550_;
			gchar* _tmp551_;
			gchar* _tmp552_;
			ValaCCodeMemberAccess* _tmp553_;
			_tmp542_ = parent_closure_block;
			_tmp543_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp542_);
			_tmp544_ = _tmp543_;
			_tmp545_ = vala_ccode_base_module_next_closure_block (self, _tmp544_);
			parent_closure_block = _tmp545_;
			_tmp546_ = parent_closure_block;
			if (_tmp546_ == NULL) {
				break;
			}
			_tmp547_ = parent_closure_block;
			_tmp548_ = vala_ccode_base_module_get_block_id (self, _tmp547_);
			parent_block_id = _tmp548_;
			_tmp549_ = outer_block;
			_tmp550_ = parent_block_id;
			_tmp551_ = g_strdup_printf ("_data%d_", _tmp550_);
			_tmp552_ = _tmp551_;
			_tmp553_ = vala_ccode_member_access_new_pointer (_tmp549_, _tmp552_);
			_vala_ccode_node_unref0 (outer_block);
			outer_block = (ValaCCodeExpression*) _tmp553_;
			_g_free0 (_tmp552_);
		}
		_tmp554_ = vala_ccode_base_module_get_this_type (self);
		_tmp555_ = _tmp554_;
		_tmp556_ = _tmp555_ != NULL;
		_vala_code_node_unref0 (_tmp555_);
		if (_tmp556_) {
			ValaCCodeFunction* _tmp557_;
			ValaCCodeFunction* _tmp558_;
			ValaTypeSymbol* _tmp559_;
			ValaTypeSymbol* _tmp560_;
			ValaDataType* _tmp561_;
			ValaDataType* _tmp562_;
			gchar* _tmp563_;
			gchar* _tmp564_;
			ValaCCodeVariableDeclarator* _tmp565_;
			ValaCCodeVariableDeclarator* _tmp566_;
			ValaCCodeFunction* _tmp567_;
			ValaCCodeFunction* _tmp568_;
			ValaCCodeIdentifier* _tmp569_;
			ValaCCodeIdentifier* _tmp570_;
			ValaCCodeExpression* _tmp571_;
			ValaCCodeMemberAccess* _tmp572_;
			ValaCCodeMemberAccess* _tmp573_;
			_tmp557_ = vala_ccode_base_module_get_ccode (self);
			_tmp558_ = _tmp557_;
			_tmp559_ = vala_ccode_base_module_get_current_type_symbol (self);
			_tmp560_ = _tmp559_;
			_tmp561_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp560_);
			_tmp562_ = _tmp561_;
			_tmp563_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp562_);
			_tmp564_ = _tmp563_;
			_tmp565_ = vala_ccode_variable_declarator_new ("self", NULL, NULL);
			_tmp566_ = _tmp565_;
			vala_ccode_function_add_declaration (_tmp558_, _tmp564_, (ValaCCodeDeclarator*) _tmp566_, 0);
			_vala_ccode_node_unref0 (_tmp566_);
			_g_free0 (_tmp564_);
			_vala_code_node_unref0 (_tmp562_);
			_tmp567_ = vala_ccode_base_module_get_ccode (self);
			_tmp568_ = _tmp567_;
			_tmp569_ = vala_ccode_identifier_new ("self");
			_tmp570_ = _tmp569_;
			_tmp571_ = outer_block;
			_tmp572_ = vala_ccode_member_access_new_pointer (_tmp571_, "self");
			_tmp573_ = _tmp572_;
			vala_ccode_function_add_assignment (_tmp568_, (ValaCCodeExpression*) _tmp570_, (ValaCCodeExpression*) _tmp573_);
			_vala_ccode_node_unref0 (_tmp573_);
			_vala_ccode_node_unref0 (_tmp570_);
		}
		_tmp574_ = vala_ccode_base_module_get_current_method (self);
		_tmp575_ = _tmp574_;
		if (_tmp575_ != NULL) {
			{
				ValaList* _type_param_list = NULL;
				ValaMethod* _tmp576_;
				ValaMethod* _tmp577_;
				ValaList* _tmp578_;
				gint _type_param_size = 0;
				ValaList* _tmp579_;
				gint _tmp580_;
				gint _tmp581_;
				gint _type_param_index = 0;
				_tmp576_ = vala_ccode_base_module_get_current_method (self);
				_tmp577_ = _tmp576_;
				_tmp578_ = vala_method_get_type_parameters (_tmp577_);
				_type_param_list = _tmp578_;
				_tmp579_ = _type_param_list;
				_tmp580_ = vala_collection_get_size ((ValaCollection*) _tmp579_);
				_tmp581_ = _tmp580_;
				_type_param_size = _tmp581_;
				_type_param_index = -1;
				while (TRUE) {
					gint _tmp582_;
					gint _tmp583_;
					gint _tmp584_;
					ValaTypeParameter* type_param = NULL;
					ValaList* _tmp585_;
					gint _tmp586_;
					gpointer _tmp587_;
					gchar* func_name = NULL;
					ValaTypeParameter* _tmp588_;
					const gchar* _tmp589_;
					const gchar* _tmp590_;
					gchar* _tmp591_;
					gchar* _tmp592_;
					gchar* _tmp593_;
					ValaCCodeFunction* _tmp594_;
					ValaCCodeFunction* _tmp595_;
					const gchar* _tmp596_;
					ValaCCodeVariableDeclarator* _tmp597_;
					ValaCCodeVariableDeclarator* _tmp598_;
					ValaCCodeFunction* _tmp599_;
					ValaCCodeFunction* _tmp600_;
					const gchar* _tmp601_;
					ValaCCodeIdentifier* _tmp602_;
					ValaCCodeIdentifier* _tmp603_;
					ValaCCodeExpression* _tmp604_;
					const gchar* _tmp605_;
					ValaCCodeMemberAccess* _tmp606_;
					ValaCCodeMemberAccess* _tmp607_;
					ValaTypeParameter* _tmp608_;
					const gchar* _tmp609_;
					const gchar* _tmp610_;
					gchar* _tmp611_;
					gchar* _tmp612_;
					gchar* _tmp613_;
					ValaCCodeFunction* _tmp614_;
					ValaCCodeFunction* _tmp615_;
					const gchar* _tmp616_;
					ValaCCodeVariableDeclarator* _tmp617_;
					ValaCCodeVariableDeclarator* _tmp618_;
					ValaCCodeFunction* _tmp619_;
					ValaCCodeFunction* _tmp620_;
					const gchar* _tmp621_;
					ValaCCodeIdentifier* _tmp622_;
					ValaCCodeIdentifier* _tmp623_;
					ValaCCodeExpression* _tmp624_;
					const gchar* _tmp625_;
					ValaCCodeMemberAccess* _tmp626_;
					ValaCCodeMemberAccess* _tmp627_;
					ValaTypeParameter* _tmp628_;
					const gchar* _tmp629_;
					const gchar* _tmp630_;
					gchar* _tmp631_;
					gchar* _tmp632_;
					gchar* _tmp633_;
					ValaCCodeFunction* _tmp634_;
					ValaCCodeFunction* _tmp635_;
					const gchar* _tmp636_;
					ValaCCodeVariableDeclarator* _tmp637_;
					ValaCCodeVariableDeclarator* _tmp638_;
					ValaCCodeFunction* _tmp639_;
					ValaCCodeFunction* _tmp640_;
					const gchar* _tmp641_;
					ValaCCodeIdentifier* _tmp642_;
					ValaCCodeIdentifier* _tmp643_;
					ValaCCodeExpression* _tmp644_;
					const gchar* _tmp645_;
					ValaCCodeMemberAccess* _tmp646_;
					ValaCCodeMemberAccess* _tmp647_;
					_tmp582_ = _type_param_index;
					_type_param_index = _tmp582_ + 1;
					_tmp583_ = _type_param_index;
					_tmp584_ = _type_param_size;
					if (!(_tmp583_ < _tmp584_)) {
						break;
					}
					_tmp585_ = _type_param_list;
					_tmp586_ = _type_param_index;
					_tmp587_ = vala_list_get (_tmp585_, _tmp586_);
					type_param = (ValaTypeParameter*) _tmp587_;
					_tmp588_ = type_param;
					_tmp589_ = vala_symbol_get_name ((ValaSymbol*) _tmp588_);
					_tmp590_ = _tmp589_;
					_tmp591_ = g_utf8_strdown (_tmp590_, (gssize) -1);
					_tmp592_ = _tmp591_;
					_tmp593_ = g_strdup_printf ("%s_type", _tmp592_);
					_g_free0 (func_name);
					func_name = _tmp593_;
					_g_free0 (_tmp592_);
					_tmp594_ = vala_ccode_base_module_get_ccode (self);
					_tmp595_ = _tmp594_;
					_tmp596_ = func_name;
					_tmp597_ = vala_ccode_variable_declarator_new (_tmp596_, NULL, NULL);
					_tmp598_ = _tmp597_;
					vala_ccode_function_add_declaration (_tmp595_, "GType", (ValaCCodeDeclarator*) _tmp598_, 0);
					_vala_ccode_node_unref0 (_tmp598_);
					_tmp599_ = vala_ccode_base_module_get_ccode (self);
					_tmp600_ = _tmp599_;
					_tmp601_ = func_name;
					_tmp602_ = vala_ccode_identifier_new (_tmp601_);
					_tmp603_ = _tmp602_;
					_tmp604_ = outer_block;
					_tmp605_ = func_name;
					_tmp606_ = vala_ccode_member_access_new_pointer (_tmp604_, _tmp605_);
					_tmp607_ = _tmp606_;
					vala_ccode_function_add_assignment (_tmp600_, (ValaCCodeExpression*) _tmp603_, (ValaCCodeExpression*) _tmp607_);
					_vala_ccode_node_unref0 (_tmp607_);
					_vala_ccode_node_unref0 (_tmp603_);
					_tmp608_ = type_param;
					_tmp609_ = vala_symbol_get_name ((ValaSymbol*) _tmp608_);
					_tmp610_ = _tmp609_;
					_tmp611_ = g_utf8_strdown (_tmp610_, (gssize) -1);
					_tmp612_ = _tmp611_;
					_tmp613_ = g_strdup_printf ("%s_dup_func", _tmp612_);
					_g_free0 (func_name);
					func_name = _tmp613_;
					_g_free0 (_tmp612_);
					_tmp614_ = vala_ccode_base_module_get_ccode (self);
					_tmp615_ = _tmp614_;
					_tmp616_ = func_name;
					_tmp617_ = vala_ccode_variable_declarator_new (_tmp616_, NULL, NULL);
					_tmp618_ = _tmp617_;
					vala_ccode_function_add_declaration (_tmp615_, "GBoxedCopyFunc", (ValaCCodeDeclarator*) _tmp618_, 0);
					_vala_ccode_node_unref0 (_tmp618_);
					_tmp619_ = vala_ccode_base_module_get_ccode (self);
					_tmp620_ = _tmp619_;
					_tmp621_ = func_name;
					_tmp622_ = vala_ccode_identifier_new (_tmp621_);
					_tmp623_ = _tmp622_;
					_tmp624_ = outer_block;
					_tmp625_ = func_name;
					_tmp626_ = vala_ccode_member_access_new_pointer (_tmp624_, _tmp625_);
					_tmp627_ = _tmp626_;
					vala_ccode_function_add_assignment (_tmp620_, (ValaCCodeExpression*) _tmp623_, (ValaCCodeExpression*) _tmp627_);
					_vala_ccode_node_unref0 (_tmp627_);
					_vala_ccode_node_unref0 (_tmp623_);
					_tmp628_ = type_param;
					_tmp629_ = vala_symbol_get_name ((ValaSymbol*) _tmp628_);
					_tmp630_ = _tmp629_;
					_tmp631_ = g_utf8_strdown (_tmp630_, (gssize) -1);
					_tmp632_ = _tmp631_;
					_tmp633_ = g_strdup_printf ("%s_destroy_func", _tmp632_);
					_g_free0 (func_name);
					func_name = _tmp633_;
					_g_free0 (_tmp632_);
					_tmp634_ = vala_ccode_base_module_get_ccode (self);
					_tmp635_ = _tmp634_;
					_tmp636_ = func_name;
					_tmp637_ = vala_ccode_variable_declarator_new (_tmp636_, NULL, NULL);
					_tmp638_ = _tmp637_;
					vala_ccode_function_add_declaration (_tmp635_, "GDestroyNotify", (ValaCCodeDeclarator*) _tmp638_, 0);
					_vala_ccode_node_unref0 (_tmp638_);
					_tmp639_ = vala_ccode_base_module_get_ccode (self);
					_tmp640_ = _tmp639_;
					_tmp641_ = func_name;
					_tmp642_ = vala_ccode_identifier_new (_tmp641_);
					_tmp643_ = _tmp642_;
					_tmp644_ = outer_block;
					_tmp645_ = func_name;
					_tmp646_ = vala_ccode_member_access_new_pointer (_tmp644_, _tmp645_);
					_tmp647_ = _tmp646_;
					vala_ccode_function_add_assignment (_tmp640_, (ValaCCodeExpression*) _tmp643_, (ValaCCodeExpression*) _tmp647_);
					_vala_ccode_node_unref0 (_tmp647_);
					_vala_ccode_node_unref0 (_tmp643_);
					_g_free0 (func_name);
					_vala_code_node_unref0 (type_param);
				}
				_vala_iterable_unref0 (_type_param_list);
			}
		}
		{
			gint i = 0;
			ValaList* _tmp648_;
			gint _tmp649_;
			gint _tmp650_;
			_tmp648_ = local_vars;
			_tmp649_ = vala_collection_get_size ((ValaCollection*) _tmp648_);
			_tmp650_ = _tmp649_;
			i = _tmp650_ - 1;
			{
				gboolean _tmp651_ = FALSE;
				_tmp651_ = TRUE;
				while (TRUE) {
					gint _tmp653_;
					ValaLocalVariable* local = NULL;
					ValaList* _tmp654_;
					gint _tmp655_;
					gpointer _tmp656_;
					ValaLocalVariable* _tmp657_;
					gboolean _tmp658_;
					gboolean _tmp659_;
					if (!_tmp651_) {
						gint _tmp652_;
						_tmp652_ = i;
						i = _tmp652_ - 1;
					}
					_tmp651_ = FALSE;
					_tmp653_ = i;
					if (!(_tmp653_ >= 0)) {
						break;
					}
					_tmp654_ = local_vars;
					_tmp655_ = i;
					_tmp656_ = vala_list_get (_tmp654_, _tmp655_);
					local = (ValaLocalVariable*) _tmp656_;
					_tmp657_ = local;
					_tmp658_ = vala_local_variable_get_captured (_tmp657_);
					_tmp659_ = _tmp658_;
					if (_tmp659_) {
						ValaLocalVariable* _tmp660_;
						ValaDataType* _tmp661_;
						ValaDataType* _tmp662_;
						gboolean _tmp663_;
						_tmp660_ = local;
						_tmp661_ = vala_variable_get_variable_type ((ValaVariable*) _tmp660_);
						_tmp662_ = _tmp661_;
						_tmp663_ = vala_ccode_base_module_requires_destroy (self, _tmp662_);
						if (_tmp663_) {
							gboolean old_coroutine = FALSE;
							ValaMethod* _tmp664_;
							ValaMethod* _tmp665_;
							ValaCCodeFunction* _tmp672_;
							ValaCCodeFunction* _tmp673_;
							ValaLocalVariable* _tmp674_;
							ValaCCodeExpression* _tmp675_;
							ValaCCodeExpression* _tmp676_;
							gboolean _tmp677_;
							old_coroutine = FALSE;
							_tmp664_ = vala_ccode_base_module_get_current_method (self);
							_tmp665_ = _tmp664_;
							if (_tmp665_ != NULL) {
								ValaMethod* _tmp666_;
								ValaMethod* _tmp667_;
								gboolean _tmp668_;
								gboolean _tmp669_;
								ValaMethod* _tmp670_;
								ValaMethod* _tmp671_;
								_tmp666_ = vala_ccode_base_module_get_current_method (self);
								_tmp667_ = _tmp666_;
								_tmp668_ = vala_method_get_coroutine (_tmp667_);
								_tmp669_ = _tmp668_;
								old_coroutine = _tmp669_;
								_tmp670_ = vala_ccode_base_module_get_current_method (self);
								_tmp671_ = _tmp670_;
								vala_method_set_coroutine (_tmp671_, FALSE);
							}
							_tmp672_ = vala_ccode_base_module_get_ccode (self);
							_tmp673_ = _tmp672_;
							_tmp674_ = local;
							_tmp675_ = vala_ccode_base_module_destroy_local (self, _tmp674_);
							_tmp676_ = _tmp675_;
							vala_ccode_function_add_expression (_tmp673_, _tmp676_);
							_vala_ccode_node_unref0 (_tmp676_);
							_tmp677_ = old_coroutine;
							if (_tmp677_) {
								ValaMethod* _tmp678_;
								ValaMethod* _tmp679_;
								_tmp678_ = vala_ccode_base_module_get_current_method (self);
								_tmp679_ = _tmp678_;
								vala_method_set_coroutine (_tmp679_, TRUE);
							}
						}
					}
					_vala_code_node_unref0 (local);
				}
			}
		}
		_tmp680_ = b;
		_tmp681_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp680_);
		_tmp682_ = _tmp681_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp682_, VALA_TYPE_METHOD)) {
			ValaMethod* m = NULL;
			ValaBlock* _tmp683_;
			ValaSymbol* _tmp684_;
			ValaSymbol* _tmp685_;
			ValaMethod* _tmp686_;
			_tmp683_ = b;
			_tmp684_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp683_);
			_tmp685_ = _tmp684_;
			_tmp686_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp685_, VALA_TYPE_METHOD, ValaMethod));
			m = _tmp686_;
			{
				ValaList* _param_list = NULL;
				ValaMethod* _tmp687_;
				ValaList* _tmp688_;
				gint _param_size = 0;
				ValaList* _tmp689_;
				gint _tmp690_;
				gint _tmp691_;
				gint _param_index = 0;
				_tmp687_ = m;
				_tmp688_ = vala_callable_get_parameters ((ValaCallable*) _tmp687_);
				_param_list = _tmp688_;
				_tmp689_ = _param_list;
				_tmp690_ = vala_collection_get_size ((ValaCollection*) _tmp689_);
				_tmp691_ = _tmp690_;
				_param_size = _tmp691_;
				_param_index = -1;
				while (TRUE) {
					gint _tmp692_;
					gint _tmp693_;
					gint _tmp694_;
					ValaParameter* param = NULL;
					ValaList* _tmp695_;
					gint _tmp696_;
					gpointer _tmp697_;
					ValaParameter* _tmp698_;
					gboolean _tmp699_;
					gboolean _tmp700_;
					_tmp692_ = _param_index;
					_param_index = _tmp692_ + 1;
					_tmp693_ = _param_index;
					_tmp694_ = _param_size;
					if (!(_tmp693_ < _tmp694_)) {
						break;
					}
					_tmp695_ = _param_list;
					_tmp696_ = _param_index;
					_tmp697_ = vala_list_get (_tmp695_, _tmp696_);
					param = (ValaParameter*) _tmp697_;
					_tmp698_ = param;
					_tmp699_ = vala_parameter_get_captured (_tmp698_);
					_tmp700_ = _tmp699_;
					if (_tmp700_) {
						ValaDataType* param_type = NULL;
						ValaParameter* _tmp701_;
						ValaDataType* _tmp702_;
						ValaDataType* _tmp703_;
						ValaDataType* _tmp704_;
						ValaDataType* _tmp705_;
						gboolean _tmp706_;
						gboolean _tmp707_;
						ValaDataType* _tmp711_;
						gboolean _tmp712_;
						_tmp701_ = param;
						_tmp702_ = vala_variable_get_variable_type ((ValaVariable*) _tmp701_);
						_tmp703_ = _tmp702_;
						_tmp704_ = vala_data_type_copy (_tmp703_);
						param_type = _tmp704_;
						_tmp705_ = param_type;
						_tmp706_ = vala_data_type_get_value_owned (_tmp705_);
						_tmp707_ = _tmp706_;
						if (!_tmp707_) {
							ValaDataType* _tmp708_;
							ValaDataType* _tmp709_;
							gboolean _tmp710_;
							_tmp708_ = param_type;
							_tmp709_ = param_type;
							_tmp710_ = vala_ccode_base_module_no_implicit_copy (self, _tmp709_);
							vala_data_type_set_value_owned (_tmp708_, !_tmp710_);
						}
						_tmp711_ = param_type;
						_tmp712_ = vala_ccode_base_module_requires_destroy (self, _tmp711_);
						if (_tmp712_) {
							gboolean old_coroutine = FALSE;
							ValaMethod* _tmp713_;
							ValaCCodeFunction* _tmp718_;
							ValaCCodeFunction* _tmp719_;
							ValaParameter* _tmp720_;
							ValaCCodeExpression* _tmp721_;
							ValaCCodeExpression* _tmp722_;
							gboolean _tmp723_;
							old_coroutine = FALSE;
							_tmp713_ = m;
							if (_tmp713_ != NULL) {
								ValaMethod* _tmp714_;
								gboolean _tmp715_;
								gboolean _tmp716_;
								ValaMethod* _tmp717_;
								_tmp714_ = m;
								_tmp715_ = vala_method_get_coroutine (_tmp714_);
								_tmp716_ = _tmp715_;
								old_coroutine = _tmp716_;
								_tmp717_ = m;
								vala_method_set_coroutine (_tmp717_, FALSE);
							}
							_tmp718_ = vala_ccode_base_module_get_ccode (self);
							_tmp719_ = _tmp718_;
							_tmp720_ = param;
							_tmp721_ = vala_ccode_base_module_destroy_parameter (self, _tmp720_);
							_tmp722_ = _tmp721_;
							vala_ccode_function_add_expression (_tmp719_, _tmp722_);
							_vala_ccode_node_unref0 (_tmp722_);
							_tmp723_ = old_coroutine;
							if (_tmp723_) {
								ValaMethod* _tmp724_;
								_tmp724_ = m;
								vala_method_set_coroutine (_tmp724_, TRUE);
							}
						}
						_vala_code_node_unref0 (param_type);
					}
					_vala_code_node_unref0 (param);
				}
				_vala_iterable_unref0 (_param_list);
			}
			_vala_code_node_unref0 (m);
		} else {
			ValaBlock* _tmp725_;
			ValaSymbol* _tmp726_;
			ValaSymbol* _tmp727_;
			_tmp725_ = b;
			_tmp726_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp725_);
			_tmp727_ = _tmp726_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp727_, VALA_TYPE_PROPERTY_ACCESSOR)) {
				ValaPropertyAccessor* acc = NULL;
				ValaBlock* _tmp728_;
				ValaSymbol* _tmp729_;
				ValaSymbol* _tmp730_;
				ValaPropertyAccessor* _tmp731_;
				gboolean _tmp732_ = FALSE;
				ValaPropertyAccessor* _tmp733_;
				gboolean _tmp734_;
				gboolean _tmp735_;
				_tmp728_ = b;
				_tmp729_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp728_);
				_tmp730_ = _tmp729_;
				_tmp731_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp730_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
				acc = _tmp731_;
				_tmp733_ = acc;
				_tmp734_ = vala_property_accessor_get_readable (_tmp733_);
				_tmp735_ = _tmp734_;
				if (!_tmp735_) {
					ValaPropertyAccessor* _tmp736_;
					ValaParameter* _tmp737_;
					ValaParameter* _tmp738_;
					gboolean _tmp739_;
					gboolean _tmp740_;
					_tmp736_ = acc;
					_tmp737_ = vala_property_accessor_get_value_parameter (_tmp736_);
					_tmp738_ = _tmp737_;
					_tmp739_ = vala_parameter_get_captured (_tmp738_);
					_tmp740_ = _tmp739_;
					_tmp732_ = _tmp740_;
				} else {
					_tmp732_ = FALSE;
				}
				if (_tmp732_) {
					ValaDataType* param_type = NULL;
					ValaPropertyAccessor* _tmp741_;
					ValaParameter* _tmp742_;
					ValaParameter* _tmp743_;
					ValaDataType* _tmp744_;
					ValaDataType* _tmp745_;
					ValaDataType* _tmp746_;
					ValaDataType* _tmp747_;
					gboolean _tmp748_;
					gboolean _tmp749_;
					ValaDataType* _tmp753_;
					gboolean _tmp754_;
					_tmp741_ = acc;
					_tmp742_ = vala_property_accessor_get_value_parameter (_tmp741_);
					_tmp743_ = _tmp742_;
					_tmp744_ = vala_variable_get_variable_type ((ValaVariable*) _tmp743_);
					_tmp745_ = _tmp744_;
					_tmp746_ = vala_data_type_copy (_tmp745_);
					param_type = _tmp746_;
					_tmp747_ = param_type;
					_tmp748_ = vala_data_type_get_value_owned (_tmp747_);
					_tmp749_ = _tmp748_;
					if (!_tmp749_) {
						ValaDataType* _tmp750_;
						ValaDataType* _tmp751_;
						gboolean _tmp752_;
						_tmp750_ = param_type;
						_tmp751_ = param_type;
						_tmp752_ = vala_ccode_base_module_no_implicit_copy (self, _tmp751_);
						vala_data_type_set_value_owned (_tmp750_, !_tmp752_);
					}
					_tmp753_ = param_type;
					_tmp754_ = vala_ccode_base_module_requires_destroy (self, _tmp753_);
					if (_tmp754_) {
						ValaCCodeFunction* _tmp755_;
						ValaCCodeFunction* _tmp756_;
						ValaPropertyAccessor* _tmp757_;
						ValaParameter* _tmp758_;
						ValaParameter* _tmp759_;
						ValaCCodeExpression* _tmp760_;
						ValaCCodeExpression* _tmp761_;
						_tmp755_ = vala_ccode_base_module_get_ccode (self);
						_tmp756_ = _tmp755_;
						_tmp757_ = acc;
						_tmp758_ = vala_property_accessor_get_value_parameter (_tmp757_);
						_tmp759_ = _tmp758_;
						_tmp760_ = vala_ccode_base_module_destroy_parameter (self, _tmp759_);
						_tmp761_ = _tmp760_;
						vala_ccode_function_add_expression (_tmp756_, _tmp761_);
						_vala_ccode_node_unref0 (_tmp761_);
					}
					_vala_code_node_unref0 (param_type);
				}
				_vala_code_node_unref0 (acc);
			}
		}
		_tmp762_ = parent_block;
		if (_tmp762_ != NULL) {
			gint parent_block_id = 0;
			ValaBlock* _tmp763_;
			gint _tmp764_;
			ValaCCodeFunctionCall* unref_call = NULL;
			gint _tmp765_;
			gchar* _tmp766_;
			gchar* _tmp767_;
			ValaCCodeIdentifier* _tmp768_;
			ValaCCodeIdentifier* _tmp769_;
			ValaCCodeFunctionCall* _tmp770_;
			ValaCCodeFunctionCall* _tmp771_;
			ValaCCodeFunctionCall* _tmp772_;
			gint _tmp773_;
			gchar* _tmp774_;
			gchar* _tmp775_;
			ValaCCodeIdentifier* _tmp776_;
			ValaCCodeIdentifier* _tmp777_;
			gint _tmp778_;
			gchar* _tmp779_;
			gchar* _tmp780_;
			ValaCCodeMemberAccess* _tmp781_;
			ValaCCodeMemberAccess* _tmp782_;
			ValaCCodeFunction* _tmp783_;
			ValaCCodeFunction* _tmp784_;
			ValaCCodeFunctionCall* _tmp785_;
			ValaCCodeFunction* _tmp786_;
			ValaCCodeFunction* _tmp787_;
			gint _tmp788_;
			gchar* _tmp789_;
			gchar* _tmp790_;
			ValaCCodeIdentifier* _tmp791_;
			ValaCCodeIdentifier* _tmp792_;
			gint _tmp793_;
			gchar* _tmp794_;
			gchar* _tmp795_;
			ValaCCodeMemberAccess* _tmp796_;
			ValaCCodeMemberAccess* _tmp797_;
			ValaCCodeConstant* _tmp798_;
			ValaCCodeConstant* _tmp799_;
			_tmp763_ = parent_block;
			_tmp764_ = vala_ccode_base_module_get_block_id (self, _tmp763_);
			parent_block_id = _tmp764_;
			_tmp765_ = parent_block_id;
			_tmp766_ = g_strdup_printf ("block%d_data_unref", _tmp765_);
			_tmp767_ = _tmp766_;
			_tmp768_ = vala_ccode_identifier_new (_tmp767_);
			_tmp769_ = _tmp768_;
			_tmp770_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp769_);
			_tmp771_ = _tmp770_;
			_vala_ccode_node_unref0 (_tmp769_);
			_g_free0 (_tmp767_);
			unref_call = _tmp771_;
			_tmp772_ = unref_call;
			_tmp773_ = block_id;
			_tmp774_ = g_strdup_printf ("_data%d_", _tmp773_);
			_tmp775_ = _tmp774_;
			_tmp776_ = vala_ccode_identifier_new (_tmp775_);
			_tmp777_ = _tmp776_;
			_tmp778_ = parent_block_id;
			_tmp779_ = g_strdup_printf ("_data%d_", _tmp778_);
			_tmp780_ = _tmp779_;
			_tmp781_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp777_, _tmp780_);
			_tmp782_ = _tmp781_;
			vala_ccode_function_call_add_argument (_tmp772_, (ValaCCodeExpression*) _tmp782_);
			_vala_ccode_node_unref0 (_tmp782_);
			_g_free0 (_tmp780_);
			_vala_ccode_node_unref0 (_tmp777_);
			_g_free0 (_tmp775_);
			_tmp783_ = vala_ccode_base_module_get_ccode (self);
			_tmp784_ = _tmp783_;
			_tmp785_ = unref_call;
			vala_ccode_function_add_expression (_tmp784_, (ValaCCodeExpression*) _tmp785_);
			_tmp786_ = vala_ccode_base_module_get_ccode (self);
			_tmp787_ = _tmp786_;
			_tmp788_ = block_id;
			_tmp789_ = g_strdup_printf ("_data%d_", _tmp788_);
			_tmp790_ = _tmp789_;
			_tmp791_ = vala_ccode_identifier_new (_tmp790_);
			_tmp792_ = _tmp791_;
			_tmp793_ = parent_block_id;
			_tmp794_ = g_strdup_printf ("_data%d_", _tmp793_);
			_tmp795_ = _tmp794_;
			_tmp796_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp792_, _tmp795_);
			_tmp797_ = _tmp796_;
			_tmp798_ = vala_ccode_constant_new ("NULL");
			_tmp799_ = _tmp798_;
			vala_ccode_function_add_assignment (_tmp787_, (ValaCCodeExpression*) _tmp797_, (ValaCCodeExpression*) _tmp799_);
			_vala_ccode_node_unref0 (_tmp799_);
			_vala_ccode_node_unref0 (_tmp797_);
			_g_free0 (_tmp795_);
			_vala_ccode_node_unref0 (_tmp792_);
			_g_free0 (_tmp790_);
			_vala_ccode_node_unref0 (unref_call);
		} else {
			ValaDataType* this_type = NULL;
			ValaDataType* _tmp800_;
			ValaDataType* _tmp801_;
			_tmp800_ = vala_ccode_base_module_get_this_type (self);
			this_type = _tmp800_;
			_tmp801_ = this_type;
			if (_tmp801_ != NULL) {
				ValaDataType* _tmp802_;
				ValaDataType* _tmp803_;
				ValaDataType* _tmp804_;
				gboolean _tmp805_ = FALSE;
				ValaDataType* _tmp806_;
				gboolean _tmp807_;
				_tmp802_ = this_type;
				_tmp803_ = vala_data_type_copy (_tmp802_);
				_vala_code_node_unref0 (this_type);
				this_type = _tmp803_;
				_tmp804_ = this_type;
				vala_data_type_set_value_owned (_tmp804_, TRUE);
				_tmp806_ = this_type;
				_tmp807_ = vala_data_type_is_disposable (_tmp806_);
				if (_tmp807_) {
					gboolean _tmp808_;
					_tmp808_ = vala_ccode_base_module_is_in_destructor (self);
					_tmp805_ = !_tmp808_;
				} else {
					_tmp805_ = FALSE;
				}
				if (_tmp805_) {
					ValaGLibValue* this_value = NULL;
					ValaTypeSymbol* _tmp809_;
					ValaTypeSymbol* _tmp810_;
					ValaDataType* _tmp811_;
					ValaDataType* _tmp812_;
					ValaCCodeIdentifier* _tmp813_;
					ValaCCodeIdentifier* _tmp814_;
					ValaGLibValue* _tmp815_;
					ValaGLibValue* _tmp816_;
					ValaCCodeFunction* _tmp817_;
					ValaCCodeFunction* _tmp818_;
					ValaGLibValue* _tmp819_;
					ValaCCodeExpression* _tmp820_;
					ValaCCodeExpression* _tmp821_;
					_tmp809_ = vala_ccode_base_module_get_current_type_symbol (self);
					_tmp810_ = _tmp809_;
					_tmp811_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp810_);
					_tmp812_ = _tmp811_;
					_tmp813_ = vala_ccode_identifier_new ("self");
					_tmp814_ = _tmp813_;
					_tmp815_ = vala_glib_value_new (_tmp812_, (ValaCCodeExpression*) _tmp814_, TRUE);
					_tmp816_ = _tmp815_;
					_vala_ccode_node_unref0 (_tmp814_);
					_vala_code_node_unref0 (_tmp812_);
					this_value = _tmp816_;
					_tmp817_ = vala_ccode_base_module_get_ccode (self);
					_tmp818_ = _tmp817_;
					_tmp819_ = this_value;
					_tmp820_ = vala_ccode_base_module_destroy_value (self, (ValaTargetValue*) _tmp819_, FALSE);
					_tmp821_ = _tmp820_;
					vala_ccode_function_add_expression (_tmp818_, _tmp821_);
					_vala_ccode_node_unref0 (_tmp821_);
					_vala_target_value_unref0 (this_value);
				}
			}
			_vala_code_node_unref0 (this_type);
		}
		_tmp822_ = vala_ccode_identifier_new ("g_slice_free");
		_tmp823_ = _tmp822_;
		_tmp824_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp823_);
		_tmp825_ = _tmp824_;
		_vala_ccode_node_unref0 (_tmp823_);
		data_free = _tmp825_;
		_tmp826_ = data_free;
		_tmp827_ = struct_name;
		_tmp828_ = vala_ccode_identifier_new (_tmp827_);
		_tmp829_ = _tmp828_;
		vala_ccode_function_call_add_argument (_tmp826_, (ValaCCodeExpression*) _tmp829_);
		_vala_ccode_node_unref0 (_tmp829_);
		_tmp830_ = data_free;
		_tmp831_ = block_id;
		_tmp832_ = g_strdup_printf ("_data%d_", _tmp831_);
		_tmp833_ = _tmp832_;
		_tmp834_ = vala_ccode_identifier_new (_tmp833_);
		_tmp835_ = _tmp834_;
		vala_ccode_function_call_add_argument (_tmp830_, (ValaCCodeExpression*) _tmp835_);
		_vala_ccode_node_unref0 (_tmp835_);
		_g_free0 (_tmp833_);
		_tmp836_ = vala_ccode_base_module_get_ccode (self);
		_tmp837_ = _tmp836_;
		_tmp838_ = data_free;
		vala_ccode_function_add_expression (_tmp837_, (ValaCCodeExpression*) _tmp838_);
		_tmp839_ = vala_ccode_base_module_get_ccode (self);
		_tmp840_ = _tmp839_;
		vala_ccode_function_close (_tmp840_);
		vala_ccode_base_module_pop_function (self);
		_tmp841_ = self->cfile;
		_tmp842_ = unref_fun;
		vala_ccode_file_add_function_declaration (_tmp841_, _tmp842_);
		_tmp843_ = self->cfile;
		_tmp844_ = unref_fun;
		vala_ccode_file_add_function (_tmp843_, _tmp844_);
		_vala_ccode_node_unref0 (data_free);
		_vala_ccode_node_unref0 (outer_block);
		_vala_ccode_node_unref0 (unref_fun);
		_vala_ccode_node_unref0 (ccall);
		_vala_ccode_node_unref0 (ref_fun);
		_vala_ccode_node_unref0 (_typedef_);
		_vala_ccode_node_unref0 (data_alloc);
		_vala_ccode_node_unref0 (data);
		_g_free0 (struct_name);
		_vala_code_node_unref0 (parent_block);
	}
	{
		ValaList* _stmt_list = NULL;
		ValaBlock* _tmp845_;
		ValaList* _tmp846_;
		gint _stmt_size = 0;
		ValaList* _tmp847_;
		gint _tmp848_;
		gint _tmp849_;
		gint _stmt_index = 0;
		_tmp845_ = b;
		_tmp846_ = vala_block_get_statements (_tmp845_);
		_stmt_list = _tmp846_;
		_tmp847_ = _stmt_list;
		_tmp848_ = vala_collection_get_size ((ValaCollection*) _tmp847_);
		_tmp849_ = _tmp848_;
		_stmt_size = _tmp849_;
		_stmt_index = -1;
		while (TRUE) {
			gint _tmp850_;
			gint _tmp851_;
			gint _tmp852_;
			ValaStatement* stmt = NULL;
			ValaList* _tmp853_;
			gint _tmp854_;
			gpointer _tmp855_;
			ValaStatement* _tmp856_;
			ValaSourceReference* _tmp857_;
			ValaSourceReference* _tmp858_;
			ValaStatement* _tmp859_;
			_tmp850_ = _stmt_index;
			_stmt_index = _tmp850_ + 1;
			_tmp851_ = _stmt_index;
			_tmp852_ = _stmt_size;
			if (!(_tmp851_ < _tmp852_)) {
				break;
			}
			_tmp853_ = _stmt_list;
			_tmp854_ = _stmt_index;
			_tmp855_ = vala_list_get (_tmp853_, _tmp854_);
			stmt = (ValaStatement*) _tmp855_;
			_tmp856_ = stmt;
			_tmp857_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp856_);
			_tmp858_ = _tmp857_;
			vala_ccode_base_module_push_line (self, _tmp858_);
			_tmp859_ = stmt;
			vala_code_node_emit ((ValaCodeNode*) _tmp859_, (ValaCodeGenerator*) self);
			vala_ccode_base_module_pop_line (self);
			_vala_code_node_unref0 (stmt);
		}
		_vala_iterable_unref0 (_stmt_list);
	}
	{
		gint i = 0;
		ValaList* _tmp860_;
		gint _tmp861_;
		gint _tmp862_;
		_tmp860_ = local_vars;
		_tmp861_ = vala_collection_get_size ((ValaCollection*) _tmp860_);
		_tmp862_ = _tmp861_;
		i = _tmp862_ - 1;
		{
			gboolean _tmp863_ = FALSE;
			_tmp863_ = TRUE;
			while (TRUE) {
				gint _tmp865_;
				ValaLocalVariable* local = NULL;
				ValaList* _tmp866_;
				gint _tmp867_;
				gpointer _tmp868_;
				ValaLocalVariable* _tmp869_;
				gboolean _tmp870_ = FALSE;
				gboolean _tmp871_ = FALSE;
				ValaLocalVariable* _tmp872_;
				gboolean _tmp873_;
				gboolean _tmp874_;
				if (!_tmp863_) {
					gint _tmp864_;
					_tmp864_ = i;
					i = _tmp864_ - 1;
				}
				_tmp863_ = FALSE;
				_tmp865_ = i;
				if (!(_tmp865_ >= 0)) {
					break;
				}
				_tmp866_ = local_vars;
				_tmp867_ = i;
				_tmp868_ = vala_list_get (_tmp866_, _tmp867_);
				local = (ValaLocalVariable*) _tmp868_;
				_tmp869_ = local;
				vala_symbol_set_active ((ValaSymbol*) _tmp869_, FALSE);
				_tmp872_ = local;
				_tmp873_ = vala_code_node_get_unreachable ((ValaCodeNode*) _tmp872_);
				_tmp874_ = _tmp873_;
				if (!_tmp874_) {
					ValaLocalVariable* _tmp875_;
					gboolean _tmp876_;
					gboolean _tmp877_;
					_tmp875_ = local;
					_tmp876_ = vala_local_variable_get_captured (_tmp875_);
					_tmp877_ = _tmp876_;
					_tmp871_ = !_tmp877_;
				} else {
					_tmp871_ = FALSE;
				}
				if (_tmp871_) {
					ValaLocalVariable* _tmp878_;
					ValaDataType* _tmp879_;
					ValaDataType* _tmp880_;
					gboolean _tmp881_;
					_tmp878_ = local;
					_tmp879_ = vala_variable_get_variable_type ((ValaVariable*) _tmp878_);
					_tmp880_ = _tmp879_;
					_tmp881_ = vala_ccode_base_module_requires_destroy (self, _tmp880_);
					_tmp870_ = _tmp881_;
				} else {
					_tmp870_ = FALSE;
				}
				if (_tmp870_) {
					ValaCCodeFunction* _tmp882_;
					ValaCCodeFunction* _tmp883_;
					ValaLocalVariable* _tmp884_;
					ValaCCodeExpression* _tmp885_;
					ValaCCodeExpression* _tmp886_;
					_tmp882_ = vala_ccode_base_module_get_ccode (self);
					_tmp883_ = _tmp882_;
					_tmp884_ = local;
					_tmp885_ = vala_ccode_base_module_destroy_local (self, _tmp884_);
					_tmp886_ = _tmp885_;
					vala_ccode_function_add_expression (_tmp883_, _tmp886_);
					_vala_ccode_node_unref0 (_tmp886_);
				}
				_vala_code_node_unref0 (local);
			}
		}
	}
	_tmp887_ = b;
	_tmp888_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp887_);
	_tmp889_ = _tmp888_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp889_, VALA_TYPE_METHOD)) {
		ValaMethod* m = NULL;
		ValaBlock* _tmp890_;
		ValaSymbol* _tmp891_;
		ValaSymbol* _tmp892_;
		ValaMethod* _tmp893_;
		_tmp890_ = b;
		_tmp891_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp890_);
		_tmp892_ = _tmp891_;
		_tmp893_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp892_, VALA_TYPE_METHOD, ValaMethod));
		m = _tmp893_;
		{
			ValaList* _param_list = NULL;
			ValaMethod* _tmp894_;
			ValaList* _tmp895_;
			gint _param_size = 0;
			ValaList* _tmp896_;
			gint _tmp897_;
			gint _tmp898_;
			gint _param_index = 0;
			_tmp894_ = m;
			_tmp895_ = vala_callable_get_parameters ((ValaCallable*) _tmp894_);
			_param_list = _tmp895_;
			_tmp896_ = _param_list;
			_tmp897_ = vala_collection_get_size ((ValaCollection*) _tmp896_);
			_tmp898_ = _tmp897_;
			_param_size = _tmp898_;
			_param_index = -1;
			while (TRUE) {
				gint _tmp899_;
				gint _tmp900_;
				gint _tmp901_;
				ValaParameter* param = NULL;
				ValaList* _tmp902_;
				gint _tmp903_;
				gpointer _tmp904_;
				gboolean _tmp905_ = FALSE;
				gboolean _tmp906_ = FALSE;
				gboolean _tmp907_ = FALSE;
				ValaParameter* _tmp908_;
				gboolean _tmp909_;
				gboolean _tmp910_;
				_tmp899_ = _param_index;
				_param_index = _tmp899_ + 1;
				_tmp900_ = _param_index;
				_tmp901_ = _param_size;
				if (!(_tmp900_ < _tmp901_)) {
					break;
				}
				_tmp902_ = _param_list;
				_tmp903_ = _param_index;
				_tmp904_ = vala_list_get (_tmp902_, _tmp903_);
				param = (ValaParameter*) _tmp904_;
				_tmp908_ = param;
				_tmp909_ = vala_parameter_get_captured (_tmp908_);
				_tmp910_ = _tmp909_;
				if (!_tmp910_) {
					ValaParameter* _tmp911_;
					gboolean _tmp912_;
					gboolean _tmp913_;
					_tmp911_ = param;
					_tmp912_ = vala_parameter_get_ellipsis (_tmp911_);
					_tmp913_ = _tmp912_;
					_tmp907_ = !_tmp913_;
				} else {
					_tmp907_ = FALSE;
				}
				if (_tmp907_) {
					ValaParameter* _tmp914_;
					ValaDataType* _tmp915_;
					ValaDataType* _tmp916_;
					gboolean _tmp917_;
					_tmp914_ = param;
					_tmp915_ = vala_variable_get_variable_type ((ValaVariable*) _tmp914_);
					_tmp916_ = _tmp915_;
					_tmp917_ = vala_ccode_base_module_requires_destroy (self, _tmp916_);
					_tmp906_ = _tmp917_;
				} else {
					_tmp906_ = FALSE;
				}
				if (_tmp906_) {
					ValaParameter* _tmp918_;
					ValaParameterDirection _tmp919_;
					ValaParameterDirection _tmp920_;
					_tmp918_ = param;
					_tmp919_ = vala_parameter_get_direction (_tmp918_);
					_tmp920_ = _tmp919_;
					_tmp905_ = _tmp920_ == VALA_PARAMETER_DIRECTION_IN;
				} else {
					_tmp905_ = FALSE;
				}
				if (_tmp905_) {
					ValaCCodeFunction* _tmp921_;
					ValaCCodeFunction* _tmp922_;
					ValaParameter* _tmp923_;
					ValaCCodeExpression* _tmp924_;
					ValaCCodeExpression* _tmp925_;
					_tmp921_ = vala_ccode_base_module_get_ccode (self);
					_tmp922_ = _tmp921_;
					_tmp923_ = param;
					_tmp924_ = vala_ccode_base_module_destroy_parameter (self, _tmp923_);
					_tmp925_ = _tmp924_;
					vala_ccode_function_add_expression (_tmp922_, _tmp925_);
					_vala_ccode_node_unref0 (_tmp925_);
				} else {
					gboolean _tmp926_ = FALSE;
					ValaParameter* _tmp927_;
					ValaParameterDirection _tmp928_;
					ValaParameterDirection _tmp929_;
					_tmp927_ = param;
					_tmp928_ = vala_parameter_get_direction (_tmp927_);
					_tmp929_ = _tmp928_;
					if (_tmp929_ == VALA_PARAMETER_DIRECTION_OUT) {
						ValaMethod* _tmp930_;
						gboolean _tmp931_;
						gboolean _tmp932_;
						_tmp930_ = m;
						_tmp931_ = vala_method_get_coroutine (_tmp930_);
						_tmp932_ = _tmp931_;
						_tmp926_ = !_tmp932_;
					} else {
						_tmp926_ = FALSE;
					}
					if (_tmp926_) {
						ValaParameter* _tmp933_;
						_tmp933_ = param;
						vala_ccode_base_module_return_out_parameter (self, _tmp933_);
					}
				}
				_vala_code_node_unref0 (param);
			}
			_vala_iterable_unref0 (_param_list);
		}
		{
			ValaList* _postcondition_list = NULL;
			ValaMethod* _tmp934_;
			ValaList* _tmp935_;
			gint _postcondition_size = 0;
			ValaList* _tmp936_;
			gint _tmp937_;
			gint _tmp938_;
			gint _postcondition_index = 0;
			_tmp934_ = m;
			_tmp935_ = vala_method_get_postconditions (_tmp934_);
			_postcondition_list = _tmp935_;
			_tmp936_ = _postcondition_list;
			_tmp937_ = vala_collection_get_size ((ValaCollection*) _tmp936_);
			_tmp938_ = _tmp937_;
			_postcondition_size = _tmp938_;
			_postcondition_index = -1;
			while (TRUE) {
				gint _tmp939_;
				gint _tmp940_;
				gint _tmp941_;
				ValaExpression* postcondition = NULL;
				ValaList* _tmp942_;
				gint _tmp943_;
				gpointer _tmp944_;
				ValaExpression* _tmp945_;
				_tmp939_ = _postcondition_index;
				_postcondition_index = _tmp939_ + 1;
				_tmp940_ = _postcondition_index;
				_tmp941_ = _postcondition_size;
				if (!(_tmp940_ < _tmp941_)) {
					break;
				}
				_tmp942_ = _postcondition_list;
				_tmp943_ = _postcondition_index;
				_tmp944_ = vala_list_get (_tmp942_, _tmp943_);
				postcondition = (ValaExpression*) _tmp944_;
				_tmp945_ = postcondition;
				vala_ccode_base_module_create_postcondition_statement (self, _tmp945_);
				_vala_code_node_unref0 (postcondition);
			}
			_vala_iterable_unref0 (_postcondition_list);
		}
		_vala_code_node_unref0 (m);
	} else {
		ValaBlock* _tmp946_;
		ValaSymbol* _tmp947_;
		ValaSymbol* _tmp948_;
		_tmp946_ = b;
		_tmp947_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp946_);
		_tmp948_ = _tmp947_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp948_, VALA_TYPE_PROPERTY_ACCESSOR)) {
			ValaPropertyAccessor* acc = NULL;
			ValaBlock* _tmp949_;
			ValaSymbol* _tmp950_;
			ValaSymbol* _tmp951_;
			ValaPropertyAccessor* _tmp952_;
			gboolean _tmp953_ = FALSE;
			gboolean _tmp954_ = FALSE;
			ValaPropertyAccessor* _tmp955_;
			ValaParameter* _tmp956_;
			ValaParameter* _tmp957_;
			_tmp949_ = b;
			_tmp950_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp949_);
			_tmp951_ = _tmp950_;
			_tmp952_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp951_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
			acc = _tmp952_;
			_tmp955_ = acc;
			_tmp956_ = vala_property_accessor_get_value_parameter (_tmp955_);
			_tmp957_ = _tmp956_;
			if (_tmp957_ != NULL) {
				ValaPropertyAccessor* _tmp958_;
				ValaParameter* _tmp959_;
				ValaParameter* _tmp960_;
				gboolean _tmp961_;
				gboolean _tmp962_;
				_tmp958_ = acc;
				_tmp959_ = vala_property_accessor_get_value_parameter (_tmp958_);
				_tmp960_ = _tmp959_;
				_tmp961_ = vala_parameter_get_captured (_tmp960_);
				_tmp962_ = _tmp961_;
				_tmp954_ = !_tmp962_;
			} else {
				_tmp954_ = FALSE;
			}
			if (_tmp954_) {
				ValaPropertyAccessor* _tmp963_;
				ValaParameter* _tmp964_;
				ValaParameter* _tmp965_;
				ValaDataType* _tmp966_;
				ValaDataType* _tmp967_;
				gboolean _tmp968_;
				_tmp963_ = acc;
				_tmp964_ = vala_property_accessor_get_value_parameter (_tmp963_);
				_tmp965_ = _tmp964_;
				_tmp966_ = vala_variable_get_variable_type ((ValaVariable*) _tmp965_);
				_tmp967_ = _tmp966_;
				_tmp968_ = vala_ccode_base_module_requires_destroy (self, _tmp967_);
				_tmp953_ = _tmp968_;
			} else {
				_tmp953_ = FALSE;
			}
			if (_tmp953_) {
				ValaCCodeFunction* _tmp969_;
				ValaCCodeFunction* _tmp970_;
				ValaPropertyAccessor* _tmp971_;
				ValaParameter* _tmp972_;
				ValaParameter* _tmp973_;
				ValaCCodeExpression* _tmp974_;
				ValaCCodeExpression* _tmp975_;
				_tmp969_ = vala_ccode_base_module_get_ccode (self);
				_tmp970_ = _tmp969_;
				_tmp971_ = acc;
				_tmp972_ = vala_property_accessor_get_value_parameter (_tmp971_);
				_tmp973_ = _tmp972_;
				_tmp974_ = vala_ccode_base_module_destroy_parameter (self, _tmp973_);
				_tmp975_ = _tmp974_;
				vala_ccode_function_add_expression (_tmp970_, _tmp975_);
				_vala_ccode_node_unref0 (_tmp975_);
			}
			_vala_code_node_unref0 (acc);
		}
	}
	_tmp976_ = b;
	_tmp977_ = vala_block_get_captured (_tmp976_);
	_tmp978_ = _tmp977_;
	if (_tmp978_) {
		gint block_id = 0;
		ValaBlock* _tmp979_;
		gint _tmp980_;
		ValaCCodeFunctionCall* data_unref = NULL;
		gint _tmp981_;
		gchar* _tmp982_;
		gchar* _tmp983_;
		ValaCCodeIdentifier* _tmp984_;
		ValaCCodeIdentifier* _tmp985_;
		ValaCCodeFunctionCall* _tmp986_;
		ValaCCodeFunctionCall* _tmp987_;
		ValaCCodeFunctionCall* _tmp988_;
		gint _tmp989_;
		gchar* _tmp990_;
		gchar* _tmp991_;
		ValaCCodeExpression* _tmp992_;
		ValaCCodeExpression* _tmp993_;
		ValaCCodeFunction* _tmp994_;
		ValaCCodeFunction* _tmp995_;
		ValaCCodeFunctionCall* _tmp996_;
		ValaCCodeFunction* _tmp997_;
		ValaCCodeFunction* _tmp998_;
		gint _tmp999_;
		gchar* _tmp1000_;
		gchar* _tmp1001_;
		ValaCCodeExpression* _tmp1002_;
		ValaCCodeExpression* _tmp1003_;
		ValaCCodeConstant* _tmp1004_;
		ValaCCodeConstant* _tmp1005_;
		_tmp979_ = b;
		_tmp980_ = vala_ccode_base_module_get_block_id (self, _tmp979_);
		block_id = _tmp980_;
		_tmp981_ = block_id;
		_tmp982_ = g_strdup_printf ("block%d_data_unref", _tmp981_);
		_tmp983_ = _tmp982_;
		_tmp984_ = vala_ccode_identifier_new (_tmp983_);
		_tmp985_ = _tmp984_;
		_tmp986_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp985_);
		_tmp987_ = _tmp986_;
		_vala_ccode_node_unref0 (_tmp985_);
		_g_free0 (_tmp983_);
		data_unref = _tmp987_;
		_tmp988_ = data_unref;
		_tmp989_ = block_id;
		_tmp990_ = g_strdup_printf ("_data%d_", _tmp989_);
		_tmp991_ = _tmp990_;
		_tmp992_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp991_);
		_tmp993_ = _tmp992_;
		vala_ccode_function_call_add_argument (_tmp988_, _tmp993_);
		_vala_ccode_node_unref0 (_tmp993_);
		_g_free0 (_tmp991_);
		_tmp994_ = vala_ccode_base_module_get_ccode (self);
		_tmp995_ = _tmp994_;
		_tmp996_ = data_unref;
		vala_ccode_function_add_expression (_tmp995_, (ValaCCodeExpression*) _tmp996_);
		_tmp997_ = vala_ccode_base_module_get_ccode (self);
		_tmp998_ = _tmp997_;
		_tmp999_ = block_id;
		_tmp1000_ = g_strdup_printf ("_data%d_", _tmp999_);
		_tmp1001_ = _tmp1000_;
		_tmp1002_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp1001_);
		_tmp1003_ = _tmp1002_;
		_tmp1004_ = vala_ccode_constant_new ("NULL");
		_tmp1005_ = _tmp1004_;
		vala_ccode_function_add_assignment (_tmp998_, _tmp1003_, (ValaCCodeExpression*) _tmp1005_);
		_vala_ccode_node_unref0 (_tmp1005_);
		_vala_ccode_node_unref0 (_tmp1003_);
		_g_free0 (_tmp1001_);
		_vala_ccode_node_unref0 (data_unref);
	}
	_tmp1008_ = b;
	_tmp1009_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp1008_);
	_tmp1010_ = _tmp1009_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1010_, VALA_TYPE_BLOCK)) {
		_tmp1007_ = TRUE;
	} else {
		ValaBlock* _tmp1011_;
		ValaCodeNode* _tmp1012_;
		ValaCodeNode* _tmp1013_;
		_tmp1011_ = b;
		_tmp1012_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp1011_);
		_tmp1013_ = _tmp1012_;
		_tmp1007_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1013_, VALA_TYPE_SWITCH_STATEMENT);
	}
	if (_tmp1007_) {
		_tmp1006_ = TRUE;
	} else {
		ValaBlock* _tmp1014_;
		ValaCodeNode* _tmp1015_;
		ValaCodeNode* _tmp1016_;
		_tmp1014_ = b;
		_tmp1015_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp1014_);
		_tmp1016_ = _tmp1015_;
		_tmp1006_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1016_, VALA_TYPE_TRY_STATEMENT);
	}
	if (_tmp1006_) {
		ValaCCodeFunction* _tmp1017_;
		ValaCCodeFunction* _tmp1018_;
		_tmp1017_ = vala_ccode_base_module_get_ccode (self);
		_tmp1018_ = _tmp1017_;
		vala_ccode_function_close (_tmp1018_);
	}
	_tmp1019_ = self->emit_context;
	vala_ccode_base_module_emit_context_pop_symbol (_tmp1019_);
	_vala_iterable_unref0 (local_vars);
}


static void vala_ccode_base_module_real_visit_declaration_statement (ValaCodeVisitor* base, ValaDeclarationStatement* stmt) {
	ValaCCodeBaseModule * self;
	ValaDeclarationStatement* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (stmt != NULL);
	_tmp0_ = stmt;
	_tmp1_ = vala_declaration_statement_get_declaration (_tmp0_);
	_tmp2_ = _tmp1_;
	vala_code_node_accept ((ValaCodeNode*) _tmp2_, (ValaCodeVisitor*) self);
}


ValaCCodeExpression* vala_ccode_base_module_get_local_cexpression (ValaCCodeBaseModule* self, ValaLocalVariable* local) {
	ValaCCodeExpression* result = NULL;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (local != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_is_in_coroutine (self);
	if (_tmp0_) {
		ValaCCodeIdentifier* _tmp1_;
		ValaCCodeIdentifier* _tmp2_;
		ValaLocalVariable* _tmp3_;
		gchar* _tmp4_;
		gchar* _tmp5_;
		ValaCCodeMemberAccess* _tmp6_;
		ValaCCodeExpression* _tmp7_;
		_tmp1_ = vala_ccode_identifier_new ("_data_");
		_tmp2_ = _tmp1_;
		_tmp3_ = local;
		_tmp4_ = vala_ccode_base_module_get_local_cname (self, _tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp2_, _tmp5_);
		_tmp7_ = (ValaCCodeExpression*) _tmp6_;
		_g_free0 (_tmp5_);
		_vala_ccode_node_unref0 (_tmp2_);
		result = _tmp7_;
		return result;
	} else {
		ValaLocalVariable* _tmp8_;
		gchar* _tmp9_;
		gchar* _tmp10_;
		ValaCCodeIdentifier* _tmp11_;
		ValaCCodeExpression* _tmp12_;
		_tmp8_ = local;
		_tmp9_ = vala_ccode_base_module_get_local_cname (self, _tmp8_);
		_tmp10_ = _tmp9_;
		_tmp11_ = vala_ccode_identifier_new (_tmp10_);
		_tmp12_ = (ValaCCodeExpression*) _tmp11_;
		_g_free0 (_tmp10_);
		result = _tmp12_;
		return result;
	}
}


ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name) {
	ValaCCodeExpression* result = NULL;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (name != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_is_in_coroutine (self);
	if (_tmp0_) {
		ValaCCodeIdentifier* _tmp1_;
		ValaCCodeIdentifier* _tmp2_;
		const gchar* _tmp3_;
		gchar* _tmp4_;
		gchar* _tmp5_;
		ValaCCodeMemberAccess* _tmp6_;
		ValaCCodeExpression* _tmp7_;
		_tmp1_ = vala_ccode_identifier_new ("_data_");
		_tmp2_ = _tmp1_;
		_tmp3_ = name;
		_tmp4_ = vala_ccode_base_module_get_variable_cname (self, _tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp2_, _tmp5_);
		_tmp7_ = (ValaCCodeExpression*) _tmp6_;
		_g_free0 (_tmp5_);
		_vala_ccode_node_unref0 (_tmp2_);
		result = _tmp7_;
		return result;
	} else {
		const gchar* _tmp8_;
		gchar* _tmp9_;
		gchar* _tmp10_;
		ValaCCodeIdentifier* _tmp11_;
		ValaCCodeExpression* _tmp12_;
		_tmp8_ = name;
		_tmp9_ = vala_ccode_base_module_get_variable_cname (self, _tmp8_);
		_tmp10_ = _tmp9_;
		_tmp11_ = vala_ccode_identifier_new (_tmp10_);
		_tmp12_ = (ValaCCodeExpression*) _tmp11_;
		_g_free0 (_tmp10_);
		result = _tmp12_;
		return result;
	}
}


ValaCCodeExpression* vala_ccode_base_module_get_this_cexpression (ValaCCodeBaseModule* self) {
	ValaCCodeExpression* result = NULL;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_is_in_coroutine (self);
	if (_tmp0_) {
		ValaCCodeIdentifier* _tmp1_;
		ValaCCodeIdentifier* _tmp2_;
		ValaCCodeMemberAccess* _tmp3_;
		ValaCCodeExpression* _tmp4_;
		_tmp1_ = vala_ccode_identifier_new ("_data_");
		_tmp2_ = _tmp1_;
		_tmp3_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp2_, "self");
		_tmp4_ = (ValaCCodeExpression*) _tmp3_;
		_vala_ccode_node_unref0 (_tmp2_);
		result = _tmp4_;
		return result;
	} else {
		ValaCCodeIdentifier* _tmp5_;
		_tmp5_ = vala_ccode_identifier_new ("self");
		result = (ValaCCodeExpression*) _tmp5_;
		return result;
	}
}


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


gchar* vala_ccode_base_module_get_local_cname (ValaCCodeBaseModule* self, ValaLocalVariable* local) {
	gchar* result = NULL;
	gchar* cname = NULL;
	ValaLocalVariable* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar _tmp5_;
	gboolean _tmp6_;
	gboolean _tmp9_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (local != NULL, NULL);
	_tmp0_ = local;
	_tmp1_ = vala_symbol_get_name ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_variable_cname (self, _tmp2_);
	cname = _tmp3_;
	_tmp4_ = cname;
	_tmp5_ = string_get (_tmp4_, (glong) 0);
	_tmp6_ = g_ascii_isdigit (_tmp5_);
	if (_tmp6_) {
		const gchar* _tmp7_;
		gchar* _tmp8_;
		_tmp7_ = cname;
		_tmp8_ = g_strdup_printf ("_%s_", _tmp7_);
		_g_free0 (cname);
		cname = _tmp8_;
	}
	_tmp9_ = vala_ccode_base_module_is_in_coroutine (self);
	if (_tmp9_) {
		gint clash_index = 0;
		ValaCCodeBaseModuleEmitContext* _tmp10_;
		ValaMap* _tmp11_;
		ValaLocalVariable* _tmp12_;
		gpointer _tmp13_;
		gint _tmp14_;
		_tmp10_ = self->emit_context;
		_tmp11_ = _tmp10_->closure_variable_clash_map;
		_tmp12_ = local;
		_tmp13_ = vala_map_get (_tmp11_, _tmp12_);
		clash_index = (gint) ((gintptr) _tmp13_);
		_tmp14_ = clash_index;
		if (_tmp14_ > 0) {
			gint _tmp15_;
			const gchar* _tmp16_;
			gchar* _tmp17_;
			_tmp15_ = clash_index;
			_tmp16_ = cname;
			_tmp17_ = g_strdup_printf ("_vala%d_%s", _tmp15_, _tmp16_);
			_g_free0 (cname);
			cname = _tmp17_;
		}
	}
	result = cname;
	return result;
}


gchar* vala_ccode_base_module_get_variable_cname (ValaCCodeBaseModule* self, const gchar* name) {
	gchar* result = NULL;
	const gchar* _tmp0_;
	gchar _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (name != NULL, NULL);
	_tmp0_ = name;
	_tmp1_ = string_get (_tmp0_, (glong) 0);
	if (_tmp1_ == '.') {
		const gchar* _tmp2_;
		ValaMap* _tmp4_;
		ValaMap* _tmp5_;
		const gchar* _tmp6_;
		gboolean _tmp7_;
		ValaMap* _tmp17_;
		ValaMap* _tmp18_;
		const gchar* _tmp19_;
		gpointer _tmp20_;
		_tmp2_ = name;
		if (g_strcmp0 (_tmp2_, ".result") == 0) {
			gchar* _tmp3_;
			_tmp3_ = g_strdup ("result");
			result = _tmp3_;
			return result;
		}
		_tmp4_ = vala_ccode_base_module_get_variable_name_map (self);
		_tmp5_ = _tmp4_;
		_tmp6_ = name;
		_tmp7_ = vala_map_contains (_tmp5_, _tmp6_);
		if (!_tmp7_) {
			ValaMap* _tmp8_;
			ValaMap* _tmp9_;
			const gchar* _tmp10_;
			gint _tmp11_;
			gint _tmp12_;
			gchar* _tmp13_;
			gchar* _tmp14_;
			gint _tmp15_;
			gint _tmp16_;
			_tmp8_ = vala_ccode_base_module_get_variable_name_map (self);
			_tmp9_ = _tmp8_;
			_tmp10_ = name;
			_tmp11_ = vala_ccode_base_module_get_next_temp_var_id (self);
			_tmp12_ = _tmp11_;
			_tmp13_ = g_strdup_printf ("_tmp%d_", _tmp12_);
			_tmp14_ = _tmp13_;
			vala_map_set (_tmp9_, _tmp10_, _tmp14_);
			_g_free0 (_tmp14_);
			_tmp15_ = vala_ccode_base_module_get_next_temp_var_id (self);
			_tmp16_ = _tmp15_;
			vala_ccode_base_module_set_next_temp_var_id (self, _tmp16_ + 1);
		}
		_tmp17_ = vala_ccode_base_module_get_variable_name_map (self);
		_tmp18_ = _tmp17_;
		_tmp19_ = name;
		_tmp20_ = vala_map_get (_tmp18_, _tmp19_);
		result = (gchar*) _tmp20_;
		return result;
	} else {
		ValaSet* _tmp21_;
		const gchar* _tmp22_;
		gboolean _tmp23_;
		_tmp21_ = self->priv->reserved_identifiers;
		_tmp22_ = name;
		_tmp23_ = vala_collection_contains ((ValaCollection*) _tmp21_, _tmp22_);
		if (_tmp23_) {
			const gchar* _tmp24_;
			gchar* _tmp25_;
			_tmp24_ = name;
			_tmp25_ = g_strdup_printf ("_%s_", _tmp24_);
			result = _tmp25_;
			return result;
		} else {
			const gchar* _tmp26_;
			gchar* _tmp27_;
			_tmp26_ = name;
			_tmp27_ = g_strdup (_tmp26_);
			result = _tmp27_;
			return result;
		}
	}
}


ValaCCodeExpression* vala_ccode_base_module_get_result_cexpression (ValaCCodeBaseModule* self, const gchar* cname) {
	ValaCCodeExpression* result = NULL;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (cname != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_is_in_coroutine (self);
	if (_tmp0_) {
		ValaCCodeIdentifier* _tmp1_;
		ValaCCodeIdentifier* _tmp2_;
		const gchar* _tmp3_;
		ValaCCodeMemberAccess* _tmp4_;
		ValaCCodeExpression* _tmp5_;
		_tmp1_ = vala_ccode_identifier_new ("_data_");
		_tmp2_ = _tmp1_;
		_tmp3_ = cname;
		_tmp4_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp2_, _tmp3_);
		_tmp5_ = (ValaCCodeExpression*) _tmp4_;
		_vala_ccode_node_unref0 (_tmp2_);
		result = _tmp5_;
		return result;
	} else {
		const gchar* _tmp6_;
		ValaCCodeIdentifier* _tmp7_;
		_tmp6_ = cname;
		_tmp7_ = vala_ccode_identifier_new (_tmp6_);
		result = (ValaCCodeExpression*) _tmp7_;
		return result;
	}
}


gboolean vala_ccode_base_module_is_simple_struct_creation (ValaCCodeBaseModule* self, ValaVariable* variable, ValaExpression* expr) {
	gboolean result = FALSE;
	ValaStruct* st = NULL;
	ValaVariable* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaTypeSymbol* _tmp3_;
	ValaTypeSymbol* _tmp4_;
	ValaStruct* _tmp5_;
	ValaObjectCreationExpression* creation = NULL;
	ValaExpression* _tmp6_;
	ValaObjectCreationExpression* _tmp7_;
	gboolean _tmp8_ = FALSE;
	gboolean _tmp9_ = FALSE;
	gboolean _tmp10_ = FALSE;
	gboolean _tmp11_ = FALSE;
	gboolean _tmp12_ = FALSE;
	ValaObjectCreationExpression* _tmp13_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (variable != NULL, FALSE);
	g_return_val_if_fail (expr != NULL, FALSE);
	_tmp0_ = variable;
	_tmp1_ = vala_variable_get_variable_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_data_type_get_data_type (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp4_) : NULL);
	st = _tmp5_;
	_tmp6_ = expr;
	_tmp7_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_OBJECT_CREATION_EXPRESSION) ? ((ValaObjectCreationExpression*) _tmp6_) : NULL);
	creation = _tmp7_;
	_tmp13_ = creation;
	if (_tmp13_ != NULL) {
		ValaStruct* _tmp14_;
		_tmp14_ = st;
		_tmp12_ = _tmp14_ != NULL;
	} else {
		_tmp12_ = FALSE;
	}
	if (_tmp12_) {
		gboolean _tmp15_ = FALSE;
		ValaStruct* _tmp16_;
		gboolean _tmp17_;
		_tmp16_ = st;
		_tmp17_ = vala_struct_is_simple_type (_tmp16_);
		if (!_tmp17_) {
			_tmp15_ = TRUE;
		} else {
			ValaStruct* _tmp18_;
			gchar* _tmp19_;
			gchar* _tmp20_;
			_tmp18_ = st;
			_tmp19_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp18_);
			_tmp20_ = _tmp19_;
			_tmp15_ = g_strcmp0 (_tmp20_, "va_list") == 0;
			_g_free0 (_tmp20_);
		}
		_tmp11_ = _tmp15_;
	} else {
		_tmp11_ = FALSE;
	}
	if (_tmp11_) {
		ValaVariable* _tmp21_;
		ValaDataType* _tmp22_;
		ValaDataType* _tmp23_;
		gboolean _tmp24_;
		gboolean _tmp25_;
		_tmp21_ = variable;
		_tmp22_ = vala_variable_get_variable_type (_tmp21_);
		_tmp23_ = _tmp22_;
		_tmp24_ = vala_data_type_get_nullable (_tmp23_);
		_tmp25_ = _tmp24_;
		_tmp10_ = !_tmp25_;
	} else {
		_tmp10_ = FALSE;
	}
	if (_tmp10_) {
		ValaVariable* _tmp26_;
		ValaDataType* _tmp27_;
		ValaDataType* _tmp28_;
		ValaTypeSymbol* _tmp29_;
		ValaTypeSymbol* _tmp30_;
		ValaStruct* _tmp31_;
		_tmp26_ = variable;
		_tmp27_ = vala_variable_get_variable_type (_tmp26_);
		_tmp28_ = _tmp27_;
		_tmp29_ = vala_data_type_get_data_type (_tmp28_);
		_tmp30_ = _tmp29_;
		_tmp31_ = self->gvalue_type;
		_tmp9_ = _tmp30_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp31_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	} else {
		_tmp9_ = FALSE;
	}
	if (_tmp9_) {
		ValaObjectCreationExpression* _tmp32_;
		ValaList* _tmp33_;
		ValaList* _tmp34_;
		gint _tmp35_;
		gint _tmp36_;
		_tmp32_ = creation;
		_tmp33_ = vala_object_creation_expression_get_object_initializer (_tmp32_);
		_tmp34_ = _tmp33_;
		_tmp35_ = vala_collection_get_size ((ValaCollection*) _tmp34_);
		_tmp36_ = _tmp35_;
		_tmp8_ = _tmp36_ == 0;
		_vala_iterable_unref0 (_tmp34_);
	} else {
		_tmp8_ = FALSE;
	}
	if (_tmp8_) {
		result = TRUE;
		_vala_code_node_unref0 (creation);
		_vala_code_node_unref0 (st);
		return result;
	} else {
		result = FALSE;
		_vala_code_node_unref0 (creation);
		_vala_code_node_unref0 (st);
		return result;
	}
	_vala_code_node_unref0 (creation);
	_vala_code_node_unref0 (st);
}


static gboolean vala_ccode_base_module_is_foreach_element_variable (ValaCCodeBaseModule* self, ValaLocalVariable* local) {
	gboolean result = FALSE;
	ValaSymbol* block = NULL;
	ValaLocalVariable* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp3_;
	ValaSymbol* _tmp4_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (local != NULL, FALSE);
	_tmp0_ = local;
	_tmp1_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (_tmp2_);
	block = _tmp3_;
	_tmp4_ = block;
	if (_tmp4_ != NULL) {
		ValaForeachStatement* stmt = NULL;
		ValaSymbol* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		ValaForeachStatement* _tmp8_;
		gboolean _tmp9_ = FALSE;
		gboolean _tmp10_ = FALSE;
		ValaForeachStatement* _tmp11_;
		_tmp5_ = block;
		_tmp6_ = vala_symbol_get_parent_symbol (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_FOREACH_STATEMENT) ? ((ValaForeachStatement*) _tmp7_) : NULL);
		stmt = _tmp8_;
		_tmp11_ = stmt;
		if (_tmp11_ != NULL) {
			ValaForeachStatement* _tmp12_;
			gboolean _tmp13_;
			gboolean _tmp14_;
			_tmp12_ = stmt;
			_tmp13_ = vala_foreach_statement_get_use_iterator (_tmp12_);
			_tmp14_ = _tmp13_;
			_tmp10_ = !_tmp14_;
		} else {
			_tmp10_ = FALSE;
		}
		if (_tmp10_) {
			ValaForeachStatement* _tmp15_;
			ValaLocalVariable* _tmp16_;
			ValaLocalVariable* _tmp17_;
			ValaLocalVariable* _tmp18_;
			_tmp15_ = stmt;
			_tmp16_ = vala_foreach_statement_get_element_variable (_tmp15_);
			_tmp17_ = _tmp16_;
			_tmp18_ = local;
			_tmp9_ = _tmp17_ == _tmp18_;
		} else {
			_tmp9_ = FALSE;
		}
		if (_tmp9_) {
			result = TRUE;
			_vala_code_node_unref0 (stmt);
			_vala_code_node_unref0 (block);
			return result;
		}
		_vala_code_node_unref0 (stmt);
	}
	result = FALSE;
	_vala_code_node_unref0 (block);
	return result;
}


static void vala_ccode_base_module_real_visit_local_variable (ValaCodeVisitor* base, ValaLocalVariable* local) {
	ValaCCodeBaseModule * self;
	ValaLocalVariable* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaLocalVariable* _tmp3_;
	ValaDataType* _tmp4_;
	ValaDataType* _tmp5_;
	ValaCCodeFile* _tmp6_;
	gboolean _tmp7_ = FALSE;
	ValaLocalVariable* _tmp8_;
	gboolean _tmp9_;
	gboolean _tmp10_;
	gboolean declared = FALSE;
	gboolean _tmp13_;
	ValaLocalVariable* _tmp71_;
	ValaExpression* _tmp72_;
	ValaExpression* _tmp73_;
	ValaCCodeExpression* rhs = NULL;
	gboolean _tmp80_ = FALSE;
	ValaLocalVariable* _tmp81_;
	ValaExpression* _tmp82_;
	ValaExpression* _tmp83_;
	gboolean _tmp93_;
	ValaCCodeExpression* _tmp190_;
	gboolean _tmp202_ = FALSE;
	ValaLocalVariable* _tmp203_;
	ValaExpression* _tmp204_;
	ValaExpression* _tmp205_;
	ValaLocalVariable* _tmp214_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (local != NULL);
	_tmp0_ = local;
	_tmp1_ = vala_variable_get_variable_type ((ValaVariable*) _tmp0_);
	_tmp2_ = _tmp1_;
	vala_ccode_base_module_check_type (self, _tmp2_);
	_tmp3_ = local;
	_tmp4_ = vala_variable_get_variable_type ((ValaVariable*) _tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = self->cfile;
	vala_ccode_base_module_generate_type_declaration (self, _tmp5_, _tmp6_);
	_tmp8_ = local;
	_tmp9_ = vala_local_variable_get_captured (_tmp8_);
	_tmp10_ = _tmp9_;
	if (!_tmp10_) {
		_tmp7_ = TRUE;
	} else {
		ValaLocalVariable* _tmp11_;
		gboolean _tmp12_;
		_tmp11_ = local;
		_tmp12_ = vala_ccode_base_module_is_foreach_element_variable (self, _tmp11_);
		_tmp7_ = _tmp12_;
	}
	declared = _tmp7_;
	_tmp13_ = declared;
	if (_tmp13_) {
		gboolean _tmp14_;
		_tmp14_ = vala_ccode_base_module_is_in_coroutine (self);
		if (_tmp14_) {
			gint count = 0;
			ValaCCodeBaseModuleEmitContext* _tmp15_;
			ValaMap* _tmp16_;
			ValaLocalVariable* _tmp17_;
			const gchar* _tmp18_;
			const gchar* _tmp19_;
			gpointer _tmp20_;
			gint _tmp21_;
			ValaCCodeBaseModuleEmitContext* _tmp26_;
			ValaMap* _tmp27_;
			ValaLocalVariable* _tmp28_;
			const gchar* _tmp29_;
			const gchar* _tmp30_;
			gint _tmp31_;
			ValaCCodeStruct* _tmp32_;
			ValaLocalVariable* _tmp33_;
			ValaDataType* _tmp34_;
			ValaDataType* _tmp35_;
			gchar* _tmp36_;
			gchar* _tmp37_;
			ValaLocalVariable* _tmp38_;
			gchar* _tmp39_;
			gchar* _tmp40_;
			ValaLocalVariable* _tmp41_;
			ValaDataType* _tmp42_;
			ValaDataType* _tmp43_;
			ValaCCodeDeclaratorSuffix* _tmp44_;
			ValaCCodeDeclaratorSuffix* _tmp45_;
			_tmp15_ = self->emit_context;
			_tmp16_ = _tmp15_->closure_variable_count_map;
			_tmp17_ = local;
			_tmp18_ = vala_symbol_get_name ((ValaSymbol*) _tmp17_);
			_tmp19_ = _tmp18_;
			_tmp20_ = vala_map_get (_tmp16_, _tmp19_);
			count = (gint) ((gintptr) _tmp20_);
			_tmp21_ = count;
			if (_tmp21_ > 0) {
				ValaCCodeBaseModuleEmitContext* _tmp22_;
				ValaMap* _tmp23_;
				ValaLocalVariable* _tmp24_;
				gint _tmp25_;
				_tmp22_ = self->emit_context;
				_tmp23_ = _tmp22_->closure_variable_clash_map;
				_tmp24_ = local;
				_tmp25_ = count;
				vala_map_set (_tmp23_, _tmp24_, (gpointer) ((gintptr) _tmp25_));
			}
			_tmp26_ = self->emit_context;
			_tmp27_ = _tmp26_->closure_variable_count_map;
			_tmp28_ = local;
			_tmp29_ = vala_symbol_get_name ((ValaSymbol*) _tmp28_);
			_tmp30_ = _tmp29_;
			_tmp31_ = count;
			vala_map_set (_tmp27_, _tmp30_, (gpointer) ((gintptr) (_tmp31_ + 1)));
			_tmp32_ = self->closure_struct;
			_tmp33_ = local;
			_tmp34_ = vala_variable_get_variable_type ((ValaVariable*) _tmp33_);
			_tmp35_ = _tmp34_;
			_tmp36_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp35_);
			_tmp37_ = _tmp36_;
			_tmp38_ = local;
			_tmp39_ = vala_ccode_base_module_get_local_cname (self, _tmp38_);
			_tmp40_ = _tmp39_;
			_tmp41_ = local;
			_tmp42_ = vala_variable_get_variable_type ((ValaVariable*) _tmp41_);
			_tmp43_ = _tmp42_;
			_tmp44_ = vala_ccode_base_module_get_ccode_declarator_suffix (self, _tmp43_);
			_tmp45_ = _tmp44_;
			vala_ccode_struct_add_field (_tmp32_, _tmp37_, _tmp40_, 0, _tmp45_);
			_vala_ccode_declarator_suffix_unref0 (_tmp45_);
			_g_free0 (_tmp40_);
			_g_free0 (_tmp37_);
		} else {
			ValaCCodeVariableDeclarator* cvar = NULL;
			ValaLocalVariable* _tmp46_;
			gchar* _tmp47_;
			gchar* _tmp48_;
			ValaLocalVariable* _tmp49_;
			ValaDataType* _tmp50_;
			ValaDataType* _tmp51_;
			ValaCCodeDeclaratorSuffix* _tmp52_;
			ValaCCodeDeclaratorSuffix* _tmp53_;
			ValaCCodeVariableDeclarator* _tmp54_;
			ValaCCodeVariableDeclarator* _tmp55_;
			ValaCCodeVariableDeclarator* _tmp56_;
			ValaLocalVariable* _tmp57_;
			ValaDataType* _tmp58_;
			ValaDataType* _tmp59_;
			ValaCCodeExpression* _tmp60_;
			ValaCCodeExpression* _tmp61_;
			ValaCCodeVariableDeclarator* _tmp62_;
			ValaCCodeFunction* _tmp63_;
			ValaCCodeFunction* _tmp64_;
			ValaLocalVariable* _tmp65_;
			ValaDataType* _tmp66_;
			ValaDataType* _tmp67_;
			gchar* _tmp68_;
			gchar* _tmp69_;
			ValaCCodeVariableDeclarator* _tmp70_;
			_tmp46_ = local;
			_tmp47_ = vala_ccode_base_module_get_local_cname (self, _tmp46_);
			_tmp48_ = _tmp47_;
			_tmp49_ = local;
			_tmp50_ = vala_variable_get_variable_type ((ValaVariable*) _tmp49_);
			_tmp51_ = _tmp50_;
			_tmp52_ = vala_ccode_base_module_get_ccode_declarator_suffix (self, _tmp51_);
			_tmp53_ = _tmp52_;
			_tmp54_ = vala_ccode_variable_declarator_new (_tmp48_, NULL, _tmp53_);
			_tmp55_ = _tmp54_;
			_vala_ccode_declarator_suffix_unref0 (_tmp53_);
			_g_free0 (_tmp48_);
			cvar = _tmp55_;
			_tmp56_ = cvar;
			_tmp57_ = local;
			_tmp58_ = vala_variable_get_variable_type ((ValaVariable*) _tmp57_);
			_tmp59_ = _tmp58_;
			_tmp60_ = vala_ccode_base_module_default_value_for_type (self, _tmp59_, TRUE);
			_tmp61_ = _tmp60_;
			vala_ccode_variable_declarator_set_initializer (_tmp56_, _tmp61_);
			_vala_ccode_node_unref0 (_tmp61_);
			_tmp62_ = cvar;
			vala_ccode_variable_declarator_set_init0 (_tmp62_, TRUE);
			_tmp63_ = vala_ccode_base_module_get_ccode (self);
			_tmp64_ = _tmp63_;
			_tmp65_ = local;
			_tmp66_ = vala_variable_get_variable_type ((ValaVariable*) _tmp65_);
			_tmp67_ = _tmp66_;
			_tmp68_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp67_);
			_tmp69_ = _tmp68_;
			_tmp70_ = cvar;
			vala_ccode_function_add_declaration (_tmp64_, _tmp69_, (ValaCCodeDeclarator*) _tmp70_, 0);
			_g_free0 (_tmp69_);
			_vala_ccode_node_unref0 (cvar);
		}
	}
	_tmp71_ = local;
	_tmp72_ = vala_variable_get_initializer ((ValaVariable*) _tmp71_);
	_tmp73_ = _tmp72_;
	if (_tmp73_ != NULL) {
		ValaLocalVariable* _tmp74_;
		ValaExpression* _tmp75_;
		ValaExpression* _tmp76_;
		ValaLocalVariable* _tmp77_;
		ValaExpression* _tmp78_;
		ValaExpression* _tmp79_;
		_tmp74_ = local;
		_tmp75_ = vala_variable_get_initializer ((ValaVariable*) _tmp74_);
		_tmp76_ = _tmp75_;
		vala_code_node_emit ((ValaCodeNode*) _tmp76_, (ValaCodeGenerator*) self);
		_tmp77_ = local;
		_tmp78_ = vala_variable_get_initializer ((ValaVariable*) _tmp77_);
		_tmp79_ = _tmp78_;
		vala_code_visitor_visit_end_full_expression ((ValaCodeVisitor*) self, _tmp79_);
	}
	rhs = NULL;
	_tmp81_ = local;
	_tmp82_ = vala_variable_get_initializer ((ValaVariable*) _tmp81_);
	_tmp83_ = _tmp82_;
	if (_tmp83_ != NULL) {
		ValaLocalVariable* _tmp84_;
		ValaExpression* _tmp85_;
		ValaExpression* _tmp86_;
		ValaCCodeExpression* _tmp87_;
		ValaCCodeExpression* _tmp88_;
		_tmp84_ = local;
		_tmp85_ = vala_variable_get_initializer ((ValaVariable*) _tmp84_);
		_tmp86_ = _tmp85_;
		_tmp87_ = vala_ccode_base_module_get_cvalue (self, _tmp86_);
		_tmp88_ = _tmp87_;
		_tmp80_ = _tmp88_ != NULL;
		_vala_ccode_node_unref0 (_tmp88_);
	} else {
		_tmp80_ = FALSE;
	}
	if (_tmp80_) {
		ValaLocalVariable* _tmp89_;
		ValaExpression* _tmp90_;
		ValaExpression* _tmp91_;
		ValaCCodeExpression* _tmp92_;
		_tmp89_ = local;
		_tmp90_ = vala_variable_get_initializer ((ValaVariable*) _tmp89_);
		_tmp91_ = _tmp90_;
		_tmp92_ = vala_ccode_base_module_get_cvalue (self, _tmp91_);
		_vala_ccode_node_unref0 (rhs);
		rhs = _tmp92_;
	}
	_tmp93_ = declared;
	if (_tmp93_) {
		ValaLocalVariable* _tmp94_;
		ValaDataType* _tmp95_;
		ValaDataType* _tmp96_;
		_tmp94_ = local;
		_tmp95_ = vala_variable_get_variable_type ((ValaVariable*) _tmp94_);
		_tmp96_ = _tmp95_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp96_, VALA_TYPE_ARRAY_TYPE)) {
			ValaArrayType* array_type = NULL;
			ValaLocalVariable* _tmp97_;
			ValaDataType* _tmp98_;
			ValaDataType* _tmp99_;
			ValaArrayType* _tmp100_;
			ValaArrayType* _tmp101_;
			gboolean _tmp102_;
			gboolean _tmp103_;
			_tmp97_ = local;
			_tmp98_ = vala_variable_get_variable_type ((ValaVariable*) _tmp97_);
			_tmp99_ = _tmp98_;
			_tmp100_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp99_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			array_type = _tmp100_;
			_tmp101_ = array_type;
			_tmp102_ = vala_array_type_get_fixed_length (_tmp101_);
			_tmp103_ = _tmp102_;
			if (!_tmp103_) {
				ValaArrayType* _tmp126_;
				gint _tmp127_;
				gint _tmp128_;
				{
					gint dim = 0;
					dim = 1;
					{
						gboolean _tmp104_ = FALSE;
						_tmp104_ = TRUE;
						while (TRUE) {
							gint _tmp106_;
							ValaArrayType* _tmp107_;
							gint _tmp108_;
							gint _tmp109_;
							ValaLocalVariable* len_var = NULL;
							ValaDataType* _tmp110_;
							ValaDataType* _tmp111_;
							ValaDataType* _tmp112_;
							ValaLocalVariable* _tmp113_;
							gchar* _tmp114_;
							gchar* _tmp115_;
							gint _tmp116_;
							gchar* _tmp117_;
							gchar* _tmp118_;
							ValaLocalVariable* _tmp119_;
							ValaLocalVariable* _tmp120_;
							ValaLocalVariable* _tmp121_;
							ValaLocalVariable* _tmp122_;
							ValaExpression* _tmp123_;
							ValaExpression* _tmp124_;
							ValaLocalVariable* _tmp125_;
							if (!_tmp104_) {
								gint _tmp105_;
								_tmp105_ = dim;
								dim = _tmp105_ + 1;
							}
							_tmp104_ = FALSE;
							_tmp106_ = dim;
							_tmp107_ = array_type;
							_tmp108_ = vala_array_type_get_rank (_tmp107_);
							_tmp109_ = _tmp108_;
							if (!(_tmp106_ <= _tmp109_)) {
								break;
							}
							_tmp110_ = self->int_type;
							_tmp111_ = vala_data_type_copy (_tmp110_);
							_tmp112_ = _tmp111_;
							_tmp113_ = local;
							_tmp114_ = vala_ccode_base_module_get_local_cname (self, _tmp113_);
							_tmp115_ = _tmp114_;
							_tmp116_ = dim;
							_tmp117_ = vala_ccode_base_module_get_array_length_cname (self, _tmp115_, _tmp116_);
							_tmp118_ = _tmp117_;
							_tmp119_ = vala_local_variable_new (_tmp112_, _tmp118_, NULL, NULL);
							_tmp120_ = _tmp119_;
							_g_free0 (_tmp118_);
							_g_free0 (_tmp115_);
							_vala_code_node_unref0 (_tmp112_);
							len_var = _tmp120_;
							_tmp121_ = len_var;
							_tmp122_ = local;
							_tmp123_ = vala_variable_get_initializer ((ValaVariable*) _tmp122_);
							_tmp124_ = _tmp123_;
							vala_local_variable_set_init (_tmp121_, _tmp124_ == NULL);
							_tmp125_ = len_var;
							vala_ccode_base_module_emit_temp_var (self, _tmp125_);
							_vala_code_node_unref0 (len_var);
						}
					}
				}
				_tmp126_ = array_type;
				_tmp127_ = vala_array_type_get_rank (_tmp126_);
				_tmp128_ = _tmp127_;
				if (_tmp128_ == 1) {
					ValaLocalVariable* size_var = NULL;
					ValaDataType* _tmp129_;
					ValaDataType* _tmp130_;
					ValaDataType* _tmp131_;
					ValaLocalVariable* _tmp132_;
					gchar* _tmp133_;
					gchar* _tmp134_;
					gchar* _tmp135_;
					gchar* _tmp136_;
					ValaLocalVariable* _tmp137_;
					ValaLocalVariable* _tmp138_;
					ValaLocalVariable* _tmp139_;
					ValaLocalVariable* _tmp140_;
					ValaExpression* _tmp141_;
					ValaExpression* _tmp142_;
					ValaLocalVariable* _tmp143_;
					_tmp129_ = self->int_type;
					_tmp130_ = vala_data_type_copy (_tmp129_);
					_tmp131_ = _tmp130_;
					_tmp132_ = local;
					_tmp133_ = vala_ccode_base_module_get_local_cname (self, _tmp132_);
					_tmp134_ = _tmp133_;
					_tmp135_ = vala_ccode_base_module_get_array_size_cname (self, _tmp134_);
					_tmp136_ = _tmp135_;
					_tmp137_ = vala_local_variable_new (_tmp131_, _tmp136_, NULL, NULL);
					_tmp138_ = _tmp137_;
					_g_free0 (_tmp136_);
					_g_free0 (_tmp134_);
					_vala_code_node_unref0 (_tmp131_);
					size_var = _tmp138_;
					_tmp139_ = size_var;
					_tmp140_ = local;
					_tmp141_ = vala_variable_get_initializer ((ValaVariable*) _tmp140_);
					_tmp142_ = _tmp141_;
					vala_local_variable_set_init (_tmp139_, _tmp142_ == NULL);
					_tmp143_ = size_var;
					vala_ccode_base_module_emit_temp_var (self, _tmp143_);
					_vala_code_node_unref0 (size_var);
				}
			}
			_vala_code_node_unref0 (array_type);
		} else {
			ValaLocalVariable* _tmp144_;
			ValaDataType* _tmp145_;
			ValaDataType* _tmp146_;
			_tmp144_ = local;
			_tmp145_ = vala_variable_get_variable_type ((ValaVariable*) _tmp144_);
			_tmp146_ = _tmp145_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp146_, VALA_TYPE_DELEGATE_TYPE)) {
				ValaDelegateType* deleg_type = NULL;
				ValaLocalVariable* _tmp147_;
				ValaDataType* _tmp148_;
				ValaDataType* _tmp149_;
				ValaDelegateType* _tmp150_;
				ValaDelegate* d = NULL;
				ValaDelegateType* _tmp151_;
				ValaDelegate* _tmp152_;
				ValaDelegate* _tmp153_;
				ValaDelegate* _tmp154_;
				ValaDelegate* _tmp155_;
				gboolean _tmp156_;
				gboolean _tmp157_;
				_tmp147_ = local;
				_tmp148_ = vala_variable_get_variable_type ((ValaVariable*) _tmp147_);
				_tmp149_ = _tmp148_;
				_tmp150_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp149_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
				deleg_type = _tmp150_;
				_tmp151_ = deleg_type;
				_tmp152_ = vala_delegate_type_get_delegate_symbol (_tmp151_);
				_tmp153_ = _tmp152_;
				_tmp154_ = _vala_code_node_ref0 (_tmp153_);
				d = _tmp154_;
				_tmp155_ = d;
				_tmp156_ = vala_delegate_get_has_target (_tmp155_);
				_tmp157_ = _tmp156_;
				if (_tmp157_) {
					ValaLocalVariable* target_var = NULL;
					ValaVoidType* _tmp158_;
					ValaVoidType* _tmp159_;
					ValaPointerType* _tmp160_;
					ValaPointerType* _tmp161_;
					ValaLocalVariable* _tmp162_;
					gchar* _tmp163_;
					gchar* _tmp164_;
					gchar* _tmp165_;
					gchar* _tmp166_;
					ValaLocalVariable* _tmp167_;
					ValaLocalVariable* _tmp168_;
					ValaLocalVariable* _tmp169_;
					ValaLocalVariable* _tmp170_;
					ValaExpression* _tmp171_;
					ValaExpression* _tmp172_;
					ValaLocalVariable* _tmp173_;
					ValaDelegateType* _tmp174_;
					gboolean _tmp175_;
					gboolean _tmp176_;
					_tmp158_ = vala_void_type_new (NULL);
					_tmp159_ = _tmp158_;
					_tmp160_ = vala_pointer_type_new ((ValaDataType*) _tmp159_, NULL);
					_tmp161_ = _tmp160_;
					_tmp162_ = local;
					_tmp163_ = vala_ccode_base_module_get_local_cname (self, _tmp162_);
					_tmp164_ = _tmp163_;
					_tmp165_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp164_);
					_tmp166_ = _tmp165_;
					_tmp167_ = vala_local_variable_new ((ValaDataType*) _tmp161_, _tmp166_, NULL, NULL);
					_tmp168_ = _tmp167_;
					_g_free0 (_tmp166_);
					_g_free0 (_tmp164_);
					_vala_code_node_unref0 (_tmp161_);
					_vala_code_node_unref0 (_tmp159_);
					target_var = _tmp168_;
					_tmp169_ = target_var;
					_tmp170_ = local;
					_tmp171_ = vala_variable_get_initializer ((ValaVariable*) _tmp170_);
					_tmp172_ = _tmp171_;
					vala_local_variable_set_init (_tmp169_, _tmp172_ == NULL);
					_tmp173_ = target_var;
					vala_ccode_base_module_emit_temp_var (self, _tmp173_);
					_tmp174_ = deleg_type;
					_tmp175_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp174_);
					_tmp176_ = _tmp175_;
					if (_tmp176_) {
						ValaLocalVariable* target_destroy_notify_var = NULL;
						ValaDataType* _tmp177_;
						ValaLocalVariable* _tmp178_;
						gchar* _tmp179_;
						gchar* _tmp180_;
						gchar* _tmp181_;
						gchar* _tmp182_;
						ValaLocalVariable* _tmp183_;
						ValaLocalVariable* _tmp184_;
						ValaLocalVariable* _tmp185_;
						ValaLocalVariable* _tmp186_;
						ValaExpression* _tmp187_;
						ValaExpression* _tmp188_;
						ValaLocalVariable* _tmp189_;
						_tmp177_ = self->gdestroynotify_type;
						_tmp178_ = local;
						_tmp179_ = vala_ccode_base_module_get_local_cname (self, _tmp178_);
						_tmp180_ = _tmp179_;
						_tmp181_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp180_);
						_tmp182_ = _tmp181_;
						_tmp183_ = vala_local_variable_new (_tmp177_, _tmp182_, NULL, NULL);
						_tmp184_ = _tmp183_;
						_g_free0 (_tmp182_);
						_g_free0 (_tmp180_);
						target_destroy_notify_var = _tmp184_;
						_tmp185_ = target_destroy_notify_var;
						_tmp186_ = local;
						_tmp187_ = vala_variable_get_initializer ((ValaVariable*) _tmp186_);
						_tmp188_ = _tmp187_;
						vala_local_variable_set_init (_tmp185_, _tmp188_ == NULL);
						_tmp189_ = target_destroy_notify_var;
						vala_ccode_base_module_emit_temp_var (self, _tmp189_);
						_vala_code_node_unref0 (target_destroy_notify_var);
					}
					_vala_code_node_unref0 (target_var);
				}
				_vala_code_node_unref0 (d);
				_vala_code_node_unref0 (deleg_type);
			}
		}
	}
	_tmp190_ = rhs;
	if (_tmp190_ != NULL) {
		ValaLocalVariable* _tmp191_;
		ValaLocalVariable* _tmp192_;
		ValaExpression* _tmp193_;
		ValaExpression* _tmp194_;
		gboolean _tmp195_;
		_tmp191_ = local;
		_tmp192_ = local;
		_tmp193_ = vala_variable_get_initializer ((ValaVariable*) _tmp192_);
		_tmp194_ = _tmp193_;
		_tmp195_ = vala_ccode_base_module_is_simple_struct_creation (self, (ValaVariable*) _tmp191_, _tmp194_);
		if (!_tmp195_) {
			ValaLocalVariable* _tmp196_;
			ValaLocalVariable* _tmp197_;
			ValaExpression* _tmp198_;
			ValaExpression* _tmp199_;
			ValaTargetValue* _tmp200_;
			ValaTargetValue* _tmp201_;
			_tmp196_ = local;
			_tmp197_ = local;
			_tmp198_ = vala_variable_get_initializer ((ValaVariable*) _tmp197_);
			_tmp199_ = _tmp198_;
			_tmp200_ = vala_expression_get_target_value (_tmp199_);
			_tmp201_ = _tmp200_;
			vala_code_generator_store_local ((ValaCodeGenerator*) self, _tmp196_, _tmp201_, TRUE);
		}
	}
	_tmp203_ = local;
	_tmp204_ = vala_variable_get_initializer ((ValaVariable*) _tmp203_);
	_tmp205_ = _tmp204_;
	if (_tmp205_ != NULL) {
		ValaLocalVariable* _tmp206_;
		ValaExpression* _tmp207_;
		ValaExpression* _tmp208_;
		gboolean _tmp209_;
		gboolean _tmp210_;
		_tmp206_ = local;
		_tmp207_ = vala_variable_get_initializer ((ValaVariable*) _tmp206_);
		_tmp208_ = _tmp207_;
		_tmp209_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp208_);
		_tmp210_ = _tmp209_;
		_tmp202_ = _tmp210_;
	} else {
		_tmp202_ = FALSE;
	}
	if (_tmp202_) {
		ValaLocalVariable* _tmp211_;
		ValaExpression* _tmp212_;
		ValaExpression* _tmp213_;
		_tmp211_ = local;
		_tmp212_ = vala_variable_get_initializer ((ValaVariable*) _tmp211_);
		_tmp213_ = _tmp212_;
		vala_ccode_base_module_add_simple_check (self, (ValaCodeNode*) _tmp213_, FALSE);
	}
	_tmp214_ = local;
	vala_symbol_set_active ((ValaSymbol*) _tmp214_, TRUE);
	_vala_ccode_node_unref0 (rhs);
}


/**
 * Create a temporary variable and return lvalue access to it
 */
ValaTargetValue* vala_ccode_base_module_create_temp_value (ValaCCodeBaseModule* self, ValaDataType* type, gboolean init, ValaCodeNode* node_reference, gboolean* value_owned) {
	ValaTargetValue* result = NULL;
	ValaLocalVariable* local = NULL;
	ValaDataType* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	ValaCodeNode* _tmp7_;
	ValaSourceReference* _tmp8_;
	ValaSourceReference* _tmp9_;
	ValaLocalVariable* _tmp10_;
	ValaLocalVariable* _tmp11_;
	ValaLocalVariable* _tmp12_;
	gboolean _tmp13_;
	gboolean* _tmp14_;
	ValaArrayType* array_type = NULL;
	ValaLocalVariable* _tmp19_;
	ValaDataType* _tmp20_;
	ValaDataType* _tmp21_;
	ValaArrayType* _tmp22_;
	ValaDelegateType* deleg_type = NULL;
	ValaLocalVariable* _tmp23_;
	ValaDataType* _tmp24_;
	ValaDataType* _tmp25_;
	ValaDelegateType* _tmp26_;
	ValaLocalVariable* _tmp27_;
	ValaArrayType* _tmp28_;
	ValaTargetValue* value = NULL;
	ValaLocalVariable* _tmp95_;
	ValaTargetValue* _tmp96_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	g_return_val_if_fail (node_reference != NULL, NULL);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_copy (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_next_temp_var_id (self);
	_tmp4_ = _tmp3_;
	vala_ccode_base_module_set_next_temp_var_id (self, _tmp4_ + 1);
	_tmp5_ = g_strdup_printf ("_tmp%d_", _tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = node_reference;
	_tmp8_ = vala_code_node_get_source_reference (_tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_local_variable_new (_tmp2_, _tmp6_, NULL, _tmp9_);
	_tmp11_ = _tmp10_;
	_g_free0 (_tmp6_);
	_vala_code_node_unref0 (_tmp2_);
	local = _tmp11_;
	_tmp12_ = local;
	_tmp13_ = init;
	vala_local_variable_set_init (_tmp12_, _tmp13_);
	_tmp14_ = value_owned;
	if (_tmp14_ != NULL) {
		ValaLocalVariable* _tmp15_;
		ValaDataType* _tmp16_;
		ValaDataType* _tmp17_;
		gboolean* _tmp18_;
		_tmp15_ = local;
		_tmp16_ = vala_variable_get_variable_type ((ValaVariable*) _tmp15_);
		_tmp17_ = _tmp16_;
		_tmp18_ = value_owned;
		vala_data_type_set_value_owned (_tmp17_, *_tmp18_);
	}
	_tmp19_ = local;
	_tmp20_ = vala_variable_get_variable_type ((ValaVariable*) _tmp19_);
	_tmp21_ = _tmp20_;
	_tmp22_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp21_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp21_) : NULL);
	array_type = _tmp22_;
	_tmp23_ = local;
	_tmp24_ = vala_variable_get_variable_type ((ValaVariable*) _tmp23_);
	_tmp25_ = _tmp24_;
	_tmp26_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp25_) : NULL);
	deleg_type = _tmp26_;
	_tmp27_ = local;
	vala_ccode_base_module_emit_temp_var (self, _tmp27_);
	_tmp28_ = array_type;
	if (_tmp28_ != NULL) {
		{
			gint dim = 0;
			dim = 1;
			{
				gboolean _tmp29_ = FALSE;
				_tmp29_ = TRUE;
				while (TRUE) {
					gint _tmp31_;
					ValaArrayType* _tmp32_;
					gint _tmp33_;
					gint _tmp34_;
					ValaLocalVariable* len_var = NULL;
					ValaDataType* _tmp35_;
					ValaDataType* _tmp36_;
					ValaDataType* _tmp37_;
					ValaLocalVariable* _tmp38_;
					const gchar* _tmp39_;
					const gchar* _tmp40_;
					gint _tmp41_;
					gchar* _tmp42_;
					gchar* _tmp43_;
					ValaCodeNode* _tmp44_;
					ValaSourceReference* _tmp45_;
					ValaSourceReference* _tmp46_;
					ValaLocalVariable* _tmp47_;
					ValaLocalVariable* _tmp48_;
					ValaLocalVariable* _tmp49_;
					gboolean _tmp50_;
					ValaLocalVariable* _tmp51_;
					if (!_tmp29_) {
						gint _tmp30_;
						_tmp30_ = dim;
						dim = _tmp30_ + 1;
					}
					_tmp29_ = FALSE;
					_tmp31_ = dim;
					_tmp32_ = array_type;
					_tmp33_ = vala_array_type_get_rank (_tmp32_);
					_tmp34_ = _tmp33_;
					if (!(_tmp31_ <= _tmp34_)) {
						break;
					}
					_tmp35_ = self->int_type;
					_tmp36_ = vala_data_type_copy (_tmp35_);
					_tmp37_ = _tmp36_;
					_tmp38_ = local;
					_tmp39_ = vala_symbol_get_name ((ValaSymbol*) _tmp38_);
					_tmp40_ = _tmp39_;
					_tmp41_ = dim;
					_tmp42_ = vala_ccode_base_module_get_array_length_cname (self, _tmp40_, _tmp41_);
					_tmp43_ = _tmp42_;
					_tmp44_ = node_reference;
					_tmp45_ = vala_code_node_get_source_reference (_tmp44_);
					_tmp46_ = _tmp45_;
					_tmp47_ = vala_local_variable_new (_tmp37_, _tmp43_, NULL, _tmp46_);
					_tmp48_ = _tmp47_;
					_g_free0 (_tmp43_);
					_vala_code_node_unref0 (_tmp37_);
					len_var = _tmp48_;
					_tmp49_ = len_var;
					_tmp50_ = init;
					vala_local_variable_set_init (_tmp49_, _tmp50_);
					_tmp51_ = len_var;
					vala_ccode_base_module_emit_temp_var (self, _tmp51_);
					_vala_code_node_unref0 (len_var);
				}
			}
		}
	} else {
		gboolean _tmp52_ = FALSE;
		ValaDelegateType* _tmp53_;
		_tmp53_ = deleg_type;
		if (_tmp53_ != NULL) {
			ValaDelegateType* _tmp54_;
			ValaDelegate* _tmp55_;
			ValaDelegate* _tmp56_;
			gboolean _tmp57_;
			gboolean _tmp58_;
			_tmp54_ = deleg_type;
			_tmp55_ = vala_delegate_type_get_delegate_symbol (_tmp54_);
			_tmp56_ = _tmp55_;
			_tmp57_ = vala_delegate_get_has_target (_tmp56_);
			_tmp58_ = _tmp57_;
			_tmp52_ = _tmp58_;
		} else {
			_tmp52_ = FALSE;
		}
		if (_tmp52_) {
			ValaLocalVariable* target_var = NULL;
			ValaVoidType* _tmp59_;
			ValaVoidType* _tmp60_;
			ValaPointerType* _tmp61_;
			ValaPointerType* _tmp62_;
			ValaLocalVariable* _tmp63_;
			const gchar* _tmp64_;
			const gchar* _tmp65_;
			gchar* _tmp66_;
			gchar* _tmp67_;
			ValaCodeNode* _tmp68_;
			ValaSourceReference* _tmp69_;
			ValaSourceReference* _tmp70_;
			ValaLocalVariable* _tmp71_;
			ValaLocalVariable* _tmp72_;
			ValaLocalVariable* _tmp73_;
			gboolean _tmp74_;
			ValaLocalVariable* _tmp75_;
			ValaDelegateType* _tmp76_;
			gboolean _tmp77_;
			gboolean _tmp78_;
			_tmp59_ = vala_void_type_new (NULL);
			_tmp60_ = _tmp59_;
			_tmp61_ = vala_pointer_type_new ((ValaDataType*) _tmp60_, NULL);
			_tmp62_ = _tmp61_;
			_tmp63_ = local;
			_tmp64_ = vala_symbol_get_name ((ValaSymbol*) _tmp63_);
			_tmp65_ = _tmp64_;
			_tmp66_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp65_);
			_tmp67_ = _tmp66_;
			_tmp68_ = node_reference;
			_tmp69_ = vala_code_node_get_source_reference (_tmp68_);
			_tmp70_ = _tmp69_;
			_tmp71_ = vala_local_variable_new ((ValaDataType*) _tmp62_, _tmp67_, NULL, _tmp70_);
			_tmp72_ = _tmp71_;
			_g_free0 (_tmp67_);
			_vala_code_node_unref0 (_tmp62_);
			_vala_code_node_unref0 (_tmp60_);
			target_var = _tmp72_;
			_tmp73_ = target_var;
			_tmp74_ = init;
			vala_local_variable_set_init (_tmp73_, _tmp74_);
			_tmp75_ = target_var;
			vala_ccode_base_module_emit_temp_var (self, _tmp75_);
			_tmp76_ = deleg_type;
			_tmp77_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp76_);
			_tmp78_ = _tmp77_;
			if (_tmp78_) {
				ValaLocalVariable* target_destroy_notify_var = NULL;
				ValaDataType* _tmp79_;
				ValaDataType* _tmp80_;
				ValaDataType* _tmp81_;
				ValaLocalVariable* _tmp82_;
				const gchar* _tmp83_;
				const gchar* _tmp84_;
				gchar* _tmp85_;
				gchar* _tmp86_;
				ValaCodeNode* _tmp87_;
				ValaSourceReference* _tmp88_;
				ValaSourceReference* _tmp89_;
				ValaLocalVariable* _tmp90_;
				ValaLocalVariable* _tmp91_;
				ValaLocalVariable* _tmp92_;
				gboolean _tmp93_;
				ValaLocalVariable* _tmp94_;
				_tmp79_ = self->gdestroynotify_type;
				_tmp80_ = vala_data_type_copy (_tmp79_);
				_tmp81_ = _tmp80_;
				_tmp82_ = local;
				_tmp83_ = vala_symbol_get_name ((ValaSymbol*) _tmp82_);
				_tmp84_ = _tmp83_;
				_tmp85_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp84_);
				_tmp86_ = _tmp85_;
				_tmp87_ = node_reference;
				_tmp88_ = vala_code_node_get_source_reference (_tmp87_);
				_tmp89_ = _tmp88_;
				_tmp90_ = vala_local_variable_new (_tmp81_, _tmp86_, NULL, _tmp89_);
				_tmp91_ = _tmp90_;
				_g_free0 (_tmp86_);
				_vala_code_node_unref0 (_tmp81_);
				target_destroy_notify_var = _tmp91_;
				_tmp92_ = target_destroy_notify_var;
				_tmp93_ = init;
				vala_local_variable_set_init (_tmp92_, _tmp93_);
				_tmp94_ = target_destroy_notify_var;
				vala_ccode_base_module_emit_temp_var (self, _tmp94_);
				_vala_code_node_unref0 (target_destroy_notify_var);
			}
			_vala_code_node_unref0 (target_var);
		}
	}
	_tmp95_ = local;
	_tmp96_ = vala_ccode_base_module_get_local_cvalue (self, _tmp95_);
	value = _tmp96_;
	vala_ccode_base_module_set_array_size_cvalue (self, value, NULL);
	result = value;
	_vala_code_node_unref0 (deleg_type);
	_vala_code_node_unref0 (array_type);
	_vala_code_node_unref0 (local);
	return result;
}


/**
 * Load a temporary variable returning unowned or owned rvalue access to it, depending on the ownership of the value type.
 */
ValaTargetValue* vala_ccode_base_module_load_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue) {
	ValaTargetValue* result = NULL;
	ValaGLibValue* value = NULL;
	ValaTargetValue* _tmp0_;
	ValaGLibValue* _tmp1_;
	ValaDelegateType* deleg_type = NULL;
	ValaGLibValue* _tmp2_;
	ValaDataType* _tmp3_;
	ValaDataType* _tmp4_;
	ValaDelegateType* _tmp5_;
	ValaDelegateType* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (lvalue != NULL, NULL);
	_tmp0_ = lvalue;
	_tmp1_ = vala_glib_value_copy (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	value = _tmp1_;
	_tmp2_ = value;
	_tmp3_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp4_) : NULL);
	deleg_type = _tmp5_;
	_tmp6_ = deleg_type;
	if (_tmp6_ != NULL) {
		ValaDelegateType* _tmp7_;
		ValaDelegate* _tmp8_;
		ValaDelegate* _tmp9_;
		gboolean _tmp10_;
		gboolean _tmp11_;
		_tmp7_ = deleg_type;
		_tmp8_ = vala_delegate_type_get_delegate_symbol (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_delegate_get_has_target (_tmp9_);
		_tmp11_ = _tmp10_;
		if (!_tmp11_) {
			ValaGLibValue* _tmp12_;
			ValaCCodeConstant* _tmp13_;
			ValaGLibValue* _tmp14_;
			_tmp12_ = value;
			_tmp13_ = vala_ccode_constant_new ("NULL");
			_vala_ccode_node_unref0 (_tmp12_->delegate_target_cvalue);
			_tmp12_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp13_;
			_tmp14_ = value;
			G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = FALSE;
		} else {
			ValaDelegateType* _tmp15_;
			gboolean _tmp16_;
			_tmp15_ = deleg_type;
			_tmp16_ = vala_data_type_is_disposable ((ValaDataType*) _tmp15_);
			if (!_tmp16_) {
				ValaGLibValue* _tmp17_;
				ValaCCodeConstant* _tmp18_;
				ValaGLibValue* _tmp19_;
				_tmp17_ = value;
				_tmp18_ = vala_ccode_constant_new ("NULL");
				_vala_ccode_node_unref0 (_tmp17_->delegate_target_destroy_notify_cvalue);
				_tmp17_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp18_;
				_tmp19_ = value;
				G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = FALSE;
			}
		}
	}
	result = (ValaTargetValue*) value;
	_vala_code_node_unref0 (deleg_type);
	return result;
}


/**
 * Store a value in a temporary variable and return unowned or owned rvalue access to it, depending on the ownership of the given type.
 */
ValaTargetValue* vala_ccode_base_module_store_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* initializer, ValaCodeNode* node_reference, gboolean* value_owned) {
	ValaTargetValue* result = NULL;
	ValaTargetValue* lvalue = NULL;
	ValaTargetValue* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaCodeNode* _tmp3_;
	gboolean* _tmp4_;
	ValaTargetValue* _tmp5_;
	ValaTargetValue* _tmp6_;
	ValaTargetValue* _tmp7_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (initializer != NULL, NULL);
	g_return_val_if_fail (node_reference != NULL, NULL);
	_tmp0_ = initializer;
	_tmp1_ = vala_target_value_get_value_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = node_reference;
	_tmp4_ = value_owned;
	_tmp5_ = vala_ccode_base_module_create_temp_value (self, _tmp2_, FALSE, _tmp3_, _tmp4_);
	lvalue = _tmp5_;
	_tmp6_ = initializer;
	vala_ccode_base_module_store_value (self, lvalue, _tmp6_);
	_tmp7_ = vala_ccode_base_module_load_temp_value (self, lvalue);
	result = _tmp7_;
	_vala_target_value_unref0 (lvalue);
	return result;
}


static void vala_ccode_base_module_real_visit_initializer_list (ValaCodeVisitor* base, ValaInitializerList* list) {
	ValaCCodeBaseModule * self;
	ValaInitializerList* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaTypeSymbol* _tmp3_;
	ValaTypeSymbol* _tmp4_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (list != NULL);
	_tmp0_ = list;
	_tmp1_ = vala_expression_get_target_type ((ValaExpression*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_data_type_get_data_type (_tmp2_);
	_tmp4_ = _tmp3_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_STRUCT)) {
		ValaStruct* st = NULL;
		ValaInitializerList* _tmp5_;
		ValaDataType* _tmp6_;
		ValaDataType* _tmp7_;
		ValaTypeSymbol* _tmp8_;
		ValaTypeSymbol* _tmp9_;
		ValaStruct* _tmp10_;
		gboolean _tmp18_ = FALSE;
		gboolean _tmp19_ = FALSE;
		ValaInitializerList* _tmp20_;
		ValaCodeNode* _tmp21_;
		ValaCodeNode* _tmp22_;
		_tmp5_ = list;
		_tmp6_ = vala_expression_get_target_type ((ValaExpression*) _tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_data_type_get_data_type (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_STRUCT, ValaStruct));
		st = _tmp10_;
		while (TRUE) {
			ValaStruct* _tmp11_;
			ValaStruct* _tmp12_;
			ValaStruct* _tmp13_;
			ValaStruct* _tmp14_;
			ValaStruct* _tmp15_;
			ValaStruct* _tmp16_;
			ValaStruct* _tmp17_;
			_tmp11_ = st;
			_tmp12_ = vala_struct_get_base_struct (_tmp11_);
			_tmp13_ = _tmp12_;
			if (!(_tmp13_ != NULL)) {
				break;
			}
			_tmp14_ = st;
			_tmp15_ = vala_struct_get_base_struct (_tmp14_);
			_tmp16_ = _tmp15_;
			_tmp17_ = _vala_code_node_ref0 (_tmp16_);
			_vala_code_node_unref0 (st);
			st = _tmp17_;
		}
		_tmp20_ = list;
		_tmp21_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp20_);
		_tmp22_ = _tmp21_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp22_, VALA_TYPE_CONSTANT)) {
			_tmp19_ = TRUE;
		} else {
			ValaInitializerList* _tmp23_;
			ValaCodeNode* _tmp24_;
			ValaCodeNode* _tmp25_;
			_tmp23_ = list;
			_tmp24_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp23_);
			_tmp25_ = _tmp24_;
			_tmp19_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_FIELD);
		}
		if (_tmp19_) {
			_tmp18_ = TRUE;
		} else {
			ValaInitializerList* _tmp26_;
			ValaCodeNode* _tmp27_;
			ValaCodeNode* _tmp28_;
			_tmp26_ = list;
			_tmp27_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp26_);
			_tmp28_ = _tmp27_;
			_tmp18_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp28_, VALA_TYPE_INITIALIZER_LIST);
		}
		if (_tmp18_) {
			ValaCCodeInitializerList* clist = NULL;
			ValaCCodeInitializerList* _tmp29_;
			ValaIterator* field_it = NULL;
			ValaStruct* _tmp30_;
			ValaList* _tmp31_;
			ValaList* _tmp32_;
			ValaIterator* _tmp33_;
			ValaIterator* _tmp34_;
			ValaInitializerList* _tmp87_;
			ValaCCodeInitializerList* _tmp88_;
			_tmp29_ = vala_ccode_initializer_list_new ();
			clist = _tmp29_;
			_tmp30_ = st;
			_tmp31_ = vala_struct_get_fields (_tmp30_);
			_tmp32_ = _tmp31_;
			_tmp33_ = vala_iterable_iterator ((ValaIterable*) _tmp32_);
			_tmp34_ = _tmp33_;
			_vala_iterable_unref0 (_tmp32_);
			field_it = _tmp34_;
			{
				ValaList* _expr_list = NULL;
				ValaInitializerList* _tmp35_;
				ValaList* _tmp36_;
				gint _expr_size = 0;
				ValaList* _tmp37_;
				gint _tmp38_;
				gint _tmp39_;
				gint _expr_index = 0;
				_tmp35_ = list;
				_tmp36_ = vala_initializer_list_get_initializers (_tmp35_);
				_expr_list = _tmp36_;
				_tmp37_ = _expr_list;
				_tmp38_ = vala_collection_get_size ((ValaCollection*) _tmp37_);
				_tmp39_ = _tmp38_;
				_expr_size = _tmp39_;
				_expr_index = -1;
				while (TRUE) {
					gint _tmp40_;
					gint _tmp41_;
					gint _tmp42_;
					ValaExpression* expr = NULL;
					ValaList* _tmp43_;
					gint _tmp44_;
					gpointer _tmp45_;
					ValaField* field = NULL;
					ValaCCodeExpression* cexpr = NULL;
					ValaExpression* _tmp53_;
					ValaCCodeExpression* _tmp54_;
					gchar* ctype = NULL;
					ValaField* _tmp55_;
					gchar* _tmp56_;
					const gchar* _tmp57_;
					ValaCCodeInitializerList* _tmp61_;
					ValaCCodeExpression* _tmp62_;
					ValaArrayType* array_type = NULL;
					ValaField* _tmp63_;
					ValaDataType* _tmp64_;
					ValaDataType* _tmp65_;
					ValaArrayType* _tmp66_;
					gboolean _tmp67_ = FALSE;
					gboolean _tmp68_ = FALSE;
					ValaArrayType* _tmp69_;
					_tmp40_ = _expr_index;
					_expr_index = _tmp40_ + 1;
					_tmp41_ = _expr_index;
					_tmp42_ = _expr_size;
					if (!(_tmp41_ < _tmp42_)) {
						break;
					}
					_tmp43_ = _expr_list;
					_tmp44_ = _expr_index;
					_tmp45_ = vala_list_get (_tmp43_, _tmp44_);
					expr = (ValaExpression*) _tmp45_;
					field = NULL;
					while (TRUE) {
						ValaField* _tmp46_;
						ValaIterator* _tmp47_;
						ValaIterator* _tmp48_;
						gpointer _tmp49_;
						ValaField* _tmp50_;
						ValaMemberBinding _tmp51_;
						ValaMemberBinding _tmp52_;
						_tmp46_ = field;
						if (!(_tmp46_ == NULL)) {
							break;
						}
						_tmp47_ = field_it;
						vala_iterator_next (_tmp47_);
						_tmp48_ = field_it;
						_tmp49_ = vala_iterator_get (_tmp48_);
						_vala_code_node_unref0 (field);
						field = (ValaField*) _tmp49_;
						_tmp50_ = field;
						_tmp51_ = vala_field_get_binding (_tmp50_);
						_tmp52_ = _tmp51_;
						if (_tmp52_ != VALA_MEMBER_BINDING_INSTANCE) {
							_vala_code_node_unref0 (field);
							field = NULL;
						}
					}
					_tmp53_ = expr;
					_tmp54_ = vala_ccode_base_module_get_cvalue (self, _tmp53_);
					cexpr = _tmp54_;
					_tmp55_ = field;
					_tmp56_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp55_);
					ctype = _tmp56_;
					_tmp57_ = ctype;
					if (_tmp57_ != NULL) {
						ValaCCodeExpression* _tmp58_;
						const gchar* _tmp59_;
						ValaCCodeCastExpression* _tmp60_;
						_tmp58_ = cexpr;
						_tmp59_ = ctype;
						_tmp60_ = vala_ccode_cast_expression_new (_tmp58_, _tmp59_);
						_vala_ccode_node_unref0 (cexpr);
						cexpr = (ValaCCodeExpression*) _tmp60_;
					}
					_tmp61_ = clist;
					_tmp62_ = cexpr;
					vala_ccode_initializer_list_append (_tmp61_, _tmp62_);
					_tmp63_ = field;
					_tmp64_ = vala_variable_get_variable_type ((ValaVariable*) _tmp63_);
					_tmp65_ = _tmp64_;
					_tmp66_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp65_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp65_) : NULL);
					array_type = _tmp66_;
					_tmp69_ = array_type;
					if (_tmp69_ != NULL) {
						ValaField* _tmp70_;
						gboolean _tmp71_;
						_tmp70_ = field;
						_tmp71_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp70_);
						_tmp68_ = _tmp71_;
					} else {
						_tmp68_ = FALSE;
					}
					if (_tmp68_) {
						ValaField* _tmp72_;
						gboolean _tmp73_;
						_tmp72_ = field;
						_tmp73_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp72_);
						_tmp67_ = !_tmp73_;
					} else {
						_tmp67_ = FALSE;
					}
					if (_tmp67_) {
						{
							gint dim = 0;
							dim = 1;
							{
								gboolean _tmp74_ = FALSE;
								_tmp74_ = TRUE;
								while (TRUE) {
									gint _tmp76_;
									ValaArrayType* _tmp77_;
									gint _tmp78_;
									gint _tmp79_;
									ValaCCodeInitializerList* _tmp80_;
									ValaExpression* _tmp81_;
									ValaTargetValue* _tmp82_;
									ValaTargetValue* _tmp83_;
									gint _tmp84_;
									ValaCCodeExpression* _tmp85_;
									ValaCCodeExpression* _tmp86_;
									if (!_tmp74_) {
										gint _tmp75_;
										_tmp75_ = dim;
										dim = _tmp75_ + 1;
									}
									_tmp74_ = FALSE;
									_tmp76_ = dim;
									_tmp77_ = array_type;
									_tmp78_ = vala_array_type_get_rank (_tmp77_);
									_tmp79_ = _tmp78_;
									if (!(_tmp76_ <= _tmp79_)) {
										break;
									}
									_tmp80_ = clist;
									_tmp81_ = expr;
									_tmp82_ = vala_expression_get_target_value (_tmp81_);
									_tmp83_ = _tmp82_;
									_tmp84_ = dim;
									_tmp85_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp83_, _tmp84_);
									_tmp86_ = _tmp85_;
									vala_ccode_initializer_list_append (_tmp80_, _tmp86_);
									_vala_ccode_node_unref0 (_tmp86_);
								}
							}
						}
					}
					_vala_code_node_unref0 (array_type);
					_g_free0 (ctype);
					_vala_ccode_node_unref0 (cexpr);
					_vala_code_node_unref0 (field);
					_vala_code_node_unref0 (expr);
				}
				_vala_iterable_unref0 (_expr_list);
			}
			_tmp87_ = list;
			_tmp88_ = clist;
			vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp87_, (ValaCCodeExpression*) _tmp88_);
			_vala_iterator_unref0 (field_it);
			_vala_ccode_node_unref0 (clist);
		} else {
			ValaTargetValue* instance = NULL;
			ValaInitializerList* _tmp89_;
			ValaDataType* _tmp90_;
			ValaDataType* _tmp91_;
			ValaInitializerList* _tmp92_;
			ValaTargetValue* _tmp93_;
			ValaIterator* field_it = NULL;
			ValaStruct* _tmp94_;
			ValaList* _tmp95_;
			ValaList* _tmp96_;
			ValaIterator* _tmp97_;
			ValaIterator* _tmp98_;
			ValaInitializerList* _tmp122_;
			ValaTargetValue* _tmp123_;
			_tmp89_ = list;
			_tmp90_ = vala_expression_get_value_type ((ValaExpression*) _tmp89_);
			_tmp91_ = _tmp90_;
			_tmp92_ = list;
			_tmp93_ = vala_ccode_base_module_create_temp_value (self, _tmp91_, TRUE, (ValaCodeNode*) _tmp92_, NULL);
			instance = _tmp93_;
			_tmp94_ = st;
			_tmp95_ = vala_struct_get_fields (_tmp94_);
			_tmp96_ = _tmp95_;
			_tmp97_ = vala_iterable_iterator ((ValaIterable*) _tmp96_);
			_tmp98_ = _tmp97_;
			_vala_iterable_unref0 (_tmp96_);
			field_it = _tmp98_;
			{
				ValaList* _expr_list = NULL;
				ValaInitializerList* _tmp99_;
				ValaList* _tmp100_;
				gint _expr_size = 0;
				ValaList* _tmp101_;
				gint _tmp102_;
				gint _tmp103_;
				gint _expr_index = 0;
				_tmp99_ = list;
				_tmp100_ = vala_initializer_list_get_initializers (_tmp99_);
				_expr_list = _tmp100_;
				_tmp101_ = _expr_list;
				_tmp102_ = vala_collection_get_size ((ValaCollection*) _tmp101_);
				_tmp103_ = _tmp102_;
				_expr_size = _tmp103_;
				_expr_index = -1;
				while (TRUE) {
					gint _tmp104_;
					gint _tmp105_;
					gint _tmp106_;
					ValaExpression* expr = NULL;
					ValaList* _tmp107_;
					gint _tmp108_;
					gpointer _tmp109_;
					ValaField* field = NULL;
					ValaField* _tmp117_;
					ValaTargetValue* _tmp118_;
					ValaExpression* _tmp119_;
					ValaTargetValue* _tmp120_;
					ValaTargetValue* _tmp121_;
					_tmp104_ = _expr_index;
					_expr_index = _tmp104_ + 1;
					_tmp105_ = _expr_index;
					_tmp106_ = _expr_size;
					if (!(_tmp105_ < _tmp106_)) {
						break;
					}
					_tmp107_ = _expr_list;
					_tmp108_ = _expr_index;
					_tmp109_ = vala_list_get (_tmp107_, _tmp108_);
					expr = (ValaExpression*) _tmp109_;
					field = NULL;
					while (TRUE) {
						ValaField* _tmp110_;
						ValaIterator* _tmp111_;
						ValaIterator* _tmp112_;
						gpointer _tmp113_;
						ValaField* _tmp114_;
						ValaMemberBinding _tmp115_;
						ValaMemberBinding _tmp116_;
						_tmp110_ = field;
						if (!(_tmp110_ == NULL)) {
							break;
						}
						_tmp111_ = field_it;
						vala_iterator_next (_tmp111_);
						_tmp112_ = field_it;
						_tmp113_ = vala_iterator_get (_tmp112_);
						_vala_code_node_unref0 (field);
						field = (ValaField*) _tmp113_;
						_tmp114_ = field;
						_tmp115_ = vala_field_get_binding (_tmp114_);
						_tmp116_ = _tmp115_;
						if (_tmp116_ != VALA_MEMBER_BINDING_INSTANCE) {
							_vala_code_node_unref0 (field);
							field = NULL;
						}
					}
					_tmp117_ = field;
					_tmp118_ = instance;
					_tmp119_ = expr;
					_tmp120_ = vala_expression_get_target_value (_tmp119_);
					_tmp121_ = _tmp120_;
					vala_code_generator_store_field ((ValaCodeGenerator*) self, _tmp117_, _tmp118_, _tmp121_);
					_vala_code_node_unref0 (field);
					_vala_code_node_unref0 (expr);
				}
				_vala_iterable_unref0 (_expr_list);
			}
			_tmp122_ = list;
			_tmp123_ = instance;
			vala_expression_set_target_value ((ValaExpression*) _tmp122_, _tmp123_);
			_vala_iterator_unref0 (field_it);
			_vala_target_value_unref0 (instance);
		}
		_vala_code_node_unref0 (st);
	} else {
		ValaCCodeInitializerList* clist = NULL;
		ValaCCodeInitializerList* _tmp124_;
		ValaInitializerList* _tmp140_;
		ValaCCodeInitializerList* _tmp141_;
		_tmp124_ = vala_ccode_initializer_list_new ();
		clist = _tmp124_;
		{
			ValaList* _expr_list = NULL;
			ValaInitializerList* _tmp125_;
			ValaList* _tmp126_;
			gint _expr_size = 0;
			ValaList* _tmp127_;
			gint _tmp128_;
			gint _tmp129_;
			gint _expr_index = 0;
			_tmp125_ = list;
			_tmp126_ = vala_initializer_list_get_initializers (_tmp125_);
			_expr_list = _tmp126_;
			_tmp127_ = _expr_list;
			_tmp128_ = vala_collection_get_size ((ValaCollection*) _tmp127_);
			_tmp129_ = _tmp128_;
			_expr_size = _tmp129_;
			_expr_index = -1;
			while (TRUE) {
				gint _tmp130_;
				gint _tmp131_;
				gint _tmp132_;
				ValaExpression* expr = NULL;
				ValaList* _tmp133_;
				gint _tmp134_;
				gpointer _tmp135_;
				ValaCCodeInitializerList* _tmp136_;
				ValaExpression* _tmp137_;
				ValaCCodeExpression* _tmp138_;
				ValaCCodeExpression* _tmp139_;
				_tmp130_ = _expr_index;
				_expr_index = _tmp130_ + 1;
				_tmp131_ = _expr_index;
				_tmp132_ = _expr_size;
				if (!(_tmp131_ < _tmp132_)) {
					break;
				}
				_tmp133_ = _expr_list;
				_tmp134_ = _expr_index;
				_tmp135_ = vala_list_get (_tmp133_, _tmp134_);
				expr = (ValaExpression*) _tmp135_;
				_tmp136_ = clist;
				_tmp137_ = expr;
				_tmp138_ = vala_ccode_base_module_get_cvalue (self, _tmp137_);
				_tmp139_ = _tmp138_;
				vala_ccode_initializer_list_append (_tmp136_, _tmp139_);
				_vala_ccode_node_unref0 (_tmp139_);
				_vala_code_node_unref0 (expr);
			}
			_vala_iterable_unref0 (_expr_list);
		}
		_tmp140_ = list;
		_tmp141_ = clist;
		vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp140_, (ValaCCodeExpression*) _tmp141_);
		_vala_ccode_node_unref0 (clist);
	}
}


ValaLocalVariable* vala_ccode_base_module_get_temp_variable (ValaCCodeBaseModule* self, ValaDataType* type, gboolean value_owned, ValaCodeNode* node_reference, gboolean init) {
	ValaLocalVariable* result = NULL;
	ValaDataType* var_type = NULL;
	ValaDataType* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	gboolean _tmp3_;
	ValaLocalVariable* local = NULL;
	ValaDataType* _tmp4_;
	gint _tmp5_;
	gint _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	ValaLocalVariable* _tmp9_;
	ValaLocalVariable* _tmp10_;
	ValaLocalVariable* _tmp11_;
	gboolean _tmp12_;
	ValaCodeNode* _tmp13_;
	gint _tmp18_;
	gint _tmp19_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_copy (_tmp0_);
	var_type = _tmp1_;
	_tmp2_ = var_type;
	_tmp3_ = value_owned;
	vala_data_type_set_value_owned (_tmp2_, _tmp3_);
	_tmp4_ = var_type;
	_tmp5_ = vala_ccode_base_module_get_next_temp_var_id (self);
	_tmp6_ = _tmp5_;
	_tmp7_ = g_strdup_printf ("_tmp%d_", _tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = vala_local_variable_new (_tmp4_, _tmp8_, NULL, NULL);
	_tmp10_ = _tmp9_;
	_g_free0 (_tmp8_);
	local = _tmp10_;
	_tmp11_ = local;
	_tmp12_ = init;
	vala_local_variable_set_init (_tmp11_, _tmp12_);
	_tmp13_ = node_reference;
	if (_tmp13_ != NULL) {
		ValaLocalVariable* _tmp14_;
		ValaCodeNode* _tmp15_;
		ValaSourceReference* _tmp16_;
		ValaSourceReference* _tmp17_;
		_tmp14_ = local;
		_tmp15_ = node_reference;
		_tmp16_ = vala_code_node_get_source_reference (_tmp15_);
		_tmp17_ = _tmp16_;
		vala_code_node_set_source_reference ((ValaCodeNode*) _tmp14_, _tmp17_);
	}
	_tmp18_ = vala_ccode_base_module_get_next_temp_var_id (self);
	_tmp19_ = _tmp18_;
	vala_ccode_base_module_set_next_temp_var_id (self, _tmp19_ + 1);
	result = local;
	_vala_code_node_unref0 (var_type);
	return result;
}


static gboolean vala_ccode_base_module_is_in_generic_type (ValaCCodeBaseModule* self, ValaDataType* type) {
	gboolean result = FALSE;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp3_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type != NULL, FALSE);
	_tmp2_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp3_ = _tmp2_;
	if (_tmp3_ != NULL) {
		ValaDataType* _tmp4_;
		ValaTypeParameter* _tmp5_;
		ValaTypeParameter* _tmp6_;
		ValaSymbol* _tmp7_;
		ValaSymbol* _tmp8_;
		_tmp4_ = type;
		_tmp5_ = vala_data_type_get_type_parameter (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp6_);
		_tmp8_ = _tmp7_;
		_tmp1_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_TYPESYMBOL);
	} else {
		_tmp1_ = FALSE;
	}
	if (_tmp1_) {
		gboolean _tmp9_ = FALSE;
		ValaMethod* _tmp10_;
		ValaMethod* _tmp11_;
		_tmp10_ = vala_ccode_base_module_get_current_method (self);
		_tmp11_ = _tmp10_;
		if (_tmp11_ == NULL) {
			_tmp9_ = TRUE;
		} else {
			ValaMethod* _tmp12_;
			ValaMethod* _tmp13_;
			ValaMemberBinding _tmp14_;
			ValaMemberBinding _tmp15_;
			_tmp12_ = vala_ccode_base_module_get_current_method (self);
			_tmp13_ = _tmp12_;
			_tmp14_ = vala_method_get_binding (_tmp13_);
			_tmp15_ = _tmp14_;
			_tmp9_ = _tmp15_ == VALA_MEMBER_BINDING_INSTANCE;
		}
		_tmp0_ = _tmp9_;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		result = TRUE;
		return result;
	} else {
		result = FALSE;
		return result;
	}
}


static void vala_ccode_base_module_require_generic_accessors (ValaCCodeBaseModule* self, ValaInterface* iface) {
	ValaInterface* _tmp0_;
	ValaAttribute* _tmp1_;
	ValaAttribute* _tmp2_;
	gboolean _tmp3_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (iface != NULL);
	_tmp0_ = iface;
	_tmp1_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp0_, "GenericAccessors");
	_tmp2_ = _tmp1_;
	_tmp3_ = _tmp2_ == NULL;
	_vala_code_node_unref0 (_tmp2_);
	if (_tmp3_) {
		ValaInterface* _tmp4_;
		ValaSourceReference* _tmp5_;
		ValaSourceReference* _tmp6_;
		ValaInterface* _tmp7_;
		gchar* _tmp8_;
		gchar* _tmp9_;
		gchar* _tmp10_;
		gchar* _tmp11_;
		_tmp4_ = iface;
		_tmp5_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = iface;
		_tmp8_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = g_strdup_printf ("missing generic type for interface `%s', add GenericAccessors attribut" \
"e to interface declaration", _tmp9_);
		_tmp11_ = _tmp10_;
		vala_report_error (_tmp6_, _tmp11_);
		_g_free0 (_tmp11_);
		_g_free0 (_tmp9_);
	}
}


ValaCCodeExpression* vala_ccode_base_module_get_type_id_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup) {
	ValaCCodeExpression* result = NULL;
	ValaDataType* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_GENERIC_TYPE)) {
		gchar* var_name = NULL;
		ValaDataType* _tmp1_;
		ValaTypeParameter* _tmp2_;
		ValaTypeParameter* _tmp3_;
		const gchar* _tmp4_;
		const gchar* _tmp5_;
		gchar* _tmp6_;
		gchar* _tmp7_;
		gchar* _tmp8_;
		gchar* _tmp9_;
		ValaDataType* _tmp10_;
		ValaTypeParameter* _tmp11_;
		ValaTypeParameter* _tmp12_;
		ValaSymbol* _tmp13_;
		ValaSymbol* _tmp14_;
		gboolean _tmp52_ = FALSE;
		gboolean _tmp53_ = FALSE;
		ValaDataType* _tmp54_;
		gboolean _tmp55_;
		_tmp1_ = type;
		_tmp2_ = vala_data_type_get_type_parameter (_tmp1_);
		_tmp3_ = _tmp2_;
		_tmp4_ = vala_symbol_get_name ((ValaSymbol*) _tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = g_utf8_strdown (_tmp5_, (gssize) -1);
		_tmp7_ = _tmp6_;
		_tmp8_ = g_strdup_printf ("%s_type", _tmp7_);
		_tmp9_ = _tmp8_;
		_g_free0 (_tmp7_);
		var_name = _tmp9_;
		_tmp10_ = type;
		_tmp11_ = vala_data_type_get_type_parameter (_tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp12_);
		_tmp14_ = _tmp13_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp14_, VALA_TYPE_INTERFACE)) {
			ValaInterface* iface = NULL;
			ValaDataType* _tmp15_;
			ValaTypeParameter* _tmp16_;
			ValaTypeParameter* _tmp17_;
			ValaSymbol* _tmp18_;
			ValaSymbol* _tmp19_;
			ValaInterface* _tmp20_;
			ValaInterface* _tmp21_;
			gchar* method_name = NULL;
			ValaDataType* _tmp22_;
			ValaTypeParameter* _tmp23_;
			ValaTypeParameter* _tmp24_;
			const gchar* _tmp25_;
			const gchar* _tmp26_;
			gchar* _tmp27_;
			gchar* _tmp28_;
			gchar* _tmp29_;
			gchar* _tmp30_;
			ValaCCodeFunctionCall* cast_self = NULL;
			ValaInterface* _tmp31_;
			gchar* _tmp32_;
			gchar* _tmp33_;
			gchar* _tmp34_;
			gchar* _tmp35_;
			ValaCCodeIdentifier* _tmp36_;
			ValaCCodeIdentifier* _tmp37_;
			ValaCCodeFunctionCall* _tmp38_;
			ValaCCodeFunctionCall* _tmp39_;
			ValaCCodeFunctionCall* _tmp40_;
			ValaCCodeIdentifier* _tmp41_;
			ValaCCodeIdentifier* _tmp42_;
			ValaCCodeFunctionCall* function_call = NULL;
			ValaCCodeFunctionCall* _tmp43_;
			const gchar* _tmp44_;
			ValaCCodeMemberAccess* _tmp45_;
			ValaCCodeMemberAccess* _tmp46_;
			ValaCCodeFunctionCall* _tmp47_;
			ValaCCodeFunctionCall* _tmp48_;
			ValaCCodeFunctionCall* _tmp49_;
			ValaCCodeIdentifier* _tmp50_;
			ValaCCodeIdentifier* _tmp51_;
			_tmp15_ = type;
			_tmp16_ = vala_data_type_get_type_parameter (_tmp15_);
			_tmp17_ = _tmp16_;
			_tmp18_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp17_);
			_tmp19_ = _tmp18_;
			_tmp20_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, VALA_TYPE_INTERFACE, ValaInterface));
			iface = _tmp20_;
			_tmp21_ = iface;
			vala_ccode_base_module_require_generic_accessors (self, _tmp21_);
			_tmp22_ = type;
			_tmp23_ = vala_data_type_get_type_parameter (_tmp22_);
			_tmp24_ = _tmp23_;
			_tmp25_ = vala_symbol_get_name ((ValaSymbol*) _tmp24_);
			_tmp26_ = _tmp25_;
			_tmp27_ = g_utf8_strdown (_tmp26_, (gssize) -1);
			_tmp28_ = _tmp27_;
			_tmp29_ = g_strdup_printf ("get_%s_type", _tmp28_);
			_tmp30_ = _tmp29_;
			_g_free0 (_tmp28_);
			method_name = _tmp30_;
			_tmp31_ = iface;
			_tmp32_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp31_, NULL);
			_tmp33_ = _tmp32_;
			_tmp34_ = g_strdup_printf ("%s_GET_INTERFACE", _tmp33_);
			_tmp35_ = _tmp34_;
			_tmp36_ = vala_ccode_identifier_new (_tmp35_);
			_tmp37_ = _tmp36_;
			_tmp38_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp37_);
			_tmp39_ = _tmp38_;
			_vala_ccode_node_unref0 (_tmp37_);
			_g_free0 (_tmp35_);
			_g_free0 (_tmp33_);
			cast_self = _tmp39_;
			_tmp40_ = cast_self;
			_tmp41_ = vala_ccode_identifier_new ("self");
			_tmp42_ = _tmp41_;
			vala_ccode_function_call_add_argument (_tmp40_, (ValaCCodeExpression*) _tmp42_);
			_vala_ccode_node_unref0 (_tmp42_);
			_tmp43_ = cast_self;
			_tmp44_ = method_name;
			_tmp45_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp43_, _tmp44_);
			_tmp46_ = _tmp45_;
			_tmp47_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp46_);
			_tmp48_ = _tmp47_;
			_vala_ccode_node_unref0 (_tmp46_);
			function_call = _tmp48_;
			_tmp49_ = function_call;
			_tmp50_ = vala_ccode_identifier_new ("self");
			_tmp51_ = _tmp50_;
			vala_ccode_function_call_add_argument (_tmp49_, (ValaCCodeExpression*) _tmp51_);
			_vala_ccode_node_unref0 (_tmp51_);
			result = (ValaCCodeExpression*) function_call;
			_vala_ccode_node_unref0 (cast_self);
			_g_free0 (method_name);
			_vala_code_node_unref0 (iface);
			_g_free0 (var_name);
			return result;
		}
		_tmp54_ = type;
		_tmp55_ = vala_ccode_base_module_is_in_generic_type (self, _tmp54_);
		if (_tmp55_) {
			gboolean _tmp56_;
			_tmp56_ = is_chainup;
			_tmp53_ = !_tmp56_;
		} else {
			_tmp53_ = FALSE;
		}
		if (_tmp53_) {
			gboolean _tmp57_;
			gboolean _tmp58_;
			_tmp57_ = vala_ccode_base_module_get_in_creation_method (self);
			_tmp58_ = _tmp57_;
			_tmp52_ = !_tmp58_;
		} else {
			_tmp52_ = FALSE;
		}
		if (_tmp52_) {
			ValaCCodeExpression* _tmp59_;
			ValaCCodeExpression* _tmp60_;
			ValaCCodeMemberAccess* _tmp61_;
			ValaCCodeMemberAccess* _tmp62_;
			const gchar* _tmp63_;
			ValaCCodeMemberAccess* _tmp64_;
			ValaCCodeExpression* _tmp65_;
			_tmp59_ = vala_ccode_base_module_get_result_cexpression (self, "self");
			_tmp60_ = _tmp59_;
			_tmp61_ = vala_ccode_member_access_new_pointer (_tmp60_, "priv");
			_tmp62_ = _tmp61_;
			_tmp63_ = var_name;
			_tmp64_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp62_, _tmp63_);
			_tmp65_ = (ValaCCodeExpression*) _tmp64_;
			_vala_ccode_node_unref0 (_tmp62_);
			_vala_ccode_node_unref0 (_tmp60_);
			result = _tmp65_;
			_g_free0 (var_name);
			return result;
		} else {
			const gchar* _tmp66_;
			ValaCCodeExpression* _tmp67_;
			_tmp66_ = var_name;
			_tmp67_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp66_);
			result = _tmp67_;
			_g_free0 (var_name);
			return result;
		}
		_g_free0 (var_name);
	} else {
		gchar* type_id = NULL;
		ValaDataType* _tmp68_;
		gchar* _tmp69_;
		const gchar* _tmp70_;
		const gchar* _tmp74_;
		ValaCCodeIdentifier* _tmp75_;
		_tmp68_ = type;
		_tmp69_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp68_);
		type_id = _tmp69_;
		_tmp70_ = type_id;
		if (g_strcmp0 (_tmp70_, "") == 0) {
			gchar* _tmp71_;
			_tmp71_ = g_strdup ("G_TYPE_INVALID");
			_g_free0 (type_id);
			type_id = _tmp71_;
		} else {
			ValaDataType* _tmp72_;
			ValaCCodeFile* _tmp73_;
			_tmp72_ = type;
			_tmp73_ = self->cfile;
			vala_ccode_base_module_generate_type_declaration (self, _tmp72_, _tmp73_);
		}
		_tmp74_ = type_id;
		_tmp75_ = vala_ccode_identifier_new (_tmp74_);
		result = (ValaCCodeExpression*) _tmp75_;
		_g_free0 (type_id);
		return result;
	}
}


static ValaCCodeExpression* vala_ccode_base_module_real_get_dup_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup) {
	ValaCCodeExpression* result = NULL;
	ValaDataType* _tmp0_;
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ERROR_TYPE)) {
		ValaCCodeIdentifier* _tmp1_;
		_tmp1_ = vala_ccode_identifier_new ("g_error_copy");
		result = (ValaCCodeExpression*) _tmp1_;
		return result;
	} else {
		ValaDataType* _tmp2_;
		ValaTypeSymbol* _tmp3_;
		ValaTypeSymbol* _tmp4_;
		_tmp2_ = type;
		_tmp3_ = vala_data_type_get_data_type (_tmp2_);
		_tmp4_ = _tmp3_;
		if (_tmp4_ != NULL) {
			gchar* dup_function = NULL;
			ValaClass* cl = NULL;
			ValaDataType* _tmp5_;
			ValaTypeSymbol* _tmp6_;
			ValaTypeSymbol* _tmp7_;
			ValaClass* _tmp8_;
			ValaDataType* _tmp9_;
			ValaTypeSymbol* _tmp10_;
			ValaTypeSymbol* _tmp11_;
			gboolean _tmp12_;
			const gchar* _tmp73_;
			ValaCCodeIdentifier* _tmp74_;
			_tmp5_ = type;
			_tmp6_ = vala_data_type_get_data_type (_tmp5_);
			_tmp7_ = _tmp6_;
			_tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp7_) : NULL);
			cl = _tmp8_;
			_tmp9_ = type;
			_tmp10_ = vala_data_type_get_data_type (_tmp9_);
			_tmp11_ = _tmp10_;
			_tmp12_ = vala_ccode_base_module_is_reference_counting (_tmp11_);
			if (_tmp12_) {
				ValaDataType* _tmp13_;
				ValaTypeSymbol* _tmp14_;
				ValaTypeSymbol* _tmp15_;
				gchar* _tmp16_;
				gboolean _tmp17_ = FALSE;
				ValaDataType* _tmp18_;
				ValaTypeSymbol* _tmp19_;
				ValaTypeSymbol* _tmp20_;
				_tmp13_ = type;
				_tmp14_ = vala_data_type_get_data_type (_tmp13_);
				_tmp15_ = _tmp14_;
				_tmp16_ = vala_ccode_base_module_get_ccode_ref_function ((ValaTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp15_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
				_g_free0 (dup_function);
				dup_function = _tmp16_;
				_tmp18_ = type;
				_tmp19_ = vala_data_type_get_data_type (_tmp18_);
				_tmp20_ = _tmp19_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp20_, VALA_TYPE_INTERFACE)) {
					const gchar* _tmp21_;
					_tmp21_ = dup_function;
					_tmp17_ = _tmp21_ == NULL;
				} else {
					_tmp17_ = FALSE;
				}
				if (_tmp17_) {
					ValaSourceReference* _tmp22_;
					ValaDataType* _tmp23_;
					ValaTypeSymbol* _tmp24_;
					ValaTypeSymbol* _tmp25_;
					gchar* _tmp26_;
					gchar* _tmp27_;
					gchar* _tmp28_;
					gchar* _tmp29_;
					ValaCCodeInvalidExpression* _tmp30_;
					_tmp22_ = source_reference;
					_tmp23_ = type;
					_tmp24_ = vala_data_type_get_data_type (_tmp23_);
					_tmp25_ = _tmp24_;
					_tmp26_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp25_);
					_tmp27_ = _tmp26_;
					_tmp28_ = g_strdup_printf ("missing class prerequisite for interface `%s', add GLib.Object to inte" \
"rface declaration if unsure", _tmp27_);
					_tmp29_ = _tmp28_;
					vala_report_error (_tmp22_, _tmp29_);
					_g_free0 (_tmp29_);
					_g_free0 (_tmp27_);
					_tmp30_ = vala_ccode_invalid_expression_new ();
					result = (ValaCCodeExpression*) _tmp30_;
					_vala_code_node_unref0 (cl);
					_g_free0 (dup_function);
					return result;
				}
			} else {
				gboolean _tmp31_ = FALSE;
				ValaClass* _tmp32_;
				_tmp32_ = cl;
				if (_tmp32_ != NULL) {
					ValaClass* _tmp33_;
					gboolean _tmp34_;
					gboolean _tmp35_;
					_tmp33_ = cl;
					_tmp34_ = vala_class_get_is_immutable (_tmp33_);
					_tmp35_ = _tmp34_;
					_tmp31_ = _tmp35_;
				} else {
					_tmp31_ = FALSE;
				}
				if (_tmp31_) {
					ValaDataType* _tmp36_;
					ValaTypeSymbol* _tmp37_;
					ValaTypeSymbol* _tmp38_;
					gchar* _tmp39_;
					const gchar* _tmp40_;
					_tmp36_ = type;
					_tmp37_ = vala_data_type_get_data_type (_tmp36_);
					_tmp38_ = _tmp37_;
					_tmp39_ = vala_ccode_base_module_get_ccode_dup_function (_tmp38_);
					_g_free0 (dup_function);
					dup_function = _tmp39_;
					_tmp40_ = dup_function;
					if (_tmp40_ == NULL) {
						gchar* _tmp41_;
						_tmp41_ = g_strdup ("");
						_g_free0 (dup_function);
						dup_function = _tmp41_;
					}
				} else {
					gboolean _tmp42_ = FALSE;
					ValaClass* _tmp43_;
					_tmp43_ = cl;
					if (_tmp43_ != NULL) {
						ValaClass* _tmp44_;
						gboolean _tmp45_;
						_tmp44_ = cl;
						_tmp45_ = vala_ccode_base_module_get_ccode_is_gboxed ((ValaTypeSymbol*) _tmp44_);
						_tmp42_ = _tmp45_;
					} else {
						_tmp42_ = FALSE;
					}
					if (_tmp42_) {
						ValaDataType* _tmp46_;
						gchar* _tmp47_;
						const gchar* _tmp48_;
						_tmp46_ = type;
						_tmp47_ = vala_ccode_base_module_generate_dup_func_wrapper (self, _tmp46_);
						_g_free0 (dup_function);
						dup_function = _tmp47_;
						_tmp48_ = dup_function;
						if (_tmp48_ == NULL) {
							gchar* _tmp49_;
							_tmp49_ = g_strdup ("");
							_g_free0 (dup_function);
							dup_function = _tmp49_;
						}
					} else {
						ValaDataType* _tmp50_;
						_tmp50_ = type;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp50_, VALA_TYPE_VALUE_TYPE)) {
							ValaDataType* _tmp51_;
							ValaTypeSymbol* _tmp52_;
							ValaTypeSymbol* _tmp53_;
							gchar* _tmp54_;
							gboolean _tmp55_ = FALSE;
							const gchar* _tmp56_;
							_tmp51_ = type;
							_tmp52_ = vala_data_type_get_data_type (_tmp51_);
							_tmp53_ = _tmp52_;
							_tmp54_ = vala_ccode_base_module_get_ccode_dup_function (_tmp53_);
							_g_free0 (dup_function);
							dup_function = _tmp54_;
							_tmp56_ = dup_function;
							if (_tmp56_ == NULL) {
								ValaDataType* _tmp57_;
								gboolean _tmp58_;
								gboolean _tmp59_;
								_tmp57_ = type;
								_tmp58_ = vala_data_type_get_nullable (_tmp57_);
								_tmp59_ = _tmp58_;
								_tmp55_ = _tmp59_;
							} else {
								_tmp55_ = FALSE;
							}
							if (_tmp55_) {
								ValaDataType* _tmp60_;
								gchar* _tmp61_;
								_tmp60_ = type;
								_tmp61_ = vala_ccode_base_module_generate_struct_dup_wrapper (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp60_, VALA_TYPE_VALUE_TYPE, ValaValueType));
								_g_free0 (dup_function);
								dup_function = _tmp61_;
							} else {
								const gchar* _tmp62_;
								_tmp62_ = dup_function;
								if (_tmp62_ == NULL) {
									gchar* _tmp63_;
									_tmp63_ = g_strdup ("");
									_g_free0 (dup_function);
									dup_function = _tmp63_;
								}
							}
						} else {
							ValaSourceReference* _tmp64_;
							ValaDataType* _tmp65_;
							ValaTypeSymbol* _tmp66_;
							ValaTypeSymbol* _tmp67_;
							const gchar* _tmp68_;
							const gchar* _tmp69_;
							gchar* _tmp70_;
							gchar* _tmp71_;
							ValaCCodeInvalidExpression* _tmp72_;
							_tmp64_ = source_reference;
							_tmp65_ = type;
							_tmp66_ = vala_data_type_get_data_type (_tmp65_);
							_tmp67_ = _tmp66_;
							_tmp68_ = vala_symbol_get_name ((ValaSymbol*) _tmp67_);
							_tmp69_ = _tmp68_;
							_tmp70_ = g_strdup_printf ("duplicating %s instance, use unowned variable or explicitly invoke cop" \
"y method", _tmp69_);
							_tmp71_ = _tmp70_;
							vala_report_error (_tmp64_, _tmp71_);
							_g_free0 (_tmp71_);
							_tmp72_ = vala_ccode_invalid_expression_new ();
							result = (ValaCCodeExpression*) _tmp72_;
							_vala_code_node_unref0 (cl);
							_g_free0 (dup_function);
							return result;
						}
					}
				}
			}
			_tmp73_ = dup_function;
			_tmp74_ = vala_ccode_identifier_new (_tmp73_);
			result = (ValaCCodeExpression*) _tmp74_;
			_vala_code_node_unref0 (cl);
			_g_free0 (dup_function);
			return result;
		} else {
			ValaDataType* _tmp75_;
			ValaTypeParameter* _tmp76_;
			ValaTypeParameter* _tmp77_;
			_tmp75_ = type;
			_tmp76_ = vala_data_type_get_type_parameter (_tmp75_);
			_tmp77_ = _tmp76_;
			if (_tmp77_ != NULL) {
				gchar* func_name = NULL;
				ValaDataType* _tmp78_;
				ValaTypeParameter* _tmp79_;
				ValaTypeParameter* _tmp80_;
				const gchar* _tmp81_;
				const gchar* _tmp82_;
				gchar* _tmp83_;
				gchar* _tmp84_;
				gchar* _tmp85_;
				gchar* _tmp86_;
				ValaDataType* _tmp87_;
				ValaTypeParameter* _tmp88_;
				ValaTypeParameter* _tmp89_;
				ValaSymbol* _tmp90_;
				ValaSymbol* _tmp91_;
				gboolean _tmp129_ = FALSE;
				gboolean _tmp130_ = FALSE;
				ValaDataType* _tmp131_;
				gboolean _tmp132_;
				_tmp78_ = type;
				_tmp79_ = vala_data_type_get_type_parameter (_tmp78_);
				_tmp80_ = _tmp79_;
				_tmp81_ = vala_symbol_get_name ((ValaSymbol*) _tmp80_);
				_tmp82_ = _tmp81_;
				_tmp83_ = g_utf8_strdown (_tmp82_, (gssize) -1);
				_tmp84_ = _tmp83_;
				_tmp85_ = g_strdup_printf ("%s_dup_func", _tmp84_);
				_tmp86_ = _tmp85_;
				_g_free0 (_tmp84_);
				func_name = _tmp86_;
				_tmp87_ = type;
				_tmp88_ = vala_data_type_get_type_parameter (_tmp87_);
				_tmp89_ = _tmp88_;
				_tmp90_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp89_);
				_tmp91_ = _tmp90_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp91_, VALA_TYPE_INTERFACE)) {
					ValaInterface* iface = NULL;
					ValaDataType* _tmp92_;
					ValaTypeParameter* _tmp93_;
					ValaTypeParameter* _tmp94_;
					ValaSymbol* _tmp95_;
					ValaSymbol* _tmp96_;
					ValaInterface* _tmp97_;
					ValaInterface* _tmp98_;
					gchar* method_name = NULL;
					ValaDataType* _tmp99_;
					ValaTypeParameter* _tmp100_;
					ValaTypeParameter* _tmp101_;
					const gchar* _tmp102_;
					const gchar* _tmp103_;
					gchar* _tmp104_;
					gchar* _tmp105_;
					gchar* _tmp106_;
					gchar* _tmp107_;
					ValaCCodeFunctionCall* cast_self = NULL;
					ValaInterface* _tmp108_;
					gchar* _tmp109_;
					gchar* _tmp110_;
					gchar* _tmp111_;
					gchar* _tmp112_;
					ValaCCodeIdentifier* _tmp113_;
					ValaCCodeIdentifier* _tmp114_;
					ValaCCodeFunctionCall* _tmp115_;
					ValaCCodeFunctionCall* _tmp116_;
					ValaCCodeFunctionCall* _tmp117_;
					ValaCCodeIdentifier* _tmp118_;
					ValaCCodeIdentifier* _tmp119_;
					ValaCCodeFunctionCall* function_call = NULL;
					ValaCCodeFunctionCall* _tmp120_;
					const gchar* _tmp121_;
					ValaCCodeMemberAccess* _tmp122_;
					ValaCCodeMemberAccess* _tmp123_;
					ValaCCodeFunctionCall* _tmp124_;
					ValaCCodeFunctionCall* _tmp125_;
					ValaCCodeFunctionCall* _tmp126_;
					ValaCCodeIdentifier* _tmp127_;
					ValaCCodeIdentifier* _tmp128_;
					_tmp92_ = type;
					_tmp93_ = vala_data_type_get_type_parameter (_tmp92_);
					_tmp94_ = _tmp93_;
					_tmp95_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp94_);
					_tmp96_ = _tmp95_;
					_tmp97_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp96_, VALA_TYPE_INTERFACE, ValaInterface));
					iface = _tmp97_;
					_tmp98_ = iface;
					vala_ccode_base_module_require_generic_accessors (self, _tmp98_);
					_tmp99_ = type;
					_tmp100_ = vala_data_type_get_type_parameter (_tmp99_);
					_tmp101_ = _tmp100_;
					_tmp102_ = vala_symbol_get_name ((ValaSymbol*) _tmp101_);
					_tmp103_ = _tmp102_;
					_tmp104_ = g_utf8_strdown (_tmp103_, (gssize) -1);
					_tmp105_ = _tmp104_;
					_tmp106_ = g_strdup_printf ("get_%s_dup_func", _tmp105_);
					_tmp107_ = _tmp106_;
					_g_free0 (_tmp105_);
					method_name = _tmp107_;
					_tmp108_ = iface;
					_tmp109_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp108_, NULL);
					_tmp110_ = _tmp109_;
					_tmp111_ = g_strdup_printf ("%s_GET_INTERFACE", _tmp110_);
					_tmp112_ = _tmp111_;
					_tmp113_ = vala_ccode_identifier_new (_tmp112_);
					_tmp114_ = _tmp113_;
					_tmp115_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp114_);
					_tmp116_ = _tmp115_;
					_vala_ccode_node_unref0 (_tmp114_);
					_g_free0 (_tmp112_);
					_g_free0 (_tmp110_);
					cast_self = _tmp116_;
					_tmp117_ = cast_self;
					_tmp118_ = vala_ccode_identifier_new ("self");
					_tmp119_ = _tmp118_;
					vala_ccode_function_call_add_argument (_tmp117_, (ValaCCodeExpression*) _tmp119_);
					_vala_ccode_node_unref0 (_tmp119_);
					_tmp120_ = cast_self;
					_tmp121_ = method_name;
					_tmp122_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp120_, _tmp121_);
					_tmp123_ = _tmp122_;
					_tmp124_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp123_);
					_tmp125_ = _tmp124_;
					_vala_ccode_node_unref0 (_tmp123_);
					function_call = _tmp125_;
					_tmp126_ = function_call;
					_tmp127_ = vala_ccode_identifier_new ("self");
					_tmp128_ = _tmp127_;
					vala_ccode_function_call_add_argument (_tmp126_, (ValaCCodeExpression*) _tmp128_);
					_vala_ccode_node_unref0 (_tmp128_);
					result = (ValaCCodeExpression*) function_call;
					_vala_ccode_node_unref0 (cast_self);
					_g_free0 (method_name);
					_vala_code_node_unref0 (iface);
					_g_free0 (func_name);
					return result;
				}
				_tmp131_ = type;
				_tmp132_ = vala_ccode_base_module_is_in_generic_type (self, _tmp131_);
				if (_tmp132_) {
					gboolean _tmp133_;
					_tmp133_ = is_chainup;
					_tmp130_ = !_tmp133_;
				} else {
					_tmp130_ = FALSE;
				}
				if (_tmp130_) {
					gboolean _tmp134_;
					gboolean _tmp135_;
					_tmp134_ = vala_ccode_base_module_get_in_creation_method (self);
					_tmp135_ = _tmp134_;
					_tmp129_ = !_tmp135_;
				} else {
					_tmp129_ = FALSE;
				}
				if (_tmp129_) {
					ValaCCodeExpression* _tmp136_;
					ValaCCodeExpression* _tmp137_;
					ValaCCodeMemberAccess* _tmp138_;
					ValaCCodeMemberAccess* _tmp139_;
					const gchar* _tmp140_;
					ValaCCodeMemberAccess* _tmp141_;
					ValaCCodeExpression* _tmp142_;
					_tmp136_ = vala_ccode_base_module_get_result_cexpression (self, "self");
					_tmp137_ = _tmp136_;
					_tmp138_ = vala_ccode_member_access_new_pointer (_tmp137_, "priv");
					_tmp139_ = _tmp138_;
					_tmp140_ = func_name;
					_tmp141_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp139_, _tmp140_);
					_tmp142_ = (ValaCCodeExpression*) _tmp141_;
					_vala_ccode_node_unref0 (_tmp139_);
					_vala_ccode_node_unref0 (_tmp137_);
					result = _tmp142_;
					_g_free0 (func_name);
					return result;
				} else {
					const gchar* _tmp143_;
					ValaCCodeExpression* _tmp144_;
					_tmp143_ = func_name;
					_tmp144_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp143_);
					result = _tmp144_;
					_g_free0 (func_name);
					return result;
				}
				_g_free0 (func_name);
			} else {
				ValaDataType* _tmp145_;
				_tmp145_ = type;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp145_, VALA_TYPE_POINTER_TYPE)) {
					ValaPointerType* pointer_type = NULL;
					ValaDataType* _tmp146_;
					ValaPointerType* _tmp147_;
					ValaPointerType* _tmp148_;
					ValaDataType* _tmp149_;
					ValaDataType* _tmp150_;
					ValaSourceReference* _tmp151_;
					ValaCCodeExpression* _tmp152_;
					_tmp146_ = type;
					_tmp147_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp146_, VALA_TYPE_POINTER_TYPE, ValaPointerType));
					pointer_type = _tmp147_;
					_tmp148_ = pointer_type;
					_tmp149_ = vala_pointer_type_get_base_type (_tmp148_);
					_tmp150_ = _tmp149_;
					_tmp151_ = source_reference;
					_tmp152_ = vala_ccode_base_module_get_dup_func_expression (self, _tmp150_, _tmp151_, FALSE);
					result = _tmp152_;
					_vala_code_node_unref0 (pointer_type);
					return result;
				} else {
					ValaCCodeConstant* _tmp153_;
					_tmp153_ = vala_ccode_constant_new ("NULL");
					result = (ValaCCodeExpression*) _tmp153_;
					return result;
				}
			}
		}
	}
}


ValaCCodeExpression* vala_ccode_base_module_get_dup_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_dup_func_expression (self, type, source_reference, is_chainup);
}


static void vala_ccode_base_module_make_comparable_cexpression (ValaCCodeBaseModule* self, ValaDataType* * left_type, ValaCCodeExpression* * cleft, ValaDataType* * right_type, ValaCCodeExpression* * cright) {
	ValaStruct* left_type_as_struct = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	ValaStruct* _tmp3_;
	ValaStruct* right_type_as_struct = NULL;
	ValaDataType* _tmp4_;
	ValaTypeSymbol* _tmp5_;
	ValaTypeSymbol* _tmp6_;
	ValaStruct* _tmp7_;
	ValaCCodeExpression* valuecast = NULL;
	ValaCCodeExpression* _tmp8_;
	ValaDataType* _tmp9_;
	ValaDataType* _tmp10_;
	ValaCCodeExpression* _tmp11_;
	ValaCCodeExpression* _tmp12_;
	ValaCCodeExpression* _tmp17_;
	ValaDataType* _tmp18_;
	ValaDataType* _tmp19_;
	ValaCCodeExpression* _tmp20_;
	ValaCCodeExpression* _tmp21_;
	gboolean _tmp26_ = FALSE;
	gboolean _tmp27_ = FALSE;
	gboolean _tmp28_ = FALSE;
	ValaDataType* _tmp29_;
	ValaTypeSymbol* _tmp30_;
	ValaTypeSymbol* _tmp31_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (*left_type != NULL);
	g_return_if_fail (*cleft != NULL);
	g_return_if_fail (*right_type != NULL);
	g_return_if_fail (*cright != NULL);
	_tmp0_ = *left_type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp2_) : NULL);
	left_type_as_struct = _tmp3_;
	_tmp4_ = *right_type;
	_tmp5_ = vala_data_type_get_data_type (_tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp6_) : NULL);
	right_type_as_struct = _tmp7_;
	_tmp8_ = *cleft;
	_tmp9_ = *left_type;
	_tmp10_ = *right_type;
	_tmp11_ = vala_ccode_base_module_try_cast_value_to_type (self, _tmp8_, _tmp9_, _tmp10_, NULL);
	valuecast = _tmp11_;
	_tmp12_ = valuecast;
	if (_tmp12_ != NULL) {
		ValaCCodeExpression* _tmp13_;
		ValaCCodeExpression* _tmp14_;
		ValaDataType* _tmp15_;
		ValaDataType* _tmp16_;
		_tmp13_ = valuecast;
		_tmp14_ = _vala_ccode_node_ref0 (_tmp13_);
		_vala_ccode_node_unref0 (*cleft);
		*cleft = _tmp14_;
		_tmp15_ = *right_type;
		_tmp16_ = _vala_code_node_ref0 (_tmp15_);
		_vala_code_node_unref0 (*left_type);
		*left_type = _tmp16_;
		vala_ccode_base_module_make_comparable_cexpression (self, left_type, cleft, right_type, cright);
		_vala_ccode_node_unref0 (valuecast);
		_vala_code_node_unref0 (right_type_as_struct);
		_vala_code_node_unref0 (left_type_as_struct);
		return;
	}
	_tmp17_ = *cright;
	_tmp18_ = *right_type;
	_tmp19_ = *left_type;
	_tmp20_ = vala_ccode_base_module_try_cast_value_to_type (self, _tmp17_, _tmp18_, _tmp19_, NULL);
	_vala_ccode_node_unref0 (valuecast);
	valuecast = _tmp20_;
	_tmp21_ = valuecast;
	if (_tmp21_ != NULL) {
		ValaCCodeExpression* _tmp22_;
		ValaCCodeExpression* _tmp23_;
		ValaDataType* _tmp24_;
		ValaDataType* _tmp25_;
		_tmp22_ = valuecast;
		_tmp23_ = _vala_ccode_node_ref0 (_tmp22_);
		_vala_ccode_node_unref0 (*cright);
		*cright = _tmp23_;
		_tmp24_ = *left_type;
		_tmp25_ = _vala_code_node_ref0 (_tmp24_);
		_vala_code_node_unref0 (*right_type);
		*right_type = _tmp25_;
		vala_ccode_base_module_make_comparable_cexpression (self, left_type, cleft, right_type, cright);
		_vala_ccode_node_unref0 (valuecast);
		_vala_code_node_unref0 (right_type_as_struct);
		_vala_code_node_unref0 (left_type_as_struct);
		return;
	}
	_tmp29_ = *left_type;
	_tmp30_ = vala_data_type_get_data_type (_tmp29_);
	_tmp31_ = _tmp30_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp31_, VALA_TYPE_CLASS)) {
		ValaDataType* _tmp32_;
		ValaTypeSymbol* _tmp33_;
		ValaTypeSymbol* _tmp34_;
		gboolean _tmp35_;
		gboolean _tmp36_;
		_tmp32_ = *left_type;
		_tmp33_ = vala_data_type_get_data_type (_tmp32_);
		_tmp34_ = _tmp33_;
		_tmp35_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, VALA_TYPE_CLASS, ValaClass));
		_tmp36_ = _tmp35_;
		_tmp28_ = !_tmp36_;
	} else {
		_tmp28_ = FALSE;
	}
	if (_tmp28_) {
		ValaDataType* _tmp37_;
		ValaTypeSymbol* _tmp38_;
		ValaTypeSymbol* _tmp39_;
		_tmp37_ = *right_type;
		_tmp38_ = vala_data_type_get_data_type (_tmp37_);
		_tmp39_ = _tmp38_;
		_tmp27_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp39_, VALA_TYPE_CLASS);
	} else {
		_tmp27_ = FALSE;
	}
	if (_tmp27_) {
		ValaDataType* _tmp40_;
		ValaTypeSymbol* _tmp41_;
		ValaTypeSymbol* _tmp42_;
		gboolean _tmp43_;
		gboolean _tmp44_;
		_tmp40_ = *right_type;
		_tmp41_ = vala_data_type_get_data_type (_tmp40_);
		_tmp42_ = _tmp41_;
		_tmp43_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp42_, VALA_TYPE_CLASS, ValaClass));
		_tmp44_ = _tmp43_;
		_tmp26_ = !_tmp44_;
	} else {
		_tmp26_ = FALSE;
	}
	if (_tmp26_) {
		ValaClass* left_cl = NULL;
		ValaDataType* _tmp45_;
		ValaTypeSymbol* _tmp46_;
		ValaTypeSymbol* _tmp47_;
		ValaClass* _tmp48_;
		ValaClass* right_cl = NULL;
		ValaDataType* _tmp49_;
		ValaTypeSymbol* _tmp50_;
		ValaTypeSymbol* _tmp51_;
		ValaClass* _tmp52_;
		ValaClass* _tmp53_;
		ValaClass* _tmp54_;
		_tmp45_ = *left_type;
		_tmp46_ = vala_data_type_get_data_type (_tmp45_);
		_tmp47_ = _tmp46_;
		_tmp48_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp47_, VALA_TYPE_CLASS, ValaClass));
		left_cl = _tmp48_;
		_tmp49_ = *right_type;
		_tmp50_ = vala_data_type_get_data_type (_tmp49_);
		_tmp51_ = _tmp50_;
		_tmp52_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp51_, VALA_TYPE_CLASS, ValaClass));
		right_cl = _tmp52_;
		_tmp53_ = left_cl;
		_tmp54_ = right_cl;
		if (_tmp53_ != _tmp54_) {
			ValaClass* _tmp55_;
			ValaClass* _tmp56_;
			gboolean _tmp57_;
			_tmp55_ = left_cl;
			_tmp56_ = right_cl;
			_tmp57_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp55_, (ValaTypeSymbol*) _tmp56_);
			if (_tmp57_) {
				ValaCCodeExpression* _tmp58_;
				ValaClass* _tmp59_;
				ValaCCodeFunctionCall* _tmp60_;
				_tmp58_ = *cleft;
				_tmp59_ = right_cl;
				_tmp60_ = vala_ccode_base_module_generate_instance_cast (self, _tmp58_, (ValaTypeSymbol*) _tmp59_);
				_vala_ccode_node_unref0 (*cleft);
				*cleft = (ValaCCodeExpression*) _tmp60_;
			} else {
				ValaClass* _tmp61_;
				ValaClass* _tmp62_;
				gboolean _tmp63_;
				_tmp61_ = right_cl;
				_tmp62_ = left_cl;
				_tmp63_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp61_, (ValaTypeSymbol*) _tmp62_);
				if (_tmp63_) {
					ValaCCodeExpression* _tmp64_;
					ValaClass* _tmp65_;
					ValaCCodeFunctionCall* _tmp66_;
					_tmp64_ = *cright;
					_tmp65_ = left_cl;
					_tmp66_ = vala_ccode_base_module_generate_instance_cast (self, _tmp64_, (ValaTypeSymbol*) _tmp65_);
					_vala_ccode_node_unref0 (*cright);
					*cright = (ValaCCodeExpression*) _tmp66_;
				}
			}
		}
		_vala_code_node_unref0 (right_cl);
		_vala_code_node_unref0 (left_cl);
	} else {
		gboolean _tmp67_ = FALSE;
		ValaStruct* _tmp68_;
		_tmp68_ = left_type_as_struct;
		if (_tmp68_ != NULL) {
			ValaStruct* _tmp69_;
			_tmp69_ = right_type_as_struct;
			_tmp67_ = _tmp69_ != NULL;
		} else {
			_tmp67_ = FALSE;
		}
		if (_tmp67_) {
			ValaDataType* _tmp70_;
			_tmp70_ = *left_type;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp70_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
				ValaDataType* _tmp71_;
				gboolean _tmp72_;
				gboolean _tmp73_;
				ValaDataType* _tmp76_;
				gboolean _tmp77_;
				gboolean _tmp78_;
				_tmp71_ = *left_type;
				_tmp72_ = vala_data_type_get_nullable (_tmp71_);
				_tmp73_ = _tmp72_;
				if (!_tmp73_) {
					ValaCCodeExpression* _tmp74_;
					ValaCCodeUnaryExpression* _tmp75_;
					_tmp74_ = *cleft;
					_tmp75_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp74_);
					_vala_ccode_node_unref0 (*cleft);
					*cleft = (ValaCCodeExpression*) _tmp75_;
				}
				_tmp76_ = *right_type;
				_tmp77_ = vala_data_type_get_nullable (_tmp76_);
				_tmp78_ = _tmp77_;
				if (!_tmp78_) {
					ValaCCodeExpression* _tmp79_;
					ValaCCodeUnaryExpression* _tmp80_;
					_tmp79_ = *cright;
					_tmp80_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp79_);
					_vala_ccode_node_unref0 (*cright);
					*cright = (ValaCCodeExpression*) _tmp80_;
				}
			} else {
				gboolean _tmp81_ = FALSE;
				ValaDataType* _tmp82_;
				gboolean _tmp83_;
				gboolean _tmp84_;
				_tmp82_ = *left_type;
				_tmp83_ = vala_data_type_get_nullable (_tmp82_);
				_tmp84_ = _tmp83_;
				if (_tmp84_) {
					ValaDataType* _tmp85_;
					gboolean _tmp86_;
					gboolean _tmp87_;
					_tmp85_ = *right_type;
					_tmp86_ = vala_data_type_get_nullable (_tmp85_);
					_tmp87_ = _tmp86_;
					_tmp81_ = _tmp87_;
				} else {
					_tmp81_ = FALSE;
				}
				if (_tmp81_) {
				} else {
					ValaDataType* _tmp88_;
					gboolean _tmp89_;
					gboolean _tmp90_;
					_tmp88_ = *left_type;
					_tmp89_ = vala_data_type_get_nullable (_tmp88_);
					_tmp90_ = _tmp89_;
					if (_tmp90_) {
						ValaCCodeExpression* _tmp91_;
						ValaCCodeUnaryExpression* _tmp92_;
						_tmp91_ = *cleft;
						_tmp92_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp91_);
						_vala_ccode_node_unref0 (*cleft);
						*cleft = (ValaCCodeExpression*) _tmp92_;
					} else {
						ValaDataType* _tmp93_;
						gboolean _tmp94_;
						gboolean _tmp95_;
						_tmp93_ = *right_type;
						_tmp94_ = vala_data_type_get_nullable (_tmp93_);
						_tmp95_ = _tmp94_;
						if (_tmp95_) {
							ValaCCodeExpression* _tmp96_;
							ValaCCodeUnaryExpression* _tmp97_;
							_tmp96_ = *cright;
							_tmp97_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp96_);
							_vala_ccode_node_unref0 (*cright);
							*cright = (ValaCCodeExpression*) _tmp97_;
						}
					}
				}
			}
		}
	}
	_vala_ccode_node_unref0 (valuecast);
	_vala_code_node_unref0 (right_type_as_struct);
	_vala_code_node_unref0 (left_type_as_struct);
}


static gchar* vala_ccode_base_module_generate_struct_equal_function (ValaCCodeBaseModule* self, ValaStruct* st) {
	gchar* result = NULL;
	ValaStruct* _tmp0_;
	ValaStruct* _tmp1_;
	ValaStruct* _tmp2_;
	gchar* equal_func = NULL;
	ValaStruct* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	const gchar* _tmp12_;
	gboolean _tmp13_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp14_;
	ValaCCodeFunction* _tmp15_;
	ValaCCodeFunction* _tmp16_;
	ValaCCodeFunction* _tmp17_;
	ValaStruct* _tmp18_;
	gchar* _tmp19_;
	gchar* _tmp20_;
	gchar* _tmp21_;
	gchar* _tmp22_;
	ValaCCodeParameter* _tmp23_;
	ValaCCodeParameter* _tmp24_;
	ValaCCodeFunction* _tmp25_;
	ValaStruct* _tmp26_;
	gchar* _tmp27_;
	gchar* _tmp28_;
	gchar* _tmp29_;
	gchar* _tmp30_;
	ValaCCodeParameter* _tmp31_;
	ValaCCodeParameter* _tmp32_;
	ValaCCodeFunction* _tmp33_;
	gboolean has_instance_fields = FALSE;
	gboolean _tmp161_;
	ValaCCodeFile* _tmp185_;
	ValaCCodeFunction* _tmp186_;
	ValaCCodeFile* _tmp187_;
	ValaCCodeFunction* _tmp188_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (st != NULL, NULL);
	_tmp0_ = st;
	_tmp1_ = vala_struct_get_base_struct (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ != NULL) {
		ValaStruct* _tmp3_;
		ValaStruct* _tmp4_;
		ValaStruct* _tmp5_;
		gchar* _tmp6_;
		_tmp3_ = st;
		_tmp4_ = vala_struct_get_base_struct (_tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = vala_ccode_base_module_generate_struct_equal_function (self, _tmp5_);
		result = _tmp6_;
		return result;
	}
	_tmp7_ = st;
	_tmp8_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = g_strdup_printf ("_%sequal", _tmp9_);
	_tmp11_ = _tmp10_;
	_g_free0 (_tmp9_);
	equal_func = _tmp11_;
	_tmp12_ = equal_func;
	_tmp13_ = vala_ccode_base_module_add_wrapper (self, _tmp12_);
	if (!_tmp13_) {
		result = equal_func;
		return result;
	}
	_tmp14_ = equal_func;
	_tmp15_ = vala_ccode_function_new (_tmp14_, "gboolean");
	function = _tmp15_;
	_tmp16_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp16_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp17_ = function;
	_tmp18_ = st;
	_tmp19_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp18_);
	_tmp20_ = _tmp19_;
	_tmp21_ = g_strdup_printf ("const %s *", _tmp20_);
	_tmp22_ = _tmp21_;
	_tmp23_ = vala_ccode_parameter_new ("s1", _tmp22_);
	_tmp24_ = _tmp23_;
	vala_ccode_function_add_parameter (_tmp17_, _tmp24_);
	_vala_ccode_node_unref0 (_tmp24_);
	_g_free0 (_tmp22_);
	_g_free0 (_tmp20_);
	_tmp25_ = function;
	_tmp26_ = st;
	_tmp27_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp26_);
	_tmp28_ = _tmp27_;
	_tmp29_ = g_strdup_printf ("const %s *", _tmp28_);
	_tmp30_ = _tmp29_;
	_tmp31_ = vala_ccode_parameter_new ("s2", _tmp30_);
	_tmp32_ = _tmp31_;
	vala_ccode_function_add_parameter (_tmp25_, _tmp32_);
	_vala_ccode_node_unref0 (_tmp32_);
	_g_free0 (_tmp30_);
	_g_free0 (_tmp28_);
	_tmp33_ = function;
	vala_ccode_base_module_push_function (self, _tmp33_);
	{
		ValaCCodeBinaryExpression* cexp = NULL;
		ValaCCodeIdentifier* _tmp34_;
		ValaCCodeIdentifier* _tmp35_;
		ValaCCodeIdentifier* _tmp36_;
		ValaCCodeIdentifier* _tmp37_;
		ValaCCodeBinaryExpression* _tmp38_;
		ValaCCodeBinaryExpression* _tmp39_;
		ValaCCodeFunction* _tmp40_;
		ValaCCodeFunction* _tmp41_;
		ValaCCodeBinaryExpression* _tmp42_;
		ValaCCodeFunction* _tmp43_;
		ValaCCodeFunction* _tmp44_;
		ValaCCodeConstant* _tmp45_;
		ValaCCodeConstant* _tmp46_;
		ValaCCodeFunction* _tmp47_;
		ValaCCodeFunction* _tmp48_;
		_tmp34_ = vala_ccode_identifier_new ("s1");
		_tmp35_ = _tmp34_;
		_tmp36_ = vala_ccode_identifier_new ("s2");
		_tmp37_ = _tmp36_;
		_tmp38_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp35_, (ValaCCodeExpression*) _tmp37_);
		_tmp39_ = _tmp38_;
		_vala_ccode_node_unref0 (_tmp37_);
		_vala_ccode_node_unref0 (_tmp35_);
		cexp = _tmp39_;
		_tmp40_ = vala_ccode_base_module_get_ccode (self);
		_tmp41_ = _tmp40_;
		_tmp42_ = cexp;
		vala_ccode_function_open_if (_tmp41_, (ValaCCodeExpression*) _tmp42_);
		_tmp43_ = vala_ccode_base_module_get_ccode (self);
		_tmp44_ = _tmp43_;
		_tmp45_ = vala_ccode_constant_new ("TRUE");
		_tmp46_ = _tmp45_;
		vala_ccode_function_add_return (_tmp44_, (ValaCCodeExpression*) _tmp46_);
		_vala_ccode_node_unref0 (_tmp46_);
		_tmp47_ = vala_ccode_base_module_get_ccode (self);
		_tmp48_ = _tmp47_;
		vala_ccode_function_close (_tmp48_);
		_vala_ccode_node_unref0 (cexp);
	}
	{
		ValaCCodeBinaryExpression* cexp = NULL;
		ValaCCodeIdentifier* _tmp49_;
		ValaCCodeIdentifier* _tmp50_;
		ValaCCodeConstant* _tmp51_;
		ValaCCodeConstant* _tmp52_;
		ValaCCodeBinaryExpression* _tmp53_;
		ValaCCodeBinaryExpression* _tmp54_;
		ValaCCodeFunction* _tmp55_;
		ValaCCodeFunction* _tmp56_;
		ValaCCodeBinaryExpression* _tmp57_;
		ValaCCodeFunction* _tmp58_;
		ValaCCodeFunction* _tmp59_;
		ValaCCodeConstant* _tmp60_;
		ValaCCodeConstant* _tmp61_;
		ValaCCodeFunction* _tmp62_;
		ValaCCodeFunction* _tmp63_;
		ValaCCodeIdentifier* _tmp64_;
		ValaCCodeIdentifier* _tmp65_;
		ValaCCodeConstant* _tmp66_;
		ValaCCodeConstant* _tmp67_;
		ValaCCodeBinaryExpression* _tmp68_;
		ValaCCodeFunction* _tmp69_;
		ValaCCodeFunction* _tmp70_;
		ValaCCodeBinaryExpression* _tmp71_;
		ValaCCodeFunction* _tmp72_;
		ValaCCodeFunction* _tmp73_;
		ValaCCodeConstant* _tmp74_;
		ValaCCodeConstant* _tmp75_;
		ValaCCodeFunction* _tmp76_;
		ValaCCodeFunction* _tmp77_;
		_tmp49_ = vala_ccode_identifier_new ("s1");
		_tmp50_ = _tmp49_;
		_tmp51_ = vala_ccode_constant_new ("NULL");
		_tmp52_ = _tmp51_;
		_tmp53_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp50_, (ValaCCodeExpression*) _tmp52_);
		_tmp54_ = _tmp53_;
		_vala_ccode_node_unref0 (_tmp52_);
		_vala_ccode_node_unref0 (_tmp50_);
		cexp = _tmp54_;
		_tmp55_ = vala_ccode_base_module_get_ccode (self);
		_tmp56_ = _tmp55_;
		_tmp57_ = cexp;
		vala_ccode_function_open_if (_tmp56_, (ValaCCodeExpression*) _tmp57_);
		_tmp58_ = vala_ccode_base_module_get_ccode (self);
		_tmp59_ = _tmp58_;
		_tmp60_ = vala_ccode_constant_new ("FALSE");
		_tmp61_ = _tmp60_;
		vala_ccode_function_add_return (_tmp59_, (ValaCCodeExpression*) _tmp61_);
		_vala_ccode_node_unref0 (_tmp61_);
		_tmp62_ = vala_ccode_base_module_get_ccode (self);
		_tmp63_ = _tmp62_;
		vala_ccode_function_close (_tmp63_);
		_tmp64_ = vala_ccode_identifier_new ("s2");
		_tmp65_ = _tmp64_;
		_tmp66_ = vala_ccode_constant_new ("NULL");
		_tmp67_ = _tmp66_;
		_tmp68_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp65_, (ValaCCodeExpression*) _tmp67_);
		_vala_ccode_node_unref0 (cexp);
		cexp = _tmp68_;
		_vala_ccode_node_unref0 (_tmp67_);
		_vala_ccode_node_unref0 (_tmp65_);
		_tmp69_ = vala_ccode_base_module_get_ccode (self);
		_tmp70_ = _tmp69_;
		_tmp71_ = cexp;
		vala_ccode_function_open_if (_tmp70_, (ValaCCodeExpression*) _tmp71_);
		_tmp72_ = vala_ccode_base_module_get_ccode (self);
		_tmp73_ = _tmp72_;
		_tmp74_ = vala_ccode_constant_new ("FALSE");
		_tmp75_ = _tmp74_;
		vala_ccode_function_add_return (_tmp73_, (ValaCCodeExpression*) _tmp75_);
		_vala_ccode_node_unref0 (_tmp75_);
		_tmp76_ = vala_ccode_base_module_get_ccode (self);
		_tmp77_ = _tmp76_;
		vala_ccode_function_close (_tmp77_);
		_vala_ccode_node_unref0 (cexp);
	}
	has_instance_fields = FALSE;
	{
		ValaList* _f_list = NULL;
		ValaStruct* _tmp78_;
		ValaList* _tmp79_;
		gint _f_size = 0;
		ValaList* _tmp80_;
		gint _tmp81_;
		gint _tmp82_;
		gint _f_index = 0;
		_tmp78_ = st;
		_tmp79_ = vala_struct_get_fields (_tmp78_);
		_f_list = _tmp79_;
		_tmp80_ = _f_list;
		_tmp81_ = vala_collection_get_size ((ValaCollection*) _tmp80_);
		_tmp82_ = _tmp81_;
		_f_size = _tmp82_;
		_f_index = -1;
		while (TRUE) {
			gint _tmp83_;
			gint _tmp84_;
			gint _tmp85_;
			ValaField* f = NULL;
			ValaList* _tmp86_;
			gint _tmp87_;
			gpointer _tmp88_;
			ValaField* _tmp89_;
			ValaMemberBinding _tmp90_;
			ValaMemberBinding _tmp91_;
			ValaCCodeExpression* cexp = NULL;
			ValaCCodeExpression* s1 = NULL;
			ValaCCodeIdentifier* _tmp92_;
			ValaCCodeIdentifier* _tmp93_;
			ValaField* _tmp94_;
			gchar* _tmp95_;
			gchar* _tmp96_;
			ValaCCodeMemberAccess* _tmp97_;
			ValaCCodeExpression* _tmp98_;
			ValaCCodeExpression* s2 = NULL;
			ValaCCodeIdentifier* _tmp99_;
			ValaCCodeIdentifier* _tmp100_;
			ValaField* _tmp101_;
			gchar* _tmp102_;
			gchar* _tmp103_;
			ValaCCodeMemberAccess* _tmp104_;
			ValaCCodeExpression* _tmp105_;
			ValaDataType* variable_type = NULL;
			ValaField* _tmp106_;
			ValaDataType* _tmp107_;
			ValaDataType* _tmp108_;
			ValaDataType* _tmp109_;
			gboolean _tmp110_ = FALSE;
			ValaField* _tmp111_;
			ValaDataType* _tmp112_;
			ValaDataType* _tmp113_;
			ValaCCodeFunction* _tmp152_;
			ValaCCodeFunction* _tmp153_;
			ValaCCodeExpression* _tmp154_;
			ValaCCodeFunction* _tmp155_;
			ValaCCodeFunction* _tmp156_;
			ValaCCodeConstant* _tmp157_;
			ValaCCodeConstant* _tmp158_;
			ValaCCodeFunction* _tmp159_;
			ValaCCodeFunction* _tmp160_;
			_tmp83_ = _f_index;
			_f_index = _tmp83_ + 1;
			_tmp84_ = _f_index;
			_tmp85_ = _f_size;
			if (!(_tmp84_ < _tmp85_)) {
				break;
			}
			_tmp86_ = _f_list;
			_tmp87_ = _f_index;
			_tmp88_ = vala_list_get (_tmp86_, _tmp87_);
			f = (ValaField*) _tmp88_;
			_tmp89_ = f;
			_tmp90_ = vala_field_get_binding (_tmp89_);
			_tmp91_ = _tmp90_;
			if (_tmp91_ != VALA_MEMBER_BINDING_INSTANCE) {
				_vala_code_node_unref0 (f);
				continue;
			}
			has_instance_fields = TRUE;
			_tmp92_ = vala_ccode_identifier_new ("s1");
			_tmp93_ = _tmp92_;
			_tmp94_ = f;
			_tmp95_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp94_);
			_tmp96_ = _tmp95_;
			_tmp97_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp93_, _tmp96_);
			_tmp98_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp97_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression);
			_g_free0 (_tmp96_);
			_vala_ccode_node_unref0 (_tmp93_);
			s1 = _tmp98_;
			_tmp99_ = vala_ccode_identifier_new ("s2");
			_tmp100_ = _tmp99_;
			_tmp101_ = f;
			_tmp102_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp101_);
			_tmp103_ = _tmp102_;
			_tmp104_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp100_, _tmp103_);
			_tmp105_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp104_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression);
			_g_free0 (_tmp103_);
			_vala_ccode_node_unref0 (_tmp100_);
			s2 = _tmp105_;
			_tmp106_ = f;
			_tmp107_ = vala_variable_get_variable_type ((ValaVariable*) _tmp106_);
			_tmp108_ = _tmp107_;
			_tmp109_ = vala_data_type_copy (_tmp108_);
			variable_type = _tmp109_;
			vala_ccode_base_module_make_comparable_cexpression (self, &variable_type, &s1, &variable_type, &s2);
			_tmp111_ = f;
			_tmp112_ = vala_variable_get_variable_type ((ValaVariable*) _tmp111_);
			_tmp113_ = _tmp112_;
			if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp113_, VALA_TYPE_NULL_TYPE)) {
				ValaField* _tmp114_;
				ValaDataType* _tmp115_;
				ValaDataType* _tmp116_;
				ValaDataType* _tmp117_;
				gboolean _tmp118_;
				_tmp114_ = f;
				_tmp115_ = vala_variable_get_variable_type ((ValaVariable*) _tmp114_);
				_tmp116_ = _tmp115_;
				_tmp117_ = self->string_type;
				_tmp118_ = vala_data_type_compatible (_tmp116_, _tmp117_);
				_tmp110_ = _tmp118_;
			} else {
				_tmp110_ = FALSE;
			}
			if (_tmp110_) {
				ValaCCodeFunctionCall* ccall = NULL;
				ValaCCodeIdentifier* _tmp119_;
				ValaCCodeIdentifier* _tmp120_;
				ValaCCodeFunctionCall* _tmp121_;
				ValaCCodeFunctionCall* _tmp122_;
				ValaCCodeFunctionCall* _tmp123_;
				ValaCCodeExpression* _tmp124_;
				ValaCCodeFunctionCall* _tmp125_;
				ValaCCodeExpression* _tmp126_;
				ValaCCodeFunctionCall* _tmp127_;
				ValaCCodeExpression* _tmp128_;
				_tmp119_ = vala_ccode_identifier_new ("g_strcmp0");
				_tmp120_ = _tmp119_;
				_tmp121_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp120_);
				_tmp122_ = _tmp121_;
				_vala_ccode_node_unref0 (_tmp120_);
				ccall = _tmp122_;
				_tmp123_ = ccall;
				_tmp124_ = s1;
				vala_ccode_function_call_add_argument (_tmp123_, _tmp124_);
				_tmp125_ = ccall;
				_tmp126_ = s2;
				vala_ccode_function_call_add_argument (_tmp125_, _tmp126_);
				_tmp127_ = ccall;
				_tmp128_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp127_);
				_vala_ccode_node_unref0 (cexp);
				cexp = _tmp128_;
				_vala_ccode_node_unref0 (ccall);
			} else {
				ValaField* _tmp129_;
				ValaDataType* _tmp130_;
				ValaDataType* _tmp131_;
				_tmp129_ = f;
				_tmp130_ = vala_variable_get_variable_type ((ValaVariable*) _tmp129_);
				_tmp131_ = _tmp130_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp131_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
					gchar* equalfunc = NULL;
					ValaField* _tmp132_;
					ValaDataType* _tmp133_;
					ValaDataType* _tmp134_;
					ValaTypeSymbol* _tmp135_;
					ValaTypeSymbol* _tmp136_;
					gchar* _tmp137_;
					ValaCCodeFunctionCall* ccall = NULL;
					const gchar* _tmp138_;
					ValaCCodeIdentifier* _tmp139_;
					ValaCCodeIdentifier* _tmp140_;
					ValaCCodeFunctionCall* _tmp141_;
					ValaCCodeFunctionCall* _tmp142_;
					ValaCCodeFunctionCall* _tmp143_;
					ValaCCodeExpression* _tmp144_;
					ValaCCodeFunctionCall* _tmp145_;
					ValaCCodeExpression* _tmp146_;
					ValaCCodeFunctionCall* _tmp147_;
					ValaCCodeUnaryExpression* _tmp148_;
					_tmp132_ = f;
					_tmp133_ = vala_variable_get_variable_type ((ValaVariable*) _tmp132_);
					_tmp134_ = _tmp133_;
					_tmp135_ = vala_data_type_get_data_type (_tmp134_);
					_tmp136_ = _tmp135_;
					_tmp137_ = vala_ccode_base_module_generate_struct_equal_function (self, G_TYPE_CHECK_INSTANCE_TYPE (_tmp136_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp136_) : NULL);
					equalfunc = _tmp137_;
					_tmp138_ = equalfunc;
					_tmp139_ = vala_ccode_identifier_new (_tmp138_);
					_tmp140_ = _tmp139_;
					_tmp141_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp140_);
					_tmp142_ = _tmp141_;
					_vala_ccode_node_unref0 (_tmp140_);
					ccall = _tmp142_;
					_tmp143_ = ccall;
					_tmp144_ = s1;
					vala_ccode_function_call_add_argument (_tmp143_, _tmp144_);
					_tmp145_ = ccall;
					_tmp146_ = s2;
					vala_ccode_function_call_add_argument (_tmp145_, _tmp146_);
					_tmp147_ = ccall;
					_tmp148_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp147_);
					_vala_ccode_node_unref0 (cexp);
					cexp = (ValaCCodeExpression*) _tmp148_;
					_vala_ccode_node_unref0 (ccall);
					_g_free0 (equalfunc);
				} else {
					ValaCCodeExpression* _tmp149_;
					ValaCCodeExpression* _tmp150_;
					ValaCCodeBinaryExpression* _tmp151_;
					_tmp149_ = s1;
					_tmp150_ = s2;
					_tmp151_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, _tmp149_, _tmp150_);
					_vala_ccode_node_unref0 (cexp);
					cexp = (ValaCCodeExpression*) _tmp151_;
				}
			}
			_tmp152_ = vala_ccode_base_module_get_ccode (self);
			_tmp153_ = _tmp152_;
			_tmp154_ = cexp;
			vala_ccode_function_open_if (_tmp153_, _tmp154_);
			_tmp155_ = vala_ccode_base_module_get_ccode (self);
			_tmp156_ = _tmp155_;
			_tmp157_ = vala_ccode_constant_new ("FALSE");
			_tmp158_ = _tmp157_;
			vala_ccode_function_add_return (_tmp156_, (ValaCCodeExpression*) _tmp158_);
			_vala_ccode_node_unref0 (_tmp158_);
			_tmp159_ = vala_ccode_base_module_get_ccode (self);
			_tmp160_ = _tmp159_;
			vala_ccode_function_close (_tmp160_);
			_vala_code_node_unref0 (variable_type);
			_vala_ccode_node_unref0 (s2);
			_vala_ccode_node_unref0 (s1);
			_vala_ccode_node_unref0 (cexp);
			_vala_code_node_unref0 (f);
		}
		_vala_iterable_unref0 (_f_list);
	}
	_tmp161_ = has_instance_fields;
	if (!_tmp161_) {
		ValaStruct* _tmp162_;
		gboolean _tmp163_;
		_tmp162_ = st;
		_tmp163_ = vala_struct_is_simple_type (_tmp162_);
		if (_tmp163_) {
			ValaCCodeBinaryExpression* cexp = NULL;
			ValaCCodeIdentifier* _tmp164_;
			ValaCCodeIdentifier* _tmp165_;
			ValaCCodeUnaryExpression* _tmp166_;
			ValaCCodeUnaryExpression* _tmp167_;
			ValaCCodeIdentifier* _tmp168_;
			ValaCCodeIdentifier* _tmp169_;
			ValaCCodeUnaryExpression* _tmp170_;
			ValaCCodeUnaryExpression* _tmp171_;
			ValaCCodeBinaryExpression* _tmp172_;
			ValaCCodeBinaryExpression* _tmp173_;
			ValaCCodeFunction* _tmp174_;
			ValaCCodeFunction* _tmp175_;
			ValaCCodeBinaryExpression* _tmp176_;
			_tmp164_ = vala_ccode_identifier_new ("s1");
			_tmp165_ = _tmp164_;
			_tmp166_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp165_);
			_tmp167_ = _tmp166_;
			_tmp168_ = vala_ccode_identifier_new ("s2");
			_tmp169_ = _tmp168_;
			_tmp170_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp169_);
			_tmp171_ = _tmp170_;
			_tmp172_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp167_, (ValaCCodeExpression*) _tmp171_);
			_tmp173_ = _tmp172_;
			_vala_ccode_node_unref0 (_tmp171_);
			_vala_ccode_node_unref0 (_tmp169_);
			_vala_ccode_node_unref0 (_tmp167_);
			_vala_ccode_node_unref0 (_tmp165_);
			cexp = _tmp173_;
			_tmp174_ = vala_ccode_base_module_get_ccode (self);
			_tmp175_ = _tmp174_;
			_tmp176_ = cexp;
			vala_ccode_function_add_return (_tmp175_, (ValaCCodeExpression*) _tmp176_);
			_vala_ccode_node_unref0 (cexp);
		} else {
			ValaCCodeFunction* _tmp177_;
			ValaCCodeFunction* _tmp178_;
			ValaCCodeConstant* _tmp179_;
			ValaCCodeConstant* _tmp180_;
			_tmp177_ = vala_ccode_base_module_get_ccode (self);
			_tmp178_ = _tmp177_;
			_tmp179_ = vala_ccode_constant_new ("FALSE");
			_tmp180_ = _tmp179_;
			vala_ccode_function_add_return (_tmp178_, (ValaCCodeExpression*) _tmp180_);
			_vala_ccode_node_unref0 (_tmp180_);
		}
	} else {
		ValaCCodeFunction* _tmp181_;
		ValaCCodeFunction* _tmp182_;
		ValaCCodeConstant* _tmp183_;
		ValaCCodeConstant* _tmp184_;
		_tmp181_ = vala_ccode_base_module_get_ccode (self);
		_tmp182_ = _tmp181_;
		_tmp183_ = vala_ccode_constant_new ("TRUE");
		_tmp184_ = _tmp183_;
		vala_ccode_function_add_return (_tmp182_, (ValaCCodeExpression*) _tmp184_);
		_vala_ccode_node_unref0 (_tmp184_);
	}
	vala_ccode_base_module_pop_function (self);
	_tmp185_ = self->cfile;
	_tmp186_ = function;
	vala_ccode_file_add_function_declaration (_tmp185_, _tmp186_);
	_tmp187_ = self->cfile;
	_tmp188_ = function;
	vala_ccode_file_add_function (_tmp187_, _tmp188_);
	result = equal_func;
	_vala_ccode_node_unref0 (function);
	return result;
}


static gchar* vala_ccode_base_module_generate_numeric_equal_function (ValaCCodeBaseModule* self, ValaTypeSymbol* sym) {
	gchar* result = NULL;
	gchar* equal_func = NULL;
	ValaTypeSymbol* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	const gchar* _tmp5_;
	gboolean _tmp6_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp7_;
	ValaCCodeFunction* _tmp8_;
	ValaCCodeFunction* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	ValaTypeSymbol* _tmp11_;
	gchar* _tmp12_;
	gchar* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
	ValaCCodeParameter* _tmp16_;
	ValaCCodeParameter* _tmp17_;
	ValaCCodeFunction* _tmp18_;
	ValaTypeSymbol* _tmp19_;
	gchar* _tmp20_;
	gchar* _tmp21_;
	gchar* _tmp22_;
	gchar* _tmp23_;
	ValaCCodeParameter* _tmp24_;
	ValaCCodeParameter* _tmp25_;
	ValaCCodeFunction* _tmp26_;
	ValaCCodeFile* _tmp84_;
	ValaCCodeFunction* _tmp85_;
	ValaCCodeFile* _tmp86_;
	ValaCCodeFunction* _tmp87_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = g_strdup_printf ("_%sequal", _tmp2_);
	_tmp4_ = _tmp3_;
	_g_free0 (_tmp2_);
	equal_func = _tmp4_;
	_tmp5_ = equal_func;
	_tmp6_ = vala_ccode_base_module_add_wrapper (self, _tmp5_);
	if (!_tmp6_) {
		result = equal_func;
		return result;
	}
	_tmp7_ = equal_func;
	_tmp8_ = vala_ccode_function_new (_tmp7_, "gboolean");
	function = _tmp8_;
	_tmp9_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp9_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp10_ = function;
	_tmp11_ = sym;
	_tmp12_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp11_);
	_tmp13_ = _tmp12_;
	_tmp14_ = g_strdup_printf ("const %s *", _tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = vala_ccode_parameter_new ("s1", _tmp15_);
	_tmp17_ = _tmp16_;
	vala_ccode_function_add_parameter (_tmp10_, _tmp17_);
	_vala_ccode_node_unref0 (_tmp17_);
	_g_free0 (_tmp15_);
	_g_free0 (_tmp13_);
	_tmp18_ = function;
	_tmp19_ = sym;
	_tmp20_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp19_);
	_tmp21_ = _tmp20_;
	_tmp22_ = g_strdup_printf ("const %s *", _tmp21_);
	_tmp23_ = _tmp22_;
	_tmp24_ = vala_ccode_parameter_new ("s2", _tmp23_);
	_tmp25_ = _tmp24_;
	vala_ccode_function_add_parameter (_tmp18_, _tmp25_);
	_vala_ccode_node_unref0 (_tmp25_);
	_g_free0 (_tmp23_);
	_g_free0 (_tmp21_);
	_tmp26_ = function;
	vala_ccode_base_module_push_function (self, _tmp26_);
	{
		ValaCCodeBinaryExpression* cexp = NULL;
		ValaCCodeIdentifier* _tmp27_;
		ValaCCodeIdentifier* _tmp28_;
		ValaCCodeIdentifier* _tmp29_;
		ValaCCodeIdentifier* _tmp30_;
		ValaCCodeBinaryExpression* _tmp31_;
		ValaCCodeBinaryExpression* _tmp32_;
		ValaCCodeFunction* _tmp33_;
		ValaCCodeFunction* _tmp34_;
		ValaCCodeBinaryExpression* _tmp35_;
		ValaCCodeFunction* _tmp36_;
		ValaCCodeFunction* _tmp37_;
		ValaCCodeConstant* _tmp38_;
		ValaCCodeConstant* _tmp39_;
		ValaCCodeFunction* _tmp40_;
		ValaCCodeFunction* _tmp41_;
		_tmp27_ = vala_ccode_identifier_new ("s1");
		_tmp28_ = _tmp27_;
		_tmp29_ = vala_ccode_identifier_new ("s2");
		_tmp30_ = _tmp29_;
		_tmp31_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp28_, (ValaCCodeExpression*) _tmp30_);
		_tmp32_ = _tmp31_;
		_vala_ccode_node_unref0 (_tmp30_);
		_vala_ccode_node_unref0 (_tmp28_);
		cexp = _tmp32_;
		_tmp33_ = vala_ccode_base_module_get_ccode (self);
		_tmp34_ = _tmp33_;
		_tmp35_ = cexp;
		vala_ccode_function_open_if (_tmp34_, (ValaCCodeExpression*) _tmp35_);
		_tmp36_ = vala_ccode_base_module_get_ccode (self);
		_tmp37_ = _tmp36_;
		_tmp38_ = vala_ccode_constant_new ("TRUE");
		_tmp39_ = _tmp38_;
		vala_ccode_function_add_return (_tmp37_, (ValaCCodeExpression*) _tmp39_);
		_vala_ccode_node_unref0 (_tmp39_);
		_tmp40_ = vala_ccode_base_module_get_ccode (self);
		_tmp41_ = _tmp40_;
		vala_ccode_function_close (_tmp41_);
		_vala_ccode_node_unref0 (cexp);
	}
	{
		ValaCCodeBinaryExpression* cexp = NULL;
		ValaCCodeIdentifier* _tmp42_;
		ValaCCodeIdentifier* _tmp43_;
		ValaCCodeConstant* _tmp44_;
		ValaCCodeConstant* _tmp45_;
		ValaCCodeBinaryExpression* _tmp46_;
		ValaCCodeBinaryExpression* _tmp47_;
		ValaCCodeFunction* _tmp48_;
		ValaCCodeFunction* _tmp49_;
		ValaCCodeBinaryExpression* _tmp50_;
		ValaCCodeFunction* _tmp51_;
		ValaCCodeFunction* _tmp52_;
		ValaCCodeConstant* _tmp53_;
		ValaCCodeConstant* _tmp54_;
		ValaCCodeFunction* _tmp55_;
		ValaCCodeFunction* _tmp56_;
		ValaCCodeIdentifier* _tmp57_;
		ValaCCodeIdentifier* _tmp58_;
		ValaCCodeConstant* _tmp59_;
		ValaCCodeConstant* _tmp60_;
		ValaCCodeBinaryExpression* _tmp61_;
		ValaCCodeFunction* _tmp62_;
		ValaCCodeFunction* _tmp63_;
		ValaCCodeBinaryExpression* _tmp64_;
		ValaCCodeFunction* _tmp65_;
		ValaCCodeFunction* _tmp66_;
		ValaCCodeConstant* _tmp67_;
		ValaCCodeConstant* _tmp68_;
		ValaCCodeFunction* _tmp69_;
		ValaCCodeFunction* _tmp70_;
		_tmp42_ = vala_ccode_identifier_new ("s1");
		_tmp43_ = _tmp42_;
		_tmp44_ = vala_ccode_constant_new ("NULL");
		_tmp45_ = _tmp44_;
		_tmp46_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp43_, (ValaCCodeExpression*) _tmp45_);
		_tmp47_ = _tmp46_;
		_vala_ccode_node_unref0 (_tmp45_);
		_vala_ccode_node_unref0 (_tmp43_);
		cexp = _tmp47_;
		_tmp48_ = vala_ccode_base_module_get_ccode (self);
		_tmp49_ = _tmp48_;
		_tmp50_ = cexp;
		vala_ccode_function_open_if (_tmp49_, (ValaCCodeExpression*) _tmp50_);
		_tmp51_ = vala_ccode_base_module_get_ccode (self);
		_tmp52_ = _tmp51_;
		_tmp53_ = vala_ccode_constant_new ("FALSE");
		_tmp54_ = _tmp53_;
		vala_ccode_function_add_return (_tmp52_, (ValaCCodeExpression*) _tmp54_);
		_vala_ccode_node_unref0 (_tmp54_);
		_tmp55_ = vala_ccode_base_module_get_ccode (self);
		_tmp56_ = _tmp55_;
		vala_ccode_function_close (_tmp56_);
		_tmp57_ = vala_ccode_identifier_new ("s2");
		_tmp58_ = _tmp57_;
		_tmp59_ = vala_ccode_constant_new ("NULL");
		_tmp60_ = _tmp59_;
		_tmp61_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp58_, (ValaCCodeExpression*) _tmp60_);
		_vala_ccode_node_unref0 (cexp);
		cexp = _tmp61_;
		_vala_ccode_node_unref0 (_tmp60_);
		_vala_ccode_node_unref0 (_tmp58_);
		_tmp62_ = vala_ccode_base_module_get_ccode (self);
		_tmp63_ = _tmp62_;
		_tmp64_ = cexp;
		vala_ccode_function_open_if (_tmp63_, (ValaCCodeExpression*) _tmp64_);
		_tmp65_ = vala_ccode_base_module_get_ccode (self);
		_tmp66_ = _tmp65_;
		_tmp67_ = vala_ccode_constant_new ("FALSE");
		_tmp68_ = _tmp67_;
		vala_ccode_function_add_return (_tmp66_, (ValaCCodeExpression*) _tmp68_);
		_vala_ccode_node_unref0 (_tmp68_);
		_tmp69_ = vala_ccode_base_module_get_ccode (self);
		_tmp70_ = _tmp69_;
		vala_ccode_function_close (_tmp70_);
		_vala_ccode_node_unref0 (cexp);
	}
	{
		ValaCCodeBinaryExpression* cexp = NULL;
		ValaCCodeIdentifier* _tmp71_;
		ValaCCodeIdentifier* _tmp72_;
		ValaCCodeUnaryExpression* _tmp73_;
		ValaCCodeUnaryExpression* _tmp74_;
		ValaCCodeIdentifier* _tmp75_;
		ValaCCodeIdentifier* _tmp76_;
		ValaCCodeUnaryExpression* _tmp77_;
		ValaCCodeUnaryExpression* _tmp78_;
		ValaCCodeBinaryExpression* _tmp79_;
		ValaCCodeBinaryExpression* _tmp80_;
		ValaCCodeFunction* _tmp81_;
		ValaCCodeFunction* _tmp82_;
		ValaCCodeBinaryExpression* _tmp83_;
		_tmp71_ = vala_ccode_identifier_new ("s1");
		_tmp72_ = _tmp71_;
		_tmp73_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp72_);
		_tmp74_ = _tmp73_;
		_tmp75_ = vala_ccode_identifier_new ("s2");
		_tmp76_ = _tmp75_;
		_tmp77_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp76_);
		_tmp78_ = _tmp77_;
		_tmp79_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp74_, (ValaCCodeExpression*) _tmp78_);
		_tmp80_ = _tmp79_;
		_vala_ccode_node_unref0 (_tmp78_);
		_vala_ccode_node_unref0 (_tmp76_);
		_vala_ccode_node_unref0 (_tmp74_);
		_vala_ccode_node_unref0 (_tmp72_);
		cexp = _tmp80_;
		_tmp81_ = vala_ccode_base_module_get_ccode (self);
		_tmp82_ = _tmp81_;
		_tmp83_ = cexp;
		vala_ccode_function_add_return (_tmp82_, (ValaCCodeExpression*) _tmp83_);
		_vala_ccode_node_unref0 (cexp);
	}
	vala_ccode_base_module_pop_function (self);
	_tmp84_ = self->cfile;
	_tmp85_ = function;
	vala_ccode_file_add_function_declaration (_tmp84_, _tmp85_);
	_tmp86_ = self->cfile;
	_tmp87_ = function;
	vala_ccode_file_add_function (_tmp86_, _tmp87_);
	result = equal_func;
	_vala_ccode_node_unref0 (function);
	return result;
}


static gchar* vala_ccode_base_module_generate_struct_dup_wrapper (ValaCCodeBaseModule* self, ValaValueType* value_type) {
	gchar* result = NULL;
	gchar* dup_func = NULL;
	ValaValueType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	const gchar* _tmp7_;
	gboolean _tmp8_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp9_;
	ValaValueType* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	ValaCCodeFunction* _tmp13_;
	ValaCCodeFunction* _tmp14_;
	ValaCCodeFunction* _tmp15_;
	ValaCCodeFunction* _tmp16_;
	ValaValueType* _tmp17_;
	gchar* _tmp18_;
	gchar* _tmp19_;
	ValaCCodeParameter* _tmp20_;
	ValaCCodeParameter* _tmp21_;
	ValaCCodeFunction* _tmp22_;
	ValaValueType* _tmp23_;
	ValaTypeSymbol* _tmp24_;
	ValaTypeSymbol* _tmp25_;
	ValaStruct* _tmp26_;
	ValaCCodeFile* _tmp126_;
	ValaCCodeFunction* _tmp127_;
	ValaCCodeFile* _tmp128_;
	ValaCCodeFunction* _tmp129_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (value_type != NULL, NULL);
	_tmp0_ = value_type;
	_tmp1_ = vala_value_type_get_type_symbol (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup_printf ("_%sdup", _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	dup_func = _tmp6_;
	_tmp7_ = dup_func;
	_tmp8_ = vala_ccode_base_module_add_wrapper (self, _tmp7_);
	if (!_tmp8_) {
		result = dup_func;
		return result;
	}
	_tmp9_ = dup_func;
	_tmp10_ = value_type;
	_tmp11_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp10_);
	_tmp12_ = _tmp11_;
	_tmp13_ = vala_ccode_function_new (_tmp9_, _tmp12_);
	_tmp14_ = _tmp13_;
	_g_free0 (_tmp12_);
	function = _tmp14_;
	_tmp15_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp15_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp16_ = function;
	_tmp17_ = value_type;
	_tmp18_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = vala_ccode_parameter_new ("self", _tmp19_);
	_tmp21_ = _tmp20_;
	vala_ccode_function_add_parameter (_tmp16_, _tmp21_);
	_vala_ccode_node_unref0 (_tmp21_);
	_g_free0 (_tmp19_);
	_tmp22_ = function;
	vala_ccode_base_module_push_function (self, _tmp22_);
	_tmp23_ = value_type;
	_tmp24_ = vala_value_type_get_type_symbol (_tmp23_);
	_tmp25_ = _tmp24_;
	_tmp26_ = self->gvalue_type;
	if (_tmp25_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) {
		ValaCCodeFunctionCall* dup_call = NULL;
		ValaCCodeIdentifier* _tmp27_;
		ValaCCodeIdentifier* _tmp28_;
		ValaCCodeFunctionCall* _tmp29_;
		ValaCCodeFunctionCall* _tmp30_;
		ValaCCodeFunctionCall* _tmp31_;
		ValaCCodeIdentifier* _tmp32_;
		ValaCCodeIdentifier* _tmp33_;
		ValaCCodeFunctionCall* _tmp34_;
		ValaCCodeIdentifier* _tmp35_;
		ValaCCodeIdentifier* _tmp36_;
		ValaCCodeFunction* _tmp37_;
		ValaCCodeFunction* _tmp38_;
		ValaCCodeFunctionCall* _tmp39_;
		_tmp27_ = vala_ccode_identifier_new ("g_boxed_copy");
		_tmp28_ = _tmp27_;
		_tmp29_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp28_);
		_tmp30_ = _tmp29_;
		_vala_ccode_node_unref0 (_tmp28_);
		dup_call = _tmp30_;
		_tmp31_ = dup_call;
		_tmp32_ = vala_ccode_identifier_new ("G_TYPE_VALUE");
		_tmp33_ = _tmp32_;
		vala_ccode_function_call_add_argument (_tmp31_, (ValaCCodeExpression*) _tmp33_);
		_vala_ccode_node_unref0 (_tmp33_);
		_tmp34_ = dup_call;
		_tmp35_ = vala_ccode_identifier_new ("self");
		_tmp36_ = _tmp35_;
		vala_ccode_function_call_add_argument (_tmp34_, (ValaCCodeExpression*) _tmp36_);
		_vala_ccode_node_unref0 (_tmp36_);
		_tmp37_ = vala_ccode_base_module_get_ccode (self);
		_tmp38_ = _tmp37_;
		_tmp39_ = dup_call;
		vala_ccode_function_add_return (_tmp38_, (ValaCCodeExpression*) _tmp39_);
		_vala_ccode_node_unref0 (dup_call);
	} else {
		ValaCCodeFunction* _tmp40_;
		ValaCCodeFunction* _tmp41_;
		ValaValueType* _tmp42_;
		gchar* _tmp43_;
		gchar* _tmp44_;
		ValaCCodeVariableDeclarator* _tmp45_;
		ValaCCodeVariableDeclarator* _tmp46_;
		ValaCCodeFunctionCall* creation_call = NULL;
		ValaCCodeIdentifier* _tmp47_;
		ValaCCodeIdentifier* _tmp48_;
		ValaCCodeFunctionCall* _tmp49_;
		ValaCCodeFunctionCall* _tmp50_;
		ValaCCodeFunctionCall* _tmp51_;
		ValaValueType* _tmp52_;
		ValaTypeSymbol* _tmp53_;
		ValaTypeSymbol* _tmp54_;
		gchar* _tmp55_;
		gchar* _tmp56_;
		ValaCCodeConstant* _tmp57_;
		ValaCCodeConstant* _tmp58_;
		ValaCCodeFunctionCall* _tmp59_;
		ValaCCodeConstant* _tmp60_;
		ValaCCodeConstant* _tmp61_;
		ValaCCodeFunction* _tmp62_;
		ValaCCodeFunction* _tmp63_;
		ValaCCodeIdentifier* _tmp64_;
		ValaCCodeIdentifier* _tmp65_;
		ValaCCodeFunctionCall* _tmp66_;
		ValaStruct* st = NULL;
		ValaValueType* _tmp67_;
		ValaTypeSymbol* _tmp68_;
		ValaTypeSymbol* _tmp69_;
		ValaStruct* _tmp70_;
		gboolean _tmp71_ = FALSE;
		ValaStruct* _tmp72_;
		ValaCCodeFunction* _tmp122_;
		ValaCCodeFunction* _tmp123_;
		ValaCCodeIdentifier* _tmp124_;
		ValaCCodeIdentifier* _tmp125_;
		_tmp40_ = vala_ccode_base_module_get_ccode (self);
		_tmp41_ = _tmp40_;
		_tmp42_ = value_type;
		_tmp43_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp42_);
		_tmp44_ = _tmp43_;
		_tmp45_ = vala_ccode_variable_declarator_new ("dup", NULL, NULL);
		_tmp46_ = _tmp45_;
		vala_ccode_function_add_declaration (_tmp41_, _tmp44_, (ValaCCodeDeclarator*) _tmp46_, 0);
		_vala_ccode_node_unref0 (_tmp46_);
		_g_free0 (_tmp44_);
		_tmp47_ = vala_ccode_identifier_new ("g_new0");
		_tmp48_ = _tmp47_;
		_tmp49_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp48_);
		_tmp50_ = _tmp49_;
		_vala_ccode_node_unref0 (_tmp48_);
		creation_call = _tmp50_;
		_tmp51_ = creation_call;
		_tmp52_ = value_type;
		_tmp53_ = vala_data_type_get_data_type ((ValaDataType*) _tmp52_);
		_tmp54_ = _tmp53_;
		_tmp55_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp54_);
		_tmp56_ = _tmp55_;
		_tmp57_ = vala_ccode_constant_new (_tmp56_);
		_tmp58_ = _tmp57_;
		vala_ccode_function_call_add_argument (_tmp51_, (ValaCCodeExpression*) _tmp58_);
		_vala_ccode_node_unref0 (_tmp58_);
		_g_free0 (_tmp56_);
		_tmp59_ = creation_call;
		_tmp60_ = vala_ccode_constant_new ("1");
		_tmp61_ = _tmp60_;
		vala_ccode_function_call_add_argument (_tmp59_, (ValaCCodeExpression*) _tmp61_);
		_vala_ccode_node_unref0 (_tmp61_);
		_tmp62_ = vala_ccode_base_module_get_ccode (self);
		_tmp63_ = _tmp62_;
		_tmp64_ = vala_ccode_identifier_new ("dup");
		_tmp65_ = _tmp64_;
		_tmp66_ = creation_call;
		vala_ccode_function_add_assignment (_tmp63_, (ValaCCodeExpression*) _tmp65_, (ValaCCodeExpression*) _tmp66_);
		_vala_ccode_node_unref0 (_tmp65_);
		_tmp67_ = value_type;
		_tmp68_ = vala_data_type_get_data_type ((ValaDataType*) _tmp67_);
		_tmp69_ = _tmp68_;
		_tmp70_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp69_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp69_) : NULL);
		st = _tmp70_;
		_tmp72_ = st;
		if (_tmp72_ != NULL) {
			ValaStruct* _tmp73_;
			gboolean _tmp74_;
			_tmp73_ = st;
			_tmp74_ = vala_struct_is_disposable (_tmp73_);
			_tmp71_ = _tmp74_;
		} else {
			_tmp71_ = FALSE;
		}
		if (_tmp71_) {
			ValaStruct* _tmp75_;
			gboolean _tmp76_;
			ValaCCodeFunctionCall* copy_call = NULL;
			ValaStruct* _tmp78_;
			gchar* _tmp79_;
			gchar* _tmp80_;
			ValaCCodeIdentifier* _tmp81_;
			ValaCCodeIdentifier* _tmp82_;
			ValaCCodeFunctionCall* _tmp83_;
			ValaCCodeFunctionCall* _tmp84_;
			ValaCCodeFunctionCall* _tmp85_;
			ValaCCodeIdentifier* _tmp86_;
			ValaCCodeIdentifier* _tmp87_;
			ValaCCodeFunctionCall* _tmp88_;
			ValaCCodeIdentifier* _tmp89_;
			ValaCCodeIdentifier* _tmp90_;
			ValaCCodeFunction* _tmp91_;
			ValaCCodeFunction* _tmp92_;
			ValaCCodeFunctionCall* _tmp93_;
			_tmp75_ = st;
			_tmp76_ = vala_ccode_base_module_get_ccode_has_copy_function (_tmp75_);
			if (!_tmp76_) {
				ValaStruct* _tmp77_;
				_tmp77_ = st;
				vala_ccode_base_module_generate_struct_copy_function (self, _tmp77_);
			}
			_tmp78_ = st;
			_tmp79_ = vala_ccode_base_module_get_ccode_copy_function ((ValaTypeSymbol*) _tmp78_);
			_tmp80_ = _tmp79_;
			_tmp81_ = vala_ccode_identifier_new (_tmp80_);
			_tmp82_ = _tmp81_;
			_tmp83_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp82_);
			_tmp84_ = _tmp83_;
			_vala_ccode_node_unref0 (_tmp82_);
			_g_free0 (_tmp80_);
			copy_call = _tmp84_;
			_tmp85_ = copy_call;
			_tmp86_ = vala_ccode_identifier_new ("self");
			_tmp87_ = _tmp86_;
			vala_ccode_function_call_add_argument (_tmp85_, (ValaCCodeExpression*) _tmp87_);
			_vala_ccode_node_unref0 (_tmp87_);
			_tmp88_ = copy_call;
			_tmp89_ = vala_ccode_identifier_new ("dup");
			_tmp90_ = _tmp89_;
			vala_ccode_function_call_add_argument (_tmp88_, (ValaCCodeExpression*) _tmp90_);
			_vala_ccode_node_unref0 (_tmp90_);
			_tmp91_ = vala_ccode_base_module_get_ccode (self);
			_tmp92_ = _tmp91_;
			_tmp93_ = copy_call;
			vala_ccode_function_add_expression (_tmp92_, (ValaCCodeExpression*) _tmp93_);
			_vala_ccode_node_unref0 (copy_call);
		} else {
			ValaCCodeFile* _tmp94_;
			ValaCCodeFunctionCall* sizeof_call = NULL;
			ValaCCodeIdentifier* _tmp95_;
			ValaCCodeIdentifier* _tmp96_;
			ValaCCodeFunctionCall* _tmp97_;
			ValaCCodeFunctionCall* _tmp98_;
			ValaCCodeFunctionCall* _tmp99_;
			ValaValueType* _tmp100_;
			ValaTypeSymbol* _tmp101_;
			ValaTypeSymbol* _tmp102_;
			gchar* _tmp103_;
			gchar* _tmp104_;
			ValaCCodeConstant* _tmp105_;
			ValaCCodeConstant* _tmp106_;
			ValaCCodeFunctionCall* copy_call = NULL;
			ValaCCodeIdentifier* _tmp107_;
			ValaCCodeIdentifier* _tmp108_;
			ValaCCodeFunctionCall* _tmp109_;
			ValaCCodeFunctionCall* _tmp110_;
			ValaCCodeFunctionCall* _tmp111_;
			ValaCCodeIdentifier* _tmp112_;
			ValaCCodeIdentifier* _tmp113_;
			ValaCCodeFunctionCall* _tmp114_;
			ValaCCodeIdentifier* _tmp115_;
			ValaCCodeIdentifier* _tmp116_;
			ValaCCodeFunctionCall* _tmp117_;
			ValaCCodeFunctionCall* _tmp118_;
			ValaCCodeFunction* _tmp119_;
			ValaCCodeFunction* _tmp120_;
			ValaCCodeFunctionCall* _tmp121_;
			_tmp94_ = self->cfile;
			vala_ccode_file_add_include (_tmp94_, "string.h", FALSE);
			_tmp95_ = vala_ccode_identifier_new ("sizeof");
			_tmp96_ = _tmp95_;
			_tmp97_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp96_);
			_tmp98_ = _tmp97_;
			_vala_ccode_node_unref0 (_tmp96_);
			sizeof_call = _tmp98_;
			_tmp99_ = sizeof_call;
			_tmp100_ = value_type;
			_tmp101_ = vala_data_type_get_data_type ((ValaDataType*) _tmp100_);
			_tmp102_ = _tmp101_;
			_tmp103_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp102_);
			_tmp104_ = _tmp103_;
			_tmp105_ = vala_ccode_constant_new (_tmp104_);
			_tmp106_ = _tmp105_;
			vala_ccode_function_call_add_argument (_tmp99_, (ValaCCodeExpression*) _tmp106_);
			_vala_ccode_node_unref0 (_tmp106_);
			_g_free0 (_tmp104_);
			_tmp107_ = vala_ccode_identifier_new ("memcpy");
			_tmp108_ = _tmp107_;
			_tmp109_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp108_);
			_tmp110_ = _tmp109_;
			_vala_ccode_node_unref0 (_tmp108_);
			copy_call = _tmp110_;
			_tmp111_ = copy_call;
			_tmp112_ = vala_ccode_identifier_new ("dup");
			_tmp113_ = _tmp112_;
			vala_ccode_function_call_add_argument (_tmp111_, (ValaCCodeExpression*) _tmp113_);
			_vala_ccode_node_unref0 (_tmp113_);
			_tmp114_ = copy_call;
			_tmp115_ = vala_ccode_identifier_new ("self");
			_tmp116_ = _tmp115_;
			vala_ccode_function_call_add_argument (_tmp114_, (ValaCCodeExpression*) _tmp116_);
			_vala_ccode_node_unref0 (_tmp116_);
			_tmp117_ = copy_call;
			_tmp118_ = sizeof_call;
			vala_ccode_function_call_add_argument (_tmp117_, (ValaCCodeExpression*) _tmp118_);
			_tmp119_ = vala_ccode_base_module_get_ccode (self);
			_tmp120_ = _tmp119_;
			_tmp121_ = copy_call;
			vala_ccode_function_add_expression (_tmp120_, (ValaCCodeExpression*) _tmp121_);
			_vala_ccode_node_unref0 (copy_call);
			_vala_ccode_node_unref0 (sizeof_call);
		}
		_tmp122_ = vala_ccode_base_module_get_ccode (self);
		_tmp123_ = _tmp122_;
		_tmp124_ = vala_ccode_identifier_new ("dup");
		_tmp125_ = _tmp124_;
		vala_ccode_function_add_return (_tmp123_, (ValaCCodeExpression*) _tmp125_);
		_vala_ccode_node_unref0 (_tmp125_);
		_vala_code_node_unref0 (st);
		_vala_ccode_node_unref0 (creation_call);
	}
	vala_ccode_base_module_pop_function (self);
	_tmp126_ = self->cfile;
	_tmp127_ = function;
	vala_ccode_file_add_function_declaration (_tmp126_, _tmp127_);
	_tmp128_ = self->cfile;
	_tmp129_ = function;
	vala_ccode_file_add_function (_tmp128_, _tmp129_);
	result = dup_func;
	_vala_ccode_node_unref0 (function);
	return result;
}


gchar* vala_ccode_base_module_generate_dup_func_wrapper (ValaCCodeBaseModule* self, ValaDataType* type) {
	gchar* result = NULL;
	gchar* destroy_func = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	const gchar* _tmp7_;
	gboolean _tmp8_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp9_;
	ValaDataType* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	ValaCCodeFunction* _tmp13_;
	ValaCCodeFunction* _tmp14_;
	ValaCCodeFunction* _tmp15_;
	ValaCCodeFunction* _tmp16_;
	ValaDataType* _tmp17_;
	gchar* _tmp18_;
	gchar* _tmp19_;
	ValaCCodeParameter* _tmp20_;
	ValaCCodeParameter* _tmp21_;
	ValaCCodeFunction* _tmp22_;
	ValaClass* cl = NULL;
	ValaDataType* _tmp23_;
	ValaTypeSymbol* _tmp24_;
	ValaTypeSymbol* _tmp25_;
	ValaClass* _tmp26_;
	gboolean _tmp27_ = FALSE;
	ValaClass* _tmp28_;
	ValaCCodeFunctionCall* free_call = NULL;
	ValaCCodeIdentifier* _tmp31_;
	ValaCCodeIdentifier* _tmp32_;
	ValaCCodeFunctionCall* _tmp33_;
	ValaCCodeFunctionCall* _tmp34_;
	ValaCCodeFunctionCall* _tmp35_;
	ValaClass* _tmp36_;
	gchar* _tmp37_;
	gchar* _tmp38_;
	ValaCCodeIdentifier* _tmp39_;
	ValaCCodeIdentifier* _tmp40_;
	ValaCCodeFunctionCall* _tmp41_;
	ValaCCodeIdentifier* _tmp42_;
	ValaCCodeIdentifier* _tmp43_;
	ValaCCodeFunction* _tmp44_;
	ValaCCodeFunction* _tmp45_;
	ValaCCodeFunctionCall* _tmp46_;
	ValaCCodeFile* _tmp47_;
	ValaCCodeFunction* _tmp48_;
	ValaCCodeFile* _tmp49_;
	ValaCCodeFunction* _tmp50_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup_printf ("_vala_%s_copy", _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	destroy_func = _tmp6_;
	_tmp7_ = destroy_func;
	_tmp8_ = vala_ccode_base_module_add_wrapper (self, _tmp7_);
	if (!_tmp8_) {
		result = destroy_func;
		return result;
	}
	_tmp9_ = destroy_func;
	_tmp10_ = type;
	_tmp11_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp10_);
	_tmp12_ = _tmp11_;
	_tmp13_ = vala_ccode_function_new (_tmp9_, _tmp12_);
	_tmp14_ = _tmp13_;
	_g_free0 (_tmp12_);
	function = _tmp14_;
	_tmp15_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp15_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp16_ = function;
	_tmp17_ = type;
	_tmp18_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = vala_ccode_parameter_new ("self", _tmp19_);
	_tmp21_ = _tmp20_;
	vala_ccode_function_add_parameter (_tmp16_, _tmp21_);
	_vala_ccode_node_unref0 (_tmp21_);
	_g_free0 (_tmp19_);
	_tmp22_ = function;
	vala_ccode_base_module_push_function (self, _tmp22_);
	_tmp23_ = type;
	_tmp24_ = vala_data_type_get_data_type (_tmp23_);
	_tmp25_ = _tmp24_;
	_tmp26_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp25_) : NULL);
	cl = _tmp26_;
	_tmp28_ = cl;
	if (_tmp28_ != NULL) {
		ValaClass* _tmp29_;
		gboolean _tmp30_;
		_tmp29_ = cl;
		_tmp30_ = vala_ccode_base_module_get_ccode_is_gboxed ((ValaTypeSymbol*) _tmp29_);
		_tmp27_ = _tmp30_;
	} else {
		_tmp27_ = FALSE;
	}
	_vala_assert (_tmp27_, "cl != null && get_ccode_is_gboxed (cl)");
	_tmp31_ = vala_ccode_identifier_new ("g_boxed_copy");
	_tmp32_ = _tmp31_;
	_tmp33_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp32_);
	_tmp34_ = _tmp33_;
	_vala_ccode_node_unref0 (_tmp32_);
	free_call = _tmp34_;
	_tmp35_ = free_call;
	_tmp36_ = cl;
	_tmp37_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp36_);
	_tmp38_ = _tmp37_;
	_tmp39_ = vala_ccode_identifier_new (_tmp38_);
	_tmp40_ = _tmp39_;
	vala_ccode_function_call_add_argument (_tmp35_, (ValaCCodeExpression*) _tmp40_);
	_vala_ccode_node_unref0 (_tmp40_);
	_g_free0 (_tmp38_);
	_tmp41_ = free_call;
	_tmp42_ = vala_ccode_identifier_new ("self");
	_tmp43_ = _tmp42_;
	vala_ccode_function_call_add_argument (_tmp41_, (ValaCCodeExpression*) _tmp43_);
	_vala_ccode_node_unref0 (_tmp43_);
	_tmp44_ = vala_ccode_base_module_get_ccode (self);
	_tmp45_ = _tmp44_;
	_tmp46_ = free_call;
	vala_ccode_function_add_return (_tmp45_, (ValaCCodeExpression*) _tmp46_);
	vala_ccode_base_module_pop_function (self);
	_tmp47_ = self->cfile;
	_tmp48_ = function;
	vala_ccode_file_add_function_declaration (_tmp47_, _tmp48_);
	_tmp49_ = self->cfile;
	_tmp50_ = function;
	vala_ccode_file_add_function (_tmp49_, _tmp50_);
	result = destroy_func;
	_vala_ccode_node_unref0 (free_call);
	_vala_code_node_unref0 (cl);
	_vala_ccode_node_unref0 (function);
	return result;
}


gchar* vala_ccode_base_module_generate_free_function_address_of_wrapper (ValaCCodeBaseModule* self, ValaDataType* type) {
	gchar* result = NULL;
	gchar* destroy_func = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	const gchar* _tmp7_;
	gboolean _tmp8_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	ValaCCodeFunction* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaDataType* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
	ValaCCodeParameter* _tmp16_;
	ValaCCodeParameter* _tmp17_;
	ValaCCodeFunction* _tmp18_;
	ValaClass* cl = NULL;
	ValaDataType* _tmp19_;
	ValaTypeSymbol* _tmp20_;
	ValaTypeSymbol* _tmp21_;
	ValaClass* _tmp22_;
	ValaCCodeFunctionCall* free_call = NULL;
	ValaClass* _tmp23_;
	gchar* _tmp24_;
	gchar* _tmp25_;
	ValaCCodeIdentifier* _tmp26_;
	ValaCCodeIdentifier* _tmp27_;
	ValaCCodeFunctionCall* _tmp28_;
	ValaCCodeFunctionCall* _tmp29_;
	ValaCCodeFunctionCall* _tmp30_;
	ValaCCodeIdentifier* _tmp31_;
	ValaCCodeIdentifier* _tmp32_;
	ValaCCodeUnaryExpression* _tmp33_;
	ValaCCodeUnaryExpression* _tmp34_;
	ValaCCodeFunction* _tmp35_;
	ValaCCodeFunction* _tmp36_;
	ValaCCodeFunctionCall* _tmp37_;
	ValaCCodeFile* _tmp38_;
	ValaCCodeFunction* _tmp39_;
	ValaCCodeFile* _tmp40_;
	ValaCCodeFunction* _tmp41_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup_printf ("_vala_%s_free_function_address_of", _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	destroy_func = _tmp6_;
	_tmp7_ = destroy_func;
	_tmp8_ = vala_ccode_base_module_add_wrapper (self, _tmp7_);
	if (!_tmp8_) {
		result = destroy_func;
		return result;
	}
	_tmp9_ = destroy_func;
	_tmp10_ = vala_ccode_function_new (_tmp9_, "void");
	function = _tmp10_;
	_tmp11_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp11_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp12_ = function;
	_tmp13_ = type;
	_tmp14_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = vala_ccode_parameter_new ("self", _tmp15_);
	_tmp17_ = _tmp16_;
	vala_ccode_function_add_parameter (_tmp12_, _tmp17_);
	_vala_ccode_node_unref0 (_tmp17_);
	_g_free0 (_tmp15_);
	_tmp18_ = function;
	vala_ccode_base_module_push_function (self, _tmp18_);
	_tmp19_ = type;
	_tmp20_ = vala_data_type_get_data_type (_tmp19_);
	_tmp21_ = _tmp20_;
	_tmp22_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp21_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp21_) : NULL);
	cl = _tmp22_;
	_tmp23_ = cl;
	_tmp24_ = vala_ccode_base_module_get_ccode_free_function ((ValaTypeSymbol*) _tmp23_);
	_tmp25_ = _tmp24_;
	_tmp26_ = vala_ccode_identifier_new (_tmp25_);
	_tmp27_ = _tmp26_;
	_tmp28_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp27_);
	_tmp29_ = _tmp28_;
	_vala_ccode_node_unref0 (_tmp27_);
	_g_free0 (_tmp25_);
	free_call = _tmp29_;
	_tmp30_ = free_call;
	_tmp31_ = vala_ccode_identifier_new ("self");
	_tmp32_ = _tmp31_;
	_tmp33_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp32_);
	_tmp34_ = _tmp33_;
	vala_ccode_function_call_add_argument (_tmp30_, (ValaCCodeExpression*) _tmp34_);
	_vala_ccode_node_unref0 (_tmp34_);
	_vala_ccode_node_unref0 (_tmp32_);
	_tmp35_ = vala_ccode_base_module_get_ccode (self);
	_tmp36_ = _tmp35_;
	_tmp37_ = free_call;
	vala_ccode_function_add_expression (_tmp36_, (ValaCCodeExpression*) _tmp37_);
	vala_ccode_base_module_pop_function (self);
	_tmp38_ = self->cfile;
	_tmp39_ = function;
	vala_ccode_file_add_function_declaration (_tmp38_, _tmp39_);
	_tmp40_ = self->cfile;
	_tmp41_ = function;
	vala_ccode_file_add_function (_tmp40_, _tmp41_);
	result = destroy_func;
	_vala_ccode_node_unref0 (free_call);
	_vala_code_node_unref0 (cl);
	_vala_ccode_node_unref0 (function);
	return result;
}


gchar* vala_ccode_base_module_generate_free_func_wrapper (ValaCCodeBaseModule* self, ValaDataType* type) {
	gchar* result = NULL;
	gchar* destroy_func = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	const gchar* _tmp7_;
	gboolean _tmp8_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	ValaCCodeFunction* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaDataType* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
	ValaCCodeParameter* _tmp16_;
	ValaCCodeParameter* _tmp17_;
	ValaCCodeFunction* _tmp18_;
	ValaClass* cl = NULL;
	ValaDataType* _tmp19_;
	ValaTypeSymbol* _tmp20_;
	ValaTypeSymbol* _tmp21_;
	ValaClass* _tmp22_;
	gboolean _tmp23_ = FALSE;
	ValaClass* _tmp24_;
	ValaCCodeFile* _tmp77_;
	ValaCCodeFunction* _tmp78_;
	ValaCCodeFile* _tmp79_;
	ValaCCodeFunction* _tmp80_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup_printf ("_vala_%s_free", _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	destroy_func = _tmp6_;
	_tmp7_ = destroy_func;
	_tmp8_ = vala_ccode_base_module_add_wrapper (self, _tmp7_);
	if (!_tmp8_) {
		result = destroy_func;
		return result;
	}
	_tmp9_ = destroy_func;
	_tmp10_ = vala_ccode_function_new (_tmp9_, "void");
	function = _tmp10_;
	_tmp11_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp11_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp12_ = function;
	_tmp13_ = type;
	_tmp14_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = vala_ccode_parameter_new ("self", _tmp15_);
	_tmp17_ = _tmp16_;
	vala_ccode_function_add_parameter (_tmp12_, _tmp17_);
	_vala_ccode_node_unref0 (_tmp17_);
	_g_free0 (_tmp15_);
	_tmp18_ = function;
	vala_ccode_base_module_push_function (self, _tmp18_);
	_tmp19_ = type;
	_tmp20_ = vala_data_type_get_data_type (_tmp19_);
	_tmp21_ = _tmp20_;
	_tmp22_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp21_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp21_) : NULL);
	cl = _tmp22_;
	_tmp24_ = cl;
	if (_tmp24_ != NULL) {
		ValaClass* _tmp25_;
		gboolean _tmp26_;
		_tmp25_ = cl;
		_tmp26_ = vala_ccode_base_module_get_ccode_is_gboxed ((ValaTypeSymbol*) _tmp25_);
		_tmp23_ = _tmp26_;
	} else {
		_tmp23_ = FALSE;
	}
	if (_tmp23_) {
		ValaCCodeFunctionCall* free_call = NULL;
		ValaCCodeIdentifier* _tmp27_;
		ValaCCodeIdentifier* _tmp28_;
		ValaCCodeFunctionCall* _tmp29_;
		ValaCCodeFunctionCall* _tmp30_;
		ValaCCodeFunctionCall* _tmp31_;
		ValaClass* _tmp32_;
		gchar* _tmp33_;
		gchar* _tmp34_;
		ValaCCodeIdentifier* _tmp35_;
		ValaCCodeIdentifier* _tmp36_;
		ValaCCodeFunctionCall* _tmp37_;
		ValaCCodeIdentifier* _tmp38_;
		ValaCCodeIdentifier* _tmp39_;
		ValaCCodeFunction* _tmp40_;
		ValaCCodeFunction* _tmp41_;
		ValaCCodeFunctionCall* _tmp42_;
		_tmp27_ = vala_ccode_identifier_new ("g_boxed_free");
		_tmp28_ = _tmp27_;
		_tmp29_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp28_);
		_tmp30_ = _tmp29_;
		_vala_ccode_node_unref0 (_tmp28_);
		free_call = _tmp30_;
		_tmp31_ = free_call;
		_tmp32_ = cl;
		_tmp33_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp32_);
		_tmp34_ = _tmp33_;
		_tmp35_ = vala_ccode_identifier_new (_tmp34_);
		_tmp36_ = _tmp35_;
		vala_ccode_function_call_add_argument (_tmp31_, (ValaCCodeExpression*) _tmp36_);
		_vala_ccode_node_unref0 (_tmp36_);
		_g_free0 (_tmp34_);
		_tmp37_ = free_call;
		_tmp38_ = vala_ccode_identifier_new ("self");
		_tmp39_ = _tmp38_;
		vala_ccode_function_call_add_argument (_tmp37_, (ValaCCodeExpression*) _tmp39_);
		_vala_ccode_node_unref0 (_tmp39_);
		_tmp40_ = vala_ccode_base_module_get_ccode (self);
		_tmp41_ = _tmp40_;
		_tmp42_ = free_call;
		vala_ccode_function_add_expression (_tmp41_, (ValaCCodeExpression*) _tmp42_);
		_vala_ccode_node_unref0 (free_call);
	} else {
		ValaStruct* st = NULL;
		ValaDataType* _tmp43_;
		ValaTypeSymbol* _tmp44_;
		ValaTypeSymbol* _tmp45_;
		ValaStruct* _tmp46_;
		gboolean _tmp47_ = FALSE;
		ValaStruct* _tmp48_;
		ValaCCodeFunctionCall* free_call = NULL;
		ValaCCodeIdentifier* _tmp67_;
		ValaCCodeIdentifier* _tmp68_;
		ValaCCodeFunctionCall* _tmp69_;
		ValaCCodeFunctionCall* _tmp70_;
		ValaCCodeFunctionCall* _tmp71_;
		ValaCCodeIdentifier* _tmp72_;
		ValaCCodeIdentifier* _tmp73_;
		ValaCCodeFunction* _tmp74_;
		ValaCCodeFunction* _tmp75_;
		ValaCCodeFunctionCall* _tmp76_;
		_tmp43_ = type;
		_tmp44_ = vala_data_type_get_data_type (_tmp43_);
		_tmp45_ = _tmp44_;
		_tmp46_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp45_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp45_) : NULL);
		st = _tmp46_;
		_tmp48_ = st;
		if (_tmp48_ != NULL) {
			ValaStruct* _tmp49_;
			gboolean _tmp50_;
			_tmp49_ = st;
			_tmp50_ = vala_struct_is_disposable (_tmp49_);
			_tmp47_ = _tmp50_;
		} else {
			_tmp47_ = FALSE;
		}
		if (_tmp47_) {
			ValaStruct* _tmp51_;
			gboolean _tmp52_;
			ValaCCodeFunctionCall* destroy_call = NULL;
			ValaStruct* _tmp54_;
			gchar* _tmp55_;
			gchar* _tmp56_;
			ValaCCodeIdentifier* _tmp57_;
			ValaCCodeIdentifier* _tmp58_;
			ValaCCodeFunctionCall* _tmp59_;
			ValaCCodeFunctionCall* _tmp60_;
			ValaCCodeFunctionCall* _tmp61_;
			ValaCCodeIdentifier* _tmp62_;
			ValaCCodeIdentifier* _tmp63_;
			ValaCCodeFunction* _tmp64_;
			ValaCCodeFunction* _tmp65_;
			ValaCCodeFunctionCall* _tmp66_;
			_tmp51_ = st;
			_tmp52_ = vala_ccode_base_module_get_ccode_has_destroy_function (_tmp51_);
			if (!_tmp52_) {
				ValaStruct* _tmp53_;
				_tmp53_ = st;
				vala_ccode_base_module_generate_struct_destroy_function (self, _tmp53_);
			}
			_tmp54_ = st;
			_tmp55_ = vala_ccode_base_module_get_ccode_destroy_function ((ValaTypeSymbol*) _tmp54_);
			_tmp56_ = _tmp55_;
			_tmp57_ = vala_ccode_identifier_new (_tmp56_);
			_tmp58_ = _tmp57_;
			_tmp59_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp58_);
			_tmp60_ = _tmp59_;
			_vala_ccode_node_unref0 (_tmp58_);
			_g_free0 (_tmp56_);
			destroy_call = _tmp60_;
			_tmp61_ = destroy_call;
			_tmp62_ = vala_ccode_identifier_new ("self");
			_tmp63_ = _tmp62_;
			vala_ccode_function_call_add_argument (_tmp61_, (ValaCCodeExpression*) _tmp63_);
			_vala_ccode_node_unref0 (_tmp63_);
			_tmp64_ = vala_ccode_base_module_get_ccode (self);
			_tmp65_ = _tmp64_;
			_tmp66_ = destroy_call;
			vala_ccode_function_add_expression (_tmp65_, (ValaCCodeExpression*) _tmp66_);
			_vala_ccode_node_unref0 (destroy_call);
		}
		_tmp67_ = vala_ccode_identifier_new ("g_free");
		_tmp68_ = _tmp67_;
		_tmp69_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp68_);
		_tmp70_ = _tmp69_;
		_vala_ccode_node_unref0 (_tmp68_);
		free_call = _tmp70_;
		_tmp71_ = free_call;
		_tmp72_ = vala_ccode_identifier_new ("self");
		_tmp73_ = _tmp72_;
		vala_ccode_function_call_add_argument (_tmp71_, (ValaCCodeExpression*) _tmp73_);
		_vala_ccode_node_unref0 (_tmp73_);
		_tmp74_ = vala_ccode_base_module_get_ccode (self);
		_tmp75_ = _tmp74_;
		_tmp76_ = free_call;
		vala_ccode_function_add_expression (_tmp75_, (ValaCCodeExpression*) _tmp76_);
		_vala_ccode_node_unref0 (free_call);
		_vala_code_node_unref0 (st);
	}
	vala_ccode_base_module_pop_function (self);
	_tmp77_ = self->cfile;
	_tmp78_ = function;
	vala_ccode_file_add_function_declaration (_tmp77_, _tmp78_);
	_tmp79_ = self->cfile;
	_tmp80_ = function;
	vala_ccode_file_add_function (_tmp79_, _tmp80_);
	result = destroy_func;
	_vala_code_node_unref0 (cl);
	_vala_ccode_node_unref0 (function);
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_destroy0_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeExpression* element_destroy_func_expression = NULL;
	ValaDataType* _tmp0_;
	gboolean _tmp1_;
	ValaCCodeExpression* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	_tmp1_ = is_chainup;
	_tmp2_ = vala_ccode_base_module_get_destroy_func_expression (self, _tmp0_, _tmp1_);
	element_destroy_func_expression = _tmp2_;
	_tmp3_ = element_destroy_func_expression;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_CCODE_IDENTIFIER)) {
		ValaCCodeIdentifier* freeid = NULL;
		ValaCCodeExpression* _tmp4_;
		ValaCCodeIdentifier* _tmp5_;
		gchar* free0_func = NULL;
		ValaCCodeIdentifier* _tmp6_;
		const gchar* _tmp7_;
		const gchar* _tmp8_;
		gchar* _tmp9_;
		const gchar* _tmp10_;
		gboolean _tmp11_;
		const gchar* _tmp32_;
		ValaCCodeIdentifier* _tmp33_;
		_tmp4_ = element_destroy_func_expression;
		_tmp5_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_CCODE_IDENTIFIER, ValaCCodeIdentifier));
		freeid = _tmp5_;
		_tmp6_ = freeid;
		_tmp7_ = vala_ccode_identifier_get_name (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = g_strdup_printf ("_%s0_", _tmp8_);
		free0_func = _tmp9_;
		_tmp10_ = free0_func;
		_tmp11_ = vala_ccode_base_module_add_wrapper (self, _tmp10_);
		if (_tmp11_) {
			ValaCCodeFunction* function = NULL;
			const gchar* _tmp12_;
			ValaCCodeFunction* _tmp13_;
			ValaCCodeFunction* _tmp14_;
			ValaCCodeFunction* _tmp15_;
			ValaCCodeParameter* _tmp16_;
			ValaCCodeParameter* _tmp17_;
			ValaCCodeFunction* _tmp18_;
			ValaCCodeFunction* _tmp19_;
			ValaCCodeFunction* _tmp20_;
			ValaDataType* _tmp21_;
			ValaCCodeIdentifier* _tmp22_;
			ValaCCodeIdentifier* _tmp23_;
			ValaGLibValue* _tmp24_;
			ValaGLibValue* _tmp25_;
			ValaCCodeExpression* _tmp26_;
			ValaCCodeExpression* _tmp27_;
			ValaCCodeFile* _tmp28_;
			ValaCCodeFunction* _tmp29_;
			ValaCCodeFile* _tmp30_;
			ValaCCodeFunction* _tmp31_;
			_tmp12_ = free0_func;
			_tmp13_ = vala_ccode_function_new (_tmp12_, "void");
			function = _tmp13_;
			_tmp14_ = function;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp14_, VALA_CCODE_MODIFIERS_STATIC);
			_tmp15_ = function;
			_tmp16_ = vala_ccode_parameter_new ("var", "gpointer");
			_tmp17_ = _tmp16_;
			vala_ccode_function_add_parameter (_tmp15_, _tmp17_);
			_vala_ccode_node_unref0 (_tmp17_);
			_tmp18_ = function;
			vala_ccode_base_module_push_function (self, _tmp18_);
			_tmp19_ = vala_ccode_base_module_get_ccode (self);
			_tmp20_ = _tmp19_;
			_tmp21_ = type;
			_tmp22_ = vala_ccode_identifier_new ("var");
			_tmp23_ = _tmp22_;
			_tmp24_ = vala_glib_value_new (_tmp21_, (ValaCCodeExpression*) _tmp23_, TRUE);
			_tmp25_ = _tmp24_;
			_tmp26_ = vala_ccode_base_module_destroy_value (self, (ValaTargetValue*) _tmp25_, TRUE);
			_tmp27_ = _tmp26_;
			vala_ccode_function_add_expression (_tmp20_, _tmp27_);
			_vala_ccode_node_unref0 (_tmp27_);
			_vala_target_value_unref0 (_tmp25_);
			_vala_ccode_node_unref0 (_tmp23_);
			vala_ccode_base_module_pop_function (self);
			_tmp28_ = self->cfile;
			_tmp29_ = function;
			vala_ccode_file_add_function_declaration (_tmp28_, _tmp29_);
			_tmp30_ = self->cfile;
			_tmp31_ = function;
			vala_ccode_file_add_function (_tmp30_, _tmp31_);
			_vala_ccode_node_unref0 (function);
		}
		_tmp32_ = free0_func;
		_tmp33_ = vala_ccode_identifier_new (_tmp32_);
		_vala_ccode_node_unref0 (element_destroy_func_expression);
		element_destroy_func_expression = (ValaCCodeExpression*) _tmp33_;
		_g_free0 (free0_func);
		_vala_ccode_node_unref0 (freeid);
	}
	result = element_destroy_func_expression;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_destroy_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup) {
	ValaCCodeExpression* result = NULL;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp2_ = FALSE;
	ValaDataType* _tmp3_;
	ValaTypeSymbol* _tmp4_;
	ValaTypeSymbol* _tmp5_;
	ValaClass* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp3_ = type;
	_tmp4_ = vala_data_type_get_data_type (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = self->glist_type;
	if (_tmp5_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) {
		_tmp2_ = TRUE;
	} else {
		ValaDataType* _tmp7_;
		ValaTypeSymbol* _tmp8_;
		ValaTypeSymbol* _tmp9_;
		ValaClass* _tmp10_;
		_tmp7_ = type;
		_tmp8_ = vala_data_type_get_data_type (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = self->gslist_type;
		_tmp2_ = _tmp9_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp10_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	}
	if (_tmp2_) {
		_tmp1_ = TRUE;
	} else {
		ValaDataType* _tmp11_;
		ValaTypeSymbol* _tmp12_;
		ValaTypeSymbol* _tmp13_;
		ValaClass* _tmp14_;
		_tmp11_ = type;
		_tmp12_ = vala_data_type_get_data_type (_tmp11_);
		_tmp13_ = _tmp12_;
		_tmp14_ = self->gnode_type;
		_tmp1_ = _tmp13_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	}
	if (_tmp1_) {
		_tmp0_ = TRUE;
	} else {
		ValaDataType* _tmp15_;
		ValaTypeSymbol* _tmp16_;
		ValaTypeSymbol* _tmp17_;
		ValaClass* _tmp18_;
		_tmp15_ = type;
		_tmp16_ = vala_data_type_get_data_type (_tmp15_);
		_tmp17_ = _tmp16_;
		_tmp18_ = self->gqueue_type;
		_tmp0_ = _tmp17_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp18_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	}
	if (_tmp0_) {
		gboolean elements_require_free = FALSE;
		ValaCCodeExpression* element_destroy_func_expression = NULL;
		gboolean _tmp35_ = FALSE;
		gboolean _tmp36_;
		elements_require_free = FALSE;
		element_destroy_func_expression = NULL;
		{
			ValaList* _type_arg_list = NULL;
			ValaDataType* _tmp19_;
			ValaList* _tmp20_;
			gint _type_arg_size = 0;
			ValaList* _tmp21_;
			gint _tmp22_;
			gint _tmp23_;
			gint _type_arg_index = 0;
			_tmp19_ = type;
			_tmp20_ = vala_data_type_get_type_arguments (_tmp19_);
			_type_arg_list = _tmp20_;
			_tmp21_ = _type_arg_list;
			_tmp22_ = vala_collection_get_size ((ValaCollection*) _tmp21_);
			_tmp23_ = _tmp22_;
			_type_arg_size = _tmp23_;
			_type_arg_index = -1;
			while (TRUE) {
				gint _tmp24_;
				gint _tmp25_;
				gint _tmp26_;
				ValaDataType* type_arg = NULL;
				ValaList* _tmp27_;
				gint _tmp28_;
				gpointer _tmp29_;
				ValaDataType* _tmp30_;
				gboolean _tmp31_;
				gboolean _tmp32_;
				_tmp24_ = _type_arg_index;
				_type_arg_index = _tmp24_ + 1;
				_tmp25_ = _type_arg_index;
				_tmp26_ = _type_arg_size;
				if (!(_tmp25_ < _tmp26_)) {
					break;
				}
				_tmp27_ = _type_arg_list;
				_tmp28_ = _type_arg_index;
				_tmp29_ = vala_list_get (_tmp27_, _tmp28_);
				type_arg = (ValaDataType*) _tmp29_;
				_tmp30_ = type_arg;
				_tmp31_ = vala_ccode_base_module_requires_destroy (self, _tmp30_);
				elements_require_free = _tmp31_;
				_tmp32_ = elements_require_free;
				if (_tmp32_) {
					ValaDataType* _tmp33_;
					ValaCCodeExpression* _tmp34_;
					_tmp33_ = type_arg;
					_tmp34_ = vala_ccode_base_module_get_destroy0_func_expression (self, _tmp33_, FALSE);
					_vala_ccode_node_unref0 (element_destroy_func_expression);
					element_destroy_func_expression = _tmp34_;
				}
				_vala_code_node_unref0 (type_arg);
			}
			_vala_iterable_unref0 (_type_arg_list);
		}
		_tmp36_ = elements_require_free;
		if (_tmp36_) {
			ValaCCodeExpression* _tmp37_;
			_tmp37_ = element_destroy_func_expression;
			_tmp35_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp37_, VALA_TYPE_CCODE_IDENTIFIER);
		} else {
			_tmp35_ = FALSE;
		}
		if (_tmp35_) {
			ValaDataType* _tmp38_;
			ValaCCodeExpression* _tmp39_;
			gchar* _tmp40_;
			gchar* _tmp41_;
			ValaCCodeIdentifier* _tmp42_;
			ValaCCodeExpression* _tmp43_;
			_tmp38_ = type;
			_tmp39_ = element_destroy_func_expression;
			_tmp40_ = vala_ccode_base_module_generate_collection_free_wrapper (self, _tmp38_, G_TYPE_CHECK_INSTANCE_CAST (_tmp39_, VALA_TYPE_CCODE_IDENTIFIER, ValaCCodeIdentifier));
			_tmp41_ = _tmp40_;
			_tmp42_ = vala_ccode_identifier_new (_tmp41_);
			_tmp43_ = (ValaCCodeExpression*) _tmp42_;
			_g_free0 (_tmp41_);
			result = _tmp43_;
			_vala_ccode_node_unref0 (element_destroy_func_expression);
			return result;
		} else {
			ValaDataType* _tmp44_;
			ValaTypeSymbol* _tmp45_;
			ValaTypeSymbol* _tmp46_;
			gchar* _tmp47_;
			gchar* _tmp48_;
			ValaCCodeIdentifier* _tmp49_;
			ValaCCodeExpression* _tmp50_;
			_tmp44_ = type;
			_tmp45_ = vala_data_type_get_data_type (_tmp44_);
			_tmp46_ = _tmp45_;
			_tmp47_ = vala_ccode_base_module_get_ccode_free_function (_tmp46_);
			_tmp48_ = _tmp47_;
			_tmp49_ = vala_ccode_identifier_new (_tmp48_);
			_tmp50_ = (ValaCCodeExpression*) _tmp49_;
			_g_free0 (_tmp48_);
			result = _tmp50_;
			_vala_ccode_node_unref0 (element_destroy_func_expression);
			return result;
		}
		_vala_ccode_node_unref0 (element_destroy_func_expression);
	} else {
		ValaDataType* _tmp51_;
		_tmp51_ = type;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp51_, VALA_TYPE_ERROR_TYPE)) {
			ValaCCodeIdentifier* _tmp52_;
			_tmp52_ = vala_ccode_identifier_new ("g_error_free");
			result = (ValaCCodeExpression*) _tmp52_;
			return result;
		} else {
			ValaDataType* _tmp53_;
			ValaTypeSymbol* _tmp54_;
			ValaTypeSymbol* _tmp55_;
			_tmp53_ = type;
			_tmp54_ = vala_data_type_get_data_type (_tmp53_);
			_tmp55_ = _tmp54_;
			if (_tmp55_ != NULL) {
				gchar* unref_function = NULL;
				ValaDataType* _tmp56_;
				const gchar* _tmp129_;
				const gchar* _tmp131_;
				ValaCCodeIdentifier* _tmp132_;
				_tmp56_ = type;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp56_, VALA_TYPE_REFERENCE_TYPE)) {
					ValaDataType* _tmp57_;
					ValaTypeSymbol* _tmp58_;
					ValaTypeSymbol* _tmp59_;
					gboolean _tmp60_;
					_tmp57_ = type;
					_tmp58_ = vala_data_type_get_data_type (_tmp57_);
					_tmp59_ = _tmp58_;
					_tmp60_ = vala_ccode_base_module_is_reference_counting (_tmp59_);
					if (_tmp60_) {
						ValaDataType* _tmp61_;
						ValaTypeSymbol* _tmp62_;
						ValaTypeSymbol* _tmp63_;
						gchar* _tmp64_;
						gboolean _tmp65_ = FALSE;
						ValaDataType* _tmp66_;
						ValaTypeSymbol* _tmp67_;
						ValaTypeSymbol* _tmp68_;
						_tmp61_ = type;
						_tmp62_ = vala_data_type_get_data_type (_tmp61_);
						_tmp63_ = _tmp62_;
						_tmp64_ = vala_ccode_base_module_get_ccode_unref_function (G_TYPE_CHECK_INSTANCE_CAST (_tmp63_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
						_g_free0 (unref_function);
						unref_function = _tmp64_;
						_tmp66_ = type;
						_tmp67_ = vala_data_type_get_data_type (_tmp66_);
						_tmp68_ = _tmp67_;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp68_, VALA_TYPE_INTERFACE)) {
							const gchar* _tmp69_;
							_tmp69_ = unref_function;
							_tmp65_ = _tmp69_ == NULL;
						} else {
							_tmp65_ = FALSE;
						}
						if (_tmp65_) {
							ValaDataType* _tmp70_;
							ValaSourceReference* _tmp71_;
							ValaSourceReference* _tmp72_;
							ValaDataType* _tmp73_;
							ValaTypeSymbol* _tmp74_;
							ValaTypeSymbol* _tmp75_;
							gchar* _tmp76_;
							gchar* _tmp77_;
							gchar* _tmp78_;
							gchar* _tmp79_;
							_tmp70_ = type;
							_tmp71_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp70_);
							_tmp72_ = _tmp71_;
							_tmp73_ = type;
							_tmp74_ = vala_data_type_get_data_type (_tmp73_);
							_tmp75_ = _tmp74_;
							_tmp76_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp75_);
							_tmp77_ = _tmp76_;
							_tmp78_ = g_strdup_printf ("missing class prerequisite for interface `%s', add GLib.Object to inte" \
"rface declaration if unsure", _tmp77_);
							_tmp79_ = _tmp78_;
							vala_report_error (_tmp72_, _tmp79_);
							_g_free0 (_tmp79_);
							_g_free0 (_tmp77_);
							result = NULL;
							_g_free0 (unref_function);
							return result;
						}
					} else {
						ValaClass* cl = NULL;
						ValaDataType* _tmp80_;
						ValaTypeSymbol* _tmp81_;
						ValaTypeSymbol* _tmp82_;
						ValaClass* _tmp83_;
						gboolean _tmp84_ = FALSE;
						ValaClass* _tmp85_;
						_tmp80_ = type;
						_tmp81_ = vala_data_type_get_data_type (_tmp80_);
						_tmp82_ = _tmp81_;
						_tmp83_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp82_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp82_) : NULL);
						cl = _tmp83_;
						_tmp85_ = cl;
						if (_tmp85_ != NULL) {
							ValaClass* _tmp86_;
							gboolean _tmp87_;
							_tmp86_ = cl;
							_tmp87_ = vala_ccode_base_module_get_ccode_is_gboxed ((ValaTypeSymbol*) _tmp86_);
							_tmp84_ = _tmp87_;
						} else {
							_tmp84_ = FALSE;
						}
						if (_tmp84_) {
							ValaDataType* _tmp88_;
							gchar* _tmp89_;
							_tmp88_ = type;
							_tmp89_ = vala_ccode_base_module_generate_free_func_wrapper (self, _tmp88_);
							_g_free0 (unref_function);
							unref_function = _tmp89_;
						} else {
							ValaDataType* _tmp90_;
							gboolean _tmp91_;
							_tmp90_ = type;
							_tmp91_ = vala_ccode_base_module_is_free_function_address_of (self, _tmp90_);
							if (_tmp91_) {
								ValaDataType* _tmp92_;
								gchar* _tmp93_;
								_tmp92_ = type;
								_tmp93_ = vala_ccode_base_module_generate_free_function_address_of_wrapper (self, _tmp92_);
								_g_free0 (unref_function);
								unref_function = _tmp93_;
							} else {
								ValaDataType* _tmp94_;
								ValaTypeSymbol* _tmp95_;
								ValaTypeSymbol* _tmp96_;
								gchar* _tmp97_;
								_tmp94_ = type;
								_tmp95_ = vala_data_type_get_data_type (_tmp94_);
								_tmp96_ = _tmp95_;
								_tmp97_ = vala_ccode_base_module_get_ccode_free_function (_tmp96_);
								_g_free0 (unref_function);
								unref_function = _tmp97_;
							}
						}
						_vala_code_node_unref0 (cl);
					}
				} else {
					ValaDataType* _tmp98_;
					gboolean _tmp99_;
					gboolean _tmp100_;
					_tmp98_ = type;
					_tmp99_ = vala_data_type_get_nullable (_tmp98_);
					_tmp100_ = _tmp99_;
					if (_tmp100_) {
						ValaDataType* _tmp101_;
						ValaTypeSymbol* _tmp102_;
						ValaTypeSymbol* _tmp103_;
						gchar* _tmp104_;
						const gchar* _tmp105_;
						_tmp101_ = type;
						_tmp102_ = vala_data_type_get_data_type (_tmp101_);
						_tmp103_ = _tmp102_;
						_tmp104_ = vala_ccode_base_module_get_ccode_free_function (_tmp103_);
						_g_free0 (unref_function);
						unref_function = _tmp104_;
						_tmp105_ = unref_function;
						if (_tmp105_ == NULL) {
							gboolean _tmp106_ = FALSE;
							ValaDataType* _tmp107_;
							ValaTypeSymbol* _tmp108_;
							ValaTypeSymbol* _tmp109_;
							_tmp107_ = type;
							_tmp108_ = vala_data_type_get_data_type (_tmp107_);
							_tmp109_ = _tmp108_;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp109_, VALA_TYPE_STRUCT)) {
								ValaDataType* _tmp110_;
								ValaTypeSymbol* _tmp111_;
								ValaTypeSymbol* _tmp112_;
								gboolean _tmp113_;
								_tmp110_ = type;
								_tmp111_ = vala_data_type_get_data_type (_tmp110_);
								_tmp112_ = _tmp111_;
								_tmp113_ = vala_struct_is_disposable (G_TYPE_CHECK_INSTANCE_CAST (_tmp112_, VALA_TYPE_STRUCT, ValaStruct));
								_tmp106_ = _tmp113_;
							} else {
								_tmp106_ = FALSE;
							}
							if (_tmp106_) {
								ValaDataType* _tmp114_;
								gchar* _tmp115_;
								_tmp114_ = type;
								_tmp115_ = vala_ccode_base_module_generate_free_func_wrapper (self, _tmp114_);
								_g_free0 (unref_function);
								unref_function = _tmp115_;
							} else {
								gchar* _tmp116_;
								_tmp116_ = g_strdup ("g_free");
								_g_free0 (unref_function);
								unref_function = _tmp116_;
							}
						}
					} else {
						ValaDataType* _tmp117_;
						_tmp117_ = type;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp117_, VALA_TYPE_ENUM_VALUE_TYPE)) {
							_g_free0 (unref_function);
							unref_function = NULL;
						} else {
							ValaStruct* st = NULL;
							ValaDataType* _tmp118_;
							ValaTypeSymbol* _tmp119_;
							ValaTypeSymbol* _tmp120_;
							ValaStruct* _tmp121_;
							ValaStruct* _tmp122_;
							gboolean _tmp123_;
							_tmp118_ = type;
							_tmp119_ = vala_data_type_get_data_type (_tmp118_);
							_tmp120_ = _tmp119_;
							_tmp121_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp120_, VALA_TYPE_STRUCT, ValaStruct));
							st = _tmp121_;
							_tmp122_ = st;
							_tmp123_ = vala_struct_is_disposable (_tmp122_);
							if (_tmp123_) {
								ValaStruct* _tmp124_;
								gboolean _tmp125_;
								ValaStruct* _tmp127_;
								gchar* _tmp128_;
								_tmp124_ = st;
								_tmp125_ = vala_ccode_base_module_get_ccode_has_destroy_function (_tmp124_);
								if (!_tmp125_) {
									ValaStruct* _tmp126_;
									_tmp126_ = st;
									vala_ccode_base_module_generate_struct_destroy_function (self, _tmp126_);
								}
								_tmp127_ = st;
								_tmp128_ = vala_ccode_base_module_get_ccode_destroy_function ((ValaTypeSymbol*) _tmp127_);
								_g_free0 (unref_function);
								unref_function = _tmp128_;
							} else {
								_g_free0 (unref_function);
								unref_function = NULL;
							}
							_vala_code_node_unref0 (st);
						}
					}
				}
				_tmp129_ = unref_function;
				if (_tmp129_ == NULL) {
					ValaCCodeConstant* _tmp130_;
					_tmp130_ = vala_ccode_constant_new ("NULL");
					result = (ValaCCodeExpression*) _tmp130_;
					_g_free0 (unref_function);
					return result;
				}
				_tmp131_ = unref_function;
				_tmp132_ = vala_ccode_identifier_new (_tmp131_);
				result = (ValaCCodeExpression*) _tmp132_;
				_g_free0 (unref_function);
				return result;
			} else {
				ValaDataType* _tmp133_;
				ValaTypeParameter* _tmp134_;
				ValaTypeParameter* _tmp135_;
				_tmp133_ = type;
				_tmp134_ = vala_data_type_get_type_parameter (_tmp133_);
				_tmp135_ = _tmp134_;
				if (_tmp135_ != NULL) {
					gchar* func_name = NULL;
					ValaDataType* _tmp136_;
					ValaTypeParameter* _tmp137_;
					ValaTypeParameter* _tmp138_;
					const gchar* _tmp139_;
					const gchar* _tmp140_;
					gchar* _tmp141_;
					gchar* _tmp142_;
					gchar* _tmp143_;
					gchar* _tmp144_;
					ValaDataType* _tmp145_;
					ValaTypeParameter* _tmp146_;
					ValaTypeParameter* _tmp147_;
					ValaSymbol* _tmp148_;
					ValaSymbol* _tmp149_;
					gboolean _tmp187_ = FALSE;
					gboolean _tmp188_ = FALSE;
					ValaDataType* _tmp189_;
					gboolean _tmp190_;
					_tmp136_ = type;
					_tmp137_ = vala_data_type_get_type_parameter (_tmp136_);
					_tmp138_ = _tmp137_;
					_tmp139_ = vala_symbol_get_name ((ValaSymbol*) _tmp138_);
					_tmp140_ = _tmp139_;
					_tmp141_ = g_utf8_strdown (_tmp140_, (gssize) -1);
					_tmp142_ = _tmp141_;
					_tmp143_ = g_strdup_printf ("%s_destroy_func", _tmp142_);
					_tmp144_ = _tmp143_;
					_g_free0 (_tmp142_);
					func_name = _tmp144_;
					_tmp145_ = type;
					_tmp146_ = vala_data_type_get_type_parameter (_tmp145_);
					_tmp147_ = _tmp146_;
					_tmp148_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp147_);
					_tmp149_ = _tmp148_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp149_, VALA_TYPE_INTERFACE)) {
						ValaInterface* iface = NULL;
						ValaDataType* _tmp150_;
						ValaTypeParameter* _tmp151_;
						ValaTypeParameter* _tmp152_;
						ValaSymbol* _tmp153_;
						ValaSymbol* _tmp154_;
						ValaInterface* _tmp155_;
						ValaInterface* _tmp156_;
						gchar* method_name = NULL;
						ValaDataType* _tmp157_;
						ValaTypeParameter* _tmp158_;
						ValaTypeParameter* _tmp159_;
						const gchar* _tmp160_;
						const gchar* _tmp161_;
						gchar* _tmp162_;
						gchar* _tmp163_;
						gchar* _tmp164_;
						gchar* _tmp165_;
						ValaCCodeFunctionCall* cast_self = NULL;
						ValaInterface* _tmp166_;
						gchar* _tmp167_;
						gchar* _tmp168_;
						gchar* _tmp169_;
						gchar* _tmp170_;
						ValaCCodeIdentifier* _tmp171_;
						ValaCCodeIdentifier* _tmp172_;
						ValaCCodeFunctionCall* _tmp173_;
						ValaCCodeFunctionCall* _tmp174_;
						ValaCCodeFunctionCall* _tmp175_;
						ValaCCodeIdentifier* _tmp176_;
						ValaCCodeIdentifier* _tmp177_;
						ValaCCodeFunctionCall* function_call = NULL;
						ValaCCodeFunctionCall* _tmp178_;
						const gchar* _tmp179_;
						ValaCCodeMemberAccess* _tmp180_;
						ValaCCodeMemberAccess* _tmp181_;
						ValaCCodeFunctionCall* _tmp182_;
						ValaCCodeFunctionCall* _tmp183_;
						ValaCCodeFunctionCall* _tmp184_;
						ValaCCodeIdentifier* _tmp185_;
						ValaCCodeIdentifier* _tmp186_;
						_tmp150_ = type;
						_tmp151_ = vala_data_type_get_type_parameter (_tmp150_);
						_tmp152_ = _tmp151_;
						_tmp153_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp152_);
						_tmp154_ = _tmp153_;
						_tmp155_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp154_, VALA_TYPE_INTERFACE, ValaInterface));
						iface = _tmp155_;
						_tmp156_ = iface;
						vala_ccode_base_module_require_generic_accessors (self, _tmp156_);
						_tmp157_ = type;
						_tmp158_ = vala_data_type_get_type_parameter (_tmp157_);
						_tmp159_ = _tmp158_;
						_tmp160_ = vala_symbol_get_name ((ValaSymbol*) _tmp159_);
						_tmp161_ = _tmp160_;
						_tmp162_ = g_utf8_strdown (_tmp161_, (gssize) -1);
						_tmp163_ = _tmp162_;
						_tmp164_ = g_strdup_printf ("get_%s_destroy_func", _tmp163_);
						_tmp165_ = _tmp164_;
						_g_free0 (_tmp163_);
						method_name = _tmp165_;
						_tmp166_ = iface;
						_tmp167_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp166_, NULL);
						_tmp168_ = _tmp167_;
						_tmp169_ = g_strdup_printf ("%s_GET_INTERFACE", _tmp168_);
						_tmp170_ = _tmp169_;
						_tmp171_ = vala_ccode_identifier_new (_tmp170_);
						_tmp172_ = _tmp171_;
						_tmp173_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp172_);
						_tmp174_ = _tmp173_;
						_vala_ccode_node_unref0 (_tmp172_);
						_g_free0 (_tmp170_);
						_g_free0 (_tmp168_);
						cast_self = _tmp174_;
						_tmp175_ = cast_self;
						_tmp176_ = vala_ccode_identifier_new ("self");
						_tmp177_ = _tmp176_;
						vala_ccode_function_call_add_argument (_tmp175_, (ValaCCodeExpression*) _tmp177_);
						_vala_ccode_node_unref0 (_tmp177_);
						_tmp178_ = cast_self;
						_tmp179_ = method_name;
						_tmp180_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp178_, _tmp179_);
						_tmp181_ = _tmp180_;
						_tmp182_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp181_);
						_tmp183_ = _tmp182_;
						_vala_ccode_node_unref0 (_tmp181_);
						function_call = _tmp183_;
						_tmp184_ = function_call;
						_tmp185_ = vala_ccode_identifier_new ("self");
						_tmp186_ = _tmp185_;
						vala_ccode_function_call_add_argument (_tmp184_, (ValaCCodeExpression*) _tmp186_);
						_vala_ccode_node_unref0 (_tmp186_);
						result = (ValaCCodeExpression*) function_call;
						_vala_ccode_node_unref0 (cast_self);
						_g_free0 (method_name);
						_vala_code_node_unref0 (iface);
						_g_free0 (func_name);
						return result;
					}
					_tmp189_ = type;
					_tmp190_ = vala_ccode_base_module_is_in_generic_type (self, _tmp189_);
					if (_tmp190_) {
						gboolean _tmp191_;
						_tmp191_ = is_chainup;
						_tmp188_ = !_tmp191_;
					} else {
						_tmp188_ = FALSE;
					}
					if (_tmp188_) {
						gboolean _tmp192_;
						gboolean _tmp193_;
						_tmp192_ = vala_ccode_base_module_get_in_creation_method (self);
						_tmp193_ = _tmp192_;
						_tmp187_ = !_tmp193_;
					} else {
						_tmp187_ = FALSE;
					}
					if (_tmp187_) {
						ValaCCodeExpression* _tmp194_;
						ValaCCodeExpression* _tmp195_;
						ValaCCodeMemberAccess* _tmp196_;
						ValaCCodeMemberAccess* _tmp197_;
						const gchar* _tmp198_;
						ValaCCodeMemberAccess* _tmp199_;
						ValaCCodeExpression* _tmp200_;
						_tmp194_ = vala_ccode_base_module_get_result_cexpression (self, "self");
						_tmp195_ = _tmp194_;
						_tmp196_ = vala_ccode_member_access_new_pointer (_tmp195_, "priv");
						_tmp197_ = _tmp196_;
						_tmp198_ = func_name;
						_tmp199_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp197_, _tmp198_);
						_tmp200_ = (ValaCCodeExpression*) _tmp199_;
						_vala_ccode_node_unref0 (_tmp197_);
						_vala_ccode_node_unref0 (_tmp195_);
						result = _tmp200_;
						_g_free0 (func_name);
						return result;
					} else {
						const gchar* _tmp201_;
						ValaCCodeExpression* _tmp202_;
						_tmp201_ = func_name;
						_tmp202_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp201_);
						result = _tmp202_;
						_g_free0 (func_name);
						return result;
					}
					_g_free0 (func_name);
				} else {
					ValaDataType* _tmp203_;
					_tmp203_ = type;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp203_, VALA_TYPE_ARRAY_TYPE)) {
						ValaCCodeIdentifier* _tmp204_;
						_tmp204_ = vala_ccode_identifier_new ("g_free");
						result = (ValaCCodeExpression*) _tmp204_;
						return result;
					} else {
						ValaDataType* _tmp205_;
						_tmp205_ = type;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp205_, VALA_TYPE_POINTER_TYPE)) {
							ValaCCodeIdentifier* _tmp206_;
							_tmp206_ = vala_ccode_identifier_new ("g_free");
							result = (ValaCCodeExpression*) _tmp206_;
							return result;
						} else {
							ValaCCodeConstant* _tmp207_;
							_tmp207_ = vala_ccode_constant_new ("NULL");
							result = (ValaCCodeExpression*) _tmp207_;
							return result;
						}
					}
				}
			}
		}
	}
}


static gchar* vala_ccode_base_module_generate_collection_free_wrapper (ValaCCodeBaseModule* self, ValaDataType* collection_type, ValaCCodeIdentifier* element_destroy_func_expression) {
	gchar* result = NULL;
	gchar* destroy_func = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	ValaCCodeIdentifier* _tmp5_;
	const gchar* _tmp6_;
	const gchar* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	const gchar* _tmp10_;
	gboolean _tmp11_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp12_;
	ValaCCodeFunction* _tmp13_;
	ValaCCodeFunction* _tmp14_;
	ValaCCodeFunction* _tmp15_;
	ValaDataType* _tmp16_;
	gchar* _tmp17_;
	gchar* _tmp18_;
	ValaCCodeParameter* _tmp19_;
	ValaCCodeParameter* _tmp20_;
	ValaCCodeFunction* _tmp21_;
	ValaCCodeFunctionCall* element_free_call = NULL;
	ValaDataType* _tmp22_;
	ValaTypeSymbol* _tmp23_;
	ValaTypeSymbol* _tmp24_;
	ValaClass* _tmp25_;
	ValaCCodeFunction* _tmp108_;
	ValaCCodeFunction* _tmp109_;
	ValaCCodeFunctionCall* _tmp110_;
	ValaCCodeFunctionCall* cfreecall = NULL;
	ValaDataType* _tmp111_;
	ValaTypeSymbol* _tmp112_;
	ValaTypeSymbol* _tmp113_;
	gchar* _tmp114_;
	gchar* _tmp115_;
	ValaCCodeIdentifier* _tmp116_;
	ValaCCodeIdentifier* _tmp117_;
	ValaCCodeFunctionCall* _tmp118_;
	ValaCCodeFunctionCall* _tmp119_;
	ValaCCodeFunctionCall* _tmp120_;
	ValaCCodeIdentifier* _tmp121_;
	ValaCCodeIdentifier* _tmp122_;
	ValaCCodeFunction* _tmp123_;
	ValaCCodeFunction* _tmp124_;
	ValaCCodeFunctionCall* _tmp125_;
	ValaCCodeFile* _tmp126_;
	ValaCCodeFunction* _tmp127_;
	ValaCCodeFile* _tmp128_;
	ValaCCodeFunction* _tmp129_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (collection_type != NULL, NULL);
	g_return_val_if_fail (element_destroy_func_expression != NULL, NULL);
	_tmp0_ = collection_type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_ccode_free_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = element_destroy_func_expression;
	_tmp6_ = vala_ccode_identifier_get_name (_tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = g_strdup_printf ("_%s_%s", _tmp4_, _tmp7_);
	_tmp9_ = _tmp8_;
	_g_free0 (_tmp4_);
	destroy_func = _tmp9_;
	_tmp10_ = destroy_func;
	_tmp11_ = vala_ccode_base_module_add_wrapper (self, _tmp10_);
	if (!_tmp11_) {
		result = destroy_func;
		return result;
	}
	_tmp12_ = destroy_func;
	_tmp13_ = vala_ccode_function_new (_tmp12_, "void");
	function = _tmp13_;
	_tmp14_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp14_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp15_ = function;
	_tmp16_ = collection_type;
	_tmp17_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp16_);
	_tmp18_ = _tmp17_;
	_tmp19_ = vala_ccode_parameter_new ("self", _tmp18_);
	_tmp20_ = _tmp19_;
	vala_ccode_function_add_parameter (_tmp15_, _tmp20_);
	_vala_ccode_node_unref0 (_tmp20_);
	_g_free0 (_tmp18_);
	_tmp21_ = function;
	vala_ccode_base_module_push_function (self, _tmp21_);
	_tmp22_ = collection_type;
	_tmp23_ = vala_data_type_get_data_type (_tmp22_);
	_tmp24_ = _tmp23_;
	_tmp25_ = self->gnode_type;
	if (_tmp24_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) {
		gchar* destroy_node_func = NULL;
		const gchar* _tmp26_;
		gchar* _tmp27_;
		ValaCCodeFunction* wrapper = NULL;
		const gchar* _tmp28_;
		ValaCCodeFunction* _tmp29_;
		ValaCCodeFunction* _tmp30_;
		ValaCCodeFunction* _tmp31_;
		ValaDataType* _tmp32_;
		gchar* _tmp33_;
		gchar* _tmp34_;
		ValaCCodeParameter* _tmp35_;
		ValaCCodeParameter* _tmp36_;
		ValaCCodeFunction* _tmp37_;
		ValaCCodeParameter* _tmp38_;
		ValaCCodeParameter* _tmp39_;
		ValaCCodeFunction* _tmp40_;
		ValaCCodeFunctionCall* free_call = NULL;
		ValaCCodeIdentifier* _tmp41_;
		ValaCCodeFunctionCall* _tmp42_;
		ValaCCodeFunctionCall* _tmp43_;
		ValaCCodeIdentifier* _tmp44_;
		ValaCCodeIdentifier* _tmp45_;
		ValaCCodeMemberAccess* _tmp46_;
		ValaCCodeMemberAccess* _tmp47_;
		ValaCCodeFunction* _tmp48_;
		ValaCCodeFunction* _tmp49_;
		ValaCCodeFunctionCall* _tmp50_;
		ValaCCodeFunction* _tmp51_;
		ValaCCodeFunction* _tmp52_;
		ValaCCodeConstant* _tmp53_;
		ValaCCodeConstant* _tmp54_;
		ValaCCodeFile* _tmp55_;
		ValaCCodeFunction* _tmp56_;
		ValaCCodeFile* _tmp57_;
		ValaCCodeFunction* _tmp58_;
		ValaCCodeIdentifier* _tmp59_;
		ValaCCodeIdentifier* _tmp60_;
		ValaCCodeFunctionCall* _tmp61_;
		ValaCCodeFunctionCall* _tmp62_;
		ValaCCodeIdentifier* _tmp63_;
		ValaCCodeIdentifier* _tmp64_;
		ValaCCodeFunctionCall* _tmp65_;
		ValaCCodeConstant* _tmp66_;
		ValaCCodeConstant* _tmp67_;
		ValaCCodeFunctionCall* _tmp68_;
		ValaCCodeConstant* _tmp69_;
		ValaCCodeConstant* _tmp70_;
		ValaCCodeFunctionCall* _tmp71_;
		ValaCCodeConstant* _tmp72_;
		ValaCCodeConstant* _tmp73_;
		ValaCCodeFunctionCall* _tmp74_;
		const gchar* _tmp75_;
		ValaCCodeIdentifier* _tmp76_;
		ValaCCodeIdentifier* _tmp77_;
		ValaCCodeFunctionCall* _tmp78_;
		ValaCCodeConstant* _tmp79_;
		ValaCCodeConstant* _tmp80_;
		_tmp26_ = destroy_func;
		_tmp27_ = g_strdup_printf ("%s_node", _tmp26_);
		destroy_node_func = _tmp27_;
		_tmp28_ = destroy_node_func;
		_tmp29_ = vala_ccode_function_new (_tmp28_, "gboolean");
		wrapper = _tmp29_;
		_tmp30_ = wrapper;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp30_, VALA_CCODE_MODIFIERS_STATIC);
		_tmp31_ = wrapper;
		_tmp32_ = collection_type;
		_tmp33_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp32_);
		_tmp34_ = _tmp33_;
		_tmp35_ = vala_ccode_parameter_new ("node", _tmp34_);
		_tmp36_ = _tmp35_;
		vala_ccode_function_add_parameter (_tmp31_, _tmp36_);
		_vala_ccode_node_unref0 (_tmp36_);
		_g_free0 (_tmp34_);
		_tmp37_ = wrapper;
		_tmp38_ = vala_ccode_parameter_new ("unused", "gpointer");
		_tmp39_ = _tmp38_;
		vala_ccode_function_add_parameter (_tmp37_, _tmp39_);
		_vala_ccode_node_unref0 (_tmp39_);
		_tmp40_ = wrapper;
		vala_ccode_base_module_push_function (self, _tmp40_);
		_tmp41_ = element_destroy_func_expression;
		_tmp42_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp41_);
		free_call = _tmp42_;
		_tmp43_ = free_call;
		_tmp44_ = vala_ccode_identifier_new ("node");
		_tmp45_ = _tmp44_;
		_tmp46_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp45_, "data");
		_tmp47_ = _tmp46_;
		vala_ccode_function_call_add_argument (_tmp43_, (ValaCCodeExpression*) _tmp47_);
		_vala_ccode_node_unref0 (_tmp47_);
		_vala_ccode_node_unref0 (_tmp45_);
		_tmp48_ = vala_ccode_base_module_get_ccode (self);
		_tmp49_ = _tmp48_;
		_tmp50_ = free_call;
		vala_ccode_function_add_expression (_tmp49_, (ValaCCodeExpression*) _tmp50_);
		_tmp51_ = vala_ccode_base_module_get_ccode (self);
		_tmp52_ = _tmp51_;
		_tmp53_ = vala_ccode_constant_new ("FALSE");
		_tmp54_ = _tmp53_;
		vala_ccode_function_add_return (_tmp52_, (ValaCCodeExpression*) _tmp54_);
		_vala_ccode_node_unref0 (_tmp54_);
		vala_ccode_base_module_pop_function (self);
		_tmp55_ = self->cfile;
		_tmp56_ = function;
		vala_ccode_file_add_function_declaration (_tmp55_, _tmp56_);
		_tmp57_ = self->cfile;
		_tmp58_ = wrapper;
		vala_ccode_file_add_function (_tmp57_, _tmp58_);
		_tmp59_ = vala_ccode_identifier_new ("g_node_traverse");
		_tmp60_ = _tmp59_;
		_tmp61_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp60_);
		_vala_ccode_node_unref0 (element_free_call);
		element_free_call = _tmp61_;
		_vala_ccode_node_unref0 (_tmp60_);
		_tmp62_ = element_free_call;
		_tmp63_ = vala_ccode_identifier_new ("self");
		_tmp64_ = _tmp63_;
		vala_ccode_function_call_add_argument (_tmp62_, (ValaCCodeExpression*) _tmp64_);
		_vala_ccode_node_unref0 (_tmp64_);
		_tmp65_ = element_free_call;
		_tmp66_ = vala_ccode_constant_new ("G_POST_ORDER");
		_tmp67_ = _tmp66_;
		vala_ccode_function_call_add_argument (_tmp65_, (ValaCCodeExpression*) _tmp67_);
		_vala_ccode_node_unref0 (_tmp67_);
		_tmp68_ = element_free_call;
		_tmp69_ = vala_ccode_constant_new ("G_TRAVERSE_ALL");
		_tmp70_ = _tmp69_;
		vala_ccode_function_call_add_argument (_tmp68_, (ValaCCodeExpression*) _tmp70_);
		_vala_ccode_node_unref0 (_tmp70_);
		_tmp71_ = element_free_call;
		_tmp72_ = vala_ccode_constant_new ("-1");
		_tmp73_ = _tmp72_;
		vala_ccode_function_call_add_argument (_tmp71_, (ValaCCodeExpression*) _tmp73_);
		_vala_ccode_node_unref0 (_tmp73_);
		_tmp74_ = element_free_call;
		_tmp75_ = destroy_node_func;
		_tmp76_ = vala_ccode_identifier_new (_tmp75_);
		_tmp77_ = _tmp76_;
		vala_ccode_function_call_add_argument (_tmp74_, (ValaCCodeExpression*) _tmp77_);
		_vala_ccode_node_unref0 (_tmp77_);
		_tmp78_ = element_free_call;
		_tmp79_ = vala_ccode_constant_new ("NULL");
		_tmp80_ = _tmp79_;
		vala_ccode_function_call_add_argument (_tmp78_, (ValaCCodeExpression*) _tmp80_);
		_vala_ccode_node_unref0 (_tmp80_);
		_vala_ccode_node_unref0 (free_call);
		_vala_ccode_node_unref0 (wrapper);
		_g_free0 (destroy_node_func);
	} else {
		ValaDataType* _tmp81_;
		ValaTypeSymbol* _tmp82_;
		ValaTypeSymbol* _tmp83_;
		ValaClass* _tmp84_;
		ValaCCodeFunctionCall* _tmp98_;
		ValaCCodeIdentifier* _tmp99_;
		ValaCCodeIdentifier* _tmp100_;
		ValaCCodeFunctionCall* _tmp101_;
		ValaCCodeIdentifier* _tmp102_;
		ValaCCodeCastExpression* _tmp103_;
		ValaCCodeCastExpression* _tmp104_;
		ValaCCodeFunctionCall* _tmp105_;
		ValaCCodeConstant* _tmp106_;
		ValaCCodeConstant* _tmp107_;
		_tmp81_ = collection_type;
		_tmp82_ = vala_data_type_get_data_type (_tmp81_);
		_tmp83_ = _tmp82_;
		_tmp84_ = self->glist_type;
		if (_tmp83_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp84_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) {
			ValaCCodeIdentifier* _tmp85_;
			ValaCCodeIdentifier* _tmp86_;
			ValaCCodeFunctionCall* _tmp87_;
			_tmp85_ = vala_ccode_identifier_new ("g_list_foreach");
			_tmp86_ = _tmp85_;
			_tmp87_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp86_);
			_vala_ccode_node_unref0 (element_free_call);
			element_free_call = _tmp87_;
			_vala_ccode_node_unref0 (_tmp86_);
		} else {
			ValaDataType* _tmp88_;
			ValaTypeSymbol* _tmp89_;
			ValaTypeSymbol* _tmp90_;
			ValaClass* _tmp91_;
			_tmp88_ = collection_type;
			_tmp89_ = vala_data_type_get_data_type (_tmp88_);
			_tmp90_ = _tmp89_;
			_tmp91_ = self->gslist_type;
			if (_tmp90_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp91_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) {
				ValaCCodeIdentifier* _tmp92_;
				ValaCCodeIdentifier* _tmp93_;
				ValaCCodeFunctionCall* _tmp94_;
				_tmp92_ = vala_ccode_identifier_new ("g_slist_foreach");
				_tmp93_ = _tmp92_;
				_tmp94_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp93_);
				_vala_ccode_node_unref0 (element_free_call);
				element_free_call = _tmp94_;
				_vala_ccode_node_unref0 (_tmp93_);
			} else {
				ValaCCodeIdentifier* _tmp95_;
				ValaCCodeIdentifier* _tmp96_;
				ValaCCodeFunctionCall* _tmp97_;
				_tmp95_ = vala_ccode_identifier_new ("g_queue_foreach");
				_tmp96_ = _tmp95_;
				_tmp97_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp96_);
				_vala_ccode_node_unref0 (element_free_call);
				element_free_call = _tmp97_;
				_vala_ccode_node_unref0 (_tmp96_);
			}
		}
		_tmp98_ = element_free_call;
		_tmp99_ = vala_ccode_identifier_new ("self");
		_tmp100_ = _tmp99_;
		vala_ccode_function_call_add_argument (_tmp98_, (ValaCCodeExpression*) _tmp100_);
		_vala_ccode_node_unref0 (_tmp100_);
		_tmp101_ = element_free_call;
		_tmp102_ = element_destroy_func_expression;
		_tmp103_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp102_, "GFunc");
		_tmp104_ = _tmp103_;
		vala_ccode_function_call_add_argument (_tmp101_, (ValaCCodeExpression*) _tmp104_);
		_vala_ccode_node_unref0 (_tmp104_);
		_tmp105_ = element_free_call;
		_tmp106_ = vala_ccode_constant_new ("NULL");
		_tmp107_ = _tmp106_;
		vala_ccode_function_call_add_argument (_tmp105_, (ValaCCodeExpression*) _tmp107_);
		_vala_ccode_node_unref0 (_tmp107_);
	}
	_tmp108_ = vala_ccode_base_module_get_ccode (self);
	_tmp109_ = _tmp108_;
	_tmp110_ = element_free_call;
	vala_ccode_function_add_expression (_tmp109_, (ValaCCodeExpression*) _tmp110_);
	_tmp111_ = collection_type;
	_tmp112_ = vala_data_type_get_data_type (_tmp111_);
	_tmp113_ = _tmp112_;
	_tmp114_ = vala_ccode_base_module_get_ccode_free_function (_tmp113_);
	_tmp115_ = _tmp114_;
	_tmp116_ = vala_ccode_identifier_new (_tmp115_);
	_tmp117_ = _tmp116_;
	_tmp118_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp117_);
	_tmp119_ = _tmp118_;
	_vala_ccode_node_unref0 (_tmp117_);
	_g_free0 (_tmp115_);
	cfreecall = _tmp119_;
	_tmp120_ = cfreecall;
	_tmp121_ = vala_ccode_identifier_new ("self");
	_tmp122_ = _tmp121_;
	vala_ccode_function_call_add_argument (_tmp120_, (ValaCCodeExpression*) _tmp122_);
	_vala_ccode_node_unref0 (_tmp122_);
	_tmp123_ = vala_ccode_base_module_get_ccode (self);
	_tmp124_ = _tmp123_;
	_tmp125_ = cfreecall;
	vala_ccode_function_add_expression (_tmp124_, (ValaCCodeExpression*) _tmp125_);
	vala_ccode_base_module_pop_function (self);
	_tmp126_ = self->cfile;
	_tmp127_ = function;
	vala_ccode_file_add_function_declaration (_tmp126_, _tmp127_);
	_tmp128_ = self->cfile;
	_tmp129_ = function;
	vala_ccode_file_add_function (_tmp128_, _tmp129_);
	result = destroy_func;
	_vala_ccode_node_unref0 (cfreecall);
	_vala_ccode_node_unref0 (element_free_call);
	_vala_ccode_node_unref0 (function);
	return result;
}


static gchar* vala_ccode_base_module_real_append_struct_array_free (ValaCCodeBaseModule* self, ValaStruct* st) {
	gchar* result = NULL;
	g_return_val_if_fail (st != NULL, NULL);
	result = NULL;
	return result;
}


gchar* vala_ccode_base_module_append_struct_array_free (ValaCCodeBaseModule* self, ValaStruct* st) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->append_struct_array_free (self, st);
}


ValaCCodeExpression* vala_ccode_base_module_destroy_local (ValaCCodeBaseModule* self, ValaLocalVariable* local) {
	ValaCCodeExpression* result = NULL;
	ValaLocalVariable* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (local != NULL, NULL);
	_tmp0_ = local;
	_tmp1_ = vala_ccode_base_module_get_local_cvalue (self, _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_destroy_value (self, _tmp2_, FALSE);
	_tmp4_ = _tmp3_;
	_vala_target_value_unref0 (_tmp2_);
	result = _tmp4_;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_destroy_parameter (ValaCCodeBaseModule* self, ValaParameter* param) {
	ValaCCodeExpression* result = NULL;
	ValaParameter* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (param != NULL, NULL);
	_tmp0_ = param;
	_tmp1_ = vala_ccode_base_module_get_parameter_cvalue (self, _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_destroy_value (self, _tmp2_, FALSE);
	_tmp4_ = _tmp3_;
	_vala_target_value_unref0 (_tmp2_);
	result = _tmp4_;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_destroy_field (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance) {
	ValaCCodeExpression* result = NULL;
	ValaField* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaTargetValue* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	ValaCCodeExpression* _tmp5_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (field != NULL, NULL);
	_tmp0_ = field;
	_tmp1_ = instance;
	_tmp2_ = vala_ccode_base_module_get_field_cvalue (self, _tmp0_, _tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_base_module_destroy_value (self, _tmp3_, FALSE);
	_tmp5_ = _tmp4_;
	_vala_target_value_unref0 (_tmp3_);
	result = _tmp5_;
	return result;
}


static ValaCCodeExpression* vala_ccode_base_module_real_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition) {
	ValaCCodeExpression* result = NULL;
	ValaDataType* type = NULL;
	ValaTargetValue* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaDataType* _tmp3_;
	ValaTargetValue* _tmp4_;
	ValaDataType* _tmp5_;
	ValaDataType* _tmp6_;
	ValaCCodeExpression* cvar = NULL;
	ValaTargetValue* _tmp11_;
	ValaCCodeExpression* _tmp12_;
	ValaDataType* _tmp13_;
	ValaCCodeFunctionCall* ccall = NULL;
	ValaDataType* _tmp59_;
	ValaCCodeExpression* _tmp60_;
	ValaCCodeExpression* _tmp61_;
	ValaCCodeFunctionCall* _tmp62_;
	ValaCCodeFunctionCall* _tmp63_;
	gboolean _tmp64_ = FALSE;
	ValaDataType* _tmp65_;
	gboolean _tmp138_ = FALSE;
	gboolean _tmp139_ = FALSE;
	ValaCCodeFunctionCall* _tmp140_;
	ValaCCodeExpression* _tmp141_;
	ValaCCodeExpression* _tmp142_;
	ValaCCodeBinaryExpression* cisnull = NULL;
	ValaCCodeExpression* _tmp175_;
	ValaCCodeConstant* _tmp176_;
	ValaCCodeConstant* _tmp177_;
	ValaCCodeBinaryExpression* _tmp178_;
	ValaCCodeBinaryExpression* _tmp179_;
	ValaDataType* _tmp180_;
	ValaTypeParameter* _tmp181_;
	ValaTypeParameter* _tmp182_;
	ValaCCodeFunctionCall* _tmp211_;
	ValaCCodeExpression* _tmp212_;
	ValaCCodeCommaExpression* ccomma = NULL;
	ValaCCodeCommaExpression* _tmp213_;
	gboolean _tmp214_ = FALSE;
	gboolean _tmp215_ = FALSE;
	ValaDataType* _tmp216_;
	ValaTypeSymbol* _tmp217_;
	ValaTypeSymbol* _tmp218_;
	ValaCCodeCommaExpression* _tmp317_;
	ValaCCodeFunctionCall* _tmp318_;
	ValaCCodeCommaExpression* _tmp319_;
	ValaCCodeConstant* _tmp320_;
	ValaCCodeConstant* _tmp321_;
	ValaCCodeAssignment* cassign = NULL;
	ValaCCodeExpression* _tmp322_;
	ValaCCodeCommaExpression* _tmp323_;
	ValaCCodeAssignment* _tmp324_;
	gboolean _tmp325_ = FALSE;
	gboolean _tmp326_ = FALSE;
	ValaDataType* _tmp327_;
	ValaTypeSymbol* _tmp328_;
	ValaTypeSymbol* _tmp329_;
	gboolean uses_gfree = FALSE;
	gboolean _tmp339_ = FALSE;
	gboolean _tmp340_;
	gboolean _tmp342_;
	ValaCCodeBinaryExpression* _tmp343_;
	ValaCCodeConstant* _tmp344_;
	ValaCCodeConstant* _tmp345_;
	ValaCCodeAssignment* _tmp346_;
	ValaCCodeConditionalExpression* _tmp347_;
	ValaCCodeExpression* _tmp348_;
	g_return_val_if_fail (value != NULL, NULL);
	_tmp0_ = value;
	_tmp1_ = vala_target_value_get_value_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (_tmp2_);
	type = _tmp3_;
	_tmp4_ = value;
	_tmp5_ = vala_target_value_get_actual_value_type (_tmp4_);
	_tmp6_ = _tmp5_;
	if (_tmp6_ != NULL) {
		ValaTargetValue* _tmp7_;
		ValaDataType* _tmp8_;
		ValaDataType* _tmp9_;
		ValaDataType* _tmp10_;
		_tmp7_ = value;
		_tmp8_ = vala_target_value_get_actual_value_type (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = _vala_code_node_ref0 (_tmp9_);
		_vala_code_node_unref0 (type);
		type = _tmp10_;
	}
	_tmp11_ = value;
	_tmp12_ = vala_ccode_base_module_get_cvalue_ (self, _tmp11_);
	cvar = _tmp12_;
	_tmp13_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_DELEGATE_TYPE)) {
		ValaCCodeExpression* delegate_target = NULL;
		ValaTargetValue* _tmp14_;
		ValaCCodeExpression* _tmp15_;
		ValaCCodeExpression* delegate_target_destroy_notify = NULL;
		ValaTargetValue* _tmp16_;
		ValaCCodeExpression* _tmp17_;
		ValaCCodeFunctionCall* ccall = NULL;
		ValaCCodeExpression* _tmp18_;
		ValaCCodeFunctionCall* _tmp19_;
		ValaCCodeFunctionCall* _tmp20_;
		ValaCCodeExpression* _tmp21_;
		ValaCCodeCommaExpression* destroy_call = NULL;
		ValaCCodeCommaExpression* _tmp22_;
		ValaCCodeCommaExpression* _tmp23_;
		ValaCCodeFunctionCall* _tmp24_;
		ValaCCodeCommaExpression* _tmp25_;
		ValaCCodeConstant* _tmp26_;
		ValaCCodeConstant* _tmp27_;
		ValaCCodeBinaryExpression* cisnull = NULL;
		ValaCCodeExpression* _tmp28_;
		ValaCCodeConstant* _tmp29_;
		ValaCCodeConstant* _tmp30_;
		ValaCCodeBinaryExpression* _tmp31_;
		ValaCCodeBinaryExpression* _tmp32_;
		ValaCCodeCommaExpression* ccomma = NULL;
		ValaCCodeCommaExpression* _tmp33_;
		ValaCCodeCommaExpression* _tmp34_;
		ValaCCodeBinaryExpression* _tmp35_;
		ValaCCodeConstant* _tmp36_;
		ValaCCodeConstant* _tmp37_;
		ValaCCodeCommaExpression* _tmp38_;
		ValaCCodeConditionalExpression* _tmp39_;
		ValaCCodeConditionalExpression* _tmp40_;
		ValaCCodeCommaExpression* _tmp41_;
		ValaCCodeExpression* _tmp42_;
		ValaCCodeConstant* _tmp43_;
		ValaCCodeConstant* _tmp44_;
		ValaCCodeAssignment* _tmp45_;
		ValaCCodeAssignment* _tmp46_;
		ValaCCodeCommaExpression* _tmp47_;
		ValaCCodeExpression* _tmp48_;
		ValaCCodeConstant* _tmp49_;
		ValaCCodeConstant* _tmp50_;
		ValaCCodeAssignment* _tmp51_;
		ValaCCodeAssignment* _tmp52_;
		ValaCCodeCommaExpression* _tmp53_;
		ValaCCodeExpression* _tmp54_;
		ValaCCodeConstant* _tmp55_;
		ValaCCodeConstant* _tmp56_;
		ValaCCodeAssignment* _tmp57_;
		ValaCCodeAssignment* _tmp58_;
		_tmp14_ = value;
		_tmp15_ = vala_ccode_base_module_get_delegate_target_cvalue (self, _tmp14_);
		delegate_target = _tmp15_;
		_tmp16_ = value;
		_tmp17_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp16_);
		delegate_target_destroy_notify = _tmp17_;
		_tmp18_ = delegate_target_destroy_notify;
		_tmp19_ = vala_ccode_function_call_new (_tmp18_);
		ccall = _tmp19_;
		_tmp20_ = ccall;
		_tmp21_ = delegate_target;
		vala_ccode_function_call_add_argument (_tmp20_, _tmp21_);
		_tmp22_ = vala_ccode_comma_expression_new ();
		destroy_call = _tmp22_;
		_tmp23_ = destroy_call;
		_tmp24_ = ccall;
		vala_ccode_comma_expression_append_expression (_tmp23_, (ValaCCodeExpression*) _tmp24_);
		_tmp25_ = destroy_call;
		_tmp26_ = vala_ccode_constant_new ("NULL");
		_tmp27_ = _tmp26_;
		vala_ccode_comma_expression_append_expression (_tmp25_, (ValaCCodeExpression*) _tmp27_);
		_vala_ccode_node_unref0 (_tmp27_);
		_tmp28_ = delegate_target_destroy_notify;
		_tmp29_ = vala_ccode_constant_new ("NULL");
		_tmp30_ = _tmp29_;
		_tmp31_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, _tmp28_, (ValaCCodeExpression*) _tmp30_);
		_tmp32_ = _tmp31_;
		_vala_ccode_node_unref0 (_tmp30_);
		cisnull = _tmp32_;
		_tmp33_ = vala_ccode_comma_expression_new ();
		ccomma = _tmp33_;
		_tmp34_ = ccomma;
		_tmp35_ = cisnull;
		_tmp36_ = vala_ccode_constant_new ("NULL");
		_tmp37_ = _tmp36_;
		_tmp38_ = destroy_call;
		_tmp39_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp35_, (ValaCCodeExpression*) _tmp37_, (ValaCCodeExpression*) _tmp38_);
		_tmp40_ = _tmp39_;
		vala_ccode_comma_expression_append_expression (_tmp34_, (ValaCCodeExpression*) _tmp40_);
		_vala_ccode_node_unref0 (_tmp40_);
		_vala_ccode_node_unref0 (_tmp37_);
		_tmp41_ = ccomma;
		_tmp42_ = cvar;
		_tmp43_ = vala_ccode_constant_new ("NULL");
		_tmp44_ = _tmp43_;
		_tmp45_ = vala_ccode_assignment_new (_tmp42_, (ValaCCodeExpression*) _tmp44_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
		_tmp46_ = _tmp45_;
		vala_ccode_comma_expression_append_expression (_tmp41_, (ValaCCodeExpression*) _tmp46_);
		_vala_ccode_node_unref0 (_tmp46_);
		_vala_ccode_node_unref0 (_tmp44_);
		_tmp47_ = ccomma;
		_tmp48_ = delegate_target;
		_tmp49_ = vala_ccode_constant_new ("NULL");
		_tmp50_ = _tmp49_;
		_tmp51_ = vala_ccode_assignment_new (_tmp48_, (ValaCCodeExpression*) _tmp50_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
		_tmp52_ = _tmp51_;
		vala_ccode_comma_expression_append_expression (_tmp47_, (ValaCCodeExpression*) _tmp52_);
		_vala_ccode_node_unref0 (_tmp52_);
		_vala_ccode_node_unref0 (_tmp50_);
		_tmp53_ = ccomma;
		_tmp54_ = delegate_target_destroy_notify;
		_tmp55_ = vala_ccode_constant_new ("NULL");
		_tmp56_ = _tmp55_;
		_tmp57_ = vala_ccode_assignment_new (_tmp54_, (ValaCCodeExpression*) _tmp56_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
		_tmp58_ = _tmp57_;
		vala_ccode_comma_expression_append_expression (_tmp53_, (ValaCCodeExpression*) _tmp58_);
		_vala_ccode_node_unref0 (_tmp58_);
		_vala_ccode_node_unref0 (_tmp56_);
		result = (ValaCCodeExpression*) ccomma;
		_vala_ccode_node_unref0 (cisnull);
		_vala_ccode_node_unref0 (destroy_call);
		_vala_ccode_node_unref0 (ccall);
		_vala_ccode_node_unref0 (delegate_target_destroy_notify);
		_vala_ccode_node_unref0 (delegate_target);
		_vala_ccode_node_unref0 (cvar);
		_vala_code_node_unref0 (type);
		return result;
	}
	_tmp59_ = type;
	_tmp60_ = vala_ccode_base_module_get_destroy_func_expression (self, _tmp59_, FALSE);
	_tmp61_ = _tmp60_;
	_tmp62_ = vala_ccode_function_call_new (_tmp61_);
	_tmp63_ = _tmp62_;
	_vala_ccode_node_unref0 (_tmp61_);
	ccall = _tmp63_;
	_tmp65_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp65_, VALA_TYPE_VALUE_TYPE)) {
		ValaDataType* _tmp66_;
		gboolean _tmp67_;
		gboolean _tmp68_;
		_tmp66_ = type;
		_tmp67_ = vala_data_type_get_nullable (_tmp66_);
		_tmp68_ = _tmp67_;
		_tmp64_ = !_tmp68_;
	} else {
		_tmp64_ = FALSE;
	}
	if (_tmp64_) {
		ValaStruct* st = NULL;
		ValaDataType* _tmp69_;
		ValaTypeSymbol* _tmp70_;
		ValaTypeSymbol* _tmp71_;
		ValaStruct* _tmp72_;
		gboolean _tmp73_ = FALSE;
		ValaStruct* _tmp74_;
		gboolean _tmp83_ = FALSE;
		ValaStruct* _tmp84_;
		_tmp69_ = type;
		_tmp70_ = vala_data_type_get_data_type (_tmp69_);
		_tmp71_ = _tmp70_;
		_tmp72_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp71_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp71_) : NULL);
		st = _tmp72_;
		_tmp74_ = st;
		if (_tmp74_ != NULL) {
			ValaStruct* _tmp75_;
			gboolean _tmp76_;
			_tmp75_ = st;
			_tmp76_ = vala_struct_is_simple_type (_tmp75_);
			_tmp73_ = _tmp76_;
		} else {
			_tmp73_ = FALSE;
		}
		if (_tmp73_) {
			ValaCCodeFunctionCall* _tmp77_;
			ValaCCodeExpression* _tmp78_;
			_tmp77_ = ccall;
			_tmp78_ = cvar;
			vala_ccode_function_call_add_argument (_tmp77_, _tmp78_);
		} else {
			ValaCCodeFunctionCall* _tmp79_;
			ValaCCodeExpression* _tmp80_;
			ValaCCodeUnaryExpression* _tmp81_;
			ValaCCodeUnaryExpression* _tmp82_;
			_tmp79_ = ccall;
			_tmp80_ = cvar;
			_tmp81_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp80_);
			_tmp82_ = _tmp81_;
			vala_ccode_function_call_add_argument (_tmp79_, (ValaCCodeExpression*) _tmp82_);
			_vala_ccode_node_unref0 (_tmp82_);
		}
		_tmp84_ = self->gvalue_type;
		if (_tmp84_ != NULL) {
			ValaDataType* _tmp85_;
			ValaTypeSymbol* _tmp86_;
			ValaTypeSymbol* _tmp87_;
			ValaStruct* _tmp88_;
			_tmp85_ = type;
			_tmp86_ = vala_data_type_get_data_type (_tmp85_);
			_tmp87_ = _tmp86_;
			_tmp88_ = self->gvalue_type;
			_tmp83_ = _tmp87_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp88_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
		} else {
			_tmp83_ = FALSE;
		}
		if (_tmp83_) {
			ValaCCodeFunctionCall* cisvalid = NULL;
			ValaCCodeIdentifier* _tmp89_;
			ValaCCodeIdentifier* _tmp90_;
			ValaCCodeFunctionCall* _tmp91_;
			ValaCCodeFunctionCall* _tmp92_;
			ValaCCodeFunctionCall* _tmp93_;
			ValaCCodeExpression* _tmp94_;
			ValaCCodeUnaryExpression* _tmp95_;
			ValaCCodeUnaryExpression* _tmp96_;
			ValaCCodeCommaExpression* ccomma = NULL;
			ValaCCodeCommaExpression* _tmp97_;
			ValaCCodeCommaExpression* _tmp98_;
			ValaCCodeFunctionCall* _tmp99_;
			ValaCCodeCommaExpression* _tmp100_;
			ValaCCodeConstant* _tmp101_;
			ValaCCodeConstant* _tmp102_;
			ValaCCodeFunctionCall* _tmp103_;
			ValaCCodeCommaExpression* _tmp104_;
			ValaCCodeConstant* _tmp105_;
			ValaCCodeConstant* _tmp106_;
			ValaCCodeConditionalExpression* _tmp107_;
			ValaCCodeExpression* _tmp108_;
			_tmp89_ = vala_ccode_identifier_new ("G_IS_VALUE");
			_tmp90_ = _tmp89_;
			_tmp91_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp90_);
			_tmp92_ = _tmp91_;
			_vala_ccode_node_unref0 (_tmp90_);
			cisvalid = _tmp92_;
			_tmp93_ = cisvalid;
			_tmp94_ = cvar;
			_tmp95_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp94_);
			_tmp96_ = _tmp95_;
			vala_ccode_function_call_add_argument (_tmp93_, (ValaCCodeExpression*) _tmp96_);
			_vala_ccode_node_unref0 (_tmp96_);
			_tmp97_ = vala_ccode_comma_expression_new ();
			ccomma = _tmp97_;
			_tmp98_ = ccomma;
			_tmp99_ = ccall;
			vala_ccode_comma_expression_append_expression (_tmp98_, (ValaCCodeExpression*) _tmp99_);
			_tmp100_ = ccomma;
			_tmp101_ = vala_ccode_constant_new ("NULL");
			_tmp102_ = _tmp101_;
			vala_ccode_comma_expression_append_expression (_tmp100_, (ValaCCodeExpression*) _tmp102_);
			_vala_ccode_node_unref0 (_tmp102_);
			_tmp103_ = cisvalid;
			_tmp104_ = ccomma;
			_tmp105_ = vala_ccode_constant_new ("NULL");
			_tmp106_ = _tmp105_;
			_tmp107_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp103_, (ValaCCodeExpression*) _tmp104_, (ValaCCodeExpression*) _tmp106_);
			_tmp108_ = (ValaCCodeExpression*) _tmp107_;
			_vala_ccode_node_unref0 (_tmp106_);
			result = _tmp108_;
			_vala_ccode_node_unref0 (ccomma);
			_vala_ccode_node_unref0 (cisvalid);
			_vala_code_node_unref0 (st);
			_vala_ccode_node_unref0 (ccall);
			_vala_ccode_node_unref0 (cvar);
			_vala_code_node_unref0 (type);
			return result;
		} else {
			gboolean _tmp109_ = FALSE;
			gboolean _tmp110_ = FALSE;
			gboolean _tmp111_ = FALSE;
			ValaDataType* _tmp112_;
			ValaTypeSymbol* _tmp113_;
			ValaTypeSymbol* _tmp114_;
			ValaStruct* _tmp115_;
			_tmp112_ = type;
			_tmp113_ = vala_data_type_get_data_type (_tmp112_);
			_tmp114_ = _tmp113_;
			_tmp115_ = self->gmutex_type;
			if (_tmp114_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp115_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) {
				_tmp111_ = TRUE;
			} else {
				ValaDataType* _tmp116_;
				ValaTypeSymbol* _tmp117_;
				ValaTypeSymbol* _tmp118_;
				ValaStruct* _tmp119_;
				_tmp116_ = type;
				_tmp117_ = vala_data_type_get_data_type (_tmp116_);
				_tmp118_ = _tmp117_;
				_tmp119_ = self->grecmutex_type;
				_tmp111_ = _tmp118_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp119_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
			}
			if (_tmp111_) {
				_tmp110_ = TRUE;
			} else {
				ValaDataType* _tmp120_;
				ValaTypeSymbol* _tmp121_;
				ValaTypeSymbol* _tmp122_;
				ValaStruct* _tmp123_;
				_tmp120_ = type;
				_tmp121_ = vala_data_type_get_data_type (_tmp120_);
				_tmp122_ = _tmp121_;
				_tmp123_ = self->grwlock_type;
				_tmp110_ = _tmp122_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp123_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
			}
			if (_tmp110_) {
				_tmp109_ = TRUE;
			} else {
				ValaDataType* _tmp124_;
				ValaTypeSymbol* _tmp125_;
				ValaTypeSymbol* _tmp126_;
				ValaStruct* _tmp127_;
				_tmp124_ = type;
				_tmp125_ = vala_data_type_get_data_type (_tmp124_);
				_tmp126_ = _tmp125_;
				_tmp127_ = self->gcond_type;
				_tmp109_ = _tmp126_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp127_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
			}
			if (_tmp109_) {
				ValaCCodeFunctionCall* _tmp128_;
				ValaDataType* _tmp129_;
				ValaTypeSymbol* _tmp130_;
				ValaTypeSymbol* _tmp131_;
				gchar* _tmp132_;
				gchar* _tmp133_;
				gchar* _tmp134_;
				gchar* _tmp135_;
				ValaCCodeIdentifier* _tmp136_;
				ValaCCodeIdentifier* _tmp137_;
				self->requires_clear_mutex = TRUE;
				_tmp128_ = ccall;
				_tmp129_ = type;
				_tmp130_ = vala_data_type_get_data_type (_tmp129_);
				_tmp131_ = _tmp130_;
				_tmp132_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp131_);
				_tmp133_ = _tmp132_;
				_tmp134_ = g_strconcat ("_vala_clear_", _tmp133_, NULL);
				_tmp135_ = _tmp134_;
				_tmp136_ = vala_ccode_identifier_new (_tmp135_);
				_tmp137_ = _tmp136_;
				vala_ccode_function_call_set_call (_tmp128_, (ValaCCodeExpression*) _tmp137_);
				_vala_ccode_node_unref0 (_tmp137_);
				_g_free0 (_tmp135_);
				_g_free0 (_tmp133_);
				result = (ValaCCodeExpression*) ccall;
				_vala_code_node_unref0 (st);
				_vala_ccode_node_unref0 (cvar);
				_vala_code_node_unref0 (type);
				return result;
			} else {
				result = (ValaCCodeExpression*) ccall;
				_vala_code_node_unref0 (st);
				_vala_ccode_node_unref0 (cvar);
				_vala_code_node_unref0 (type);
				return result;
			}
		}
		_vala_code_node_unref0 (st);
	}
	_tmp140_ = ccall;
	_tmp141_ = vala_ccode_function_call_get_call (_tmp140_);
	_tmp142_ = _tmp141_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp142_, VALA_TYPE_CCODE_IDENTIFIER)) {
		ValaDataType* _tmp143_;
		_tmp143_ = type;
		_tmp139_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp143_, VALA_TYPE_ARRAY_TYPE);
	} else {
		_tmp139_ = FALSE;
	}
	if (_tmp139_) {
		gboolean _tmp144_;
		_tmp144_ = is_macro_definition;
		_tmp138_ = !_tmp144_;
	} else {
		_tmp138_ = FALSE;
	}
	if (_tmp138_) {
		ValaCCodeIdentifier* freeid = NULL;
		ValaCCodeFunctionCall* _tmp145_;
		ValaCCodeExpression* _tmp146_;
		ValaCCodeExpression* _tmp147_;
		ValaCCodeIdentifier* _tmp148_;
		gchar* free0_func = NULL;
		ValaCCodeIdentifier* _tmp149_;
		const gchar* _tmp150_;
		const gchar* _tmp151_;
		gchar* _tmp152_;
		const gchar* _tmp153_;
		gboolean _tmp154_;
		const gchar* _tmp169_;
		ValaCCodeIdentifier* _tmp170_;
		ValaCCodeIdentifier* _tmp171_;
		ValaCCodeFunctionCall* _tmp172_;
		ValaCCodeFunctionCall* _tmp173_;
		ValaCCodeExpression* _tmp174_;
		_tmp145_ = ccall;
		_tmp146_ = vala_ccode_function_call_get_call (_tmp145_);
		_tmp147_ = _tmp146_;
		_tmp148_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp147_, VALA_TYPE_CCODE_IDENTIFIER, ValaCCodeIdentifier));
		freeid = _tmp148_;
		_tmp149_ = freeid;
		_tmp150_ = vala_ccode_identifier_get_name (_tmp149_);
		_tmp151_ = _tmp150_;
		_tmp152_ = g_strdup_printf ("_%s0", _tmp151_);
		free0_func = _tmp152_;
		_tmp153_ = free0_func;
		_tmp154_ = vala_ccode_base_module_add_wrapper (self, _tmp153_);
		if (_tmp154_) {
			ValaCCodeExpression* macro = NULL;
			ValaDataType* _tmp155_;
			ValaCCodeIdentifier* _tmp156_;
			ValaCCodeIdentifier* _tmp157_;
			ValaGLibValue* _tmp158_;
			ValaGLibValue* _tmp159_;
			ValaCCodeExpression* _tmp160_;
			ValaCCodeExpression* _tmp161_;
			ValaCCodeFile* _tmp162_;
			const gchar* _tmp163_;
			gchar* _tmp164_;
			gchar* _tmp165_;
			ValaCCodeExpression* _tmp166_;
			ValaCCodeMacroReplacement* _tmp167_;
			ValaCCodeMacroReplacement* _tmp168_;
			_tmp155_ = type;
			_tmp156_ = vala_ccode_identifier_new ("var");
			_tmp157_ = _tmp156_;
			_tmp158_ = vala_glib_value_new (_tmp155_, (ValaCCodeExpression*) _tmp157_, TRUE);
			_tmp159_ = _tmp158_;
			_tmp160_ = vala_ccode_base_module_destroy_value (self, (ValaTargetValue*) _tmp159_, TRUE);
			_tmp161_ = _tmp160_;
			_vala_target_value_unref0 (_tmp159_);
			_vala_ccode_node_unref0 (_tmp157_);
			macro = _tmp161_;
			_tmp162_ = self->cfile;
			_tmp163_ = free0_func;
			_tmp164_ = g_strdup_printf ("%s(var)", _tmp163_);
			_tmp165_ = _tmp164_;
			_tmp166_ = macro;
			_tmp167_ = vala_ccode_macro_replacement_new_with_expression (_tmp165_, _tmp166_);
			_tmp168_ = _tmp167_;
			vala_ccode_file_add_type_declaration (_tmp162_, (ValaCCodeNode*) _tmp168_);
			_vala_ccode_node_unref0 (_tmp168_);
			_g_free0 (_tmp165_);
			_vala_ccode_node_unref0 (macro);
		}
		_tmp169_ = free0_func;
		_tmp170_ = vala_ccode_identifier_new (_tmp169_);
		_tmp171_ = _tmp170_;
		_tmp172_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp171_);
		_vala_ccode_node_unref0 (ccall);
		ccall = _tmp172_;
		_vala_ccode_node_unref0 (_tmp171_);
		_tmp173_ = ccall;
		_tmp174_ = cvar;
		vala_ccode_function_call_add_argument (_tmp173_, _tmp174_);
		result = (ValaCCodeExpression*) ccall;
		_g_free0 (free0_func);
		_vala_ccode_node_unref0 (freeid);
		_vala_ccode_node_unref0 (cvar);
		_vala_code_node_unref0 (type);
		return result;
	}
	_tmp175_ = cvar;
	_tmp176_ = vala_ccode_constant_new ("NULL");
	_tmp177_ = _tmp176_;
	_tmp178_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, _tmp175_, (ValaCCodeExpression*) _tmp177_);
	_tmp179_ = _tmp178_;
	_vala_ccode_node_unref0 (_tmp177_);
	cisnull = _tmp179_;
	_tmp180_ = type;
	_tmp181_ = vala_data_type_get_type_parameter (_tmp180_);
	_tmp182_ = _tmp181_;
	if (_tmp182_ != NULL) {
		ValaSymbol* parent = NULL;
		ValaDataType* _tmp183_;
		ValaTypeParameter* _tmp184_;
		ValaTypeParameter* _tmp185_;
		ValaSymbol* _tmp186_;
		ValaSymbol* _tmp187_;
		ValaSymbol* _tmp188_;
		ValaClass* cl = NULL;
		ValaSymbol* _tmp189_;
		ValaClass* _tmp190_;
		gboolean _tmp191_ = FALSE;
		gboolean _tmp192_ = FALSE;
		ValaSymbol* _tmp193_;
		ValaCCodeBinaryExpression* cunrefisnull = NULL;
		ValaDataType* _tmp201_;
		ValaCCodeExpression* _tmp202_;
		ValaCCodeExpression* _tmp203_;
		ValaCCodeConstant* _tmp204_;
		ValaCCodeConstant* _tmp205_;
		ValaCCodeBinaryExpression* _tmp206_;
		ValaCCodeBinaryExpression* _tmp207_;
		ValaCCodeBinaryExpression* _tmp208_;
		ValaCCodeBinaryExpression* _tmp209_;
		ValaCCodeBinaryExpression* _tmp210_;
		_tmp183_ = type;
		_tmp184_ = vala_data_type_get_type_parameter (_tmp183_);
		_tmp185_ = _tmp184_;
		_tmp186_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp185_);
		_tmp187_ = _tmp186_;
		_tmp188_ = _vala_code_node_ref0 (_tmp187_);
		parent = _tmp188_;
		_tmp189_ = parent;
		_tmp190_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp189_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp189_) : NULL);
		cl = _tmp190_;
		_tmp193_ = parent;
		if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp193_, VALA_TYPE_METHOD)) {
			ValaSymbol* _tmp194_;
			_tmp194_ = parent;
			_tmp192_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp194_, VALA_TYPE_OBJECT_TYPE_SYMBOL);
		} else {
			_tmp192_ = FALSE;
		}
		if (_tmp192_) {
			_tmp191_ = TRUE;
		} else {
			gboolean _tmp195_ = FALSE;
			ValaClass* _tmp196_;
			_tmp196_ = cl;
			if (_tmp196_ != NULL) {
				ValaClass* _tmp197_;
				gboolean _tmp198_;
				gboolean _tmp199_;
				_tmp197_ = cl;
				_tmp198_ = vala_class_get_is_compact (_tmp197_);
				_tmp199_ = _tmp198_;
				_tmp195_ = _tmp199_;
			} else {
				_tmp195_ = FALSE;
			}
			_tmp191_ = _tmp195_;
		}
		if (_tmp191_) {
			ValaCCodeConstant* _tmp200_;
			_tmp200_ = vala_ccode_constant_new ("NULL");
			result = (ValaCCodeExpression*) _tmp200_;
			_vala_code_node_unref0 (cl);
			_vala_code_node_unref0 (parent);
			_vala_ccode_node_unref0 (cisnull);
			_vala_ccode_node_unref0 (ccall);
			_vala_ccode_node_unref0 (cvar);
			_vala_code_node_unref0 (type);
			return result;
		}
		_tmp201_ = type;
		_tmp202_ = vala_ccode_base_module_get_destroy_func_expression (self, _tmp201_, FALSE);
		_tmp203_ = _tmp202_;
		_tmp204_ = vala_ccode_constant_new ("NULL");
		_tmp205_ = _tmp204_;
		_tmp206_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, _tmp203_, (ValaCCodeExpression*) _tmp205_);
		_tmp207_ = _tmp206_;
		_vala_ccode_node_unref0 (_tmp205_);
		_vala_ccode_node_unref0 (_tmp203_);
		cunrefisnull = _tmp207_;
		_tmp208_ = cisnull;
		_tmp209_ = cunrefisnull;
		_tmp210_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_OR, (ValaCCodeExpression*) _tmp208_, (ValaCCodeExpression*) _tmp209_);
		_vala_ccode_node_unref0 (cisnull);
		cisnull = _tmp210_;
		_vala_ccode_node_unref0 (cunrefisnull);
		_vala_code_node_unref0 (cl);
		_vala_code_node_unref0 (parent);
	}
	_tmp211_ = ccall;
	_tmp212_ = cvar;
	vala_ccode_function_call_add_argument (_tmp211_, _tmp212_);
	_tmp213_ = vala_ccode_comma_expression_new ();
	ccomma = _tmp213_;
	_tmp216_ = type;
	_tmp217_ = vala_data_type_get_data_type (_tmp216_);
	_tmp218_ = _tmp217_;
	if (_tmp218_ != NULL) {
		ValaDataType* _tmp219_;
		ValaTypeSymbol* _tmp220_;
		ValaTypeSymbol* _tmp221_;
		gboolean _tmp222_;
		_tmp219_ = type;
		_tmp220_ = vala_data_type_get_data_type (_tmp219_);
		_tmp221_ = _tmp220_;
		_tmp222_ = vala_ccode_base_module_is_reference_counting (_tmp221_);
		_tmp215_ = !_tmp222_;
	} else {
		_tmp215_ = FALSE;
	}
	if (_tmp215_) {
		gboolean _tmp223_ = FALSE;
		gboolean _tmp224_ = FALSE;
		gboolean _tmp225_ = FALSE;
		ValaDataType* _tmp226_;
		ValaTypeSymbol* _tmp227_;
		ValaTypeSymbol* _tmp228_;
		ValaTypeSymbol* _tmp229_;
		gboolean _tmp230_;
		_tmp226_ = type;
		_tmp227_ = vala_data_type_get_data_type (_tmp226_);
		_tmp228_ = _tmp227_;
		_tmp229_ = self->gstringbuilder_type;
		_tmp230_ = vala_typesymbol_is_subtype_of (_tmp228_, _tmp229_);
		if (_tmp230_) {
			_tmp225_ = TRUE;
		} else {
			ValaDataType* _tmp231_;
			ValaTypeSymbol* _tmp232_;
			ValaTypeSymbol* _tmp233_;
			ValaTypeSymbol* _tmp234_;
			gboolean _tmp235_;
			_tmp231_ = type;
			_tmp232_ = vala_data_type_get_data_type (_tmp231_);
			_tmp233_ = _tmp232_;
			_tmp234_ = self->garray_type;
			_tmp235_ = vala_typesymbol_is_subtype_of (_tmp233_, _tmp234_);
			_tmp225_ = _tmp235_;
		}
		if (_tmp225_) {
			_tmp224_ = TRUE;
		} else {
			ValaDataType* _tmp236_;
			ValaTypeSymbol* _tmp237_;
			ValaTypeSymbol* _tmp238_;
			ValaTypeSymbol* _tmp239_;
			gboolean _tmp240_;
			_tmp236_ = type;
			_tmp237_ = vala_data_type_get_data_type (_tmp236_);
			_tmp238_ = _tmp237_;
			_tmp239_ = self->gbytearray_type;
			_tmp240_ = vala_typesymbol_is_subtype_of (_tmp238_, _tmp239_);
			_tmp224_ = _tmp240_;
		}
		if (_tmp224_) {
			_tmp223_ = TRUE;
		} else {
			ValaDataType* _tmp241_;
			ValaTypeSymbol* _tmp242_;
			ValaTypeSymbol* _tmp243_;
			ValaTypeSymbol* _tmp244_;
			gboolean _tmp245_;
			_tmp241_ = type;
			_tmp242_ = vala_data_type_get_data_type (_tmp241_);
			_tmp243_ = _tmp242_;
			_tmp244_ = self->gptrarray_type;
			_tmp245_ = vala_typesymbol_is_subtype_of (_tmp243_, _tmp244_);
			_tmp223_ = _tmp245_;
		}
		_tmp214_ = _tmp223_;
	} else {
		_tmp214_ = FALSE;
	}
	if (_tmp214_) {
		ValaCCodeFunctionCall* _tmp246_;
		ValaCCodeConstant* _tmp247_;
		ValaCCodeConstant* _tmp248_;
		_tmp246_ = ccall;
		_tmp247_ = vala_ccode_constant_new ("TRUE");
		_tmp248_ = _tmp247_;
		vala_ccode_function_call_add_argument (_tmp246_, (ValaCCodeExpression*) _tmp248_);
		_vala_ccode_node_unref0 (_tmp248_);
	} else {
		ValaDataType* _tmp249_;
		ValaTypeSymbol* _tmp250_;
		ValaTypeSymbol* _tmp251_;
		ValaTypeSymbol* _tmp252_;
		_tmp249_ = type;
		_tmp250_ = vala_data_type_get_data_type (_tmp249_);
		_tmp251_ = _tmp250_;
		_tmp252_ = self->gthreadpool_type;
		if (_tmp251_ == _tmp252_) {
			ValaCCodeFunctionCall* _tmp253_;
			ValaCCodeConstant* _tmp254_;
			ValaCCodeConstant* _tmp255_;
			ValaCCodeFunctionCall* _tmp256_;
			ValaCCodeConstant* _tmp257_;
			ValaCCodeConstant* _tmp258_;
			_tmp253_ = ccall;
			_tmp254_ = vala_ccode_constant_new ("FALSE");
			_tmp255_ = _tmp254_;
			vala_ccode_function_call_add_argument (_tmp253_, (ValaCCodeExpression*) _tmp255_);
			_vala_ccode_node_unref0 (_tmp255_);
			_tmp256_ = ccall;
			_tmp257_ = vala_ccode_constant_new ("TRUE");
			_tmp258_ = _tmp257_;
			vala_ccode_function_call_add_argument (_tmp256_, (ValaCCodeExpression*) _tmp258_);
			_vala_ccode_node_unref0 (_tmp258_);
		} else {
			ValaDataType* _tmp259_;
			_tmp259_ = type;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp259_, VALA_TYPE_ARRAY_TYPE)) {
				ValaArrayType* array_type = NULL;
				ValaDataType* _tmp260_;
				ValaArrayType* _tmp261_;
				ValaArrayType* _tmp262_;
				ValaDataType* _tmp263_;
				ValaDataType* _tmp264_;
				gboolean _tmp265_;
				_tmp260_ = type;
				_tmp261_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp260_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
				array_type = _tmp261_;
				_tmp262_ = array_type;
				_tmp263_ = vala_array_type_get_element_type (_tmp262_);
				_tmp264_ = _tmp263_;
				_tmp265_ = vala_ccode_base_module_requires_destroy (self, _tmp264_);
				if (_tmp265_) {
					ValaCCodeExpression* csizeexpr = NULL;
					ValaTargetValue* _tmp266_;
					ValaList* _tmp267_;
					ValaCCodeExpression* _tmp282_;
					csizeexpr = NULL;
					_tmp266_ = value;
					_tmp267_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp266_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->array_length_cvalues;
					if (_tmp267_ != NULL) {
						ValaTargetValue* _tmp268_;
						ValaCCodeExpression* _tmp269_;
						_tmp268_ = value;
						_tmp269_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp268_, -1);
						_vala_ccode_node_unref0 (csizeexpr);
						csizeexpr = _tmp269_;
					} else {
						ValaTargetValue* _tmp270_;
						gboolean _tmp271_;
						_tmp270_ = value;
						_tmp271_ = vala_ccode_base_module_get_array_null_terminated (self, _tmp270_);
						if (_tmp271_) {
							ValaCCodeFunctionCall* len_call = NULL;
							ValaCCodeIdentifier* _tmp272_;
							ValaCCodeIdentifier* _tmp273_;
							ValaCCodeFunctionCall* _tmp274_;
							ValaCCodeFunctionCall* _tmp275_;
							ValaCCodeFunctionCall* _tmp276_;
							ValaCCodeExpression* _tmp277_;
							ValaCCodeFunctionCall* _tmp278_;
							ValaCCodeExpression* _tmp279_;
							self->requires_array_length = TRUE;
							_tmp272_ = vala_ccode_identifier_new ("_vala_array_length");
							_tmp273_ = _tmp272_;
							_tmp274_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp273_);
							_tmp275_ = _tmp274_;
							_vala_ccode_node_unref0 (_tmp273_);
							len_call = _tmp275_;
							_tmp276_ = len_call;
							_tmp277_ = cvar;
							vala_ccode_function_call_add_argument (_tmp276_, _tmp277_);
							_tmp278_ = len_call;
							_tmp279_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp278_);
							_vala_ccode_node_unref0 (csizeexpr);
							csizeexpr = _tmp279_;
							_vala_ccode_node_unref0 (len_call);
						} else {
							ValaTargetValue* _tmp280_;
							ValaCCodeExpression* _tmp281_;
							_tmp280_ = value;
							_tmp281_ = vala_ccode_base_module_get_array_length_cexpr (self, _tmp280_);
							_vala_ccode_node_unref0 (csizeexpr);
							csizeexpr = _tmp281_;
						}
					}
					_tmp282_ = csizeexpr;
					if (_tmp282_ != NULL) {
						ValaStruct* st = NULL;
						ValaArrayType* _tmp283_;
						ValaDataType* _tmp284_;
						ValaDataType* _tmp285_;
						ValaTypeSymbol* _tmp286_;
						ValaTypeSymbol* _tmp287_;
						ValaStruct* _tmp288_;
						gboolean _tmp289_ = FALSE;
						ValaStruct* _tmp290_;
						_tmp283_ = array_type;
						_tmp284_ = vala_array_type_get_element_type (_tmp283_);
						_tmp285_ = _tmp284_;
						_tmp286_ = vala_data_type_get_data_type (_tmp285_);
						_tmp287_ = _tmp286_;
						_tmp288_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp287_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp287_) : NULL);
						st = _tmp288_;
						_tmp290_ = st;
						if (_tmp290_ != NULL) {
							ValaArrayType* _tmp291_;
							ValaDataType* _tmp292_;
							ValaDataType* _tmp293_;
							gboolean _tmp294_;
							gboolean _tmp295_;
							_tmp291_ = array_type;
							_tmp292_ = vala_array_type_get_element_type (_tmp291_);
							_tmp293_ = _tmp292_;
							_tmp294_ = vala_data_type_get_nullable (_tmp293_);
							_tmp295_ = _tmp294_;
							_tmp289_ = !_tmp295_;
						} else {
							_tmp289_ = FALSE;
						}
						if (_tmp289_) {
							ValaCCodeFunctionCall* _tmp296_;
							ValaStruct* _tmp297_;
							gchar* _tmp298_;
							gchar* _tmp299_;
							ValaCCodeIdentifier* _tmp300_;
							ValaCCodeIdentifier* _tmp301_;
							ValaCCodeFunctionCall* _tmp302_;
							ValaCCodeExpression* _tmp303_;
							_tmp296_ = ccall;
							_tmp297_ = st;
							_tmp298_ = vala_ccode_base_module_append_struct_array_free (self, _tmp297_);
							_tmp299_ = _tmp298_;
							_tmp300_ = vala_ccode_identifier_new (_tmp299_);
							_tmp301_ = _tmp300_;
							vala_ccode_function_call_set_call (_tmp296_, (ValaCCodeExpression*) _tmp301_);
							_vala_ccode_node_unref0 (_tmp301_);
							_g_free0 (_tmp299_);
							_tmp302_ = ccall;
							_tmp303_ = csizeexpr;
							vala_ccode_function_call_add_argument (_tmp302_, _tmp303_);
						} else {
							ValaCCodeFunctionCall* _tmp304_;
							ValaCCodeIdentifier* _tmp305_;
							ValaCCodeIdentifier* _tmp306_;
							ValaCCodeFunctionCall* _tmp307_;
							ValaCCodeExpression* _tmp308_;
							ValaCCodeFunctionCall* _tmp309_;
							ValaArrayType* _tmp310_;
							ValaDataType* _tmp311_;
							ValaDataType* _tmp312_;
							ValaCCodeExpression* _tmp313_;
							ValaCCodeExpression* _tmp314_;
							ValaCCodeCastExpression* _tmp315_;
							ValaCCodeCastExpression* _tmp316_;
							self->requires_array_free = TRUE;
							_tmp304_ = ccall;
							_tmp305_ = vala_ccode_identifier_new ("_vala_array_free");
							_tmp306_ = _tmp305_;
							vala_ccode_function_call_set_call (_tmp304_, (ValaCCodeExpression*) _tmp306_);
							_vala_ccode_node_unref0 (_tmp306_);
							_tmp307_ = ccall;
							_tmp308_ = csizeexpr;
							vala_ccode_function_call_add_argument (_tmp307_, _tmp308_);
							_tmp309_ = ccall;
							_tmp310_ = array_type;
							_tmp311_ = vala_array_type_get_element_type (_tmp310_);
							_tmp312_ = _tmp311_;
							_tmp313_ = vala_ccode_base_module_get_destroy_func_expression (self, _tmp312_, FALSE);
							_tmp314_ = _tmp313_;
							_tmp315_ = vala_ccode_cast_expression_new (_tmp314_, "GDestroyNotify");
							_tmp316_ = _tmp315_;
							vala_ccode_function_call_add_argument (_tmp309_, (ValaCCodeExpression*) _tmp316_);
							_vala_ccode_node_unref0 (_tmp316_);
							_vala_ccode_node_unref0 (_tmp314_);
						}
						_vala_code_node_unref0 (st);
					}
					_vala_ccode_node_unref0 (csizeexpr);
				}
				_vala_code_node_unref0 (array_type);
			}
		}
	}
	_tmp317_ = ccomma;
	_tmp318_ = ccall;
	vala_ccode_comma_expression_append_expression (_tmp317_, (ValaCCodeExpression*) _tmp318_);
	_tmp319_ = ccomma;
	_tmp320_ = vala_ccode_constant_new ("NULL");
	_tmp321_ = _tmp320_;
	vala_ccode_comma_expression_append_expression (_tmp319_, (ValaCCodeExpression*) _tmp321_);
	_vala_ccode_node_unref0 (_tmp321_);
	_tmp322_ = cvar;
	_tmp323_ = ccomma;
	_tmp324_ = vala_ccode_assignment_new (_tmp322_, (ValaCCodeExpression*) _tmp323_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
	cassign = _tmp324_;
	_tmp327_ = type;
	_tmp328_ = vala_data_type_get_data_type (_tmp327_);
	_tmp329_ = _tmp328_;
	if (_tmp329_ != NULL) {
		ValaDataType* _tmp330_;
		ValaTypeSymbol* _tmp331_;
		ValaTypeSymbol* _tmp332_;
		gboolean _tmp333_;
		_tmp330_ = type;
		_tmp331_ = vala_data_type_get_data_type (_tmp330_);
		_tmp332_ = _tmp331_;
		_tmp333_ = vala_ccode_base_module_is_reference_counting (_tmp332_);
		_tmp326_ = !_tmp333_;
	} else {
		_tmp326_ = FALSE;
	}
	if (_tmp326_) {
		ValaDataType* _tmp334_;
		ValaTypeSymbol* _tmp335_;
		ValaTypeSymbol* _tmp336_;
		gchar* _tmp337_;
		gchar* _tmp338_;
		_tmp334_ = type;
		_tmp335_ = vala_data_type_get_data_type (_tmp334_);
		_tmp336_ = _tmp335_;
		_tmp337_ = vala_ccode_base_module_get_ccode_free_function (_tmp336_);
		_tmp338_ = _tmp337_;
		_tmp325_ = g_strcmp0 (_tmp338_, "g_free") == 0;
		_g_free0 (_tmp338_);
	} else {
		_tmp325_ = FALSE;
	}
	uses_gfree = _tmp325_;
	_tmp340_ = uses_gfree;
	if (_tmp340_) {
		_tmp339_ = TRUE;
	} else {
		ValaDataType* _tmp341_;
		_tmp341_ = type;
		_tmp339_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp341_, VALA_TYPE_ARRAY_TYPE);
	}
	uses_gfree = _tmp339_;
	_tmp342_ = uses_gfree;
	if (_tmp342_) {
		result = (ValaCCodeExpression*) cassign;
		_vala_ccode_node_unref0 (ccomma);
		_vala_ccode_node_unref0 (cisnull);
		_vala_ccode_node_unref0 (ccall);
		_vala_ccode_node_unref0 (cvar);
		_vala_code_node_unref0 (type);
		return result;
	}
	_tmp343_ = cisnull;
	_tmp344_ = vala_ccode_constant_new ("NULL");
	_tmp345_ = _tmp344_;
	_tmp346_ = cassign;
	_tmp347_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp343_, (ValaCCodeExpression*) _tmp345_, (ValaCCodeExpression*) _tmp346_);
	_tmp348_ = (ValaCCodeExpression*) _tmp347_;
	_vala_ccode_node_unref0 (_tmp345_);
	result = _tmp348_;
	_vala_ccode_node_unref0 (cassign);
	_vala_ccode_node_unref0 (ccomma);
	_vala_ccode_node_unref0 (cisnull);
	_vala_ccode_node_unref0 (ccall);
	_vala_ccode_node_unref0 (cvar);
	_vala_code_node_unref0 (type);
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->destroy_value (self, value, is_macro_definition);
}


static void vala_ccode_base_module_real_visit_end_full_expression (ValaCodeVisitor* base, ValaExpression* expr) {
	ValaCCodeBaseModule * self;
	ValaArrayList* _tmp0_;
	ValaArrayList* _tmp1_;
	gint _tmp2_;
	gint _tmp3_;
	ValaLocalVariable* local_decl = NULL;
	ValaExpression* _tmp4_;
	ValaCodeNode* _tmp5_;
	ValaCodeNode* _tmp6_;
	ValaLocalVariable* _tmp7_;
	gboolean _tmp8_ = FALSE;
	ValaLocalVariable* _tmp9_;
	ValaArrayList* _tmp39_;
	ValaArrayList* _tmp40_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = vala_ccode_base_module_get_temp_ref_values (self);
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_collection_get_size ((ValaCollection*) _tmp1_);
	_tmp3_ = _tmp2_;
	if (_tmp3_ == 0) {
		return;
	}
	_tmp4_ = expr;
	_tmp5_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp6_) : NULL);
	local_decl = _tmp7_;
	_tmp9_ = local_decl;
	if (_tmp9_ != NULL) {
		ValaLocalVariable* _tmp10_;
		ValaLocalVariable* _tmp11_;
		ValaExpression* _tmp12_;
		ValaExpression* _tmp13_;
		gboolean _tmp14_;
		_tmp10_ = local_decl;
		_tmp11_ = local_decl;
		_tmp12_ = vala_variable_get_initializer ((ValaVariable*) _tmp11_);
		_tmp13_ = _tmp12_;
		_tmp14_ = vala_ccode_base_module_is_simple_struct_creation (self, (ValaVariable*) _tmp10_, _tmp13_);
		_tmp8_ = _tmp14_;
	} else {
		_tmp8_ = FALSE;
	}
	if (!_tmp8_) {
		ValaExpression* _tmp15_;
		ValaExpression* _tmp16_;
		ValaTargetValue* _tmp17_;
		ValaTargetValue* _tmp18_;
		ValaExpression* _tmp19_;
		ValaTargetValue* _tmp20_;
		ValaTargetValue* _tmp21_;
		_tmp15_ = expr;
		_tmp16_ = expr;
		_tmp17_ = vala_expression_get_target_value (_tmp16_);
		_tmp18_ = _tmp17_;
		_tmp19_ = expr;
		_tmp20_ = vala_ccode_base_module_store_temp_value (self, _tmp18_, (ValaCodeNode*) _tmp19_, NULL);
		_tmp21_ = _tmp20_;
		vala_expression_set_target_value (_tmp15_, _tmp21_);
		_vala_target_value_unref0 (_tmp21_);
	}
	{
		ValaArrayList* _value_list = NULL;
		ValaArrayList* _tmp22_;
		ValaArrayList* _tmp23_;
		ValaArrayList* _tmp24_;
		gint _value_size = 0;
		ValaArrayList* _tmp25_;
		gint _tmp26_;
		gint _tmp27_;
		gint _value_index = 0;
		_tmp22_ = vala_ccode_base_module_get_temp_ref_values (self);
		_tmp23_ = _tmp22_;
		_tmp24_ = _vala_iterable_ref0 (_tmp23_);
		_value_list = _tmp24_;
		_tmp25_ = _value_list;
		_tmp26_ = vala_collection_get_size ((ValaCollection*) _tmp25_);
		_tmp27_ = _tmp26_;
		_value_size = _tmp27_;
		_value_index = -1;
		while (TRUE) {
			gint _tmp28_;
			gint _tmp29_;
			gint _tmp30_;
			ValaTargetValue* value = NULL;
			ValaArrayList* _tmp31_;
			gint _tmp32_;
			gpointer _tmp33_;
			ValaCCodeFunction* _tmp34_;
			ValaCCodeFunction* _tmp35_;
			ValaTargetValue* _tmp36_;
			ValaCCodeExpression* _tmp37_;
			ValaCCodeExpression* _tmp38_;
			_tmp28_ = _value_index;
			_value_index = _tmp28_ + 1;
			_tmp29_ = _value_index;
			_tmp30_ = _value_size;
			if (!(_tmp29_ < _tmp30_)) {
				break;
			}
			_tmp31_ = _value_list;
			_tmp32_ = _value_index;
			_tmp33_ = vala_list_get ((ValaList*) _tmp31_, _tmp32_);
			value = (ValaTargetValue*) _tmp33_;
			_tmp34_ = vala_ccode_base_module_get_ccode (self);
			_tmp35_ = _tmp34_;
			_tmp36_ = value;
			_tmp37_ = vala_ccode_base_module_destroy_value (self, _tmp36_, FALSE);
			_tmp38_ = _tmp37_;
			vala_ccode_function_add_expression (_tmp35_, _tmp38_);
			_vala_ccode_node_unref0 (_tmp38_);
			_vala_target_value_unref0 (value);
		}
		_vala_iterable_unref0 (_value_list);
	}
	_tmp39_ = vala_ccode_base_module_get_temp_ref_values (self);
	_tmp40_ = _tmp39_;
	vala_collection_clear ((ValaCollection*) _tmp40_);
	_vala_code_node_unref0 (local_decl);
}


void vala_ccode_base_module_emit_temp_var (ValaCCodeBaseModule* self, ValaLocalVariable* local) {
	gboolean _tmp0_ = FALSE;
	ValaLocalVariable* _tmp1_;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	gboolean _tmp4_;
	gboolean init = FALSE;
	gboolean _tmp8_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (local != NULL);
	_tmp1_ = local;
	_tmp2_ = vala_symbol_get_name ((ValaSymbol*) _tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = g_str_has_prefix (_tmp3_, "*");
	if (!_tmp4_) {
		ValaLocalVariable* _tmp5_;
		gboolean _tmp6_;
		gboolean _tmp7_;
		_tmp5_ = local;
		_tmp6_ = vala_local_variable_get_init (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp0_ = _tmp7_;
	} else {
		_tmp0_ = FALSE;
	}
	init = _tmp0_;
	_tmp8_ = vala_ccode_base_module_is_in_coroutine (self);
	if (_tmp8_) {
		ValaCCodeStruct* _tmp9_;
		ValaLocalVariable* _tmp10_;
		ValaDataType* _tmp11_;
		ValaDataType* _tmp12_;
		gchar* _tmp13_;
		gchar* _tmp14_;
		ValaLocalVariable* _tmp15_;
		const gchar* _tmp16_;
		const gchar* _tmp17_;
		gboolean _tmp18_;
		_tmp9_ = self->closure_struct;
		_tmp10_ = local;
		_tmp11_ = vala_variable_get_variable_type ((ValaVariable*) _tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp12_);
		_tmp14_ = _tmp13_;
		_tmp15_ = local;
		_tmp16_ = vala_symbol_get_name ((ValaSymbol*) _tmp15_);
		_tmp17_ = _tmp16_;
		vala_ccode_struct_add_field (_tmp9_, _tmp14_, _tmp17_, 0, NULL);
		_g_free0 (_tmp14_);
		_tmp18_ = init;
		if (_tmp18_) {
			ValaCCodeExpression* initializer = NULL;
			ValaLocalVariable* _tmp19_;
			ValaDataType* _tmp20_;
			ValaDataType* _tmp21_;
			ValaCCodeExpression* _tmp22_;
			ValaCCodeExpression* _tmp23_;
			_tmp19_ = local;
			_tmp20_ = vala_variable_get_variable_type ((ValaVariable*) _tmp19_);
			_tmp21_ = _tmp20_;
			_tmp22_ = vala_ccode_base_module_default_value_for_type (self, _tmp21_, FALSE);
			initializer = _tmp22_;
			_tmp23_ = initializer;
			if (_tmp23_ == NULL) {
				ValaCCodeFile* _tmp24_;
				ValaCCodeFunctionCall* memset_call = NULL;
				ValaCCodeIdentifier* _tmp25_;
				ValaCCodeIdentifier* _tmp26_;
				ValaCCodeFunctionCall* _tmp27_;
				ValaCCodeFunctionCall* _tmp28_;
				ValaCCodeFunctionCall* _tmp29_;
				ValaLocalVariable* _tmp30_;
				const gchar* _tmp31_;
				const gchar* _tmp32_;
				ValaCCodeExpression* _tmp33_;
				ValaCCodeExpression* _tmp34_;
				ValaCCodeUnaryExpression* _tmp35_;
				ValaCCodeUnaryExpression* _tmp36_;
				ValaCCodeFunctionCall* _tmp37_;
				ValaCCodeConstant* _tmp38_;
				ValaCCodeConstant* _tmp39_;
				ValaCCodeFunctionCall* _tmp40_;
				ValaLocalVariable* _tmp41_;
				ValaDataType* _tmp42_;
				ValaDataType* _tmp43_;
				gchar* _tmp44_;
				gchar* _tmp45_;
				gchar* _tmp46_;
				gchar* _tmp47_;
				ValaCCodeIdentifier* _tmp48_;
				ValaCCodeIdentifier* _tmp49_;
				ValaCCodeFunction* _tmp50_;
				ValaCCodeFunction* _tmp51_;
				ValaCCodeFunctionCall* _tmp52_;
				_tmp24_ = self->cfile;
				vala_ccode_file_add_include (_tmp24_, "string.h", FALSE);
				_tmp25_ = vala_ccode_identifier_new ("memset");
				_tmp26_ = _tmp25_;
				_tmp27_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp26_);
				_tmp28_ = _tmp27_;
				_vala_ccode_node_unref0 (_tmp26_);
				memset_call = _tmp28_;
				_tmp29_ = memset_call;
				_tmp30_ = local;
				_tmp31_ = vala_symbol_get_name ((ValaSymbol*) _tmp30_);
				_tmp32_ = _tmp31_;
				_tmp33_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp32_);
				_tmp34_ = _tmp33_;
				_tmp35_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp34_);
				_tmp36_ = _tmp35_;
				vala_ccode_function_call_add_argument (_tmp29_, (ValaCCodeExpression*) _tmp36_);
				_vala_ccode_node_unref0 (_tmp36_);
				_vala_ccode_node_unref0 (_tmp34_);
				_tmp37_ = memset_call;
				_tmp38_ = vala_ccode_constant_new ("0");
				_tmp39_ = _tmp38_;
				vala_ccode_function_call_add_argument (_tmp37_, (ValaCCodeExpression*) _tmp39_);
				_vala_ccode_node_unref0 (_tmp39_);
				_tmp40_ = memset_call;
				_tmp41_ = local;
				_tmp42_ = vala_variable_get_variable_type ((ValaVariable*) _tmp41_);
				_tmp43_ = _tmp42_;
				_tmp44_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp43_);
				_tmp45_ = _tmp44_;
				_tmp46_ = g_strdup_printf ("sizeof (%s)", _tmp45_);
				_tmp47_ = _tmp46_;
				_tmp48_ = vala_ccode_identifier_new (_tmp47_);
				_tmp49_ = _tmp48_;
				vala_ccode_function_call_add_argument (_tmp40_, (ValaCCodeExpression*) _tmp49_);
				_vala_ccode_node_unref0 (_tmp49_);
				_g_free0 (_tmp47_);
				_g_free0 (_tmp45_);
				_tmp50_ = vala_ccode_base_module_get_ccode (self);
				_tmp51_ = _tmp50_;
				_tmp52_ = memset_call;
				vala_ccode_function_add_expression (_tmp51_, (ValaCCodeExpression*) _tmp52_);
				_vala_ccode_node_unref0 (memset_call);
			} else {
				ValaCCodeFunction* _tmp53_;
				ValaCCodeFunction* _tmp54_;
				ValaLocalVariable* _tmp55_;
				const gchar* _tmp56_;
				const gchar* _tmp57_;
				ValaCCodeExpression* _tmp58_;
				ValaCCodeExpression* _tmp59_;
				ValaCCodeExpression* _tmp60_;
				_tmp53_ = vala_ccode_base_module_get_ccode (self);
				_tmp54_ = _tmp53_;
				_tmp55_ = local;
				_tmp56_ = vala_symbol_get_name ((ValaSymbol*) _tmp55_);
				_tmp57_ = _tmp56_;
				_tmp58_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp57_);
				_tmp59_ = _tmp58_;
				_tmp60_ = initializer;
				vala_ccode_function_add_assignment (_tmp54_, _tmp59_, _tmp60_);
				_vala_ccode_node_unref0 (_tmp59_);
			}
			_vala_ccode_node_unref0 (initializer);
		}
	} else {
		ValaCCodeVariableDeclarator* cvar = NULL;
		ValaLocalVariable* _tmp61_;
		const gchar* _tmp62_;
		const gchar* _tmp63_;
		ValaLocalVariable* _tmp64_;
		ValaDataType* _tmp65_;
		ValaDataType* _tmp66_;
		ValaCCodeDeclaratorSuffix* _tmp67_;
		ValaCCodeDeclaratorSuffix* _tmp68_;
		ValaCCodeVariableDeclarator* _tmp69_;
		ValaCCodeVariableDeclarator* _tmp70_;
		gboolean _tmp71_;
		ValaCCodeFunction* _tmp79_;
		ValaCCodeFunction* _tmp80_;
		ValaLocalVariable* _tmp81_;
		ValaDataType* _tmp82_;
		ValaDataType* _tmp83_;
		gchar* _tmp84_;
		gchar* _tmp85_;
		ValaCCodeVariableDeclarator* _tmp86_;
		_tmp61_ = local;
		_tmp62_ = vala_symbol_get_name ((ValaSymbol*) _tmp61_);
		_tmp63_ = _tmp62_;
		_tmp64_ = local;
		_tmp65_ = vala_variable_get_variable_type ((ValaVariable*) _tmp64_);
		_tmp66_ = _tmp65_;
		_tmp67_ = vala_ccode_base_module_get_ccode_declarator_suffix (self, _tmp66_);
		_tmp68_ = _tmp67_;
		_tmp69_ = vala_ccode_variable_declarator_new (_tmp63_, NULL, _tmp68_);
		_tmp70_ = _tmp69_;
		_vala_ccode_declarator_suffix_unref0 (_tmp68_);
		cvar = _tmp70_;
		_tmp71_ = init;
		if (_tmp71_) {
			ValaCCodeVariableDeclarator* _tmp72_;
			ValaLocalVariable* _tmp73_;
			ValaDataType* _tmp74_;
			ValaDataType* _tmp75_;
			ValaCCodeExpression* _tmp76_;
			ValaCCodeExpression* _tmp77_;
			ValaCCodeVariableDeclarator* _tmp78_;
			_tmp72_ = cvar;
			_tmp73_ = local;
			_tmp74_ = vala_variable_get_variable_type ((ValaVariable*) _tmp73_);
			_tmp75_ = _tmp74_;
			_tmp76_ = vala_ccode_base_module_default_value_for_type (self, _tmp75_, TRUE);
			_tmp77_ = _tmp76_;
			vala_ccode_variable_declarator_set_initializer (_tmp72_, _tmp77_);
			_vala_ccode_node_unref0 (_tmp77_);
			_tmp78_ = cvar;
			vala_ccode_variable_declarator_set_init0 (_tmp78_, TRUE);
		}
		_tmp79_ = vala_ccode_base_module_get_ccode (self);
		_tmp80_ = _tmp79_;
		_tmp81_ = local;
		_tmp82_ = vala_variable_get_variable_type ((ValaVariable*) _tmp81_);
		_tmp83_ = _tmp82_;
		_tmp84_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp83_);
		_tmp85_ = _tmp84_;
		_tmp86_ = cvar;
		vala_ccode_function_add_declaration (_tmp80_, _tmp85_, (ValaCCodeDeclarator*) _tmp86_, 0);
		_g_free0 (_tmp85_);
		_vala_ccode_node_unref0 (cvar);
	}
}


static void vala_ccode_base_module_real_visit_expression_statement (ValaCodeVisitor* base, ValaExpressionStatement* stmt) {
	ValaCCodeBaseModule * self;
	ValaExpressionStatement* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp23_ = FALSE;
	ValaExpressionStatement* _tmp24_;
	gboolean _tmp25_;
	gboolean _tmp26_;
	ValaArrayList* _tmp35_;
	ValaArrayList* _tmp36_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (stmt != NULL);
	_tmp0_ = stmt;
	_tmp1_ = vala_expression_statement_get_expression (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_code_node_get_error ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	if (_tmp4_) {
		ValaExpressionStatement* _tmp5_;
		_tmp5_ = stmt;
		vala_code_node_set_error ((ValaCodeNode*) _tmp5_, TRUE);
		return;
	}
	{
		ValaArrayList* _value_list = NULL;
		ValaArrayList* _tmp6_;
		ValaArrayList* _tmp7_;
		ValaArrayList* _tmp8_;
		gint _value_size = 0;
		ValaArrayList* _tmp9_;
		gint _tmp10_;
		gint _tmp11_;
		gint _value_index = 0;
		_tmp6_ = vala_ccode_base_module_get_temp_ref_values (self);
		_tmp7_ = _tmp6_;
		_tmp8_ = _vala_iterable_ref0 (_tmp7_);
		_value_list = _tmp8_;
		_tmp9_ = _value_list;
		_tmp10_ = vala_collection_get_size ((ValaCollection*) _tmp9_);
		_tmp11_ = _tmp10_;
		_value_size = _tmp11_;
		_value_index = -1;
		while (TRUE) {
			gint _tmp12_;
			gint _tmp13_;
			gint _tmp14_;
			ValaTargetValue* value = NULL;
			ValaArrayList* _tmp15_;
			gint _tmp16_;
			gpointer _tmp17_;
			ValaCCodeFunction* _tmp18_;
			ValaCCodeFunction* _tmp19_;
			ValaTargetValue* _tmp20_;
			ValaCCodeExpression* _tmp21_;
			ValaCCodeExpression* _tmp22_;
			_tmp12_ = _value_index;
			_value_index = _tmp12_ + 1;
			_tmp13_ = _value_index;
			_tmp14_ = _value_size;
			if (!(_tmp13_ < _tmp14_)) {
				break;
			}
			_tmp15_ = _value_list;
			_tmp16_ = _value_index;
			_tmp17_ = vala_list_get ((ValaList*) _tmp15_, _tmp16_);
			value = (ValaTargetValue*) _tmp17_;
			_tmp18_ = vala_ccode_base_module_get_ccode (self);
			_tmp19_ = _tmp18_;
			_tmp20_ = value;
			_tmp21_ = vala_ccode_base_module_destroy_value (self, _tmp20_, FALSE);
			_tmp22_ = _tmp21_;
			vala_ccode_function_add_expression (_tmp19_, _tmp22_);
			_vala_ccode_node_unref0 (_tmp22_);
			_vala_target_value_unref0 (value);
		}
		_vala_iterable_unref0 (_value_list);
	}
	_tmp24_ = stmt;
	_tmp25_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp24_);
	_tmp26_ = _tmp25_;
	if (_tmp26_) {
		ValaExpressionStatement* _tmp27_;
		ValaExpression* _tmp28_;
		ValaExpression* _tmp29_;
		gboolean _tmp30_;
		gboolean _tmp31_;
		_tmp27_ = stmt;
		_tmp28_ = vala_expression_statement_get_expression (_tmp27_);
		_tmp29_ = _tmp28_;
		_tmp30_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp29_);
		_tmp31_ = _tmp30_;
		_tmp23_ = _tmp31_;
	} else {
		_tmp23_ = FALSE;
	}
	if (_tmp23_) {
		ValaExpressionStatement* _tmp32_;
		ValaExpression* _tmp33_;
		ValaExpression* _tmp34_;
		_tmp32_ = stmt;
		_tmp33_ = vala_expression_statement_get_expression (_tmp32_);
		_tmp34_ = _tmp33_;
		vala_ccode_base_module_add_simple_check (self, (ValaCodeNode*) _tmp34_, FALSE);
	}
	_tmp35_ = vala_ccode_base_module_get_temp_ref_values (self);
	_tmp36_ = _tmp35_;
	vala_collection_clear ((ValaCollection*) _tmp36_);
}


static void vala_ccode_base_module_real_append_scope_free (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at) {
	ValaBlock* b = NULL;
	ValaSymbol* _tmp0_;
	ValaBlock* _tmp1_;
	ValaList* local_vars = NULL;
	ValaBlock* _tmp2_;
	ValaList* _tmp3_;
	ValaBlock* _tmp34_;
	gboolean _tmp35_;
	gboolean _tmp36_;
	g_return_if_fail (sym != NULL);
	_tmp0_ = sym;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_BLOCK, ValaBlock));
	b = _tmp1_;
	_tmp2_ = b;
	_tmp3_ = vala_block_get_local_variables (_tmp2_);
	local_vars = _tmp3_;
	{
		gint i = 0;
		ValaList* _tmp4_;
		gint _tmp5_;
		gint _tmp6_;
		_tmp4_ = local_vars;
		_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
		_tmp6_ = _tmp5_;
		i = _tmp6_ - 1;
		{
			gboolean _tmp7_ = FALSE;
			_tmp7_ = TRUE;
			while (TRUE) {
				gint _tmp9_;
				ValaLocalVariable* local = NULL;
				ValaList* _tmp10_;
				gint _tmp11_;
				gpointer _tmp12_;
				gboolean _tmp13_ = FALSE;
				gboolean _tmp14_ = FALSE;
				gboolean _tmp15_ = FALSE;
				ValaLocalVariable* _tmp16_;
				gboolean _tmp17_;
				gboolean _tmp18_;
				if (!_tmp7_) {
					gint _tmp8_;
					_tmp8_ = i;
					i = _tmp8_ - 1;
				}
				_tmp7_ = FALSE;
				_tmp9_ = i;
				if (!(_tmp9_ >= 0)) {
					break;
				}
				_tmp10_ = local_vars;
				_tmp11_ = i;
				_tmp12_ = vala_list_get (_tmp10_, _tmp11_);
				local = (ValaLocalVariable*) _tmp12_;
				_tmp16_ = local;
				_tmp17_ = vala_code_node_get_unreachable ((ValaCodeNode*) _tmp16_);
				_tmp18_ = _tmp17_;
				if (!_tmp18_) {
					ValaLocalVariable* _tmp19_;
					gboolean _tmp20_;
					gboolean _tmp21_;
					_tmp19_ = local;
					_tmp20_ = vala_symbol_get_active ((ValaSymbol*) _tmp19_);
					_tmp21_ = _tmp20_;
					_tmp15_ = _tmp21_;
				} else {
					_tmp15_ = FALSE;
				}
				if (_tmp15_) {
					ValaLocalVariable* _tmp22_;
					gboolean _tmp23_;
					gboolean _tmp24_;
					_tmp22_ = local;
					_tmp23_ = vala_local_variable_get_captured (_tmp22_);
					_tmp24_ = _tmp23_;
					_tmp14_ = !_tmp24_;
				} else {
					_tmp14_ = FALSE;
				}
				if (_tmp14_) {
					ValaLocalVariable* _tmp25_;
					ValaDataType* _tmp26_;
					ValaDataType* _tmp27_;
					gboolean _tmp28_;
					_tmp25_ = local;
					_tmp26_ = vala_variable_get_variable_type ((ValaVariable*) _tmp25_);
					_tmp27_ = _tmp26_;
					_tmp28_ = vala_ccode_base_module_requires_destroy (self, _tmp27_);
					_tmp13_ = _tmp28_;
				} else {
					_tmp13_ = FALSE;
				}
				if (_tmp13_) {
					ValaCCodeFunction* _tmp29_;
					ValaCCodeFunction* _tmp30_;
					ValaLocalVariable* _tmp31_;
					ValaCCodeExpression* _tmp32_;
					ValaCCodeExpression* _tmp33_;
					_tmp29_ = vala_ccode_base_module_get_ccode (self);
					_tmp30_ = _tmp29_;
					_tmp31_ = local;
					_tmp32_ = vala_ccode_base_module_destroy_local (self, _tmp31_);
					_tmp33_ = _tmp32_;
					vala_ccode_function_add_expression (_tmp30_, _tmp33_);
					_vala_ccode_node_unref0 (_tmp33_);
				}
				_vala_code_node_unref0 (local);
			}
		}
	}
	_tmp34_ = b;
	_tmp35_ = vala_block_get_captured (_tmp34_);
	_tmp36_ = _tmp35_;
	if (_tmp36_) {
		gint block_id = 0;
		ValaBlock* _tmp37_;
		gint _tmp38_;
		ValaCCodeFunctionCall* data_unref = NULL;
		gint _tmp39_;
		gchar* _tmp40_;
		gchar* _tmp41_;
		ValaCCodeIdentifier* _tmp42_;
		ValaCCodeIdentifier* _tmp43_;
		ValaCCodeFunctionCall* _tmp44_;
		ValaCCodeFunctionCall* _tmp45_;
		ValaCCodeFunctionCall* _tmp46_;
		gint _tmp47_;
		gchar* _tmp48_;
		gchar* _tmp49_;
		ValaCCodeExpression* _tmp50_;
		ValaCCodeExpression* _tmp51_;
		ValaCCodeFunction* _tmp52_;
		ValaCCodeFunction* _tmp53_;
		ValaCCodeFunctionCall* _tmp54_;
		ValaCCodeFunction* _tmp55_;
		ValaCCodeFunction* _tmp56_;
		gint _tmp57_;
		gchar* _tmp58_;
		gchar* _tmp59_;
		ValaCCodeExpression* _tmp60_;
		ValaCCodeExpression* _tmp61_;
		ValaCCodeConstant* _tmp62_;
		ValaCCodeConstant* _tmp63_;
		_tmp37_ = b;
		_tmp38_ = vala_ccode_base_module_get_block_id (self, _tmp37_);
		block_id = _tmp38_;
		_tmp39_ = block_id;
		_tmp40_ = g_strdup_printf ("block%d_data_unref", _tmp39_);
		_tmp41_ = _tmp40_;
		_tmp42_ = vala_ccode_identifier_new (_tmp41_);
		_tmp43_ = _tmp42_;
		_tmp44_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp43_);
		_tmp45_ = _tmp44_;
		_vala_ccode_node_unref0 (_tmp43_);
		_g_free0 (_tmp41_);
		data_unref = _tmp45_;
		_tmp46_ = data_unref;
		_tmp47_ = block_id;
		_tmp48_ = g_strdup_printf ("_data%d_", _tmp47_);
		_tmp49_ = _tmp48_;
		_tmp50_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp49_);
		_tmp51_ = _tmp50_;
		vala_ccode_function_call_add_argument (_tmp46_, _tmp51_);
		_vala_ccode_node_unref0 (_tmp51_);
		_g_free0 (_tmp49_);
		_tmp52_ = vala_ccode_base_module_get_ccode (self);
		_tmp53_ = _tmp52_;
		_tmp54_ = data_unref;
		vala_ccode_function_add_expression (_tmp53_, (ValaCCodeExpression*) _tmp54_);
		_tmp55_ = vala_ccode_base_module_get_ccode (self);
		_tmp56_ = _tmp55_;
		_tmp57_ = block_id;
		_tmp58_ = g_strdup_printf ("_data%d_", _tmp57_);
		_tmp59_ = _tmp58_;
		_tmp60_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp59_);
		_tmp61_ = _tmp60_;
		_tmp62_ = vala_ccode_constant_new ("NULL");
		_tmp63_ = _tmp62_;
		vala_ccode_function_add_assignment (_tmp56_, _tmp61_, (ValaCCodeExpression*) _tmp63_);
		_vala_ccode_node_unref0 (_tmp63_);
		_vala_ccode_node_unref0 (_tmp61_);
		_g_free0 (_tmp59_);
		_vala_ccode_node_unref0 (data_unref);
	}
	_vala_iterable_unref0 (local_vars);
	_vala_code_node_unref0 (b);
}


void vala_ccode_base_module_append_scope_free (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->append_scope_free (self, sym, stop_at);
}


void vala_ccode_base_module_append_local_free (ValaCCodeBaseModule* self, ValaSymbol* sym, gboolean stop_at_loop, ValaCodeNode* stop_at) {
	ValaBlock* b = NULL;
	ValaSymbol* _tmp0_;
	ValaBlock* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaCodeNode* _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp16_ = FALSE;
	ValaCodeNode* _tmp17_;
	ValaSymbol* _tmp22_;
	ValaSymbol* _tmp23_;
	ValaSymbol* _tmp24_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (sym != NULL);
	_tmp0_ = sym;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_BLOCK, ValaBlock));
	b = _tmp1_;
	_tmp2_ = sym;
	_tmp3_ = stop_at;
	vala_ccode_base_module_append_scope_free (self, _tmp2_, _tmp3_);
	_tmp4_ = stop_at_loop;
	if (_tmp4_) {
		gboolean _tmp5_ = FALSE;
		gboolean _tmp6_ = FALSE;
		ValaBlock* _tmp7_;
		ValaCodeNode* _tmp8_;
		ValaCodeNode* _tmp9_;
		_tmp7_ = b;
		_tmp8_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp7_);
		_tmp9_ = _tmp8_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_LOOP)) {
			_tmp6_ = TRUE;
		} else {
			ValaBlock* _tmp10_;
			ValaCodeNode* _tmp11_;
			ValaCodeNode* _tmp12_;
			_tmp10_ = b;
			_tmp11_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp10_);
			_tmp12_ = _tmp11_;
			_tmp6_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_FOREACH_STATEMENT);
		}
		if (_tmp6_) {
			_tmp5_ = TRUE;
		} else {
			ValaBlock* _tmp13_;
			ValaCodeNode* _tmp14_;
			ValaCodeNode* _tmp15_;
			_tmp13_ = b;
			_tmp14_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp13_);
			_tmp15_ = _tmp14_;
			_tmp5_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_SWITCH_STATEMENT);
		}
		if (_tmp5_) {
			_vala_code_node_unref0 (b);
			return;
		}
	}
	_tmp17_ = stop_at;
	if (_tmp17_ != NULL) {
		ValaBlock* _tmp18_;
		ValaCodeNode* _tmp19_;
		ValaCodeNode* _tmp20_;
		ValaCodeNode* _tmp21_;
		_tmp18_ = b;
		_tmp19_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp18_);
		_tmp20_ = _tmp19_;
		_tmp21_ = stop_at;
		_tmp16_ = _tmp20_ == _tmp21_;
	} else {
		_tmp16_ = FALSE;
	}
	if (_tmp16_) {
		_vala_code_node_unref0 (b);
		return;
	}
	_tmp22_ = sym;
	_tmp23_ = vala_symbol_get_parent_symbol (_tmp22_);
	_tmp24_ = _tmp23_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp24_, VALA_TYPE_BLOCK)) {
		ValaSymbol* _tmp25_;
		ValaSymbol* _tmp26_;
		ValaSymbol* _tmp27_;
		gboolean _tmp28_;
		ValaCodeNode* _tmp29_;
		_tmp25_ = sym;
		_tmp26_ = vala_symbol_get_parent_symbol (_tmp25_);
		_tmp27_ = _tmp26_;
		_tmp28_ = stop_at_loop;
		_tmp29_ = stop_at;
		vala_ccode_base_module_append_local_free (self, _tmp27_, _tmp28_, _tmp29_);
	} else {
		ValaSymbol* _tmp30_;
		ValaSymbol* _tmp31_;
		ValaSymbol* _tmp32_;
		_tmp30_ = sym;
		_tmp31_ = vala_symbol_get_parent_symbol (_tmp30_);
		_tmp32_ = _tmp31_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_METHOD)) {
			ValaSymbol* _tmp33_;
			ValaSymbol* _tmp34_;
			ValaSymbol* _tmp35_;
			_tmp33_ = sym;
			_tmp34_ = vala_symbol_get_parent_symbol (_tmp33_);
			_tmp35_ = _tmp34_;
			vala_ccode_base_module_append_param_free (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp35_, VALA_TYPE_METHOD, ValaMethod));
		} else {
			ValaSymbol* _tmp36_;
			ValaSymbol* _tmp37_;
			ValaSymbol* _tmp38_;
			_tmp36_ = sym;
			_tmp37_ = vala_symbol_get_parent_symbol (_tmp36_);
			_tmp38_ = _tmp37_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp38_, VALA_TYPE_PROPERTY_ACCESSOR)) {
				ValaPropertyAccessor* acc = NULL;
				ValaSymbol* _tmp39_;
				ValaSymbol* _tmp40_;
				ValaSymbol* _tmp41_;
				ValaPropertyAccessor* _tmp42_;
				gboolean _tmp43_ = FALSE;
				ValaPropertyAccessor* _tmp44_;
				ValaParameter* _tmp45_;
				ValaParameter* _tmp46_;
				_tmp39_ = sym;
				_tmp40_ = vala_symbol_get_parent_symbol (_tmp39_);
				_tmp41_ = _tmp40_;
				_tmp42_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp41_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
				acc = _tmp42_;
				_tmp44_ = acc;
				_tmp45_ = vala_property_accessor_get_value_parameter (_tmp44_);
				_tmp46_ = _tmp45_;
				if (_tmp46_ != NULL) {
					ValaPropertyAccessor* _tmp47_;
					ValaParameter* _tmp48_;
					ValaParameter* _tmp49_;
					ValaDataType* _tmp50_;
					ValaDataType* _tmp51_;
					gboolean _tmp52_;
					_tmp47_ = acc;
					_tmp48_ = vala_property_accessor_get_value_parameter (_tmp47_);
					_tmp49_ = _tmp48_;
					_tmp50_ = vala_variable_get_variable_type ((ValaVariable*) _tmp49_);
					_tmp51_ = _tmp50_;
					_tmp52_ = vala_ccode_base_module_requires_destroy (self, _tmp51_);
					_tmp43_ = _tmp52_;
				} else {
					_tmp43_ = FALSE;
				}
				if (_tmp43_) {
					ValaCCodeFunction* _tmp53_;
					ValaCCodeFunction* _tmp54_;
					ValaPropertyAccessor* _tmp55_;
					ValaParameter* _tmp56_;
					ValaParameter* _tmp57_;
					ValaCCodeExpression* _tmp58_;
					ValaCCodeExpression* _tmp59_;
					_tmp53_ = vala_ccode_base_module_get_ccode (self);
					_tmp54_ = _tmp53_;
					_tmp55_ = acc;
					_tmp56_ = vala_property_accessor_get_value_parameter (_tmp55_);
					_tmp57_ = _tmp56_;
					_tmp58_ = vala_ccode_base_module_destroy_parameter (self, _tmp57_);
					_tmp59_ = _tmp58_;
					vala_ccode_function_add_expression (_tmp54_, _tmp59_);
					_vala_ccode_node_unref0 (_tmp59_);
				}
				_vala_code_node_unref0 (acc);
			}
		}
	}
	_vala_code_node_unref0 (b);
}


static void vala_ccode_base_module_append_param_free (ValaCCodeBaseModule* self, ValaMethod* m) {
	g_return_if_fail (self != NULL);
	g_return_if_fail (m != NULL);
	{
		ValaList* _param_list = NULL;
		ValaMethod* _tmp0_;
		ValaList* _tmp1_;
		gint _param_size = 0;
		ValaList* _tmp2_;
		gint _tmp3_;
		gint _tmp4_;
		gint _param_index = 0;
		_tmp0_ = m;
		_tmp1_ = vala_callable_get_parameters ((ValaCallable*) _tmp0_);
		_param_list = _tmp1_;
		_tmp2_ = _param_list;
		_tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
		_tmp4_ = _tmp3_;
		_param_size = _tmp4_;
		_param_index = -1;
		while (TRUE) {
			gint _tmp5_;
			gint _tmp6_;
			gint _tmp7_;
			ValaParameter* param = NULL;
			ValaList* _tmp8_;
			gint _tmp9_;
			gpointer _tmp10_;
			gboolean _tmp11_ = FALSE;
			gboolean _tmp12_ = FALSE;
			gboolean _tmp13_ = FALSE;
			ValaParameter* _tmp14_;
			gboolean _tmp15_;
			gboolean _tmp16_;
			_tmp5_ = _param_index;
			_param_index = _tmp5_ + 1;
			_tmp6_ = _param_index;
			_tmp7_ = _param_size;
			if (!(_tmp6_ < _tmp7_)) {
				break;
			}
			_tmp8_ = _param_list;
			_tmp9_ = _param_index;
			_tmp10_ = vala_list_get (_tmp8_, _tmp9_);
			param = (ValaParameter*) _tmp10_;
			_tmp14_ = param;
			_tmp15_ = vala_parameter_get_captured (_tmp14_);
			_tmp16_ = _tmp15_;
			if (!_tmp16_) {
				ValaParameter* _tmp17_;
				gboolean _tmp18_;
				gboolean _tmp19_;
				_tmp17_ = param;
				_tmp18_ = vala_parameter_get_ellipsis (_tmp17_);
				_tmp19_ = _tmp18_;
				_tmp13_ = !_tmp19_;
			} else {
				_tmp13_ = FALSE;
			}
			if (_tmp13_) {
				ValaParameter* _tmp20_;
				ValaDataType* _tmp21_;
				ValaDataType* _tmp22_;
				gboolean _tmp23_;
				_tmp20_ = param;
				_tmp21_ = vala_variable_get_variable_type ((ValaVariable*) _tmp20_);
				_tmp22_ = _tmp21_;
				_tmp23_ = vala_ccode_base_module_requires_destroy (self, _tmp22_);
				_tmp12_ = _tmp23_;
			} else {
				_tmp12_ = FALSE;
			}
			if (_tmp12_) {
				ValaParameter* _tmp24_;
				ValaParameterDirection _tmp25_;
				ValaParameterDirection _tmp26_;
				_tmp24_ = param;
				_tmp25_ = vala_parameter_get_direction (_tmp24_);
				_tmp26_ = _tmp25_;
				_tmp11_ = _tmp26_ == VALA_PARAMETER_DIRECTION_IN;
			} else {
				_tmp11_ = FALSE;
			}
			if (_tmp11_) {
				ValaCCodeFunction* _tmp27_;
				ValaCCodeFunction* _tmp28_;
				ValaParameter* _tmp29_;
				ValaCCodeExpression* _tmp30_;
				ValaCCodeExpression* _tmp31_;
				_tmp27_ = vala_ccode_base_module_get_ccode (self);
				_tmp28_ = _tmp27_;
				_tmp29_ = param;
				_tmp30_ = vala_ccode_base_module_destroy_parameter (self, _tmp29_);
				_tmp31_ = _tmp30_;
				vala_ccode_function_add_expression (_tmp28_, _tmp31_);
				_vala_ccode_node_unref0 (_tmp31_);
			}
			_vala_code_node_unref0 (param);
		}
		_vala_iterable_unref0 (_param_list);
	}
}


gboolean vala_ccode_base_module_variable_accessible_in_finally (ValaCCodeBaseModule* self, ValaLocalVariable* local) {
	gboolean result = FALSE;
	ValaTryStatement* _tmp0_;
	ValaTryStatement* _tmp1_;
	ValaSymbol* sym = NULL;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp3_;
	ValaSymbol* _tmp4_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (local != NULL, FALSE);
	_tmp0_ = vala_ccode_base_module_get_current_try (self);
	_tmp1_ = _tmp0_;
	if (_tmp1_ == NULL) {
		result = FALSE;
		return result;
	}
	_tmp2_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp3_ = _tmp2_;
	_tmp4_ = _vala_code_node_ref0 (_tmp3_);
	sym = _tmp4_;
	while (TRUE) {
		gboolean _tmp5_ = FALSE;
		gboolean _tmp6_ = FALSE;
		ValaSymbol* _tmp7_;
		gboolean _tmp17_ = FALSE;
		gboolean _tmp18_ = FALSE;
		ValaSymbol* _tmp19_;
		ValaCodeNode* _tmp20_;
		ValaCodeNode* _tmp21_;
		ValaSymbol* _tmp38_;
		ValaSymbol* _tmp39_;
		ValaSymbol* _tmp40_;
		ValaSymbol* _tmp41_;
		_tmp7_ = sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_METHOD)) {
			_tmp6_ = TRUE;
		} else {
			ValaSymbol* _tmp8_;
			_tmp8_ = sym;
			_tmp6_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_PROPERTY_ACCESSOR);
		}
		if (!_tmp6_) {
			ValaSymbol* _tmp9_;
			ValaScope* _tmp10_;
			ValaScope* _tmp11_;
			ValaLocalVariable* _tmp12_;
			const gchar* _tmp13_;
			const gchar* _tmp14_;
			ValaSymbol* _tmp15_;
			ValaSymbol* _tmp16_;
			_tmp9_ = sym;
			_tmp10_ = vala_symbol_get_scope (_tmp9_);
			_tmp11_ = _tmp10_;
			_tmp12_ = local;
			_tmp13_ = vala_symbol_get_name ((ValaSymbol*) _tmp12_);
			_tmp14_ = _tmp13_;
			_tmp15_ = vala_scope_lookup (_tmp11_, _tmp14_);
			_tmp16_ = _tmp15_;
			_tmp5_ = _tmp16_ == NULL;
			_vala_code_node_unref0 (_tmp16_);
		} else {
			_tmp5_ = FALSE;
		}
		if (!_tmp5_) {
			break;
		}
		_tmp19_ = sym;
		_tmp20_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp19_);
		_tmp21_ = _tmp20_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp21_, VALA_TYPE_TRY_STATEMENT)) {
			ValaSymbol* _tmp22_;
			ValaCodeNode* _tmp23_;
			ValaCodeNode* _tmp24_;
			ValaBlock* _tmp25_;
			ValaBlock* _tmp26_;
			_tmp22_ = sym;
			_tmp23_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp22_);
			_tmp24_ = _tmp23_;
			_tmp25_ = vala_try_statement_get_finally_body (G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, VALA_TYPE_TRY_STATEMENT, ValaTryStatement));
			_tmp26_ = _tmp25_;
			_tmp18_ = _tmp26_ != NULL;
		} else {
			_tmp18_ = FALSE;
		}
		if (_tmp18_) {
			_tmp17_ = TRUE;
		} else {
			gboolean _tmp27_ = FALSE;
			ValaSymbol* _tmp28_;
			ValaCodeNode* _tmp29_;
			ValaCodeNode* _tmp30_;
			_tmp28_ = sym;
			_tmp29_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp28_);
			_tmp30_ = _tmp29_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp30_, VALA_TYPE_CATCH_CLAUSE)) {
				ValaSymbol* _tmp31_;
				ValaCodeNode* _tmp32_;
				ValaCodeNode* _tmp33_;
				ValaCodeNode* _tmp34_;
				ValaCodeNode* _tmp35_;
				ValaBlock* _tmp36_;
				ValaBlock* _tmp37_;
				_tmp31_ = sym;
				_tmp32_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp31_);
				_tmp33_ = _tmp32_;
				_tmp34_ = vala_code_node_get_parent_node (_tmp33_);
				_tmp35_ = _tmp34_;
				_tmp36_ = vala_try_statement_get_finally_body (G_TYPE_CHECK_INSTANCE_CAST (_tmp35_, VALA_TYPE_TRY_STATEMENT, ValaTryStatement));
				_tmp37_ = _tmp36_;
				_tmp27_ = _tmp37_ != NULL;
			} else {
				_tmp27_ = FALSE;
			}
			_tmp17_ = _tmp27_;
		}
		if (_tmp17_) {
			result = TRUE;
			_vala_code_node_unref0 (sym);
			return result;
		}
		_tmp38_ = sym;
		_tmp39_ = vala_symbol_get_parent_symbol (_tmp38_);
		_tmp40_ = _tmp39_;
		_tmp41_ = _vala_code_node_ref0 (_tmp40_);
		_vala_code_node_unref0 (sym);
		sym = _tmp41_;
	}
	result = FALSE;
	_vala_code_node_unref0 (sym);
	return result;
}


void vala_ccode_base_module_return_out_parameter (ValaCCodeBaseModule* self, ValaParameter* param) {
	ValaDelegateType* delegate_type = NULL;
	ValaParameter* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaDelegateType* _tmp3_;
	ValaTargetValue* value = NULL;
	ValaParameter* _tmp4_;
	ValaTargetValue* _tmp5_;
	gboolean old_coroutine = FALSE;
	gboolean _tmp6_;
	ValaMethod* _tmp7_;
	ValaMethod* _tmp8_;
	ValaCCodeFunction* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	ValaParameter* _tmp11_;
	const gchar* _tmp12_;
	const gchar* _tmp13_;
	ValaCCodeExpression* _tmp14_;
	ValaCCodeExpression* _tmp15_;
	ValaCCodeFunction* _tmp16_;
	ValaCCodeFunction* _tmp17_;
	ValaParameter* _tmp18_;
	const gchar* _tmp19_;
	const gchar* _tmp20_;
	ValaCCodeExpression* _tmp21_;
	ValaCCodeExpression* _tmp22_;
	ValaCCodeUnaryExpression* _tmp23_;
	ValaCCodeUnaryExpression* _tmp24_;
	ValaTargetValue* _tmp25_;
	ValaCCodeExpression* _tmp26_;
	ValaCCodeExpression* _tmp27_;
	gboolean _tmp28_ = FALSE;
	ValaDelegateType* _tmp29_;
	ValaParameter* _tmp65_;
	ValaDataType* _tmp66_;
	ValaDataType* _tmp67_;
	gboolean _tmp68_;
	ValaCCodeFunction* _tmp81_;
	ValaCCodeFunction* _tmp82_;
	ValaArrayType* array_type = NULL;
	ValaParameter* _tmp83_;
	ValaDataType* _tmp84_;
	ValaDataType* _tmp85_;
	ValaArrayType* _tmp86_;
	gboolean _tmp87_ = FALSE;
	gboolean _tmp88_ = FALSE;
	ValaArrayType* _tmp89_;
	ValaMethod* _tmp125_;
	ValaMethod* _tmp126_;
	gboolean _tmp127_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (param != NULL);
	_tmp0_ = param;
	_tmp1_ = vala_variable_get_variable_type ((ValaVariable*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp2_) : NULL);
	delegate_type = _tmp3_;
	_tmp4_ = param;
	_tmp5_ = vala_ccode_base_module_get_parameter_cvalue (self, _tmp4_);
	value = _tmp5_;
	_tmp6_ = vala_ccode_base_module_is_in_coroutine (self);
	old_coroutine = _tmp6_;
	_tmp7_ = vala_ccode_base_module_get_current_method (self);
	_tmp8_ = _tmp7_;
	vala_method_set_coroutine (_tmp8_, FALSE);
	_tmp9_ = vala_ccode_base_module_get_ccode (self);
	_tmp10_ = _tmp9_;
	_tmp11_ = param;
	_tmp12_ = vala_symbol_get_name ((ValaSymbol*) _tmp11_);
	_tmp13_ = _tmp12_;
	_tmp14_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp13_);
	_tmp15_ = _tmp14_;
	vala_ccode_function_open_if (_tmp10_, _tmp15_);
	_vala_ccode_node_unref0 (_tmp15_);
	_tmp16_ = vala_ccode_base_module_get_ccode (self);
	_tmp17_ = _tmp16_;
	_tmp18_ = param;
	_tmp19_ = vala_symbol_get_name ((ValaSymbol*) _tmp18_);
	_tmp20_ = _tmp19_;
	_tmp21_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp20_);
	_tmp22_ = _tmp21_;
	_tmp23_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp22_);
	_tmp24_ = _tmp23_;
	_tmp25_ = value;
	_tmp26_ = vala_ccode_base_module_get_cvalue_ (self, _tmp25_);
	_tmp27_ = _tmp26_;
	vala_ccode_function_add_assignment (_tmp17_, (ValaCCodeExpression*) _tmp24_, _tmp27_);
	_vala_ccode_node_unref0 (_tmp27_);
	_vala_ccode_node_unref0 (_tmp24_);
	_vala_ccode_node_unref0 (_tmp22_);
	_tmp29_ = delegate_type;
	if (_tmp29_ != NULL) {
		ValaDelegateType* _tmp30_;
		ValaDelegate* _tmp31_;
		ValaDelegate* _tmp32_;
		gboolean _tmp33_;
		gboolean _tmp34_;
		_tmp30_ = delegate_type;
		_tmp31_ = vala_delegate_type_get_delegate_symbol (_tmp30_);
		_tmp32_ = _tmp31_;
		_tmp33_ = vala_delegate_get_has_target (_tmp32_);
		_tmp34_ = _tmp33_;
		_tmp28_ = _tmp34_;
	} else {
		_tmp28_ = FALSE;
	}
	if (_tmp28_) {
		ValaCCodeFunction* _tmp35_;
		ValaCCodeFunction* _tmp36_;
		ValaParameter* _tmp37_;
		gchar* _tmp38_;
		gchar* _tmp39_;
		ValaCCodeExpression* _tmp40_;
		ValaCCodeExpression* _tmp41_;
		ValaCCodeUnaryExpression* _tmp42_;
		ValaCCodeUnaryExpression* _tmp43_;
		ValaTargetValue* _tmp44_;
		ValaCCodeExpression* _tmp45_;
		ValaCCodeExpression* _tmp46_;
		ValaDelegateType* _tmp47_;
		gboolean _tmp48_;
		_tmp35_ = vala_ccode_base_module_get_ccode (self);
		_tmp36_ = _tmp35_;
		_tmp37_ = param;
		_tmp38_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp37_);
		_tmp39_ = _tmp38_;
		_tmp40_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp39_);
		_tmp41_ = _tmp40_;
		_tmp42_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp41_);
		_tmp43_ = _tmp42_;
		_tmp44_ = value;
		_tmp45_ = vala_ccode_base_module_get_delegate_target_cvalue (self, _tmp44_);
		_tmp46_ = _tmp45_;
		vala_ccode_function_add_assignment (_tmp36_, (ValaCCodeExpression*) _tmp43_, _tmp46_);
		_vala_ccode_node_unref0 (_tmp46_);
		_vala_ccode_node_unref0 (_tmp43_);
		_vala_ccode_node_unref0 (_tmp41_);
		_g_free0 (_tmp39_);
		_tmp47_ = delegate_type;
		_tmp48_ = vala_data_type_is_disposable ((ValaDataType*) _tmp47_);
		if (_tmp48_) {
			ValaCCodeFunction* _tmp49_;
			ValaCCodeFunction* _tmp50_;
			ValaParameter* _tmp51_;
			const gchar* _tmp52_;
			const gchar* _tmp53_;
			gchar* _tmp54_;
			gchar* _tmp55_;
			ValaCCodeExpression* _tmp56_;
			ValaCCodeExpression* _tmp57_;
			ValaCCodeUnaryExpression* _tmp58_;
			ValaCCodeUnaryExpression* _tmp59_;
			ValaParameter* _tmp60_;
			ValaTargetValue* _tmp61_;
			ValaTargetValue* _tmp62_;
			ValaCCodeExpression* _tmp63_;
			ValaCCodeExpression* _tmp64_;
			_tmp49_ = vala_ccode_base_module_get_ccode (self);
			_tmp50_ = _tmp49_;
			_tmp51_ = param;
			_tmp52_ = vala_symbol_get_name ((ValaSymbol*) _tmp51_);
			_tmp53_ = _tmp52_;
			_tmp54_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp53_);
			_tmp55_ = _tmp54_;
			_tmp56_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp55_);
			_tmp57_ = _tmp56_;
			_tmp58_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp57_);
			_tmp59_ = _tmp58_;
			_tmp60_ = param;
			_tmp61_ = vala_ccode_base_module_get_parameter_cvalue (self, _tmp60_);
			_tmp62_ = _tmp61_;
			_tmp63_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp62_);
			_tmp64_ = _tmp63_;
			vala_ccode_function_add_assignment (_tmp50_, (ValaCCodeExpression*) _tmp59_, _tmp64_);
			_vala_ccode_node_unref0 (_tmp64_);
			_vala_target_value_unref0 (_tmp62_);
			_vala_ccode_node_unref0 (_tmp59_);
			_vala_ccode_node_unref0 (_tmp57_);
			_g_free0 (_tmp55_);
		}
	}
	_tmp65_ = param;
	_tmp66_ = vala_variable_get_variable_type ((ValaVariable*) _tmp65_);
	_tmp67_ = _tmp66_;
	_tmp68_ = vala_data_type_is_disposable (_tmp67_);
	if (_tmp68_) {
		ValaCCodeFunction* _tmp69_;
		ValaCCodeFunction* _tmp70_;
		ValaMethod* _tmp71_;
		ValaMethod* _tmp72_;
		gboolean _tmp73_;
		ValaCCodeFunction* _tmp74_;
		ValaCCodeFunction* _tmp75_;
		ValaParameter* _tmp76_;
		ValaCCodeExpression* _tmp77_;
		ValaCCodeExpression* _tmp78_;
		ValaMethod* _tmp79_;
		ValaMethod* _tmp80_;
		_tmp69_ = vala_ccode_base_module_get_ccode (self);
		_tmp70_ = _tmp69_;
		vala_ccode_function_add_else (_tmp70_);
		_tmp71_ = vala_ccode_base_module_get_current_method (self);
		_tmp72_ = _tmp71_;
		_tmp73_ = old_coroutine;
		vala_method_set_coroutine (_tmp72_, _tmp73_);
		_tmp74_ = vala_ccode_base_module_get_ccode (self);
		_tmp75_ = _tmp74_;
		_tmp76_ = param;
		_tmp77_ = vala_ccode_base_module_destroy_parameter (self, _tmp76_);
		_tmp78_ = _tmp77_;
		vala_ccode_function_add_expression (_tmp75_, _tmp78_);
		_vala_ccode_node_unref0 (_tmp78_);
		_tmp79_ = vala_ccode_base_module_get_current_method (self);
		_tmp80_ = _tmp79_;
		vala_method_set_coroutine (_tmp80_, FALSE);
	}
	_tmp81_ = vala_ccode_base_module_get_ccode (self);
	_tmp82_ = _tmp81_;
	vala_ccode_function_close (_tmp82_);
	_tmp83_ = param;
	_tmp84_ = vala_variable_get_variable_type ((ValaVariable*) _tmp83_);
	_tmp85_ = _tmp84_;
	_tmp86_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp85_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp85_) : NULL);
	array_type = _tmp86_;
	_tmp89_ = array_type;
	if (_tmp89_ != NULL) {
		ValaArrayType* _tmp90_;
		gboolean _tmp91_;
		gboolean _tmp92_;
		_tmp90_ = array_type;
		_tmp91_ = vala_array_type_get_fixed_length (_tmp90_);
		_tmp92_ = _tmp91_;
		_tmp88_ = !_tmp92_;
	} else {
		_tmp88_ = FALSE;
	}
	if (_tmp88_) {
		ValaParameter* _tmp93_;
		gboolean _tmp94_;
		_tmp93_ = param;
		_tmp94_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp93_);
		_tmp87_ = _tmp94_;
	} else {
		_tmp87_ = FALSE;
	}
	if (_tmp87_) {
		{
			gint dim = 0;
			dim = 1;
			{
				gboolean _tmp95_ = FALSE;
				_tmp95_ = TRUE;
				while (TRUE) {
					gint _tmp97_;
					ValaArrayType* _tmp98_;
					gint _tmp99_;
					gint _tmp100_;
					ValaCCodeFunction* _tmp101_;
					ValaCCodeFunction* _tmp102_;
					ValaParameter* _tmp103_;
					gint _tmp104_;
					gchar* _tmp105_;
					gchar* _tmp106_;
					ValaCCodeExpression* _tmp107_;
					ValaCCodeExpression* _tmp108_;
					ValaCCodeFunction* _tmp109_;
					ValaCCodeFunction* _tmp110_;
					ValaParameter* _tmp111_;
					gint _tmp112_;
					gchar* _tmp113_;
					gchar* _tmp114_;
					ValaCCodeExpression* _tmp115_;
					ValaCCodeExpression* _tmp116_;
					ValaCCodeUnaryExpression* _tmp117_;
					ValaCCodeUnaryExpression* _tmp118_;
					ValaTargetValue* _tmp119_;
					gint _tmp120_;
					ValaCCodeExpression* _tmp121_;
					ValaCCodeExpression* _tmp122_;
					ValaCCodeFunction* _tmp123_;
					ValaCCodeFunction* _tmp124_;
					if (!_tmp95_) {
						gint _tmp96_;
						_tmp96_ = dim;
						dim = _tmp96_ + 1;
					}
					_tmp95_ = FALSE;
					_tmp97_ = dim;
					_tmp98_ = array_type;
					_tmp99_ = vala_array_type_get_rank (_tmp98_);
					_tmp100_ = _tmp99_;
					if (!(_tmp97_ <= _tmp100_)) {
						break;
					}
					_tmp101_ = vala_ccode_base_module_get_ccode (self);
					_tmp102_ = _tmp101_;
					_tmp103_ = param;
					_tmp104_ = dim;
					_tmp105_ = vala_ccode_base_module_get_parameter_array_length_cname (self, _tmp103_, _tmp104_);
					_tmp106_ = _tmp105_;
					_tmp107_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp106_);
					_tmp108_ = _tmp107_;
					vala_ccode_function_open_if (_tmp102_, _tmp108_);
					_vala_ccode_node_unref0 (_tmp108_);
					_g_free0 (_tmp106_);
					_tmp109_ = vala_ccode_base_module_get_ccode (self);
					_tmp110_ = _tmp109_;
					_tmp111_ = param;
					_tmp112_ = dim;
					_tmp113_ = vala_ccode_base_module_get_parameter_array_length_cname (self, _tmp111_, _tmp112_);
					_tmp114_ = _tmp113_;
					_tmp115_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp114_);
					_tmp116_ = _tmp115_;
					_tmp117_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp116_);
					_tmp118_ = _tmp117_;
					_tmp119_ = value;
					_tmp120_ = dim;
					_tmp121_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp119_, _tmp120_);
					_tmp122_ = _tmp121_;
					vala_ccode_function_add_assignment (_tmp110_, (ValaCCodeExpression*) _tmp118_, _tmp122_);
					_vala_ccode_node_unref0 (_tmp122_);
					_vala_ccode_node_unref0 (_tmp118_);
					_vala_ccode_node_unref0 (_tmp116_);
					_g_free0 (_tmp114_);
					_tmp123_ = vala_ccode_base_module_get_ccode (self);
					_tmp124_ = _tmp123_;
					vala_ccode_function_close (_tmp124_);
				}
			}
		}
	}
	_tmp125_ = vala_ccode_base_module_get_current_method (self);
	_tmp126_ = _tmp125_;
	_tmp127_ = old_coroutine;
	vala_method_set_coroutine (_tmp126_, _tmp127_);
	_vala_code_node_unref0 (array_type);
	_vala_target_value_unref0 (value);
	_vala_code_node_unref0 (delegate_type);
}


static void vala_ccode_base_module_real_visit_return_statement (ValaCodeVisitor* base, ValaReturnStatement* stmt) {
	ValaCCodeBaseModule * self;
	ValaSymbol* return_expression_symbol = NULL;
	ValaReturnStatement* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	gboolean _tmp16_ = FALSE;
	gboolean _tmp17_ = FALSE;
	gboolean _tmp18_ = FALSE;
	ValaMethod* _tmp19_;
	ValaMethod* _tmp20_;
	ValaReturnStatement* _tmp127_;
	ValaExpression* _tmp128_;
	ValaExpression* _tmp129_;
	ValaSymbol* _tmp146_;
	ValaSymbol* _tmp147_;
	ValaMethod* _tmp148_;
	ValaMethod* _tmp149_;
	gboolean _tmp163_ = FALSE;
	ValaMethod* _tmp164_;
	ValaMethod* _tmp165_;
	gboolean _tmp186_ = FALSE;
	ValaMethod* _tmp187_;
	ValaMethod* _tmp188_;
	gboolean _tmp227_;
	ValaSymbol* _tmp254_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (stmt != NULL);
	return_expression_symbol = NULL;
	_tmp0_ = stmt;
	_tmp1_ = vala_return_statement_get_return_expression (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ != NULL) {
		ValaLocalVariable* local = NULL;
		ValaReturnStatement* _tmp3_;
		ValaExpression* _tmp4_;
		ValaExpression* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		ValaLocalVariable* _tmp8_;
		gboolean _tmp9_ = FALSE;
		ValaLocalVariable* _tmp10_;
		_tmp3_ = stmt;
		_tmp4_ = vala_return_statement_get_return_expression (_tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = vala_expression_get_symbol_reference (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp7_) : NULL);
		local = _tmp8_;
		_tmp10_ = local;
		if (_tmp10_ != NULL) {
			ValaLocalVariable* _tmp11_;
			gboolean _tmp12_;
			gboolean _tmp13_;
			_tmp11_ = local;
			_tmp12_ = vala_symbol_get_active ((ValaSymbol*) _tmp11_);
			_tmp13_ = _tmp12_;
			_tmp9_ = !_tmp13_;
		} else {
			_tmp9_ = FALSE;
		}
		if (_tmp9_) {
			ValaLocalVariable* _tmp14_;
			ValaSymbol* _tmp15_;
			_tmp14_ = local;
			_tmp15_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp14_);
			_vala_code_node_unref0 (return_expression_symbol);
			return_expression_symbol = _tmp15_;
		}
		_vala_code_node_unref0 (local);
	}
	_tmp19_ = vala_ccode_base_module_get_current_method (self);
	_tmp20_ = _tmp19_;
	if (_tmp20_ != NULL) {
		ValaMethod* _tmp21_;
		ValaMethod* _tmp22_;
		gboolean _tmp23_;
		_tmp21_ = vala_ccode_base_module_get_current_method (self);
		_tmp22_ = _tmp21_;
		_tmp23_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp22_);
		_tmp18_ = _tmp23_;
	} else {
		_tmp18_ = FALSE;
	}
	if (_tmp18_) {
		_tmp17_ = TRUE;
	} else {
		ValaPropertyAccessor* _tmp24_;
		ValaPropertyAccessor* _tmp25_;
		_tmp24_ = vala_ccode_base_module_get_current_property_accessor (self);
		_tmp25_ = _tmp24_;
		_tmp17_ = _tmp25_ != NULL;
	}
	if (_tmp17_) {
		ValaDataType* _tmp26_;
		ValaDataType* _tmp27_;
		_tmp26_ = vala_ccode_base_module_get_current_return_type (self);
		_tmp27_ = _tmp26_;
		_tmp16_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp27_, VALA_TYPE_ARRAY_TYPE);
	} else {
		_tmp16_ = FALSE;
	}
	if (_tmp16_) {
		ValaTargetValue* temp_value = NULL;
		ValaReturnStatement* _tmp28_;
		ValaExpression* _tmp29_;
		ValaExpression* _tmp30_;
		ValaTargetValue* _tmp31_;
		ValaTargetValue* _tmp32_;
		ValaReturnStatement* _tmp33_;
		ValaTargetValue* _tmp34_;
		ValaArrayType* array_type = NULL;
		ValaDataType* _tmp35_;
		ValaDataType* _tmp36_;
		ValaArrayType* _tmp37_;
		ValaReturnStatement* _tmp68_;
		ValaExpression* _tmp69_;
		ValaExpression* _tmp70_;
		ValaTargetValue* _tmp71_;
		_tmp28_ = stmt;
		_tmp29_ = vala_return_statement_get_return_expression (_tmp28_);
		_tmp30_ = _tmp29_;
		_tmp31_ = vala_expression_get_target_value (_tmp30_);
		_tmp32_ = _tmp31_;
		_tmp33_ = stmt;
		_tmp34_ = vala_ccode_base_module_store_temp_value (self, _tmp32_, (ValaCodeNode*) _tmp33_, NULL);
		temp_value = _tmp34_;
		_tmp35_ = vala_ccode_base_module_get_current_return_type (self);
		_tmp36_ = _tmp35_;
		_tmp37_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp36_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		array_type = _tmp37_;
		{
			gint dim = 0;
			dim = 1;
			{
				gboolean _tmp38_ = FALSE;
				_tmp38_ = TRUE;
				while (TRUE) {
					gint _tmp40_;
					ValaArrayType* _tmp41_;
					gint _tmp42_;
					gint _tmp43_;
					ValaCCodeExpression* len_l = NULL;
					gint _tmp44_;
					gchar* _tmp45_;
					gchar* _tmp46_;
					ValaCCodeExpression* _tmp47_;
					ValaCCodeExpression* _tmp48_;
					ValaCCodeExpression* len_r = NULL;
					ValaTargetValue* _tmp49_;
					gint _tmp50_;
					ValaCCodeExpression* _tmp51_;
					gboolean _tmp52_;
					if (!_tmp38_) {
						gint _tmp39_;
						_tmp39_ = dim;
						dim = _tmp39_ + 1;
					}
					_tmp38_ = FALSE;
					_tmp40_ = dim;
					_tmp41_ = array_type;
					_tmp42_ = vala_array_type_get_rank (_tmp41_);
					_tmp43_ = _tmp42_;
					if (!(_tmp40_ <= _tmp43_)) {
						break;
					}
					_tmp44_ = dim;
					_tmp45_ = vala_ccode_base_module_get_array_length_cname (self, "result", _tmp44_);
					_tmp46_ = _tmp45_;
					_tmp47_ = vala_ccode_base_module_get_result_cexpression (self, _tmp46_);
					_tmp48_ = _tmp47_;
					_g_free0 (_tmp46_);
					len_l = _tmp48_;
					_tmp49_ = temp_value;
					_tmp50_ = dim;
					_tmp51_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp49_, _tmp50_);
					len_r = _tmp51_;
					_tmp52_ = vala_ccode_base_module_is_in_coroutine (self);
					if (!_tmp52_) {
						ValaCCodeFunction* _tmp53_;
						ValaCCodeFunction* _tmp54_;
						ValaCCodeExpression* _tmp55_;
						ValaCCodeExpression* _tmp56_;
						ValaCCodeUnaryExpression* _tmp57_;
						ValaCCodeFunction* _tmp58_;
						ValaCCodeFunction* _tmp59_;
						ValaCCodeExpression* _tmp60_;
						ValaCCodeExpression* _tmp61_;
						ValaCCodeFunction* _tmp62_;
						ValaCCodeFunction* _tmp63_;
						_tmp53_ = vala_ccode_base_module_get_ccode (self);
						_tmp54_ = _tmp53_;
						_tmp55_ = len_l;
						vala_ccode_function_open_if (_tmp54_, _tmp55_);
						_tmp56_ = len_l;
						_tmp57_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp56_);
						_vala_ccode_node_unref0 (len_l);
						len_l = (ValaCCodeExpression*) _tmp57_;
						_tmp58_ = vala_ccode_base_module_get_ccode (self);
						_tmp59_ = _tmp58_;
						_tmp60_ = len_l;
						_tmp61_ = len_r;
						vala_ccode_function_add_assignment (_tmp59_, _tmp60_, _tmp61_);
						_tmp62_ = vala_ccode_base_module_get_ccode (self);
						_tmp63_ = _tmp62_;
						vala_ccode_function_close (_tmp63_);
					} else {
						ValaCCodeFunction* _tmp64_;
						ValaCCodeFunction* _tmp65_;
						ValaCCodeExpression* _tmp66_;
						ValaCCodeExpression* _tmp67_;
						_tmp64_ = vala_ccode_base_module_get_ccode (self);
						_tmp65_ = _tmp64_;
						_tmp66_ = len_l;
						_tmp67_ = len_r;
						vala_ccode_function_add_assignment (_tmp65_, _tmp66_, _tmp67_);
					}
					_vala_ccode_node_unref0 (len_r);
					_vala_ccode_node_unref0 (len_l);
				}
			}
		}
		_tmp68_ = stmt;
		_tmp69_ = vala_return_statement_get_return_expression (_tmp68_);
		_tmp70_ = _tmp69_;
		_tmp71_ = temp_value;
		vala_expression_set_target_value (_tmp70_, _tmp71_);
		_vala_code_node_unref0 (array_type);
		_vala_target_value_unref0 (temp_value);
	} else {
		gboolean _tmp72_ = FALSE;
		gboolean _tmp73_ = FALSE;
		ValaMethod* _tmp74_;
		ValaMethod* _tmp75_;
		_tmp74_ = vala_ccode_base_module_get_current_method (self);
		_tmp75_ = _tmp74_;
		if (_tmp75_ != NULL) {
			_tmp73_ = TRUE;
		} else {
			ValaPropertyAccessor* _tmp76_;
			ValaPropertyAccessor* _tmp77_;
			_tmp76_ = vala_ccode_base_module_get_current_property_accessor (self);
			_tmp77_ = _tmp76_;
			_tmp73_ = _tmp77_ != NULL;
		}
		if (_tmp73_) {
			ValaDataType* _tmp78_;
			ValaDataType* _tmp79_;
			_tmp78_ = vala_ccode_base_module_get_current_return_type (self);
			_tmp79_ = _tmp78_;
			_tmp72_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp79_, VALA_TYPE_DELEGATE_TYPE);
		} else {
			_tmp72_ = FALSE;
		}
		if (_tmp72_) {
			ValaDelegateType* delegate_type = NULL;
			ValaDataType* _tmp80_;
			ValaDataType* _tmp81_;
			ValaDelegateType* _tmp82_;
			ValaDelegateType* _tmp83_;
			ValaDelegate* _tmp84_;
			ValaDelegate* _tmp85_;
			gboolean _tmp86_;
			gboolean _tmp87_;
			_tmp80_ = vala_ccode_base_module_get_current_return_type (self);
			_tmp81_ = _tmp80_;
			_tmp82_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp81_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
			delegate_type = _tmp82_;
			_tmp83_ = delegate_type;
			_tmp84_ = vala_delegate_type_get_delegate_symbol (_tmp83_);
			_tmp85_ = _tmp84_;
			_tmp86_ = vala_delegate_get_has_target (_tmp85_);
			_tmp87_ = _tmp86_;
			if (_tmp87_) {
				ValaTargetValue* temp_value = NULL;
				ValaReturnStatement* _tmp88_;
				ValaExpression* _tmp89_;
				ValaExpression* _tmp90_;
				ValaTargetValue* _tmp91_;
				ValaTargetValue* _tmp92_;
				ValaReturnStatement* _tmp93_;
				ValaTargetValue* _tmp94_;
				ValaCCodeExpression* target_l = NULL;
				gchar* _tmp95_;
				gchar* _tmp96_;
				ValaCCodeExpression* _tmp97_;
				ValaCCodeExpression* _tmp98_;
				gboolean _tmp99_;
				ValaCCodeExpression* target_r = NULL;
				ValaTargetValue* _tmp102_;
				ValaCCodeExpression* _tmp103_;
				ValaCCodeFunction* _tmp104_;
				ValaCCodeFunction* _tmp105_;
				ValaCCodeExpression* _tmp106_;
				ValaCCodeExpression* _tmp107_;
				ValaDelegateType* _tmp108_;
				gboolean _tmp109_;
				ValaReturnStatement* _tmp123_;
				ValaExpression* _tmp124_;
				ValaExpression* _tmp125_;
				ValaTargetValue* _tmp126_;
				_tmp88_ = stmt;
				_tmp89_ = vala_return_statement_get_return_expression (_tmp88_);
				_tmp90_ = _tmp89_;
				_tmp91_ = vala_expression_get_target_value (_tmp90_);
				_tmp92_ = _tmp91_;
				_tmp93_ = stmt;
				_tmp94_ = vala_ccode_base_module_store_temp_value (self, _tmp92_, (ValaCodeNode*) _tmp93_, NULL);
				temp_value = _tmp94_;
				_tmp95_ = vala_ccode_base_module_get_delegate_target_cname (self, "result");
				_tmp96_ = _tmp95_;
				_tmp97_ = vala_ccode_base_module_get_result_cexpression (self, _tmp96_);
				_tmp98_ = _tmp97_;
				_g_free0 (_tmp96_);
				target_l = _tmp98_;
				_tmp99_ = vala_ccode_base_module_is_in_coroutine (self);
				if (!_tmp99_) {
					ValaCCodeExpression* _tmp100_;
					ValaCCodeUnaryExpression* _tmp101_;
					_tmp100_ = target_l;
					_tmp101_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp100_);
					_vala_ccode_node_unref0 (target_l);
					target_l = (ValaCCodeExpression*) _tmp101_;
				}
				_tmp102_ = temp_value;
				_tmp103_ = vala_ccode_base_module_get_delegate_target_cvalue (self, _tmp102_);
				target_r = _tmp103_;
				_tmp104_ = vala_ccode_base_module_get_ccode (self);
				_tmp105_ = _tmp104_;
				_tmp106_ = target_l;
				_tmp107_ = target_r;
				vala_ccode_function_add_assignment (_tmp105_, _tmp106_, _tmp107_);
				_tmp108_ = delegate_type;
				_tmp109_ = vala_data_type_is_disposable ((ValaDataType*) _tmp108_);
				if (_tmp109_) {
					ValaCCodeExpression* target_l_destroy_notify = NULL;
					gchar* _tmp110_;
					gchar* _tmp111_;
					ValaCCodeExpression* _tmp112_;
					ValaCCodeExpression* _tmp113_;
					gboolean _tmp114_;
					ValaCCodeExpression* target_r_destroy_notify = NULL;
					ValaTargetValue* _tmp117_;
					ValaCCodeExpression* _tmp118_;
					ValaCCodeFunction* _tmp119_;
					ValaCCodeFunction* _tmp120_;
					ValaCCodeExpression* _tmp121_;
					ValaCCodeExpression* _tmp122_;
					_tmp110_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, "result");
					_tmp111_ = _tmp110_;
					_tmp112_ = vala_ccode_base_module_get_result_cexpression (self, _tmp111_);
					_tmp113_ = _tmp112_;
					_g_free0 (_tmp111_);
					target_l_destroy_notify = _tmp113_;
					_tmp114_ = vala_ccode_base_module_is_in_coroutine (self);
					if (!_tmp114_) {
						ValaCCodeExpression* _tmp115_;
						ValaCCodeUnaryExpression* _tmp116_;
						_tmp115_ = target_l_destroy_notify;
						_tmp116_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp115_);
						_vala_ccode_node_unref0 (target_l_destroy_notify);
						target_l_destroy_notify = (ValaCCodeExpression*) _tmp116_;
					}
					_tmp117_ = temp_value;
					_tmp118_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp117_);
					target_r_destroy_notify = _tmp118_;
					_tmp119_ = vala_ccode_base_module_get_ccode (self);
					_tmp120_ = _tmp119_;
					_tmp121_ = target_l_destroy_notify;
					_tmp122_ = target_r_destroy_notify;
					vala_ccode_function_add_assignment (_tmp120_, _tmp121_, _tmp122_);
					_vala_ccode_node_unref0 (target_r_destroy_notify);
					_vala_ccode_node_unref0 (target_l_destroy_notify);
				}
				_tmp123_ = stmt;
				_tmp124_ = vala_return_statement_get_return_expression (_tmp123_);
				_tmp125_ = _tmp124_;
				_tmp126_ = temp_value;
				vala_expression_set_target_value (_tmp125_, _tmp126_);
				_vala_ccode_node_unref0 (target_r);
				_vala_ccode_node_unref0 (target_l);
				_vala_target_value_unref0 (temp_value);
			}
			_vala_code_node_unref0 (delegate_type);
		}
	}
	_tmp127_ = stmt;
	_tmp128_ = vala_return_statement_get_return_expression (_tmp127_);
	_tmp129_ = _tmp128_;
	if (_tmp129_ != NULL) {
		ValaCCodeExpression* result_lhs = NULL;
		ValaCCodeExpression* _tmp130_;
		gboolean _tmp131_ = FALSE;
		ValaDataType* _tmp132_;
		ValaDataType* _tmp133_;
		gboolean _tmp134_;
		ValaCCodeFunction* _tmp138_;
		ValaCCodeFunction* _tmp139_;
		ValaCCodeExpression* _tmp140_;
		ValaReturnStatement* _tmp141_;
		ValaExpression* _tmp142_;
		ValaExpression* _tmp143_;
		ValaCCodeExpression* _tmp144_;
		ValaCCodeExpression* _tmp145_;
		_tmp130_ = vala_ccode_base_module_get_result_cexpression (self, "result");
		result_lhs = _tmp130_;
		_tmp132_ = vala_ccode_base_module_get_current_return_type (self);
		_tmp133_ = _tmp132_;
		_tmp134_ = vala_data_type_is_real_non_null_struct_type (_tmp133_);
		if (_tmp134_) {
			gboolean _tmp135_;
			_tmp135_ = vala_ccode_base_module_is_in_coroutine (self);
			_tmp131_ = !_tmp135_;
		} else {
			_tmp131_ = FALSE;
		}
		if (_tmp131_) {
			ValaCCodeExpression* _tmp136_;
			ValaCCodeUnaryExpression* _tmp137_;
			_tmp136_ = result_lhs;
			_tmp137_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp136_);
			_vala_ccode_node_unref0 (result_lhs);
			result_lhs = (ValaCCodeExpression*) _tmp137_;
		}
		_tmp138_ = vala_ccode_base_module_get_ccode (self);
		_tmp139_ = _tmp138_;
		_tmp140_ = result_lhs;
		_tmp141_ = stmt;
		_tmp142_ = vala_return_statement_get_return_expression (_tmp141_);
		_tmp143_ = _tmp142_;
		_tmp144_ = vala_ccode_base_module_get_cvalue (self, _tmp143_);
		_tmp145_ = _tmp144_;
		vala_ccode_function_add_assignment (_tmp139_, _tmp140_, _tmp145_);
		_vala_ccode_node_unref0 (_tmp145_);
		_vala_ccode_node_unref0 (result_lhs);
	}
	_tmp146_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp147_ = _tmp146_;
	vala_ccode_base_module_append_local_free (self, _tmp147_, FALSE, NULL);
	_tmp148_ = vala_ccode_base_module_get_current_method (self);
	_tmp149_ = _tmp148_;
	if (_tmp149_ != NULL) {
		{
			ValaList* _postcondition_list = NULL;
			ValaMethod* _tmp150_;
			ValaMethod* _tmp151_;
			ValaList* _tmp152_;
			gint _postcondition_size = 0;
			ValaList* _tmp153_;
			gint _tmp154_;
			gint _tmp155_;
			gint _postcondition_index = 0;
			_tmp150_ = vala_ccode_base_module_get_current_method (self);
			_tmp151_ = _tmp150_;
			_tmp152_ = vala_method_get_postconditions (_tmp151_);
			_postcondition_list = _tmp152_;
			_tmp153_ = _postcondition_list;
			_tmp154_ = vala_collection_get_size ((ValaCollection*) _tmp153_);
			_tmp155_ = _tmp154_;
			_postcondition_size = _tmp155_;
			_postcondition_index = -1;
			while (TRUE) {
				gint _tmp156_;
				gint _tmp157_;
				gint _tmp158_;
				ValaExpression* postcondition = NULL;
				ValaList* _tmp159_;
				gint _tmp160_;
				gpointer _tmp161_;
				ValaExpression* _tmp162_;
				_tmp156_ = _postcondition_index;
				_postcondition_index = _tmp156_ + 1;
				_tmp157_ = _postcondition_index;
				_tmp158_ = _postcondition_size;
				if (!(_tmp157_ < _tmp158_)) {
					break;
				}
				_tmp159_ = _postcondition_list;
				_tmp160_ = _postcondition_index;
				_tmp161_ = vala_list_get (_tmp159_, _tmp160_);
				postcondition = (ValaExpression*) _tmp161_;
				_tmp162_ = postcondition;
				vala_ccode_base_module_create_postcondition_statement (self, _tmp162_);
				_vala_code_node_unref0 (postcondition);
			}
			_vala_iterable_unref0 (_postcondition_list);
		}
	}
	_tmp164_ = vala_ccode_base_module_get_current_method (self);
	_tmp165_ = _tmp164_;
	if (_tmp165_ != NULL) {
		ValaMethod* _tmp166_;
		ValaMethod* _tmp167_;
		gboolean _tmp168_;
		gboolean _tmp169_;
		_tmp166_ = vala_ccode_base_module_get_current_method (self);
		_tmp167_ = _tmp166_;
		_tmp168_ = vala_method_get_coroutine (_tmp167_);
		_tmp169_ = _tmp168_;
		_tmp163_ = !_tmp169_;
	} else {
		_tmp163_ = FALSE;
	}
	if (_tmp163_) {
		{
			ValaList* _param_list = NULL;
			ValaMethod* _tmp170_;
			ValaMethod* _tmp171_;
			ValaList* _tmp172_;
			gint _param_size = 0;
			ValaList* _tmp173_;
			gint _tmp174_;
			gint _tmp175_;
			gint _param_index = 0;
			_tmp170_ = vala_ccode_base_module_get_current_method (self);
			_tmp171_ = _tmp170_;
			_tmp172_ = vala_callable_get_parameters ((ValaCallable*) _tmp171_);
			_param_list = _tmp172_;
			_tmp173_ = _param_list;
			_tmp174_ = vala_collection_get_size ((ValaCollection*) _tmp173_);
			_tmp175_ = _tmp174_;
			_param_size = _tmp175_;
			_param_index = -1;
			while (TRUE) {
				gint _tmp176_;
				gint _tmp177_;
				gint _tmp178_;
				ValaParameter* param = NULL;
				ValaList* _tmp179_;
				gint _tmp180_;
				gpointer _tmp181_;
				ValaParameter* _tmp182_;
				ValaParameterDirection _tmp183_;
				ValaParameterDirection _tmp184_;
				ValaParameter* _tmp185_;
				_tmp176_ = _param_index;
				_param_index = _tmp176_ + 1;
				_tmp177_ = _param_index;
				_tmp178_ = _param_size;
				if (!(_tmp177_ < _tmp178_)) {
					break;
				}
				_tmp179_ = _param_list;
				_tmp180_ = _param_index;
				_tmp181_ = vala_list_get (_tmp179_, _tmp180_);
				param = (ValaParameter*) _tmp181_;
				_tmp182_ = param;
				_tmp183_ = vala_parameter_get_direction (_tmp182_);
				_tmp184_ = _tmp183_;
				if (_tmp184_ != VALA_PARAMETER_DIRECTION_OUT) {
					_vala_code_node_unref0 (param);
					continue;
				}
				_tmp185_ = param;
				vala_ccode_base_module_return_out_parameter (self, _tmp185_);
				_vala_code_node_unref0 (param);
			}
			_vala_iterable_unref0 (_param_list);
		}
	}
	_tmp187_ = vala_ccode_base_module_get_current_method (self);
	_tmp188_ = _tmp187_;
	if (_tmp188_ != NULL) {
		ValaMethod* _tmp189_;
		ValaMethod* _tmp190_;
		ValaAttribute* _tmp191_;
		ValaAttribute* _tmp192_;
		_tmp189_ = vala_ccode_base_module_get_current_method (self);
		_tmp190_ = _tmp189_;
		_tmp191_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp190_, "Profile");
		_tmp192_ = _tmp191_;
		_tmp186_ = _tmp192_ != NULL;
		_vala_code_node_unref0 (_tmp192_);
	} else {
		_tmp186_ = FALSE;
	}
	if (_tmp186_) {
		gchar* prefix = NULL;
		ValaMethod* _tmp193_;
		ValaMethod* _tmp194_;
		gchar* _tmp195_;
		gchar* _tmp196_;
		gchar* _tmp197_;
		gchar* _tmp198_;
		ValaCCodeIdentifier* level = NULL;
		const gchar* _tmp199_;
		gchar* _tmp200_;
		gchar* _tmp201_;
		ValaCCodeIdentifier* _tmp202_;
		ValaCCodeIdentifier* _tmp203_;
		ValaCCodeFunction* _tmp204_;
		ValaCCodeFunction* _tmp205_;
		ValaCCodeIdentifier* _tmp206_;
		ValaCCodeUnaryExpression* _tmp207_;
		ValaCCodeUnaryExpression* _tmp208_;
		ValaCCodeUnaryExpression* _tmp209_;
		ValaCCodeUnaryExpression* _tmp210_;
		ValaCCodeIdentifier* timer = NULL;
		const gchar* _tmp211_;
		gchar* _tmp212_;
		gchar* _tmp213_;
		ValaCCodeIdentifier* _tmp214_;
		ValaCCodeIdentifier* _tmp215_;
		ValaCCodeFunctionCall* stop_call = NULL;
		ValaCCodeIdentifier* _tmp216_;
		ValaCCodeIdentifier* _tmp217_;
		ValaCCodeFunctionCall* _tmp218_;
		ValaCCodeFunctionCall* _tmp219_;
		ValaCCodeFunctionCall* _tmp220_;
		ValaCCodeIdentifier* _tmp221_;
		ValaCCodeFunction* _tmp222_;
		ValaCCodeFunction* _tmp223_;
		ValaCCodeFunctionCall* _tmp224_;
		ValaCCodeFunction* _tmp225_;
		ValaCCodeFunction* _tmp226_;
		_tmp193_ = vala_ccode_base_module_get_current_method (self);
		_tmp194_ = _tmp193_;
		_tmp195_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp194_);
		_tmp196_ = _tmp195_;
		_tmp197_ = g_strdup_printf ("_vala_prof_%s", _tmp196_);
		_tmp198_ = _tmp197_;
		_g_free0 (_tmp196_);
		prefix = _tmp198_;
		_tmp199_ = prefix;
		_tmp200_ = g_strconcat (_tmp199_, "_level", NULL);
		_tmp201_ = _tmp200_;
		_tmp202_ = vala_ccode_identifier_new (_tmp201_);
		_tmp203_ = _tmp202_;
		_g_free0 (_tmp201_);
		level = _tmp203_;
		_tmp204_ = vala_ccode_base_module_get_ccode (self);
		_tmp205_ = _tmp204_;
		_tmp206_ = level;
		_tmp207_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp206_);
		_tmp208_ = _tmp207_;
		_tmp209_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp208_);
		_tmp210_ = _tmp209_;
		vala_ccode_function_open_if (_tmp205_, (ValaCCodeExpression*) _tmp210_);
		_vala_ccode_node_unref0 (_tmp210_);
		_vala_ccode_node_unref0 (_tmp208_);
		_tmp211_ = prefix;
		_tmp212_ = g_strconcat (_tmp211_, "_timer", NULL);
		_tmp213_ = _tmp212_;
		_tmp214_ = vala_ccode_identifier_new (_tmp213_);
		_tmp215_ = _tmp214_;
		_g_free0 (_tmp213_);
		timer = _tmp215_;
		_tmp216_ = vala_ccode_identifier_new ("g_timer_stop");
		_tmp217_ = _tmp216_;
		_tmp218_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp217_);
		_tmp219_ = _tmp218_;
		_vala_ccode_node_unref0 (_tmp217_);
		stop_call = _tmp219_;
		_tmp220_ = stop_call;
		_tmp221_ = timer;
		vala_ccode_function_call_add_argument (_tmp220_, (ValaCCodeExpression*) _tmp221_);
		_tmp222_ = vala_ccode_base_module_get_ccode (self);
		_tmp223_ = _tmp222_;
		_tmp224_ = stop_call;
		vala_ccode_function_add_expression (_tmp223_, (ValaCCodeExpression*) _tmp224_);
		_tmp225_ = vala_ccode_base_module_get_ccode (self);
		_tmp226_ = _tmp225_;
		vala_ccode_function_close (_tmp226_);
		_vala_ccode_node_unref0 (stop_call);
		_vala_ccode_node_unref0 (timer);
		_vala_ccode_node_unref0 (level);
		_g_free0 (prefix);
	}
	_tmp227_ = vala_ccode_base_module_is_in_constructor (self);
	if (_tmp227_) {
		ValaCCodeFunction* _tmp228_;
		ValaCCodeFunction* _tmp229_;
		ValaCCodeIdentifier* _tmp230_;
		ValaCCodeIdentifier* _tmp231_;
		_tmp228_ = vala_ccode_base_module_get_ccode (self);
		_tmp229_ = _tmp228_;
		_tmp230_ = vala_ccode_identifier_new ("obj");
		_tmp231_ = _tmp230_;
		vala_ccode_function_add_return (_tmp229_, (ValaCCodeExpression*) _tmp231_);
		_vala_ccode_node_unref0 (_tmp231_);
	} else {
		gboolean _tmp232_;
		_tmp232_ = vala_ccode_base_module_is_in_destructor (self);
		if (_tmp232_) {
			ValaCCodeFunction* _tmp233_;
			ValaCCodeFunction* _tmp234_;
			_tmp233_ = vala_ccode_base_module_get_ccode (self);
			_tmp234_ = _tmp233_;
			vala_ccode_function_add_goto (_tmp234_, "_return");
		} else {
			gboolean _tmp235_;
			_tmp235_ = vala_ccode_base_module_is_in_coroutine (self);
			if (_tmp235_) {
			} else {
				ValaMethod* _tmp236_;
				ValaMethod* _tmp237_;
				_tmp236_ = vala_ccode_base_module_get_current_method (self);
				_tmp237_ = _tmp236_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp237_, VALA_TYPE_CREATION_METHOD)) {
					ValaCCodeFunction* _tmp238_;
					ValaCCodeFunction* _tmp239_;
					ValaCCodeIdentifier* _tmp240_;
					ValaCCodeIdentifier* _tmp241_;
					_tmp238_ = vala_ccode_base_module_get_ccode (self);
					_tmp239_ = _tmp238_;
					_tmp240_ = vala_ccode_identifier_new ("self");
					_tmp241_ = _tmp240_;
					vala_ccode_function_add_return (_tmp239_, (ValaCCodeExpression*) _tmp241_);
					_vala_ccode_node_unref0 (_tmp241_);
				} else {
					gboolean _tmp242_ = FALSE;
					ValaDataType* _tmp243_;
					ValaDataType* _tmp244_;
					_tmp243_ = vala_ccode_base_module_get_current_return_type (self);
					_tmp244_ = _tmp243_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp244_, VALA_TYPE_VOID_TYPE)) {
						_tmp242_ = TRUE;
					} else {
						ValaDataType* _tmp245_;
						ValaDataType* _tmp246_;
						gboolean _tmp247_;
						_tmp245_ = vala_ccode_base_module_get_current_return_type (self);
						_tmp246_ = _tmp245_;
						_tmp247_ = vala_data_type_is_real_non_null_struct_type (_tmp246_);
						_tmp242_ = _tmp247_;
					}
					if (_tmp242_) {
						ValaCCodeFunction* _tmp248_;
						ValaCCodeFunction* _tmp249_;
						_tmp248_ = vala_ccode_base_module_get_ccode (self);
						_tmp249_ = _tmp248_;
						vala_ccode_function_add_return (_tmp249_, NULL);
					} else {
						ValaCCodeFunction* _tmp250_;
						ValaCCodeFunction* _tmp251_;
						ValaCCodeIdentifier* _tmp252_;
						ValaCCodeIdentifier* _tmp253_;
						_tmp250_ = vala_ccode_base_module_get_ccode (self);
						_tmp251_ = _tmp250_;
						_tmp252_ = vala_ccode_identifier_new ("result");
						_tmp253_ = _tmp252_;
						vala_ccode_function_add_return (_tmp251_, (ValaCCodeExpression*) _tmp253_);
						_vala_ccode_node_unref0 (_tmp253_);
					}
				}
			}
		}
	}
	_tmp254_ = return_expression_symbol;
	if (_tmp254_ != NULL) {
		ValaSymbol* _tmp255_;
		_tmp255_ = return_expression_symbol;
		vala_symbol_set_active (_tmp255_, TRUE);
	}
	vala_ccode_base_module_set_current_method_return (self, TRUE);
	_vala_code_node_unref0 (return_expression_symbol);
}


gchar* vala_ccode_base_module_get_symbol_lock_name (ValaCCodeBaseModule* self, const gchar* symname) {
	gchar* result = NULL;
	const gchar* _tmp0_;
	gchar* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (symname != NULL, NULL);
	_tmp0_ = symname;
	_tmp1_ = g_strdup_printf ("__lock_%s", _tmp0_);
	result = _tmp1_;
	return result;
}


static ValaCCodeExpression* vala_ccode_base_module_get_lock_expression (ValaCCodeBaseModule* self, ValaStatement* stmt, ValaExpression* resource) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeExpression* l = NULL;
	ValaExpression* inner_node = NULL;
	ValaExpression* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	ValaSymbol* member = NULL;
	ValaExpression* _tmp4_;
	ValaSymbol* _tmp5_;
	ValaSymbol* _tmp6_;
	ValaSymbol* _tmp7_;
	ValaTypeSymbol* parent = NULL;
	ValaExpression* _tmp8_;
	ValaSymbol* _tmp9_;
	ValaSymbol* _tmp10_;
	ValaSymbol* _tmp11_;
	ValaSymbol* _tmp12_;
	ValaTypeSymbol* _tmp13_;
	ValaSymbol* _tmp14_;
	gboolean _tmp15_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (stmt != NULL, NULL);
	g_return_val_if_fail (resource != NULL, NULL);
	l = NULL;
	_tmp0_ = resource;
	_tmp1_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (_tmp2_);
	inner_node = _tmp3_;
	_tmp4_ = resource;
	_tmp5_ = vala_expression_get_symbol_reference (_tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = _vala_code_node_ref0 (_tmp6_);
	member = _tmp7_;
	_tmp8_ = resource;
	_tmp9_ = vala_expression_get_symbol_reference (_tmp8_);
	_tmp10_ = _tmp9_;
	_tmp11_ = vala_symbol_get_parent_symbol (_tmp10_);
	_tmp12_ = _tmp11_;
	_tmp13_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
	parent = _tmp13_;
	_tmp14_ = member;
	_tmp15_ = vala_symbol_is_instance_member (_tmp14_);
	if (_tmp15_) {
		ValaExpression* _tmp16_;
		ValaCCodeExpression* _tmp32_;
		ValaCCodeMemberAccess* _tmp33_;
		ValaCCodeMemberAccess* _tmp34_;
		ValaExpression* _tmp35_;
		ValaSymbol* _tmp36_;
		ValaSymbol* _tmp37_;
		const gchar* _tmp38_;
		const gchar* _tmp39_;
		gchar* _tmp40_;
		gchar* _tmp41_;
		ValaCCodeMemberAccess* _tmp42_;
		_tmp16_ = inner_node;
		if (_tmp16_ == NULL) {
			ValaCCodeIdentifier* _tmp17_;
			_tmp17_ = vala_ccode_identifier_new ("self");
			_vala_ccode_node_unref0 (l);
			l = (ValaCCodeExpression*) _tmp17_;
		} else {
			ValaExpression* _tmp18_;
			ValaSymbol* _tmp19_;
			ValaSymbol* _tmp20_;
			ValaSymbol* _tmp21_;
			ValaSymbol* _tmp22_;
			ValaTypeSymbol* _tmp23_;
			ValaTypeSymbol* _tmp24_;
			_tmp18_ = resource;
			_tmp19_ = vala_expression_get_symbol_reference (_tmp18_);
			_tmp20_ = _tmp19_;
			_tmp21_ = vala_symbol_get_parent_symbol (_tmp20_);
			_tmp22_ = _tmp21_;
			_tmp23_ = vala_ccode_base_module_get_current_type_symbol (self);
			_tmp24_ = _tmp23_;
			if (_tmp22_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, VALA_TYPE_SYMBOL, ValaSymbol)) {
				ValaExpression* _tmp25_;
				ValaCCodeExpression* _tmp26_;
				ValaCCodeExpression* _tmp27_;
				ValaTypeSymbol* _tmp28_;
				ValaCCodeFunctionCall* _tmp29_;
				_tmp25_ = inner_node;
				_tmp26_ = vala_ccode_base_module_get_cvalue (self, _tmp25_);
				_tmp27_ = _tmp26_;
				_tmp28_ = parent;
				_tmp29_ = vala_ccode_base_module_generate_instance_cast (self, _tmp27_, _tmp28_);
				_vala_ccode_node_unref0 (l);
				l = (ValaCCodeExpression*) _tmp29_;
				_vala_ccode_node_unref0 (_tmp27_);
			} else {
				ValaExpression* _tmp30_;
				ValaCCodeExpression* _tmp31_;
				_tmp30_ = inner_node;
				_tmp31_ = vala_ccode_base_module_get_cvalue (self, _tmp30_);
				_vala_ccode_node_unref0 (l);
				l = _tmp31_;
			}
		}
		_tmp32_ = l;
		_tmp33_ = vala_ccode_member_access_new_pointer (_tmp32_, "priv");
		_tmp34_ = _tmp33_;
		_tmp35_ = resource;
		_tmp36_ = vala_expression_get_symbol_reference (_tmp35_);
		_tmp37_ = _tmp36_;
		_tmp38_ = vala_symbol_get_name (_tmp37_);
		_tmp39_ = _tmp38_;
		_tmp40_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp39_);
		_tmp41_ = _tmp40_;
		_tmp42_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp34_, _tmp41_);
		_vala_ccode_node_unref0 (l);
		l = (ValaCCodeExpression*) _tmp42_;
		_g_free0 (_tmp41_);
		_vala_ccode_node_unref0 (_tmp34_);
	} else {
		ValaSymbol* _tmp43_;
		gboolean _tmp44_;
		_tmp43_ = member;
		_tmp44_ = vala_symbol_is_class_member (_tmp43_);
		if (_tmp44_) {
			ValaCCodeExpression* klass = NULL;
			ValaDataType* _tmp45_;
			ValaDataType* _tmp46_;
			gboolean _tmp47_;
			ValaCCodeFunctionCall* get_class_private_call = NULL;
			ValaTypeSymbol* _tmp58_;
			gchar* _tmp59_;
			gchar* _tmp60_;
			gchar* _tmp61_;
			gchar* _tmp62_;
			ValaCCodeIdentifier* _tmp63_;
			ValaCCodeIdentifier* _tmp64_;
			ValaCCodeFunctionCall* _tmp65_;
			ValaCCodeFunctionCall* _tmp66_;
			ValaCCodeFunctionCall* _tmp67_;
			ValaCCodeExpression* _tmp68_;
			ValaCCodeFunctionCall* _tmp69_;
			ValaExpression* _tmp70_;
			ValaSymbol* _tmp71_;
			ValaSymbol* _tmp72_;
			const gchar* _tmp73_;
			const gchar* _tmp74_;
			gchar* _tmp75_;
			gchar* _tmp76_;
			ValaCCodeMemberAccess* _tmp77_;
			_tmp45_ = vala_ccode_base_module_get_this_type (self);
			_tmp46_ = _tmp45_;
			_tmp47_ = _tmp46_ != NULL;
			_vala_code_node_unref0 (_tmp46_);
			if (_tmp47_) {
				ValaCCodeFunctionCall* k = NULL;
				ValaCCodeIdentifier* _tmp48_;
				ValaCCodeIdentifier* _tmp49_;
				ValaCCodeFunctionCall* _tmp50_;
				ValaCCodeFunctionCall* _tmp51_;
				ValaCCodeFunctionCall* _tmp52_;
				ValaCCodeIdentifier* _tmp53_;
				ValaCCodeIdentifier* _tmp54_;
				ValaCCodeFunctionCall* _tmp55_;
				ValaCCodeExpression* _tmp56_;
				_tmp48_ = vala_ccode_identifier_new ("G_OBJECT_GET_CLASS");
				_tmp49_ = _tmp48_;
				_tmp50_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp49_);
				_tmp51_ = _tmp50_;
				_vala_ccode_node_unref0 (_tmp49_);
				k = _tmp51_;
				_tmp52_ = k;
				_tmp53_ = vala_ccode_identifier_new ("self");
				_tmp54_ = _tmp53_;
				vala_ccode_function_call_add_argument (_tmp52_, (ValaCCodeExpression*) _tmp54_);
				_vala_ccode_node_unref0 (_tmp54_);
				_tmp55_ = k;
				_tmp56_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp55_);
				_vala_ccode_node_unref0 (klass);
				klass = _tmp56_;
				_vala_ccode_node_unref0 (k);
			} else {
				ValaCCodeIdentifier* _tmp57_;
				_tmp57_ = vala_ccode_identifier_new ("klass");
				_vala_ccode_node_unref0 (klass);
				klass = (ValaCCodeExpression*) _tmp57_;
			}
			_tmp58_ = parent;
			_tmp59_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp58_, NULL);
			_tmp60_ = _tmp59_;
			_tmp61_ = g_strdup_printf ("%s_GET_CLASS_PRIVATE", _tmp60_);
			_tmp62_ = _tmp61_;
			_tmp63_ = vala_ccode_identifier_new (_tmp62_);
			_tmp64_ = _tmp63_;
			_tmp65_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp64_);
			_tmp66_ = _tmp65_;
			_vala_ccode_node_unref0 (_tmp64_);
			_g_free0 (_tmp62_);
			_g_free0 (_tmp60_);
			get_class_private_call = _tmp66_;
			_tmp67_ = get_class_private_call;
			_tmp68_ = klass;
			vala_ccode_function_call_add_argument (_tmp67_, _tmp68_);
			_tmp69_ = get_class_private_call;
			_tmp70_ = resource;
			_tmp71_ = vala_expression_get_symbol_reference (_tmp70_);
			_tmp72_ = _tmp71_;
			_tmp73_ = vala_symbol_get_name (_tmp72_);
			_tmp74_ = _tmp73_;
			_tmp75_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp74_);
			_tmp76_ = _tmp75_;
			_tmp77_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp69_, _tmp76_);
			_vala_ccode_node_unref0 (l);
			l = (ValaCCodeExpression*) _tmp77_;
			_g_free0 (_tmp76_);
			_vala_ccode_node_unref0 (get_class_private_call);
			_vala_ccode_node_unref0 (klass);
		} else {
			gchar* lock_name = NULL;
			ValaTypeSymbol* _tmp78_;
			gchar* _tmp79_;
			gchar* _tmp80_;
			ValaExpression* _tmp81_;
			ValaSymbol* _tmp82_;
			ValaSymbol* _tmp83_;
			const gchar* _tmp84_;
			const gchar* _tmp85_;
			gchar* _tmp86_;
			gchar* _tmp87_;
			const gchar* _tmp88_;
			gchar* _tmp89_;
			gchar* _tmp90_;
			ValaCCodeIdentifier* _tmp91_;
			_tmp78_ = parent;
			_tmp79_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp78_, NULL);
			_tmp80_ = _tmp79_;
			_tmp81_ = resource;
			_tmp82_ = vala_expression_get_symbol_reference (_tmp81_);
			_tmp83_ = _tmp82_;
			_tmp84_ = vala_symbol_get_name (_tmp83_);
			_tmp85_ = _tmp84_;
			_tmp86_ = g_strdup_printf ("%s_%s", _tmp80_, _tmp85_);
			_tmp87_ = _tmp86_;
			_g_free0 (_tmp80_);
			lock_name = _tmp87_;
			_tmp88_ = lock_name;
			_tmp89_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp88_);
			_tmp90_ = _tmp89_;
			_tmp91_ = vala_ccode_identifier_new (_tmp90_);
			_vala_ccode_node_unref0 (l);
			l = (ValaCCodeExpression*) _tmp91_;
			_g_free0 (_tmp90_);
			_g_free0 (lock_name);
		}
	}
	result = l;
	_vala_code_node_unref0 (parent);
	_vala_code_node_unref0 (member);
	_vala_code_node_unref0 (inner_node);
	return result;
}


static void vala_ccode_base_module_real_visit_lock_statement (ValaCodeVisitor* base, ValaLockStatement* stmt) {
	ValaCCodeBaseModule * self;
	ValaCCodeExpression* l = NULL;
	ValaLockStatement* _tmp0_;
	ValaLockStatement* _tmp1_;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	ValaCCodeFunctionCall* fc = NULL;
	ValaStruct* _tmp5_;
	ValaScope* _tmp6_;
	ValaScope* _tmp7_;
	ValaSymbol* _tmp8_;
	ValaSymbol* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	ValaCCodeIdentifier* _tmp12_;
	ValaCCodeIdentifier* _tmp13_;
	ValaCCodeFunctionCall* _tmp14_;
	ValaCCodeFunctionCall* _tmp15_;
	ValaCCodeUnaryExpression* _tmp16_;
	ValaCCodeUnaryExpression* _tmp17_;
	ValaCCodeFunction* _tmp18_;
	ValaCCodeFunction* _tmp19_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (stmt != NULL);
	_tmp0_ = stmt;
	_tmp1_ = stmt;
	_tmp2_ = vala_lock_statement_get_resource (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_base_module_get_lock_expression (self, (ValaStatement*) _tmp0_, _tmp3_);
	l = _tmp4_;
	_tmp5_ = self->mutex_type;
	_tmp6_ = vala_symbol_get_scope ((ValaSymbol*) _tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = vala_scope_lookup (_tmp7_, "lock");
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = vala_ccode_identifier_new (_tmp11_);
	_tmp13_ = _tmp12_;
	_tmp14_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp13_);
	_tmp15_ = _tmp14_;
	_vala_ccode_node_unref0 (_tmp13_);
	_g_free0 (_tmp11_);
	_vala_code_node_unref0 (_tmp9_);
	fc = _tmp15_;
	_tmp16_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, l);
	_tmp17_ = _tmp16_;
	vala_ccode_function_call_add_argument (fc, (ValaCCodeExpression*) _tmp17_);
	_vala_ccode_node_unref0 (_tmp17_);
	_tmp18_ = vala_ccode_base_module_get_ccode (self);
	_tmp19_ = _tmp18_;
	vala_ccode_function_add_expression (_tmp19_, (ValaCCodeExpression*) fc);
	_vala_ccode_node_unref0 (fc);
	_vala_ccode_node_unref0 (l);
}


static void vala_ccode_base_module_real_visit_unlock_statement (ValaCodeVisitor* base, ValaUnlockStatement* stmt) {
	ValaCCodeBaseModule * self;
	ValaCCodeExpression* l = NULL;
	ValaUnlockStatement* _tmp0_;
	ValaUnlockStatement* _tmp1_;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	ValaCCodeFunctionCall* fc = NULL;
	ValaStruct* _tmp5_;
	ValaScope* _tmp6_;
	ValaScope* _tmp7_;
	ValaSymbol* _tmp8_;
	ValaSymbol* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	ValaCCodeIdentifier* _tmp12_;
	ValaCCodeIdentifier* _tmp13_;
	ValaCCodeFunctionCall* _tmp14_;
	ValaCCodeFunctionCall* _tmp15_;
	ValaCCodeUnaryExpression* _tmp16_;
	ValaCCodeUnaryExpression* _tmp17_;
	ValaCCodeFunction* _tmp18_;
	ValaCCodeFunction* _tmp19_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (stmt != NULL);
	_tmp0_ = stmt;
	_tmp1_ = stmt;
	_tmp2_ = vala_unlock_statement_get_resource (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_base_module_get_lock_expression (self, (ValaStatement*) _tmp0_, _tmp3_);
	l = _tmp4_;
	_tmp5_ = self->mutex_type;
	_tmp6_ = vala_symbol_get_scope ((ValaSymbol*) _tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = vala_scope_lookup (_tmp7_, "unlock");
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = vala_ccode_identifier_new (_tmp11_);
	_tmp13_ = _tmp12_;
	_tmp14_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp13_);
	_tmp15_ = _tmp14_;
	_vala_ccode_node_unref0 (_tmp13_);
	_g_free0 (_tmp11_);
	_vala_code_node_unref0 (_tmp9_);
	fc = _tmp15_;
	_tmp16_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, l);
	_tmp17_ = _tmp16_;
	vala_ccode_function_call_add_argument (fc, (ValaCCodeExpression*) _tmp17_);
	_vala_ccode_node_unref0 (_tmp17_);
	_tmp18_ = vala_ccode_base_module_get_ccode (self);
	_tmp19_ = _tmp18_;
	vala_ccode_function_add_expression (_tmp19_, (ValaCCodeExpression*) fc);
	_vala_ccode_node_unref0 (fc);
	_vala_ccode_node_unref0 (l);
}


static void vala_ccode_base_module_real_visit_delete_statement (ValaCodeVisitor* base, ValaDeleteStatement* stmt) {
	ValaCCodeBaseModule * self;
	ValaPointerType* pointer_type = NULL;
	ValaDeleteStatement* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	ValaDataType* _tmp3_;
	ValaDataType* _tmp4_;
	ValaPointerType* _tmp5_;
	ValaDataType* type = NULL;
	ValaPointerType* _tmp6_;
	ValaDataType* _tmp7_;
	gboolean _tmp8_ = FALSE;
	ValaPointerType* _tmp9_;
	ValaDataType* _tmp10_;
	ValaDataType* _tmp11_;
	ValaTypeSymbol* _tmp12_;
	ValaTypeSymbol* _tmp13_;
	ValaCCodeFunctionCall* ccall = NULL;
	ValaDataType* _tmp24_;
	ValaCCodeExpression* _tmp25_;
	ValaCCodeExpression* _tmp26_;
	ValaCCodeFunctionCall* _tmp27_;
	ValaCCodeFunctionCall* _tmp28_;
	ValaDeleteStatement* _tmp29_;
	ValaExpression* _tmp30_;
	ValaExpression* _tmp31_;
	ValaCCodeExpression* _tmp32_;
	ValaCCodeExpression* _tmp33_;
	ValaCCodeFunction* _tmp34_;
	ValaCCodeFunction* _tmp35_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (stmt != NULL);
	_tmp0_ = stmt;
	_tmp1_ = vala_delete_statement_get_expression (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_expression_get_value_type (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_POINTER_TYPE, ValaPointerType));
	pointer_type = _tmp5_;
	_tmp6_ = pointer_type;
	_tmp7_ = _vala_code_node_ref0 ((ValaDataType*) _tmp6_);
	type = _tmp7_;
	_tmp9_ = pointer_type;
	_tmp10_ = vala_pointer_type_get_base_type (_tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = vala_data_type_get_data_type (_tmp11_);
	_tmp13_ = _tmp12_;
	if (_tmp13_ != NULL) {
		ValaPointerType* _tmp14_;
		ValaDataType* _tmp15_;
		ValaDataType* _tmp16_;
		ValaTypeSymbol* _tmp17_;
		ValaTypeSymbol* _tmp18_;
		gboolean _tmp19_;
		_tmp14_ = pointer_type;
		_tmp15_ = vala_pointer_type_get_base_type (_tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = vala_data_type_get_data_type (_tmp16_);
		_tmp18_ = _tmp17_;
		_tmp19_ = vala_typesymbol_is_reference_type (_tmp18_);
		_tmp8_ = _tmp19_;
	} else {
		_tmp8_ = FALSE;
	}
	if (_tmp8_) {
		ValaPointerType* _tmp20_;
		ValaDataType* _tmp21_;
		ValaDataType* _tmp22_;
		ValaDataType* _tmp23_;
		_tmp20_ = pointer_type;
		_tmp21_ = vala_pointer_type_get_base_type (_tmp20_);
		_tmp22_ = _tmp21_;
		_tmp23_ = _vala_code_node_ref0 (_tmp22_);
		_vala_code_node_unref0 (type);
		type = _tmp23_;
	}
	_tmp24_ = type;
	_tmp25_ = vala_ccode_base_module_get_destroy_func_expression (self, _tmp24_, FALSE);
	_tmp26_ = _tmp25_;
	_tmp27_ = vala_ccode_function_call_new (_tmp26_);
	_tmp28_ = _tmp27_;
	_vala_ccode_node_unref0 (_tmp26_);
	ccall = _tmp28_;
	_tmp29_ = stmt;
	_tmp30_ = vala_delete_statement_get_expression (_tmp29_);
	_tmp31_ = _tmp30_;
	_tmp32_ = vala_ccode_base_module_get_cvalue (self, _tmp31_);
	_tmp33_ = _tmp32_;
	vala_ccode_function_call_add_argument (ccall, _tmp33_);
	_vala_ccode_node_unref0 (_tmp33_);
	_tmp34_ = vala_ccode_base_module_get_ccode (self);
	_tmp35_ = _tmp34_;
	vala_ccode_function_add_expression (_tmp35_, (ValaCCodeExpression*) ccall);
	_vala_ccode_node_unref0 (ccall);
	_vala_code_node_unref0 (type);
	_vala_code_node_unref0 (pointer_type);
}


static void vala_ccode_base_module_real_visit_expression (ValaCodeVisitor* base, ValaExpression* expr) {
	ValaCCodeBaseModule * self;
	gboolean _tmp0_ = FALSE;
	ValaExpression* _tmp1_;
	ValaCCodeExpression* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	gboolean _tmp4_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp1_ = expr;
	_tmp2_ = vala_ccode_base_module_get_cvalue (self, _tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = _tmp3_ != NULL;
	_vala_ccode_node_unref0 (_tmp3_);
	if (_tmp4_) {
		ValaExpression* _tmp5_;
		gboolean _tmp6_;
		gboolean _tmp7_;
		_tmp5_ = expr;
		_tmp6_ = vala_expression_get_lvalue (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp0_ = !_tmp7_;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		gboolean _tmp8_ = FALSE;
		ValaExpression* _tmp9_;
		ValaDataType* _tmp10_;
		ValaDataType* _tmp11_;
		ValaExpression* _tmp51_;
		ValaDataType* _tmp52_;
		ValaDataType* _tmp53_;
		ValaExpression* _tmp70_;
		ValaTargetValue* _tmp71_;
		ValaTargetValue* _tmp72_;
		gboolean _tmp73_ = FALSE;
		ValaExpression* _tmp74_;
		ValaDataType* _tmp75_;
		ValaDataType* _tmp76_;
		gboolean _tmp100_ = FALSE;
		ValaExpression* _tmp101_;
		ValaDataType* _tmp102_;
		ValaDataType* _tmp103_;
		_tmp9_ = expr;
		_tmp10_ = vala_expression_get_formal_value_type (_tmp9_);
		_tmp11_ = _tmp10_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp11_, VALA_TYPE_GENERIC_TYPE)) {
			ValaExpression* _tmp12_;
			ValaDataType* _tmp13_;
			ValaDataType* _tmp14_;
			_tmp12_ = expr;
			_tmp13_ = vala_expression_get_value_type (_tmp12_);
			_tmp14_ = _tmp13_;
			_tmp8_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp14_, VALA_TYPE_GENERIC_TYPE);
		} else {
			_tmp8_ = FALSE;
		}
		if (_tmp8_) {
			ValaStruct* st = NULL;
			ValaExpression* _tmp15_;
			ValaDataType* _tmp16_;
			ValaDataType* _tmp17_;
			ValaTypeParameter* _tmp18_;
			ValaTypeParameter* _tmp19_;
			ValaSymbol* _tmp20_;
			ValaSymbol* _tmp21_;
			ValaSymbol* _tmp22_;
			ValaSymbol* _tmp23_;
			ValaStruct* _tmp24_;
			gboolean _tmp25_ = FALSE;
			ValaExpression* _tmp26_;
			ValaDataType* _tmp27_;
			ValaDataType* _tmp28_;
			ValaTypeParameter* _tmp29_;
			ValaTypeParameter* _tmp30_;
			ValaSymbol* _tmp31_;
			ValaSymbol* _tmp32_;
			ValaTypeSymbol* _tmp33_;
			_tmp15_ = expr;
			_tmp16_ = vala_expression_get_formal_value_type (_tmp15_);
			_tmp17_ = _tmp16_;
			_tmp18_ = vala_data_type_get_type_parameter (_tmp17_);
			_tmp19_ = _tmp18_;
			_tmp20_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp19_);
			_tmp21_ = _tmp20_;
			_tmp22_ = vala_symbol_get_parent_symbol (_tmp21_);
			_tmp23_ = _tmp22_;
			_tmp24_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp23_) : NULL);
			st = _tmp24_;
			_tmp26_ = expr;
			_tmp27_ = vala_expression_get_formal_value_type (_tmp26_);
			_tmp28_ = _tmp27_;
			_tmp29_ = vala_data_type_get_type_parameter (_tmp28_);
			_tmp30_ = _tmp29_;
			_tmp31_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp30_);
			_tmp32_ = _tmp31_;
			_tmp33_ = self->garray_type;
			if (_tmp32_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_SYMBOL, ValaSymbol)) {
				gboolean _tmp34_ = FALSE;
				ValaStruct* _tmp35_;
				_tmp35_ = st;
				if (_tmp35_ == NULL) {
					_tmp34_ = TRUE;
				} else {
					ValaStruct* _tmp36_;
					gchar* _tmp37_;
					gchar* _tmp38_;
					_tmp36_ = st;
					_tmp37_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp36_);
					_tmp38_ = _tmp37_;
					_tmp34_ = g_strcmp0 (_tmp38_, "va_list") != 0;
					_g_free0 (_tmp38_);
				}
				_tmp25_ = _tmp34_;
			} else {
				_tmp25_ = FALSE;
			}
			if (_tmp25_) {
				ValaExpression* _tmp39_;
				ValaExpression* _tmp40_;
				ValaCCodeExpression* _tmp41_;
				ValaCCodeExpression* _tmp42_;
				ValaExpression* _tmp43_;
				ValaDataType* _tmp44_;
				ValaDataType* _tmp45_;
				ValaCCodeExpression* _tmp46_;
				ValaCCodeExpression* _tmp47_;
				ValaExpression* _tmp48_;
				ValaTargetValue* _tmp49_;
				ValaTargetValue* _tmp50_;
				_tmp39_ = expr;
				_tmp40_ = expr;
				_tmp41_ = vala_ccode_base_module_get_cvalue (self, _tmp40_);
				_tmp42_ = _tmp41_;
				_tmp43_ = expr;
				_tmp44_ = vala_expression_get_value_type (_tmp43_);
				_tmp45_ = _tmp44_;
				_tmp46_ = vala_ccode_base_module_convert_from_generic_pointer (self, _tmp42_, _tmp45_);
				_tmp47_ = _tmp46_;
				vala_ccode_base_module_set_cvalue (self, _tmp39_, _tmp47_);
				_vala_ccode_node_unref0 (_tmp47_);
				_vala_ccode_node_unref0 (_tmp42_);
				_tmp48_ = expr;
				_tmp49_ = vala_expression_get_target_value (_tmp48_);
				_tmp50_ = _tmp49_;
				G_TYPE_CHECK_INSTANCE_CAST (_tmp50_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = FALSE;
			}
			_vala_code_node_unref0 (st);
		}
		_tmp51_ = expr;
		_tmp52_ = vala_expression_get_value_type (_tmp51_);
		_tmp53_ = _tmp52_;
		if (_tmp53_ != NULL) {
			ValaExpression* _tmp54_;
			ValaTargetValue* _tmp55_;
			ValaTargetValue* _tmp56_;
			ValaExpression* _tmp57_;
			ValaDataType* _tmp58_;
			ValaDataType* _tmp59_;
			ValaExpression* _tmp60_;
			ValaExpression* _tmp61_;
			ValaTargetValue* _tmp62_;
			ValaTargetValue* _tmp63_;
			ValaExpression* _tmp64_;
			ValaDataType* _tmp65_;
			ValaDataType* _tmp66_;
			ValaExpression* _tmp67_;
			ValaTargetValue* _tmp68_;
			ValaTargetValue* _tmp69_;
			_tmp54_ = expr;
			_tmp55_ = vala_expression_get_target_value (_tmp54_);
			_tmp56_ = _tmp55_;
			_tmp57_ = expr;
			_tmp58_ = vala_expression_get_value_type (_tmp57_);
			_tmp59_ = _tmp58_;
			vala_target_value_set_value_type (_tmp56_, _tmp59_);
			_tmp60_ = expr;
			_tmp61_ = expr;
			_tmp62_ = vala_expression_get_target_value (_tmp61_);
			_tmp63_ = _tmp62_;
			_tmp64_ = expr;
			_tmp65_ = vala_expression_get_target_type (_tmp64_);
			_tmp66_ = _tmp65_;
			_tmp67_ = expr;
			_tmp68_ = vala_ccode_base_module_transform_value (self, _tmp63_, _tmp66_, (ValaCodeNode*) _tmp67_);
			_tmp69_ = _tmp68_;
			vala_expression_set_target_value (_tmp60_, _tmp69_);
			_vala_target_value_unref0 (_tmp69_);
		}
		_tmp70_ = expr;
		_tmp71_ = vala_expression_get_target_value (_tmp70_);
		_tmp72_ = _tmp71_;
		if (_tmp72_ == NULL) {
			return;
		}
		_tmp74_ = expr;
		_tmp75_ = vala_expression_get_formal_target_type (_tmp74_);
		_tmp76_ = _tmp75_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp76_, VALA_TYPE_GENERIC_TYPE)) {
			ValaExpression* _tmp77_;
			ValaDataType* _tmp78_;
			ValaDataType* _tmp79_;
			_tmp77_ = expr;
			_tmp78_ = vala_expression_get_target_type (_tmp77_);
			_tmp79_ = _tmp78_;
			_tmp73_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp79_, VALA_TYPE_GENERIC_TYPE);
		} else {
			_tmp73_ = FALSE;
		}
		if (_tmp73_) {
			ValaExpression* _tmp80_;
			ValaDataType* _tmp81_;
			ValaDataType* _tmp82_;
			ValaTypeParameter* _tmp83_;
			ValaTypeParameter* _tmp84_;
			ValaSymbol* _tmp85_;
			ValaSymbol* _tmp86_;
			ValaTypeSymbol* _tmp87_;
			_tmp80_ = expr;
			_tmp81_ = vala_expression_get_formal_target_type (_tmp80_);
			_tmp82_ = _tmp81_;
			_tmp83_ = vala_data_type_get_type_parameter (_tmp82_);
			_tmp84_ = _tmp83_;
			_tmp85_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp84_);
			_tmp86_ = _tmp85_;
			_tmp87_ = self->garray_type;
			if (_tmp86_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp87_, VALA_TYPE_SYMBOL, ValaSymbol)) {
				ValaExpression* _tmp88_;
				ValaExpression* _tmp89_;
				ValaCCodeExpression* _tmp90_;
				ValaCCodeExpression* _tmp91_;
				ValaExpression* _tmp92_;
				ValaDataType* _tmp93_;
				ValaDataType* _tmp94_;
				ValaCCodeExpression* _tmp95_;
				ValaCCodeExpression* _tmp96_;
				ValaExpression* _tmp97_;
				ValaTargetValue* _tmp98_;
				ValaTargetValue* _tmp99_;
				_tmp88_ = expr;
				_tmp89_ = expr;
				_tmp90_ = vala_ccode_base_module_get_cvalue (self, _tmp89_);
				_tmp91_ = _tmp90_;
				_tmp92_ = expr;
				_tmp93_ = vala_expression_get_target_type (_tmp92_);
				_tmp94_ = _tmp93_;
				_tmp95_ = vala_ccode_base_module_convert_to_generic_pointer (self, _tmp91_, _tmp94_);
				_tmp96_ = _tmp95_;
				vala_ccode_base_module_set_cvalue (self, _tmp88_, _tmp96_);
				_vala_ccode_node_unref0 (_tmp96_);
				_vala_ccode_node_unref0 (_tmp91_);
				_tmp97_ = expr;
				_tmp98_ = vala_expression_get_target_value (_tmp97_);
				_tmp99_ = _tmp98_;
				G_TYPE_CHECK_INSTANCE_CAST (_tmp99_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = FALSE;
			}
		}
		_tmp101_ = expr;
		_tmp102_ = vala_expression_get_value_type (_tmp101_);
		_tmp103_ = _tmp102_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp103_, VALA_TYPE_VALUE_TYPE)) {
			ValaExpression* _tmp104_;
			ValaDataType* _tmp105_;
			ValaDataType* _tmp106_;
			gboolean _tmp107_;
			gboolean _tmp108_;
			_tmp104_ = expr;
			_tmp105_ = vala_expression_get_value_type (_tmp104_);
			_tmp106_ = _tmp105_;
			_tmp107_ = vala_data_type_get_nullable (_tmp106_);
			_tmp108_ = _tmp107_;
			_tmp100_ = !_tmp108_;
		} else {
			_tmp100_ = FALSE;
		}
		if (!_tmp100_) {
			ValaExpression* _tmp109_;
			ValaTargetValue* _tmp110_;
			ValaTargetValue* _tmp111_;
			ValaExpression* _tmp112_;
			gboolean _tmp113_;
			_tmp109_ = expr;
			_tmp110_ = vala_expression_get_target_value (_tmp109_);
			_tmp111_ = _tmp110_;
			_tmp112_ = expr;
			_tmp113_ = vala_expression_is_non_null (_tmp112_);
			G_TYPE_CHECK_INSTANCE_CAST (_tmp111_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->non_null = _tmp113_;
		}
	}
}


static void vala_ccode_base_module_real_visit_boolean_literal (ValaCodeVisitor* base, ValaBooleanLiteral* expr) {
	ValaCCodeBaseModule * self;
	const gchar* _tmp0_ = NULL;
	ValaBooleanLiteral* _tmp1_;
	gboolean _tmp2_;
	gboolean _tmp3_;
	ValaBooleanLiteral* _tmp4_;
	ValaCCodeConstant* _tmp5_;
	ValaCCodeConstant* _tmp6_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp1_ = expr;
	_tmp2_ = vala_boolean_literal_get_value (_tmp1_);
	_tmp3_ = _tmp2_;
	if (_tmp3_) {
		_tmp0_ = "TRUE";
	} else {
		_tmp0_ = "FALSE";
	}
	_tmp4_ = expr;
	_tmp5_ = vala_ccode_constant_new (_tmp0_);
	_tmp6_ = _tmp5_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp4_, (ValaCCodeExpression*) _tmp6_);
	_vala_ccode_node_unref0 (_tmp6_);
}


static void vala_ccode_base_module_real_visit_character_literal (ValaCodeVisitor* base, ValaCharacterLiteral* expr) {
	ValaCCodeBaseModule * self;
	gboolean _tmp0_ = FALSE;
	ValaCharacterLiteral* _tmp1_;
	gunichar _tmp2_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp1_ = expr;
	_tmp2_ = vala_character_literal_get_char (_tmp1_);
	if (_tmp2_ >= ((gunichar) 0x20)) {
		ValaCharacterLiteral* _tmp3_;
		gunichar _tmp4_;
		_tmp3_ = expr;
		_tmp4_ = vala_character_literal_get_char (_tmp3_);
		_tmp0_ = _tmp4_ < ((gunichar) 0x80);
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		ValaCharacterLiteral* _tmp5_;
		ValaCharacterLiteral* _tmp6_;
		const gchar* _tmp7_;
		const gchar* _tmp8_;
		ValaCCodeConstant* _tmp9_;
		ValaCCodeConstant* _tmp10_;
		_tmp5_ = expr;
		_tmp6_ = expr;
		_tmp7_ = vala_character_literal_get_value (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = vala_ccode_constant_new (_tmp8_);
		_tmp10_ = _tmp9_;
		vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp5_, (ValaCCodeExpression*) _tmp10_);
		_vala_ccode_node_unref0 (_tmp10_);
	} else {
		ValaCharacterLiteral* _tmp11_;
		ValaCharacterLiteral* _tmp12_;
		gunichar _tmp13_;
		gchar* _tmp14_;
		gchar* _tmp15_;
		ValaCCodeConstant* _tmp16_;
		ValaCCodeConstant* _tmp17_;
		_tmp11_ = expr;
		_tmp12_ = expr;
		_tmp13_ = vala_character_literal_get_char (_tmp12_);
		_tmp14_ = g_strdup_printf ("%uU", (guint) _tmp13_);
		_tmp15_ = _tmp14_;
		_tmp16_ = vala_ccode_constant_new (_tmp15_);
		_tmp17_ = _tmp16_;
		vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp11_, (ValaCCodeExpression*) _tmp17_);
		_vala_ccode_node_unref0 (_tmp17_);
		_g_free0 (_tmp15_);
	}
}


static void vala_ccode_base_module_real_visit_integer_literal (ValaCodeVisitor* base, ValaIntegerLiteral* expr) {
	ValaCCodeBaseModule * self;
	ValaIntegerLiteral* _tmp0_;
	ValaIntegerLiteral* _tmp1_;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	ValaIntegerLiteral* _tmp4_;
	const gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	ValaCCodeConstant* _tmp9_;
	ValaCCodeConstant* _tmp10_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = expr;
	_tmp2_ = vala_integer_literal_get_value (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = expr;
	_tmp5_ = vala_integer_literal_get_type_suffix (_tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = g_strconcat (_tmp3_, _tmp6_, NULL);
	_tmp8_ = _tmp7_;
	_tmp9_ = vala_ccode_constant_new (_tmp8_);
	_tmp10_ = _tmp9_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp0_, (ValaCCodeExpression*) _tmp10_);
	_vala_ccode_node_unref0 (_tmp10_);
	_g_free0 (_tmp8_);
}


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


static gchar* string_substring (const gchar* self, glong offset, glong len) {
	gchar* result = NULL;
	glong string_length = 0L;
	gboolean _tmp0_ = FALSE;
	glong _tmp1_;
	glong _tmp8_;
	glong _tmp14_;
	glong _tmp17_;
	glong _tmp18_;
	glong _tmp19_;
	glong _tmp20_;
	glong _tmp21_;
	gchar* _tmp22_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp1_ = offset;
	if (_tmp1_ >= ((glong) 0)) {
		glong _tmp2_;
		_tmp2_ = len;
		_tmp0_ = _tmp2_ >= ((glong) 0);
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		glong _tmp3_;
		glong _tmp4_;
		glong _tmp5_;
		_tmp3_ = offset;
		_tmp4_ = len;
		_tmp5_ = string_strnlen ((gchar*) self, _tmp3_ + _tmp4_);
		string_length = _tmp5_;
	} else {
		gint _tmp6_;
		gint _tmp7_;
		_tmp6_ = strlen (self);
		_tmp7_ = _tmp6_;
		string_length = (glong) _tmp7_;
	}
	_tmp8_ = offset;
	if (_tmp8_ < ((glong) 0)) {
		glong _tmp9_;
		glong _tmp10_;
		glong _tmp11_;
		_tmp9_ = string_length;
		_tmp10_ = offset;
		offset = _tmp9_ + _tmp10_;
		_tmp11_ = offset;
		g_return_val_if_fail (_tmp11_ >= ((glong) 0), NULL);
	} else {
		glong _tmp12_;
		glong _tmp13_;
		_tmp12_ = offset;
		_tmp13_ = string_length;
		g_return_val_if_fail (_tmp12_ <= _tmp13_, NULL);
	}
	_tmp14_ = len;
	if (_tmp14_ < ((glong) 0)) {
		glong _tmp15_;
		glong _tmp16_;
		_tmp15_ = string_length;
		_tmp16_ = offset;
		len = _tmp15_ - _tmp16_;
	}
	_tmp17_ = offset;
	_tmp18_ = len;
	_tmp19_ = string_length;
	g_return_val_if_fail ((_tmp17_ + _tmp18_) <= _tmp19_, NULL);
	_tmp20_ = offset;
	_tmp21_ = len;
	_tmp22_ = g_strndup (((gchar*) self) + _tmp20_, (gsize) _tmp21_);
	result = _tmp22_;
	return result;
}


static gboolean string_contains (const gchar* self, const gchar* needle) {
	gboolean result = FALSE;
	const gchar* _tmp0_;
	gchar* _tmp1_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (needle != NULL, FALSE);
	_tmp0_ = needle;
	_tmp1_ = strstr ((gchar*) self, (gchar*) _tmp0_);
	result = _tmp1_ != NULL;
	return result;
}


static void vala_ccode_base_module_real_visit_real_literal (ValaCodeVisitor* base, ValaRealLiteral* expr) {
	ValaCCodeBaseModule * self;
	gchar* c_literal = NULL;
	ValaRealLiteral* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gboolean _tmp4_ = FALSE;
	const gchar* _tmp5_;
	gboolean _tmp6_;
	gboolean _tmp14_ = FALSE;
	gboolean _tmp15_ = FALSE;
	const gchar* _tmp16_;
	gboolean _tmp17_;
	ValaRealLiteral* _tmp36_;
	const gchar* _tmp37_;
	ValaCCodeConstant* _tmp38_;
	ValaCCodeConstant* _tmp39_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_real_literal_get_value (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = g_strdup (_tmp2_);
	c_literal = _tmp3_;
	_tmp5_ = c_literal;
	_tmp6_ = g_str_has_suffix (_tmp5_, "d");
	if (_tmp6_) {
		_tmp4_ = TRUE;
	} else {
		const gchar* _tmp7_;
		gboolean _tmp8_;
		_tmp7_ = c_literal;
		_tmp8_ = g_str_has_suffix (_tmp7_, "D");
		_tmp4_ = _tmp8_;
	}
	if (_tmp4_) {
		const gchar* _tmp9_;
		const gchar* _tmp10_;
		gint _tmp11_;
		gint _tmp12_;
		gchar* _tmp13_;
		_tmp9_ = c_literal;
		_tmp10_ = c_literal;
		_tmp11_ = strlen (_tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = string_substring (_tmp9_, (glong) 0, (glong) (_tmp12_ - 1));
		_g_free0 (c_literal);
		c_literal = _tmp13_;
	}
	_tmp16_ = c_literal;
	_tmp17_ = string_contains (_tmp16_, ".");
	if (_tmp17_) {
		_tmp15_ = TRUE;
	} else {
		const gchar* _tmp18_;
		gboolean _tmp19_;
		_tmp18_ = c_literal;
		_tmp19_ = string_contains (_tmp18_, "e");
		_tmp15_ = _tmp19_;
	}
	if (_tmp15_) {
		_tmp14_ = TRUE;
	} else {
		const gchar* _tmp20_;
		gboolean _tmp21_;
		_tmp20_ = c_literal;
		_tmp21_ = string_contains (_tmp20_, "E");
		_tmp14_ = _tmp21_;
	}
	if (!_tmp14_) {
		gboolean _tmp22_ = FALSE;
		const gchar* _tmp23_;
		gboolean _tmp24_;
		_tmp23_ = c_literal;
		_tmp24_ = string_contains (_tmp23_, "f");
		if (_tmp24_) {
			_tmp22_ = TRUE;
		} else {
			const gchar* _tmp25_;
			gboolean _tmp26_;
			_tmp25_ = c_literal;
			_tmp26_ = string_contains (_tmp25_, "F");
			_tmp22_ = _tmp26_;
		}
		if (_tmp22_) {
			const gchar* _tmp27_;
			const gchar* _tmp28_;
			gint _tmp29_;
			gint _tmp30_;
			gchar* _tmp31_;
			gchar* _tmp32_;
			gchar* _tmp33_;
			_tmp27_ = c_literal;
			_tmp28_ = c_literal;
			_tmp29_ = strlen (_tmp28_);
			_tmp30_ = _tmp29_;
			_tmp31_ = string_substring (_tmp27_, (glong) 0, (glong) (_tmp30_ - 1));
			_tmp32_ = _tmp31_;
			_tmp33_ = g_strconcat (_tmp32_, ".f", NULL);
			_g_free0 (c_literal);
			c_literal = _tmp33_;
			_g_free0 (_tmp32_);
		} else {
			const gchar* _tmp34_;
			gchar* _tmp35_;
			_tmp34_ = c_literal;
			_tmp35_ = g_strconcat (_tmp34_, ".", NULL);
			_g_free0 (c_literal);
			c_literal = _tmp35_;
		}
	}
	_tmp36_ = expr;
	_tmp37_ = c_literal;
	_tmp38_ = vala_ccode_constant_new (_tmp37_);
	_tmp39_ = _tmp38_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp36_, (ValaCCodeExpression*) _tmp39_);
	_vala_ccode_node_unref0 (_tmp39_);
	_g_free0 (c_literal);
}


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


static void vala_ccode_base_module_real_visit_string_literal (ValaCodeVisitor* base, ValaStringLiteral* expr) {
	ValaCCodeBaseModule * self;
	ValaStringLiteral* _tmp0_;
	ValaStringLiteral* _tmp1_;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	ValaCCodeConstant* _tmp6_;
	ValaCCodeConstant* _tmp7_;
	ValaStringLiteral* _tmp8_;
	gboolean _tmp9_;
	gboolean _tmp10_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = expr;
	_tmp2_ = vala_string_literal_get_value (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = string_replace (_tmp3_, "\n", "\\n");
	_tmp5_ = _tmp4_;
	_tmp6_ = vala_ccode_constant_new_string (_tmp5_);
	_tmp7_ = _tmp6_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp0_, (ValaCCodeExpression*) _tmp7_);
	_vala_ccode_node_unref0 (_tmp7_);
	_g_free0 (_tmp5_);
	_tmp8_ = expr;
	_tmp9_ = vala_string_literal_get_translate (_tmp8_);
	_tmp10_ = _tmp9_;
	if (_tmp10_) {
		ValaMethod* m = NULL;
		ValaSymbol* _tmp11_;
		ValaScope* _tmp12_;
		ValaScope* _tmp13_;
		ValaSymbol* _tmp14_;
		ValaSymbol* _tmp15_;
		ValaScope* _tmp16_;
		ValaScope* _tmp17_;
		ValaSymbol* _tmp18_;
		ValaMethod* _tmp19_;
		ValaCCodeFile* _tmp20_;
		ValaMethod* _tmp21_;
		ValaMethod* _tmp22_;
		gchar* _tmp23_;
		gchar* _tmp24_;
		ValaCCodeFunctionCall* translate = NULL;
		ValaCCodeIdentifier* _tmp25_;
		ValaCCodeIdentifier* _tmp26_;
		ValaCCodeFunctionCall* _tmp27_;
		ValaCCodeFunctionCall* _tmp28_;
		ValaCCodeFunctionCall* _tmp29_;
		ValaStringLiteral* _tmp30_;
		ValaCCodeExpression* _tmp31_;
		ValaCCodeExpression* _tmp32_;
		ValaStringLiteral* _tmp33_;
		ValaCCodeFunctionCall* _tmp34_;
		_tmp11_ = self->root_symbol;
		_tmp12_ = vala_symbol_get_scope (_tmp11_);
		_tmp13_ = _tmp12_;
		_tmp14_ = vala_scope_lookup (_tmp13_, "GLib");
		_tmp15_ = _tmp14_;
		_tmp16_ = vala_symbol_get_scope (_tmp15_);
		_tmp17_ = _tmp16_;
		_tmp18_ = vala_scope_lookup (_tmp17_, "_");
		_tmp19_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp18_, VALA_TYPE_METHOD, ValaMethod);
		_vala_code_node_unref0 (_tmp15_);
		m = _tmp19_;
		_tmp20_ = self->cfile;
		_tmp21_ = m;
		_tmp22_ = m;
		_tmp23_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp22_);
		_tmp24_ = _tmp23_;
		vala_ccode_base_module_add_symbol_declaration (self, _tmp20_, (ValaSymbol*) _tmp21_, _tmp24_);
		_g_free0 (_tmp24_);
		_tmp25_ = vala_ccode_identifier_new ("_");
		_tmp26_ = _tmp25_;
		_tmp27_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp26_);
		_tmp28_ = _tmp27_;
		_vala_ccode_node_unref0 (_tmp26_);
		translate = _tmp28_;
		_tmp29_ = translate;
		_tmp30_ = expr;
		_tmp31_ = vala_ccode_base_module_get_cvalue (self, (ValaExpression*) _tmp30_);
		_tmp32_ = _tmp31_;
		vala_ccode_function_call_add_argument (_tmp29_, _tmp32_);
		_vala_ccode_node_unref0 (_tmp32_);
		_tmp33_ = expr;
		_tmp34_ = translate;
		vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp33_, (ValaCCodeExpression*) _tmp34_);
		_vala_ccode_node_unref0 (translate);
		_vala_code_node_unref0 (m);
	}
}


static void vala_ccode_base_module_real_visit_regex_literal (ValaCodeVisitor* base, ValaRegexLiteral* expr) {
	ValaCCodeBaseModule * self;
	gchar** parts = NULL;
	ValaRegexLiteral* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar** _tmp3_;
	gchar** _tmp4_;
	gint parts_length1;
	gint _parts_size_;
	gchar* re = NULL;
	gchar** _tmp5_;
	gint _tmp5__length1;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* flags = NULL;
	gchar* _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	const gchar* _tmp10_;
	gboolean _tmp11_;
	gchar** _tmp14_;
	gint _tmp14__length1;
	const gchar* _tmp15_;
	gboolean _tmp16_;
	gchar** _tmp19_;
	gint _tmp19__length1;
	const gchar* _tmp20_;
	gboolean _tmp21_;
	gchar** _tmp24_;
	gint _tmp24__length1;
	const gchar* _tmp25_;
	gboolean _tmp26_;
	ValaCCodeDeclaration* _cdecl_ = NULL;
	ValaCCodeDeclaration* _tmp29_;
	gchar* cname = NULL;
	gint _tmp30_;
	gchar* _tmp31_;
	gint _tmp32_;
	gint _tmp97_;
	ValaCCodeDeclaration* _tmp98_;
	const gchar* _tmp99_;
	gchar* _tmp100_;
	gchar* _tmp101_;
	ValaCCodeVariableDeclarator* _tmp102_;
	ValaCCodeVariableDeclarator* _tmp103_;
	ValaCCodeDeclaration* _tmp104_;
	ValaCCodeConstant* regex_const = NULL;
	const gchar* _tmp105_;
	const gchar* _tmp106_;
	const gchar* _tmp107_;
	gchar* _tmp108_;
	gchar* _tmp109_;
	ValaCCodeConstant* _tmp110_;
	ValaCCodeConstant* _tmp111_;
	ValaCCodeFile* _tmp112_;
	ValaCCodeDeclaration* _tmp113_;
	ValaRegexLiteral* _tmp114_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_regex_literal_get_value (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp4_ = _tmp3_ = g_strsplit (_tmp2_, "/", 3);
	parts = _tmp4_;
	parts_length1 = _vala_array_length (_tmp3_);
	_parts_size_ = parts_length1;
	_tmp5_ = parts;
	_tmp5__length1 = parts_length1;
	_tmp6_ = _tmp5_[2];
	_tmp7_ = g_strescape (_tmp6_, "");
	re = _tmp7_;
	_tmp8_ = g_strdup ("0");
	flags = _tmp8_;
	_tmp9_ = parts;
	_tmp9__length1 = parts_length1;
	_tmp10_ = _tmp9_[1];
	_tmp11_ = string_contains (_tmp10_, "i");
	if (_tmp11_) {
		const gchar* _tmp12_;
		gchar* _tmp13_;
		_tmp12_ = flags;
		_tmp13_ = g_strconcat (_tmp12_, " | G_REGEX_CASELESS", NULL);
		_g_free0 (flags);
		flags = _tmp13_;
	}
	_tmp14_ = parts;
	_tmp14__length1 = parts_length1;
	_tmp15_ = _tmp14_[1];
	_tmp16_ = string_contains (_tmp15_, "m");
	if (_tmp16_) {
		const gchar* _tmp17_;
		gchar* _tmp18_;
		_tmp17_ = flags;
		_tmp18_ = g_strconcat (_tmp17_, " | G_REGEX_MULTILINE", NULL);
		_g_free0 (flags);
		flags = _tmp18_;
	}
	_tmp19_ = parts;
	_tmp19__length1 = parts_length1;
	_tmp20_ = _tmp19_[1];
	_tmp21_ = string_contains (_tmp20_, "s");
	if (_tmp21_) {
		const gchar* _tmp22_;
		gchar* _tmp23_;
		_tmp22_ = flags;
		_tmp23_ = g_strconcat (_tmp22_, " | G_REGEX_DOTALL", NULL);
		_g_free0 (flags);
		flags = _tmp23_;
	}
	_tmp24_ = parts;
	_tmp24__length1 = parts_length1;
	_tmp25_ = _tmp24_[1];
	_tmp26_ = string_contains (_tmp25_, "x");
	if (_tmp26_) {
		const gchar* _tmp27_;
		gchar* _tmp28_;
		_tmp27_ = flags;
		_tmp28_ = g_strconcat (_tmp27_, " | G_REGEX_EXTENDED", NULL);
		_g_free0 (flags);
		flags = _tmp28_;
	}
	_tmp29_ = vala_ccode_declaration_new ("GRegex*");
	_cdecl_ = _tmp29_;
	_tmp30_ = self->next_regex_id;
	_tmp31_ = g_strdup_printf ("_tmp_regex_%d", _tmp30_);
	cname = _tmp31_;
	_tmp32_ = self->next_regex_id;
	if (_tmp32_ == 0) {
		ValaCCodeFunction* fun = NULL;
		ValaCCodeFunction* _tmp33_;
		ValaCCodeFunction* _tmp34_;
		ValaCCodeFunction* _tmp35_;
		ValaCCodeParameter* _tmp36_;
		ValaCCodeParameter* _tmp37_;
		ValaCCodeFunction* _tmp38_;
		ValaCCodeParameter* _tmp39_;
		ValaCCodeParameter* _tmp40_;
		ValaCCodeFunction* _tmp41_;
		ValaCCodeParameter* _tmp42_;
		ValaCCodeParameter* _tmp43_;
		ValaCCodeFunction* _tmp44_;
		ValaCCodeFunctionCall* once_enter_call = NULL;
		ValaCCodeIdentifier* _tmp45_;
		ValaCCodeIdentifier* _tmp46_;
		ValaCCodeFunctionCall* _tmp47_;
		ValaCCodeFunctionCall* _tmp48_;
		ValaCCodeFunctionCall* _tmp49_;
		ValaCCodeConstant* _tmp50_;
		ValaCCodeConstant* _tmp51_;
		ValaCCodeFunction* _tmp52_;
		ValaCCodeFunction* _tmp53_;
		ValaCCodeFunctionCall* _tmp54_;
		ValaCCodeFunctionCall* regex_new_call = NULL;
		ValaCCodeIdentifier* _tmp55_;
		ValaCCodeIdentifier* _tmp56_;
		ValaCCodeFunctionCall* _tmp57_;
		ValaCCodeFunctionCall* _tmp58_;
		ValaCCodeFunctionCall* _tmp59_;
		ValaCCodeConstant* _tmp60_;
		ValaCCodeConstant* _tmp61_;
		ValaCCodeFunctionCall* _tmp62_;
		ValaCCodeConstant* _tmp63_;
		ValaCCodeConstant* _tmp64_;
		ValaCCodeFunctionCall* _tmp65_;
		ValaCCodeConstant* _tmp66_;
		ValaCCodeConstant* _tmp67_;
		ValaCCodeFunctionCall* _tmp68_;
		ValaCCodeConstant* _tmp69_;
		ValaCCodeConstant* _tmp70_;
		ValaCCodeFunction* _tmp71_;
		ValaCCodeFunction* _tmp72_;
		ValaCCodeIdentifier* _tmp73_;
		ValaCCodeIdentifier* _tmp74_;
		ValaCCodeFunctionCall* _tmp75_;
		ValaCCodeFunctionCall* once_leave_call = NULL;
		ValaCCodeIdentifier* _tmp76_;
		ValaCCodeIdentifier* _tmp77_;
		ValaCCodeFunctionCall* _tmp78_;
		ValaCCodeFunctionCall* _tmp79_;
		ValaCCodeFunctionCall* _tmp80_;
		ValaCCodeConstant* _tmp81_;
		ValaCCodeConstant* _tmp82_;
		ValaCCodeFunctionCall* _tmp83_;
		ValaCCodeConstant* _tmp84_;
		ValaCCodeConstant* _tmp85_;
		ValaCCodeFunction* _tmp86_;
		ValaCCodeFunction* _tmp87_;
		ValaCCodeFunctionCall* _tmp88_;
		ValaCCodeFunction* _tmp89_;
		ValaCCodeFunction* _tmp90_;
		ValaCCodeFunction* _tmp91_;
		ValaCCodeFunction* _tmp92_;
		ValaCCodeIdentifier* _tmp93_;
		ValaCCodeIdentifier* _tmp94_;
		ValaCCodeFile* _tmp95_;
		ValaCCodeFunction* _tmp96_;
		_tmp33_ = vala_ccode_function_new ("_thread_safe_regex_init", "GRegex*");
		fun = _tmp33_;
		_tmp34_ = fun;
		vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp34_, VALA_CCODE_MODIFIERS_STATIC | VALA_CCODE_MODIFIERS_INLINE);
		_tmp35_ = fun;
		_tmp36_ = vala_ccode_parameter_new ("re", "GRegex**");
		_tmp37_ = _tmp36_;
		vala_ccode_function_add_parameter (_tmp35_, _tmp37_);
		_vala_ccode_node_unref0 (_tmp37_);
		_tmp38_ = fun;
		_tmp39_ = vala_ccode_parameter_new ("pattern", "const gchar *");
		_tmp40_ = _tmp39_;
		vala_ccode_function_add_parameter (_tmp38_, _tmp40_);
		_vala_ccode_node_unref0 (_tmp40_);
		_tmp41_ = fun;
		_tmp42_ = vala_ccode_parameter_new ("match_options", "GRegexMatchFlags");
		_tmp43_ = _tmp42_;
		vala_ccode_function_add_parameter (_tmp41_, _tmp43_);
		_vala_ccode_node_unref0 (_tmp43_);
		_tmp44_ = fun;
		vala_ccode_base_module_push_function (self, _tmp44_);
		_tmp45_ = vala_ccode_identifier_new ("g_once_init_enter");
		_tmp46_ = _tmp45_;
		_tmp47_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp46_);
		_tmp48_ = _tmp47_;
		_vala_ccode_node_unref0 (_tmp46_);
		once_enter_call = _tmp48_;
		_tmp49_ = once_enter_call;
		_tmp50_ = vala_ccode_constant_new ("(volatile gsize*) re");
		_tmp51_ = _tmp50_;
		vala_ccode_function_call_add_argument (_tmp49_, (ValaCCodeExpression*) _tmp51_);
		_vala_ccode_node_unref0 (_tmp51_);
		_tmp52_ = vala_ccode_base_module_get_ccode (self);
		_tmp53_ = _tmp52_;
		_tmp54_ = once_enter_call;
		vala_ccode_function_open_if (_tmp53_, (ValaCCodeExpression*) _tmp54_);
		_tmp55_ = vala_ccode_identifier_new ("g_regex_new");
		_tmp56_ = _tmp55_;
		_tmp57_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp56_);
		_tmp58_ = _tmp57_;
		_vala_ccode_node_unref0 (_tmp56_);
		regex_new_call = _tmp58_;
		_tmp59_ = regex_new_call;
		_tmp60_ = vala_ccode_constant_new ("pattern");
		_tmp61_ = _tmp60_;
		vala_ccode_function_call_add_argument (_tmp59_, (ValaCCodeExpression*) _tmp61_);
		_vala_ccode_node_unref0 (_tmp61_);
		_tmp62_ = regex_new_call;
		_tmp63_ = vala_ccode_constant_new ("match_options");
		_tmp64_ = _tmp63_;
		vala_ccode_function_call_add_argument (_tmp62_, (ValaCCodeExpression*) _tmp64_);
		_vala_ccode_node_unref0 (_tmp64_);
		_tmp65_ = regex_new_call;
		_tmp66_ = vala_ccode_constant_new ("0");
		_tmp67_ = _tmp66_;
		vala_ccode_function_call_add_argument (_tmp65_, (ValaCCodeExpression*) _tmp67_);
		_vala_ccode_node_unref0 (_tmp67_);
		_tmp68_ = regex_new_call;
		_tmp69_ = vala_ccode_constant_new ("NULL");
		_tmp70_ = _tmp69_;
		vala_ccode_function_call_add_argument (_tmp68_, (ValaCCodeExpression*) _tmp70_);
		_vala_ccode_node_unref0 (_tmp70_);
		_tmp71_ = vala_ccode_base_module_get_ccode (self);
		_tmp72_ = _tmp71_;
		_tmp73_ = vala_ccode_identifier_new ("GRegex* val");
		_tmp74_ = _tmp73_;
		_tmp75_ = regex_new_call;
		vala_ccode_function_add_assignment (_tmp72_, (ValaCCodeExpression*) _tmp74_, (ValaCCodeExpression*) _tmp75_);
		_vala_ccode_node_unref0 (_tmp74_);
		_tmp76_ = vala_ccode_identifier_new ("g_once_init_leave");
		_tmp77_ = _tmp76_;
		_tmp78_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp77_);
		_tmp79_ = _tmp78_;
		_vala_ccode_node_unref0 (_tmp77_);
		once_leave_call = _tmp79_;
		_tmp80_ = once_leave_call;
		_tmp81_ = vala_ccode_constant_new ("(volatile gsize*) re");
		_tmp82_ = _tmp81_;
		vala_ccode_function_call_add_argument (_tmp80_, (ValaCCodeExpression*) _tmp82_);
		_vala_ccode_node_unref0 (_tmp82_);
		_tmp83_ = once_leave_call;
		_tmp84_ = vala_ccode_constant_new ("(gsize) val");
		_tmp85_ = _tmp84_;
		vala_ccode_function_call_add_argument (_tmp83_, (ValaCCodeExpression*) _tmp85_);
		_vala_ccode_node_unref0 (_tmp85_);
		_tmp86_ = vala_ccode_base_module_get_ccode (self);
		_tmp87_ = _tmp86_;
		_tmp88_ = once_leave_call;
		vala_ccode_function_add_expression (_tmp87_, (ValaCCodeExpression*) _tmp88_);
		_tmp89_ = vala_ccode_base_module_get_ccode (self);
		_tmp90_ = _tmp89_;
		vala_ccode_function_close (_tmp90_);
		_tmp91_ = vala_ccode_base_module_get_ccode (self);
		_tmp92_ = _tmp91_;
		_tmp93_ = vala_ccode_identifier_new ("*re");
		_tmp94_ = _tmp93_;
		vala_ccode_function_add_return (_tmp92_, (ValaCCodeExpression*) _tmp94_);
		_vala_ccode_node_unref0 (_tmp94_);
		vala_ccode_base_module_pop_function (self);
		_tmp95_ = self->cfile;
		_tmp96_ = fun;
		vala_ccode_file_add_function (_tmp95_, _tmp96_);
		_vala_ccode_node_unref0 (once_leave_call);
		_vala_ccode_node_unref0 (regex_new_call);
		_vala_ccode_node_unref0 (once_enter_call);
		_vala_ccode_node_unref0 (fun);
	}
	_tmp97_ = self->next_regex_id;
	self->next_regex_id = _tmp97_ + 1;
	_tmp98_ = _cdecl_;
	_tmp99_ = cname;
	_tmp100_ = g_strconcat (_tmp99_, " = NULL", NULL);
	_tmp101_ = _tmp100_;
	_tmp102_ = vala_ccode_variable_declarator_new (_tmp101_, NULL, NULL);
	_tmp103_ = _tmp102_;
	vala_ccode_declaration_add_declarator (_tmp98_, (ValaCCodeDeclarator*) _tmp103_);
	_vala_ccode_node_unref0 (_tmp103_);
	_g_free0 (_tmp101_);
	_tmp104_ = _cdecl_;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp104_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp105_ = cname;
	_tmp106_ = re;
	_tmp107_ = flags;
	_tmp108_ = g_strdup_printf ("_thread_safe_regex_init (&%s, \"%s\", %s)", _tmp105_, _tmp106_, _tmp107_);
	_tmp109_ = _tmp108_;
	_tmp110_ = vala_ccode_constant_new (_tmp109_);
	_tmp111_ = _tmp110_;
	_g_free0 (_tmp109_);
	regex_const = _tmp111_;
	_tmp112_ = self->cfile;
	_tmp113_ = _cdecl_;
	vala_ccode_file_add_constant_declaration (_tmp112_, (ValaCCodeNode*) _tmp113_);
	_tmp114_ = expr;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp114_, (ValaCCodeExpression*) regex_const);
	_vala_ccode_node_unref0 (regex_const);
	_g_free0 (cname);
	_vala_ccode_node_unref0 (_cdecl_);
	_g_free0 (flags);
	_g_free0 (re);
	parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
}


static void vala_ccode_base_module_real_visit_null_literal (ValaCodeVisitor* base, ValaNullLiteral* expr) {
	ValaCCodeBaseModule * self;
	ValaNullLiteral* _tmp0_;
	ValaCCodeConstant* _tmp1_;
	ValaCCodeConstant* _tmp2_;
	ValaArrayType* array_type = NULL;
	ValaNullLiteral* _tmp3_;
	ValaDataType* _tmp4_;
	ValaDataType* _tmp5_;
	ValaArrayType* _tmp6_;
	ValaDelegateType* delegate_type = NULL;
	ValaNullLiteral* _tmp7_;
	ValaDataType* _tmp8_;
	ValaDataType* _tmp9_;
	ValaDelegateType* _tmp10_;
	ValaArrayType* _tmp11_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_ccode_constant_new ("NULL");
	_tmp2_ = _tmp1_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp0_, (ValaCCodeExpression*) _tmp2_);
	_vala_ccode_node_unref0 (_tmp2_);
	_tmp3_ = expr;
	_tmp4_ = vala_expression_get_target_type ((ValaExpression*) _tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp5_) : NULL);
	array_type = _tmp6_;
	_tmp7_ = expr;
	_tmp8_ = vala_expression_get_target_type ((ValaExpression*) _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp9_) : NULL);
	delegate_type = _tmp10_;
	_tmp11_ = array_type;
	if (_tmp11_ != NULL) {
		{
			gint dim = 0;
			dim = 1;
			{
				gboolean _tmp12_ = FALSE;
				_tmp12_ = TRUE;
				while (TRUE) {
					gint _tmp14_;
					ValaArrayType* _tmp15_;
					gint _tmp16_;
					gint _tmp17_;
					ValaNullLiteral* _tmp18_;
					ValaCCodeConstant* _tmp19_;
					ValaCCodeConstant* _tmp20_;
					if (!_tmp12_) {
						gint _tmp13_;
						_tmp13_ = dim;
						dim = _tmp13_ + 1;
					}
					_tmp12_ = FALSE;
					_tmp14_ = dim;
					_tmp15_ = array_type;
					_tmp16_ = vala_array_type_get_rank (_tmp15_);
					_tmp17_ = _tmp16_;
					if (!(_tmp14_ <= _tmp17_)) {
						break;
					}
					_tmp18_ = expr;
					_tmp19_ = vala_ccode_constant_new ("0");
					_tmp20_ = _tmp19_;
					vala_ccode_base_module_append_array_length (self, (ValaExpression*) _tmp18_, (ValaCCodeExpression*) _tmp20_);
					_vala_ccode_node_unref0 (_tmp20_);
				}
			}
		}
	} else {
		gboolean _tmp21_ = FALSE;
		ValaDelegateType* _tmp22_;
		_tmp22_ = delegate_type;
		if (_tmp22_ != NULL) {
			ValaDelegateType* _tmp23_;
			ValaDelegate* _tmp24_;
			ValaDelegate* _tmp25_;
			gboolean _tmp26_;
			gboolean _tmp27_;
			_tmp23_ = delegate_type;
			_tmp24_ = vala_delegate_type_get_delegate_symbol (_tmp23_);
			_tmp25_ = _tmp24_;
			_tmp26_ = vala_delegate_get_has_target (_tmp25_);
			_tmp27_ = _tmp26_;
			_tmp21_ = _tmp27_;
		} else {
			_tmp21_ = FALSE;
		}
		if (_tmp21_) {
			ValaNullLiteral* _tmp28_;
			ValaCCodeConstant* _tmp29_;
			ValaCCodeConstant* _tmp30_;
			ValaNullLiteral* _tmp31_;
			ValaCCodeConstant* _tmp32_;
			ValaCCodeConstant* _tmp33_;
			_tmp28_ = expr;
			_tmp29_ = vala_ccode_constant_new ("NULL");
			_tmp30_ = _tmp29_;
			vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp28_, (ValaCCodeExpression*) _tmp30_);
			_vala_ccode_node_unref0 (_tmp30_);
			_tmp31_ = expr;
			_tmp32_ = vala_ccode_constant_new ("NULL");
			_tmp33_ = _tmp32_;
			vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp31_, (ValaCCodeExpression*) _tmp33_);
			_vala_ccode_node_unref0 (_tmp33_);
		}
	}
	_vala_code_node_unref0 (delegate_type);
	_vala_code_node_unref0 (array_type);
}


static ValaTargetValue* vala_ccode_base_module_real_get_local_cvalue (ValaCCodeBaseModule* self, ValaLocalVariable* local) {
	g_critical ("Type `%s' does not implement abstract method `vala_ccode_base_module_get_local_cvalue'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
	return NULL;
}


ValaTargetValue* vala_ccode_base_module_get_local_cvalue (ValaCCodeBaseModule* self, ValaLocalVariable* local) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_local_cvalue (self, local);
}


static ValaTargetValue* vala_ccode_base_module_real_get_parameter_cvalue (ValaCCodeBaseModule* self, ValaParameter* param) {
	g_critical ("Type `%s' does not implement abstract method `vala_ccode_base_module_get_parameter_cvalue'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
	return NULL;
}


ValaTargetValue* vala_ccode_base_module_get_parameter_cvalue (ValaCCodeBaseModule* self, ValaParameter* param) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_parameter_cvalue (self, param);
}


static ValaTargetValue* vala_ccode_base_module_real_get_field_cvalue (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance) {
	g_critical ("Type `%s' does not implement abstract method `vala_ccode_base_module_get_field_cvalue'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
	return NULL;
}


ValaTargetValue* vala_ccode_base_module_get_field_cvalue (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_field_cvalue (self, field, instance);
}


static ValaTargetValue* vala_ccode_base_module_real_load_variable (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value) {
	g_critical ("Type `%s' does not implement abstract method `vala_ccode_base_module_load_variable'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
	return NULL;
}


ValaTargetValue* vala_ccode_base_module_load_variable (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->load_variable (self, variable, value);
}


static ValaTargetValue* vala_ccode_base_module_real_load_this_parameter (ValaCCodeBaseModule* self, ValaTypeSymbol* sym) {
	g_critical ("Type `%s' does not implement abstract method `vala_ccode_base_module_load_this_parameter'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
	return NULL;
}


ValaTargetValue* vala_ccode_base_module_load_this_parameter (ValaCCodeBaseModule* self, ValaTypeSymbol* sym) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->load_this_parameter (self, sym);
}


static void vala_ccode_base_module_real_store_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value) {
	g_critical ("Type `%s' does not implement abstract method `vala_ccode_base_module_store_value'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
	return;
}


void vala_ccode_base_module_store_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->store_value (self, lvalue, value);
}


static gchar* vala_ccode_base_module_real_get_delegate_target_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname) {
	gchar* result = NULL;
	g_return_val_if_fail (delegate_cname != NULL, NULL);
	g_assert_not_reached ();
	return result;
}


gchar* vala_ccode_base_module_get_delegate_target_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_delegate_target_cname (self, delegate_cname);
}


static ValaCCodeExpression* vala_ccode_base_module_real_get_delegate_target_cexpression (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression* * delegate_target_destroy_notify) {
	ValaCCodeExpression* _vala_delegate_target_destroy_notify = NULL;
	ValaCCodeExpression* result = NULL;
	g_return_val_if_fail (delegate_expr != NULL, NULL);
	g_assert_not_reached ();
	if (delegate_target_destroy_notify) {
		*delegate_target_destroy_notify = _vala_delegate_target_destroy_notify;
	} else {
		_vala_ccode_node_unref0 (_vala_delegate_target_destroy_notify);
	}
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cexpression (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression* * delegate_target_destroy_notify) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_delegate_target_cexpression (self, delegate_expr, delegate_target_destroy_notify);
}


static ValaCCodeExpression* vala_ccode_base_module_real_get_delegate_target_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeInvalidExpression* _tmp0_;
	g_return_val_if_fail (value != NULL, NULL);
	_tmp0_ = vala_ccode_invalid_expression_new ();
	result = (ValaCCodeExpression*) _tmp0_;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_delegate_target_cvalue (self, value);
}


static ValaCCodeExpression* vala_ccode_base_module_real_get_delegate_target_destroy_notify_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeInvalidExpression* _tmp0_;
	g_return_val_if_fail (value != NULL, NULL);
	_tmp0_ = vala_ccode_invalid_expression_new ();
	result = (ValaCCodeExpression*) _tmp0_;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_delegate_target_destroy_notify_cvalue (self, value);
}


static gchar* vala_ccode_base_module_real_get_delegate_target_destroy_notify_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname) {
	gchar* result = NULL;
	g_return_val_if_fail (delegate_cname != NULL, NULL);
	g_assert_not_reached ();
	return result;
}


gchar* vala_ccode_base_module_get_delegate_target_destroy_notify_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_delegate_target_destroy_notify_cname (self, delegate_cname);
}


static void vala_ccode_base_module_real_visit_base_access (ValaCodeVisitor* base, ValaBaseAccess* expr) {
	ValaCCodeBaseModule * self;
	ValaCCodeExpression* this_access = NULL;
	gboolean _tmp0_;
	ValaBaseAccess* _tmp5_;
	ValaCCodeExpression* _tmp6_;
	ValaBaseAccess* _tmp7_;
	ValaDataType* _tmp8_;
	ValaDataType* _tmp9_;
	ValaTypeSymbol* _tmp10_;
	ValaTypeSymbol* _tmp11_;
	ValaCCodeFunctionCall* _tmp12_;
	ValaCCodeFunctionCall* _tmp13_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = vala_ccode_base_module_is_in_coroutine (self);
	if (_tmp0_) {
		ValaCCodeIdentifier* _tmp1_;
		ValaCCodeIdentifier* _tmp2_;
		ValaCCodeMemberAccess* _tmp3_;
		_tmp1_ = vala_ccode_identifier_new ("_data_");
		_tmp2_ = _tmp1_;
		_tmp3_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp2_, "self");
		_vala_ccode_node_unref0 (this_access);
		this_access = (ValaCCodeExpression*) _tmp3_;
		_vala_ccode_node_unref0 (_tmp2_);
	} else {
		ValaCCodeIdentifier* _tmp4_;
		_tmp4_ = vala_ccode_identifier_new ("self");
		_vala_ccode_node_unref0 (this_access);
		this_access = (ValaCCodeExpression*) _tmp4_;
	}
	_tmp5_ = expr;
	_tmp6_ = this_access;
	_tmp7_ = expr;
	_tmp8_ = vala_expression_get_value_type ((ValaExpression*) _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_data_type_get_data_type (_tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = vala_ccode_base_module_generate_instance_cast (self, _tmp6_, _tmp11_);
	_tmp13_ = _tmp12_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp5_, (ValaCCodeExpression*) _tmp13_);
	_vala_ccode_node_unref0 (_tmp13_);
	_vala_ccode_node_unref0 (this_access);
}


static void vala_ccode_base_module_real_visit_postfix_expression (ValaCodeVisitor* base, ValaPostfixExpression* expr) {
	ValaCCodeBaseModule * self;
	ValaMemberAccess* ma = NULL;
	ValaPostfixExpression* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	ValaMemberAccess* _tmp3_;
	ValaMemberAccess* _tmp4_;
	ValaTargetValue* temp_value = NULL;
	ValaPostfixExpression* _tmp39_;
	ValaExpression* _tmp40_;
	ValaExpression* _tmp41_;
	ValaTargetValue* _tmp42_;
	ValaTargetValue* _tmp43_;
	ValaPostfixExpression* _tmp44_;
	ValaTargetValue* _tmp45_;
	ValaCCodeBinaryOperator _tmp46_ = 0;
	ValaPostfixExpression* _tmp47_;
	gboolean _tmp48_;
	gboolean _tmp49_;
	ValaCCodeBinaryOperator op = 0;
	ValaCCodeBinaryExpression* cexpr = NULL;
	ValaCCodeBinaryOperator _tmp50_;
	ValaTargetValue* _tmp51_;
	ValaCCodeExpression* _tmp52_;
	ValaCCodeExpression* _tmp53_;
	ValaCCodeConstant* _tmp54_;
	ValaCCodeConstant* _tmp55_;
	ValaCCodeBinaryExpression* _tmp56_;
	ValaCCodeBinaryExpression* _tmp57_;
	ValaCCodeFunction* _tmp58_;
	ValaCCodeFunction* _tmp59_;
	ValaPostfixExpression* _tmp60_;
	ValaExpression* _tmp61_;
	ValaExpression* _tmp62_;
	ValaCCodeExpression* _tmp63_;
	ValaCCodeExpression* _tmp64_;
	ValaCCodeBinaryExpression* _tmp65_;
	ValaPostfixExpression* _tmp66_;
	ValaTargetValue* _tmp67_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_postfix_expression_get_inner (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_find_property_access (self, _tmp2_);
	ma = _tmp3_;
	_tmp4_ = ma;
	if (_tmp4_ != NULL) {
		ValaProperty* prop = NULL;
		ValaMemberAccess* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		ValaProperty* _tmp8_;
		ValaCCodeBinaryOperator _tmp9_ = 0;
		ValaPostfixExpression* _tmp10_;
		gboolean _tmp11_;
		gboolean _tmp12_;
		ValaCCodeBinaryOperator op = 0;
		ValaCCodeBinaryExpression* cexpr = NULL;
		ValaCCodeBinaryOperator _tmp13_;
		ValaPostfixExpression* _tmp14_;
		ValaExpression* _tmp15_;
		ValaExpression* _tmp16_;
		ValaCCodeExpression* _tmp17_;
		ValaCCodeExpression* _tmp18_;
		ValaCCodeConstant* _tmp19_;
		ValaCCodeConstant* _tmp20_;
		ValaCCodeBinaryExpression* _tmp21_;
		ValaCCodeBinaryExpression* _tmp22_;
		ValaProperty* _tmp23_;
		ValaMemberAccess* _tmp24_;
		ValaExpression* _tmp25_;
		ValaExpression* _tmp26_;
		ValaPostfixExpression* _tmp27_;
		ValaDataType* _tmp28_;
		ValaDataType* _tmp29_;
		ValaCCodeBinaryExpression* _tmp30_;
		ValaGLibValue* _tmp31_;
		ValaGLibValue* _tmp32_;
		ValaPostfixExpression* _tmp33_;
		ValaPostfixExpression* _tmp34_;
		ValaExpression* _tmp35_;
		ValaExpression* _tmp36_;
		ValaTargetValue* _tmp37_;
		ValaTargetValue* _tmp38_;
		_tmp5_ = ma;
		_tmp6_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_PROPERTY, ValaProperty));
		prop = _tmp8_;
		_tmp10_ = expr;
		_tmp11_ = vala_postfix_expression_get_increment (_tmp10_);
		_tmp12_ = _tmp11_;
		if (_tmp12_) {
			_tmp9_ = VALA_CCODE_BINARY_OPERATOR_PLUS;
		} else {
			_tmp9_ = VALA_CCODE_BINARY_OPERATOR_MINUS;
		}
		op = _tmp9_;
		_tmp13_ = op;
		_tmp14_ = expr;
		_tmp15_ = vala_postfix_expression_get_inner (_tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = vala_ccode_base_module_get_cvalue (self, _tmp16_);
		_tmp18_ = _tmp17_;
		_tmp19_ = vala_ccode_constant_new ("1");
		_tmp20_ = _tmp19_;
		_tmp21_ = vala_ccode_binary_expression_new (_tmp13_, _tmp18_, (ValaCCodeExpression*) _tmp20_);
		_tmp22_ = _tmp21_;
		_vala_ccode_node_unref0 (_tmp20_);
		_vala_ccode_node_unref0 (_tmp18_);
		cexpr = _tmp22_;
		_tmp23_ = prop;
		_tmp24_ = ma;
		_tmp25_ = vala_member_access_get_inner (_tmp24_);
		_tmp26_ = _tmp25_;
		_tmp27_ = expr;
		_tmp28_ = vala_expression_get_value_type ((ValaExpression*) _tmp27_);
		_tmp29_ = _tmp28_;
		_tmp30_ = cexpr;
		_tmp31_ = vala_glib_value_new (_tmp29_, (ValaCCodeExpression*) _tmp30_, FALSE);
		_tmp32_ = _tmp31_;
		vala_ccode_base_module_store_property (self, _tmp23_, _tmp26_, (ValaTargetValue*) _tmp32_);
		_vala_target_value_unref0 (_tmp32_);
		_tmp33_ = expr;
		_tmp34_ = expr;
		_tmp35_ = vala_postfix_expression_get_inner (_tmp34_);
		_tmp36_ = _tmp35_;
		_tmp37_ = vala_expression_get_target_value (_tmp36_);
		_tmp38_ = _tmp37_;
		vala_expression_set_target_value ((ValaExpression*) _tmp33_, _tmp38_);
		_vala_ccode_node_unref0 (cexpr);
		_vala_code_node_unref0 (prop);
		_vala_code_node_unref0 (ma);
		return;
	}
	_tmp39_ = expr;
	_tmp40_ = vala_postfix_expression_get_inner (_tmp39_);
	_tmp41_ = _tmp40_;
	_tmp42_ = vala_expression_get_target_value (_tmp41_);
	_tmp43_ = _tmp42_;
	_tmp44_ = expr;
	_tmp45_ = vala_ccode_base_module_store_temp_value (self, _tmp43_, (ValaCodeNode*) _tmp44_, NULL);
	temp_value = _tmp45_;
	_tmp47_ = expr;
	_tmp48_ = vala_postfix_expression_get_increment (_tmp47_);
	_tmp49_ = _tmp48_;
	if (_tmp49_) {
		_tmp46_ = VALA_CCODE_BINARY_OPERATOR_PLUS;
	} else {
		_tmp46_ = VALA_CCODE_BINARY_OPERATOR_MINUS;
	}
	op = _tmp46_;
	_tmp50_ = op;
	_tmp51_ = temp_value;
	_tmp52_ = vala_ccode_base_module_get_cvalue_ (self, _tmp51_);
	_tmp53_ = _tmp52_;
	_tmp54_ = vala_ccode_constant_new ("1");
	_tmp55_ = _tmp54_;
	_tmp56_ = vala_ccode_binary_expression_new (_tmp50_, _tmp53_, (ValaCCodeExpression*) _tmp55_);
	_tmp57_ = _tmp56_;
	_vala_ccode_node_unref0 (_tmp55_);
	_vala_ccode_node_unref0 (_tmp53_);
	cexpr = _tmp57_;
	_tmp58_ = vala_ccode_base_module_get_ccode (self);
	_tmp59_ = _tmp58_;
	_tmp60_ = expr;
	_tmp61_ = vala_postfix_expression_get_inner (_tmp60_);
	_tmp62_ = _tmp61_;
	_tmp63_ = vala_ccode_base_module_get_cvalue (self, _tmp62_);
	_tmp64_ = _tmp63_;
	_tmp65_ = cexpr;
	vala_ccode_function_add_assignment (_tmp59_, _tmp64_, (ValaCCodeExpression*) _tmp65_);
	_vala_ccode_node_unref0 (_tmp64_);
	_tmp66_ = expr;
	_tmp67_ = temp_value;
	vala_expression_set_target_value ((ValaExpression*) _tmp66_, _tmp67_);
	_vala_ccode_node_unref0 (cexpr);
	_vala_target_value_unref0 (temp_value);
	_vala_code_node_unref0 (ma);
}


static ValaMemberAccess* vala_ccode_base_module_find_property_access (ValaCCodeBaseModule* self, ValaExpression* expr) {
	ValaMemberAccess* result = NULL;
	ValaExpression* _tmp0_;
	ValaMemberAccess* ma = NULL;
	ValaExpression* _tmp1_;
	ValaMemberAccess* _tmp2_;
	ValaMemberAccess* _tmp3_;
	ValaSymbol* _tmp4_;
	ValaSymbol* _tmp5_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (expr != NULL, NULL);
	_tmp0_ = expr;
	if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_MEMBER_ACCESS)) {
		result = NULL;
		return result;
	}
	_tmp1_ = expr;
	_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
	ma = _tmp2_;
	_tmp3_ = ma;
	_tmp4_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp3_);
	_tmp5_ = _tmp4_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_PROPERTY)) {
		result = ma;
		return result;
	}
	result = NULL;
	_vala_code_node_unref0 (ma);
	return result;
}


static gboolean vala_ccode_base_module_is_limited_generic_type (ValaCCodeBaseModule* self, ValaDataType* type) {
	gboolean result = FALSE;
	ValaClass* cl = NULL;
	ValaDataType* _tmp0_;
	ValaTypeParameter* _tmp1_;
	ValaTypeParameter* _tmp2_;
	ValaSymbol* _tmp3_;
	ValaSymbol* _tmp4_;
	ValaClass* _tmp5_;
	ValaStruct* st = NULL;
	ValaDataType* _tmp6_;
	ValaTypeParameter* _tmp7_;
	ValaTypeParameter* _tmp8_;
	ValaSymbol* _tmp9_;
	ValaSymbol* _tmp10_;
	ValaStruct* _tmp11_;
	gboolean _tmp12_ = FALSE;
	gboolean _tmp13_ = FALSE;
	ValaClass* _tmp14_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type != NULL, FALSE);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_get_type_parameter (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp4_) : NULL);
	cl = _tmp5_;
	_tmp6_ = type;
	_tmp7_ = vala_data_type_get_type_parameter (_tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp8_);
	_tmp10_ = _tmp9_;
	_tmp11_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp10_) : NULL);
	st = _tmp11_;
	_tmp14_ = cl;
	if (_tmp14_ != NULL) {
		ValaClass* _tmp15_;
		gboolean _tmp16_;
		gboolean _tmp17_;
		_tmp15_ = cl;
		_tmp16_ = vala_class_get_is_compact (_tmp15_);
		_tmp17_ = _tmp16_;
		_tmp13_ = _tmp17_;
	} else {
		_tmp13_ = FALSE;
	}
	if (_tmp13_) {
		_tmp12_ = TRUE;
	} else {
		ValaStruct* _tmp18_;
		_tmp18_ = st;
		_tmp12_ = _tmp18_ != NULL;
	}
	if (_tmp12_) {
		result = TRUE;
		_vala_code_node_unref0 (st);
		_vala_code_node_unref0 (cl);
		return result;
	}
	result = FALSE;
	_vala_code_node_unref0 (st);
	_vala_code_node_unref0 (cl);
	return result;
}


gboolean vala_ccode_base_module_requires_copy (ValaCCodeBaseModule* self, ValaDataType* type) {
	gboolean result = FALSE;
	ValaDataType* _tmp0_;
	gboolean _tmp1_;
	ValaClass* cl = NULL;
	ValaDataType* _tmp2_;
	ValaTypeSymbol* _tmp3_;
	ValaTypeSymbol* _tmp4_;
	ValaClass* _tmp5_;
	gboolean _tmp6_ = FALSE;
	gboolean _tmp7_ = FALSE;
	ValaClass* _tmp8_;
	ValaDataType* _tmp14_;
	ValaTypeParameter* _tmp15_;
	ValaTypeParameter* _tmp16_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type != NULL, FALSE);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_is_disposable (_tmp0_);
	if (!_tmp1_) {
		result = FALSE;
		return result;
	}
	_tmp2_ = type;
	_tmp3_ = vala_data_type_get_data_type (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp4_) : NULL);
	cl = _tmp5_;
	_tmp8_ = cl;
	if (_tmp8_ != NULL) {
		ValaClass* _tmp9_;
		gboolean _tmp10_;
		_tmp9_ = cl;
		_tmp10_ = vala_ccode_base_module_is_reference_counting ((ValaTypeSymbol*) _tmp9_);
		_tmp7_ = _tmp10_;
	} else {
		_tmp7_ = FALSE;
	}
	if (_tmp7_) {
		ValaClass* _tmp11_;
		gchar* _tmp12_;
		gchar* _tmp13_;
		_tmp11_ = cl;
		_tmp12_ = vala_ccode_base_module_get_ccode_ref_function ((ValaTypeSymbol*) _tmp11_);
		_tmp13_ = _tmp12_;
		_tmp6_ = g_strcmp0 (_tmp13_, "") == 0;
		_g_free0 (_tmp13_);
	} else {
		_tmp6_ = FALSE;
	}
	if (_tmp6_) {
		result = FALSE;
		_vala_code_node_unref0 (cl);
		return result;
	}
	_tmp14_ = type;
	_tmp15_ = vala_data_type_get_type_parameter (_tmp14_);
	_tmp16_ = _tmp15_;
	if (_tmp16_ != NULL) {
		ValaDataType* _tmp17_;
		gboolean _tmp18_;
		_tmp17_ = type;
		_tmp18_ = vala_ccode_base_module_is_limited_generic_type (self, _tmp17_);
		if (_tmp18_) {
			result = FALSE;
			_vala_code_node_unref0 (cl);
			return result;
		}
	}
	result = TRUE;
	_vala_code_node_unref0 (cl);
	return result;
}


gboolean vala_ccode_base_module_requires_destroy (ValaCCodeBaseModule* self, ValaDataType* type) {
	gboolean result = FALSE;
	ValaDataType* _tmp0_;
	gboolean _tmp1_;
	ValaArrayType* array_type = NULL;
	ValaDataType* _tmp2_;
	ValaArrayType* _tmp3_;
	gboolean _tmp4_ = FALSE;
	ValaArrayType* _tmp5_;
	ValaClass* cl = NULL;
	ValaDataType* _tmp13_;
	ValaTypeSymbol* _tmp14_;
	ValaTypeSymbol* _tmp15_;
	ValaClass* _tmp16_;
	gboolean _tmp17_ = FALSE;
	gboolean _tmp18_ = FALSE;
	ValaClass* _tmp19_;
	ValaDataType* _tmp25_;
	ValaTypeParameter* _tmp26_;
	ValaTypeParameter* _tmp27_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type != NULL, FALSE);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_is_disposable (_tmp0_);
	if (!_tmp1_) {
		result = FALSE;
		return result;
	}
	_tmp2_ = type;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp2_) : NULL);
	array_type = _tmp3_;
	_tmp5_ = array_type;
	if (_tmp5_ != NULL) {
		ValaArrayType* _tmp6_;
		gboolean _tmp7_;
		gboolean _tmp8_;
		_tmp6_ = array_type;
		_tmp7_ = vala_array_type_get_fixed_length (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp4_ = _tmp8_;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		ValaArrayType* _tmp9_;
		ValaDataType* _tmp10_;
		ValaDataType* _tmp11_;
		gboolean _tmp12_;
		_tmp9_ = array_type;
		_tmp10_ = vala_array_type_get_element_type (_tmp9_);
		_tmp11_ = _tmp10_;
		_tmp12_ = vala_ccode_base_module_requires_destroy (self, _tmp11_);
		result = _tmp12_;
		_vala_code_node_unref0 (array_type);
		return result;
	}
	_tmp13_ = type;
	_tmp14_ = vala_data_type_get_data_type (_tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp15_) : NULL);
	cl = _tmp16_;
	_tmp19_ = cl;
	if (_tmp19_ != NULL) {
		ValaClass* _tmp20_;
		gboolean _tmp21_;
		_tmp20_ = cl;
		_tmp21_ = vala_ccode_base_module_is_reference_counting ((ValaTypeSymbol*) _tmp20_);
		_tmp18_ = _tmp21_;
	} else {
		_tmp18_ = FALSE;
	}
	if (_tmp18_) {
		ValaClass* _tmp22_;
		gchar* _tmp23_;
		gchar* _tmp24_;
		_tmp22_ = cl;
		_tmp23_ = vala_ccode_base_module_get_ccode_unref_function ((ValaObjectTypeSymbol*) _tmp22_);
		_tmp24_ = _tmp23_;
		_tmp17_ = g_strcmp0 (_tmp24_, "") == 0;
		_g_free0 (_tmp24_);
	} else {
		_tmp17_ = FALSE;
	}
	if (_tmp17_) {
		result = FALSE;
		_vala_code_node_unref0 (cl);
		_vala_code_node_unref0 (array_type);
		return result;
	}
	_tmp25_ = type;
	_tmp26_ = vala_data_type_get_type_parameter (_tmp25_);
	_tmp27_ = _tmp26_;
	if (_tmp27_ != NULL) {
		ValaDataType* _tmp28_;
		gboolean _tmp29_;
		_tmp28_ = type;
		_tmp29_ = vala_ccode_base_module_is_limited_generic_type (self, _tmp28_);
		if (_tmp29_) {
			result = FALSE;
			_vala_code_node_unref0 (cl);
			_vala_code_node_unref0 (array_type);
			return result;
		}
	}
	result = TRUE;
	_vala_code_node_unref0 (cl);
	_vala_code_node_unref0 (array_type);
	return result;
}


static gboolean vala_ccode_base_module_is_ref_function_void (ValaCCodeBaseModule* self, ValaDataType* type) {
	gboolean result = FALSE;
	ValaClass* cl = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	ValaClass* _tmp3_;
	ValaClass* _tmp4_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type != NULL, FALSE);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp2_) : NULL);
	cl = _tmp3_;
	_tmp4_ = cl;
	if (_tmp4_ != NULL) {
		ValaClass* _tmp5_;
		gboolean _tmp6_;
		_tmp5_ = cl;
		_tmp6_ = vala_ccode_base_module_get_ccode_ref_function_void (_tmp5_);
		result = _tmp6_;
		_vala_code_node_unref0 (cl);
		return result;
	} else {
		result = FALSE;
		_vala_code_node_unref0 (cl);
		return result;
	}
	_vala_code_node_unref0 (cl);
}


static gboolean vala_ccode_base_module_is_free_function_address_of (ValaCCodeBaseModule* self, ValaDataType* type) {
	gboolean result = FALSE;
	ValaClass* cl = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	ValaClass* _tmp3_;
	ValaClass* _tmp4_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type != NULL, FALSE);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp2_) : NULL);
	cl = _tmp3_;
	_tmp4_ = cl;
	if (_tmp4_ != NULL) {
		ValaClass* _tmp5_;
		gboolean _tmp6_;
		_tmp5_ = cl;
		_tmp6_ = vala_ccode_base_module_get_ccode_free_function_address_of (_tmp5_);
		result = _tmp6_;
		_vala_code_node_unref0 (cl);
		return result;
	} else {
		result = FALSE;
		_vala_code_node_unref0 (cl);
		return result;
	}
	_vala_code_node_unref0 (cl);
}


static ValaTargetValue* vala_ccode_base_module_real_copy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node) {
	ValaTargetValue* result = NULL;
	ValaDataType* type = NULL;
	ValaTargetValue* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaDataType* _tmp3_;
	ValaCCodeExpression* cexpr = NULL;
	ValaTargetValue* _tmp4_;
	ValaCCodeExpression* _tmp5_;
	ValaGLibValue* _result_ = NULL;
	ValaTargetValue* _tmp6_;
	ValaGLibValue* _tmp7_;
	ValaDataType* _tmp8_;
	gboolean _tmp25_ = FALSE;
	ValaDataType* _tmp26_;
	ValaCCodeExpression* dupexpr = NULL;
	ValaDataType* _tmp110_;
	ValaCodeNode* _tmp111_;
	ValaSourceReference* _tmp112_;
	ValaSourceReference* _tmp113_;
	ValaCCodeExpression* _tmp114_;
	ValaCCodeExpression* _tmp115_;
	gboolean _tmp117_ = FALSE;
	gboolean _tmp118_ = FALSE;
	gboolean _tmp119_ = FALSE;
	ValaCCodeExpression* _tmp120_;
	ValaCCodeFunctionCall* ccall = NULL;
	ValaCCodeExpression* _tmp182_;
	ValaCCodeFunctionCall* _tmp183_;
	gboolean _tmp184_ = FALSE;
	gboolean _tmp185_ = FALSE;
	ValaDataType* _tmp186_;
	g_return_val_if_fail (value != NULL, NULL);
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = value;
	_tmp1_ = vala_target_value_get_value_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (_tmp2_);
	type = _tmp3_;
	_tmp4_ = value;
	_tmp5_ = vala_ccode_base_module_get_cvalue_ (self, _tmp4_);
	cexpr = _tmp5_;
	_tmp6_ = value;
	_tmp7_ = vala_glib_value_copy (G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	_result_ = _tmp7_;
	_tmp8_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_DELEGATE_TYPE)) {
		ValaDelegateType* delegate_type = NULL;
		ValaDataType* _tmp9_;
		ValaDelegateType* _tmp10_;
		gboolean _tmp11_ = FALSE;
		ValaDelegateType* _tmp12_;
		ValaDelegate* _tmp13_;
		ValaDelegate* _tmp14_;
		gboolean _tmp15_;
		gboolean _tmp16_;
		ValaGLibValue* _tmp23_;
		ValaCCodeConstant* _tmp24_;
		_tmp9_ = type;
		_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
		delegate_type = _tmp10_;
		_tmp12_ = delegate_type;
		_tmp13_ = vala_delegate_type_get_delegate_symbol (_tmp12_);
		_tmp14_ = _tmp13_;
		_tmp15_ = vala_delegate_get_has_target (_tmp14_);
		_tmp16_ = _tmp15_;
		if (_tmp16_) {
			ValaCodeContext* _tmp17_;
			gboolean _tmp18_;
			gboolean _tmp19_;
			_tmp17_ = self->priv->_context;
			_tmp18_ = vala_code_context_get_deprecated (_tmp17_);
			_tmp19_ = _tmp18_;
			_tmp11_ = !_tmp19_;
		} else {
			_tmp11_ = FALSE;
		}
		if (_tmp11_) {
			ValaCodeNode* _tmp20_;
			ValaSourceReference* _tmp21_;
			ValaSourceReference* _tmp22_;
			_tmp20_ = node;
			_tmp21_ = vala_code_node_get_source_reference (_tmp20_);
			_tmp22_ = _tmp21_;
			vala_report_deprecated (_tmp22_, "copying delegates is not supported");
		}
		_tmp23_ = _result_;
		_tmp24_ = vala_ccode_constant_new ("NULL");
		_vala_ccode_node_unref0 (_tmp23_->delegate_target_destroy_notify_cvalue);
		_tmp23_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp24_;
		result = (ValaTargetValue*) _result_;
		_vala_code_node_unref0 (delegate_type);
		_vala_ccode_node_unref0 (cexpr);
		_vala_code_node_unref0 (type);
		return result;
	}
	_tmp26_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp26_, VALA_TYPE_VALUE_TYPE)) {
		ValaDataType* _tmp27_;
		gboolean _tmp28_;
		gboolean _tmp29_;
		_tmp27_ = type;
		_tmp28_ = vala_data_type_get_nullable (_tmp27_);
		_tmp29_ = _tmp28_;
		_tmp25_ = !_tmp29_;
	} else {
		_tmp25_ = FALSE;
	}
	if (_tmp25_) {
		ValaTargetValue* temp_value = NULL;
		ValaDataType* _tmp30_;
		ValaCodeNode* _tmp31_;
		gboolean _tmp32_;
		ValaTargetValue* _tmp33_;
		ValaCCodeExpression* ctemp = NULL;
		ValaTargetValue* _tmp34_;
		ValaCCodeExpression* _tmp35_;
		ValaValueType* vt = NULL;
		ValaDataType* _tmp36_;
		ValaValueType* _tmp37_;
		ValaStruct* st = NULL;
		ValaValueType* _tmp38_;
		ValaTypeSymbol* _tmp39_;
		ValaTypeSymbol* _tmp40_;
		ValaStruct* _tmp41_;
		ValaCCodeFunctionCall* copy_call = NULL;
		ValaStruct* _tmp42_;
		gchar* _tmp43_;
		gchar* _tmp44_;
		ValaCCodeIdentifier* _tmp45_;
		ValaCCodeIdentifier* _tmp46_;
		ValaCCodeFunctionCall* _tmp47_;
		ValaCCodeFunctionCall* _tmp48_;
		ValaCCodeFunctionCall* _tmp49_;
		ValaCCodeExpression* _tmp50_;
		ValaCCodeUnaryExpression* _tmp51_;
		ValaCCodeUnaryExpression* _tmp52_;
		ValaCCodeFunctionCall* _tmp53_;
		ValaCCodeExpression* _tmp54_;
		ValaCCodeUnaryExpression* _tmp55_;
		ValaCCodeUnaryExpression* _tmp56_;
		ValaStruct* _tmp57_;
		gboolean _tmp58_;
		gboolean _tmp60_ = FALSE;
		ValaStruct* _tmp61_;
		_tmp30_ = type;
		_tmp31_ = node;
		_tmp32_ = TRUE;
		_tmp33_ = vala_ccode_base_module_create_temp_value (self, _tmp30_, TRUE, _tmp31_, &_tmp32_);
		temp_value = _tmp33_;
		_tmp34_ = temp_value;
		_tmp35_ = vala_ccode_base_module_get_cvalue_ (self, _tmp34_);
		ctemp = _tmp35_;
		_tmp36_ = type;
		_tmp37_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp36_, VALA_TYPE_VALUE_TYPE, ValaValueType));
		vt = _tmp37_;
		_tmp38_ = vt;
		_tmp39_ = vala_value_type_get_type_symbol (_tmp38_);
		_tmp40_ = _tmp39_;
		_tmp41_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp40_, VALA_TYPE_STRUCT, ValaStruct));
		st = _tmp41_;
		_tmp42_ = st;
		_tmp43_ = vala_ccode_base_module_get_ccode_copy_function ((ValaTypeSymbol*) _tmp42_);
		_tmp44_ = _tmp43_;
		_tmp45_ = vala_ccode_identifier_new (_tmp44_);
		_tmp46_ = _tmp45_;
		_tmp47_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp46_);
		_tmp48_ = _tmp47_;
		_vala_ccode_node_unref0 (_tmp46_);
		_g_free0 (_tmp44_);
		copy_call = _tmp48_;
		_tmp49_ = copy_call;
		_tmp50_ = cexpr;
		_tmp51_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp50_);
		_tmp52_ = _tmp51_;
		vala_ccode_function_call_add_argument (_tmp49_, (ValaCCodeExpression*) _tmp52_);
		_vala_ccode_node_unref0 (_tmp52_);
		_tmp53_ = copy_call;
		_tmp54_ = ctemp;
		_tmp55_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp54_);
		_tmp56_ = _tmp55_;
		vala_ccode_function_call_add_argument (_tmp53_, (ValaCCodeExpression*) _tmp56_);
		_vala_ccode_node_unref0 (_tmp56_);
		_tmp57_ = st;
		_tmp58_ = vala_ccode_base_module_get_ccode_has_copy_function (_tmp57_);
		if (!_tmp58_) {
			ValaStruct* _tmp59_;
			_tmp59_ = st;
			vala_ccode_base_module_generate_struct_copy_function (self, _tmp59_);
		}
		_tmp61_ = self->gvalue_type;
		if (_tmp61_ != NULL) {
			ValaDataType* _tmp62_;
			ValaTypeSymbol* _tmp63_;
			ValaTypeSymbol* _tmp64_;
			ValaStruct* _tmp65_;
			_tmp62_ = type;
			_tmp63_ = vala_data_type_get_data_type (_tmp62_);
			_tmp64_ = _tmp63_;
			_tmp65_ = self->gvalue_type;
			_tmp60_ = _tmp64_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp65_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
		} else {
			_tmp60_ = FALSE;
		}
		if (_tmp60_) {
			ValaCCodeFunctionCall* cisvalid = NULL;
			ValaCCodeIdentifier* _tmp66_;
			ValaCCodeIdentifier* _tmp67_;
			ValaCCodeFunctionCall* _tmp68_;
			ValaCCodeFunctionCall* _tmp69_;
			ValaCCodeFunctionCall* _tmp70_;
			ValaCCodeExpression* _tmp71_;
			ValaCCodeUnaryExpression* _tmp72_;
			ValaCCodeUnaryExpression* _tmp73_;
			ValaCCodeFunction* _tmp74_;
			ValaCCodeFunction* _tmp75_;
			ValaCCodeFunctionCall* _tmp76_;
			ValaCCodeFunctionCall* value_type_call = NULL;
			ValaCCodeIdentifier* _tmp77_;
			ValaCCodeIdentifier* _tmp78_;
			ValaCCodeFunctionCall* _tmp79_;
			ValaCCodeFunctionCall* _tmp80_;
			ValaCCodeFunctionCall* _tmp81_;
			ValaCCodeExpression* _tmp82_;
			ValaCCodeUnaryExpression* _tmp83_;
			ValaCCodeUnaryExpression* _tmp84_;
			ValaCCodeFunctionCall* init_call = NULL;
			ValaCCodeIdentifier* _tmp85_;
			ValaCCodeIdentifier* _tmp86_;
			ValaCCodeFunctionCall* _tmp87_;
			ValaCCodeFunctionCall* _tmp88_;
			ValaCCodeFunctionCall* _tmp89_;
			ValaCCodeExpression* _tmp90_;
			ValaCCodeUnaryExpression* _tmp91_;
			ValaCCodeUnaryExpression* _tmp92_;
			ValaCCodeFunctionCall* _tmp93_;
			ValaCCodeFunctionCall* _tmp94_;
			ValaCCodeFunction* _tmp95_;
			ValaCCodeFunction* _tmp96_;
			ValaCCodeFunctionCall* _tmp97_;
			ValaCCodeFunction* _tmp98_;
			ValaCCodeFunction* _tmp99_;
			ValaCCodeFunctionCall* _tmp100_;
			ValaCCodeFunction* _tmp101_;
			ValaCCodeFunction* _tmp102_;
			ValaTargetValue* _tmp103_;
			ValaTargetValue* _tmp104_;
			ValaCCodeFunction* _tmp105_;
			ValaCCodeFunction* _tmp106_;
			_tmp66_ = vala_ccode_identifier_new ("G_IS_VALUE");
			_tmp67_ = _tmp66_;
			_tmp68_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp67_);
			_tmp69_ = _tmp68_;
			_vala_ccode_node_unref0 (_tmp67_);
			cisvalid = _tmp69_;
			_tmp70_ = cisvalid;
			_tmp71_ = cexpr;
			_tmp72_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp71_);
			_tmp73_ = _tmp72_;
			vala_ccode_function_call_add_argument (_tmp70_, (ValaCCodeExpression*) _tmp73_);
			_vala_ccode_node_unref0 (_tmp73_);
			_tmp74_ = vala_ccode_base_module_get_ccode (self);
			_tmp75_ = _tmp74_;
			_tmp76_ = cisvalid;
			vala_ccode_function_open_if (_tmp75_, (ValaCCodeExpression*) _tmp76_);
			_tmp77_ = vala_ccode_identifier_new ("G_VALUE_TYPE");
			_tmp78_ = _tmp77_;
			_tmp79_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp78_);
			_tmp80_ = _tmp79_;
			_vala_ccode_node_unref0 (_tmp78_);
			value_type_call = _tmp80_;
			_tmp81_ = value_type_call;
			_tmp82_ = cexpr;
			_tmp83_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp82_);
			_tmp84_ = _tmp83_;
			vala_ccode_function_call_add_argument (_tmp81_, (ValaCCodeExpression*) _tmp84_);
			_vala_ccode_node_unref0 (_tmp84_);
			_tmp85_ = vala_ccode_identifier_new ("g_value_init");
			_tmp86_ = _tmp85_;
			_tmp87_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp86_);
			_tmp88_ = _tmp87_;
			_vala_ccode_node_unref0 (_tmp86_);
			init_call = _tmp88_;
			_tmp89_ = init_call;
			_tmp90_ = ctemp;
			_tmp91_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp90_);
			_tmp92_ = _tmp91_;
			vala_ccode_function_call_add_argument (_tmp89_, (ValaCCodeExpression*) _tmp92_);
			_vala_ccode_node_unref0 (_tmp92_);
			_tmp93_ = init_call;
			_tmp94_ = value_type_call;
			vala_ccode_function_call_add_argument (_tmp93_, (ValaCCodeExpression*) _tmp94_);
			_tmp95_ = vala_ccode_base_module_get_ccode (self);
			_tmp96_ = _tmp95_;
			_tmp97_ = init_call;
			vala_ccode_function_add_expression (_tmp96_, (ValaCCodeExpression*) _tmp97_);
			_tmp98_ = vala_ccode_base_module_get_ccode (self);
			_tmp99_ = _tmp98_;
			_tmp100_ = copy_call;
			vala_ccode_function_add_expression (_tmp99_, (ValaCCodeExpression*) _tmp100_);
			_tmp101_ = vala_ccode_base_module_get_ccode (self);
			_tmp102_ = _tmp101_;
			vala_ccode_function_add_else (_tmp102_);
			_tmp103_ = temp_value;
			_tmp104_ = value;
			vala_ccode_base_module_store_value (self, _tmp103_, _tmp104_);
			_tmp105_ = vala_ccode_base_module_get_ccode (self);
			_tmp106_ = _tmp105_;
			vala_ccode_function_close (_tmp106_);
			_vala_ccode_node_unref0 (init_call);
			_vala_ccode_node_unref0 (value_type_call);
			_vala_ccode_node_unref0 (cisvalid);
		} else {
			ValaCCodeFunction* _tmp107_;
			ValaCCodeFunction* _tmp108_;
			ValaCCodeFunctionCall* _tmp109_;
			_tmp107_ = vala_ccode_base_module_get_ccode (self);
			_tmp108_ = _tmp107_;
			_tmp109_ = copy_call;
			vala_ccode_function_add_expression (_tmp108_, (ValaCCodeExpression*) _tmp109_);
		}
		result = temp_value;
		_vala_ccode_node_unref0 (copy_call);
		_vala_code_node_unref0 (st);
		_vala_code_node_unref0 (vt);
		_vala_ccode_node_unref0 (ctemp);
		_vala_target_value_unref0 (_result_);
		_vala_ccode_node_unref0 (cexpr);
		_vala_code_node_unref0 (type);
		return result;
	}
	_tmp110_ = type;
	_tmp111_ = node;
	_tmp112_ = vala_code_node_get_source_reference (_tmp111_);
	_tmp113_ = _tmp112_;
	_tmp114_ = vala_ccode_base_module_get_dup_func_expression (self, _tmp110_, _tmp113_, FALSE);
	dupexpr = _tmp114_;
	_tmp115_ = dupexpr;
	if (_tmp115_ == NULL) {
		ValaCodeNode* _tmp116_;
		_tmp116_ = node;
		vala_code_node_set_error (_tmp116_, TRUE);
		result = NULL;
		_vala_ccode_node_unref0 (dupexpr);
		_vala_target_value_unref0 (_result_);
		_vala_ccode_node_unref0 (cexpr);
		_vala_code_node_unref0 (type);
		return result;
	}
	_tmp120_ = dupexpr;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp120_, VALA_TYPE_CCODE_IDENTIFIER)) {
		ValaDataType* _tmp121_;
		_tmp121_ = type;
		_tmp119_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp121_, VALA_TYPE_ARRAY_TYPE);
	} else {
		_tmp119_ = FALSE;
	}
	if (_tmp119_) {
		ValaDataType* _tmp122_;
		_tmp122_ = type;
		_tmp118_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp122_, VALA_TYPE_GENERIC_TYPE);
	} else {
		_tmp118_ = FALSE;
	}
	if (_tmp118_) {
		ValaDataType* _tmp123_;
		gboolean _tmp124_;
		_tmp123_ = type;
		_tmp124_ = vala_ccode_base_module_is_ref_function_void (self, _tmp123_);
		_tmp117_ = !_tmp124_;
	} else {
		_tmp117_ = FALSE;
	}
	if (_tmp117_) {
		ValaCCodeIdentifier* dupid = NULL;
		ValaCCodeExpression* _tmp125_;
		ValaCCodeIdentifier* _tmp126_;
		gchar* dup0_func = NULL;
		ValaCCodeIdentifier* _tmp127_;
		const gchar* _tmp128_;
		const gchar* _tmp129_;
		gchar* _tmp130_;
		ValaCCodeIdentifier* _tmp131_;
		const gchar* _tmp132_;
		const gchar* _tmp133_;
		ValaCCodeFunctionCall* ccall = NULL;
		const gchar* _tmp166_;
		ValaCCodeIdentifier* _tmp167_;
		ValaCCodeIdentifier* _tmp168_;
		ValaCCodeFunctionCall* _tmp169_;
		ValaCCodeFunctionCall* _tmp170_;
		ValaCCodeFunctionCall* _tmp171_;
		ValaCCodeExpression* _tmp172_;
		ValaGLibValue* _tmp173_;
		ValaCCodeFunctionCall* _tmp174_;
		ValaCCodeExpression* _tmp175_;
		ValaGLibValue* _tmp176_;
		ValaDataType* _tmp177_;
		ValaDataType* _tmp178_;
		ValaGLibValue* _tmp179_;
		ValaCodeNode* _tmp180_;
		ValaTargetValue* _tmp181_;
		_tmp125_ = dupexpr;
		_tmp126_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp125_, VALA_TYPE_CCODE_IDENTIFIER, ValaCCodeIdentifier));
		dupid = _tmp126_;
		_tmp127_ = dupid;
		_tmp128_ = vala_ccode_identifier_get_name (_tmp127_);
		_tmp129_ = _tmp128_;
		_tmp130_ = g_strdup_printf ("_%s0", _tmp129_);
		dup0_func = _tmp130_;
		_tmp131_ = dupid;
		_tmp132_ = vala_ccode_identifier_get_name (_tmp131_);
		_tmp133_ = _tmp132_;
		if (g_strcmp0 (_tmp133_, "g_strdup") == 0) {
			ValaCCodeIdentifier* _tmp134_;
			const gchar* _tmp135_;
			const gchar* _tmp136_;
			gchar* _tmp137_;
			_tmp134_ = dupid;
			_tmp135_ = vala_ccode_identifier_get_name (_tmp134_);
			_tmp136_ = _tmp135_;
			_tmp137_ = g_strdup (_tmp136_);
			_g_free0 (dup0_func);
			dup0_func = _tmp137_;
		} else {
			const gchar* _tmp138_;
			gboolean _tmp139_;
			_tmp138_ = dup0_func;
			_tmp139_ = vala_ccode_base_module_add_wrapper (self, _tmp138_);
			if (_tmp139_) {
				gchar* pointer_cname = NULL;
				gchar* _tmp140_;
				ValaCCodeFunction* dup0_fun = NULL;
				const gchar* _tmp141_;
				const gchar* _tmp142_;
				ValaCCodeFunction* _tmp143_;
				ValaCCodeFunction* _tmp144_;
				const gchar* _tmp145_;
				ValaCCodeParameter* _tmp146_;
				ValaCCodeParameter* _tmp147_;
				ValaCCodeFunction* _tmp148_;
				ValaCCodeFunction* _tmp149_;
				ValaCCodeFunctionCall* dup_call = NULL;
				ValaCCodeExpression* _tmp150_;
				ValaCCodeFunctionCall* _tmp151_;
				ValaCCodeFunctionCall* _tmp152_;
				ValaCCodeIdentifier* _tmp153_;
				ValaCCodeIdentifier* _tmp154_;
				ValaCCodeFunction* _tmp155_;
				ValaCCodeFunction* _tmp156_;
				ValaCCodeIdentifier* _tmp157_;
				ValaCCodeIdentifier* _tmp158_;
				ValaCCodeFunctionCall* _tmp159_;
				ValaCCodeConstant* _tmp160_;
				ValaCCodeConstant* _tmp161_;
				ValaCCodeConditionalExpression* _tmp162_;
				ValaCCodeConditionalExpression* _tmp163_;
				ValaCCodeFile* _tmp164_;
				ValaCCodeFunction* _tmp165_;
				_tmp140_ = g_strdup ("gpointer");
				pointer_cname = _tmp140_;
				_tmp141_ = dup0_func;
				_tmp142_ = pointer_cname;
				_tmp143_ = vala_ccode_function_new (_tmp141_, _tmp142_);
				dup0_fun = _tmp143_;
				_tmp144_ = dup0_fun;
				_tmp145_ = pointer_cname;
				_tmp146_ = vala_ccode_parameter_new ("self", _tmp145_);
				_tmp147_ = _tmp146_;
				vala_ccode_function_add_parameter (_tmp144_, _tmp147_);
				_vala_ccode_node_unref0 (_tmp147_);
				_tmp148_ = dup0_fun;
				vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp148_, VALA_CCODE_MODIFIERS_STATIC);
				_tmp149_ = dup0_fun;
				vala_ccode_base_module_push_function (self, _tmp149_);
				_tmp150_ = dupexpr;
				_tmp151_ = vala_ccode_function_call_new (_tmp150_);
				dup_call = _tmp151_;
				_tmp152_ = dup_call;
				_tmp153_ = vala_ccode_identifier_new ("self");
				_tmp154_ = _tmp153_;
				vala_ccode_function_call_add_argument (_tmp152_, (ValaCCodeExpression*) _tmp154_);
				_vala_ccode_node_unref0 (_tmp154_);
				_tmp155_ = vala_ccode_base_module_get_ccode (self);
				_tmp156_ = _tmp155_;
				_tmp157_ = vala_ccode_identifier_new ("self");
				_tmp158_ = _tmp157_;
				_tmp159_ = dup_call;
				_tmp160_ = vala_ccode_constant_new ("NULL");
				_tmp161_ = _tmp160_;
				_tmp162_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp158_, (ValaCCodeExpression*) _tmp159_, (ValaCCodeExpression*) _tmp161_);
				_tmp163_ = _tmp162_;
				vala_ccode_function_add_return (_tmp156_, (ValaCCodeExpression*) _tmp163_);
				_vala_ccode_node_unref0 (_tmp163_);
				_vala_ccode_node_unref0 (_tmp161_);
				_vala_ccode_node_unref0 (_tmp158_);
				vala_ccode_base_module_pop_function (self);
				_tmp164_ = self->cfile;
				_tmp165_ = dup0_fun;
				vala_ccode_file_add_function (_tmp164_, _tmp165_);
				_vala_ccode_node_unref0 (dup_call);
				_vala_ccode_node_unref0 (dup0_fun);
				_g_free0 (pointer_cname);
			}
		}
		_tmp166_ = dup0_func;
		_tmp167_ = vala_ccode_identifier_new (_tmp166_);
		_tmp168_ = _tmp167_;
		_tmp169_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp168_);
		_tmp170_ = _tmp169_;
		_vala_ccode_node_unref0 (_tmp168_);
		ccall = _tmp170_;
		_tmp171_ = ccall;
		_tmp172_ = cexpr;
		vala_ccode_function_call_add_argument (_tmp171_, _tmp172_);
		_tmp173_ = _result_;
		_tmp174_ = ccall;
		_tmp175_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp174_);
		_vala_ccode_node_unref0 (_tmp173_->cvalue);
		_tmp173_->cvalue = _tmp175_;
		_tmp176_ = _result_;
		_tmp177_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp176_);
		_tmp178_ = _tmp177_;
		vala_data_type_set_value_owned (_tmp178_, TRUE);
		_tmp179_ = _result_;
		_tmp180_ = node;
		_tmp181_ = vala_ccode_base_module_store_temp_value (self, (ValaTargetValue*) _tmp179_, _tmp180_, NULL);
		result = _tmp181_;
		_vala_ccode_node_unref0 (ccall);
		_g_free0 (dup0_func);
		_vala_ccode_node_unref0 (dupid);
		_vala_ccode_node_unref0 (dupexpr);
		_vala_target_value_unref0 (_result_);
		_vala_ccode_node_unref0 (cexpr);
		_vala_code_node_unref0 (type);
		return result;
	}
	_tmp182_ = dupexpr;
	_tmp183_ = vala_ccode_function_call_new (_tmp182_);
	ccall = _tmp183_;
	_tmp186_ = type;
	if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp186_, VALA_TYPE_ARRAY_TYPE)) {
		ValaTargetValue* _tmp187_;
		gboolean _tmp188_;
		_tmp187_ = value;
		_tmp188_ = vala_ccode_base_module_get_non_null (self, _tmp187_);
		_tmp185_ = _tmp188_;
	} else {
		_tmp185_ = FALSE;
	}
	if (_tmp185_) {
		ValaDataType* _tmp189_;
		gboolean _tmp190_;
		_tmp189_ = type;
		_tmp190_ = vala_ccode_base_module_is_ref_function_void (self, _tmp189_);
		_tmp184_ = !_tmp190_;
	} else {
		_tmp184_ = FALSE;
	}
	if (_tmp184_) {
		ValaCCodeFunctionCall* _tmp191_;
		ValaCCodeExpression* _tmp192_;
		ValaDataType* _tmp193_;
		ValaCCodeFunctionCall* _tmp194_;
		ValaGLibValue* _tmp195_;
		ValaGLibValue* _tmp196_;
		ValaCodeNode* _tmp197_;
		ValaTargetValue* _tmp198_;
		ValaTargetValue* _tmp199_;
		_tmp191_ = ccall;
		_tmp192_ = cexpr;
		vala_ccode_function_call_add_argument (_tmp191_, _tmp192_);
		_tmp193_ = type;
		_tmp194_ = ccall;
		_tmp195_ = vala_glib_value_new (_tmp193_, (ValaCCodeExpression*) _tmp194_, FALSE);
		_tmp196_ = _tmp195_;
		_tmp197_ = node;
		_tmp198_ = vala_ccode_base_module_store_temp_value (self, (ValaTargetValue*) _tmp196_, _tmp197_, NULL);
		_tmp199_ = _tmp198_;
		_vala_target_value_unref0 (_tmp196_);
		result = _tmp199_;
		_vala_ccode_node_unref0 (ccall);
		_vala_ccode_node_unref0 (dupexpr);
		_vala_target_value_unref0 (_result_);
		_vala_ccode_node_unref0 (cexpr);
		_vala_code_node_unref0 (type);
		return result;
	} else {
		ValaCCodeBinaryExpression* cnotnull = NULL;
		ValaCCodeExpression* _tmp200_;
		ValaCCodeConstant* _tmp201_;
		ValaCCodeConstant* _tmp202_;
		ValaCCodeBinaryExpression* _tmp203_;
		ValaCCodeBinaryExpression* _tmp204_;
		ValaDataType* _tmp205_;
		ValaTypeParameter* _tmp206_;
		ValaTypeParameter* _tmp207_;
		ValaDataType* _tmp221_;
		ValaTypeParameter* _tmp222_;
		ValaTypeParameter* _tmp223_;
		ValaDataType* _tmp230_;
		ValaCCodeExpression* cifnull = NULL;
		ValaDataType* _tmp251_;
		ValaTypeSymbol* _tmp252_;
		ValaTypeSymbol* _tmp253_;
		ValaDataType* _tmp257_;
		gboolean _tmp258_;
		_tmp200_ = cexpr;
		_tmp201_ = vala_ccode_constant_new ("NULL");
		_tmp202_ = _tmp201_;
		_tmp203_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, _tmp200_, (ValaCCodeExpression*) _tmp202_);
		_tmp204_ = _tmp203_;
		_vala_ccode_node_unref0 (_tmp202_);
		cnotnull = _tmp204_;
		_tmp205_ = type;
		_tmp206_ = vala_data_type_get_type_parameter (_tmp205_);
		_tmp207_ = _tmp206_;
		if (_tmp207_ != NULL) {
			ValaCCodeBinaryExpression* cdupnotnull = NULL;
			ValaDataType* _tmp208_;
			ValaCodeNode* _tmp209_;
			ValaSourceReference* _tmp210_;
			ValaSourceReference* _tmp211_;
			ValaCCodeExpression* _tmp212_;
			ValaCCodeExpression* _tmp213_;
			ValaCCodeConstant* _tmp214_;
			ValaCCodeConstant* _tmp215_;
			ValaCCodeBinaryExpression* _tmp216_;
			ValaCCodeBinaryExpression* _tmp217_;
			ValaCCodeBinaryExpression* _tmp218_;
			ValaCCodeBinaryExpression* _tmp219_;
			ValaCCodeBinaryExpression* _tmp220_;
			_tmp208_ = type;
			_tmp209_ = node;
			_tmp210_ = vala_code_node_get_source_reference (_tmp209_);
			_tmp211_ = _tmp210_;
			_tmp212_ = vala_ccode_base_module_get_dup_func_expression (self, _tmp208_, _tmp211_, FALSE);
			_tmp213_ = _tmp212_;
			_tmp214_ = vala_ccode_constant_new ("NULL");
			_tmp215_ = _tmp214_;
			_tmp216_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, _tmp213_, (ValaCCodeExpression*) _tmp215_);
			_tmp217_ = _tmp216_;
			_vala_ccode_node_unref0 (_tmp215_);
			_vala_ccode_node_unref0 (_tmp213_);
			cdupnotnull = _tmp217_;
			_tmp218_ = cnotnull;
			_tmp219_ = cdupnotnull;
			_tmp220_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_AND, (ValaCCodeExpression*) _tmp218_, (ValaCCodeExpression*) _tmp219_);
			_vala_ccode_node_unref0 (cnotnull);
			cnotnull = _tmp220_;
			_vala_ccode_node_unref0 (cdupnotnull);
		}
		_tmp221_ = type;
		_tmp222_ = vala_data_type_get_type_parameter (_tmp221_);
		_tmp223_ = _tmp222_;
		if (_tmp223_ != NULL) {
			ValaCCodeFunctionCall* _tmp224_;
			ValaCCodeExpression* _tmp225_;
			ValaCCodeCastExpression* _tmp226_;
			ValaCCodeCastExpression* _tmp227_;
			_tmp224_ = ccall;
			_tmp225_ = cexpr;
			_tmp226_ = vala_ccode_cast_expression_new (_tmp225_, "gpointer");
			_tmp227_ = _tmp226_;
			vala_ccode_function_call_add_argument (_tmp224_, (ValaCCodeExpression*) _tmp227_);
			_vala_ccode_node_unref0 (_tmp227_);
		} else {
			ValaCCodeFunctionCall* _tmp228_;
			ValaCCodeExpression* _tmp229_;
			_tmp228_ = ccall;
			_tmp229_ = cexpr;
			vala_ccode_function_call_add_argument (_tmp228_, _tmp229_);
		}
		_tmp230_ = type;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp230_, VALA_TYPE_ARRAY_TYPE)) {
			ValaArrayType* array_type = NULL;
			ValaDataType* _tmp231_;
			ValaArrayType* _tmp232_;
			ValaCCodeFunctionCall* _tmp233_;
			ValaTargetValue* _tmp234_;
			ValaCCodeExpression* _tmp235_;
			ValaCCodeExpression* _tmp236_;
			ValaArrayType* _tmp237_;
			ValaDataType* _tmp238_;
			ValaDataType* _tmp239_;
			_tmp231_ = type;
			_tmp232_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp231_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			array_type = _tmp232_;
			_tmp233_ = ccall;
			_tmp234_ = value;
			_tmp235_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp234_, -1);
			_tmp236_ = _tmp235_;
			vala_ccode_function_call_add_argument (_tmp233_, _tmp236_);
			_vala_ccode_node_unref0 (_tmp236_);
			_tmp237_ = array_type;
			_tmp238_ = vala_array_type_get_element_type (_tmp237_);
			_tmp239_ = _tmp238_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp239_, VALA_TYPE_GENERIC_TYPE)) {
				ValaCCodeExpression* elem_dupexpr = NULL;
				ValaArrayType* _tmp240_;
				ValaDataType* _tmp241_;
				ValaDataType* _tmp242_;
				ValaCodeNode* _tmp243_;
				ValaSourceReference* _tmp244_;
				ValaSourceReference* _tmp245_;
				ValaCCodeExpression* _tmp246_;
				ValaCCodeExpression* _tmp247_;
				ValaCCodeFunctionCall* _tmp249_;
				ValaCCodeExpression* _tmp250_;
				_tmp240_ = array_type;
				_tmp241_ = vala_array_type_get_element_type (_tmp240_);
				_tmp242_ = _tmp241_;
				_tmp243_ = node;
				_tmp244_ = vala_code_node_get_source_reference (_tmp243_);
				_tmp245_ = _tmp244_;
				_tmp246_ = vala_ccode_base_module_get_dup_func_expression (self, _tmp242_, _tmp245_, FALSE);
				elem_dupexpr = _tmp246_;
				_tmp247_ = elem_dupexpr;
				if (_tmp247_ == NULL) {
					ValaCCodeConstant* _tmp248_;
					_tmp248_ = vala_ccode_constant_new ("NULL");
					_vala_ccode_node_unref0 (elem_dupexpr);
					elem_dupexpr = (ValaCCodeExpression*) _tmp248_;
				}
				_tmp249_ = ccall;
				_tmp250_ = elem_dupexpr;
				vala_ccode_function_call_add_argument (_tmp249_, _tmp250_);
				_vala_ccode_node_unref0 (elem_dupexpr);
			}
			_vala_code_node_unref0 (array_type);
		}
		_tmp251_ = type;
		_tmp252_ = vala_data_type_get_data_type (_tmp251_);
		_tmp253_ = _tmp252_;
		if (_tmp253_ != NULL) {
			ValaCCodeConstant* _tmp254_;
			_tmp254_ = vala_ccode_constant_new ("NULL");
			_vala_ccode_node_unref0 (cifnull);
			cifnull = (ValaCCodeExpression*) _tmp254_;
		} else {
			ValaCCodeExpression* _tmp255_;
			ValaCCodeCastExpression* _tmp256_;
			_tmp255_ = cexpr;
			_tmp256_ = vala_ccode_cast_expression_new (_tmp255_, "gpointer");
			_vala_ccode_node_unref0 (cifnull);
			cifnull = (ValaCCodeExpression*) _tmp256_;
		}
		_tmp257_ = type;
		_tmp258_ = vala_ccode_base_module_is_ref_function_void (self, _tmp257_);
		if (_tmp258_) {
			ValaCCodeFunction* _tmp259_;
			ValaCCodeFunction* _tmp260_;
			ValaCCodeBinaryExpression* _tmp261_;
			ValaCCodeFunction* _tmp262_;
			ValaCCodeFunction* _tmp263_;
			ValaCCodeFunctionCall* _tmp264_;
			ValaCCodeFunction* _tmp265_;
			ValaCCodeFunction* _tmp266_;
			_tmp259_ = vala_ccode_base_module_get_ccode (self);
			_tmp260_ = _tmp259_;
			_tmp261_ = cnotnull;
			vala_ccode_function_open_if (_tmp260_, (ValaCCodeExpression*) _tmp261_);
			_tmp262_ = vala_ccode_base_module_get_ccode (self);
			_tmp263_ = _tmp262_;
			_tmp264_ = ccall;
			vala_ccode_function_add_expression (_tmp263_, (ValaCCodeExpression*) _tmp264_);
			_tmp265_ = vala_ccode_base_module_get_ccode (self);
			_tmp266_ = _tmp265_;
			vala_ccode_function_close (_tmp266_);
		} else {
			ValaCCodeConditionalExpression* ccond = NULL;
			ValaCCodeBinaryExpression* _tmp267_;
			ValaCCodeFunctionCall* _tmp268_;
			ValaCCodeExpression* _tmp269_;
			ValaCCodeConditionalExpression* _tmp270_;
			ValaGLibValue* _tmp271_;
			ValaCCodeConditionalExpression* _tmp272_;
			ValaCCodeExpression* _tmp273_;
			ValaGLibValue* _tmp274_;
			ValaCodeNode* _tmp275_;
			gboolean _tmp276_;
			ValaTargetValue* _tmp277_;
			_tmp267_ = cnotnull;
			_tmp268_ = ccall;
			_tmp269_ = cifnull;
			_tmp270_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp267_, (ValaCCodeExpression*) _tmp268_, _tmp269_);
			ccond = _tmp270_;
			_tmp271_ = _result_;
			_tmp272_ = ccond;
			_tmp273_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp272_);
			_vala_ccode_node_unref0 (_tmp271_->cvalue);
			_tmp271_->cvalue = _tmp273_;
			_tmp274_ = _result_;
			_tmp275_ = node;
			_tmp276_ = TRUE;
			_tmp277_ = vala_ccode_base_module_store_temp_value (self, (ValaTargetValue*) _tmp274_, _tmp275_, &_tmp276_);
			_vala_target_value_unref0 (_result_);
			_result_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp277_, VALA_TYPE_GLIB_VALUE, ValaGLibValue);
			_vala_ccode_node_unref0 (ccond);
		}
		result = (ValaTargetValue*) _result_;
		_vala_ccode_node_unref0 (cifnull);
		_vala_ccode_node_unref0 (cnotnull);
		_vala_ccode_node_unref0 (ccall);
		_vala_ccode_node_unref0 (dupexpr);
		_vala_ccode_node_unref0 (cexpr);
		_vala_code_node_unref0 (type);
		return result;
	}
	_vala_ccode_node_unref0 (ccall);
	_vala_ccode_node_unref0 (dupexpr);
	_vala_target_value_unref0 (_result_);
	_vala_ccode_node_unref0 (cexpr);
	_vala_code_node_unref0 (type);
}


ValaTargetValue* vala_ccode_base_module_copy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->copy_value (self, value, node);
}


static gboolean vala_ccode_base_module_is_reference_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg) {
	gboolean result = FALSE;
	gboolean _tmp0_ = FALSE;
	ValaDataType* _tmp1_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type_arg != NULL, FALSE);
	_tmp1_ = type_arg;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_ERROR_TYPE)) {
		_tmp0_ = TRUE;
	} else {
		gboolean _tmp2_ = FALSE;
		ValaDataType* _tmp3_;
		ValaTypeSymbol* _tmp4_;
		ValaTypeSymbol* _tmp5_;
		_tmp3_ = type_arg;
		_tmp4_ = vala_data_type_get_data_type (_tmp3_);
		_tmp5_ = _tmp4_;
		if (_tmp5_ != NULL) {
			ValaDataType* _tmp6_;
			ValaTypeSymbol* _tmp7_;
			ValaTypeSymbol* _tmp8_;
			gboolean _tmp9_;
			_tmp6_ = type_arg;
			_tmp7_ = vala_data_type_get_data_type (_tmp6_);
			_tmp8_ = _tmp7_;
			_tmp9_ = vala_typesymbol_is_reference_type (_tmp8_);
			_tmp2_ = _tmp9_;
		} else {
			_tmp2_ = FALSE;
		}
		_tmp0_ = _tmp2_;
	}
	if (_tmp0_) {
		result = TRUE;
		return result;
	} else {
		result = FALSE;
		return result;
	}
}


static gboolean vala_ccode_base_module_is_nullable_value_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg) {
	gboolean result = FALSE;
	gboolean _tmp0_ = FALSE;
	ValaDataType* _tmp1_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type_arg != NULL, FALSE);
	_tmp1_ = type_arg;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_VALUE_TYPE)) {
		ValaDataType* _tmp2_;
		gboolean _tmp3_;
		gboolean _tmp4_;
		_tmp2_ = type_arg;
		_tmp3_ = vala_data_type_get_nullable (_tmp2_);
		_tmp4_ = _tmp3_;
		_tmp0_ = _tmp4_;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		result = TRUE;
		return result;
	} else {
		result = FALSE;
		return result;
	}
}


static gboolean vala_ccode_base_module_is_signed_integer_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg) {
	gboolean result = FALSE;
	ValaStruct* st = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	ValaStruct* _tmp3_;
	ValaDataType* _tmp4_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type_arg != NULL, FALSE);
	_tmp0_ = type_arg;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp2_) : NULL);
	st = _tmp3_;
	_tmp4_ = type_arg;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_ENUM_VALUE_TYPE)) {
		result = TRUE;
		_vala_code_node_unref0 (st);
		return result;
	} else {
		ValaDataType* _tmp5_;
		gboolean _tmp6_;
		gboolean _tmp7_;
		_tmp5_ = type_arg;
		_tmp6_ = vala_data_type_get_nullable (_tmp5_);
		_tmp7_ = _tmp6_;
		if (_tmp7_) {
			result = FALSE;
			_vala_code_node_unref0 (st);
			return result;
		} else {
			ValaStruct* _tmp8_;
			_tmp8_ = st;
			if (_tmp8_ == NULL) {
				result = FALSE;
				_vala_code_node_unref0 (st);
				return result;
			} else {
				ValaStruct* _tmp9_;
				ValaDataType* _tmp10_;
				ValaTypeSymbol* _tmp11_;
				ValaTypeSymbol* _tmp12_;
				gboolean _tmp13_;
				_tmp9_ = st;
				_tmp10_ = self->bool_type;
				_tmp11_ = vala_data_type_get_data_type (_tmp10_);
				_tmp12_ = _tmp11_;
				_tmp13_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp9_, _tmp12_);
				if (_tmp13_) {
					result = TRUE;
					_vala_code_node_unref0 (st);
					return result;
				} else {
					ValaStruct* _tmp14_;
					ValaDataType* _tmp15_;
					ValaTypeSymbol* _tmp16_;
					ValaTypeSymbol* _tmp17_;
					gboolean _tmp18_;
					_tmp14_ = st;
					_tmp15_ = self->char_type;
					_tmp16_ = vala_data_type_get_data_type (_tmp15_);
					_tmp17_ = _tmp16_;
					_tmp18_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp14_, _tmp17_);
					if (_tmp18_) {
						result = TRUE;
						_vala_code_node_unref0 (st);
						return result;
					} else {
						gboolean _tmp19_ = FALSE;
						ValaDataType* _tmp20_;
						_tmp20_ = self->unichar_type;
						if (_tmp20_ != NULL) {
							ValaStruct* _tmp21_;
							ValaDataType* _tmp22_;
							ValaTypeSymbol* _tmp23_;
							ValaTypeSymbol* _tmp24_;
							gboolean _tmp25_;
							_tmp21_ = st;
							_tmp22_ = self->unichar_type;
							_tmp23_ = vala_data_type_get_data_type (_tmp22_);
							_tmp24_ = _tmp23_;
							_tmp25_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp21_, _tmp24_);
							_tmp19_ = _tmp25_;
						} else {
							_tmp19_ = FALSE;
						}
						if (_tmp19_) {
							result = TRUE;
							_vala_code_node_unref0 (st);
							return result;
						} else {
							ValaStruct* _tmp26_;
							ValaDataType* _tmp27_;
							ValaTypeSymbol* _tmp28_;
							ValaTypeSymbol* _tmp29_;
							gboolean _tmp30_;
							_tmp26_ = st;
							_tmp27_ = self->short_type;
							_tmp28_ = vala_data_type_get_data_type (_tmp27_);
							_tmp29_ = _tmp28_;
							_tmp30_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp26_, _tmp29_);
							if (_tmp30_) {
								result = TRUE;
								_vala_code_node_unref0 (st);
								return result;
							} else {
								ValaStruct* _tmp31_;
								ValaDataType* _tmp32_;
								ValaTypeSymbol* _tmp33_;
								ValaTypeSymbol* _tmp34_;
								gboolean _tmp35_;
								_tmp31_ = st;
								_tmp32_ = self->int_type;
								_tmp33_ = vala_data_type_get_data_type (_tmp32_);
								_tmp34_ = _tmp33_;
								_tmp35_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp31_, _tmp34_);
								if (_tmp35_) {
									result = TRUE;
									_vala_code_node_unref0 (st);
									return result;
								} else {
									ValaStruct* _tmp36_;
									ValaDataType* _tmp37_;
									ValaTypeSymbol* _tmp38_;
									ValaTypeSymbol* _tmp39_;
									gboolean _tmp40_;
									_tmp36_ = st;
									_tmp37_ = self->long_type;
									_tmp38_ = vala_data_type_get_data_type (_tmp37_);
									_tmp39_ = _tmp38_;
									_tmp40_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp36_, _tmp39_);
									if (_tmp40_) {
										result = TRUE;
										_vala_code_node_unref0 (st);
										return result;
									} else {
										ValaStruct* _tmp41_;
										ValaDataType* _tmp42_;
										ValaTypeSymbol* _tmp43_;
										ValaTypeSymbol* _tmp44_;
										gboolean _tmp45_;
										_tmp41_ = st;
										_tmp42_ = self->int8_type;
										_tmp43_ = vala_data_type_get_data_type (_tmp42_);
										_tmp44_ = _tmp43_;
										_tmp45_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp41_, _tmp44_);
										if (_tmp45_) {
											result = TRUE;
											_vala_code_node_unref0 (st);
											return result;
										} else {
											ValaStruct* _tmp46_;
											ValaDataType* _tmp47_;
											ValaTypeSymbol* _tmp48_;
											ValaTypeSymbol* _tmp49_;
											gboolean _tmp50_;
											_tmp46_ = st;
											_tmp47_ = self->int16_type;
											_tmp48_ = vala_data_type_get_data_type (_tmp47_);
											_tmp49_ = _tmp48_;
											_tmp50_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp46_, _tmp49_);
											if (_tmp50_) {
												result = TRUE;
												_vala_code_node_unref0 (st);
												return result;
											} else {
												ValaStruct* _tmp51_;
												ValaDataType* _tmp52_;
												ValaTypeSymbol* _tmp53_;
												ValaTypeSymbol* _tmp54_;
												gboolean _tmp55_;
												_tmp51_ = st;
												_tmp52_ = self->int32_type;
												_tmp53_ = vala_data_type_get_data_type (_tmp52_);
												_tmp54_ = _tmp53_;
												_tmp55_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp51_, _tmp54_);
												if (_tmp55_) {
													result = TRUE;
													_vala_code_node_unref0 (st);
													return result;
												} else {
													ValaStruct* _tmp56_;
													ValaTypeSymbol* _tmp57_;
													gboolean _tmp58_;
													_tmp56_ = st;
													_tmp57_ = self->gtype_type;
													_tmp58_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp56_, _tmp57_);
													if (_tmp58_) {
														result = TRUE;
														_vala_code_node_unref0 (st);
														return result;
													} else {
														result = FALSE;
														_vala_code_node_unref0 (st);
														return result;
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}
	_vala_code_node_unref0 (st);
}


static gboolean vala_ccode_base_module_is_unsigned_integer_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg) {
	gboolean result = FALSE;
	ValaStruct* st = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	ValaStruct* _tmp3_;
	ValaStruct* _tmp4_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type_arg != NULL, FALSE);
	_tmp0_ = type_arg;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp2_) : NULL);
	st = _tmp3_;
	_tmp4_ = st;
	if (_tmp4_ == NULL) {
		result = FALSE;
		_vala_code_node_unref0 (st);
		return result;
	} else {
		ValaDataType* _tmp5_;
		gboolean _tmp6_;
		gboolean _tmp7_;
		_tmp5_ = type_arg;
		_tmp6_ = vala_data_type_get_nullable (_tmp5_);
		_tmp7_ = _tmp6_;
		if (_tmp7_) {
			result = FALSE;
			_vala_code_node_unref0 (st);
			return result;
		} else {
			ValaStruct* _tmp8_;
			ValaDataType* _tmp9_;
			ValaTypeSymbol* _tmp10_;
			ValaTypeSymbol* _tmp11_;
			gboolean _tmp12_;
			_tmp8_ = st;
			_tmp9_ = self->uchar_type;
			_tmp10_ = vala_data_type_get_data_type (_tmp9_);
			_tmp11_ = _tmp10_;
			_tmp12_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp8_, _tmp11_);
			if (_tmp12_) {
				result = TRUE;
				_vala_code_node_unref0 (st);
				return result;
			} else {
				ValaStruct* _tmp13_;
				ValaDataType* _tmp14_;
				ValaTypeSymbol* _tmp15_;
				ValaTypeSymbol* _tmp16_;
				gboolean _tmp17_;
				_tmp13_ = st;
				_tmp14_ = self->ushort_type;
				_tmp15_ = vala_data_type_get_data_type (_tmp14_);
				_tmp16_ = _tmp15_;
				_tmp17_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp13_, _tmp16_);
				if (_tmp17_) {
					result = TRUE;
					_vala_code_node_unref0 (st);
					return result;
				} else {
					ValaStruct* _tmp18_;
					ValaDataType* _tmp19_;
					ValaTypeSymbol* _tmp20_;
					ValaTypeSymbol* _tmp21_;
					gboolean _tmp22_;
					_tmp18_ = st;
					_tmp19_ = self->uint_type;
					_tmp20_ = vala_data_type_get_data_type (_tmp19_);
					_tmp21_ = _tmp20_;
					_tmp22_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp18_, _tmp21_);
					if (_tmp22_) {
						result = TRUE;
						_vala_code_node_unref0 (st);
						return result;
					} else {
						ValaStruct* _tmp23_;
						ValaDataType* _tmp24_;
						ValaTypeSymbol* _tmp25_;
						ValaTypeSymbol* _tmp26_;
						gboolean _tmp27_;
						_tmp23_ = st;
						_tmp24_ = self->ulong_type;
						_tmp25_ = vala_data_type_get_data_type (_tmp24_);
						_tmp26_ = _tmp25_;
						_tmp27_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp23_, _tmp26_);
						if (_tmp27_) {
							result = TRUE;
							_vala_code_node_unref0 (st);
							return result;
						} else {
							ValaStruct* _tmp28_;
							ValaDataType* _tmp29_;
							ValaTypeSymbol* _tmp30_;
							ValaTypeSymbol* _tmp31_;
							gboolean _tmp32_;
							_tmp28_ = st;
							_tmp29_ = self->uint8_type;
							_tmp30_ = vala_data_type_get_data_type (_tmp29_);
							_tmp31_ = _tmp30_;
							_tmp32_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp28_, _tmp31_);
							if (_tmp32_) {
								result = TRUE;
								_vala_code_node_unref0 (st);
								return result;
							} else {
								ValaStruct* _tmp33_;
								ValaDataType* _tmp34_;
								ValaTypeSymbol* _tmp35_;
								ValaTypeSymbol* _tmp36_;
								gboolean _tmp37_;
								_tmp33_ = st;
								_tmp34_ = self->uint16_type;
								_tmp35_ = vala_data_type_get_data_type (_tmp34_);
								_tmp36_ = _tmp35_;
								_tmp37_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp33_, _tmp36_);
								if (_tmp37_) {
									result = TRUE;
									_vala_code_node_unref0 (st);
									return result;
								} else {
									ValaStruct* _tmp38_;
									ValaDataType* _tmp39_;
									ValaTypeSymbol* _tmp40_;
									ValaTypeSymbol* _tmp41_;
									gboolean _tmp42_;
									_tmp38_ = st;
									_tmp39_ = self->uint32_type;
									_tmp40_ = vala_data_type_get_data_type (_tmp39_);
									_tmp41_ = _tmp40_;
									_tmp42_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp38_, _tmp41_);
									if (_tmp42_) {
										result = TRUE;
										_vala_code_node_unref0 (st);
										return result;
									} else {
										result = FALSE;
										_vala_code_node_unref0 (st);
										return result;
									}
								}
							}
						}
					}
				}
			}
		}
	}
	_vala_code_node_unref0 (st);
}


void vala_ccode_base_module_check_type (ValaCCodeBaseModule* self, ValaDataType* type) {
	ValaArrayType* array_type = NULL;
	ValaDataType* _tmp0_;
	ValaArrayType* _tmp1_;
	ValaArrayType* _tmp2_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (type != NULL);
	_tmp0_ = type;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp0_) : NULL);
	array_type = _tmp1_;
	_tmp2_ = array_type;
	if (_tmp2_ != NULL) {
		ValaArrayType* _tmp3_;
		ValaDataType* _tmp4_;
		ValaDataType* _tmp5_;
		ValaArrayType* _tmp6_;
		ValaDataType* _tmp7_;
		ValaDataType* _tmp8_;
		_tmp3_ = array_type;
		_tmp4_ = vala_array_type_get_element_type (_tmp3_);
		_tmp5_ = _tmp4_;
		vala_ccode_base_module_check_type (self, _tmp5_);
		_tmp6_ = array_type;
		_tmp7_ = vala_array_type_get_element_type (_tmp6_);
		_tmp8_ = _tmp7_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_ARRAY_TYPE)) {
			ValaDataType* _tmp9_;
			ValaSourceReference* _tmp10_;
			ValaSourceReference* _tmp11_;
			_tmp9_ = type;
			_tmp10_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp9_);
			_tmp11_ = _tmp10_;
			vala_report_error (_tmp11_, "Stacked arrays are not supported");
		} else {
			ValaArrayType* _tmp12_;
			ValaDataType* _tmp13_;
			ValaDataType* _tmp14_;
			_tmp12_ = array_type;
			_tmp13_ = vala_array_type_get_element_type (_tmp12_);
			_tmp14_ = _tmp13_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp14_, VALA_TYPE_DELEGATE_TYPE)) {
				ValaDelegateType* delegate_type = NULL;
				ValaArrayType* _tmp15_;
				ValaDataType* _tmp16_;
				ValaDataType* _tmp17_;
				ValaDelegateType* _tmp18_;
				ValaDelegateType* _tmp19_;
				ValaDelegate* _tmp20_;
				ValaDelegate* _tmp21_;
				gboolean _tmp22_;
				gboolean _tmp23_;
				_tmp15_ = array_type;
				_tmp16_ = vala_array_type_get_element_type (_tmp15_);
				_tmp17_ = _tmp16_;
				_tmp18_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
				delegate_type = _tmp18_;
				_tmp19_ = delegate_type;
				_tmp20_ = vala_delegate_type_get_delegate_symbol (_tmp19_);
				_tmp21_ = _tmp20_;
				_tmp22_ = vala_delegate_get_has_target (_tmp21_);
				_tmp23_ = _tmp22_;
				if (_tmp23_) {
					ValaDataType* _tmp24_;
					ValaSourceReference* _tmp25_;
					ValaSourceReference* _tmp26_;
					_tmp24_ = type;
					_tmp25_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp24_);
					_tmp26_ = _tmp25_;
					vala_report_error (_tmp26_, "Delegates with target are not supported as array element type");
				}
				_vala_code_node_unref0 (delegate_type);
			}
		}
	}
	{
		ValaList* _type_arg_list = NULL;
		ValaDataType* _tmp27_;
		ValaList* _tmp28_;
		gint _type_arg_size = 0;
		ValaList* _tmp29_;
		gint _tmp30_;
		gint _tmp31_;
		gint _type_arg_index = 0;
		_tmp27_ = type;
		_tmp28_ = vala_data_type_get_type_arguments (_tmp27_);
		_type_arg_list = _tmp28_;
		_tmp29_ = _type_arg_list;
		_tmp30_ = vala_collection_get_size ((ValaCollection*) _tmp29_);
		_tmp31_ = _tmp30_;
		_type_arg_size = _tmp31_;
		_type_arg_index = -1;
		while (TRUE) {
			gint _tmp32_;
			gint _tmp33_;
			gint _tmp34_;
			ValaDataType* type_arg = NULL;
			ValaList* _tmp35_;
			gint _tmp36_;
			gpointer _tmp37_;
			ValaDataType* _tmp38_;
			ValaDataType* _tmp39_;
			_tmp32_ = _type_arg_index;
			_type_arg_index = _tmp32_ + 1;
			_tmp33_ = _type_arg_index;
			_tmp34_ = _type_arg_size;
			if (!(_tmp33_ < _tmp34_)) {
				break;
			}
			_tmp35_ = _type_arg_list;
			_tmp36_ = _type_arg_index;
			_tmp37_ = vala_list_get (_tmp35_, _tmp36_);
			type_arg = (ValaDataType*) _tmp37_;
			_tmp38_ = type_arg;
			vala_ccode_base_module_check_type (self, _tmp38_);
			_tmp39_ = type_arg;
			vala_ccode_base_module_check_type_argument (self, _tmp39_);
			_vala_code_node_unref0 (type_arg);
		}
		_vala_iterable_unref0 (_type_arg_list);
	}
	_vala_code_node_unref0 (array_type);
}


void vala_ccode_base_module_check_type_arguments (ValaCCodeBaseModule* self, ValaMemberAccess* access) {
	g_return_if_fail (self != NULL);
	g_return_if_fail (access != NULL);
	{
		ValaList* _type_arg_list = NULL;
		ValaMemberAccess* _tmp0_;
		ValaList* _tmp1_;
		gint _type_arg_size = 0;
		ValaList* _tmp2_;
		gint _tmp3_;
		gint _tmp4_;
		gint _type_arg_index = 0;
		_tmp0_ = access;
		_tmp1_ = vala_member_access_get_type_arguments (_tmp0_);
		_type_arg_list = _tmp1_;
		_tmp2_ = _type_arg_list;
		_tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
		_tmp4_ = _tmp3_;
		_type_arg_size = _tmp4_;
		_type_arg_index = -1;
		while (TRUE) {
			gint _tmp5_;
			gint _tmp6_;
			gint _tmp7_;
			ValaDataType* type_arg = NULL;
			ValaList* _tmp8_;
			gint _tmp9_;
			gpointer _tmp10_;
			ValaDataType* _tmp11_;
			ValaDataType* _tmp12_;
			_tmp5_ = _type_arg_index;
			_type_arg_index = _tmp5_ + 1;
			_tmp6_ = _type_arg_index;
			_tmp7_ = _type_arg_size;
			if (!(_tmp6_ < _tmp7_)) {
				break;
			}
			_tmp8_ = _type_arg_list;
			_tmp9_ = _type_arg_index;
			_tmp10_ = vala_list_get (_tmp8_, _tmp9_);
			type_arg = (ValaDataType*) _tmp10_;
			_tmp11_ = type_arg;
			vala_ccode_base_module_check_type (self, _tmp11_);
			_tmp12_ = type_arg;
			vala_ccode_base_module_check_type_argument (self, _tmp12_);
			_vala_code_node_unref0 (type_arg);
		}
		_vala_iterable_unref0 (_type_arg_list);
	}
}


static void vala_ccode_base_module_check_type_argument (ValaCCodeBaseModule* self, ValaDataType* type_arg) {
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp2_ = FALSE;
	gboolean _tmp3_ = FALSE;
	gboolean _tmp4_ = FALSE;
	ValaDataType* _tmp5_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (type_arg != NULL);
	_tmp5_ = type_arg;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_GENERIC_TYPE)) {
		_tmp4_ = TRUE;
	} else {
		ValaDataType* _tmp6_;
		_tmp6_ = type_arg;
		_tmp4_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_POINTER_TYPE);
	}
	if (_tmp4_) {
		_tmp3_ = TRUE;
	} else {
		ValaDataType* _tmp7_;
		gboolean _tmp8_;
		_tmp7_ = type_arg;
		_tmp8_ = vala_ccode_base_module_is_reference_type_argument (self, _tmp7_);
		_tmp3_ = _tmp8_;
	}
	if (_tmp3_) {
		_tmp2_ = TRUE;
	} else {
		ValaDataType* _tmp9_;
		gboolean _tmp10_;
		_tmp9_ = type_arg;
		_tmp10_ = vala_ccode_base_module_is_nullable_value_type_argument (self, _tmp9_);
		_tmp2_ = _tmp10_;
	}
	if (_tmp2_) {
		_tmp1_ = TRUE;
	} else {
		ValaDataType* _tmp11_;
		gboolean _tmp12_;
		_tmp11_ = type_arg;
		_tmp12_ = vala_ccode_base_module_is_signed_integer_type_argument (self, _tmp11_);
		_tmp1_ = _tmp12_;
	}
	if (_tmp1_) {
		_tmp0_ = TRUE;
	} else {
		ValaDataType* _tmp13_;
		gboolean _tmp14_;
		_tmp13_ = type_arg;
		_tmp14_ = vala_ccode_base_module_is_unsigned_integer_type_argument (self, _tmp13_);
		_tmp0_ = _tmp14_;
	}
	if (_tmp0_) {
	} else {
		ValaDataType* _tmp15_;
		_tmp15_ = type_arg;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_DELEGATE_TYPE)) {
			ValaDelegateType* delegate_type = NULL;
			ValaDataType* _tmp16_;
			ValaDelegateType* _tmp17_;
			ValaDelegateType* _tmp18_;
			ValaDelegate* _tmp19_;
			ValaDelegate* _tmp20_;
			gboolean _tmp21_;
			gboolean _tmp22_;
			_tmp16_ = type_arg;
			_tmp17_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp16_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
			delegate_type = _tmp17_;
			_tmp18_ = delegate_type;
			_tmp19_ = vala_delegate_type_get_delegate_symbol (_tmp18_);
			_tmp20_ = _tmp19_;
			_tmp21_ = vala_delegate_get_has_target (_tmp20_);
			_tmp22_ = _tmp21_;
			if (_tmp22_) {
				ValaDataType* _tmp23_;
				ValaSourceReference* _tmp24_;
				ValaSourceReference* _tmp25_;
				_tmp23_ = type_arg;
				_tmp24_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp23_);
				_tmp25_ = _tmp24_;
				vala_report_error (_tmp25_, "Delegates with target are not supported as generic type arguments");
			}
			_vala_code_node_unref0 (delegate_type);
		} else {
			ValaDataType* _tmp26_;
			ValaSourceReference* _tmp27_;
			ValaSourceReference* _tmp28_;
			ValaDataType* _tmp29_;
			gchar* _tmp30_;
			gchar* _tmp31_;
			gchar* _tmp32_;
			gchar* _tmp33_;
			_tmp26_ = type_arg;
			_tmp27_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp26_);
			_tmp28_ = _tmp27_;
			_tmp29_ = type_arg;
			_tmp30_ = vala_code_node_to_string ((ValaCodeNode*) _tmp29_);
			_tmp31_ = _tmp30_;
			_tmp32_ = g_strdup_printf ("`%s' is not a supported generic type argument, use `?' to box value ty" \
"pes", _tmp31_);
			_tmp33_ = _tmp32_;
			vala_report_error (_tmp28_, _tmp33_);
			_g_free0 (_tmp33_);
			_g_free0 (_tmp31_);
		}
	}
}


static void vala_ccode_base_module_real_generate_class_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space) {
	ValaCCodeFile* _tmp0_;
	ValaClass* _tmp1_;
	ValaClass* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gboolean _tmp5_;
	gboolean _tmp6_;
	g_return_if_fail (cl != NULL);
	g_return_if_fail (decl_space != NULL);
	_tmp0_ = decl_space;
	_tmp1_ = cl;
	_tmp2_ = cl;
	_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_ccode_base_module_add_symbol_declaration (self, _tmp0_, (ValaSymbol*) _tmp1_, _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	if (_tmp6_) {
		return;
	}
}


void vala_ccode_base_module_generate_class_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_class_declaration (self, cl, decl_space);
}


static void vala_ccode_base_module_real_generate_interface_declaration (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space) {
	g_return_if_fail (iface != NULL);
	g_return_if_fail (decl_space != NULL);
}


void vala_ccode_base_module_generate_interface_declaration (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_interface_declaration (self, iface, decl_space);
}


static void vala_ccode_base_module_real_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space) {
	g_return_if_fail (m != NULL);
	g_return_if_fail (decl_space != NULL);
}


void vala_ccode_base_module_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_method_declaration (self, m, decl_space);
}


static void vala_ccode_base_module_real_generate_error_domain_declaration (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space) {
	g_return_if_fail (edomain != NULL);
	g_return_if_fail (decl_space != NULL);
}


void vala_ccode_base_module_generate_error_domain_declaration (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_error_domain_declaration (self, edomain, decl_space);
}


void vala_ccode_base_module_add_generic_type_arguments (ValaCCodeBaseModule* self, ValaMap* arg_map, ValaList* type_args, ValaCodeNode* expr, gboolean is_chainup, ValaList* type_parameters) {
	gint type_param_index = 0;
	g_return_if_fail (self != NULL);
	g_return_if_fail (arg_map != NULL);
	g_return_if_fail (type_args != NULL);
	g_return_if_fail (expr != NULL);
	type_param_index = 0;
	{
		ValaList* _type_arg_list = NULL;
		ValaList* _tmp0_;
		ValaList* _tmp1_;
		gint _type_arg_size = 0;
		ValaList* _tmp2_;
		gint _tmp3_;
		gint _tmp4_;
		gint _type_arg_index = 0;
		_tmp0_ = type_args;
		_tmp1_ = _vala_iterable_ref0 (_tmp0_);
		_type_arg_list = _tmp1_;
		_tmp2_ = _type_arg_list;
		_tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
		_tmp4_ = _tmp3_;
		_type_arg_size = _tmp4_;
		_type_arg_index = -1;
		while (TRUE) {
			gint _tmp5_;
			gint _tmp6_;
			gint _tmp7_;
			ValaDataType* type_arg = NULL;
			ValaList* _tmp8_;
			gint _tmp9_;
			gpointer _tmp10_;
			ValaList* _tmp11_;
			ValaMap* _tmp44_;
			gint _tmp45_;
			gint _tmp46_;
			ValaDataType* _tmp47_;
			gboolean _tmp48_;
			ValaCCodeExpression* _tmp49_;
			ValaCCodeExpression* _tmp50_;
			ValaDataType* _tmp51_;
			gboolean _tmp52_;
			gint _tmp86_;
			_tmp5_ = _type_arg_index;
			_type_arg_index = _tmp5_ + 1;
			_tmp6_ = _type_arg_index;
			_tmp7_ = _type_arg_size;
			if (!(_tmp6_ < _tmp7_)) {
				break;
			}
			_tmp8_ = _type_arg_list;
			_tmp9_ = _type_arg_index;
			_tmp10_ = vala_list_get (_tmp8_, _tmp9_);
			type_arg = (ValaDataType*) _tmp10_;
			_tmp11_ = type_parameters;
			if (_tmp11_ != NULL) {
				gchar* type_param_name = NULL;
				ValaList* _tmp12_;
				gint _tmp13_;
				gpointer _tmp14_;
				ValaTypeParameter* _tmp15_;
				const gchar* _tmp16_;
				const gchar* _tmp17_;
				gchar* _tmp18_;
				gchar* _tmp19_;
				ValaMap* _tmp20_;
				gint _tmp21_;
				gint _tmp22_;
				const gchar* _tmp23_;
				gchar* _tmp24_;
				gchar* _tmp25_;
				ValaCCodeConstant* _tmp26_;
				ValaCCodeConstant* _tmp27_;
				ValaMap* _tmp28_;
				gint _tmp29_;
				gint _tmp30_;
				const gchar* _tmp31_;
				gchar* _tmp32_;
				gchar* _tmp33_;
				ValaCCodeConstant* _tmp34_;
				ValaCCodeConstant* _tmp35_;
				ValaMap* _tmp36_;
				gint _tmp37_;
				gint _tmp38_;
				const gchar* _tmp39_;
				gchar* _tmp40_;
				gchar* _tmp41_;
				ValaCCodeConstant* _tmp42_;
				ValaCCodeConstant* _tmp43_;
				_tmp12_ = type_parameters;
				_tmp13_ = type_param_index;
				_tmp14_ = vala_list_get (_tmp12_, _tmp13_);
				_tmp15_ = (ValaTypeParameter*) _tmp14_;
				_tmp16_ = vala_symbol_get_name ((ValaSymbol*) _tmp15_);
				_tmp17_ = _tmp16_;
				_tmp18_ = g_utf8_strdown (_tmp17_, (gssize) -1);
				_tmp19_ = _tmp18_;
				_vala_code_node_unref0 (_tmp15_);
				type_param_name = _tmp19_;
				_tmp20_ = arg_map;
				_tmp21_ = type_param_index;
				_tmp22_ = vala_ccode_base_module_get_param_pos (self, (0.1 * _tmp21_) + 0.01, FALSE);
				_tmp23_ = type_param_name;
				_tmp24_ = g_strdup_printf ("\"%s_type\"", _tmp23_);
				_tmp25_ = _tmp24_;
				_tmp26_ = vala_ccode_constant_new (_tmp25_);
				_tmp27_ = _tmp26_;
				vala_map_set (_tmp20_, (gpointer) ((gintptr) _tmp22_), (ValaCCodeExpression*) _tmp27_);
				_vala_ccode_node_unref0 (_tmp27_);
				_g_free0 (_tmp25_);
				_tmp28_ = arg_map;
				_tmp29_ = type_param_index;
				_tmp30_ = vala_ccode_base_module_get_param_pos (self, (0.1 * _tmp29_) + 0.03, FALSE);
				_tmp31_ = type_param_name;
				_tmp32_ = g_strdup_printf ("\"%s_dup_func\"", _tmp31_);
				_tmp33_ = _tmp32_;
				_tmp34_ = vala_ccode_constant_new (_tmp33_);
				_tmp35_ = _tmp34_;
				vala_map_set (_tmp28_, (gpointer) ((gintptr) _tmp30_), (ValaCCodeExpression*) _tmp35_);
				_vala_ccode_node_unref0 (_tmp35_);
				_g_free0 (_tmp33_);
				_tmp36_ = arg_map;
				_tmp37_ = type_param_index;
				_tmp38_ = vala_ccode_base_module_get_param_pos (self, (0.1 * _tmp37_) + 0.05, FALSE);
				_tmp39_ = type_param_name;
				_tmp40_ = g_strdup_printf ("\"%s_destroy_func\"", _tmp39_);
				_tmp41_ = _tmp40_;
				_tmp42_ = vala_ccode_constant_new (_tmp41_);
				_tmp43_ = _tmp42_;
				vala_map_set (_tmp36_, (gpointer) ((gintptr) _tmp38_), (ValaCCodeExpression*) _tmp43_);
				_vala_ccode_node_unref0 (_tmp43_);
				_g_free0 (_tmp41_);
				_g_free0 (type_param_name);
			}
			_tmp44_ = arg_map;
			_tmp45_ = type_param_index;
			_tmp46_ = vala_ccode_base_module_get_param_pos (self, (0.1 * _tmp45_) + 0.02, FALSE);
			_tmp47_ = type_arg;
			_tmp48_ = is_chainup;
			_tmp49_ = vala_ccode_base_module_get_type_id_expression (self, _tmp47_, _tmp48_);
			_tmp50_ = _tmp49_;
			vala_map_set (_tmp44_, (gpointer) ((gintptr) _tmp46_), _tmp50_);
			_vala_ccode_node_unref0 (_tmp50_);
			_tmp51_ = type_arg;
			_tmp52_ = vala_ccode_base_module_requires_copy (self, _tmp51_);
			if (_tmp52_) {
				ValaCCodeExpression* dup_func = NULL;
				ValaDataType* _tmp53_;
				ValaDataType* _tmp54_;
				ValaSourceReference* _tmp55_;
				ValaSourceReference* _tmp56_;
				gboolean _tmp57_;
				ValaCCodeExpression* _tmp58_;
				ValaCCodeExpression* _tmp59_;
				ValaMap* _tmp61_;
				gint _tmp62_;
				gint _tmp63_;
				ValaCCodeExpression* _tmp64_;
				ValaCCodeCastExpression* _tmp65_;
				ValaCCodeCastExpression* _tmp66_;
				ValaMap* _tmp67_;
				gint _tmp68_;
				gint _tmp69_;
				ValaDataType* _tmp70_;
				gboolean _tmp71_;
				ValaCCodeExpression* _tmp72_;
				ValaCCodeExpression* _tmp73_;
				ValaCCodeCastExpression* _tmp74_;
				ValaCCodeCastExpression* _tmp75_;
				_tmp53_ = type_arg;
				_tmp54_ = type_arg;
				_tmp55_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp54_);
				_tmp56_ = _tmp55_;
				_tmp57_ = is_chainup;
				_tmp58_ = vala_ccode_base_module_get_dup_func_expression (self, _tmp53_, _tmp56_, _tmp57_);
				dup_func = _tmp58_;
				_tmp59_ = dup_func;
				if (_tmp59_ == NULL) {
					ValaCodeNode* _tmp60_;
					_tmp60_ = expr;
					vala_code_node_set_error (_tmp60_, TRUE);
					_vala_ccode_node_unref0 (dup_func);
					_vala_code_node_unref0 (type_arg);
					_vala_iterable_unref0 (_type_arg_list);
					return;
				}
				_tmp61_ = arg_map;
				_tmp62_ = type_param_index;
				_tmp63_ = vala_ccode_base_module_get_param_pos (self, (0.1 * _tmp62_) + 0.04, FALSE);
				_tmp64_ = dup_func;
				_tmp65_ = vala_ccode_cast_expression_new (_tmp64_, "GBoxedCopyFunc");
				_tmp66_ = _tmp65_;
				vala_map_set (_tmp61_, (gpointer) ((gintptr) _tmp63_), (ValaCCodeExpression*) _tmp66_);
				_vala_ccode_node_unref0 (_tmp66_);
				_tmp67_ = arg_map;
				_tmp68_ = type_param_index;
				_tmp69_ = vala_ccode_base_module_get_param_pos (self, (0.1 * _tmp68_) + 0.06, FALSE);
				_tmp70_ = type_arg;
				_tmp71_ = is_chainup;
				_tmp72_ = vala_ccode_base_module_get_destroy_func_expression (self, _tmp70_, _tmp71_);
				_tmp73_ = _tmp72_;
				_tmp74_ = vala_ccode_cast_expression_new (_tmp73_, "GDestroyNotify");
				_tmp75_ = _tmp74_;
				vala_map_set (_tmp67_, (gpointer) ((gintptr) _tmp69_), (ValaCCodeExpression*) _tmp75_);
				_vala_ccode_node_unref0 (_tmp75_);
				_vala_ccode_node_unref0 (_tmp73_);
				_vala_ccode_node_unref0 (dup_func);
			} else {
				ValaMap* _tmp76_;
				gint _tmp77_;
				gint _tmp78_;
				ValaCCodeConstant* _tmp79_;
				ValaCCodeConstant* _tmp80_;
				ValaMap* _tmp81_;
				gint _tmp82_;
				gint _tmp83_;
				ValaCCodeConstant* _tmp84_;
				ValaCCodeConstant* _tmp85_;
				_tmp76_ = arg_map;
				_tmp77_ = type_param_index;
				_tmp78_ = vala_ccode_base_module_get_param_pos (self, (0.1 * _tmp77_) + 0.04, FALSE);
				_tmp79_ = vala_ccode_constant_new ("NULL");
				_tmp80_ = _tmp79_;
				vala_map_set (_tmp76_, (gpointer) ((gintptr) _tmp78_), (ValaCCodeExpression*) _tmp80_);
				_vala_ccode_node_unref0 (_tmp80_);
				_tmp81_ = arg_map;
				_tmp82_ = type_param_index;
				_tmp83_ = vala_ccode_base_module_get_param_pos (self, (0.1 * _tmp82_) + 0.06, FALSE);
				_tmp84_ = vala_ccode_constant_new ("NULL");
				_tmp85_ = _tmp84_;
				vala_map_set (_tmp81_, (gpointer) ((gintptr) _tmp83_), (ValaCCodeExpression*) _tmp85_);
				_vala_ccode_node_unref0 (_tmp85_);
			}
			_tmp86_ = type_param_index;
			type_param_index = _tmp86_ + 1;
			_vala_code_node_unref0 (type_arg);
		}
		_vala_iterable_unref0 (_type_arg_list);
	}
}


static gpointer _vala_map_ref0 (gpointer self) {
	return self ? vala_map_ref (self) : NULL;
}


static void vala_ccode_base_module_real_visit_object_creation_expression (ValaCodeVisitor* base, ValaObjectCreationExpression* expr) {
	ValaCCodeBaseModule * self;
	ValaCCodeExpression* instance = NULL;
	ValaCCodeExpression* creation_expr = NULL;
	ValaObjectCreationExpression* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaStruct* st = NULL;
	ValaObjectCreationExpression* _tmp3_;
	ValaDataType* _tmp4_;
	ValaDataType* _tmp5_;
	ValaTypeSymbol* _tmp6_;
	ValaTypeSymbol* _tmp7_;
	ValaStruct* _tmp8_;
	gboolean _tmp9_ = FALSE;
	gboolean _tmp10_ = FALSE;
	ValaStruct* _tmp11_;
	ValaObjectCreationExpression* _tmp145_;
	ValaSymbol* _tmp146_;
	ValaSymbol* _tmp147_;
	ValaLocalVariable* local = NULL;
	ValaObjectCreationExpression* _tmp766_;
	ValaCodeNode* _tmp767_;
	ValaCodeNode* _tmp768_;
	ValaLocalVariable* _tmp769_;
	gboolean _tmp770_ = FALSE;
	ValaLocalVariable* _tmp771_;
	ValaObjectCreationExpression* _tmp951_;
	ValaTargetValue* _tmp952_;
	ValaTargetValue* _tmp953_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	instance = NULL;
	creation_expr = NULL;
	_tmp0_ = expr;
	_tmp1_ = vala_object_creation_expression_get_type_reference (_tmp0_);
	_tmp2_ = _tmp1_;
	vala_ccode_base_module_check_type (self, _tmp2_);
	_tmp3_ = expr;
	_tmp4_ = vala_object_creation_expression_get_type_reference (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = vala_data_type_get_data_type (_tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp7_) : NULL);
	st = _tmp8_;
	_tmp11_ = st;
	if (_tmp11_ != NULL) {
		gboolean _tmp12_ = FALSE;
		ValaStruct* _tmp13_;
		gboolean _tmp14_;
		_tmp13_ = st;
		_tmp14_ = vala_struct_is_simple_type (_tmp13_);
		if (!_tmp14_) {
			_tmp12_ = TRUE;
		} else {
			ValaStruct* _tmp15_;
			gchar* _tmp16_;
			gchar* _tmp17_;
			_tmp15_ = st;
			_tmp16_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp15_);
			_tmp17_ = _tmp16_;
			_tmp12_ = g_strcmp0 (_tmp17_, "va_list") == 0;
			_g_free0 (_tmp17_);
		}
		_tmp10_ = _tmp12_;
	} else {
		_tmp10_ = FALSE;
	}
	if (_tmp10_) {
		_tmp9_ = TRUE;
	} else {
		ValaObjectCreationExpression* _tmp18_;
		ValaList* _tmp19_;
		ValaList* _tmp20_;
		gint _tmp21_;
		gint _tmp22_;
		_tmp18_ = expr;
		_tmp19_ = vala_object_creation_expression_get_object_initializer (_tmp18_);
		_tmp20_ = _tmp19_;
		_tmp21_ = vala_collection_get_size ((ValaCollection*) _tmp20_);
		_tmp22_ = _tmp21_;
		_tmp9_ = _tmp22_ > 0;
		_vala_iterable_unref0 (_tmp20_);
	}
	if (_tmp9_) {
		ValaLocalVariable* local = NULL;
		ValaObjectCreationExpression* _tmp23_;
		ValaCodeNode* _tmp24_;
		ValaCodeNode* _tmp25_;
		ValaLocalVariable* _tmp26_;
		ValaField* field = NULL;
		ValaObjectCreationExpression* _tmp27_;
		ValaCodeNode* _tmp28_;
		ValaCodeNode* _tmp29_;
		ValaField* _tmp30_;
		ValaAssignment* a = NULL;
		ValaObjectCreationExpression* _tmp31_;
		ValaCodeNode* _tmp32_;
		ValaCodeNode* _tmp33_;
		ValaAssignment* _tmp34_;
		gboolean _tmp35_ = FALSE;
		ValaLocalVariable* _tmp36_;
		_tmp23_ = expr;
		_tmp24_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp23_);
		_tmp25_ = _tmp24_;
		_tmp26_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp25_) : NULL);
		local = _tmp26_;
		_tmp27_ = expr;
		_tmp28_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp27_);
		_tmp29_ = _tmp28_;
		_tmp30_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_FIELD) ? ((ValaField*) _tmp29_) : NULL);
		field = _tmp30_;
		_tmp31_ = expr;
		_tmp32_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp31_);
		_tmp33_ = _tmp32_;
		_tmp34_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp33_, VALA_TYPE_ASSIGNMENT) ? ((ValaAssignment*) _tmp33_) : NULL);
		a = _tmp34_;
		_tmp36_ = local;
		if (_tmp36_ != NULL) {
			ValaLocalVariable* _tmp37_;
			ValaLocalVariable* _tmp38_;
			ValaExpression* _tmp39_;
			ValaExpression* _tmp40_;
			gboolean _tmp41_;
			_tmp37_ = local;
			_tmp38_ = local;
			_tmp39_ = vala_variable_get_initializer ((ValaVariable*) _tmp38_);
			_tmp40_ = _tmp39_;
			_tmp41_ = vala_ccode_base_module_is_simple_struct_creation (self, (ValaVariable*) _tmp37_, _tmp40_);
			_tmp35_ = _tmp41_;
		} else {
			_tmp35_ = FALSE;
		}
		if (_tmp35_) {
			ValaLocalVariable* _tmp42_;
			ValaTargetValue* _tmp43_;
			ValaTargetValue* _tmp44_;
			ValaCCodeExpression* _tmp45_;
			_tmp42_ = local;
			_tmp43_ = vala_ccode_base_module_get_local_cvalue (self, _tmp42_);
			_tmp44_ = _tmp43_;
			_tmp45_ = vala_ccode_base_module_get_cvalue_ (self, _tmp44_);
			_vala_ccode_node_unref0 (instance);
			instance = _tmp45_;
			_vala_target_value_unref0 (_tmp44_);
		} else {
			gboolean _tmp46_ = FALSE;
			ValaField* _tmp47_;
			_tmp47_ = field;
			if (_tmp47_ != NULL) {
				ValaField* _tmp48_;
				ValaField* _tmp49_;
				ValaExpression* _tmp50_;
				ValaExpression* _tmp51_;
				gboolean _tmp52_;
				_tmp48_ = field;
				_tmp49_ = field;
				_tmp50_ = vala_variable_get_initializer ((ValaVariable*) _tmp49_);
				_tmp51_ = _tmp50_;
				_tmp52_ = vala_ccode_base_module_is_simple_struct_creation (self, (ValaVariable*) _tmp48_, _tmp51_);
				_tmp46_ = _tmp52_;
			} else {
				_tmp46_ = FALSE;
			}
			if (_tmp46_) {
				ValaTargetValue* thisparam = NULL;
				ValaField* _tmp53_;
				ValaSymbol* _tmp54_;
				ValaSymbol* _tmp55_;
				ValaTargetValue* _tmp56_;
				ValaField* _tmp57_;
				ValaTargetValue* _tmp58_;
				ValaTargetValue* _tmp59_;
				ValaTargetValue* _tmp60_;
				ValaCCodeExpression* _tmp61_;
				_tmp53_ = field;
				_tmp54_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp53_);
				_tmp55_ = _tmp54_;
				_tmp56_ = vala_ccode_base_module_load_this_parameter (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp55_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
				thisparam = _tmp56_;
				_tmp57_ = field;
				_tmp58_ = thisparam;
				_tmp59_ = vala_ccode_base_module_get_field_cvalue (self, _tmp57_, _tmp58_);
				_tmp60_ = _tmp59_;
				_tmp61_ = vala_ccode_base_module_get_cvalue_ (self, _tmp60_);
				_vala_ccode_node_unref0 (instance);
				instance = _tmp61_;
				_vala_target_value_unref0 (_tmp60_);
				_vala_target_value_unref0 (thisparam);
			} else {
				gboolean _tmp62_ = FALSE;
				gboolean _tmp63_ = FALSE;
				ValaAssignment* _tmp64_;
				_tmp64_ = a;
				if (_tmp64_ != NULL) {
					ValaAssignment* _tmp65_;
					ValaExpression* _tmp66_;
					ValaExpression* _tmp67_;
					ValaSymbol* _tmp68_;
					ValaSymbol* _tmp69_;
					_tmp65_ = a;
					_tmp66_ = vala_assignment_get_left (_tmp65_);
					_tmp67_ = _tmp66_;
					_tmp68_ = vala_expression_get_symbol_reference (_tmp67_);
					_tmp69_ = _tmp68_;
					_tmp63_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp69_, VALA_TYPE_VARIABLE);
				} else {
					_tmp63_ = FALSE;
				}
				if (_tmp63_) {
					ValaAssignment* _tmp70_;
					ValaExpression* _tmp71_;
					ValaExpression* _tmp72_;
					ValaSymbol* _tmp73_;
					ValaSymbol* _tmp74_;
					ValaAssignment* _tmp75_;
					ValaExpression* _tmp76_;
					ValaExpression* _tmp77_;
					gboolean _tmp78_;
					_tmp70_ = a;
					_tmp71_ = vala_assignment_get_left (_tmp70_);
					_tmp72_ = _tmp71_;
					_tmp73_ = vala_expression_get_symbol_reference (_tmp72_);
					_tmp74_ = _tmp73_;
					_tmp75_ = a;
					_tmp76_ = vala_assignment_get_right (_tmp75_);
					_tmp77_ = _tmp76_;
					_tmp78_ = vala_ccode_base_module_is_simple_struct_creation (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp74_, VALA_TYPE_VARIABLE, ValaVariable), _tmp77_);
					_tmp62_ = _tmp78_;
				} else {
					_tmp62_ = FALSE;
				}
				if (_tmp62_) {
					ValaAssignment* _tmp79_;
					ValaExpression* _tmp80_;
					ValaExpression* _tmp81_;
					ValaDataType* _tmp82_;
					ValaDataType* _tmp83_;
					gboolean _tmp84_;
					ValaAssignment* _tmp94_;
					ValaExpression* _tmp95_;
					ValaExpression* _tmp96_;
					ValaSymbol* _tmp97_;
					ValaSymbol* _tmp98_;
					ValaLocalVariable* _tmp99_;
					ValaAssignment* _tmp100_;
					ValaExpression* _tmp101_;
					ValaExpression* _tmp102_;
					ValaSymbol* _tmp103_;
					ValaSymbol* _tmp104_;
					ValaField* _tmp105_;
					ValaParameter* param = NULL;
					ValaAssignment* _tmp106_;
					ValaExpression* _tmp107_;
					ValaExpression* _tmp108_;
					ValaSymbol* _tmp109_;
					ValaSymbol* _tmp110_;
					ValaParameter* _tmp111_;
					ValaLocalVariable* _tmp112_;
					_tmp79_ = a;
					_tmp80_ = vala_assignment_get_left (_tmp79_);
					_tmp81_ = _tmp80_;
					_tmp82_ = vala_expression_get_value_type (_tmp81_);
					_tmp83_ = _tmp82_;
					_tmp84_ = vala_ccode_base_module_requires_destroy (self, _tmp83_);
					if (_tmp84_) {
						ValaCCodeFunction* _tmp85_;
						ValaCCodeFunction* _tmp86_;
						ValaAssignment* _tmp87_;
						ValaExpression* _tmp88_;
						ValaExpression* _tmp89_;
						ValaTargetValue* _tmp90_;
						ValaTargetValue* _tmp91_;
						ValaCCodeExpression* _tmp92_;
						ValaCCodeExpression* _tmp93_;
						_tmp85_ = vala_ccode_base_module_get_ccode (self);
						_tmp86_ = _tmp85_;
						_tmp87_ = a;
						_tmp88_ = vala_assignment_get_left (_tmp87_);
						_tmp89_ = _tmp88_;
						_tmp90_ = vala_expression_get_target_value (_tmp89_);
						_tmp91_ = _tmp90_;
						_tmp92_ = vala_ccode_base_module_destroy_value (self, _tmp91_, FALSE);
						_tmp93_ = _tmp92_;
						vala_ccode_function_add_expression (_tmp86_, _tmp93_);
						_vala_ccode_node_unref0 (_tmp93_);
					}
					_tmp94_ = a;
					_tmp95_ = vala_assignment_get_left (_tmp94_);
					_tmp96_ = _tmp95_;
					_tmp97_ = vala_expression_get_symbol_reference (_tmp96_);
					_tmp98_ = _tmp97_;
					_tmp99_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp98_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp98_) : NULL);
					_vala_code_node_unref0 (local);
					local = _tmp99_;
					_tmp100_ = a;
					_tmp101_ = vala_assignment_get_left (_tmp100_);
					_tmp102_ = _tmp101_;
					_tmp103_ = vala_expression_get_symbol_reference (_tmp102_);
					_tmp104_ = _tmp103_;
					_tmp105_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp104_, VALA_TYPE_FIELD) ? ((ValaField*) _tmp104_) : NULL);
					_vala_code_node_unref0 (field);
					field = _tmp105_;
					_tmp106_ = a;
					_tmp107_ = vala_assignment_get_left (_tmp106_);
					_tmp108_ = _tmp107_;
					_tmp109_ = vala_expression_get_symbol_reference (_tmp108_);
					_tmp110_ = _tmp109_;
					_tmp111_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp110_, VALA_TYPE_PARAMETER) ? ((ValaParameter*) _tmp110_) : NULL);
					param = _tmp111_;
					_tmp112_ = local;
					if (_tmp112_ != NULL) {
						ValaLocalVariable* _tmp113_;
						ValaTargetValue* _tmp114_;
						ValaTargetValue* _tmp115_;
						ValaCCodeExpression* _tmp116_;
						_tmp113_ = local;
						_tmp114_ = vala_ccode_base_module_get_local_cvalue (self, _tmp113_);
						_tmp115_ = _tmp114_;
						_tmp116_ = vala_ccode_base_module_get_cvalue_ (self, _tmp115_);
						_vala_ccode_node_unref0 (instance);
						instance = _tmp116_;
						_vala_target_value_unref0 (_tmp115_);
					} else {
						ValaField* _tmp117_;
						_tmp117_ = field;
						if (_tmp117_ != NULL) {
							ValaExpression* inner = NULL;
							ValaAssignment* _tmp118_;
							ValaExpression* _tmp119_;
							ValaExpression* _tmp120_;
							ValaExpression* _tmp121_;
							ValaExpression* _tmp122_;
							ValaExpression* _tmp123_;
							ValaTargetValue* _tmp124_ = NULL;
							ValaExpression* _tmp125_;
							ValaField* _tmp129_;
							ValaTargetValue* _tmp130_;
							ValaTargetValue* _tmp131_;
							ValaCCodeExpression* _tmp132_;
							_tmp118_ = a;
							_tmp119_ = vala_assignment_get_left (_tmp118_);
							_tmp120_ = _tmp119_;
							_tmp121_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp120_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
							_tmp122_ = _tmp121_;
							_tmp123_ = _vala_code_node_ref0 (_tmp122_);
							inner = _tmp123_;
							_tmp125_ = inner;
							if (_tmp125_ != NULL) {
								ValaExpression* _tmp126_;
								ValaTargetValue* _tmp127_;
								ValaTargetValue* _tmp128_;
								_tmp126_ = inner;
								_tmp127_ = vala_expression_get_target_value (_tmp126_);
								_tmp128_ = _tmp127_;
								_tmp124_ = _tmp128_;
							} else {
								_tmp124_ = NULL;
							}
							_tmp129_ = field;
							_tmp130_ = vala_ccode_base_module_get_field_cvalue (self, _tmp129_, _tmp124_);
							_tmp131_ = _tmp130_;
							_tmp132_ = vala_ccode_base_module_get_cvalue_ (self, _tmp131_);
							_vala_ccode_node_unref0 (instance);
							instance = _tmp132_;
							_vala_target_value_unref0 (_tmp131_);
							_vala_code_node_unref0 (inner);
						} else {
							ValaParameter* _tmp133_;
							_tmp133_ = param;
							if (_tmp133_ != NULL) {
								ValaParameter* _tmp134_;
								ValaTargetValue* _tmp135_;
								ValaTargetValue* _tmp136_;
								ValaCCodeExpression* _tmp137_;
								_tmp134_ = param;
								_tmp135_ = vala_ccode_base_module_get_parameter_cvalue (self, _tmp134_);
								_tmp136_ = _tmp135_;
								_tmp137_ = vala_ccode_base_module_get_cvalue_ (self, _tmp136_);
								_vala_ccode_node_unref0 (instance);
								instance = _tmp137_;
								_vala_target_value_unref0 (_tmp136_);
							}
						}
					}
					_vala_code_node_unref0 (param);
				} else {
					ValaTargetValue* temp_value = NULL;
					ValaObjectCreationExpression* _tmp138_;
					ValaDataType* _tmp139_;
					ValaDataType* _tmp140_;
					ValaObjectCreationExpression* _tmp141_;
					ValaTargetValue* _tmp142_;
					ValaTargetValue* _tmp143_;
					ValaCCodeExpression* _tmp144_;
					_tmp138_ = expr;
					_tmp139_ = vala_object_creation_expression_get_type_reference (_tmp138_);
					_tmp140_ = _tmp139_;
					_tmp141_ = expr;
					_tmp142_ = vala_ccode_base_module_create_temp_value (self, _tmp140_, TRUE, (ValaCodeNode*) _tmp141_, NULL);
					temp_value = _tmp142_;
					_tmp143_ = temp_value;
					_tmp144_ = vala_ccode_base_module_get_cvalue_ (self, _tmp143_);
					_vala_ccode_node_unref0 (instance);
					instance = _tmp144_;
					_vala_target_value_unref0 (temp_value);
				}
			}
		}
		_vala_code_node_unref0 (a);
		_vala_code_node_unref0 (field);
		_vala_code_node_unref0 (local);
	}
	_tmp145_ = expr;
	_tmp146_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp145_);
	_tmp147_ = _tmp146_;
	if (_tmp147_ == NULL) {
		ValaObjectCreationExpression* _tmp148_;
		ValaDataType* _tmp149_;
		ValaDataType* _tmp150_;
		ValaTypeSymbol* _tmp151_;
		ValaTypeSymbol* _tmp152_;
		_tmp148_ = expr;
		_tmp149_ = vala_object_creation_expression_get_type_reference (_tmp148_);
		_tmp150_ = _tmp149_;
		_tmp151_ = vala_data_type_get_data_type (_tmp150_);
		_tmp152_ = _tmp151_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp152_, VALA_TYPE_STRUCT)) {
			ValaCCodeFile* _tmp153_;
			ValaCCodeFunctionCall* creation_call = NULL;
			ValaCCodeIdentifier* _tmp154_;
			ValaCCodeIdentifier* _tmp155_;
			ValaCCodeFunctionCall* _tmp156_;
			ValaCCodeFunctionCall* _tmp157_;
			ValaCCodeFunctionCall* _tmp158_;
			ValaCCodeExpression* _tmp159_;
			ValaCCodeUnaryExpression* _tmp160_;
			ValaCCodeUnaryExpression* _tmp161_;
			ValaCCodeFunctionCall* _tmp162_;
			ValaCCodeConstant* _tmp163_;
			ValaCCodeConstant* _tmp164_;
			ValaCCodeFunctionCall* _tmp165_;
			ValaObjectCreationExpression* _tmp166_;
			ValaDataType* _tmp167_;
			ValaDataType* _tmp168_;
			gchar* _tmp169_;
			gchar* _tmp170_;
			gchar* _tmp171_;
			gchar* _tmp172_;
			ValaCCodeIdentifier* _tmp173_;
			ValaCCodeIdentifier* _tmp174_;
			ValaCCodeFunctionCall* _tmp175_;
			ValaCCodeExpression* _tmp176_;
			_tmp153_ = self->cfile;
			vala_ccode_file_add_include (_tmp153_, "string.h", FALSE);
			_tmp154_ = vala_ccode_identifier_new ("memset");
			_tmp155_ = _tmp154_;
			_tmp156_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp155_);
			_tmp157_ = _tmp156_;
			_vala_ccode_node_unref0 (_tmp155_);
			creation_call = _tmp157_;
			_tmp158_ = creation_call;
			_tmp159_ = instance;
			_tmp160_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp159_);
			_tmp161_ = _tmp160_;
			vala_ccode_function_call_add_argument (_tmp158_, (ValaCCodeExpression*) _tmp161_);
			_vala_ccode_node_unref0 (_tmp161_);
			_tmp162_ = creation_call;
			_tmp163_ = vala_ccode_constant_new ("0");
			_tmp164_ = _tmp163_;
			vala_ccode_function_call_add_argument (_tmp162_, (ValaCCodeExpression*) _tmp164_);
			_vala_ccode_node_unref0 (_tmp164_);
			_tmp165_ = creation_call;
			_tmp166_ = expr;
			_tmp167_ = vala_object_creation_expression_get_type_reference (_tmp166_);
			_tmp168_ = _tmp167_;
			_tmp169_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp168_);
			_tmp170_ = _tmp169_;
			_tmp171_ = g_strdup_printf ("sizeof (%s)", _tmp170_);
			_tmp172_ = _tmp171_;
			_tmp173_ = vala_ccode_identifier_new (_tmp172_);
			_tmp174_ = _tmp173_;
			vala_ccode_function_call_add_argument (_tmp165_, (ValaCCodeExpression*) _tmp174_);
			_vala_ccode_node_unref0 (_tmp174_);
			_g_free0 (_tmp172_);
			_g_free0 (_tmp170_);
			_tmp175_ = creation_call;
			_tmp176_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp175_);
			_vala_ccode_node_unref0 (creation_expr);
			creation_expr = _tmp176_;
			_vala_ccode_node_unref0 (creation_call);
		}
	} else {
		gboolean _tmp177_ = FALSE;
		ValaObjectCreationExpression* _tmp178_;
		ValaDataType* _tmp179_;
		ValaDataType* _tmp180_;
		ValaTypeSymbol* _tmp181_;
		ValaTypeSymbol* _tmp182_;
		ValaClass* _tmp183_;
		_tmp178_ = expr;
		_tmp179_ = vala_object_creation_expression_get_type_reference (_tmp178_);
		_tmp180_ = _tmp179_;
		_tmp181_ = vala_data_type_get_data_type (_tmp180_);
		_tmp182_ = _tmp181_;
		_tmp183_ = self->glist_type;
		if (_tmp182_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp183_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) {
			_tmp177_ = TRUE;
		} else {
			ValaObjectCreationExpression* _tmp184_;
			ValaDataType* _tmp185_;
			ValaDataType* _tmp186_;
			ValaTypeSymbol* _tmp187_;
			ValaTypeSymbol* _tmp188_;
			ValaClass* _tmp189_;
			_tmp184_ = expr;
			_tmp185_ = vala_object_creation_expression_get_type_reference (_tmp184_);
			_tmp186_ = _tmp185_;
			_tmp187_ = vala_data_type_get_data_type (_tmp186_);
			_tmp188_ = _tmp187_;
			_tmp189_ = self->gslist_type;
			_tmp177_ = _tmp188_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp189_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
		}
		if (_tmp177_) {
			ValaObjectCreationExpression* _tmp190_;
			ValaCCodeConstant* _tmp191_;
			ValaCCodeConstant* _tmp192_;
			_tmp190_ = expr;
			_tmp191_ = vala_ccode_constant_new ("NULL");
			_tmp192_ = _tmp191_;
			vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp190_, (ValaCCodeExpression*) _tmp192_);
			_vala_ccode_node_unref0 (_tmp192_);
		} else {
			ValaObjectCreationExpression* _tmp193_;
			ValaSymbol* _tmp194_;
			ValaSymbol* _tmp195_;
			_tmp193_ = expr;
			_tmp194_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp193_);
			_tmp195_ = _tmp194_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp195_, VALA_TYPE_METHOD)) {
				ValaMethod* m = NULL;
				ValaObjectCreationExpression* _tmp196_;
				ValaSymbol* _tmp197_;
				ValaSymbol* _tmp198_;
				ValaMethod* _tmp199_;
				ValaList* params = NULL;
				ValaMethod* _tmp200_;
				ValaList* _tmp201_;
				ValaCCodeFunctionCall* creation_call = NULL;
				ValaCCodeFunctionCall* async_call = NULL;
				ValaCCodeFunctionCall* finish_call = NULL;
				ValaMethod* _tmp202_;
				ValaCCodeFile* _tmp203_;
				ValaClass* cl = NULL;
				ValaObjectCreationExpression* _tmp204_;
				ValaDataType* _tmp205_;
				ValaDataType* _tmp206_;
				ValaTypeSymbol* _tmp207_;
				ValaTypeSymbol* _tmp208_;
				ValaClass* _tmp209_;
				ValaMethod* _tmp210_;
				gboolean _tmp211_;
				gboolean _tmp230_ = FALSE;
				gboolean _tmp231_ = FALSE;
				ValaStruct* _tmp232_;
				ValaObjectCreationExpression* _tmp308_;
				ValaDataType* _tmp309_;
				ValaDataType* _tmp310_;
				ValaCCodeFile* _tmp311_;
				ValaHashMap* in_arg_map = NULL;
				GHashFunc _tmp312_;
				GEqualFunc _tmp313_;
				GEqualFunc _tmp314_;
				ValaHashMap* _tmp315_;
				ValaHashMap* out_arg_map = NULL;
				ValaHashMap* _tmp316_;
				ValaHashMap* _tmp317_;
				gboolean _tmp318_ = FALSE;
				ValaMethod* _tmp319_;
				gboolean _tmp347_ = FALSE;
				ValaClass* _tmp348_;
				gboolean ellipsis = FALSE;
				gint i = 0;
				gint arg_pos = 0;
				ValaIterator* params_it = NULL;
				ValaList* _tmp390_;
				ValaIterator* _tmp391_;
				ValaIterator* _tmp528_;
				gboolean _tmp529_;
				ValaObjectCreationExpression* _tmp539_;
				gboolean _tmp540_;
				gboolean _tmp541_;
				gboolean _tmp548_;
				gboolean _tmp572_ = FALSE;
				gboolean _tmp573_ = FALSE;
				ValaStruct* _tmp574_;
				gboolean _tmp584_ = FALSE;
				ValaMethod* _tmp585_;
				gboolean _tmp604_ = FALSE;
				ValaMethod* _tmp605_;
				gint last_pos = 0;
				gint min_pos = 0;
				ValaCCodeFunctionCall* _tmp620_;
				ValaCCodeFunctionCall* _tmp621_;
				ValaCCodeFunctionCall* _tmp646_;
				ValaObjectCreationExpression* _tmp671_;
				gboolean _tmp672_;
				gboolean _tmp673_;
				ValaCCodeFunctionCall* _tmp699_;
				ValaCCodeExpression* _tmp700_;
				ValaMethod* _tmp701_;
				gchar* _tmp702_;
				gchar* _tmp703_;
				gboolean _tmp704_;
				_tmp196_ = expr;
				_tmp197_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp196_);
				_tmp198_ = _tmp197_;
				_tmp199_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp198_, VALA_TYPE_METHOD, ValaMethod));
				m = _tmp199_;
				_tmp200_ = m;
				_tmp201_ = vala_callable_get_parameters ((ValaCallable*) _tmp200_);
				params = _tmp201_;
				async_call = NULL;
				finish_call = NULL;
				_tmp202_ = m;
				_tmp203_ = self->cfile;
				vala_ccode_base_module_generate_method_declaration (self, _tmp202_, _tmp203_);
				_tmp204_ = expr;
				_tmp205_ = vala_object_creation_expression_get_type_reference (_tmp204_);
				_tmp206_ = _tmp205_;
				_tmp207_ = vala_data_type_get_data_type (_tmp206_);
				_tmp208_ = _tmp207_;
				_tmp209_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp208_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp208_) : NULL);
				cl = _tmp209_;
				_tmp210_ = m;
				_tmp211_ = vala_ccode_base_module_get_ccode_has_new_function (_tmp210_);
				if (!_tmp211_) {
					ValaMethod* _tmp212_;
					gchar* _tmp213_;
					gchar* _tmp214_;
					ValaCCodeIdentifier* _tmp215_;
					ValaCCodeIdentifier* _tmp216_;
					ValaCCodeFunctionCall* _tmp217_;
					ValaCCodeFunctionCall* _tmp218_;
					ValaClass* _tmp219_;
					gchar* _tmp220_;
					gchar* _tmp221_;
					ValaCCodeIdentifier* _tmp222_;
					ValaCCodeIdentifier* _tmp223_;
					_tmp212_ = m;
					_tmp213_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp212_);
					_tmp214_ = _tmp213_;
					_tmp215_ = vala_ccode_identifier_new (_tmp214_);
					_tmp216_ = _tmp215_;
					_tmp217_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp216_);
					_vala_ccode_node_unref0 (creation_call);
					creation_call = _tmp217_;
					_vala_ccode_node_unref0 (_tmp216_);
					_g_free0 (_tmp214_);
					_tmp218_ = creation_call;
					_tmp219_ = cl;
					_tmp220_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp219_);
					_tmp221_ = _tmp220_;
					_tmp222_ = vala_ccode_identifier_new (_tmp221_);
					_tmp223_ = _tmp222_;
					vala_ccode_function_call_add_argument (_tmp218_, (ValaCCodeExpression*) _tmp223_);
					_vala_ccode_node_unref0 (_tmp223_);
					_g_free0 (_tmp221_);
				} else {
					ValaMethod* _tmp224_;
					gchar* _tmp225_;
					gchar* _tmp226_;
					ValaCCodeIdentifier* _tmp227_;
					ValaCCodeIdentifier* _tmp228_;
					ValaCCodeFunctionCall* _tmp229_;
					_tmp224_ = m;
					_tmp225_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp224_);
					_tmp226_ = _tmp225_;
					_tmp227_ = vala_ccode_identifier_new (_tmp226_);
					_tmp228_ = _tmp227_;
					_tmp229_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp228_);
					_vala_ccode_node_unref0 (creation_call);
					creation_call = _tmp229_;
					_vala_ccode_node_unref0 (_tmp228_);
					_g_free0 (_tmp226_);
				}
				_tmp232_ = st;
				if (_tmp232_ != NULL) {
					ValaStruct* _tmp233_;
					gboolean _tmp234_;
					_tmp233_ = st;
					_tmp234_ = vala_struct_is_simple_type (_tmp233_);
					_tmp231_ = !_tmp234_;
				} else {
					_tmp231_ = FALSE;
				}
				if (_tmp231_) {
					ValaMethod* _tmp235_;
					gdouble _tmp236_;
					_tmp235_ = m;
					_tmp236_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp235_);
					_tmp230_ = !(_tmp236_ < ((gdouble) 0));
				} else {
					_tmp230_ = FALSE;
				}
				if (_tmp230_) {
					ValaCCodeFunctionCall* _tmp237_;
					ValaCCodeExpression* _tmp238_;
					ValaCCodeUnaryExpression* _tmp239_;
					ValaCCodeUnaryExpression* _tmp240_;
					_tmp237_ = creation_call;
					_tmp238_ = instance;
					_tmp239_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp238_);
					_tmp240_ = _tmp239_;
					vala_ccode_function_call_add_argument (_tmp237_, (ValaCCodeExpression*) _tmp240_);
					_vala_ccode_node_unref0 (_tmp240_);
				} else {
					gboolean _tmp241_ = FALSE;
					ValaStruct* _tmp242_;
					_tmp242_ = st;
					if (_tmp242_ != NULL) {
						ValaStruct* _tmp243_;
						gchar* _tmp244_;
						gchar* _tmp245_;
						_tmp243_ = st;
						_tmp244_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp243_);
						_tmp245_ = _tmp244_;
						_tmp241_ = g_strcmp0 (_tmp245_, "va_list") == 0;
						_g_free0 (_tmp245_);
					} else {
						_tmp241_ = FALSE;
					}
					if (_tmp241_) {
						ValaCCodeFunctionCall* _tmp246_;
						ValaCCodeExpression* _tmp247_;
						ValaMethod* _tmp248_;
						gchar* _tmp249_;
						gchar* _tmp250_;
						gboolean _tmp251_;
						_tmp246_ = creation_call;
						_tmp247_ = instance;
						vala_ccode_function_call_add_argument (_tmp246_, _tmp247_);
						_tmp248_ = m;
						_tmp249_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp248_);
						_tmp250_ = _tmp249_;
						_tmp251_ = g_strcmp0 (_tmp250_, "va_start") == 0;
						_g_free0 (_tmp250_);
						if (_tmp251_) {
							gboolean _tmp252_;
							gboolean _tmp253_;
							_tmp252_ = vala_ccode_base_module_get_in_creation_method (self);
							_tmp253_ = _tmp252_;
							if (_tmp253_) {
								ValaCCodeIdentifier* _tmp254_;
								ValaCCodeIdentifier* _tmp255_;
								ValaCCodeFunctionCall* _tmp256_;
								ValaCCodeFunctionCall* _tmp257_;
								ValaCCodeExpression* _tmp258_;
								ValaCCodeFunctionCall* _tmp259_;
								ValaCCodeIdentifier* _tmp260_;
								ValaCCodeIdentifier* _tmp261_;
								_tmp254_ = vala_ccode_identifier_new ("va_copy");
								_tmp255_ = _tmp254_;
								_tmp256_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp255_);
								_vala_ccode_node_unref0 (creation_call);
								creation_call = _tmp256_;
								_vala_ccode_node_unref0 (_tmp255_);
								_tmp257_ = creation_call;
								_tmp258_ = instance;
								vala_ccode_function_call_add_argument (_tmp257_, _tmp258_);
								_tmp259_ = creation_call;
								_tmp260_ = vala_ccode_identifier_new ("_vala_va_list");
								_tmp261_ = _tmp260_;
								vala_ccode_function_call_add_argument (_tmp259_, (ValaCCodeExpression*) _tmp261_);
								_vala_ccode_node_unref0 (_tmp261_);
							} else {
								ValaParameter* last_param = NULL;
								gint nParams = 0;
								ValaCCodeFunction* _tmp279_;
								ValaCCodeFunction* _tmp280_;
								gint _tmp281_;
								gboolean _tmp282_ = FALSE;
								gint _tmp283_;
								last_param = NULL;
								{
									ValaList* _param_list = NULL;
									ValaMethod* _tmp262_;
									ValaMethod* _tmp263_;
									ValaList* _tmp264_;
									gint _param_size = 0;
									ValaList* _tmp265_;
									gint _tmp266_;
									gint _tmp267_;
									gint _param_index = 0;
									_tmp262_ = vala_ccode_base_module_get_current_method (self);
									_tmp263_ = _tmp262_;
									_tmp264_ = vala_callable_get_parameters ((ValaCallable*) _tmp263_);
									_param_list = _tmp264_;
									_tmp265_ = _param_list;
									_tmp266_ = vala_collection_get_size ((ValaCollection*) _tmp265_);
									_tmp267_ = _tmp266_;
									_param_size = _tmp267_;
									_param_index = -1;
									while (TRUE) {
										gint _tmp268_;
										gint _tmp269_;
										gint _tmp270_;
										ValaParameter* param = NULL;
										ValaList* _tmp271_;
										gint _tmp272_;
										gpointer _tmp273_;
										ValaParameter* _tmp274_;
										gboolean _tmp275_;
										gboolean _tmp276_;
										ValaParameter* _tmp277_;
										ValaParameter* _tmp278_;
										_tmp268_ = _param_index;
										_param_index = _tmp268_ + 1;
										_tmp269_ = _param_index;
										_tmp270_ = _param_size;
										if (!(_tmp269_ < _tmp270_)) {
											break;
										}
										_tmp271_ = _param_list;
										_tmp272_ = _param_index;
										_tmp273_ = vala_list_get (_tmp271_, _tmp272_);
										param = (ValaParameter*) _tmp273_;
										_tmp274_ = param;
										_tmp275_ = vala_parameter_get_ellipsis (_tmp274_);
										_tmp276_ = _tmp275_;
										if (_tmp276_) {
											_vala_code_node_unref0 (param);
											break;
										}
										_tmp277_ = param;
										_tmp278_ = _vala_code_node_ref0 (_tmp277_);
										_vala_code_node_unref0 (last_param);
										last_param = _tmp278_;
										_vala_code_node_unref0 (param);
									}
									_vala_iterable_unref0 (_param_list);
								}
								_tmp279_ = vala_ccode_base_module_get_ccode (self);
								_tmp280_ = _tmp279_;
								_tmp281_ = vala_ccode_function_get_parameter_count (_tmp280_);
								nParams = _tmp281_;
								_tmp283_ = nParams;
								if (_tmp283_ == 0) {
									_tmp282_ = TRUE;
								} else {
									ValaCCodeFunction* _tmp284_;
									ValaCCodeFunction* _tmp285_;
									gint _tmp286_;
									ValaCCodeParameter* _tmp287_;
									ValaCCodeParameter* _tmp288_;
									gboolean _tmp289_;
									gboolean _tmp290_;
									_tmp284_ = vala_ccode_base_module_get_ccode (self);
									_tmp285_ = _tmp284_;
									_tmp286_ = nParams;
									_tmp287_ = vala_ccode_function_get_parameter (_tmp285_, _tmp286_ - 1);
									_tmp288_ = _tmp287_;
									_tmp289_ = vala_ccode_parameter_get_ellipsis (_tmp288_);
									_tmp290_ = _tmp289_;
									_tmp282_ = !_tmp290_;
									_vala_ccode_node_unref0 (_tmp288_);
								}
								if (_tmp282_) {
									ValaObjectCreationExpression* _tmp291_;
									ValaSourceReference* _tmp292_;
									ValaSourceReference* _tmp293_;
									_tmp291_ = expr;
									_tmp292_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp291_);
									_tmp293_ = _tmp292_;
									vala_report_error (_tmp293_, "`va_list' used in method with fixed args");
								} else {
									gint _tmp294_;
									_tmp294_ = nParams;
									if (_tmp294_ == 1) {
										ValaObjectCreationExpression* _tmp295_;
										ValaSourceReference* _tmp296_;
										ValaSourceReference* _tmp297_;
										_tmp295_ = expr;
										_tmp296_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp295_);
										_tmp297_ = _tmp296_;
										vala_report_error (_tmp297_, "`va_list' used in method without parameter");
									} else {
										ValaCCodeFunctionCall* _tmp298_;
										ValaCCodeFunction* _tmp299_;
										ValaCCodeFunction* _tmp300_;
										gint _tmp301_;
										ValaCCodeParameter* _tmp302_;
										ValaCCodeParameter* _tmp303_;
										const gchar* _tmp304_;
										const gchar* _tmp305_;
										ValaCCodeIdentifier* _tmp306_;
										ValaCCodeIdentifier* _tmp307_;
										_tmp298_ = creation_call;
										_tmp299_ = vala_ccode_base_module_get_ccode (self);
										_tmp300_ = _tmp299_;
										_tmp301_ = nParams;
										_tmp302_ = vala_ccode_function_get_parameter (_tmp300_, _tmp301_ - 2);
										_tmp303_ = _tmp302_;
										_tmp304_ = vala_ccode_parameter_get_name (_tmp303_);
										_tmp305_ = _tmp304_;
										_tmp306_ = vala_ccode_identifier_new (_tmp305_);
										_tmp307_ = _tmp306_;
										vala_ccode_function_call_add_argument (_tmp298_, (ValaCCodeExpression*) _tmp307_);
										_vala_ccode_node_unref0 (_tmp307_);
										_vala_ccode_node_unref0 (_tmp303_);
									}
								}
								_vala_code_node_unref0 (last_param);
							}
						}
					}
				}
				_tmp308_ = expr;
				_tmp309_ = vala_object_creation_expression_get_type_reference (_tmp308_);
				_tmp310_ = _tmp309_;
				_tmp311_ = self->cfile;
				vala_ccode_base_module_generate_type_declaration (self, _tmp310_, _tmp311_);
				_tmp312_ = g_direct_hash;
				_tmp313_ = g_direct_equal;
				_tmp314_ = g_direct_equal;
				_tmp315_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp312_, _tmp313_, _tmp314_);
				in_arg_map = _tmp315_;
				_tmp316_ = in_arg_map;
				_tmp317_ = _vala_map_ref0 (_tmp316_);
				out_arg_map = _tmp317_;
				_tmp319_ = m;
				if (_tmp319_ != NULL) {
					ValaMethod* _tmp320_;
					gboolean _tmp321_;
					gboolean _tmp322_;
					_tmp320_ = m;
					_tmp321_ = vala_method_get_coroutine (_tmp320_);
					_tmp322_ = _tmp321_;
					_tmp318_ = _tmp322_;
				} else {
					_tmp318_ = FALSE;
				}
				if (_tmp318_) {
					ValaMethod* _tmp323_;
					gchar* _tmp324_;
					gchar* _tmp325_;
					ValaCCodeIdentifier* _tmp326_;
					ValaCCodeIdentifier* _tmp327_;
					ValaCCodeFunctionCall* _tmp328_;
					ValaMethod* _tmp329_;
					gchar* _tmp330_;
					gchar* _tmp331_;
					ValaCCodeIdentifier* _tmp332_;
					ValaCCodeIdentifier* _tmp333_;
					ValaCCodeFunctionCall* _tmp334_;
					ValaCCodeFunctionCall* _tmp335_;
					ValaCCodeFunctionCall* _tmp336_;
					GHashFunc _tmp337_;
					GEqualFunc _tmp338_;
					GEqualFunc _tmp339_;
					ValaHashMap* _tmp340_;
					ValaHashMap* _tmp341_;
					gint _tmp342_;
					ValaCCodeIdentifier* _tmp343_;
					ValaCCodeIdentifier* _tmp344_;
					ValaCCodeMemberAccess* _tmp345_;
					ValaCCodeMemberAccess* _tmp346_;
					_tmp323_ = m;
					_tmp324_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp323_);
					_tmp325_ = _tmp324_;
					_tmp326_ = vala_ccode_identifier_new (_tmp325_);
					_tmp327_ = _tmp326_;
					_tmp328_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp327_);
					_vala_ccode_node_unref0 (async_call);
					async_call = _tmp328_;
					_vala_ccode_node_unref0 (_tmp327_);
					_g_free0 (_tmp325_);
					_tmp329_ = m;
					_tmp330_ = vala_ccode_base_module_get_ccode_finish_name (_tmp329_);
					_tmp331_ = _tmp330_;
					_tmp332_ = vala_ccode_identifier_new (_tmp331_);
					_tmp333_ = _tmp332_;
					_tmp334_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp333_);
					_vala_ccode_node_unref0 (finish_call);
					finish_call = _tmp334_;
					_vala_ccode_node_unref0 (_tmp333_);
					_g_free0 (_tmp331_);
					_tmp335_ = finish_call;
					_tmp336_ = _vala_ccode_node_ref0 (_tmp335_);
					_vala_ccode_node_unref0 (creation_call);
					creation_call = _tmp336_;
					_tmp337_ = g_direct_hash;
					_tmp338_ = g_direct_equal;
					_tmp339_ = g_direct_equal;
					_tmp340_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp337_, _tmp338_, _tmp339_);
					_vala_map_unref0 (out_arg_map);
					out_arg_map = _tmp340_;
					_tmp341_ = out_arg_map;
					_tmp342_ = vala_ccode_base_module_get_param_pos (self, 0.1, FALSE);
					_tmp343_ = vala_ccode_identifier_new ("_data_");
					_tmp344_ = _tmp343_;
					_tmp345_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp344_, "_res_");
					_tmp346_ = _tmp345_;
					vala_map_set ((ValaMap*) _tmp341_, (gpointer) ((gintptr) _tmp342_), (ValaCCodeExpression*) _tmp346_);
					_vala_ccode_node_unref0 (_tmp346_);
					_vala_ccode_node_unref0 (_tmp344_);
				}
				_tmp348_ = cl;
				if (_tmp348_ != NULL) {
					ValaClass* _tmp349_;
					gboolean _tmp350_;
					gboolean _tmp351_;
					_tmp349_ = cl;
					_tmp350_ = vala_class_get_is_compact (_tmp349_);
					_tmp351_ = _tmp350_;
					_tmp347_ = !_tmp351_;
				} else {
					_tmp347_ = FALSE;
				}
				if (_tmp347_) {
					ValaHashMap* _tmp352_;
					ValaObjectCreationExpression* _tmp353_;
					ValaDataType* _tmp354_;
					ValaDataType* _tmp355_;
					ValaList* _tmp356_;
					ValaList* _tmp357_;
					ValaObjectCreationExpression* _tmp358_;
					_tmp352_ = in_arg_map;
					_tmp353_ = expr;
					_tmp354_ = vala_object_creation_expression_get_type_reference (_tmp353_);
					_tmp355_ = _tmp354_;
					_tmp356_ = vala_data_type_get_type_arguments (_tmp355_);
					_tmp357_ = _tmp356_;
					_tmp358_ = expr;
					vala_ccode_base_module_add_generic_type_arguments (self, (ValaMap*) _tmp352_, _tmp357_, (ValaCodeNode*) _tmp358_, FALSE, NULL);
					_vala_iterable_unref0 (_tmp357_);
				} else {
					gboolean _tmp359_ = FALSE;
					ValaClass* _tmp360_;
					_tmp360_ = cl;
					if (_tmp360_ != NULL) {
						ValaMethod* _tmp361_;
						gboolean _tmp362_;
						_tmp361_ = m;
						_tmp362_ = vala_ccode_base_module_get_ccode_simple_generics (_tmp361_);
						_tmp359_ = _tmp362_;
					} else {
						_tmp359_ = FALSE;
					}
					if (_tmp359_) {
						gint type_param_index = 0;
						type_param_index = 0;
						{
							ValaList* _type_arg_list = NULL;
							ValaObjectCreationExpression* _tmp363_;
							ValaDataType* _tmp364_;
							ValaDataType* _tmp365_;
							ValaList* _tmp366_;
							gint _type_arg_size = 0;
							ValaList* _tmp367_;
							gint _tmp368_;
							gint _tmp369_;
							gint _type_arg_index = 0;
							_tmp363_ = expr;
							_tmp364_ = vala_object_creation_expression_get_type_reference (_tmp363_);
							_tmp365_ = _tmp364_;
							_tmp366_ = vala_data_type_get_type_arguments (_tmp365_);
							_type_arg_list = _tmp366_;
							_tmp367_ = _type_arg_list;
							_tmp368_ = vala_collection_get_size ((ValaCollection*) _tmp367_);
							_tmp369_ = _tmp368_;
							_type_arg_size = _tmp369_;
							_type_arg_index = -1;
							while (TRUE) {
								gint _tmp370_;
								gint _tmp371_;
								gint _tmp372_;
								ValaDataType* type_arg = NULL;
								ValaList* _tmp373_;
								gint _tmp374_;
								gpointer _tmp375_;
								ValaDataType* _tmp376_;
								gboolean _tmp377_;
								gint _tmp389_;
								_tmp370_ = _type_arg_index;
								_type_arg_index = _tmp370_ + 1;
								_tmp371_ = _type_arg_index;
								_tmp372_ = _type_arg_size;
								if (!(_tmp371_ < _tmp372_)) {
									break;
								}
								_tmp373_ = _type_arg_list;
								_tmp374_ = _type_arg_index;
								_tmp375_ = vala_list_get (_tmp373_, _tmp374_);
								type_arg = (ValaDataType*) _tmp375_;
								_tmp376_ = type_arg;
								_tmp377_ = vala_ccode_base_module_requires_copy (self, _tmp376_);
								if (_tmp377_) {
									ValaHashMap* _tmp378_;
									gint _tmp379_;
									gint _tmp380_;
									ValaDataType* _tmp381_;
									ValaCCodeExpression* _tmp382_;
									ValaCCodeExpression* _tmp383_;
									_tmp378_ = in_arg_map;
									_tmp379_ = type_param_index;
									_tmp380_ = vala_ccode_base_module_get_param_pos (self, (-1 + (0.1 * _tmp379_)) + 0.03, FALSE);
									_tmp381_ = type_arg;
									_tmp382_ = vala_ccode_base_module_get_destroy0_func_expression (self, _tmp381_, FALSE);
									_tmp383_ = _tmp382_;
									vala_map_set ((ValaMap*) _tmp378_, (gpointer) ((gintptr) _tmp380_), _tmp383_);
									_vala_ccode_node_unref0 (_tmp383_);
								} else {
									ValaHashMap* _tmp384_;
									gint _tmp385_;
									gint _tmp386_;
									ValaCCodeConstant* _tmp387_;
									ValaCCodeConstant* _tmp388_;
									_tmp384_ = in_arg_map;
									_tmp385_ = type_param_index;
									_tmp386_ = vala_ccode_base_module_get_param_pos (self, (-1 + (0.1 * _tmp385_)) + 0.03, FALSE);
									_tmp387_ = vala_ccode_constant_new ("NULL");
									_tmp388_ = _tmp387_;
									vala_map_set ((ValaMap*) _tmp384_, (gpointer) ((gintptr) _tmp386_), (ValaCCodeExpression*) _tmp388_);
									_vala_ccode_node_unref0 (_tmp388_);
								}
								_tmp389_ = type_param_index;
								type_param_index = _tmp389_ + 1;
								_vala_code_node_unref0 (type_arg);
							}
							_vala_iterable_unref0 (_type_arg_list);
						}
					}
				}
				ellipsis = FALSE;
				i = 1;
				_tmp390_ = params;
				_tmp391_ = vala_iterable_iterator ((ValaIterable*) _tmp390_);
				params_it = _tmp391_;
				{
					ValaList* _arg_list = NULL;
					ValaObjectCreationExpression* _tmp392_;
					ValaList* _tmp393_;
					gint _arg_size = 0;
					ValaList* _tmp394_;
					gint _tmp395_;
					gint _tmp396_;
					gint _arg_index = 0;
					_tmp392_ = expr;
					_tmp393_ = vala_object_creation_expression_get_argument_list (_tmp392_);
					_arg_list = _tmp393_;
					_tmp394_ = _arg_list;
					_tmp395_ = vala_collection_get_size ((ValaCollection*) _tmp394_);
					_tmp396_ = _tmp395_;
					_arg_size = _tmp396_;
					_arg_index = -1;
					while (TRUE) {
						gint _tmp397_;
						gint _tmp398_;
						gint _tmp399_;
						ValaExpression* arg = NULL;
						ValaList* _tmp400_;
						gint _tmp401_;
						gpointer _tmp402_;
						ValaCCodeExpression* cexpr = NULL;
						ValaExpression* _tmp403_;
						ValaCCodeExpression* _tmp404_;
						ValaHashMap* carg_map = NULL;
						ValaHashMap* _tmp405_;
						ValaHashMap* _tmp406_;
						ValaParameter* param = NULL;
						ValaIterator* _tmp407_;
						gboolean _tmp408_;
						ValaHashMap* _tmp524_;
						gint _tmp525_;
						ValaCCodeExpression* _tmp526_;
						gint _tmp527_;
						_tmp397_ = _arg_index;
						_arg_index = _tmp397_ + 1;
						_tmp398_ = _arg_index;
						_tmp399_ = _arg_size;
						if (!(_tmp398_ < _tmp399_)) {
							break;
						}
						_tmp400_ = _arg_list;
						_tmp401_ = _arg_index;
						_tmp402_ = vala_list_get (_tmp400_, _tmp401_);
						arg = (ValaExpression*) _tmp402_;
						_tmp403_ = arg;
						_tmp404_ = vala_ccode_base_module_get_cvalue (self, _tmp403_);
						cexpr = _tmp404_;
						_tmp405_ = in_arg_map;
						_tmp406_ = _vala_map_ref0 (_tmp405_);
						carg_map = _tmp406_;
						param = NULL;
						_tmp407_ = params_it;
						_tmp408_ = vala_iterator_next (_tmp407_);
						if (_tmp408_) {
							ValaIterator* _tmp409_;
							gpointer _tmp410_;
							ValaParameter* _tmp411_;
							gboolean _tmp412_;
							gboolean _tmp413_;
							gboolean _tmp414_;
							ValaParameter* _tmp514_;
							gdouble _tmp515_;
							gboolean _tmp516_;
							gint _tmp517_;
							_tmp409_ = params_it;
							_tmp410_ = vala_iterator_get (_tmp409_);
							_vala_code_node_unref0 (param);
							param = (ValaParameter*) _tmp410_;
							_tmp411_ = param;
							_tmp412_ = vala_parameter_get_ellipsis (_tmp411_);
							_tmp413_ = _tmp412_;
							ellipsis = _tmp413_;
							_tmp414_ = ellipsis;
							if (!_tmp414_) {
								ValaParameter* _tmp415_;
								ValaParameterDirection _tmp416_;
								ValaParameterDirection _tmp417_;
								gboolean _tmp420_ = FALSE;
								ValaClass* _tmp421_;
								ValaTypeSymbol* _tmp422_;
								gboolean _tmp444_ = FALSE;
								ValaParameter* _tmp445_;
								gboolean _tmp446_;
								ValaParameter* _tmp498_;
								ValaExpression* _tmp499_;
								ValaCCodeExpression* _tmp500_;
								ValaCCodeExpression* _tmp501_;
								ValaParameter* _tmp502_;
								gchar* _tmp503_;
								gchar* _tmp504_;
								gboolean _tmp505_;
								_tmp415_ = param;
								_tmp416_ = vala_parameter_get_direction (_tmp415_);
								_tmp417_ = _tmp416_;
								if (_tmp417_ == VALA_PARAMETER_DIRECTION_OUT) {
									ValaHashMap* _tmp418_;
									ValaHashMap* _tmp419_;
									_tmp418_ = out_arg_map;
									_tmp419_ = _vala_map_ref0 (_tmp418_);
									_vala_map_unref0 (carg_map);
									carg_map = _tmp419_;
								}
								_tmp421_ = cl;
								_tmp422_ = self->garray_type;
								if (G_TYPE_CHECK_INSTANCE_CAST (_tmp421_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol) == _tmp422_) {
									ValaParameter* _tmp423_;
									const gchar* _tmp424_;
									const gchar* _tmp425_;
									_tmp423_ = param;
									_tmp424_ = vala_symbol_get_name ((ValaSymbol*) _tmp423_);
									_tmp425_ = _tmp424_;
									_tmp420_ = g_strcmp0 (_tmp425_, "element_size") == 0;
								} else {
									_tmp420_ = FALSE;
								}
								if (_tmp420_) {
									ValaCCodeFunctionCall* csizeof = NULL;
									ValaCCodeIdentifier* _tmp426_;
									ValaCCodeIdentifier* _tmp427_;
									ValaCCodeFunctionCall* _tmp428_;
									ValaCCodeFunctionCall* _tmp429_;
									ValaCCodeFunctionCall* _tmp430_;
									ValaObjectCreationExpression* _tmp431_;
									ValaDataType* _tmp432_;
									ValaDataType* _tmp433_;
									ValaList* _tmp434_;
									ValaList* _tmp435_;
									gpointer _tmp436_;
									ValaDataType* _tmp437_;
									gchar* _tmp438_;
									gchar* _tmp439_;
									ValaCCodeIdentifier* _tmp440_;
									ValaCCodeIdentifier* _tmp441_;
									ValaCCodeFunctionCall* _tmp442_;
									ValaCCodeExpression* _tmp443_;
									_tmp426_ = vala_ccode_identifier_new ("sizeof");
									_tmp427_ = _tmp426_;
									_tmp428_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp427_);
									_tmp429_ = _tmp428_;
									_vala_ccode_node_unref0 (_tmp427_);
									csizeof = _tmp429_;
									_tmp430_ = csizeof;
									_tmp431_ = expr;
									_tmp432_ = vala_object_creation_expression_get_type_reference (_tmp431_);
									_tmp433_ = _tmp432_;
									_tmp434_ = vala_data_type_get_type_arguments (_tmp433_);
									_tmp435_ = _tmp434_;
									_tmp436_ = vala_list_get (_tmp435_, 0);
									_tmp437_ = (ValaDataType*) _tmp436_;
									_tmp438_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp437_);
									_tmp439_ = _tmp438_;
									_tmp440_ = vala_ccode_identifier_new (_tmp439_);
									_tmp441_ = _tmp440_;
									vala_ccode_function_call_add_argument (_tmp430_, (ValaCCodeExpression*) _tmp441_);
									_vala_ccode_node_unref0 (_tmp441_);
									_g_free0 (_tmp439_);
									_vala_code_node_unref0 (_tmp437_);
									_vala_iterable_unref0 (_tmp435_);
									_tmp442_ = csizeof;
									_tmp443_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp442_);
									_vala_ccode_node_unref0 (cexpr);
									cexpr = _tmp443_;
									_vala_ccode_node_unref0 (csizeof);
								}
								_tmp445_ = param;
								_tmp446_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp445_);
								if (_tmp446_) {
									ValaParameter* _tmp447_;
									ValaDataType* _tmp448_;
									ValaDataType* _tmp449_;
									_tmp447_ = param;
									_tmp448_ = vala_variable_get_variable_type ((ValaVariable*) _tmp447_);
									_tmp449_ = _tmp448_;
									_tmp444_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp449_, VALA_TYPE_ARRAY_TYPE);
								} else {
									_tmp444_ = FALSE;
								}
								if (_tmp444_) {
									ValaArrayType* array_type = NULL;
									ValaParameter* _tmp450_;
									ValaDataType* _tmp451_;
									ValaDataType* _tmp452_;
									ValaArrayType* _tmp453_;
									_tmp450_ = param;
									_tmp451_ = vala_variable_get_variable_type ((ValaVariable*) _tmp450_);
									_tmp452_ = _tmp451_;
									_tmp453_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp452_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
									array_type = _tmp453_;
									{
										gint dim = 0;
										dim = 1;
										{
											gboolean _tmp454_ = FALSE;
											_tmp454_ = TRUE;
											while (TRUE) {
												gint _tmp456_;
												ValaArrayType* _tmp457_;
												gint _tmp458_;
												gint _tmp459_;
												ValaHashMap* _tmp460_;
												ValaParameter* _tmp461_;
												gdouble _tmp462_;
												gint _tmp463_;
												gint _tmp464_;
												ValaExpression* _tmp465_;
												gint _tmp466_;
												ValaCCodeExpression* _tmp467_;
												ValaCCodeExpression* _tmp468_;
												if (!_tmp454_) {
													gint _tmp455_;
													_tmp455_ = dim;
													dim = _tmp455_ + 1;
												}
												_tmp454_ = FALSE;
												_tmp456_ = dim;
												_tmp457_ = array_type;
												_tmp458_ = vala_array_type_get_rank (_tmp457_);
												_tmp459_ = _tmp458_;
												if (!(_tmp456_ <= _tmp459_)) {
													break;
												}
												_tmp460_ = carg_map;
												_tmp461_ = param;
												_tmp462_ = vala_ccode_base_module_get_ccode_array_length_pos ((ValaCodeNode*) _tmp461_);
												_tmp463_ = dim;
												_tmp464_ = vala_ccode_base_module_get_param_pos (self, _tmp462_ + (0.01 * _tmp463_), FALSE);
												_tmp465_ = arg;
												_tmp466_ = dim;
												_tmp467_ = vala_ccode_base_module_get_array_length_cexpression (self, _tmp465_, _tmp466_);
												_tmp468_ = _tmp467_;
												vala_map_set ((ValaMap*) _tmp460_, (gpointer) ((gintptr) _tmp464_), _tmp468_);
												_vala_ccode_node_unref0 (_tmp468_);
											}
										}
									}
									_vala_code_node_unref0 (array_type);
								} else {
									ValaParameter* _tmp469_;
									ValaDataType* _tmp470_;
									ValaDataType* _tmp471_;
									_tmp469_ = param;
									_tmp470_ = vala_variable_get_variable_type ((ValaVariable*) _tmp469_);
									_tmp471_ = _tmp470_;
									if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp471_, VALA_TYPE_DELEGATE_TYPE)) {
										ValaDelegateType* deleg_type = NULL;
										ValaParameter* _tmp472_;
										ValaDataType* _tmp473_;
										ValaDataType* _tmp474_;
										ValaDelegateType* _tmp475_;
										ValaDelegate* d = NULL;
										ValaDelegateType* _tmp476_;
										ValaDelegate* _tmp477_;
										ValaDelegate* _tmp478_;
										ValaDelegate* _tmp479_;
										ValaDelegate* _tmp480_;
										gboolean _tmp481_;
										gboolean _tmp482_;
										_tmp472_ = param;
										_tmp473_ = vala_variable_get_variable_type ((ValaVariable*) _tmp472_);
										_tmp474_ = _tmp473_;
										_tmp475_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp474_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
										deleg_type = _tmp475_;
										_tmp476_ = deleg_type;
										_tmp477_ = vala_delegate_type_get_delegate_symbol (_tmp476_);
										_tmp478_ = _tmp477_;
										_tmp479_ = _vala_code_node_ref0 (_tmp478_);
										d = _tmp479_;
										_tmp480_ = d;
										_tmp481_ = vala_delegate_get_has_target (_tmp480_);
										_tmp482_ = _tmp481_;
										if (_tmp482_) {
											ValaCCodeExpression* delegate_target_destroy_notify = NULL;
											ValaCCodeExpression* delegate_target = NULL;
											ValaExpression* _tmp483_;
											ValaCCodeExpression* _tmp484_ = NULL;
											ValaCCodeExpression* _tmp485_;
											ValaHashMap* _tmp486_;
											ValaParameter* _tmp487_;
											gdouble _tmp488_;
											gint _tmp489_;
											ValaCCodeExpression* _tmp490_;
											ValaDelegateType* _tmp491_;
											gboolean _tmp492_;
											_tmp483_ = arg;
											_tmp485_ = vala_ccode_base_module_get_delegate_target_cexpression (self, _tmp483_, &_tmp484_);
											_vala_ccode_node_unref0 (delegate_target_destroy_notify);
											delegate_target_destroy_notify = _tmp484_;
											delegate_target = _tmp485_;
											_tmp486_ = carg_map;
											_tmp487_ = param;
											_tmp488_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp487_);
											_tmp489_ = vala_ccode_base_module_get_param_pos (self, _tmp488_, FALSE);
											_tmp490_ = delegate_target;
											vala_map_set ((ValaMap*) _tmp486_, (gpointer) ((gintptr) _tmp489_), _tmp490_);
											_tmp491_ = deleg_type;
											_tmp492_ = vala_data_type_is_disposable ((ValaDataType*) _tmp491_);
											if (_tmp492_) {
												ValaHashMap* _tmp493_;
												ValaParameter* _tmp494_;
												gdouble _tmp495_;
												gint _tmp496_;
												ValaCCodeExpression* _tmp497_;
												_tmp493_ = carg_map;
												_tmp494_ = param;
												_tmp495_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp494_);
												_tmp496_ = vala_ccode_base_module_get_param_pos (self, _tmp495_ + 0.01, FALSE);
												_tmp497_ = delegate_target_destroy_notify;
												vala_map_set ((ValaMap*) _tmp493_, (gpointer) ((gintptr) _tmp496_), _tmp497_);
											}
											_vala_ccode_node_unref0 (delegate_target);
											_vala_ccode_node_unref0 (delegate_target_destroy_notify);
										}
										_vala_code_node_unref0 (d);
										_vala_code_node_unref0 (deleg_type);
									}
								}
								_tmp498_ = param;
								_tmp499_ = arg;
								_tmp500_ = cexpr;
								_tmp501_ = vala_ccode_base_module_handle_struct_argument (self, _tmp498_, _tmp499_, _tmp500_);
								_vala_ccode_node_unref0 (cexpr);
								cexpr = _tmp501_;
								_tmp502_ = param;
								_tmp503_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp502_);
								_tmp504_ = _tmp503_;
								_tmp505_ = _tmp504_ != NULL;
								_g_free0 (_tmp504_);
								if (_tmp505_) {
									ValaCCodeExpression* _tmp506_;
									ValaParameter* _tmp507_;
									gchar* _tmp508_;
									gchar* _tmp509_;
									ValaCCodeCastExpression* _tmp510_;
									_tmp506_ = cexpr;
									_tmp507_ = param;
									_tmp508_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp507_);
									_tmp509_ = _tmp508_;
									_tmp510_ = vala_ccode_cast_expression_new (_tmp506_, _tmp509_);
									_vala_ccode_node_unref0 (cexpr);
									cexpr = (ValaCCodeExpression*) _tmp510_;
									_g_free0 (_tmp509_);
								}
							} else {
								ValaExpression* _tmp511_;
								ValaCCodeExpression* _tmp512_;
								ValaCCodeExpression* _tmp513_;
								_tmp511_ = arg;
								_tmp512_ = cexpr;
								_tmp513_ = vala_ccode_base_module_handle_struct_argument (self, NULL, _tmp511_, _tmp512_);
								_vala_ccode_node_unref0 (cexpr);
								cexpr = _tmp513_;
							}
							_tmp514_ = param;
							_tmp515_ = vala_ccode_base_module_get_ccode_pos (_tmp514_);
							_tmp516_ = ellipsis;
							_tmp517_ = vala_ccode_base_module_get_param_pos (self, _tmp515_, _tmp516_);
							arg_pos = _tmp517_;
						} else {
							ValaExpression* _tmp518_;
							ValaCCodeExpression* _tmp519_;
							ValaCCodeExpression* _tmp520_;
							gint _tmp521_;
							gboolean _tmp522_;
							gint _tmp523_;
							_tmp518_ = arg;
							_tmp519_ = cexpr;
							_tmp520_ = vala_ccode_base_module_handle_struct_argument (self, NULL, _tmp518_, _tmp519_);
							_vala_ccode_node_unref0 (cexpr);
							cexpr = _tmp520_;
							_tmp521_ = i;
							_tmp522_ = ellipsis;
							_tmp523_ = vala_ccode_base_module_get_param_pos (self, (gdouble) _tmp521_, _tmp522_);
							arg_pos = _tmp523_;
						}
						_tmp524_ = carg_map;
						_tmp525_ = arg_pos;
						_tmp526_ = cexpr;
						vala_map_set ((ValaMap*) _tmp524_, (gpointer) ((gintptr) _tmp525_), _tmp526_);
						_tmp527_ = i;
						i = _tmp527_ + 1;
						_vala_code_node_unref0 (param);
						_vala_map_unref0 (carg_map);
						_vala_ccode_node_unref0 (cexpr);
						_vala_code_node_unref0 (arg);
					}
					_vala_iterable_unref0 (_arg_list);
				}
				_tmp528_ = params_it;
				_tmp529_ = vala_iterator_next (_tmp528_);
				if (_tmp529_) {
					ValaParameter* param = NULL;
					ValaIterator* _tmp530_;
					gpointer _tmp531_;
					gboolean _tmp532_ = FALSE;
					ValaParameter* _tmp533_;
					gboolean _tmp534_;
					gboolean _tmp535_;
					_tmp530_ = params_it;
					_tmp531_ = vala_iterator_get (_tmp530_);
					param = (ValaParameter*) _tmp531_;
					_tmp533_ = param;
					_tmp534_ = vala_parameter_get_params_array (_tmp533_);
					_tmp535_ = _tmp534_;
					if (_tmp535_) {
						_tmp532_ = TRUE;
					} else {
						ValaParameter* _tmp536_;
						gboolean _tmp537_;
						gboolean _tmp538_;
						_tmp536_ = param;
						_tmp537_ = vala_parameter_get_ellipsis (_tmp536_);
						_tmp538_ = _tmp537_;
						_tmp532_ = _tmp538_;
					}
					_vala_assert (_tmp532_, "param.params_array || param.ellipsis");
					ellipsis = TRUE;
					_vala_code_node_unref0 (param);
				}
				_tmp539_ = expr;
				_tmp540_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp539_);
				_tmp541_ = _tmp540_;
				if (_tmp541_) {
					ValaHashMap* _tmp542_;
					gint _tmp543_;
					ValaCCodeExpression* _tmp544_;
					ValaCCodeExpression* _tmp545_;
					ValaCCodeUnaryExpression* _tmp546_;
					ValaCCodeUnaryExpression* _tmp547_;
					vala_ccode_base_module_set_current_method_inner_error (self, TRUE);
					_tmp542_ = out_arg_map;
					_tmp543_ = vala_ccode_base_module_get_param_pos (self, (gdouble) -1, FALSE);
					_tmp544_ = vala_ccode_base_module_get_variable_cexpression (self, "_inner_error_");
					_tmp545_ = _tmp544_;
					_tmp546_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp545_);
					_tmp547_ = _tmp546_;
					vala_map_set ((ValaMap*) _tmp542_, (gpointer) ((gintptr) _tmp543_), (ValaCCodeExpression*) _tmp547_);
					_vala_ccode_node_unref0 (_tmp547_);
					_vala_ccode_node_unref0 (_tmp545_);
				}
				_tmp548_ = ellipsis;
				if (_tmp548_) {
					ValaMethod* _tmp549_;
					_tmp549_ = m;
					if (_tmp549_ == NULL) {
						ValaHashMap* _tmp550_;
						gint _tmp551_;
						ValaCCodeConstant* _tmp552_;
						ValaCCodeConstant* _tmp553_;
						_tmp550_ = in_arg_map;
						_tmp551_ = vala_ccode_base_module_get_param_pos (self, (gdouble) -1, TRUE);
						_tmp552_ = vala_ccode_constant_new ("NULL");
						_tmp553_ = _tmp552_;
						vala_map_set ((ValaMap*) _tmp550_, (gpointer) ((gintptr) _tmp551_), (ValaCCodeExpression*) _tmp553_);
						_vala_ccode_node_unref0 (_tmp553_);
					} else {
						gboolean _tmp554_ = FALSE;
						gboolean _tmp555_ = FALSE;
						ValaMethod* _tmp556_;
						gboolean _tmp557_;
						gboolean _tmp558_;
						_tmp556_ = m;
						_tmp557_ = vala_method_get_printf_format (_tmp556_);
						_tmp558_ = _tmp557_;
						if (!_tmp558_) {
							ValaMethod* _tmp559_;
							gboolean _tmp560_;
							gboolean _tmp561_;
							_tmp559_ = m;
							_tmp560_ = vala_method_get_scanf_format (_tmp559_);
							_tmp561_ = _tmp560_;
							_tmp555_ = !_tmp561_;
						} else {
							_tmp555_ = FALSE;
						}
						if (_tmp555_) {
							ValaMethod* _tmp562_;
							gchar* _tmp563_;
							gchar* _tmp564_;
							_tmp562_ = m;
							_tmp563_ = vala_ccode_base_module_get_ccode_sentinel (_tmp562_);
							_tmp564_ = _tmp563_;
							_tmp554_ = g_strcmp0 (_tmp564_, "") != 0;
							_g_free0 (_tmp564_);
						} else {
							_tmp554_ = FALSE;
						}
						if (_tmp554_) {
							ValaHashMap* _tmp565_;
							gint _tmp566_;
							ValaMethod* _tmp567_;
							gchar* _tmp568_;
							gchar* _tmp569_;
							ValaCCodeConstant* _tmp570_;
							ValaCCodeConstant* _tmp571_;
							_tmp565_ = in_arg_map;
							_tmp566_ = vala_ccode_base_module_get_param_pos (self, (gdouble) -1, TRUE);
							_tmp567_ = m;
							_tmp568_ = vala_ccode_base_module_get_ccode_sentinel (_tmp567_);
							_tmp569_ = _tmp568_;
							_tmp570_ = vala_ccode_constant_new (_tmp569_);
							_tmp571_ = _tmp570_;
							vala_map_set ((ValaMap*) _tmp565_, (gpointer) ((gintptr) _tmp566_), (ValaCCodeExpression*) _tmp571_);
							_vala_ccode_node_unref0 (_tmp571_);
							_g_free0 (_tmp569_);
						}
					}
				}
				_tmp574_ = st;
				if (_tmp574_ != NULL) {
					ValaStruct* _tmp575_;
					gboolean _tmp576_;
					_tmp575_ = st;
					_tmp576_ = vala_struct_is_simple_type (_tmp575_);
					_tmp573_ = !_tmp576_;
				} else {
					_tmp573_ = FALSE;
				}
				if (_tmp573_) {
					ValaMethod* _tmp577_;
					gdouble _tmp578_;
					_tmp577_ = m;
					_tmp578_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp577_);
					_tmp572_ = _tmp578_ < ((gdouble) 0);
				} else {
					_tmp572_ = FALSE;
				}
				if (_tmp572_) {
					ValaHashMap* _tmp579_;
					gint _tmp580_;
					ValaCCodeExpression* _tmp581_;
					ValaCCodeUnaryExpression* _tmp582_;
					ValaCCodeUnaryExpression* _tmp583_;
					_tmp579_ = out_arg_map;
					_tmp580_ = vala_ccode_base_module_get_param_pos (self, (gdouble) -3, FALSE);
					_tmp581_ = instance;
					_tmp582_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp581_);
					_tmp583_ = _tmp582_;
					vala_map_set ((ValaMap*) _tmp579_, (gpointer) ((gintptr) _tmp580_), (ValaCCodeExpression*) _tmp583_);
					_vala_ccode_node_unref0 (_tmp583_);
				}
				_tmp585_ = m;
				if (_tmp585_ != NULL) {
					ValaMethod* _tmp586_;
					gboolean _tmp587_;
					gboolean _tmp588_;
					_tmp586_ = m;
					_tmp587_ = vala_method_get_coroutine (_tmp586_);
					_tmp588_ = _tmp587_;
					_tmp584_ = _tmp588_;
				} else {
					_tmp584_ = FALSE;
				}
				if (_tmp584_) {
					ValaObjectCreationExpression* _tmp589_;
					gboolean _tmp590_;
					gboolean _tmp591_;
					_tmp589_ = expr;
					_tmp590_ = vala_object_creation_expression_get_is_yield_expression (_tmp589_);
					_tmp591_ = _tmp590_;
					if (_tmp591_) {
						ValaHashMap* _tmp592_;
						gint _tmp593_;
						ValaMethod* _tmp594_;
						ValaMethod* _tmp595_;
						gchar* _tmp596_;
						gchar* _tmp597_;
						ValaCCodeIdentifier* _tmp598_;
						ValaCCodeIdentifier* _tmp599_;
						ValaHashMap* _tmp600_;
						gint _tmp601_;
						ValaCCodeIdentifier* _tmp602_;
						ValaCCodeIdentifier* _tmp603_;
						_tmp592_ = in_arg_map;
						_tmp593_ = vala_ccode_base_module_get_param_pos (self, (gdouble) -1, FALSE);
						_tmp594_ = vala_ccode_base_module_get_current_method (self);
						_tmp595_ = _tmp594_;
						_tmp596_ = vala_ccode_base_module_generate_ready_function (self, _tmp595_);
						_tmp597_ = _tmp596_;
						_tmp598_ = vala_ccode_identifier_new (_tmp597_);
						_tmp599_ = _tmp598_;
						vala_map_set ((ValaMap*) _tmp592_, (gpointer) ((gintptr) _tmp593_), (ValaCCodeExpression*) _tmp599_);
						_vala_ccode_node_unref0 (_tmp599_);
						_g_free0 (_tmp597_);
						_tmp600_ = in_arg_map;
						_tmp601_ = vala_ccode_base_module_get_param_pos (self, -0.9, FALSE);
						_tmp602_ = vala_ccode_identifier_new ("_data_");
						_tmp603_ = _tmp602_;
						vala_map_set ((ValaMap*) _tmp600_, (gpointer) ((gintptr) _tmp601_), (ValaCCodeExpression*) _tmp603_);
						_vala_ccode_node_unref0 (_tmp603_);
					}
				}
				_tmp605_ = m;
				if (_tmp605_ != NULL) {
					ValaMethod* _tmp606_;
					ValaSymbol* _tmp607_;
					ValaSymbol* _tmp608_;
					_tmp606_ = m;
					_tmp607_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp606_);
					_tmp608_ = _tmp607_;
					_tmp604_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp608_, VALA_TYPE_CLASS);
				} else {
					_tmp604_ = FALSE;
				}
				if (_tmp604_) {
					ValaMethod* _tmp609_;
					gboolean _tmp610_;
					_tmp609_ = m;
					_tmp610_ = vala_ccode_base_module_get_ccode_finish_instance ((ValaCodeNode*) _tmp609_);
					if (_tmp610_) {
						ValaCCodeMemberAccess* tmp = NULL;
						ValaCCodeIdentifier* _tmp611_;
						ValaCCodeIdentifier* _tmp612_;
						ValaCCodeMemberAccess* _tmp613_;
						ValaCCodeMemberAccess* _tmp614_;
						ValaHashMap* _tmp615_;
						ValaMethod* _tmp616_;
						gdouble _tmp617_;
						gint _tmp618_;
						ValaCCodeMemberAccess* _tmp619_;
						_tmp611_ = vala_ccode_identifier_new ("_data_");
						_tmp612_ = _tmp611_;
						_tmp613_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp612_, "_source_object_");
						_tmp614_ = _tmp613_;
						_vala_ccode_node_unref0 (_tmp612_);
						tmp = _tmp614_;
						_tmp615_ = out_arg_map;
						_tmp616_ = m;
						_tmp617_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp616_);
						_tmp618_ = vala_ccode_base_module_get_param_pos (self, _tmp617_, FALSE);
						_tmp619_ = tmp;
						vala_map_set ((ValaMap*) _tmp615_, (gpointer) ((gintptr) _tmp618_), (ValaCCodeExpression*) _tmp619_);
						_vala_ccode_node_unref0 (tmp);
					}
				}
				_tmp620_ = async_call;
				_tmp621_ = creation_call;
				if (_tmp620_ != _tmp621_) {
					last_pos = -1;
					while (TRUE) {
						gint _tmp639_;
						ValaCCodeFunctionCall* _tmp640_;
						ValaHashMap* _tmp641_;
						gint _tmp642_;
						gpointer _tmp643_;
						ValaCCodeExpression* _tmp644_;
						gint _tmp645_;
						min_pos = -1;
						{
							ValaIterator* _pos_it = NULL;
							ValaHashMap* _tmp622_;
							ValaSet* _tmp623_;
							ValaSet* _tmp624_;
							ValaIterator* _tmp625_;
							ValaIterator* _tmp626_;
							_tmp622_ = out_arg_map;
							_tmp623_ = vala_map_get_keys ((ValaMap*) _tmp622_);
							_tmp624_ = _tmp623_;
							_tmp625_ = vala_iterable_iterator ((ValaIterable*) _tmp624_);
							_tmp626_ = _tmp625_;
							_vala_iterable_unref0 (_tmp624_);
							_pos_it = _tmp626_;
							while (TRUE) {
								ValaIterator* _tmp627_;
								gboolean _tmp628_;
								gint pos = 0;
								ValaIterator* _tmp629_;
								gpointer _tmp630_;
								gboolean _tmp631_ = FALSE;
								gint _tmp632_;
								gint _tmp633_;
								_tmp627_ = _pos_it;
								_tmp628_ = vala_iterator_next (_tmp627_);
								if (!_tmp628_) {
									break;
								}
								_tmp629_ = _pos_it;
								_tmp630_ = vala_iterator_get (_tmp629_);
								pos = (gint) ((gintptr) _tmp630_);
								_tmp632_ = pos;
								_tmp633_ = last_pos;
								if (_tmp632_ > _tmp633_) {
									gboolean _tmp634_ = FALSE;
									gint _tmp635_;
									_tmp635_ = min_pos;
									if (_tmp635_ == -1) {
										_tmp634_ = TRUE;
									} else {
										gint _tmp636_;
										gint _tmp637_;
										_tmp636_ = pos;
										_tmp637_ = min_pos;
										_tmp634_ = _tmp636_ < _tmp637_;
									}
									_tmp631_ = _tmp634_;
								} else {
									_tmp631_ = FALSE;
								}
								if (_tmp631_) {
									gint _tmp638_;
									_tmp638_ = pos;
									min_pos = _tmp638_;
								}
							}
							_vala_iterator_unref0 (_pos_it);
						}
						_tmp639_ = min_pos;
						if (_tmp639_ == -1) {
							break;
						}
						_tmp640_ = creation_call;
						_tmp641_ = out_arg_map;
						_tmp642_ = min_pos;
						_tmp643_ = vala_map_get ((ValaMap*) _tmp641_, (gpointer) ((gintptr) _tmp642_));
						_tmp644_ = (ValaCCodeExpression*) _tmp643_;
						vala_ccode_function_call_add_argument (_tmp640_, _tmp644_);
						_vala_ccode_node_unref0 (_tmp644_);
						_tmp645_ = min_pos;
						last_pos = _tmp645_;
					}
				}
				_tmp646_ = async_call;
				if (_tmp646_ != NULL) {
					last_pos = -1;
					while (TRUE) {
						gint _tmp664_;
						ValaCCodeFunctionCall* _tmp665_;
						ValaHashMap* _tmp666_;
						gint _tmp667_;
						gpointer _tmp668_;
						ValaCCodeExpression* _tmp669_;
						gint _tmp670_;
						min_pos = -1;
						{
							ValaIterator* _pos_it = NULL;
							ValaHashMap* _tmp647_;
							ValaSet* _tmp648_;
							ValaSet* _tmp649_;
							ValaIterator* _tmp650_;
							ValaIterator* _tmp651_;
							_tmp647_ = in_arg_map;
							_tmp648_ = vala_map_get_keys ((ValaMap*) _tmp647_);
							_tmp649_ = _tmp648_;
							_tmp650_ = vala_iterable_iterator ((ValaIterable*) _tmp649_);
							_tmp651_ = _tmp650_;
							_vala_iterable_unref0 (_tmp649_);
							_pos_it = _tmp651_;
							while (TRUE) {
								ValaIterator* _tmp652_;
								gboolean _tmp653_;
								gint pos = 0;
								ValaIterator* _tmp654_;
								gpointer _tmp655_;
								gboolean _tmp656_ = FALSE;
								gint _tmp657_;
								gint _tmp658_;
								_tmp652_ = _pos_it;
								_tmp653_ = vala_iterator_next (_tmp652_);
								if (!_tmp653_) {
									break;
								}
								_tmp654_ = _pos_it;
								_tmp655_ = vala_iterator_get (_tmp654_);
								pos = (gint) ((gintptr) _tmp655_);
								_tmp657_ = pos;
								_tmp658_ = last_pos;
								if (_tmp657_ > _tmp658_) {
									gboolean _tmp659_ = FALSE;
									gint _tmp660_;
									_tmp660_ = min_pos;
									if (_tmp660_ == -1) {
										_tmp659_ = TRUE;
									} else {
										gint _tmp661_;
										gint _tmp662_;
										_tmp661_ = pos;
										_tmp662_ = min_pos;
										_tmp659_ = _tmp661_ < _tmp662_;
									}
									_tmp656_ = _tmp659_;
								} else {
									_tmp656_ = FALSE;
								}
								if (_tmp656_) {
									gint _tmp663_;
									_tmp663_ = pos;
									min_pos = _tmp663_;
								}
							}
							_vala_iterator_unref0 (_pos_it);
						}
						_tmp664_ = min_pos;
						if (_tmp664_ == -1) {
							break;
						}
						_tmp665_ = async_call;
						_tmp666_ = in_arg_map;
						_tmp667_ = min_pos;
						_tmp668_ = vala_map_get ((ValaMap*) _tmp666_, (gpointer) ((gintptr) _tmp667_));
						_tmp669_ = (ValaCCodeExpression*) _tmp668_;
						vala_ccode_function_call_add_argument (_tmp665_, _tmp669_);
						_vala_ccode_node_unref0 (_tmp669_);
						_tmp670_ = min_pos;
						last_pos = _tmp670_;
					}
				}
				_tmp671_ = expr;
				_tmp672_ = vala_object_creation_expression_get_is_yield_expression (_tmp671_);
				_tmp673_ = _tmp672_;
				if (_tmp673_) {
					gint state = 0;
					ValaCCodeBaseModuleEmitContext* _tmp674_;
					gint _tmp675_;
					ValaCCodeFunction* _tmp676_;
					ValaCCodeFunction* _tmp677_;
					ValaCCodeIdentifier* _tmp678_;
					ValaCCodeIdentifier* _tmp679_;
					ValaCCodeMemberAccess* _tmp680_;
					ValaCCodeMemberAccess* _tmp681_;
					gint _tmp682_;
					gchar* _tmp683_;
					gchar* _tmp684_;
					ValaCCodeConstant* _tmp685_;
					ValaCCodeConstant* _tmp686_;
					ValaCCodeFunction* _tmp687_;
					ValaCCodeFunction* _tmp688_;
					ValaCCodeFunctionCall* _tmp689_;
					ValaCCodeFunction* _tmp690_;
					ValaCCodeFunction* _tmp691_;
					ValaCCodeConstant* _tmp692_;
					ValaCCodeConstant* _tmp693_;
					ValaCCodeFunction* _tmp694_;
					ValaCCodeFunction* _tmp695_;
					gint _tmp696_;
					gchar* _tmp697_;
					gchar* _tmp698_;
					_tmp674_ = self->emit_context;
					_tmp675_ = _tmp674_->next_coroutine_state;
					_tmp674_->next_coroutine_state = _tmp675_ + 1;
					state = _tmp675_;
					_tmp676_ = vala_ccode_base_module_get_ccode (self);
					_tmp677_ = _tmp676_;
					_tmp678_ = vala_ccode_identifier_new ("_data_");
					_tmp679_ = _tmp678_;
					_tmp680_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp679_, "_state_");
					_tmp681_ = _tmp680_;
					_tmp682_ = state;
					_tmp683_ = g_strdup_printf ("%i", _tmp682_);
					_tmp684_ = _tmp683_;
					_tmp685_ = vala_ccode_constant_new (_tmp684_);
					_tmp686_ = _tmp685_;
					vala_ccode_function_add_assignment (_tmp677_, (ValaCCodeExpression*) _tmp681_, (ValaCCodeExpression*) _tmp686_);
					_vala_ccode_node_unref0 (_tmp686_);
					_g_free0 (_tmp684_);
					_vala_ccode_node_unref0 (_tmp681_);
					_vala_ccode_node_unref0 (_tmp679_);
					_tmp687_ = vala_ccode_base_module_get_ccode (self);
					_tmp688_ = _tmp687_;
					_tmp689_ = async_call;
					vala_ccode_function_add_expression (_tmp688_, (ValaCCodeExpression*) _tmp689_);
					_tmp690_ = vala_ccode_base_module_get_ccode (self);
					_tmp691_ = _tmp690_;
					_tmp692_ = vala_ccode_constant_new ("FALSE");
					_tmp693_ = _tmp692_;
					vala_ccode_function_add_return (_tmp691_, (ValaCCodeExpression*) _tmp693_);
					_vala_ccode_node_unref0 (_tmp693_);
					_tmp694_ = vala_ccode_base_module_get_ccode (self);
					_tmp695_ = _tmp694_;
					_tmp696_ = state;
					_tmp697_ = g_strdup_printf ("_state_%d", _tmp696_);
					_tmp698_ = _tmp697_;
					vala_ccode_function_add_label (_tmp695_, _tmp698_);
					_g_free0 (_tmp698_);
				}
				_tmp699_ = creation_call;
				_tmp700_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp699_);
				_vala_ccode_node_unref0 (creation_expr);
				creation_expr = _tmp700_;
				_tmp701_ = m;
				_tmp702_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp701_);
				_tmp703_ = _tmp702_;
				_tmp704_ = _tmp703_ != NULL;
				_g_free0 (_tmp703_);
				if (_tmp704_) {
					ValaCCodeExpression* _tmp705_;
					ValaObjectCreationExpression* _tmp706_;
					ValaDataType* _tmp707_;
					ValaDataType* _tmp708_;
					gchar* _tmp709_;
					gchar* _tmp710_;
					ValaCCodeCastExpression* _tmp711_;
					_tmp705_ = creation_expr;
					_tmp706_ = expr;
					_tmp707_ = vala_object_creation_expression_get_type_reference (_tmp706_);
					_tmp708_ = _tmp707_;
					_tmp709_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp708_);
					_tmp710_ = _tmp709_;
					_tmp711_ = vala_ccode_cast_expression_new (_tmp705_, _tmp710_);
					_vala_ccode_node_unref0 (creation_expr);
					creation_expr = (ValaCCodeExpression*) _tmp711_;
					_g_free0 (_tmp710_);
				}
				_vala_iterator_unref0 (params_it);
				_vala_map_unref0 (out_arg_map);
				_vala_map_unref0 (in_arg_map);
				_vala_code_node_unref0 (cl);
				_vala_ccode_node_unref0 (finish_call);
				_vala_ccode_node_unref0 (async_call);
				_vala_ccode_node_unref0 (creation_call);
				_vala_iterable_unref0 (params);
				_vala_code_node_unref0 (m);
			} else {
				ValaObjectCreationExpression* _tmp712_;
				ValaSymbol* _tmp713_;
				ValaSymbol* _tmp714_;
				_tmp712_ = expr;
				_tmp713_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp712_);
				_tmp714_ = _tmp713_;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp714_, VALA_TYPE_ERROR_CODE)) {
					ValaErrorCode* ecode = NULL;
					ValaObjectCreationExpression* _tmp715_;
					ValaSymbol* _tmp716_;
					ValaSymbol* _tmp717_;
					ValaErrorCode* _tmp718_;
					ValaErrorDomain* edomain = NULL;
					ValaErrorCode* _tmp719_;
					ValaSymbol* _tmp720_;
					ValaSymbol* _tmp721_;
					ValaErrorDomain* _tmp722_;
					ValaCCodeFunctionCall* creation_call = NULL;
					ValaErrorDomain* _tmp723_;
					ValaCCodeFile* _tmp724_;
					ValaObjectCreationExpression* _tmp725_;
					ValaList* _tmp726_;
					ValaList* _tmp727_;
					gint _tmp728_;
					gint _tmp729_;
					gboolean _tmp730_;
					ValaCCodeFunctionCall* _tmp737_;
					ValaErrorDomain* _tmp738_;
					gchar* _tmp739_;
					gchar* _tmp740_;
					ValaCCodeIdentifier* _tmp741_;
					ValaCCodeIdentifier* _tmp742_;
					ValaCCodeFunctionCall* _tmp743_;
					ValaErrorCode* _tmp744_;
					gchar* _tmp745_;
					gchar* _tmp746_;
					ValaCCodeIdentifier* _tmp747_;
					ValaCCodeIdentifier* _tmp748_;
					ValaCCodeFunctionCall* _tmp764_;
					ValaCCodeExpression* _tmp765_;
					_tmp715_ = expr;
					_tmp716_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp715_);
					_tmp717_ = _tmp716_;
					_tmp718_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp717_, VALA_TYPE_ERROR_CODE, ValaErrorCode));
					ecode = _tmp718_;
					_tmp719_ = ecode;
					_tmp720_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp719_);
					_tmp721_ = _tmp720_;
					_tmp722_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp721_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain));
					edomain = _tmp722_;
					_tmp723_ = edomain;
					_tmp724_ = self->cfile;
					vala_ccode_base_module_generate_error_domain_declaration (self, _tmp723_, _tmp724_);
					_tmp725_ = expr;
					_tmp726_ = vala_object_creation_expression_get_argument_list (_tmp725_);
					_tmp727_ = _tmp726_;
					_tmp728_ = vala_collection_get_size ((ValaCollection*) _tmp727_);
					_tmp729_ = _tmp728_;
					_tmp730_ = _tmp729_ == 1;
					_vala_iterable_unref0 (_tmp727_);
					if (_tmp730_) {
						ValaCCodeIdentifier* _tmp731_;
						ValaCCodeIdentifier* _tmp732_;
						ValaCCodeFunctionCall* _tmp733_;
						_tmp731_ = vala_ccode_identifier_new ("g_error_new_literal");
						_tmp732_ = _tmp731_;
						_tmp733_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp732_);
						_vala_ccode_node_unref0 (creation_call);
						creation_call = _tmp733_;
						_vala_ccode_node_unref0 (_tmp732_);
					} else {
						ValaCCodeIdentifier* _tmp734_;
						ValaCCodeIdentifier* _tmp735_;
						ValaCCodeFunctionCall* _tmp736_;
						_tmp734_ = vala_ccode_identifier_new ("g_error_new");
						_tmp735_ = _tmp734_;
						_tmp736_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp735_);
						_vala_ccode_node_unref0 (creation_call);
						creation_call = _tmp736_;
						_vala_ccode_node_unref0 (_tmp735_);
					}
					_tmp737_ = creation_call;
					_tmp738_ = edomain;
					_tmp739_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp738_, NULL);
					_tmp740_ = _tmp739_;
					_tmp741_ = vala_ccode_identifier_new (_tmp740_);
					_tmp742_ = _tmp741_;
					vala_ccode_function_call_add_argument (_tmp737_, (ValaCCodeExpression*) _tmp742_);
					_vala_ccode_node_unref0 (_tmp742_);
					_g_free0 (_tmp740_);
					_tmp743_ = creation_call;
					_tmp744_ = ecode;
					_tmp745_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp744_);
					_tmp746_ = _tmp745_;
					_tmp747_ = vala_ccode_identifier_new (_tmp746_);
					_tmp748_ = _tmp747_;
					vala_ccode_function_call_add_argument (_tmp743_, (ValaCCodeExpression*) _tmp748_);
					_vala_ccode_node_unref0 (_tmp748_);
					_g_free0 (_tmp746_);
					{
						ValaList* _arg_list = NULL;
						ValaObjectCreationExpression* _tmp749_;
						ValaList* _tmp750_;
						gint _arg_size = 0;
						ValaList* _tmp751_;
						gint _tmp752_;
						gint _tmp753_;
						gint _arg_index = 0;
						_tmp749_ = expr;
						_tmp750_ = vala_object_creation_expression_get_argument_list (_tmp749_);
						_arg_list = _tmp750_;
						_tmp751_ = _arg_list;
						_tmp752_ = vala_collection_get_size ((ValaCollection*) _tmp751_);
						_tmp753_ = _tmp752_;
						_arg_size = _tmp753_;
						_arg_index = -1;
						while (TRUE) {
							gint _tmp754_;
							gint _tmp755_;
							gint _tmp756_;
							ValaExpression* arg = NULL;
							ValaList* _tmp757_;
							gint _tmp758_;
							gpointer _tmp759_;
							ValaCCodeFunctionCall* _tmp760_;
							ValaExpression* _tmp761_;
							ValaCCodeExpression* _tmp762_;
							ValaCCodeExpression* _tmp763_;
							_tmp754_ = _arg_index;
							_arg_index = _tmp754_ + 1;
							_tmp755_ = _arg_index;
							_tmp756_ = _arg_size;
							if (!(_tmp755_ < _tmp756_)) {
								break;
							}
							_tmp757_ = _arg_list;
							_tmp758_ = _arg_index;
							_tmp759_ = vala_list_get (_tmp757_, _tmp758_);
							arg = (ValaExpression*) _tmp759_;
							_tmp760_ = creation_call;
							_tmp761_ = arg;
							_tmp762_ = vala_ccode_base_module_get_cvalue (self, _tmp761_);
							_tmp763_ = _tmp762_;
							vala_ccode_function_call_add_argument (_tmp760_, _tmp763_);
							_vala_ccode_node_unref0 (_tmp763_);
							_vala_code_node_unref0 (arg);
						}
						_vala_iterable_unref0 (_arg_list);
					}
					_tmp764_ = creation_call;
					_tmp765_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp764_);
					_vala_ccode_node_unref0 (creation_expr);
					creation_expr = _tmp765_;
					_vala_ccode_node_unref0 (creation_call);
					_vala_code_node_unref0 (edomain);
					_vala_code_node_unref0 (ecode);
				} else {
					_vala_assert (FALSE, "false");
				}
			}
		}
	}
	_tmp766_ = expr;
	_tmp767_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp766_);
	_tmp768_ = _tmp767_;
	_tmp769_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp768_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp768_) : NULL);
	local = _tmp769_;
	_tmp771_ = local;
	if (_tmp771_ != NULL) {
		ValaLocalVariable* _tmp772_;
		ValaLocalVariable* _tmp773_;
		ValaExpression* _tmp774_;
		ValaExpression* _tmp775_;
		gboolean _tmp776_;
		_tmp772_ = local;
		_tmp773_ = local;
		_tmp774_ = vala_variable_get_initializer ((ValaVariable*) _tmp773_);
		_tmp775_ = _tmp774_;
		_tmp776_ = vala_ccode_base_module_is_simple_struct_creation (self, (ValaVariable*) _tmp772_, _tmp775_);
		_tmp770_ = _tmp776_;
	} else {
		_tmp770_ = FALSE;
	}
	if (_tmp770_) {
		ValaCCodeFunction* _tmp777_;
		ValaCCodeFunction* _tmp778_;
		ValaCCodeExpression* _tmp779_;
		ValaObjectCreationExpression* _tmp780_;
		ValaCCodeExpression* _tmp781_;
		_tmp777_ = vala_ccode_base_module_get_ccode (self);
		_tmp778_ = _tmp777_;
		_tmp779_ = creation_expr;
		vala_ccode_function_add_expression (_tmp778_, _tmp779_);
		_tmp780_ = expr;
		_tmp781_ = instance;
		vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp780_, _tmp781_);
	} else {
		ValaCCodeExpression* _tmp782_;
		_tmp782_ = instance;
		if (_tmp782_ != NULL) {
			ValaObjectCreationExpression* _tmp783_;
			ValaDataType* _tmp784_;
			ValaDataType* _tmp785_;
			ValaTypeSymbol* _tmp786_;
			ValaTypeSymbol* _tmp787_;
			ValaObjectCreationExpression* _tmp877_;
			ValaCCodeExpression* _tmp878_;
			_tmp783_ = expr;
			_tmp784_ = vala_object_creation_expression_get_type_reference (_tmp783_);
			_tmp785_ = _tmp784_;
			_tmp786_ = vala_data_type_get_data_type (_tmp785_);
			_tmp787_ = _tmp786_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp787_, VALA_TYPE_STRUCT)) {
				ValaCCodeFunction* _tmp788_;
				ValaCCodeFunction* _tmp789_;
				ValaCCodeExpression* _tmp790_;
				_tmp788_ = vala_ccode_base_module_get_ccode (self);
				_tmp789_ = _tmp788_;
				_tmp790_ = creation_expr;
				vala_ccode_function_add_expression (_tmp789_, _tmp790_);
			} else {
				ValaCCodeFunction* _tmp791_;
				ValaCCodeFunction* _tmp792_;
				ValaCCodeExpression* _tmp793_;
				ValaCCodeExpression* _tmp794_;
				_tmp791_ = vala_ccode_base_module_get_ccode (self);
				_tmp792_ = _tmp791_;
				_tmp793_ = instance;
				_tmp794_ = creation_expr;
				vala_ccode_function_add_assignment (_tmp792_, _tmp793_, _tmp794_);
			}
			{
				ValaList* _init_list = NULL;
				ValaObjectCreationExpression* _tmp795_;
				ValaList* _tmp796_;
				gint _init_size = 0;
				ValaList* _tmp797_;
				gint _tmp798_;
				gint _tmp799_;
				gint _init_index = 0;
				_tmp795_ = expr;
				_tmp796_ = vala_object_creation_expression_get_object_initializer (_tmp795_);
				_init_list = _tmp796_;
				_tmp797_ = _init_list;
				_tmp798_ = vala_collection_get_size ((ValaCollection*) _tmp797_);
				_tmp799_ = _tmp798_;
				_init_size = _tmp799_;
				_init_index = -1;
				while (TRUE) {
					gint _tmp800_;
					gint _tmp801_;
					gint _tmp802_;
					ValaMemberInitializer* init = NULL;
					ValaList* _tmp803_;
					gint _tmp804_;
					gpointer _tmp805_;
					ValaMemberInitializer* _tmp806_;
					ValaSymbol* _tmp807_;
					ValaSymbol* _tmp808_;
					_tmp800_ = _init_index;
					_init_index = _tmp800_ + 1;
					_tmp801_ = _init_index;
					_tmp802_ = _init_size;
					if (!(_tmp801_ < _tmp802_)) {
						break;
					}
					_tmp803_ = _init_list;
					_tmp804_ = _init_index;
					_tmp805_ = vala_list_get (_tmp803_, _tmp804_);
					init = (ValaMemberInitializer*) _tmp805_;
					_tmp806_ = init;
					_tmp807_ = vala_member_initializer_get_symbol_reference (_tmp806_);
					_tmp808_ = _tmp807_;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp808_, VALA_TYPE_FIELD)) {
						ValaField* f = NULL;
						ValaMemberInitializer* _tmp809_;
						ValaSymbol* _tmp810_;
						ValaSymbol* _tmp811_;
						ValaField* _tmp812_;
						ValaDataType* instance_target_type = NULL;
						ValaField* _tmp813_;
						ValaSymbol* _tmp814_;
						ValaSymbol* _tmp815_;
						ValaDataType* _tmp816_;
						ValaTargetValue* typed_inst = NULL;
						ValaObjectCreationExpression* _tmp817_;
						ValaDataType* _tmp818_;
						ValaDataType* _tmp819_;
						ValaCCodeExpression* _tmp820_;
						ValaGLibValue* _tmp821_;
						ValaGLibValue* _tmp822_;
						ValaDataType* _tmp823_;
						ValaMemberInitializer* _tmp824_;
						ValaTargetValue* _tmp825_;
						ValaTargetValue* _tmp826_;
						ValaField* _tmp827_;
						ValaTargetValue* _tmp828_;
						ValaMemberInitializer* _tmp829_;
						ValaExpression* _tmp830_;
						ValaExpression* _tmp831_;
						ValaTargetValue* _tmp832_;
						ValaTargetValue* _tmp833_;
						ValaClass* cl = NULL;
						ValaField* _tmp834_;
						ValaSymbol* _tmp835_;
						ValaSymbol* _tmp836_;
						ValaClass* _tmp837_;
						ValaClass* _tmp838_;
						_tmp809_ = init;
						_tmp810_ = vala_member_initializer_get_symbol_reference (_tmp809_);
						_tmp811_ = _tmp810_;
						_tmp812_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp811_, VALA_TYPE_FIELD, ValaField));
						f = _tmp812_;
						_tmp813_ = f;
						_tmp814_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp813_);
						_tmp815_ = _tmp814_;
						_tmp816_ = vala_ccode_base_module_get_data_type_for_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp815_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
						instance_target_type = _tmp816_;
						_tmp817_ = expr;
						_tmp818_ = vala_object_creation_expression_get_type_reference (_tmp817_);
						_tmp819_ = _tmp818_;
						_tmp820_ = instance;
						_tmp821_ = vala_glib_value_new (_tmp819_, _tmp820_, TRUE);
						_tmp822_ = _tmp821_;
						_tmp823_ = instance_target_type;
						_tmp824_ = init;
						_tmp825_ = vala_ccode_base_module_transform_value (self, (ValaTargetValue*) _tmp822_, _tmp823_, (ValaCodeNode*) _tmp824_);
						_tmp826_ = _tmp825_;
						_vala_target_value_unref0 (_tmp822_);
						typed_inst = _tmp826_;
						_tmp827_ = f;
						_tmp828_ = typed_inst;
						_tmp829_ = init;
						_tmp830_ = vala_member_initializer_get_initializer (_tmp829_);
						_tmp831_ = _tmp830_;
						_tmp832_ = vala_expression_get_target_value (_tmp831_);
						_tmp833_ = _tmp832_;
						vala_code_generator_store_field ((ValaCodeGenerator*) self, _tmp827_, _tmp828_, _tmp833_);
						_tmp834_ = f;
						_tmp835_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp834_);
						_tmp836_ = _tmp835_;
						_tmp837_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp836_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp836_) : NULL);
						cl = _tmp837_;
						_tmp838_ = cl;
						if (_tmp838_ != NULL) {
							ValaClass* _tmp839_;
							ValaCCodeFile* _tmp840_;
							_tmp839_ = cl;
							_tmp840_ = self->cfile;
							vala_ccode_base_module_generate_class_struct_declaration (self, _tmp839_, _tmp840_);
						}
						_vala_code_node_unref0 (cl);
						_vala_target_value_unref0 (typed_inst);
						_vala_code_node_unref0 (instance_target_type);
						_vala_code_node_unref0 (f);
					} else {
						ValaMemberInitializer* _tmp841_;
						ValaSymbol* _tmp842_;
						ValaSymbol* _tmp843_;
						_tmp841_ = init;
						_tmp842_ = vala_member_initializer_get_symbol_reference (_tmp841_);
						_tmp843_ = _tmp842_;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp843_, VALA_TYPE_PROPERTY)) {
							ValaMemberAccess* inst_ma = NULL;
							ValaMemberAccess* _tmp844_;
							ValaMemberAccess* _tmp845_;
							ValaObjectCreationExpression* _tmp846_;
							ValaDataType* _tmp847_;
							ValaDataType* _tmp848_;
							ValaMemberAccess* _tmp849_;
							ValaCCodeExpression* _tmp850_;
							ValaMemberInitializer* _tmp851_;
							ValaSymbol* _tmp852_;
							ValaSymbol* _tmp853_;
							ValaMemberAccess* _tmp854_;
							ValaMemberInitializer* _tmp855_;
							ValaExpression* _tmp856_;
							ValaExpression* _tmp857_;
							ValaTargetValue* _tmp858_;
							ValaTargetValue* _tmp859_;
							ValaMemberInitializer* _tmp860_;
							ValaExpression* _tmp861_;
							ValaExpression* _tmp862_;
							ValaTargetValue* _tmp863_;
							ValaTargetValue* _tmp864_;
							ValaDataType* _tmp865_;
							ValaDataType* _tmp866_;
							gboolean _tmp867_;
							_tmp844_ = vala_member_access_new_simple ("new", NULL);
							inst_ma = _tmp844_;
							_tmp845_ = inst_ma;
							_tmp846_ = expr;
							_tmp847_ = vala_object_creation_expression_get_type_reference (_tmp846_);
							_tmp848_ = _tmp847_;
							vala_expression_set_value_type ((ValaExpression*) _tmp845_, _tmp848_);
							_tmp849_ = inst_ma;
							_tmp850_ = instance;
							vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp849_, _tmp850_);
							_tmp851_ = init;
							_tmp852_ = vala_member_initializer_get_symbol_reference (_tmp851_);
							_tmp853_ = _tmp852_;
							_tmp854_ = inst_ma;
							_tmp855_ = init;
							_tmp856_ = vala_member_initializer_get_initializer (_tmp855_);
							_tmp857_ = _tmp856_;
							_tmp858_ = vala_expression_get_target_value (_tmp857_);
							_tmp859_ = _tmp858_;
							vala_ccode_base_module_store_property (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp853_, VALA_TYPE_PROPERTY, ValaProperty), (ValaExpression*) _tmp854_, _tmp859_);
							_tmp860_ = init;
							_tmp861_ = vala_member_initializer_get_initializer (_tmp860_);
							_tmp862_ = _tmp861_;
							_tmp863_ = vala_expression_get_target_value (_tmp862_);
							_tmp864_ = _tmp863_;
							_tmp865_ = vala_target_value_get_value_type (_tmp864_);
							_tmp866_ = _tmp865_;
							_tmp867_ = vala_ccode_base_module_requires_destroy (self, _tmp866_);
							if (_tmp867_) {
								ValaCCodeFunction* _tmp868_;
								ValaCCodeFunction* _tmp869_;
								ValaMemberInitializer* _tmp870_;
								ValaExpression* _tmp871_;
								ValaExpression* _tmp872_;
								ValaTargetValue* _tmp873_;
								ValaTargetValue* _tmp874_;
								ValaCCodeExpression* _tmp875_;
								ValaCCodeExpression* _tmp876_;
								_tmp868_ = vala_ccode_base_module_get_ccode (self);
								_tmp869_ = _tmp868_;
								_tmp870_ = init;
								_tmp871_ = vala_member_initializer_get_initializer (_tmp870_);
								_tmp872_ = _tmp871_;
								_tmp873_ = vala_expression_get_target_value (_tmp872_);
								_tmp874_ = _tmp873_;
								_tmp875_ = vala_ccode_base_module_destroy_value (self, _tmp874_, FALSE);
								_tmp876_ = _tmp875_;
								vala_ccode_function_add_expression (_tmp869_, _tmp876_);
								_vala_ccode_node_unref0 (_tmp876_);
							}
							_vala_code_node_unref0 (inst_ma);
						}
					}
					_vala_code_node_unref0 (init);
				}
				_vala_iterable_unref0 (_init_list);
			}
			_tmp877_ = expr;
			_tmp878_ = instance;
			vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp877_, _tmp878_);
		} else {
			ValaCCodeExpression* _tmp879_;
			_tmp879_ = creation_expr;
			if (_tmp879_ != NULL) {
				ValaTargetValue* temp_value = NULL;
				ValaObjectCreationExpression* _tmp880_;
				ValaDataType* _tmp881_;
				ValaDataType* _tmp882_;
				ValaObjectCreationExpression* _tmp883_;
				ValaTargetValue* _tmp884_;
				ValaCCodeFunction* _tmp885_;
				ValaCCodeFunction* _tmp886_;
				ValaTargetValue* _tmp887_;
				ValaCCodeExpression* _tmp888_;
				ValaCCodeExpression* _tmp889_;
				ValaCCodeExpression* _tmp890_;
				ValaObjectCreationExpression* _tmp891_;
				ValaTargetValue* _tmp892_;
				ValaCodeContext* _tmp893_;
				gboolean _tmp894_;
				gboolean _tmp895_;
				_tmp880_ = expr;
				_tmp881_ = vala_expression_get_value_type ((ValaExpression*) _tmp880_);
				_tmp882_ = _tmp881_;
				_tmp883_ = expr;
				_tmp884_ = vala_ccode_base_module_create_temp_value (self, _tmp882_, FALSE, (ValaCodeNode*) _tmp883_, NULL);
				temp_value = _tmp884_;
				_tmp885_ = vala_ccode_base_module_get_ccode (self);
				_tmp886_ = _tmp885_;
				_tmp887_ = temp_value;
				_tmp888_ = vala_ccode_base_module_get_cvalue_ (self, _tmp887_);
				_tmp889_ = _tmp888_;
				_tmp890_ = creation_expr;
				vala_ccode_function_add_assignment (_tmp886_, _tmp889_, _tmp890_);
				_vala_ccode_node_unref0 (_tmp889_);
				_tmp891_ = expr;
				_tmp892_ = temp_value;
				vala_expression_set_target_value ((ValaExpression*) _tmp891_, _tmp892_);
				_tmp893_ = self->priv->_context;
				_tmp894_ = vala_code_context_get_gobject_tracing (_tmp893_);
				_tmp895_ = _tmp894_;
				if (_tmp895_) {
					ValaClass* cl = NULL;
					ValaObjectCreationExpression* _tmp896_;
					ValaDataType* _tmp897_;
					ValaDataType* _tmp898_;
					ValaTypeSymbol* _tmp899_;
					ValaTypeSymbol* _tmp900_;
					ValaClass* _tmp901_;
					gboolean _tmp902_ = FALSE;
					ValaClass* _tmp903_;
					_tmp896_ = expr;
					_tmp897_ = vala_object_creation_expression_get_type_reference (_tmp896_);
					_tmp898_ = _tmp897_;
					_tmp899_ = vala_data_type_get_data_type (_tmp898_);
					_tmp900_ = _tmp899_;
					_tmp901_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp900_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp900_) : NULL);
					cl = _tmp901_;
					_tmp903_ = cl;
					if (_tmp903_ != NULL) {
						ValaClass* _tmp904_;
						ValaTypeSymbol* _tmp905_;
						gboolean _tmp906_;
						_tmp904_ = cl;
						_tmp905_ = self->gobject_type;
						_tmp906_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp904_, _tmp905_);
						_tmp902_ = _tmp906_;
					} else {
						_tmp902_ = FALSE;
					}
					if (_tmp902_) {
						ValaCCodeFunction* _tmp907_;
						ValaCCodeFunction* _tmp908_;
						ValaObjectCreationExpression* _tmp909_;
						ValaTargetValue* _tmp910_;
						ValaTargetValue* _tmp911_;
						ValaCCodeExpression* _tmp912_;
						ValaCCodeExpression* _tmp913_;
						ValaCCodeFunctionCall* set_data_call = NULL;
						ValaCCodeIdentifier* _tmp914_;
						ValaCCodeIdentifier* _tmp915_;
						ValaCCodeFunctionCall* _tmp916_;
						ValaCCodeFunctionCall* _tmp917_;
						ValaCCodeFunctionCall* _tmp918_;
						ValaObjectCreationExpression* _tmp919_;
						ValaTargetValue* _tmp920_;
						ValaTargetValue* _tmp921_;
						ValaCCodeExpression* _tmp922_;
						ValaCCodeExpression* _tmp923_;
						ValaCCodeCastExpression* _tmp924_;
						ValaCCodeCastExpression* _tmp925_;
						ValaCCodeFunctionCall* _tmp926_;
						ValaCCodeConstant* _tmp927_;
						ValaCCodeConstant* _tmp928_;
						gchar* func_name = NULL;
						gchar* _tmp929_;
						ValaMethod* _tmp930_;
						ValaMethod* _tmp931_;
						ValaCCodeFunctionCall* _tmp940_;
						const gchar* _tmp941_;
						gchar* _tmp942_;
						gchar* _tmp943_;
						ValaCCodeConstant* _tmp944_;
						ValaCCodeConstant* _tmp945_;
						ValaCCodeFunction* _tmp946_;
						ValaCCodeFunction* _tmp947_;
						ValaCCodeFunctionCall* _tmp948_;
						ValaCCodeFunction* _tmp949_;
						ValaCCodeFunction* _tmp950_;
						_tmp907_ = vala_ccode_base_module_get_ccode (self);
						_tmp908_ = _tmp907_;
						_tmp909_ = expr;
						_tmp910_ = vala_expression_get_target_value ((ValaExpression*) _tmp909_);
						_tmp911_ = _tmp910_;
						_tmp912_ = vala_ccode_base_module_get_cvalue_ (self, _tmp911_);
						_tmp913_ = _tmp912_;
						vala_ccode_function_open_if (_tmp908_, _tmp913_);
						_vala_ccode_node_unref0 (_tmp913_);
						_tmp914_ = vala_ccode_identifier_new ("g_object_set_data");
						_tmp915_ = _tmp914_;
						_tmp916_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp915_);
						_tmp917_ = _tmp916_;
						_vala_ccode_node_unref0 (_tmp915_);
						set_data_call = _tmp917_;
						_tmp918_ = set_data_call;
						_tmp919_ = expr;
						_tmp920_ = vala_expression_get_target_value ((ValaExpression*) _tmp919_);
						_tmp921_ = _tmp920_;
						_tmp922_ = vala_ccode_base_module_get_cvalue_ (self, _tmp921_);
						_tmp923_ = _tmp922_;
						_tmp924_ = vala_ccode_cast_expression_new (_tmp923_, "GObject *");
						_tmp925_ = _tmp924_;
						vala_ccode_function_call_add_argument (_tmp918_, (ValaCCodeExpression*) _tmp925_);
						_vala_ccode_node_unref0 (_tmp925_);
						_vala_ccode_node_unref0 (_tmp923_);
						_tmp926_ = set_data_call;
						_tmp927_ = vala_ccode_constant_new ("\"vala-creation-function\"");
						_tmp928_ = _tmp927_;
						vala_ccode_function_call_add_argument (_tmp926_, (ValaCCodeExpression*) _tmp928_);
						_vala_ccode_node_unref0 (_tmp928_);
						_tmp929_ = g_strdup ("");
						func_name = _tmp929_;
						_tmp930_ = vala_ccode_base_module_get_current_method (self);
						_tmp931_ = _tmp930_;
						if (_tmp931_ != NULL) {
							ValaMethod* _tmp932_;
							ValaMethod* _tmp933_;
							gchar* _tmp934_;
							_tmp932_ = vala_ccode_base_module_get_current_method (self);
							_tmp933_ = _tmp932_;
							_tmp934_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp933_);
							_g_free0 (func_name);
							func_name = _tmp934_;
						} else {
							ValaPropertyAccessor* _tmp935_;
							ValaPropertyAccessor* _tmp936_;
							_tmp935_ = vala_ccode_base_module_get_current_property_accessor (self);
							_tmp936_ = _tmp935_;
							if (_tmp936_ != NULL) {
								ValaPropertyAccessor* _tmp937_;
								ValaPropertyAccessor* _tmp938_;
								gchar* _tmp939_;
								_tmp937_ = vala_ccode_base_module_get_current_property_accessor (self);
								_tmp938_ = _tmp937_;
								_tmp939_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp938_);
								_g_free0 (func_name);
								func_name = _tmp939_;
							}
						}
						_tmp940_ = set_data_call;
						_tmp941_ = func_name;
						_tmp942_ = g_strdup_printf ("\"%s\"", _tmp941_);
						_tmp943_ = _tmp942_;
						_tmp944_ = vala_ccode_constant_new (_tmp943_);
						_tmp945_ = _tmp944_;
						vala_ccode_function_call_add_argument (_tmp940_, (ValaCCodeExpression*) _tmp945_);
						_vala_ccode_node_unref0 (_tmp945_);
						_g_free0 (_tmp943_);
						_tmp946_ = vala_ccode_base_module_get_ccode (self);
						_tmp947_ = _tmp946_;
						_tmp948_ = set_data_call;
						vala_ccode_function_add_expression (_tmp947_, (ValaCCodeExpression*) _tmp948_);
						_tmp949_ = vala_ccode_base_module_get_ccode (self);
						_tmp950_ = _tmp949_;
						vala_ccode_function_close (_tmp950_);
						_g_free0 (func_name);
						_vala_ccode_node_unref0 (set_data_call);
					}
					_vala_code_node_unref0 (cl);
				}
				_vala_target_value_unref0 (temp_value);
			}
		}
	}
	_tmp951_ = expr;
	_tmp952_ = vala_expression_get_target_value ((ValaExpression*) _tmp951_);
	_tmp953_ = _tmp952_;
	G_TYPE_CHECK_INSTANCE_CAST (_tmp953_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE;
	_vala_code_node_unref0 (local);
	_vala_code_node_unref0 (st);
	_vala_ccode_node_unref0 (creation_expr);
	_vala_ccode_node_unref0 (instance);
}


ValaCCodeExpression* vala_ccode_base_module_handle_struct_argument (ValaCCodeBaseModule* self, ValaParameter* param, ValaExpression* arg, ValaCCodeExpression* cexpr) {
	ValaCCodeExpression* result = NULL;
	ValaDataType* type = NULL;
	ValaParameter* _tmp0_;
	ValaUnaryExpression* unary = NULL;
	ValaExpression* _tmp9_;
	ValaUnaryExpression* _tmp10_;
	gboolean _tmp11_ = FALSE;
	ValaExpression* _tmp12_;
	ValaDataType* _tmp13_;
	ValaDataType* _tmp14_;
	ValaCCodeExpression* _tmp49_;
	ValaCCodeExpression* _tmp50_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (arg != NULL, NULL);
	_tmp0_ = param;
	if (_tmp0_ != NULL) {
		ValaParameter* _tmp1_;
		ValaDataType* _tmp2_;
		ValaDataType* _tmp3_;
		ValaDataType* _tmp4_;
		_tmp1_ = param;
		_tmp2_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1_);
		_tmp3_ = _tmp2_;
		_tmp4_ = _vala_code_node_ref0 (_tmp3_);
		_vala_code_node_unref0 (type);
		type = _tmp4_;
	} else {
		ValaExpression* _tmp5_;
		ValaDataType* _tmp6_;
		ValaDataType* _tmp7_;
		ValaDataType* _tmp8_;
		_tmp5_ = arg;
		_tmp6_ = vala_expression_get_value_type (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = _vala_code_node_ref0 (_tmp7_);
		_vala_code_node_unref0 (type);
		type = _tmp8_;
	}
	_tmp9_ = arg;
	_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_UNARY_EXPRESSION) ? ((ValaUnaryExpression*) _tmp9_) : NULL);
	unary = _tmp10_;
	_tmp12_ = arg;
	_tmp13_ = vala_expression_get_value_type (_tmp12_);
	_tmp14_ = _tmp13_;
	if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp14_, VALA_TYPE_NULL_TYPE)) {
		ValaDataType* _tmp15_;
		gboolean _tmp16_;
		_tmp15_ = type;
		_tmp16_ = vala_data_type_is_real_struct_type (_tmp15_);
		_tmp11_ = _tmp16_;
	} else {
		_tmp11_ = FALSE;
	}
	if (_tmp11_) {
		gboolean _tmp17_ = FALSE;
		gboolean _tmp18_ = FALSE;
		ValaUnaryExpression* _tmp19_;
		_tmp19_ = unary;
		if (_tmp19_ != NULL) {
			gboolean _tmp20_ = FALSE;
			ValaUnaryExpression* _tmp21_;
			ValaUnaryOperator _tmp22_;
			ValaUnaryOperator _tmp23_;
			_tmp21_ = unary;
			_tmp22_ = vala_unary_expression_get_operator (_tmp21_);
			_tmp23_ = _tmp22_;
			if (_tmp23_ == VALA_UNARY_OPERATOR_OUT) {
				_tmp20_ = TRUE;
			} else {
				ValaUnaryExpression* _tmp24_;
				ValaUnaryOperator _tmp25_;
				ValaUnaryOperator _tmp26_;
				_tmp24_ = unary;
				_tmp25_ = vala_unary_expression_get_operator (_tmp24_);
				_tmp26_ = _tmp25_;
				_tmp20_ = _tmp26_ == VALA_UNARY_OPERATOR_REF;
			}
			_tmp18_ = _tmp20_;
		} else {
			_tmp18_ = FALSE;
		}
		if (!_tmp18_) {
			ValaDataType* _tmp27_;
			gboolean _tmp28_;
			gboolean _tmp29_;
			_tmp27_ = type;
			_tmp28_ = vala_data_type_get_nullable (_tmp27_);
			_tmp29_ = _tmp28_;
			_tmp17_ = !_tmp29_;
		} else {
			_tmp17_ = FALSE;
		}
		if (_tmp17_) {
			gboolean _tmp30_ = FALSE;
			ValaCCodeExpression* _tmp31_;
			_tmp31_ = cexpr;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp31_, VALA_TYPE_CCODE_IDENTIFIER)) {
				_tmp30_ = TRUE;
			} else {
				ValaCCodeExpression* _tmp32_;
				_tmp32_ = cexpr;
				_tmp30_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_CCODE_MEMBER_ACCESS);
			}
			if (_tmp30_) {
				ValaCCodeExpression* _tmp33_;
				ValaCCodeUnaryExpression* _tmp34_;
				_tmp33_ = cexpr;
				_tmp34_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp33_);
				result = (ValaCCodeExpression*) _tmp34_;
				_vala_code_node_unref0 (unary);
				_vala_code_node_unref0 (type);
				return result;
			} else {
				ValaTargetValue* temp_value = NULL;
				ValaDataType* _tmp35_;
				ValaExpression* _tmp36_;
				ValaTargetValue* _tmp37_;
				ValaCCodeFunction* _tmp38_;
				ValaCCodeFunction* _tmp39_;
				ValaTargetValue* _tmp40_;
				ValaCCodeExpression* _tmp41_;
				ValaCCodeExpression* _tmp42_;
				ValaCCodeExpression* _tmp43_;
				ValaTargetValue* _tmp44_;
				ValaCCodeExpression* _tmp45_;
				ValaCCodeExpression* _tmp46_;
				ValaCCodeUnaryExpression* _tmp47_;
				ValaCCodeExpression* _tmp48_;
				_tmp35_ = type;
				_tmp36_ = arg;
				_tmp37_ = vala_ccode_base_module_create_temp_value (self, _tmp35_, FALSE, (ValaCodeNode*) _tmp36_, NULL);
				temp_value = _tmp37_;
				_tmp38_ = vala_ccode_base_module_get_ccode (self);
				_tmp39_ = _tmp38_;
				_tmp40_ = temp_value;
				_tmp41_ = vala_ccode_base_module_get_cvalue_ (self, _tmp40_);
				_tmp42_ = _tmp41_;
				_tmp43_ = cexpr;
				vala_ccode_function_add_assignment (_tmp39_, _tmp42_, _tmp43_);
				_vala_ccode_node_unref0 (_tmp42_);
				_tmp44_ = temp_value;
				_tmp45_ = vala_ccode_base_module_get_cvalue_ (self, _tmp44_);
				_tmp46_ = _tmp45_;
				_tmp47_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp46_);
				_tmp48_ = (ValaCCodeExpression*) _tmp47_;
				_vala_ccode_node_unref0 (_tmp46_);
				result = _tmp48_;
				_vala_target_value_unref0 (temp_value);
				_vala_code_node_unref0 (unary);
				_vala_code_node_unref0 (type);
				return result;
			}
		}
	}
	_tmp49_ = cexpr;
	_tmp50_ = _vala_ccode_node_ref0 (_tmp49_);
	result = _tmp50_;
	_vala_code_node_unref0 (unary);
	_vala_code_node_unref0 (type);
	return result;
}


static void vala_ccode_base_module_real_visit_sizeof_expression (ValaCodeVisitor* base, ValaSizeofExpression* expr) {
	ValaCCodeBaseModule * self;
	ValaSizeofExpression* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaCCodeFile* _tmp3_;
	ValaCCodeFunctionCall* csizeof = NULL;
	ValaCCodeIdentifier* _tmp4_;
	ValaCCodeIdentifier* _tmp5_;
	ValaCCodeFunctionCall* _tmp6_;
	ValaCCodeFunctionCall* _tmp7_;
	ValaSizeofExpression* _tmp8_;
	ValaDataType* _tmp9_;
	ValaDataType* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	ValaCCodeIdentifier* _tmp13_;
	ValaCCodeIdentifier* _tmp14_;
	ValaSizeofExpression* _tmp15_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_sizeof_expression_get_type_reference (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->cfile;
	vala_ccode_base_module_generate_type_declaration (self, _tmp2_, _tmp3_);
	_tmp4_ = vala_ccode_identifier_new ("sizeof");
	_tmp5_ = _tmp4_;
	_tmp6_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp5_);
	_tmp7_ = _tmp6_;
	_vala_ccode_node_unref0 (_tmp5_);
	csizeof = _tmp7_;
	_tmp8_ = expr;
	_tmp9_ = vala_sizeof_expression_get_type_reference (_tmp8_);
	_tmp10_ = _tmp9_;
	_tmp11_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp10_);
	_tmp12_ = _tmp11_;
	_tmp13_ = vala_ccode_identifier_new (_tmp12_);
	_tmp14_ = _tmp13_;
	vala_ccode_function_call_add_argument (csizeof, (ValaCCodeExpression*) _tmp14_);
	_vala_ccode_node_unref0 (_tmp14_);
	_g_free0 (_tmp12_);
	_tmp15_ = expr;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp15_, (ValaCCodeExpression*) csizeof);
	_vala_ccode_node_unref0 (csizeof);
}


static void vala_ccode_base_module_real_visit_typeof_expression (ValaCodeVisitor* base, ValaTypeofExpression* expr) {
	ValaCCodeBaseModule * self;
	ValaTypeofExpression* _tmp0_;
	ValaTypeofExpression* _tmp1_;
	ValaDataType* _tmp2_;
	ValaDataType* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	ValaCCodeExpression* _tmp5_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = expr;
	_tmp2_ = vala_typeof_expression_get_type_reference (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_base_module_get_type_id_expression (self, _tmp3_, FALSE);
	_tmp5_ = _tmp4_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp0_, _tmp5_);
	_vala_ccode_node_unref0 (_tmp5_);
}


static void vala_ccode_base_module_real_visit_unary_expression (ValaCodeVisitor* base, ValaUnaryExpression* expr) {
	ValaCCodeBaseModule * self;
	gboolean _tmp0_ = FALSE;
	ValaUnaryExpression* _tmp1_;
	ValaUnaryOperator _tmp2_;
	ValaUnaryOperator _tmp3_;
	ValaCCodeUnaryOperator op = 0;
	ValaUnaryExpression* _tmp75_;
	ValaUnaryOperator _tmp76_;
	ValaUnaryOperator _tmp77_;
	ValaUnaryExpression* _tmp93_;
	ValaCCodeUnaryOperator _tmp94_;
	ValaUnaryExpression* _tmp95_;
	ValaExpression* _tmp96_;
	ValaExpression* _tmp97_;
	ValaCCodeExpression* _tmp98_;
	ValaCCodeExpression* _tmp99_;
	ValaCCodeUnaryExpression* _tmp100_;
	ValaCCodeUnaryExpression* _tmp101_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp1_ = expr;
	_tmp2_ = vala_unary_expression_get_operator (_tmp1_);
	_tmp3_ = _tmp2_;
	if (_tmp3_ == VALA_UNARY_OPERATOR_REF) {
		_tmp0_ = TRUE;
	} else {
		ValaUnaryExpression* _tmp4_;
		ValaUnaryOperator _tmp5_;
		ValaUnaryOperator _tmp6_;
		_tmp4_ = expr;
		_tmp5_ = vala_unary_expression_get_operator (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp0_ = _tmp6_ == VALA_UNARY_OPERATOR_OUT;
	}
	if (_tmp0_) {
		ValaGLibValue* glib_value = NULL;
		ValaUnaryExpression* _tmp7_;
		ValaExpression* _tmp8_;
		ValaExpression* _tmp9_;
		ValaTargetValue* _tmp10_;
		ValaTargetValue* _tmp11_;
		ValaGLibValue* _tmp12_;
		ValaGLibValue* ref_value = NULL;
		ValaGLibValue* _tmp13_;
		ValaDataType* _tmp14_;
		ValaDataType* _tmp15_;
		ValaGLibValue* _tmp16_;
		gboolean _tmp17_ = FALSE;
		gboolean _tmp18_ = FALSE;
		ValaUnaryExpression* _tmp19_;
		ValaDataType* _tmp20_;
		ValaDataType* _tmp21_;
		ValaGLibValue* _tmp44_;
		ValaList* _tmp45_;
		ValaGLibValue* _tmp61_;
		ValaCCodeExpression* _tmp62_;
		ValaGLibValue* _tmp67_;
		ValaCCodeExpression* _tmp68_;
		ValaUnaryExpression* _tmp73_;
		ValaGLibValue* _tmp74_;
		_tmp7_ = expr;
		_tmp8_ = vala_unary_expression_get_inner (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_expression_get_target_value (_tmp9_);
		_tmp11_ = _tmp10_;
		_tmp12_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
		glib_value = _tmp12_;
		_tmp13_ = glib_value;
		_tmp14_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp13_);
		_tmp15_ = _tmp14_;
		_tmp16_ = vala_glib_value_new (_tmp15_, NULL, FALSE);
		ref_value = _tmp16_;
		_tmp19_ = expr;
		_tmp20_ = vala_expression_get_target_type ((ValaExpression*) _tmp19_);
		_tmp21_ = _tmp20_;
		if (_tmp21_ != NULL) {
			ValaGLibValue* _tmp22_;
			ValaDataType* _tmp23_;
			ValaDataType* _tmp24_;
			gboolean _tmp25_;
			_tmp22_ = glib_value;
			_tmp23_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp22_);
			_tmp24_ = _tmp23_;
			_tmp25_ = vala_data_type_is_real_struct_type (_tmp24_);
			_tmp18_ = _tmp25_;
		} else {
			_tmp18_ = FALSE;
		}
		if (_tmp18_) {
			ValaGLibValue* _tmp26_;
			ValaDataType* _tmp27_;
			ValaDataType* _tmp28_;
			gboolean _tmp29_;
			gboolean _tmp30_;
			ValaUnaryExpression* _tmp31_;
			ValaDataType* _tmp32_;
			ValaDataType* _tmp33_;
			gboolean _tmp34_;
			gboolean _tmp35_;
			_tmp26_ = glib_value;
			_tmp27_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp26_);
			_tmp28_ = _tmp27_;
			_tmp29_ = vala_data_type_get_nullable (_tmp28_);
			_tmp30_ = _tmp29_;
			_tmp31_ = expr;
			_tmp32_ = vala_expression_get_target_type ((ValaExpression*) _tmp31_);
			_tmp33_ = _tmp32_;
			_tmp34_ = vala_data_type_get_nullable (_tmp33_);
			_tmp35_ = _tmp34_;
			_tmp17_ = _tmp30_ != _tmp35_;
		} else {
			_tmp17_ = FALSE;
		}
		if (_tmp17_) {
			ValaGLibValue* _tmp36_;
			ValaGLibValue* _tmp37_;
			ValaCCodeExpression* _tmp38_;
			ValaCCodeExpression* _tmp39_;
			_tmp36_ = ref_value;
			_tmp37_ = glib_value;
			_tmp38_ = _tmp37_->cvalue;
			_tmp39_ = _vala_ccode_node_ref0 (_tmp38_);
			_vala_ccode_node_unref0 (_tmp36_->cvalue);
			_tmp36_->cvalue = _tmp39_;
		} else {
			ValaGLibValue* _tmp40_;
			ValaGLibValue* _tmp41_;
			ValaCCodeExpression* _tmp42_;
			ValaCCodeUnaryExpression* _tmp43_;
			_tmp40_ = ref_value;
			_tmp41_ = glib_value;
			_tmp42_ = _tmp41_->cvalue;
			_tmp43_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp42_);
			_vala_ccode_node_unref0 (_tmp40_->cvalue);
			_tmp40_->cvalue = (ValaCCodeExpression*) _tmp43_;
		}
		_tmp44_ = glib_value;
		_tmp45_ = _tmp44_->array_length_cvalues;
		if (_tmp45_ != NULL) {
			{
				gint i = 0;
				i = 0;
				{
					gboolean _tmp46_ = FALSE;
					_tmp46_ = TRUE;
					while (TRUE) {
						gint _tmp48_;
						ValaGLibValue* _tmp49_;
						ValaList* _tmp50_;
						gint _tmp51_;
						gint _tmp52_;
						ValaGLibValue* _tmp53_;
						ValaGLibValue* _tmp54_;
						ValaList* _tmp55_;
						gint _tmp56_;
						gpointer _tmp57_;
						ValaCCodeExpression* _tmp58_;
						ValaCCodeUnaryExpression* _tmp59_;
						ValaCCodeUnaryExpression* _tmp60_;
						if (!_tmp46_) {
							gint _tmp47_;
							_tmp47_ = i;
							i = _tmp47_ + 1;
						}
						_tmp46_ = FALSE;
						_tmp48_ = i;
						_tmp49_ = glib_value;
						_tmp50_ = _tmp49_->array_length_cvalues;
						_tmp51_ = vala_collection_get_size ((ValaCollection*) _tmp50_);
						_tmp52_ = _tmp51_;
						if (!(_tmp48_ < _tmp52_)) {
							break;
						}
						_tmp53_ = ref_value;
						_tmp54_ = glib_value;
						_tmp55_ = _tmp54_->array_length_cvalues;
						_tmp56_ = i;
						_tmp57_ = vala_list_get (_tmp55_, _tmp56_);
						_tmp58_ = (ValaCCodeExpression*) _tmp57_;
						_tmp59_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp58_);
						_tmp60_ = _tmp59_;
						vala_glib_value_append_array_length_cvalue (_tmp53_, (ValaCCodeExpression*) _tmp60_);
						_vala_ccode_node_unref0 (_tmp60_);
						_vala_ccode_node_unref0 (_tmp58_);
					}
				}
			}
		}
		_tmp61_ = glib_value;
		_tmp62_ = _tmp61_->delegate_target_cvalue;
		if (_tmp62_ != NULL) {
			ValaGLibValue* _tmp63_;
			ValaGLibValue* _tmp64_;
			ValaCCodeExpression* _tmp65_;
			ValaCCodeUnaryExpression* _tmp66_;
			_tmp63_ = ref_value;
			_tmp64_ = glib_value;
			_tmp65_ = _tmp64_->delegate_target_cvalue;
			_tmp66_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp65_);
			_vala_ccode_node_unref0 (_tmp63_->delegate_target_cvalue);
			_tmp63_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp66_;
		}
		_tmp67_ = glib_value;
		_tmp68_ = _tmp67_->delegate_target_destroy_notify_cvalue;
		if (_tmp68_ != NULL) {
			ValaGLibValue* _tmp69_;
			ValaGLibValue* _tmp70_;
			ValaCCodeExpression* _tmp71_;
			ValaCCodeUnaryExpression* _tmp72_;
			_tmp69_ = ref_value;
			_tmp70_ = glib_value;
			_tmp71_ = _tmp70_->delegate_target_destroy_notify_cvalue;
			_tmp72_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp71_);
			_vala_ccode_node_unref0 (_tmp69_->delegate_target_destroy_notify_cvalue);
			_tmp69_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp72_;
		}
		_tmp73_ = expr;
		_tmp74_ = ref_value;
		vala_expression_set_target_value ((ValaExpression*) _tmp73_, (ValaTargetValue*) _tmp74_);
		_vala_target_value_unref0 (ref_value);
		_vala_target_value_unref0 (glib_value);
		return;
	}
	_tmp75_ = expr;
	_tmp76_ = vala_unary_expression_get_operator (_tmp75_);
	_tmp77_ = _tmp76_;
	if (_tmp77_ == VALA_UNARY_OPERATOR_PLUS) {
		op = VALA_CCODE_UNARY_OPERATOR_PLUS;
	} else {
		ValaUnaryExpression* _tmp78_;
		ValaUnaryOperator _tmp79_;
		ValaUnaryOperator _tmp80_;
		_tmp78_ = expr;
		_tmp79_ = vala_unary_expression_get_operator (_tmp78_);
		_tmp80_ = _tmp79_;
		if (_tmp80_ == VALA_UNARY_OPERATOR_MINUS) {
			op = VALA_CCODE_UNARY_OPERATOR_MINUS;
		} else {
			ValaUnaryExpression* _tmp81_;
			ValaUnaryOperator _tmp82_;
			ValaUnaryOperator _tmp83_;
			_tmp81_ = expr;
			_tmp82_ = vala_unary_expression_get_operator (_tmp81_);
			_tmp83_ = _tmp82_;
			if (_tmp83_ == VALA_UNARY_OPERATOR_LOGICAL_NEGATION) {
				op = VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION;
			} else {
				ValaUnaryExpression* _tmp84_;
				ValaUnaryOperator _tmp85_;
				ValaUnaryOperator _tmp86_;
				_tmp84_ = expr;
				_tmp85_ = vala_unary_expression_get_operator (_tmp84_);
				_tmp86_ = _tmp85_;
				if (_tmp86_ == VALA_UNARY_OPERATOR_BITWISE_COMPLEMENT) {
					op = VALA_CCODE_UNARY_OPERATOR_BITWISE_COMPLEMENT;
				} else {
					ValaUnaryExpression* _tmp87_;
					ValaUnaryOperator _tmp88_;
					ValaUnaryOperator _tmp89_;
					_tmp87_ = expr;
					_tmp88_ = vala_unary_expression_get_operator (_tmp87_);
					_tmp89_ = _tmp88_;
					if (_tmp89_ == VALA_UNARY_OPERATOR_INCREMENT) {
						op = VALA_CCODE_UNARY_OPERATOR_PREFIX_INCREMENT;
					} else {
						ValaUnaryExpression* _tmp90_;
						ValaUnaryOperator _tmp91_;
						ValaUnaryOperator _tmp92_;
						_tmp90_ = expr;
						_tmp91_ = vala_unary_expression_get_operator (_tmp90_);
						_tmp92_ = _tmp91_;
						if (_tmp92_ == VALA_UNARY_OPERATOR_DECREMENT) {
							op = VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT;
						} else {
							g_assert_not_reached ();
						}
					}
				}
			}
		}
	}
	_tmp93_ = expr;
	_tmp94_ = op;
	_tmp95_ = expr;
	_tmp96_ = vala_unary_expression_get_inner (_tmp95_);
	_tmp97_ = _tmp96_;
	_tmp98_ = vala_ccode_base_module_get_cvalue (self, _tmp97_);
	_tmp99_ = _tmp98_;
	_tmp100_ = vala_ccode_unary_expression_new (_tmp94_, _tmp99_);
	_tmp101_ = _tmp100_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp93_, (ValaCCodeExpression*) _tmp101_);
	_vala_ccode_node_unref0 (_tmp101_);
	_vala_ccode_node_unref0 (_tmp99_);
}


ValaCCodeExpression* vala_ccode_base_module_try_cast_value_to_type (ValaCCodeBaseModule* self, ValaCCodeExpression* ccodeexpr, ValaDataType* from, ValaDataType* to, ValaExpression* expr) {
	ValaCCodeExpression* result = NULL;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp2_ = FALSE;
	gboolean _tmp3_ = FALSE;
	ValaDataType* _tmp4_;
	ValaCCodeFunctionCall* ccall = NULL;
	ValaDataType* _tmp17_;
	ValaCCodeIdentifier* _tmp18_;
	ValaCCodeIdentifier* _tmp19_;
	ValaCCodeFunctionCall* _tmp20_;
	ValaCCodeFunctionCall* _tmp21_;
	ValaCCodeExpression* gvalue = NULL;
	ValaDataType* _tmp22_;
	gboolean _tmp23_;
	gboolean _tmp24_;
	ValaCCodeFunctionCall* _tmp29_;
	ValaCCodeExpression* _tmp30_;
	ValaCCodeExpression* rv = NULL;
	ValaCCodeFunctionCall* _tmp31_;
	ValaCCodeExpression* _tmp32_;
	gboolean _tmp33_ = FALSE;
	ValaExpression* _tmp34_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (ccodeexpr != NULL, NULL);
	g_return_val_if_fail (from != NULL, NULL);
	g_return_val_if_fail (to != NULL, NULL);
	_tmp4_ = from;
	if (_tmp4_ == NULL) {
		_tmp3_ = TRUE;
	} else {
		ValaStruct* _tmp5_;
		_tmp5_ = self->gvalue_type;
		_tmp3_ = _tmp5_ == NULL;
	}
	if (_tmp3_) {
		_tmp2_ = TRUE;
	} else {
		ValaDataType* _tmp6_;
		ValaTypeSymbol* _tmp7_;
		ValaTypeSymbol* _tmp8_;
		ValaStruct* _tmp9_;
		_tmp6_ = from;
		_tmp7_ = vala_data_type_get_data_type (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = self->gvalue_type;
		_tmp2_ = _tmp8_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	}
	if (_tmp2_) {
		_tmp1_ = TRUE;
	} else {
		ValaDataType* _tmp10_;
		ValaTypeSymbol* _tmp11_;
		ValaTypeSymbol* _tmp12_;
		ValaStruct* _tmp13_;
		_tmp10_ = to;
		_tmp11_ = vala_data_type_get_data_type (_tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = self->gvalue_type;
		_tmp1_ = _tmp12_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp13_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	}
	if (_tmp1_) {
		_tmp0_ = TRUE;
	} else {
		ValaDataType* _tmp14_;
		gchar* _tmp15_;
		gchar* _tmp16_;
		_tmp14_ = to;
		_tmp15_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp14_);
		_tmp16_ = _tmp15_;
		_tmp0_ = g_strcmp0 (_tmp16_, "") == 0;
		_g_free0 (_tmp16_);
	}
	if (_tmp0_) {
		result = NULL;
		return result;
	}
	_tmp17_ = to;
	_tmp18_ = vala_ccode_base_module_get_value_getter_function (self, _tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp19_);
	_tmp21_ = _tmp20_;
	_vala_ccode_node_unref0 (_tmp19_);
	ccall = _tmp21_;
	_tmp22_ = from;
	_tmp23_ = vala_data_type_get_nullable (_tmp22_);
	_tmp24_ = _tmp23_;
	if (_tmp24_) {
		ValaCCodeExpression* _tmp25_;
		ValaCCodeExpression* _tmp26_;
		_tmp25_ = ccodeexpr;
		_tmp26_ = _vala_ccode_node_ref0 (_tmp25_);
		_vala_ccode_node_unref0 (gvalue);
		gvalue = _tmp26_;
	} else {
		ValaCCodeExpression* _tmp27_;
		ValaCCodeUnaryExpression* _tmp28_;
		_tmp27_ = ccodeexpr;
		_tmp28_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp27_);
		_vala_ccode_node_unref0 (gvalue);
		gvalue = (ValaCCodeExpression*) _tmp28_;
	}
	_tmp29_ = ccall;
	_tmp30_ = gvalue;
	vala_ccode_function_call_add_argument (_tmp29_, _tmp30_);
	_tmp31_ = ccall;
	_tmp32_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp31_);
	rv = _tmp32_;
	_tmp34_ = expr;
	if (_tmp34_ != NULL) {
		ValaDataType* _tmp35_;
		_tmp35_ = to;
		_tmp33_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp35_, VALA_TYPE_ARRAY_TYPE);
	} else {
		_tmp33_ = FALSE;
	}
	if (_tmp33_) {
		ValaCCodeFunctionCall* len_call = NULL;
		ValaCCodeIdentifier* _tmp36_;
		ValaCCodeIdentifier* _tmp37_;
		ValaCCodeFunctionCall* _tmp38_;
		ValaCCodeFunctionCall* _tmp39_;
		ValaCCodeFunctionCall* _tmp40_;
		ValaCCodeExpression* _tmp41_;
		ValaExpression* _tmp42_;
		ValaCCodeFunctionCall* _tmp43_;
		_tmp36_ = vala_ccode_identifier_new ("g_strv_length");
		_tmp37_ = _tmp36_;
		_tmp38_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp37_);
		_tmp39_ = _tmp38_;
		_vala_ccode_node_unref0 (_tmp37_);
		len_call = _tmp39_;
		_tmp40_ = len_call;
		_tmp41_ = rv;
		vala_ccode_function_call_add_argument (_tmp40_, _tmp41_);
		_tmp42_ = expr;
		_tmp43_ = len_call;
		vala_ccode_base_module_append_array_length (self, _tmp42_, (ValaCCodeExpression*) _tmp43_);
		_vala_ccode_node_unref0 (len_call);
	} else {
		ValaDataType* _tmp44_;
		_tmp44_ = to;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp44_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
			ValaCodeNode* _tmp45_ = NULL;
			ValaExpression* _tmp46_;
			ValaCodeNode* node = NULL;
			ValaCodeNode* _tmp49_;
			ValaTargetValue* temp_value = NULL;
			ValaDataType* _tmp50_;
			ValaCodeNode* _tmp51_;
			gboolean _tmp52_;
			ValaTargetValue* _tmp53_;
			ValaCCodeExpression* ctemp = NULL;
			ValaTargetValue* _tmp54_;
			ValaCCodeExpression* _tmp55_;
			ValaCCodeExpression* _tmp56_;
			ValaDataType* _tmp57_;
			ValaPointerType* _tmp58_;
			ValaPointerType* _tmp59_;
			gchar* _tmp60_;
			gchar* _tmp61_;
			ValaCCodeCastExpression* _tmp62_;
			ValaCCodeCastExpression* _tmp63_;
			ValaCCodeUnaryExpression* _tmp64_;
			ValaCCodeFunctionCall* holds = NULL;
			ValaCCodeIdentifier* _tmp65_;
			ValaCCodeIdentifier* _tmp66_;
			ValaCCodeFunctionCall* _tmp67_;
			ValaCCodeFunctionCall* _tmp68_;
			ValaCCodeFunctionCall* _tmp69_;
			ValaCCodeExpression* _tmp70_;
			ValaCCodeFunctionCall* _tmp71_;
			ValaDataType* _tmp72_;
			gchar* _tmp73_;
			gchar* _tmp74_;
			ValaCCodeIdentifier* _tmp75_;
			ValaCCodeIdentifier* _tmp76_;
			ValaCCodeBinaryExpression* cond = NULL;
			ValaCCodeFunctionCall* _tmp77_;
			ValaCCodeFunctionCall* _tmp78_;
			ValaCCodeBinaryExpression* _tmp79_;
			ValaCCodeFunctionCall* warn = NULL;
			ValaCCodeIdentifier* _tmp80_;
			ValaCCodeIdentifier* _tmp81_;
			ValaCCodeFunctionCall* _tmp82_;
			ValaCCodeFunctionCall* _tmp83_;
			ValaCCodeFunctionCall* _tmp84_;
			ValaCCodeConstant* _tmp85_;
			ValaCCodeConstant* _tmp86_;
			ValaCCodeCommaExpression* fail = NULL;
			ValaCCodeCommaExpression* _tmp87_;
			ValaCCodeCommaExpression* _tmp88_;
			ValaCCodeFunctionCall* _tmp89_;
			ValaCCodeCommaExpression* _tmp90_;
			ValaCCodeExpression* _tmp91_;
			ValaCCodeBinaryExpression* _tmp92_;
			ValaCCodeExpression* _tmp93_;
			ValaCCodeCommaExpression* _tmp94_;
			ValaCCodeConditionalExpression* _tmp95_;
			_tmp46_ = expr;
			if (_tmp46_ != NULL) {
				ValaExpression* _tmp47_;
				_tmp47_ = expr;
				_tmp45_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp47_, VALA_TYPE_CODE_NODE, ValaCodeNode);
			} else {
				ValaDataType* _tmp48_;
				_tmp48_ = to;
				_tmp45_ = (ValaCodeNode*) _tmp48_;
			}
			_tmp49_ = _vala_code_node_ref0 (_tmp45_);
			node = _tmp49_;
			_tmp50_ = to;
			_tmp51_ = node;
			_tmp52_ = TRUE;
			_tmp53_ = vala_ccode_base_module_create_temp_value (self, _tmp50_, TRUE, _tmp51_, &_tmp52_);
			temp_value = _tmp53_;
			_tmp54_ = temp_value;
			_tmp55_ = vala_ccode_base_module_get_cvalue_ (self, _tmp54_);
			ctemp = _tmp55_;
			_tmp56_ = rv;
			_tmp57_ = to;
			_tmp58_ = vala_pointer_type_new (_tmp57_, NULL);
			_tmp59_ = _tmp58_;
			_tmp60_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp59_);
			_tmp61_ = _tmp60_;
			_tmp62_ = vala_ccode_cast_expression_new (_tmp56_, _tmp61_);
			_tmp63_ = _tmp62_;
			_tmp64_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp63_);
			_vala_ccode_node_unref0 (rv);
			rv = (ValaCCodeExpression*) _tmp64_;
			_vala_ccode_node_unref0 (_tmp63_);
			_g_free0 (_tmp61_);
			_vala_code_node_unref0 (_tmp59_);
			_tmp65_ = vala_ccode_identifier_new ("G_VALUE_HOLDS");
			_tmp66_ = _tmp65_;
			_tmp67_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp66_);
			_tmp68_ = _tmp67_;
			_vala_ccode_node_unref0 (_tmp66_);
			holds = _tmp68_;
			_tmp69_ = holds;
			_tmp70_ = gvalue;
			vala_ccode_function_call_add_argument (_tmp69_, _tmp70_);
			_tmp71_ = holds;
			_tmp72_ = to;
			_tmp73_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp72_);
			_tmp74_ = _tmp73_;
			_tmp75_ = vala_ccode_identifier_new (_tmp74_);
			_tmp76_ = _tmp75_;
			vala_ccode_function_call_add_argument (_tmp71_, (ValaCCodeExpression*) _tmp76_);
			_vala_ccode_node_unref0 (_tmp76_);
			_g_free0 (_tmp74_);
			_tmp77_ = holds;
			_tmp78_ = ccall;
			_tmp79_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_AND, (ValaCCodeExpression*) _tmp77_, (ValaCCodeExpression*) _tmp78_);
			cond = _tmp79_;
			_tmp80_ = vala_ccode_identifier_new ("g_warning");
			_tmp81_ = _tmp80_;
			_tmp82_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp81_);
			_tmp83_ = _tmp82_;
			_vala_ccode_node_unref0 (_tmp81_);
			warn = _tmp83_;
			_tmp84_ = warn;
			_tmp85_ = vala_ccode_constant_new ("\"Invalid GValue unboxing (wrong type or NULL)\"");
			_tmp86_ = _tmp85_;
			vala_ccode_function_call_add_argument (_tmp84_, (ValaCCodeExpression*) _tmp86_);
			_vala_ccode_node_unref0 (_tmp86_);
			_tmp87_ = vala_ccode_comma_expression_new ();
			fail = _tmp87_;
			_tmp88_ = fail;
			_tmp89_ = warn;
			vala_ccode_comma_expression_append_expression (_tmp88_, (ValaCCodeExpression*) _tmp89_);
			_tmp90_ = fail;
			_tmp91_ = ctemp;
			vala_ccode_comma_expression_append_expression (_tmp90_, _tmp91_);
			_tmp92_ = cond;
			_tmp93_ = rv;
			_tmp94_ = fail;
			_tmp95_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp92_, _tmp93_, (ValaCCodeExpression*) _tmp94_);
			_vala_ccode_node_unref0 (rv);
			rv = (ValaCCodeExpression*) _tmp95_;
			_vala_ccode_node_unref0 (fail);
			_vala_ccode_node_unref0 (warn);
			_vala_ccode_node_unref0 (cond);
			_vala_ccode_node_unref0 (holds);
			_vala_ccode_node_unref0 (ctemp);
			_vala_target_value_unref0 (temp_value);
			_vala_code_node_unref0 (node);
		}
	}
	result = rv;
	_vala_ccode_node_unref0 (gvalue);
	_vala_ccode_node_unref0 (ccall);
	return result;
}


ValaTargetValue* vala_ccode_base_module_try_cast_variant_to_type (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* to, ValaCodeNode* node) {
	ValaTargetValue* result = NULL;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	ValaTargetValue* _tmp2_;
	ValaDataType* _tmp3_;
	ValaDataType* _tmp4_;
	gchar* variant_func = NULL;
	gint _tmp12_;
	gint _tmp13_;
	gchar* _tmp14_;
	ValaTargetValue* variant = NULL;
	ValaTargetValue* _tmp15_;
	ValaTargetValue* _tmp16_;
	ValaTargetValue* _tmp17_;
	ValaDataType* _tmp18_;
	ValaDataType* _tmp19_;
	gboolean _tmp20_;
	gboolean _tmp21_;
	ValaCCodeFunctionCall* ccall = NULL;
	const gchar* _tmp32_;
	ValaCCodeIdentifier* _tmp33_;
	ValaCCodeIdentifier* _tmp34_;
	ValaCCodeFunctionCall* _tmp35_;
	ValaCCodeFunctionCall* _tmp36_;
	ValaCCodeFunctionCall* _tmp37_;
	ValaTargetValue* _tmp38_;
	ValaCCodeExpression* _tmp39_;
	ValaCCodeExpression* _tmp40_;
	ValaTargetValue* _result_ = NULL;
	ValaDataType* _tmp41_;
	ValaCodeNode* _tmp42_;
	ValaTargetValue* _tmp43_;
	ValaCCodeFunction* cfunc = NULL;
	const gchar* _tmp44_;
	ValaCCodeFunction* _tmp45_;
	ValaCCodeFunction* _tmp46_;
	ValaCCodeFunction* _tmp47_;
	ValaCCodeParameter* _tmp48_;
	ValaCCodeParameter* _tmp49_;
	ValaDataType* _tmp50_;
	gboolean _tmp51_;
	ValaDataType* _tmp56_;
	gboolean _tmp57_;
	ValaDataType* _tmp94_;
	gboolean _tmp95_;
	ValaCCodeFunction* _tmp105_;
	ValaCCodeExpression* func_result = NULL;
	ValaDataType* _tmp106_;
	ValaCCodeIdentifier* _tmp107_;
	ValaCCodeIdentifier* _tmp108_;
	ValaCCodeIdentifier* _tmp109_;
	ValaCCodeIdentifier* _tmp110_;
	ValaCCodeExpression* _tmp111_;
	ValaCCodeExpression* _tmp112_;
	ValaDataType* _tmp113_;
	gboolean _tmp114_;
	ValaCCodeFile* _tmp123_;
	ValaCCodeFunction* _tmp124_;
	ValaCCodeFile* _tmp125_;
	ValaCCodeFunction* _tmp126_;
	ValaTargetValue* _tmp127_;
	ValaTargetValue* _tmp128_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (value != NULL, NULL);
	g_return_val_if_fail (to != NULL, NULL);
	_tmp2_ = value;
	_tmp3_ = vala_target_value_get_value_type (_tmp2_);
	_tmp4_ = _tmp3_;
	if (_tmp4_ == NULL) {
		_tmp1_ = TRUE;
	} else {
		ValaClass* _tmp5_;
		_tmp5_ = self->gvariant_type;
		_tmp1_ = _tmp5_ == NULL;
	}
	if (_tmp1_) {
		_tmp0_ = TRUE;
	} else {
		ValaTargetValue* _tmp6_;
		ValaDataType* _tmp7_;
		ValaDataType* _tmp8_;
		ValaTypeSymbol* _tmp9_;
		ValaTypeSymbol* _tmp10_;
		ValaClass* _tmp11_;
		_tmp6_ = value;
		_tmp7_ = vala_target_value_get_value_type (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = vala_data_type_get_data_type (_tmp8_);
		_tmp10_ = _tmp9_;
		_tmp11_ = self->gvariant_type;
		_tmp0_ = _tmp10_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	}
	if (_tmp0_) {
		result = NULL;
		return result;
	}
	_tmp12_ = self->priv->next_variant_function_id;
	self->priv->next_variant_function_id = _tmp12_ + 1;
	_tmp13_ = self->priv->next_variant_function_id;
	_tmp14_ = g_strdup_printf ("_variant_get%d", _tmp13_);
	variant_func = _tmp14_;
	_tmp15_ = value;
	_tmp16_ = _vala_target_value_ref0 (_tmp15_);
	variant = _tmp16_;
	_tmp17_ = value;
	_tmp18_ = vala_target_value_get_value_type (_tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = vala_data_type_get_value_owned (_tmp19_);
	_tmp21_ = _tmp20_;
	if (_tmp21_) {
		ValaTargetValue* temp_value = NULL;
		ValaTargetValue* _tmp22_;
		ValaCodeNode* _tmp23_;
		ValaTargetValue* _tmp24_;
		ValaArrayList* _tmp25_;
		ValaArrayList* _tmp26_;
		ValaTargetValue* _tmp27_;
		ValaGLibValue* _tmp28_;
		ValaGLibValue* _tmp29_;
		ValaTargetValue* _tmp30_;
		ValaTargetValue* _tmp31_;
		_tmp22_ = value;
		_tmp23_ = node;
		_tmp24_ = vala_ccode_base_module_store_temp_value (self, _tmp22_, _tmp23_, NULL);
		temp_value = _tmp24_;
		_tmp25_ = vala_ccode_base_module_get_temp_ref_values (self);
		_tmp26_ = _tmp25_;
		_tmp27_ = temp_value;
		_tmp28_ = vala_glib_value_copy (G_TYPE_CHECK_INSTANCE_CAST (_tmp27_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
		_tmp29_ = _tmp28_;
		vala_list_insert ((ValaList*) _tmp26_, 0, (ValaTargetValue*) _tmp29_);
		_vala_target_value_unref0 (_tmp29_);
		_tmp30_ = temp_value;
		_tmp31_ = _vala_target_value_ref0 (_tmp30_);
		_vala_target_value_unref0 (variant);
		variant = _tmp31_;
		_vala_target_value_unref0 (temp_value);
	}
	_tmp32_ = variant_func;
	_tmp33_ = vala_ccode_identifier_new (_tmp32_);
	_tmp34_ = _tmp33_;
	_tmp35_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp34_);
	_tmp36_ = _tmp35_;
	_vala_ccode_node_unref0 (_tmp34_);
	ccall = _tmp36_;
	_tmp37_ = ccall;
	_tmp38_ = variant;
	_tmp39_ = vala_ccode_base_module_get_cvalue_ (self, _tmp38_);
	_tmp40_ = _tmp39_;
	vala_ccode_function_call_add_argument (_tmp37_, _tmp40_);
	_vala_ccode_node_unref0 (_tmp40_);
	_tmp41_ = to;
	_tmp42_ = node;
	_tmp43_ = vala_ccode_base_module_create_temp_value (self, _tmp41_, FALSE, _tmp42_, NULL);
	_result_ = _tmp43_;
	_tmp44_ = variant_func;
	_tmp45_ = vala_ccode_function_new (_tmp44_, "void");
	cfunc = _tmp45_;
	_tmp46_ = cfunc;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp46_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp47_ = cfunc;
	_tmp48_ = vala_ccode_parameter_new ("value", "GVariant*");
	_tmp49_ = _tmp48_;
	vala_ccode_function_add_parameter (_tmp47_, _tmp49_);
	_vala_ccode_node_unref0 (_tmp49_);
	_tmp50_ = to;
	_tmp51_ = vala_data_type_is_real_non_null_struct_type (_tmp50_);
	if (!_tmp51_) {
		ValaCCodeFunction* _tmp52_;
		ValaDataType* _tmp53_;
		gchar* _tmp54_;
		gchar* _tmp55_;
		_tmp52_ = cfunc;
		_tmp53_ = to;
		_tmp54_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp53_);
		_tmp55_ = _tmp54_;
		vala_ccode_function_set_return_type (_tmp52_, _tmp55_);
		_g_free0 (_tmp55_);
	}
	_tmp56_ = to;
	_tmp57_ = vala_data_type_is_real_non_null_struct_type (_tmp56_);
	if (_tmp57_) {
		ValaCCodeFunction* _tmp58_;
		ValaDataType* _tmp59_;
		gchar* _tmp60_;
		gchar* _tmp61_;
		gchar* _tmp62_;
		gchar* _tmp63_;
		ValaCCodeParameter* _tmp64_;
		ValaCCodeParameter* _tmp65_;
		ValaCCodeFunctionCall* _tmp66_;
		ValaTargetValue* _tmp67_;
		ValaCCodeExpression* _tmp68_;
		ValaCCodeExpression* _tmp69_;
		ValaCCodeUnaryExpression* _tmp70_;
		ValaCCodeUnaryExpression* _tmp71_;
		_tmp58_ = cfunc;
		_tmp59_ = to;
		_tmp60_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp59_);
		_tmp61_ = _tmp60_;
		_tmp62_ = g_strdup_printf ("%s *", _tmp61_);
		_tmp63_ = _tmp62_;
		_tmp64_ = vala_ccode_parameter_new ("result", _tmp63_);
		_tmp65_ = _tmp64_;
		vala_ccode_function_add_parameter (_tmp58_, _tmp65_);
		_vala_ccode_node_unref0 (_tmp65_);
		_g_free0 (_tmp63_);
		_g_free0 (_tmp61_);
		_tmp66_ = ccall;
		_tmp67_ = _result_;
		_tmp68_ = vala_ccode_base_module_get_cvalue_ (self, _tmp67_);
		_tmp69_ = _tmp68_;
		_tmp70_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp69_);
		_tmp71_ = _tmp70_;
		vala_ccode_function_call_add_argument (_tmp66_, (ValaCCodeExpression*) _tmp71_);
		_vala_ccode_node_unref0 (_tmp71_);
		_vala_ccode_node_unref0 (_tmp69_);
	} else {
		ValaDataType* _tmp72_;
		_tmp72_ = to;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp72_, VALA_TYPE_ARRAY_TYPE)) {
			ValaArrayType* array_type = NULL;
			ValaDataType* _tmp73_;
			ValaArrayType* _tmp74_;
			_tmp73_ = to;
			_tmp74_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp73_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
			array_type = _tmp74_;
			{
				gint dim = 0;
				dim = 1;
				{
					gboolean _tmp75_ = FALSE;
					_tmp75_ = TRUE;
					while (TRUE) {
						gint _tmp77_;
						ValaArrayType* _tmp78_;
						gint _tmp79_;
						gint _tmp80_;
						ValaCCodeFunctionCall* _tmp81_;
						ValaTargetValue* _tmp82_;
						gint _tmp83_;
						ValaCCodeExpression* _tmp84_;
						ValaCCodeExpression* _tmp85_;
						ValaCCodeUnaryExpression* _tmp86_;
						ValaCCodeUnaryExpression* _tmp87_;
						ValaCCodeFunction* _tmp88_;
						gint _tmp89_;
						gchar* _tmp90_;
						gchar* _tmp91_;
						ValaCCodeParameter* _tmp92_;
						ValaCCodeParameter* _tmp93_;
						if (!_tmp75_) {
							gint _tmp76_;
							_tmp76_ = dim;
							dim = _tmp76_ + 1;
						}
						_tmp75_ = FALSE;
						_tmp77_ = dim;
						_tmp78_ = array_type;
						_tmp79_ = vala_array_type_get_rank (_tmp78_);
						_tmp80_ = _tmp79_;
						if (!(_tmp77_ <= _tmp80_)) {
							break;
						}
						_tmp81_ = ccall;
						_tmp82_ = _result_;
						_tmp83_ = dim;
						_tmp84_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp82_, _tmp83_);
						_tmp85_ = _tmp84_;
						_tmp86_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp85_);
						_tmp87_ = _tmp86_;
						vala_ccode_function_call_add_argument (_tmp81_, (ValaCCodeExpression*) _tmp87_);
						_vala_ccode_node_unref0 (_tmp87_);
						_vala_ccode_node_unref0 (_tmp85_);
						_tmp88_ = cfunc;
						_tmp89_ = dim;
						_tmp90_ = vala_ccode_base_module_get_array_length_cname (self, "result", _tmp89_);
						_tmp91_ = _tmp90_;
						_tmp92_ = vala_ccode_parameter_new (_tmp91_, "int*");
						_tmp93_ = _tmp92_;
						vala_ccode_function_add_parameter (_tmp88_, _tmp93_);
						_vala_ccode_node_unref0 (_tmp93_);
						_g_free0 (_tmp91_);
					}
				}
			}
			_vala_code_node_unref0 (array_type);
		}
	}
	_tmp94_ = to;
	_tmp95_ = vala_data_type_is_real_non_null_struct_type (_tmp94_);
	if (!_tmp95_) {
		ValaCCodeFunction* _tmp96_;
		ValaCCodeFunction* _tmp97_;
		ValaTargetValue* _tmp98_;
		ValaCCodeExpression* _tmp99_;
		ValaCCodeExpression* _tmp100_;
		ValaCCodeFunctionCall* _tmp101_;
		_tmp96_ = vala_ccode_base_module_get_ccode (self);
		_tmp97_ = _tmp96_;
		_tmp98_ = _result_;
		_tmp99_ = vala_ccode_base_module_get_cvalue_ (self, _tmp98_);
		_tmp100_ = _tmp99_;
		_tmp101_ = ccall;
		vala_ccode_function_add_assignment (_tmp97_, _tmp100_, (ValaCCodeExpression*) _tmp101_);
		_vala_ccode_node_unref0 (_tmp100_);
	} else {
		ValaCCodeFunction* _tmp102_;
		ValaCCodeFunction* _tmp103_;
		ValaCCodeFunctionCall* _tmp104_;
		_tmp102_ = vala_ccode_base_module_get_ccode (self);
		_tmp103_ = _tmp102_;
		_tmp104_ = ccall;
		vala_ccode_function_add_expression (_tmp103_, (ValaCCodeExpression*) _tmp104_);
	}
	_tmp105_ = cfunc;
	vala_ccode_base_module_push_function (self, _tmp105_);
	_tmp106_ = to;
	_tmp107_ = vala_ccode_identifier_new ("value");
	_tmp108_ = _tmp107_;
	_tmp109_ = vala_ccode_identifier_new ("*result");
	_tmp110_ = _tmp109_;
	_tmp111_ = vala_ccode_base_module_deserialize_expression (self, _tmp106_, (ValaCCodeExpression*) _tmp108_, (ValaCCodeExpression*) _tmp110_, NULL, NULL);
	_tmp112_ = _tmp111_;
	_vala_ccode_node_unref0 (_tmp110_);
	_vala_ccode_node_unref0 (_tmp108_);
	func_result = _tmp112_;
	_tmp113_ = to;
	_tmp114_ = vala_data_type_is_real_non_null_struct_type (_tmp113_);
	if (_tmp114_) {
		ValaCCodeFunction* _tmp115_;
		ValaCCodeFunction* _tmp116_;
		ValaCCodeIdentifier* _tmp117_;
		ValaCCodeIdentifier* _tmp118_;
		ValaCCodeExpression* _tmp119_;
		_tmp115_ = vala_ccode_base_module_get_ccode (self);
		_tmp116_ = _tmp115_;
		_tmp117_ = vala_ccode_identifier_new ("*result");
		_tmp118_ = _tmp117_;
		_tmp119_ = func_result;
		vala_ccode_function_add_assignment (_tmp116_, (ValaCCodeExpression*) _tmp118_, _tmp119_);
		_vala_ccode_node_unref0 (_tmp118_);
	} else {
		ValaCCodeFunction* _tmp120_;
		ValaCCodeFunction* _tmp121_;
		ValaCCodeExpression* _tmp122_;
		_tmp120_ = vala_ccode_base_module_get_ccode (self);
		_tmp121_ = _tmp120_;
		_tmp122_ = func_result;
		vala_ccode_function_add_return (_tmp121_, _tmp122_);
	}
	vala_ccode_base_module_pop_function (self);
	_tmp123_ = self->cfile;
	_tmp124_ = cfunc;
	vala_ccode_file_add_function_declaration (_tmp123_, _tmp124_);
	_tmp125_ = self->cfile;
	_tmp126_ = cfunc;
	vala_ccode_file_add_function (_tmp125_, _tmp126_);
	_tmp127_ = _result_;
	_tmp128_ = vala_ccode_base_module_load_temp_value (self, _tmp127_);
	result = _tmp128_;
	_vala_ccode_node_unref0 (func_result);
	_vala_ccode_node_unref0 (cfunc);
	_vala_target_value_unref0 (_result_);
	_vala_ccode_node_unref0 (ccall);
	_vala_target_value_unref0 (variant);
	_g_free0 (variant_func);
	return result;
}


static ValaCCodeExpression* vala_ccode_base_module_real_deserialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail) {
	gboolean _vala_may_fail = FALSE;
	ValaCCodeExpression* result = NULL;
	g_return_val_if_fail (type != NULL, NULL);
	g_return_val_if_fail (variant_expr != NULL, NULL);
	g_assert_not_reached ();
	if (may_fail) {
		*may_fail = _vala_may_fail;
	}
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_deserialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->deserialize_expression (self, type, variant_expr, expr, error_expr, may_fail);
}


static ValaCCodeExpression* vala_ccode_base_module_real_serialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr) {
	ValaCCodeExpression* result = NULL;
	g_return_val_if_fail (type != NULL, NULL);
	g_return_val_if_fail (expr != NULL, NULL);
	g_assert_not_reached ();
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_serialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->serialize_expression (self, type, expr);
}


static void vala_ccode_base_module_real_visit_cast_expression (ValaCodeVisitor* base, ValaCastExpression* expr) {
	ValaCCodeBaseModule * self;
	ValaCastExpression* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaCCodeFile* _tmp3_;
	ValaCastExpression* _tmp4_;
	gboolean _tmp5_;
	gboolean _tmp6_;
	ValaClass* cl = NULL;
	ValaCastExpression* _tmp39_;
	ValaDataType* _tmp40_;
	ValaDataType* _tmp41_;
	ValaTypeSymbol* _tmp42_;
	ValaTypeSymbol* _tmp43_;
	ValaClass* _tmp44_;
	ValaInterface* iface = NULL;
	ValaCastExpression* _tmp45_;
	ValaDataType* _tmp46_;
	ValaDataType* _tmp47_;
	ValaTypeSymbol* _tmp48_;
	ValaTypeSymbol* _tmp49_;
	ValaInterface* _tmp50_;
	gboolean _tmp51_ = FALSE;
	ValaInterface* _tmp52_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_cast_expression_get_type_reference (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->cfile;
	vala_ccode_base_module_generate_type_declaration (self, _tmp2_, _tmp3_);
	_tmp4_ = expr;
	_tmp5_ = vala_cast_expression_get_is_non_null_cast (_tmp4_);
	_tmp6_ = _tmp5_;
	if (!_tmp6_) {
		ValaCCodeExpression* valuecast = NULL;
		ValaCastExpression* _tmp7_;
		ValaExpression* _tmp8_;
		ValaExpression* _tmp9_;
		ValaCCodeExpression* _tmp10_;
		ValaCCodeExpression* _tmp11_;
		ValaCastExpression* _tmp12_;
		ValaExpression* _tmp13_;
		ValaExpression* _tmp14_;
		ValaDataType* _tmp15_;
		ValaDataType* _tmp16_;
		ValaCastExpression* _tmp17_;
		ValaDataType* _tmp18_;
		ValaDataType* _tmp19_;
		ValaCastExpression* _tmp20_;
		ValaCCodeExpression* _tmp21_;
		ValaCCodeExpression* _tmp22_;
		ValaCCodeExpression* _tmp23_;
		ValaTargetValue* variantcast = NULL;
		ValaCastExpression* _tmp26_;
		ValaExpression* _tmp27_;
		ValaExpression* _tmp28_;
		ValaTargetValue* _tmp29_;
		ValaTargetValue* _tmp30_;
		ValaCastExpression* _tmp31_;
		ValaDataType* _tmp32_;
		ValaDataType* _tmp33_;
		ValaCastExpression* _tmp34_;
		ValaTargetValue* _tmp35_;
		ValaTargetValue* _tmp36_;
		_tmp7_ = expr;
		_tmp8_ = vala_cast_expression_get_inner (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = vala_ccode_base_module_get_cvalue (self, _tmp9_);
		_tmp11_ = _tmp10_;
		_tmp12_ = expr;
		_tmp13_ = vala_cast_expression_get_inner (_tmp12_);
		_tmp14_ = _tmp13_;
		_tmp15_ = vala_expression_get_value_type (_tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = expr;
		_tmp18_ = vala_cast_expression_get_type_reference (_tmp17_);
		_tmp19_ = _tmp18_;
		_tmp20_ = expr;
		_tmp21_ = vala_ccode_base_module_try_cast_value_to_type (self, _tmp11_, _tmp16_, _tmp19_, (ValaExpression*) _tmp20_);
		_tmp22_ = _tmp21_;
		_vala_ccode_node_unref0 (_tmp11_);
		valuecast = _tmp22_;
		_tmp23_ = valuecast;
		if (_tmp23_ != NULL) {
			ValaCastExpression* _tmp24_;
			ValaCCodeExpression* _tmp25_;
			_tmp24_ = expr;
			_tmp25_ = valuecast;
			vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp24_, _tmp25_);
			_vala_ccode_node_unref0 (valuecast);
			return;
		}
		_tmp26_ = expr;
		_tmp27_ = vala_cast_expression_get_inner (_tmp26_);
		_tmp28_ = _tmp27_;
		_tmp29_ = vala_expression_get_target_value (_tmp28_);
		_tmp30_ = _tmp29_;
		_tmp31_ = expr;
		_tmp32_ = vala_cast_expression_get_type_reference (_tmp31_);
		_tmp33_ = _tmp32_;
		_tmp34_ = expr;
		_tmp35_ = vala_ccode_base_module_try_cast_variant_to_type (self, _tmp30_, _tmp33_, (ValaCodeNode*) _tmp34_);
		variantcast = _tmp35_;
		_tmp36_ = variantcast;
		if (_tmp36_ != NULL) {
			ValaCastExpression* _tmp37_;
			ValaTargetValue* _tmp38_;
			_tmp37_ = expr;
			_tmp38_ = variantcast;
			vala_expression_set_target_value ((ValaExpression*) _tmp37_, _tmp38_);
			_vala_target_value_unref0 (variantcast);
			_vala_ccode_node_unref0 (valuecast);
			return;
		}
		_vala_target_value_unref0 (variantcast);
		_vala_ccode_node_unref0 (valuecast);
	}
	_tmp39_ = expr;
	_tmp40_ = vala_cast_expression_get_type_reference (_tmp39_);
	_tmp41_ = _tmp40_;
	_tmp42_ = vala_data_type_get_data_type (_tmp41_);
	_tmp43_ = _tmp42_;
	_tmp44_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp43_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp43_) : NULL);
	cl = _tmp44_;
	_tmp45_ = expr;
	_tmp46_ = vala_cast_expression_get_type_reference (_tmp45_);
	_tmp47_ = _tmp46_;
	_tmp48_ = vala_data_type_get_data_type (_tmp47_);
	_tmp49_ = _tmp48_;
	_tmp50_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp49_, VALA_TYPE_INTERFACE) ? ((ValaInterface*) _tmp49_) : NULL);
	iface = _tmp50_;
	_tmp52_ = iface;
	if (_tmp52_ != NULL) {
		_tmp51_ = TRUE;
	} else {
		gboolean _tmp53_ = FALSE;
		ValaClass* _tmp54_;
		_tmp54_ = cl;
		if (_tmp54_ != NULL) {
			ValaClass* _tmp55_;
			gboolean _tmp56_;
			gboolean _tmp57_;
			_tmp55_ = cl;
			_tmp56_ = vala_class_get_is_compact (_tmp55_);
			_tmp57_ = _tmp56_;
			_tmp53_ = !_tmp57_;
		} else {
			_tmp53_ = FALSE;
		}
		_tmp51_ = _tmp53_;
	}
	if (_tmp51_) {
		ValaCastExpression* _tmp58_;
		gboolean _tmp59_;
		gboolean _tmp60_;
		_tmp58_ = expr;
		_tmp59_ = vala_cast_expression_get_is_silent_cast (_tmp58_);
		_tmp60_ = _tmp59_;
		if (_tmp60_) {
			ValaTargetValue* to_cast = NULL;
			ValaCastExpression* _tmp61_;
			ValaExpression* _tmp62_;
			ValaExpression* _tmp63_;
			ValaTargetValue* _tmp64_;
			ValaTargetValue* _tmp65_;
			ValaTargetValue* _tmp66_;
			ValaCCodeExpression* cexpr = NULL;
			ValaTargetValue* _tmp67_;
			gboolean _tmp68_;
			ValaTargetValue* _tmp72_;
			ValaCCodeExpression* _tmp73_;
			ValaCCodeExpression* ccheck = NULL;
			ValaCCodeExpression* _tmp74_;
			ValaCastExpression* _tmp75_;
			ValaDataType* _tmp76_;
			ValaDataType* _tmp77_;
			ValaCCodeExpression* _tmp78_;
			ValaCCodeCastExpression* ccast = NULL;
			ValaCCodeExpression* _tmp79_;
			ValaCastExpression* _tmp80_;
			ValaDataType* _tmp81_;
			ValaDataType* _tmp82_;
			gchar* _tmp83_;
			gchar* _tmp84_;
			ValaCCodeCastExpression* _tmp85_;
			ValaCCodeCastExpression* _tmp86_;
			ValaCCodeConstant* cnull = NULL;
			ValaCCodeConstant* _tmp87_;
			ValaGLibValue* cast_value = NULL;
			ValaCastExpression* _tmp88_;
			ValaDataType* _tmp89_;
			ValaDataType* _tmp90_;
			ValaCCodeExpression* _tmp91_;
			ValaCCodeCastExpression* _tmp92_;
			ValaCCodeConstant* _tmp93_;
			ValaCCodeConditionalExpression* _tmp94_;
			ValaCCodeConditionalExpression* _tmp95_;
			ValaGLibValue* _tmp96_;
			ValaGLibValue* _tmp97_;
			ValaCastExpression* _tmp98_;
			ValaExpression* _tmp99_;
			ValaExpression* _tmp100_;
			ValaDataType* _tmp101_;
			ValaDataType* _tmp102_;
			gboolean _tmp103_;
			_tmp61_ = expr;
			_tmp62_ = vala_cast_expression_get_inner (_tmp61_);
			_tmp63_ = _tmp62_;
			_tmp64_ = vala_expression_get_target_value (_tmp63_);
			_tmp65_ = _tmp64_;
			_tmp66_ = _vala_target_value_ref0 (_tmp65_);
			to_cast = _tmp66_;
			_tmp67_ = to_cast;
			_tmp68_ = vala_ccode_base_module_get_lvalue (self, _tmp67_);
			if (!_tmp68_) {
				ValaTargetValue* _tmp69_;
				ValaCastExpression* _tmp70_;
				ValaTargetValue* _tmp71_;
				_tmp69_ = to_cast;
				_tmp70_ = expr;
				_tmp71_ = vala_ccode_base_module_store_temp_value (self, _tmp69_, (ValaCodeNode*) _tmp70_, NULL);
				_vala_target_value_unref0 (to_cast);
				to_cast = _tmp71_;
			}
			_tmp72_ = to_cast;
			_tmp73_ = vala_ccode_base_module_get_cvalue_ (self, _tmp72_);
			_vala_ccode_node_unref0 (cexpr);
			cexpr = _tmp73_;
			_tmp74_ = cexpr;
			_tmp75_ = expr;
			_tmp76_ = vala_cast_expression_get_type_reference (_tmp75_);
			_tmp77_ = _tmp76_;
			_tmp78_ = vala_ccode_base_module_create_type_check (self, (ValaCCodeNode*) _tmp74_, _tmp77_);
			ccheck = _tmp78_;
			_tmp79_ = cexpr;
			_tmp80_ = expr;
			_tmp81_ = vala_cast_expression_get_type_reference (_tmp80_);
			_tmp82_ = _tmp81_;
			_tmp83_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp82_);
			_tmp84_ = _tmp83_;
			_tmp85_ = vala_ccode_cast_expression_new (_tmp79_, _tmp84_);
			_tmp86_ = _tmp85_;
			_g_free0 (_tmp84_);
			ccast = _tmp86_;
			_tmp87_ = vala_ccode_constant_new ("NULL");
			cnull = _tmp87_;
			_tmp88_ = expr;
			_tmp89_ = vala_expression_get_value_type ((ValaExpression*) _tmp88_);
			_tmp90_ = _tmp89_;
			_tmp91_ = ccheck;
			_tmp92_ = ccast;
			_tmp93_ = cnull;
			_tmp94_ = vala_ccode_conditional_expression_new (_tmp91_, (ValaCCodeExpression*) _tmp92_, (ValaCCodeExpression*) _tmp93_);
			_tmp95_ = _tmp94_;
			_tmp96_ = vala_glib_value_new (_tmp90_, (ValaCCodeExpression*) _tmp95_, FALSE);
			_tmp97_ = _tmp96_;
			_vala_ccode_node_unref0 (_tmp95_);
			cast_value = _tmp97_;
			_tmp98_ = expr;
			_tmp99_ = vala_cast_expression_get_inner (_tmp98_);
			_tmp100_ = _tmp99_;
			_tmp101_ = vala_expression_get_value_type (_tmp100_);
			_tmp102_ = _tmp101_;
			_tmp103_ = vala_ccode_base_module_requires_destroy (self, _tmp102_);
			if (_tmp103_) {
				ValaTargetValue* casted = NULL;
				ValaGLibValue* _tmp104_;
				ValaCastExpression* _tmp105_;
				ValaTargetValue* _tmp106_;
				ValaCCodeFunction* _tmp107_;
				ValaCCodeFunction* _tmp108_;
				ValaTargetValue* _tmp109_;
				ValaCCodeExpression* _tmp110_;
				ValaCCodeExpression* _tmp111_;
				ValaCCodeConstant* _tmp112_;
				ValaCCodeConstant* _tmp113_;
				ValaCCodeBinaryExpression* _tmp114_;
				ValaCCodeBinaryExpression* _tmp115_;
				ValaCCodeFunction* _tmp116_;
				ValaCCodeFunction* _tmp117_;
				ValaTargetValue* _tmp118_;
				ValaCCodeExpression* _tmp119_;
				ValaCCodeExpression* _tmp120_;
				ValaCCodeFunction* _tmp121_;
				ValaCCodeFunction* _tmp122_;
				ValaCastExpression* _tmp123_;
				ValaTargetValue* _tmp124_;
				ValaGLibValue* _tmp125_;
				ValaGLibValue* _tmp126_;
				_tmp104_ = cast_value;
				_tmp105_ = expr;
				_tmp106_ = vala_ccode_base_module_store_temp_value (self, (ValaTargetValue*) _tmp104_, (ValaCodeNode*) _tmp105_, NULL);
				casted = _tmp106_;
				_tmp107_ = vala_ccode_base_module_get_ccode (self);
				_tmp108_ = _tmp107_;
				_tmp109_ = casted;
				_tmp110_ = vala_ccode_base_module_get_cvalue_ (self, _tmp109_);
				_tmp111_ = _tmp110_;
				_tmp112_ = vala_ccode_constant_new ("NULL");
				_tmp113_ = _tmp112_;
				_tmp114_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, _tmp111_, (ValaCCodeExpression*) _tmp113_);
				_tmp115_ = _tmp114_;
				vala_ccode_function_open_if (_tmp108_, (ValaCCodeExpression*) _tmp115_);
				_vala_ccode_node_unref0 (_tmp115_);
				_vala_ccode_node_unref0 (_tmp113_);
				_vala_ccode_node_unref0 (_tmp111_);
				_tmp116_ = vala_ccode_base_module_get_ccode (self);
				_tmp117_ = _tmp116_;
				_tmp118_ = to_cast;
				_tmp119_ = vala_ccode_base_module_destroy_value (self, _tmp118_, FALSE);
				_tmp120_ = _tmp119_;
				vala_ccode_function_add_expression (_tmp117_, _tmp120_);
				_vala_ccode_node_unref0 (_tmp120_);
				_tmp121_ = vala_ccode_base_module_get_ccode (self);
				_tmp122_ = _tmp121_;
				vala_ccode_function_close (_tmp122_);
				_tmp123_ = expr;
				_tmp124_ = casted;
				_tmp125_ = vala_glib_value_copy (G_TYPE_CHECK_INSTANCE_CAST (_tmp124_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
				_tmp126_ = _tmp125_;
				vala_expression_set_target_value ((ValaExpression*) _tmp123_, (ValaTargetValue*) _tmp126_);
				_vala_target_value_unref0 (_tmp126_);
				_vala_target_value_unref0 (casted);
			} else {
				ValaCastExpression* _tmp127_;
				ValaGLibValue* _tmp128_;
				_tmp127_ = expr;
				_tmp128_ = cast_value;
				vala_expression_set_target_value ((ValaExpression*) _tmp127_, (ValaTargetValue*) _tmp128_);
			}
			_vala_target_value_unref0 (cast_value);
			_vala_ccode_node_unref0 (cnull);
			_vala_ccode_node_unref0 (ccast);
			_vala_ccode_node_unref0 (ccheck);
			_vala_ccode_node_unref0 (cexpr);
			_vala_target_value_unref0 (to_cast);
		} else {
			ValaCastExpression* _tmp129_;
			ValaCastExpression* _tmp130_;
			ValaExpression* _tmp131_;
			ValaExpression* _tmp132_;
			ValaCCodeExpression* _tmp133_;
			ValaCCodeExpression* _tmp134_;
			ValaCastExpression* _tmp135_;
			ValaDataType* _tmp136_;
			ValaDataType* _tmp137_;
			ValaTypeSymbol* _tmp138_;
			ValaTypeSymbol* _tmp139_;
			ValaCCodeFunctionCall* _tmp140_;
			ValaCCodeFunctionCall* _tmp141_;
			_tmp129_ = expr;
			_tmp130_ = expr;
			_tmp131_ = vala_cast_expression_get_inner (_tmp130_);
			_tmp132_ = _tmp131_;
			_tmp133_ = vala_ccode_base_module_get_cvalue (self, _tmp132_);
			_tmp134_ = _tmp133_;
			_tmp135_ = expr;
			_tmp136_ = vala_cast_expression_get_type_reference (_tmp135_);
			_tmp137_ = _tmp136_;
			_tmp138_ = vala_data_type_get_data_type (_tmp137_);
			_tmp139_ = _tmp138_;
			_tmp140_ = vala_ccode_base_module_generate_instance_cast (self, _tmp134_, _tmp139_);
			_tmp141_ = _tmp140_;
			vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp129_, (ValaCCodeExpression*) _tmp141_);
			_vala_ccode_node_unref0 (_tmp141_);
			_vala_ccode_node_unref0 (_tmp134_);
		}
	} else {
		ValaCastExpression* _tmp142_;
		gboolean _tmp143_;
		gboolean _tmp144_;
		ValaArrayType* array_type = NULL;
		ValaCastExpression* _tmp152_;
		ValaDataType* _tmp153_;
		ValaDataType* _tmp154_;
		ValaArrayType* _tmp155_;
		gboolean _tmp156_ = FALSE;
		ValaArrayType* _tmp157_;
		ValaCCodeExpression* innercexpr = NULL;
		ValaCastExpression* _tmp300_;
		ValaExpression* _tmp301_;
		ValaExpression* _tmp302_;
		ValaCCodeExpression* _tmp303_;
		gboolean _tmp304_ = FALSE;
		gboolean _tmp305_ = FALSE;
		gboolean _tmp306_ = FALSE;
		ValaCastExpression* _tmp307_;
		ValaDataType* _tmp308_;
		ValaDataType* _tmp309_;
		ValaCastExpression* _tmp348_;
		ValaCCodeExpression* _tmp349_;
		ValaCastExpression* _tmp350_;
		ValaDataType* _tmp351_;
		ValaDataType* _tmp352_;
		gchar* _tmp353_;
		gchar* _tmp354_;
		ValaCCodeCastExpression* _tmp355_;
		ValaCCodeCastExpression* _tmp356_;
		ValaCastExpression* _tmp357_;
		ValaDataType* _tmp358_;
		ValaDataType* _tmp359_;
		_tmp142_ = expr;
		_tmp143_ = vala_cast_expression_get_is_silent_cast (_tmp142_);
		_tmp144_ = _tmp143_;
		if (_tmp144_) {
			ValaCastExpression* _tmp145_;
			ValaCCodeInvalidExpression* _tmp146_;
			ValaCCodeInvalidExpression* _tmp147_;
			ValaCastExpression* _tmp148_;
			ValaCastExpression* _tmp149_;
			ValaSourceReference* _tmp150_;
			ValaSourceReference* _tmp151_;
			_tmp145_ = expr;
			_tmp146_ = vala_ccode_invalid_expression_new ();
			_tmp147_ = _tmp146_;
			vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp145_, (ValaCCodeExpression*) _tmp147_);
			_vala_ccode_node_unref0 (_tmp147_);
			_tmp148_ = expr;
			vala_code_node_set_error ((ValaCodeNode*) _tmp148_, TRUE);
			_tmp149_ = expr;
			_tmp150_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp149_);
			_tmp151_ = _tmp150_;
			vala_report_error (_tmp151_, "Operation not supported for this type");
			_vala_code_node_unref0 (iface);
			_vala_code_node_unref0 (cl);
			return;
		}
		_tmp152_ = expr;
		_tmp153_ = vala_cast_expression_get_type_reference (_tmp152_);
		_tmp154_ = _tmp153_;
		_tmp155_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp154_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp154_) : NULL);
		array_type = _tmp155_;
		_tmp157_ = array_type;
		if (_tmp157_ != NULL) {
			ValaCastExpression* _tmp158_;
			ValaExpression* _tmp159_;
			ValaExpression* _tmp160_;
			ValaDataType* _tmp161_;
			ValaDataType* _tmp162_;
			_tmp158_ = expr;
			_tmp159_ = vala_cast_expression_get_inner (_tmp158_);
			_tmp160_ = _tmp159_;
			_tmp161_ = vala_expression_get_value_type (_tmp160_);
			_tmp162_ = _tmp161_;
			_tmp156_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp162_, VALA_TYPE_ARRAY_TYPE);
		} else {
			_tmp156_ = FALSE;
		}
		if (_tmp156_) {
			gboolean _tmp163_ = FALSE;
			ValaArrayType* _tmp164_;
			ValaDataType* _tmp165_;
			ValaDataType* _tmp166_;
			_tmp164_ = array_type;
			_tmp165_ = vala_array_type_get_element_type (_tmp164_);
			_tmp166_ = _tmp165_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp166_, VALA_TYPE_GENERIC_TYPE)) {
				_tmp163_ = TRUE;
			} else {
				ValaCastExpression* _tmp167_;
				ValaExpression* _tmp168_;
				ValaExpression* _tmp169_;
				ValaDataType* _tmp170_;
				ValaDataType* _tmp171_;
				ValaDataType* _tmp172_;
				ValaDataType* _tmp173_;
				_tmp167_ = expr;
				_tmp168_ = vala_cast_expression_get_inner (_tmp167_);
				_tmp169_ = _tmp168_;
				_tmp170_ = vala_expression_get_value_type (_tmp169_);
				_tmp171_ = _tmp170_;
				_tmp172_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp171_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
				_tmp173_ = _tmp172_;
				_tmp163_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp173_, VALA_TYPE_GENERIC_TYPE);
			}
			if (_tmp163_) {
				{
					gint dim = 0;
					dim = 1;
					{
						gboolean _tmp174_ = FALSE;
						_tmp174_ = TRUE;
						while (TRUE) {
							gint _tmp176_;
							ValaArrayType* _tmp177_;
							gint _tmp178_;
							gint _tmp179_;
							ValaCastExpression* _tmp180_;
							ValaCastExpression* _tmp181_;
							ValaExpression* _tmp182_;
							ValaExpression* _tmp183_;
							gint _tmp184_;
							ValaCCodeExpression* _tmp185_;
							ValaCCodeExpression* _tmp186_;
							if (!_tmp174_) {
								gint _tmp175_;
								_tmp175_ = dim;
								dim = _tmp175_ + 1;
							}
							_tmp174_ = FALSE;
							_tmp176_ = dim;
							_tmp177_ = array_type;
							_tmp178_ = vala_array_type_get_rank (_tmp177_);
							_tmp179_ = _tmp178_;
							if (!(_tmp176_ <= _tmp179_)) {
								break;
							}
							_tmp180_ = expr;
							_tmp181_ = expr;
							_tmp182_ = vala_cast_expression_get_inner (_tmp181_);
							_tmp183_ = _tmp182_;
							_tmp184_ = dim;
							_tmp185_ = vala_ccode_base_module_get_array_length_cexpression (self, _tmp183_, _tmp184_);
							_tmp186_ = _tmp185_;
							vala_ccode_base_module_append_array_length (self, (ValaExpression*) _tmp180_, _tmp186_);
							_vala_ccode_node_unref0 (_tmp186_);
						}
					}
				}
			} else {
				ValaCCodeFunctionCall* sizeof_to = NULL;
				ValaCCodeIdentifier* _tmp187_;
				ValaCCodeIdentifier* _tmp188_;
				ValaCCodeFunctionCall* _tmp189_;
				ValaCCodeFunctionCall* _tmp190_;
				ValaCCodeFunctionCall* _tmp191_;
				ValaArrayType* _tmp192_;
				ValaDataType* _tmp193_;
				ValaDataType* _tmp194_;
				gchar* _tmp195_;
				gchar* _tmp196_;
				ValaCCodeConstant* _tmp197_;
				ValaCCodeConstant* _tmp198_;
				ValaCCodeFunctionCall* sizeof_from = NULL;
				ValaCCodeIdentifier* _tmp199_;
				ValaCCodeIdentifier* _tmp200_;
				ValaCCodeFunctionCall* _tmp201_;
				ValaCCodeFunctionCall* _tmp202_;
				ValaCCodeFunctionCall* _tmp203_;
				ValaCastExpression* _tmp204_;
				ValaExpression* _tmp205_;
				ValaExpression* _tmp206_;
				ValaDataType* _tmp207_;
				ValaDataType* _tmp208_;
				ValaDataType* _tmp209_;
				ValaDataType* _tmp210_;
				gchar* _tmp211_;
				gchar* _tmp212_;
				ValaCCodeConstant* _tmp213_;
				ValaCCodeConstant* _tmp214_;
				_tmp187_ = vala_ccode_identifier_new ("sizeof");
				_tmp188_ = _tmp187_;
				_tmp189_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp188_);
				_tmp190_ = _tmp189_;
				_vala_ccode_node_unref0 (_tmp188_);
				sizeof_to = _tmp190_;
				_tmp191_ = sizeof_to;
				_tmp192_ = array_type;
				_tmp193_ = vala_array_type_get_element_type (_tmp192_);
				_tmp194_ = _tmp193_;
				_tmp195_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp194_);
				_tmp196_ = _tmp195_;
				_tmp197_ = vala_ccode_constant_new (_tmp196_);
				_tmp198_ = _tmp197_;
				vala_ccode_function_call_add_argument (_tmp191_, (ValaCCodeExpression*) _tmp198_);
				_vala_ccode_node_unref0 (_tmp198_);
				_g_free0 (_tmp196_);
				_tmp199_ = vala_ccode_identifier_new ("sizeof");
				_tmp200_ = _tmp199_;
				_tmp201_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp200_);
				_tmp202_ = _tmp201_;
				_vala_ccode_node_unref0 (_tmp200_);
				sizeof_from = _tmp202_;
				_tmp203_ = sizeof_from;
				_tmp204_ = expr;
				_tmp205_ = vala_cast_expression_get_inner (_tmp204_);
				_tmp206_ = _tmp205_;
				_tmp207_ = vala_expression_get_value_type (_tmp206_);
				_tmp208_ = _tmp207_;
				_tmp209_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp208_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
				_tmp210_ = _tmp209_;
				_tmp211_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp210_);
				_tmp212_ = _tmp211_;
				_tmp213_ = vala_ccode_constant_new (_tmp212_);
				_tmp214_ = _tmp213_;
				vala_ccode_function_call_add_argument (_tmp203_, (ValaCCodeExpression*) _tmp214_);
				_vala_ccode_node_unref0 (_tmp214_);
				_g_free0 (_tmp212_);
				{
					gint dim = 0;
					dim = 1;
					{
						gboolean _tmp215_ = FALSE;
						_tmp215_ = TRUE;
						while (TRUE) {
							gint _tmp217_;
							ValaArrayType* _tmp218_;
							gint _tmp219_;
							gint _tmp220_;
							ValaCastExpression* _tmp221_;
							ValaCastExpression* _tmp222_;
							ValaExpression* _tmp223_;
							ValaExpression* _tmp224_;
							gint _tmp225_;
							ValaCCodeExpression* _tmp226_;
							ValaCCodeExpression* _tmp227_;
							ValaCCodeFunctionCall* _tmp228_;
							ValaCCodeBinaryExpression* _tmp229_;
							ValaCCodeBinaryExpression* _tmp230_;
							ValaCCodeFunctionCall* _tmp231_;
							ValaCCodeBinaryExpression* _tmp232_;
							ValaCCodeBinaryExpression* _tmp233_;
							if (!_tmp215_) {
								gint _tmp216_;
								_tmp216_ = dim;
								dim = _tmp216_ + 1;
							}
							_tmp215_ = FALSE;
							_tmp217_ = dim;
							_tmp218_ = array_type;
							_tmp219_ = vala_array_type_get_rank (_tmp218_);
							_tmp220_ = _tmp219_;
							if (!(_tmp217_ <= _tmp220_)) {
								break;
							}
							_tmp221_ = expr;
							_tmp222_ = expr;
							_tmp223_ = vala_cast_expression_get_inner (_tmp222_);
							_tmp224_ = _tmp223_;
							_tmp225_ = dim;
							_tmp226_ = vala_ccode_base_module_get_array_length_cexpression (self, _tmp224_, _tmp225_);
							_tmp227_ = _tmp226_;
							_tmp228_ = sizeof_from;
							_tmp229_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, _tmp227_, (ValaCCodeExpression*) _tmp228_);
							_tmp230_ = _tmp229_;
							_tmp231_ = sizeof_to;
							_tmp232_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_DIV, (ValaCCodeExpression*) _tmp230_, (ValaCCodeExpression*) _tmp231_);
							_tmp233_ = _tmp232_;
							vala_ccode_base_module_append_array_length (self, (ValaExpression*) _tmp221_, (ValaCCodeExpression*) _tmp233_);
							_vala_ccode_node_unref0 (_tmp233_);
							_vala_ccode_node_unref0 (_tmp230_);
							_vala_ccode_node_unref0 (_tmp227_);
						}
					}
				}
				_vala_ccode_node_unref0 (sizeof_from);
				_vala_ccode_node_unref0 (sizeof_to);
			}
		} else {
			ValaArrayType* _tmp234_;
			_tmp234_ = array_type;
			if (_tmp234_ != NULL) {
				ValaCCodeExpression* array_length_expr = NULL;
				ValaCCodeFunctionCall* sizeof_to = NULL;
				ValaCCodeIdentifier* _tmp235_;
				ValaCCodeIdentifier* _tmp236_;
				ValaCCodeFunctionCall* _tmp237_;
				ValaCCodeFunctionCall* _tmp238_;
				ValaCCodeFunctionCall* _tmp239_;
				ValaArrayType* _tmp240_;
				ValaDataType* _tmp241_;
				ValaDataType* _tmp242_;
				gchar* _tmp243_;
				gchar* _tmp244_;
				ValaCCodeConstant* _tmp245_;
				ValaCCodeConstant* _tmp246_;
				ValaCCodeFunctionCall* sizeof_from = NULL;
				ValaCCodeIdentifier* _tmp247_;
				ValaCCodeIdentifier* _tmp248_;
				ValaCCodeFunctionCall* _tmp249_;
				ValaCCodeFunctionCall* _tmp250_;
				ValaDataType* value_type = NULL;
				ValaCastExpression* _tmp251_;
				ValaExpression* _tmp252_;
				ValaExpression* _tmp253_;
				ValaDataType* _tmp254_;
				ValaDataType* _tmp255_;
				ValaDataType* _tmp256_;
				ValaDataType* _tmp257_;
				_tmp235_ = vala_ccode_identifier_new ("sizeof");
				_tmp236_ = _tmp235_;
				_tmp237_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp236_);
				_tmp238_ = _tmp237_;
				_vala_ccode_node_unref0 (_tmp236_);
				sizeof_to = _tmp238_;
				_tmp239_ = sizeof_to;
				_tmp240_ = array_type;
				_tmp241_ = vala_array_type_get_element_type (_tmp240_);
				_tmp242_ = _tmp241_;
				_tmp243_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp242_);
				_tmp244_ = _tmp243_;
				_tmp245_ = vala_ccode_constant_new (_tmp244_);
				_tmp246_ = _tmp245_;
				vala_ccode_function_call_add_argument (_tmp239_, (ValaCCodeExpression*) _tmp246_);
				_vala_ccode_node_unref0 (_tmp246_);
				_g_free0 (_tmp244_);
				_tmp247_ = vala_ccode_identifier_new ("sizeof");
				_tmp248_ = _tmp247_;
				_tmp249_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp248_);
				_tmp250_ = _tmp249_;
				_vala_ccode_node_unref0 (_tmp248_);
				sizeof_from = _tmp250_;
				_tmp251_ = expr;
				_tmp252_ = vala_cast_expression_get_inner (_tmp251_);
				_tmp253_ = _tmp252_;
				_tmp254_ = vala_expression_get_value_type (_tmp253_);
				_tmp255_ = _tmp254_;
				_tmp256_ = _vala_code_node_ref0 (_tmp255_);
				value_type = _tmp256_;
				_tmp257_ = value_type;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp257_, VALA_TYPE_VALUE_TYPE)) {
					ValaTypeSymbol* data_type = NULL;
					ValaDataType* _tmp258_;
					ValaTypeSymbol* _tmp259_;
					ValaTypeSymbol* _tmp260_;
					ValaTypeSymbol* _tmp261_;
					ValaCCodeFunctionCall* _tmp262_;
					ValaTypeSymbol* _tmp263_;
					gchar* _tmp264_;
					gchar* _tmp265_;
					ValaCCodeConstant* _tmp266_;
					ValaCCodeConstant* _tmp267_;
					ValaCCodeFunctionCall* _tmp268_;
					ValaCCodeFunctionCall* _tmp269_;
					ValaCCodeBinaryExpression* _tmp270_;
					_tmp258_ = value_type;
					_tmp259_ = vala_data_type_get_data_type ((ValaDataType*) G_TYPE_CHECK_INSTANCE_CAST (_tmp258_, VALA_TYPE_VALUE_TYPE, ValaValueType));
					_tmp260_ = _tmp259_;
					_tmp261_ = _vala_code_node_ref0 (_tmp260_);
					data_type = _tmp261_;
					_tmp262_ = sizeof_from;
					_tmp263_ = data_type;
					_tmp264_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp263_);
					_tmp265_ = _tmp264_;
					_tmp266_ = vala_ccode_constant_new (_tmp265_);
					_tmp267_ = _tmp266_;
					vala_ccode_function_call_add_argument (_tmp262_, (ValaCCodeExpression*) _tmp267_);
					_vala_ccode_node_unref0 (_tmp267_);
					_g_free0 (_tmp265_);
					_tmp268_ = sizeof_from;
					_tmp269_ = sizeof_to;
					_tmp270_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_DIV, (ValaCCodeExpression*) _tmp268_, (ValaCCodeExpression*) _tmp269_);
					_vala_ccode_node_unref0 (array_length_expr);
					array_length_expr = (ValaCCodeExpression*) _tmp270_;
					_vala_code_node_unref0 (data_type);
				} else {
					gboolean _tmp271_ = FALSE;
					ValaDataType* _tmp272_;
					_tmp272_ = value_type;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp272_, VALA_TYPE_POINTER_TYPE)) {
						ValaDataType* _tmp273_;
						ValaDataType* _tmp274_;
						ValaDataType* _tmp275_;
						_tmp273_ = value_type;
						_tmp274_ = vala_pointer_type_get_base_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp273_, VALA_TYPE_POINTER_TYPE, ValaPointerType));
						_tmp275_ = _tmp274_;
						_tmp271_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp275_, VALA_TYPE_VALUE_TYPE);
					} else {
						_tmp271_ = FALSE;
					}
					if (_tmp271_) {
						ValaTypeSymbol* data_type = NULL;
						ValaDataType* _tmp276_;
						ValaDataType* _tmp277_;
						ValaDataType* _tmp278_;
						ValaTypeSymbol* _tmp279_;
						ValaTypeSymbol* _tmp280_;
						ValaTypeSymbol* _tmp281_;
						ValaCCodeFunctionCall* _tmp282_;
						ValaTypeSymbol* _tmp283_;
						gchar* _tmp284_;
						gchar* _tmp285_;
						ValaCCodeConstant* _tmp286_;
						ValaCCodeConstant* _tmp287_;
						ValaCCodeFunctionCall* _tmp288_;
						ValaCCodeFunctionCall* _tmp289_;
						ValaCCodeBinaryExpression* _tmp290_;
						_tmp276_ = value_type;
						_tmp277_ = vala_pointer_type_get_base_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp276_, VALA_TYPE_POINTER_TYPE, ValaPointerType));
						_tmp278_ = _tmp277_;
						_tmp279_ = vala_data_type_get_data_type ((ValaDataType*) G_TYPE_CHECK_INSTANCE_CAST (_tmp278_, VALA_TYPE_VALUE_TYPE, ValaValueType));
						_tmp280_ = _tmp279_;
						_tmp281_ = _vala_code_node_ref0 (_tmp280_);
						data_type = _tmp281_;
						_tmp282_ = sizeof_from;
						_tmp283_ = data_type;
						_tmp284_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp283_);
						_tmp285_ = _tmp284_;
						_tmp286_ = vala_ccode_constant_new (_tmp285_);
						_tmp287_ = _tmp286_;
						vala_ccode_function_call_add_argument (_tmp282_, (ValaCCodeExpression*) _tmp287_);
						_vala_ccode_node_unref0 (_tmp287_);
						_g_free0 (_tmp285_);
						_tmp288_ = sizeof_from;
						_tmp289_ = sizeof_to;
						_tmp290_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_DIV, (ValaCCodeExpression*) _tmp288_, (ValaCCodeExpression*) _tmp289_);
						_vala_ccode_node_unref0 (array_length_expr);
						array_length_expr = (ValaCCodeExpression*) _tmp290_;
						_vala_code_node_unref0 (data_type);
					} else {
						ValaCCodeConstant* _tmp291_;
						_tmp291_ = vala_ccode_constant_new ("-1");
						_vala_ccode_node_unref0 (array_length_expr);
						array_length_expr = (ValaCCodeExpression*) _tmp291_;
					}
				}
				{
					gint dim = 0;
					dim = 1;
					{
						gboolean _tmp292_ = FALSE;
						_tmp292_ = TRUE;
						while (TRUE) {
							gint _tmp294_;
							ValaArrayType* _tmp295_;
							gint _tmp296_;
							gint _tmp297_;
							ValaCastExpression* _tmp298_;
							ValaCCodeExpression* _tmp299_;
							if (!_tmp292_) {
								gint _tmp293_;
								_tmp293_ = dim;
								dim = _tmp293_ + 1;
							}
							_tmp292_ = FALSE;
							_tmp294_ = dim;
							_tmp295_ = array_type;
							_tmp296_ = vala_array_type_get_rank (_tmp295_);
							_tmp297_ = _tmp296_;
							if (!(_tmp294_ <= _tmp297_)) {
								break;
							}
							_tmp298_ = expr;
							_tmp299_ = array_length_expr;
							vala_ccode_base_module_append_array_length (self, (ValaExpression*) _tmp298_, _tmp299_);
						}
					}
				}
				_vala_code_node_unref0 (value_type);
				_vala_ccode_node_unref0 (sizeof_from);
				_vala_ccode_node_unref0 (sizeof_to);
				_vala_ccode_node_unref0 (array_length_expr);
			}
		}
		_tmp300_ = expr;
		_tmp301_ = vala_cast_expression_get_inner (_tmp300_);
		_tmp302_ = _tmp301_;
		_tmp303_ = vala_ccode_base_module_get_cvalue (self, _tmp302_);
		innercexpr = _tmp303_;
		_tmp307_ = expr;
		_tmp308_ = vala_cast_expression_get_type_reference (_tmp307_);
		_tmp309_ = _tmp308_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp309_, VALA_TYPE_VALUE_TYPE)) {
			ValaCastExpression* _tmp310_;
			ValaDataType* _tmp311_;
			ValaDataType* _tmp312_;
			gboolean _tmp313_;
			gboolean _tmp314_;
			_tmp310_ = expr;
			_tmp311_ = vala_cast_expression_get_type_reference (_tmp310_);
			_tmp312_ = _tmp311_;
			_tmp313_ = vala_data_type_get_nullable (_tmp312_);
			_tmp314_ = _tmp313_;
			_tmp306_ = !_tmp314_;
		} else {
			_tmp306_ = FALSE;
		}
		if (_tmp306_) {
			ValaCastExpression* _tmp315_;
			ValaExpression* _tmp316_;
			ValaExpression* _tmp317_;
			ValaDataType* _tmp318_;
			ValaDataType* _tmp319_;
			_tmp315_ = expr;
			_tmp316_ = vala_cast_expression_get_inner (_tmp315_);
			_tmp317_ = _tmp316_;
			_tmp318_ = vala_expression_get_value_type (_tmp317_);
			_tmp319_ = _tmp318_;
			_tmp305_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp319_, VALA_TYPE_VALUE_TYPE);
		} else {
			_tmp305_ = FALSE;
		}
		if (_tmp305_) {
			ValaCastExpression* _tmp320_;
			ValaExpression* _tmp321_;
			ValaExpression* _tmp322_;
			ValaDataType* _tmp323_;
			ValaDataType* _tmp324_;
			gboolean _tmp325_;
			gboolean _tmp326_;
			_tmp320_ = expr;
			_tmp321_ = vala_cast_expression_get_inner (_tmp320_);
			_tmp322_ = _tmp321_;
			_tmp323_ = vala_expression_get_value_type (_tmp322_);
			_tmp324_ = _tmp323_;
			_tmp325_ = vala_data_type_get_nullable (_tmp324_);
			_tmp326_ = _tmp325_;
			_tmp304_ = _tmp326_;
		} else {
			_tmp304_ = FALSE;
		}
		if (_tmp304_) {
			ValaCCodeExpression* _tmp327_;
			ValaCCodeUnaryExpression* _tmp328_;
			_tmp327_ = innercexpr;
			_tmp328_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp327_);
			_vala_ccode_node_unref0 (innercexpr);
			innercexpr = (ValaCCodeExpression*) _tmp328_;
		} else {
			gboolean _tmp329_ = FALSE;
			gboolean _tmp330_ = FALSE;
			ValaCastExpression* _tmp331_;
			ValaDataType* _tmp332_;
			ValaDataType* _tmp333_;
			_tmp331_ = expr;
			_tmp332_ = vala_cast_expression_get_type_reference (_tmp331_);
			_tmp333_ = _tmp332_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp333_, VALA_TYPE_ARRAY_TYPE)) {
				ValaCastExpression* _tmp334_;
				ValaExpression* _tmp335_;
				ValaExpression* _tmp336_;
				ValaDataType* _tmp337_;
				ValaDataType* _tmp338_;
				_tmp334_ = expr;
				_tmp335_ = vala_cast_expression_get_inner (_tmp334_);
				_tmp336_ = _tmp335_;
				_tmp337_ = vala_expression_get_value_type (_tmp336_);
				_tmp338_ = _tmp337_;
				_tmp330_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp338_, VALA_TYPE_VALUE_TYPE);
			} else {
				_tmp330_ = FALSE;
			}
			if (_tmp330_) {
				ValaCastExpression* _tmp339_;
				ValaExpression* _tmp340_;
				ValaExpression* _tmp341_;
				ValaDataType* _tmp342_;
				ValaDataType* _tmp343_;
				gboolean _tmp344_;
				gboolean _tmp345_;
				_tmp339_ = expr;
				_tmp340_ = vala_cast_expression_get_inner (_tmp339_);
				_tmp341_ = _tmp340_;
				_tmp342_ = vala_expression_get_value_type (_tmp341_);
				_tmp343_ = _tmp342_;
				_tmp344_ = vala_data_type_get_nullable (_tmp343_);
				_tmp345_ = _tmp344_;
				_tmp329_ = !_tmp345_;
			} else {
				_tmp329_ = FALSE;
			}
			if (_tmp329_) {
				ValaCCodeExpression* _tmp346_;
				ValaCCodeUnaryExpression* _tmp347_;
				_tmp346_ = innercexpr;
				_tmp347_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp346_);
				_vala_ccode_node_unref0 (innercexpr);
				innercexpr = (ValaCCodeExpression*) _tmp347_;
			}
		}
		_tmp348_ = expr;
		_tmp349_ = innercexpr;
		_tmp350_ = expr;
		_tmp351_ = vala_cast_expression_get_type_reference (_tmp350_);
		_tmp352_ = _tmp351_;
		_tmp353_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp352_);
		_tmp354_ = _tmp353_;
		_tmp355_ = vala_ccode_cast_expression_new (_tmp349_, _tmp354_);
		_tmp356_ = _tmp355_;
		vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp348_, (ValaCCodeExpression*) _tmp356_);
		_vala_ccode_node_unref0 (_tmp356_);
		_g_free0 (_tmp354_);
		_tmp357_ = expr;
		_tmp358_ = vala_cast_expression_get_type_reference (_tmp357_);
		_tmp359_ = _tmp358_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp359_, VALA_TYPE_DELEGATE_TYPE)) {
			ValaCastExpression* _tmp360_;
			ValaExpression* _tmp361_;
			ValaExpression* _tmp362_;
			ValaCCodeExpression* _tmp363_;
			ValaCCodeExpression* _tmp364_;
			gboolean _tmp365_;
			ValaCastExpression* _tmp375_;
			ValaExpression* _tmp376_;
			ValaExpression* _tmp377_;
			ValaCCodeExpression* _tmp378_;
			ValaCCodeExpression* _tmp379_;
			gboolean _tmp380_;
			_tmp360_ = expr;
			_tmp361_ = vala_cast_expression_get_inner (_tmp360_);
			_tmp362_ = _tmp361_;
			_tmp363_ = vala_ccode_base_module_get_delegate_target (self, _tmp362_);
			_tmp364_ = _tmp363_;
			_tmp365_ = _tmp364_ != NULL;
			_vala_ccode_node_unref0 (_tmp364_);
			if (_tmp365_) {
				ValaCastExpression* _tmp366_;
				ValaCastExpression* _tmp367_;
				ValaExpression* _tmp368_;
				ValaExpression* _tmp369_;
				ValaCCodeExpression* _tmp370_;
				ValaCCodeExpression* _tmp371_;
				_tmp366_ = expr;
				_tmp367_ = expr;
				_tmp368_ = vala_cast_expression_get_inner (_tmp367_);
				_tmp369_ = _tmp368_;
				_tmp370_ = vala_ccode_base_module_get_delegate_target (self, _tmp369_);
				_tmp371_ = _tmp370_;
				vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp366_, _tmp371_);
				_vala_ccode_node_unref0 (_tmp371_);
			} else {
				ValaCastExpression* _tmp372_;
				ValaCCodeConstant* _tmp373_;
				ValaCCodeConstant* _tmp374_;
				_tmp372_ = expr;
				_tmp373_ = vala_ccode_constant_new ("NULL");
				_tmp374_ = _tmp373_;
				vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp372_, (ValaCCodeExpression*) _tmp374_);
				_vala_ccode_node_unref0 (_tmp374_);
			}
			_tmp375_ = expr;
			_tmp376_ = vala_cast_expression_get_inner (_tmp375_);
			_tmp377_ = _tmp376_;
			_tmp378_ = vala_ccode_base_module_get_delegate_target_destroy_notify (self, _tmp377_);
			_tmp379_ = _tmp378_;
			_tmp380_ = _tmp379_ != NULL;
			_vala_ccode_node_unref0 (_tmp379_);
			if (_tmp380_) {
				ValaCastExpression* _tmp381_;
				ValaCastExpression* _tmp382_;
				ValaExpression* _tmp383_;
				ValaExpression* _tmp384_;
				ValaCCodeExpression* _tmp385_;
				ValaCCodeExpression* _tmp386_;
				_tmp381_ = expr;
				_tmp382_ = expr;
				_tmp383_ = vala_cast_expression_get_inner (_tmp382_);
				_tmp384_ = _tmp383_;
				_tmp385_ = vala_ccode_base_module_get_delegate_target_destroy_notify (self, _tmp384_);
				_tmp386_ = _tmp385_;
				vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp381_, _tmp386_);
				_vala_ccode_node_unref0 (_tmp386_);
			} else {
				ValaCastExpression* _tmp387_;
				ValaCCodeConstant* _tmp388_;
				ValaCCodeConstant* _tmp389_;
				_tmp387_ = expr;
				_tmp388_ = vala_ccode_constant_new ("NULL");
				_tmp389_ = _tmp388_;
				vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp387_, (ValaCCodeExpression*) _tmp389_);
				_vala_ccode_node_unref0 (_tmp389_);
			}
		}
		_vala_ccode_node_unref0 (innercexpr);
		_vala_code_node_unref0 (array_type);
	}
	_vala_code_node_unref0 (iface);
	_vala_code_node_unref0 (cl);
}


static void vala_ccode_base_module_real_visit_named_argument (ValaCodeVisitor* base, ValaNamedArgument* expr) {
	ValaCCodeBaseModule * self;
	ValaNamedArgument* _tmp0_;
	ValaNamedArgument* _tmp1_;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	ValaCCodeExpression* _tmp5_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = expr;
	_tmp2_ = vala_named_argument_get_inner (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_base_module_get_cvalue (self, _tmp3_);
	_tmp5_ = _tmp4_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp0_, _tmp5_);
	_vala_ccode_node_unref0 (_tmp5_);
}


static void vala_ccode_base_module_real_visit_pointer_indirection (ValaCodeVisitor* base, ValaPointerIndirection* expr) {
	ValaCCodeBaseModule * self;
	ValaPointerIndirection* _tmp0_;
	ValaPointerIndirection* _tmp1_;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	ValaCCodeExpression* _tmp5_;
	ValaCCodeUnaryExpression* _tmp6_;
	ValaCCodeUnaryExpression* _tmp7_;
	ValaPointerIndirection* _tmp8_;
	ValaTargetValue* _tmp9_;
	ValaTargetValue* _tmp10_;
	ValaPointerIndirection* _tmp11_;
	ValaExpression* _tmp12_;
	ValaExpression* _tmp13_;
	ValaTargetValue* _tmp14_;
	ValaTargetValue* _tmp15_;
	gboolean _tmp16_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = expr;
	_tmp2_ = vala_pointer_indirection_get_inner (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_base_module_get_cvalue (self, _tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp5_);
	_tmp7_ = _tmp6_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp0_, (ValaCCodeExpression*) _tmp7_);
	_vala_ccode_node_unref0 (_tmp7_);
	_vala_ccode_node_unref0 (_tmp5_);
	_tmp8_ = expr;
	_tmp9_ = vala_expression_get_target_value ((ValaExpression*) _tmp8_);
	_tmp10_ = _tmp9_;
	_tmp11_ = expr;
	_tmp12_ = vala_pointer_indirection_get_inner (_tmp11_);
	_tmp13_ = _tmp12_;
	_tmp14_ = vala_expression_get_target_value (_tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = vala_ccode_base_module_get_lvalue (self, _tmp15_);
	G_TYPE_CHECK_INSTANCE_CAST (_tmp10_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = _tmp16_;
}


static void vala_ccode_base_module_real_visit_addressof_expression (ValaCodeVisitor* base, ValaAddressofExpression* expr) {
	ValaCCodeBaseModule * self;
	ValaAddressofExpression* _tmp0_;
	ValaAddressofExpression* _tmp1_;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	ValaCCodeExpression* _tmp5_;
	ValaCCodeUnaryExpression* _tmp6_;
	ValaCCodeUnaryExpression* _tmp7_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = expr;
	_tmp2_ = vala_addressof_expression_get_inner (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_base_module_get_cvalue (self, _tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp5_);
	_tmp7_ = _tmp6_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp0_, (ValaCCodeExpression*) _tmp7_);
	_vala_ccode_node_unref0 (_tmp7_);
	_vala_ccode_node_unref0 (_tmp5_);
}


static void vala_ccode_base_module_real_visit_reference_transfer_expression (ValaCodeVisitor* base, ValaReferenceTransferExpression* expr) {
	ValaCCodeBaseModule * self;
	ValaReferenceTransferExpression* _tmp0_;
	ValaReferenceTransferExpression* _tmp1_;
	ValaExpression* _tmp2_;
	ValaExpression* _tmp3_;
	ValaTargetValue* _tmp4_;
	ValaTargetValue* _tmp5_;
	ValaReferenceTransferExpression* _tmp6_;
	ValaTargetValue* _tmp7_;
	ValaTargetValue* _tmp8_;
	gboolean _tmp9_ = FALSE;
	ValaReferenceTransferExpression* _tmp10_;
	ValaExpression* _tmp11_;
	ValaExpression* _tmp12_;
	ValaDataType* _tmp13_;
	ValaDataType* _tmp14_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = expr;
	_tmp2_ = vala_reference_transfer_expression_get_inner (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_expression_get_target_value (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = expr;
	_tmp7_ = vala_ccode_base_module_store_temp_value (self, _tmp5_, (ValaCodeNode*) _tmp6_, NULL);
	_tmp8_ = _tmp7_;
	vala_expression_set_target_value ((ValaExpression*) _tmp0_, _tmp8_);
	_vala_target_value_unref0 (_tmp8_);
	_tmp10_ = expr;
	_tmp11_ = vala_reference_transfer_expression_get_inner (_tmp10_);
	_tmp12_ = _tmp11_;
	_tmp13_ = vala_expression_get_value_type (_tmp12_);
	_tmp14_ = _tmp13_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp14_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
		ValaReferenceTransferExpression* _tmp15_;
		ValaExpression* _tmp16_;
		ValaExpression* _tmp17_;
		ValaDataType* _tmp18_;
		ValaDataType* _tmp19_;
		gboolean _tmp20_;
		gboolean _tmp21_;
		_tmp15_ = expr;
		_tmp16_ = vala_reference_transfer_expression_get_inner (_tmp15_);
		_tmp17_ = _tmp16_;
		_tmp18_ = vala_expression_get_value_type (_tmp17_);
		_tmp19_ = _tmp18_;
		_tmp20_ = vala_data_type_get_nullable (_tmp19_);
		_tmp21_ = _tmp20_;
		_tmp9_ = !_tmp21_;
	} else {
		_tmp9_ = FALSE;
	}
	if (_tmp9_) {
		ValaCCodeFile* _tmp22_;
		ValaCCodeFunctionCall* creation_call = NULL;
		ValaCCodeIdentifier* _tmp23_;
		ValaCCodeIdentifier* _tmp24_;
		ValaCCodeFunctionCall* _tmp25_;
		ValaCCodeFunctionCall* _tmp26_;
		ValaCCodeFunctionCall* _tmp27_;
		ValaReferenceTransferExpression* _tmp28_;
		ValaExpression* _tmp29_;
		ValaExpression* _tmp30_;
		ValaCCodeExpression* _tmp31_;
		ValaCCodeExpression* _tmp32_;
		ValaCCodeUnaryExpression* _tmp33_;
		ValaCCodeUnaryExpression* _tmp34_;
		ValaCCodeFunctionCall* _tmp35_;
		ValaCCodeConstant* _tmp36_;
		ValaCCodeConstant* _tmp37_;
		ValaCCodeFunctionCall* _tmp38_;
		ValaReferenceTransferExpression* _tmp39_;
		ValaExpression* _tmp40_;
		ValaExpression* _tmp41_;
		ValaDataType* _tmp42_;
		ValaDataType* _tmp43_;
		gchar* _tmp44_;
		gchar* _tmp45_;
		gchar* _tmp46_;
		gchar* _tmp47_;
		ValaCCodeIdentifier* _tmp48_;
		ValaCCodeIdentifier* _tmp49_;
		ValaCCodeFunction* _tmp50_;
		ValaCCodeFunction* _tmp51_;
		ValaCCodeFunctionCall* _tmp52_;
		_tmp22_ = self->cfile;
		vala_ccode_file_add_include (_tmp22_, "string.h", FALSE);
		_tmp23_ = vala_ccode_identifier_new ("memset");
		_tmp24_ = _tmp23_;
		_tmp25_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp24_);
		_tmp26_ = _tmp25_;
		_vala_ccode_node_unref0 (_tmp24_);
		creation_call = _tmp26_;
		_tmp27_ = creation_call;
		_tmp28_ = expr;
		_tmp29_ = vala_reference_transfer_expression_get_inner (_tmp28_);
		_tmp30_ = _tmp29_;
		_tmp31_ = vala_ccode_base_module_get_cvalue (self, _tmp30_);
		_tmp32_ = _tmp31_;
		_tmp33_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp32_);
		_tmp34_ = _tmp33_;
		vala_ccode_function_call_add_argument (_tmp27_, (ValaCCodeExpression*) _tmp34_);
		_vala_ccode_node_unref0 (_tmp34_);
		_vala_ccode_node_unref0 (_tmp32_);
		_tmp35_ = creation_call;
		_tmp36_ = vala_ccode_constant_new ("0");
		_tmp37_ = _tmp36_;
		vala_ccode_function_call_add_argument (_tmp35_, (ValaCCodeExpression*) _tmp37_);
		_vala_ccode_node_unref0 (_tmp37_);
		_tmp38_ = creation_call;
		_tmp39_ = expr;
		_tmp40_ = vala_reference_transfer_expression_get_inner (_tmp39_);
		_tmp41_ = _tmp40_;
		_tmp42_ = vala_expression_get_value_type (_tmp41_);
		_tmp43_ = _tmp42_;
		_tmp44_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp43_);
		_tmp45_ = _tmp44_;
		_tmp46_ = g_strdup_printf ("sizeof (%s)", _tmp45_);
		_tmp47_ = _tmp46_;
		_tmp48_ = vala_ccode_identifier_new (_tmp47_);
		_tmp49_ = _tmp48_;
		vala_ccode_function_call_add_argument (_tmp38_, (ValaCCodeExpression*) _tmp49_);
		_vala_ccode_node_unref0 (_tmp49_);
		_g_free0 (_tmp47_);
		_g_free0 (_tmp45_);
		_tmp50_ = vala_ccode_base_module_get_ccode (self);
		_tmp51_ = _tmp50_;
		_tmp52_ = creation_call;
		vala_ccode_function_add_expression (_tmp51_, (ValaCCodeExpression*) _tmp52_);
		_vala_ccode_node_unref0 (creation_call);
	} else {
		ValaReferenceTransferExpression* _tmp53_;
		ValaDataType* _tmp54_;
		ValaDataType* _tmp55_;
		_tmp53_ = expr;
		_tmp54_ = vala_expression_get_value_type ((ValaExpression*) _tmp53_);
		_tmp55_ = _tmp54_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp55_, VALA_TYPE_DELEGATE_TYPE)) {
			ValaCCodeFunction* _tmp56_;
			ValaCCodeFunction* _tmp57_;
			ValaReferenceTransferExpression* _tmp58_;
			ValaExpression* _tmp59_;
			ValaExpression* _tmp60_;
			ValaCCodeExpression* _tmp61_;
			ValaCCodeExpression* _tmp62_;
			ValaCCodeConstant* _tmp63_;
			ValaCCodeConstant* _tmp64_;
			ValaCCodeExpression* target = NULL;
			ValaReferenceTransferExpression* _tmp65_;
			ValaExpression* _tmp66_;
			ValaExpression* _tmp67_;
			ValaTargetValue* _tmp68_;
			ValaTargetValue* _tmp69_;
			ValaCCodeExpression* _tmp70_;
			ValaCCodeExpression* _tmp71_;
			ValaCCodeExpression* target_destroy_notify = NULL;
			ValaReferenceTransferExpression* _tmp77_;
			ValaExpression* _tmp78_;
			ValaExpression* _tmp79_;
			ValaTargetValue* _tmp80_;
			ValaTargetValue* _tmp81_;
			ValaCCodeExpression* _tmp82_;
			ValaCCodeExpression* _tmp83_;
			_tmp56_ = vala_ccode_base_module_get_ccode (self);
			_tmp57_ = _tmp56_;
			_tmp58_ = expr;
			_tmp59_ = vala_reference_transfer_expression_get_inner (_tmp58_);
			_tmp60_ = _tmp59_;
			_tmp61_ = vala_ccode_base_module_get_cvalue (self, _tmp60_);
			_tmp62_ = _tmp61_;
			_tmp63_ = vala_ccode_constant_new ("NULL");
			_tmp64_ = _tmp63_;
			vala_ccode_function_add_assignment (_tmp57_, _tmp62_, (ValaCCodeExpression*) _tmp64_);
			_vala_ccode_node_unref0 (_tmp64_);
			_vala_ccode_node_unref0 (_tmp62_);
			_tmp65_ = expr;
			_tmp66_ = vala_reference_transfer_expression_get_inner (_tmp65_);
			_tmp67_ = _tmp66_;
			_tmp68_ = vala_expression_get_target_value (_tmp67_);
			_tmp69_ = _tmp68_;
			_tmp70_ = vala_ccode_base_module_get_delegate_target_cvalue (self, _tmp69_);
			target = _tmp70_;
			_tmp71_ = target;
			if (_tmp71_ != NULL) {
				ValaCCodeFunction* _tmp72_;
				ValaCCodeFunction* _tmp73_;
				ValaCCodeExpression* _tmp74_;
				ValaCCodeConstant* _tmp75_;
				ValaCCodeConstant* _tmp76_;
				_tmp72_ = vala_ccode_base_module_get_ccode (self);
				_tmp73_ = _tmp72_;
				_tmp74_ = target;
				_tmp75_ = vala_ccode_constant_new ("NULL");
				_tmp76_ = _tmp75_;
				vala_ccode_function_add_assignment (_tmp73_, _tmp74_, (ValaCCodeExpression*) _tmp76_);
				_vala_ccode_node_unref0 (_tmp76_);
			}
			_tmp77_ = expr;
			_tmp78_ = vala_reference_transfer_expression_get_inner (_tmp77_);
			_tmp79_ = _tmp78_;
			_tmp80_ = vala_expression_get_target_value (_tmp79_);
			_tmp81_ = _tmp80_;
			_tmp82_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp81_);
			target_destroy_notify = _tmp82_;
			_tmp83_ = target_destroy_notify;
			if (_tmp83_ != NULL) {
				ValaCCodeFunction* _tmp84_;
				ValaCCodeFunction* _tmp85_;
				ValaCCodeExpression* _tmp86_;
				ValaCCodeConstant* _tmp87_;
				ValaCCodeConstant* _tmp88_;
				_tmp84_ = vala_ccode_base_module_get_ccode (self);
				_tmp85_ = _tmp84_;
				_tmp86_ = target_destroy_notify;
				_tmp87_ = vala_ccode_constant_new ("NULL");
				_tmp88_ = _tmp87_;
				vala_ccode_function_add_assignment (_tmp85_, _tmp86_, (ValaCCodeExpression*) _tmp88_);
				_vala_ccode_node_unref0 (_tmp88_);
			}
			_vala_ccode_node_unref0 (target_destroy_notify);
			_vala_ccode_node_unref0 (target);
		} else {
			ValaReferenceTransferExpression* _tmp89_;
			ValaExpression* _tmp90_;
			ValaExpression* _tmp91_;
			ValaDataType* _tmp92_;
			ValaDataType* _tmp93_;
			_tmp89_ = expr;
			_tmp90_ = vala_reference_transfer_expression_get_inner (_tmp89_);
			_tmp91_ = _tmp90_;
			_tmp92_ = vala_expression_get_value_type (_tmp91_);
			_tmp93_ = _tmp92_;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp93_, VALA_TYPE_ARRAY_TYPE)) {
				ValaArrayType* array_type = NULL;
				ValaReferenceTransferExpression* _tmp94_;
				ValaExpression* _tmp95_;
				ValaExpression* _tmp96_;
				ValaDataType* _tmp97_;
				ValaDataType* _tmp98_;
				ValaArrayType* _tmp99_;
				ValaGLibValue* glib_value = NULL;
				ValaReferenceTransferExpression* _tmp100_;
				ValaExpression* _tmp101_;
				ValaExpression* _tmp102_;
				ValaTargetValue* _tmp103_;
				ValaTargetValue* _tmp104_;
				ValaGLibValue* _tmp105_;
				ValaCCodeFunction* _tmp106_;
				ValaCCodeFunction* _tmp107_;
				ValaReferenceTransferExpression* _tmp108_;
				ValaExpression* _tmp109_;
				ValaExpression* _tmp110_;
				ValaCCodeExpression* _tmp111_;
				ValaCCodeExpression* _tmp112_;
				ValaCCodeConstant* _tmp113_;
				ValaCCodeConstant* _tmp114_;
				ValaGLibValue* _tmp115_;
				ValaList* _tmp116_;
				_tmp94_ = expr;
				_tmp95_ = vala_reference_transfer_expression_get_inner (_tmp94_);
				_tmp96_ = _tmp95_;
				_tmp97_ = vala_expression_get_value_type (_tmp96_);
				_tmp98_ = _tmp97_;
				_tmp99_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp98_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
				array_type = _tmp99_;
				_tmp100_ = expr;
				_tmp101_ = vala_reference_transfer_expression_get_inner (_tmp100_);
				_tmp102_ = _tmp101_;
				_tmp103_ = vala_expression_get_target_value (_tmp102_);
				_tmp104_ = _tmp103_;
				_tmp105_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp104_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
				glib_value = _tmp105_;
				_tmp106_ = vala_ccode_base_module_get_ccode (self);
				_tmp107_ = _tmp106_;
				_tmp108_ = expr;
				_tmp109_ = vala_reference_transfer_expression_get_inner (_tmp108_);
				_tmp110_ = _tmp109_;
				_tmp111_ = vala_ccode_base_module_get_cvalue (self, _tmp110_);
				_tmp112_ = _tmp111_;
				_tmp113_ = vala_ccode_constant_new ("NULL");
				_tmp114_ = _tmp113_;
				vala_ccode_function_add_assignment (_tmp107_, _tmp112_, (ValaCCodeExpression*) _tmp114_);
				_vala_ccode_node_unref0 (_tmp114_);
				_vala_ccode_node_unref0 (_tmp112_);
				_tmp115_ = glib_value;
				_tmp116_ = _tmp115_->array_length_cvalues;
				if (_tmp116_ != NULL) {
					{
						gint dim = 0;
						dim = 1;
						{
							gboolean _tmp117_ = FALSE;
							_tmp117_ = TRUE;
							while (TRUE) {
								gint _tmp119_;
								ValaArrayType* _tmp120_;
								gint _tmp121_;
								gint _tmp122_;
								ValaCCodeFunction* _tmp123_;
								ValaCCodeFunction* _tmp124_;
								ValaGLibValue* _tmp125_;
								gint _tmp126_;
								ValaCCodeExpression* _tmp127_;
								ValaCCodeExpression* _tmp128_;
								ValaCCodeConstant* _tmp129_;
								ValaCCodeConstant* _tmp130_;
								if (!_tmp117_) {
									gint _tmp118_;
									_tmp118_ = dim;
									dim = _tmp118_ + 1;
								}
								_tmp117_ = FALSE;
								_tmp119_ = dim;
								_tmp120_ = array_type;
								_tmp121_ = vala_array_type_get_rank (_tmp120_);
								_tmp122_ = _tmp121_;
								if (!(_tmp119_ <= _tmp122_)) {
									break;
								}
								_tmp123_ = vala_ccode_base_module_get_ccode (self);
								_tmp124_ = _tmp123_;
								_tmp125_ = glib_value;
								_tmp126_ = dim;
								_tmp127_ = vala_ccode_base_module_get_array_length_cvalue (self, (ValaTargetValue*) _tmp125_, _tmp126_);
								_tmp128_ = _tmp127_;
								_tmp129_ = vala_ccode_constant_new ("0");
								_tmp130_ = _tmp129_;
								vala_ccode_function_add_assignment (_tmp124_, _tmp128_, (ValaCCodeExpression*) _tmp130_);
								_vala_ccode_node_unref0 (_tmp130_);
								_vala_ccode_node_unref0 (_tmp128_);
							}
						}
					}
				}
				_vala_target_value_unref0 (glib_value);
				_vala_code_node_unref0 (array_type);
			} else {
				ValaCCodeFunction* _tmp131_;
				ValaCCodeFunction* _tmp132_;
				ValaReferenceTransferExpression* _tmp133_;
				ValaExpression* _tmp134_;
				ValaExpression* _tmp135_;
				ValaCCodeExpression* _tmp136_;
				ValaCCodeExpression* _tmp137_;
				ValaCCodeConstant* _tmp138_;
				ValaCCodeConstant* _tmp139_;
				_tmp131_ = vala_ccode_base_module_get_ccode (self);
				_tmp132_ = _tmp131_;
				_tmp133_ = expr;
				_tmp134_ = vala_reference_transfer_expression_get_inner (_tmp133_);
				_tmp135_ = _tmp134_;
				_tmp136_ = vala_ccode_base_module_get_cvalue (self, _tmp135_);
				_tmp137_ = _tmp136_;
				_tmp138_ = vala_ccode_constant_new ("NULL");
				_tmp139_ = _tmp138_;
				vala_ccode_function_add_assignment (_tmp132_, _tmp137_, (ValaCCodeExpression*) _tmp139_);
				_vala_ccode_node_unref0 (_tmp139_);
				_vala_ccode_node_unref0 (_tmp137_);
			}
		}
	}
}


static void vala_ccode_base_module_real_visit_binary_expression (ValaCodeVisitor* base, ValaBinaryExpression* expr) {
	ValaCCodeBaseModule * self;
	ValaCCodeExpression* cleft = NULL;
	ValaBinaryExpression* _tmp0_;
	ValaExpression* _tmp1_;
	ValaExpression* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	ValaCCodeExpression* cright = NULL;
	ValaBinaryExpression* _tmp4_;
	ValaExpression* _tmp5_;
	ValaExpression* _tmp6_;
	ValaCCodeExpression* _tmp7_;
	ValaCCodeExpression* left_chain = NULL;
	ValaBinaryExpression* _tmp8_;
	gboolean _tmp9_;
	ValaCCodeBinaryOperator op = 0;
	ValaBinaryExpression* _tmp51_;
	ValaBinaryOperator _tmp52_;
	ValaBinaryOperator _tmp53_;
	gboolean _tmp185_ = FALSE;
	ValaBinaryExpression* _tmp186_;
	ValaBinaryOperator _tmp187_;
	ValaBinaryOperator _tmp188_;
	gboolean _tmp262_ = FALSE;
	gboolean _tmp263_ = FALSE;
	gboolean _tmp264_ = FALSE;
	ValaBinaryExpression* _tmp265_;
	ValaExpression* _tmp266_;
	ValaExpression* _tmp267_;
	ValaDataType* _tmp268_;
	ValaDataType* _tmp269_;
	ValaBinaryExpression* _tmp386_;
	ValaCCodeBinaryOperator _tmp387_;
	ValaCCodeExpression* _tmp388_;
	ValaCCodeExpression* _tmp389_;
	ValaCCodeBinaryExpression* _tmp390_;
	ValaCCodeBinaryExpression* _tmp391_;
	ValaCCodeExpression* _tmp392_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_binary_expression_get_left (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_cvalue (self, _tmp2_);
	cleft = _tmp3_;
	_tmp4_ = expr;
	_tmp5_ = vala_binary_expression_get_right (_tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = vala_ccode_base_module_get_cvalue (self, _tmp6_);
	cright = _tmp7_;
	left_chain = NULL;
	_tmp8_ = expr;
	_tmp9_ = _tmp8_->chained;
	if (_tmp9_) {
		ValaBinaryExpression* lbe = NULL;
		ValaBinaryExpression* _tmp10_;
		ValaExpression* _tmp11_;
		ValaExpression* _tmp12_;
		ValaBinaryExpression* _tmp13_;
		ValaLocalVariable* temp_decl = NULL;
		ValaBinaryExpression* _tmp14_;
		ValaExpression* _tmp15_;
		ValaExpression* _tmp16_;
		ValaDataType* _tmp17_;
		ValaDataType* _tmp18_;
		ValaLocalVariable* _tmp19_;
		ValaLocalVariable* _tmp20_;
		ValaCCodeExpression* cvar = NULL;
		ValaLocalVariable* _tmp21_;
		const gchar* _tmp22_;
		const gchar* _tmp23_;
		ValaCCodeExpression* _tmp24_;
		ValaCCodeBinaryExpression* clbe = NULL;
		ValaBinaryExpression* _tmp25_;
		ValaCCodeExpression* _tmp26_;
		ValaBinaryExpression* _tmp27_;
		gboolean _tmp28_;
		ValaCCodeFunction* _tmp33_;
		ValaCCodeFunction* _tmp34_;
		ValaCCodeExpression* _tmp35_;
		ValaBinaryExpression* _tmp36_;
		ValaExpression* _tmp37_;
		ValaExpression* _tmp38_;
		ValaCCodeExpression* _tmp39_;
		ValaCCodeExpression* _tmp40_;
		ValaCCodeBinaryExpression* _tmp41_;
		ValaLocalVariable* _tmp42_;
		const gchar* _tmp43_;
		const gchar* _tmp44_;
		ValaCCodeExpression* _tmp45_;
		ValaCCodeExpression* _tmp46_;
		ValaCCodeExpression* _tmp47_;
		ValaCCodeExpression* _tmp48_;
		ValaCCodeExpression* _tmp49_;
		ValaCCodeExpression* _tmp50_;
		_tmp10_ = expr;
		_tmp11_ = vala_binary_expression_get_left (_tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpression));
		lbe = _tmp13_;
		_tmp14_ = lbe;
		_tmp15_ = vala_binary_expression_get_right (_tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = vala_expression_get_target_type (_tmp16_);
		_tmp18_ = _tmp17_;
		_tmp19_ = vala_ccode_base_module_get_temp_variable (self, _tmp18_, TRUE, NULL, FALSE);
		temp_decl = _tmp19_;
		_tmp20_ = temp_decl;
		vala_ccode_base_module_emit_temp_var (self, _tmp20_);
		_tmp21_ = temp_decl;
		_tmp22_ = vala_symbol_get_name ((ValaSymbol*) _tmp21_);
		_tmp23_ = _tmp22_;
		_tmp24_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp23_);
		cvar = _tmp24_;
		_tmp25_ = lbe;
		_tmp26_ = vala_ccode_base_module_get_cvalue (self, (ValaExpression*) _tmp25_);
		clbe = G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_CCODE_BINARY_EXPRESSION, ValaCCodeBinaryExpression);
		_tmp27_ = lbe;
		_tmp28_ = _tmp27_->chained;
		if (_tmp28_) {
			ValaCCodeBinaryExpression* _tmp29_;
			ValaCCodeExpression* _tmp30_;
			ValaCCodeExpression* _tmp31_;
			ValaCCodeBinaryExpression* _tmp32_;
			_tmp29_ = clbe;
			_tmp30_ = vala_ccode_binary_expression_get_right (_tmp29_);
			_tmp31_ = _tmp30_;
			_tmp32_ = _vala_ccode_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp31_, VALA_TYPE_CCODE_BINARY_EXPRESSION, ValaCCodeBinaryExpression));
			_vala_ccode_node_unref0 (clbe);
			clbe = _tmp32_;
		}
		_tmp33_ = vala_ccode_base_module_get_ccode (self);
		_tmp34_ = _tmp33_;
		_tmp35_ = cvar;
		_tmp36_ = lbe;
		_tmp37_ = vala_binary_expression_get_right (_tmp36_);
		_tmp38_ = _tmp37_;
		_tmp39_ = vala_ccode_base_module_get_cvalue (self, _tmp38_);
		_tmp40_ = _tmp39_;
		vala_ccode_function_add_assignment (_tmp34_, _tmp35_, _tmp40_);
		_vala_ccode_node_unref0 (_tmp40_);
		_tmp41_ = clbe;
		_tmp42_ = temp_decl;
		_tmp43_ = vala_symbol_get_name ((ValaSymbol*) _tmp42_);
		_tmp44_ = _tmp43_;
		_tmp45_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp44_);
		_tmp46_ = _tmp45_;
		vala_ccode_binary_expression_set_right (_tmp41_, _tmp46_);
		_vala_ccode_node_unref0 (_tmp46_);
		_tmp47_ = cleft;
		_tmp48_ = _vala_ccode_node_ref0 (_tmp47_);
		_vala_ccode_node_unref0 (left_chain);
		left_chain = _tmp48_;
		_tmp49_ = cvar;
		_tmp50_ = _vala_ccode_node_ref0 (_tmp49_);
		_vala_ccode_node_unref0 (cleft);
		cleft = _tmp50_;
		_vala_ccode_node_unref0 (clbe);
		_vala_ccode_node_unref0 (cvar);
		_vala_code_node_unref0 (temp_decl);
		_vala_code_node_unref0 (lbe);
	}
	_tmp51_ = expr;
	_tmp52_ = vala_binary_expression_get_operator (_tmp51_);
	_tmp53_ = _tmp52_;
	if (_tmp53_ == VALA_BINARY_OPERATOR_PLUS) {
		op = VALA_CCODE_BINARY_OPERATOR_PLUS;
	} else {
		ValaBinaryExpression* _tmp54_;
		ValaBinaryOperator _tmp55_;
		ValaBinaryOperator _tmp56_;
		_tmp54_ = expr;
		_tmp55_ = vala_binary_expression_get_operator (_tmp54_);
		_tmp56_ = _tmp55_;
		if (_tmp56_ == VALA_BINARY_OPERATOR_MINUS) {
			op = VALA_CCODE_BINARY_OPERATOR_MINUS;
		} else {
			ValaBinaryExpression* _tmp57_;
			ValaBinaryOperator _tmp58_;
			ValaBinaryOperator _tmp59_;
			_tmp57_ = expr;
			_tmp58_ = vala_binary_expression_get_operator (_tmp57_);
			_tmp59_ = _tmp58_;
			if (_tmp59_ == VALA_BINARY_OPERATOR_MUL) {
				op = VALA_CCODE_BINARY_OPERATOR_MUL;
			} else {
				ValaBinaryExpression* _tmp60_;
				ValaBinaryOperator _tmp61_;
				ValaBinaryOperator _tmp62_;
				_tmp60_ = expr;
				_tmp61_ = vala_binary_expression_get_operator (_tmp60_);
				_tmp62_ = _tmp61_;
				if (_tmp62_ == VALA_BINARY_OPERATOR_DIV) {
					op = VALA_CCODE_BINARY_OPERATOR_DIV;
				} else {
					ValaBinaryExpression* _tmp63_;
					ValaBinaryOperator _tmp64_;
					ValaBinaryOperator _tmp65_;
					_tmp63_ = expr;
					_tmp64_ = vala_binary_expression_get_operator (_tmp63_);
					_tmp65_ = _tmp64_;
					if (_tmp65_ == VALA_BINARY_OPERATOR_MOD) {
						ValaBinaryExpression* _tmp66_;
						ValaDataType* _tmp67_;
						ValaDataType* _tmp68_;
						ValaDataType* _tmp69_;
						gboolean _tmp70_;
						_tmp66_ = expr;
						_tmp67_ = vala_expression_get_value_type ((ValaExpression*) _tmp66_);
						_tmp68_ = _tmp67_;
						_tmp69_ = self->double_type;
						_tmp70_ = vala_data_type_equals (_tmp68_, _tmp69_);
						if (_tmp70_) {
							ValaCCodeFile* _tmp71_;
							ValaCCodeFunctionCall* ccall = NULL;
							ValaCCodeIdentifier* _tmp72_;
							ValaCCodeIdentifier* _tmp73_;
							ValaCCodeFunctionCall* _tmp74_;
							ValaCCodeFunctionCall* _tmp75_;
							ValaCCodeFunctionCall* _tmp76_;
							ValaCCodeExpression* _tmp77_;
							ValaCCodeFunctionCall* _tmp78_;
							ValaCCodeExpression* _tmp79_;
							ValaBinaryExpression* _tmp80_;
							ValaCCodeFunctionCall* _tmp81_;
							_tmp71_ = self->cfile;
							vala_ccode_file_add_include (_tmp71_, "math.h", FALSE);
							_tmp72_ = vala_ccode_identifier_new ("fmod");
							_tmp73_ = _tmp72_;
							_tmp74_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp73_);
							_tmp75_ = _tmp74_;
							_vala_ccode_node_unref0 (_tmp73_);
							ccall = _tmp75_;
							_tmp76_ = ccall;
							_tmp77_ = cleft;
							vala_ccode_function_call_add_argument (_tmp76_, _tmp77_);
							_tmp78_ = ccall;
							_tmp79_ = cright;
							vala_ccode_function_call_add_argument (_tmp78_, _tmp79_);
							_tmp80_ = expr;
							_tmp81_ = ccall;
							vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp80_, (ValaCCodeExpression*) _tmp81_);
							_vala_ccode_node_unref0 (ccall);
							_vala_ccode_node_unref0 (left_chain);
							_vala_ccode_node_unref0 (cright);
							_vala_ccode_node_unref0 (cleft);
							return;
						} else {
							ValaBinaryExpression* _tmp82_;
							ValaDataType* _tmp83_;
							ValaDataType* _tmp84_;
							ValaDataType* _tmp85_;
							gboolean _tmp86_;
							_tmp82_ = expr;
							_tmp83_ = vala_expression_get_value_type ((ValaExpression*) _tmp82_);
							_tmp84_ = _tmp83_;
							_tmp85_ = self->float_type;
							_tmp86_ = vala_data_type_equals (_tmp84_, _tmp85_);
							if (_tmp86_) {
								ValaCCodeFile* _tmp87_;
								ValaCCodeFunctionCall* ccall = NULL;
								ValaCCodeIdentifier* _tmp88_;
								ValaCCodeIdentifier* _tmp89_;
								ValaCCodeFunctionCall* _tmp90_;
								ValaCCodeFunctionCall* _tmp91_;
								ValaCCodeFunctionCall* _tmp92_;
								ValaCCodeExpression* _tmp93_;
								ValaCCodeFunctionCall* _tmp94_;
								ValaCCodeExpression* _tmp95_;
								ValaBinaryExpression* _tmp96_;
								ValaCCodeFunctionCall* _tmp97_;
								_tmp87_ = self->cfile;
								vala_ccode_file_add_include (_tmp87_, "math.h", FALSE);
								_tmp88_ = vala_ccode_identifier_new ("fmodf");
								_tmp89_ = _tmp88_;
								_tmp90_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp89_);
								_tmp91_ = _tmp90_;
								_vala_ccode_node_unref0 (_tmp89_);
								ccall = _tmp91_;
								_tmp92_ = ccall;
								_tmp93_ = cleft;
								vala_ccode_function_call_add_argument (_tmp92_, _tmp93_);
								_tmp94_ = ccall;
								_tmp95_ = cright;
								vala_ccode_function_call_add_argument (_tmp94_, _tmp95_);
								_tmp96_ = expr;
								_tmp97_ = ccall;
								vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp96_, (ValaCCodeExpression*) _tmp97_);
								_vala_ccode_node_unref0 (ccall);
								_vala_ccode_node_unref0 (left_chain);
								_vala_ccode_node_unref0 (cright);
								_vala_ccode_node_unref0 (cleft);
								return;
							} else {
								op = VALA_CCODE_BINARY_OPERATOR_MOD;
							}
						}
					} else {
						ValaBinaryExpression* _tmp98_;
						ValaBinaryOperator _tmp99_;
						ValaBinaryOperator _tmp100_;
						_tmp98_ = expr;
						_tmp99_ = vala_binary_expression_get_operator (_tmp98_);
						_tmp100_ = _tmp99_;
						if (_tmp100_ == VALA_BINARY_OPERATOR_SHIFT_LEFT) {
							op = VALA_CCODE_BINARY_OPERATOR_SHIFT_LEFT;
						} else {
							ValaBinaryExpression* _tmp101_;
							ValaBinaryOperator _tmp102_;
							ValaBinaryOperator _tmp103_;
							_tmp101_ = expr;
							_tmp102_ = vala_binary_expression_get_operator (_tmp101_);
							_tmp103_ = _tmp102_;
							if (_tmp103_ == VALA_BINARY_OPERATOR_SHIFT_RIGHT) {
								op = VALA_CCODE_BINARY_OPERATOR_SHIFT_RIGHT;
							} else {
								ValaBinaryExpression* _tmp104_;
								ValaBinaryOperator _tmp105_;
								ValaBinaryOperator _tmp106_;
								_tmp104_ = expr;
								_tmp105_ = vala_binary_expression_get_operator (_tmp104_);
								_tmp106_ = _tmp105_;
								if (_tmp106_ == VALA_BINARY_OPERATOR_LESS_THAN) {
									op = VALA_CCODE_BINARY_OPERATOR_LESS_THAN;
								} else {
									ValaBinaryExpression* _tmp107_;
									ValaBinaryOperator _tmp108_;
									ValaBinaryOperator _tmp109_;
									_tmp107_ = expr;
									_tmp108_ = vala_binary_expression_get_operator (_tmp107_);
									_tmp109_ = _tmp108_;
									if (_tmp109_ == VALA_BINARY_OPERATOR_GREATER_THAN) {
										op = VALA_CCODE_BINARY_OPERATOR_GREATER_THAN;
									} else {
										ValaBinaryExpression* _tmp110_;
										ValaBinaryOperator _tmp111_;
										ValaBinaryOperator _tmp112_;
										_tmp110_ = expr;
										_tmp111_ = vala_binary_expression_get_operator (_tmp110_);
										_tmp112_ = _tmp111_;
										if (_tmp112_ == VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL) {
											op = VALA_CCODE_BINARY_OPERATOR_LESS_THAN_OR_EQUAL;
										} else {
											ValaBinaryExpression* _tmp113_;
											ValaBinaryOperator _tmp114_;
											ValaBinaryOperator _tmp115_;
											_tmp113_ = expr;
											_tmp114_ = vala_binary_expression_get_operator (_tmp113_);
											_tmp115_ = _tmp114_;
											if (_tmp115_ == VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL) {
												op = VALA_CCODE_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL;
											} else {
												ValaBinaryExpression* _tmp116_;
												ValaBinaryOperator _tmp117_;
												ValaBinaryOperator _tmp118_;
												_tmp116_ = expr;
												_tmp117_ = vala_binary_expression_get_operator (_tmp116_);
												_tmp118_ = _tmp117_;
												if (_tmp118_ == VALA_BINARY_OPERATOR_EQUALITY) {
													op = VALA_CCODE_BINARY_OPERATOR_EQUALITY;
												} else {
													ValaBinaryExpression* _tmp119_;
													ValaBinaryOperator _tmp120_;
													ValaBinaryOperator _tmp121_;
													_tmp119_ = expr;
													_tmp120_ = vala_binary_expression_get_operator (_tmp119_);
													_tmp121_ = _tmp120_;
													if (_tmp121_ == VALA_BINARY_OPERATOR_INEQUALITY) {
														op = VALA_CCODE_BINARY_OPERATOR_INEQUALITY;
													} else {
														ValaBinaryExpression* _tmp122_;
														ValaBinaryOperator _tmp123_;
														ValaBinaryOperator _tmp124_;
														_tmp122_ = expr;
														_tmp123_ = vala_binary_expression_get_operator (_tmp122_);
														_tmp124_ = _tmp123_;
														if (_tmp124_ == VALA_BINARY_OPERATOR_BITWISE_AND) {
															op = VALA_CCODE_BINARY_OPERATOR_BITWISE_AND;
														} else {
															ValaBinaryExpression* _tmp125_;
															ValaBinaryOperator _tmp126_;
															ValaBinaryOperator _tmp127_;
															_tmp125_ = expr;
															_tmp126_ = vala_binary_expression_get_operator (_tmp125_);
															_tmp127_ = _tmp126_;
															if (_tmp127_ == VALA_BINARY_OPERATOR_BITWISE_OR) {
																op = VALA_CCODE_BINARY_OPERATOR_BITWISE_OR;
															} else {
																ValaBinaryExpression* _tmp128_;
																ValaBinaryOperator _tmp129_;
																ValaBinaryOperator _tmp130_;
																_tmp128_ = expr;
																_tmp129_ = vala_binary_expression_get_operator (_tmp128_);
																_tmp130_ = _tmp129_;
																if (_tmp130_ == VALA_BINARY_OPERATOR_BITWISE_XOR) {
																	op = VALA_CCODE_BINARY_OPERATOR_BITWISE_XOR;
																} else {
																	ValaBinaryExpression* _tmp131_;
																	ValaBinaryOperator _tmp132_;
																	ValaBinaryOperator _tmp133_;
																	_tmp131_ = expr;
																	_tmp132_ = vala_binary_expression_get_operator (_tmp131_);
																	_tmp133_ = _tmp132_;
																	if (_tmp133_ == VALA_BINARY_OPERATOR_AND) {
																		op = VALA_CCODE_BINARY_OPERATOR_AND;
																	} else {
																		ValaBinaryExpression* _tmp134_;
																		ValaBinaryOperator _tmp135_;
																		ValaBinaryOperator _tmp136_;
																		_tmp134_ = expr;
																		_tmp135_ = vala_binary_expression_get_operator (_tmp134_);
																		_tmp136_ = _tmp135_;
																		if (_tmp136_ == VALA_BINARY_OPERATOR_OR) {
																			op = VALA_CCODE_BINARY_OPERATOR_OR;
																		} else {
																			ValaBinaryExpression* _tmp137_;
																			ValaBinaryOperator _tmp138_;
																			ValaBinaryOperator _tmp139_;
																			_tmp137_ = expr;
																			_tmp138_ = vala_binary_expression_get_operator (_tmp137_);
																			_tmp139_ = _tmp138_;
																			if (_tmp139_ == VALA_BINARY_OPERATOR_IN) {
																				ValaBinaryExpression* _tmp140_;
																				ValaExpression* _tmp141_;
																				ValaExpression* _tmp142_;
																				ValaDataType* _tmp143_;
																				ValaDataType* _tmp144_;
																				_tmp140_ = expr;
																				_tmp141_ = vala_binary_expression_get_right (_tmp140_);
																				_tmp142_ = _tmp141_;
																				_tmp143_ = vala_expression_get_value_type (_tmp142_);
																				_tmp144_ = _tmp143_;
																				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp144_, VALA_TYPE_ARRAY_TYPE)) {
																					ValaArrayType* array_type = NULL;
																					ValaBinaryExpression* _tmp145_;
																					ValaExpression* _tmp146_;
																					ValaExpression* _tmp147_;
																					ValaDataType* _tmp148_;
																					ValaDataType* _tmp149_;
																					ValaArrayType* _tmp150_;
																					ValaCCodeFunctionCall* node = NULL;
																					ValaArrayType* _tmp151_;
																					gchar* _tmp152_;
																					gchar* _tmp153_;
																					ValaCCodeIdentifier* _tmp154_;
																					ValaCCodeIdentifier* _tmp155_;
																					ValaCCodeFunctionCall* _tmp156_;
																					ValaCCodeFunctionCall* _tmp157_;
																					ValaCCodeFunctionCall* _tmp158_;
																					ValaCCodeExpression* _tmp159_;
																					ValaCCodeFunctionCall* _tmp160_;
																					ValaBinaryExpression* _tmp161_;
																					ValaExpression* _tmp162_;
																					ValaExpression* _tmp163_;
																					ValaCCodeExpression* _tmp164_;
																					ValaCCodeExpression* _tmp165_;
																					ValaArrayType* _tmp166_;
																					ValaDataType* _tmp167_;
																					ValaDataType* _tmp168_;
																					ValaBinaryExpression* _tmp175_;
																					ValaCCodeFunctionCall* _tmp176_;
																					_tmp145_ = expr;
																					_tmp146_ = vala_binary_expression_get_right (_tmp145_);
																					_tmp147_ = _tmp146_;
																					_tmp148_ = vala_expression_get_value_type (_tmp147_);
																					_tmp149_ = _tmp148_;
																					_tmp150_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp149_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
																					array_type = _tmp150_;
																					_tmp151_ = array_type;
																					_tmp152_ = vala_ccode_base_module_generate_array_contains_wrapper (self, _tmp151_);
																					_tmp153_ = _tmp152_;
																					_tmp154_ = vala_ccode_identifier_new (_tmp153_);
																					_tmp155_ = _tmp154_;
																					_tmp156_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp155_);
																					_tmp157_ = _tmp156_;
																					_vala_ccode_node_unref0 (_tmp155_);
																					_g_free0 (_tmp153_);
																					node = _tmp157_;
																					_tmp158_ = node;
																					_tmp159_ = cright;
																					vala_ccode_function_call_add_argument (_tmp158_, _tmp159_);
																					_tmp160_ = node;
																					_tmp161_ = expr;
																					_tmp162_ = vala_binary_expression_get_right (_tmp161_);
																					_tmp163_ = _tmp162_;
																					_tmp164_ = vala_ccode_base_module_get_array_length_cexpression (self, _tmp163_, -1);
																					_tmp165_ = _tmp164_;
																					vala_ccode_function_call_add_argument (_tmp160_, _tmp165_);
																					_vala_ccode_node_unref0 (_tmp165_);
																					_tmp166_ = array_type;
																					_tmp167_ = vala_array_type_get_element_type (_tmp166_);
																					_tmp168_ = _tmp167_;
																					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp168_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
																						ValaCCodeFunctionCall* _tmp169_;
																						ValaCCodeExpression* _tmp170_;
																						ValaCCodeUnaryExpression* _tmp171_;
																						ValaCCodeUnaryExpression* _tmp172_;
																						_tmp169_ = node;
																						_tmp170_ = cleft;
																						_tmp171_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp170_);
																						_tmp172_ = _tmp171_;
																						vala_ccode_function_call_add_argument (_tmp169_, (ValaCCodeExpression*) _tmp172_);
																						_vala_ccode_node_unref0 (_tmp172_);
																					} else {
																						ValaCCodeFunctionCall* _tmp173_;
																						ValaCCodeExpression* _tmp174_;
																						_tmp173_ = node;
																						_tmp174_ = cleft;
																						vala_ccode_function_call_add_argument (_tmp173_, _tmp174_);
																					}
																					_tmp175_ = expr;
																					_tmp176_ = node;
																					vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp175_, (ValaCCodeExpression*) _tmp176_);
																					_vala_ccode_node_unref0 (node);
																					_vala_code_node_unref0 (array_type);
																				} else {
																					ValaBinaryExpression* _tmp177_;
																					ValaCCodeExpression* _tmp178_;
																					ValaCCodeExpression* _tmp179_;
																					ValaCCodeBinaryExpression* _tmp180_;
																					ValaCCodeBinaryExpression* _tmp181_;
																					ValaCCodeExpression* _tmp182_;
																					ValaCCodeBinaryExpression* _tmp183_;
																					ValaCCodeBinaryExpression* _tmp184_;
																					_tmp177_ = expr;
																					_tmp178_ = cright;
																					_tmp179_ = cleft;
																					_tmp180_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_BITWISE_AND, _tmp178_, _tmp179_);
																					_tmp181_ = _tmp180_;
																					_tmp182_ = cleft;
																					_tmp183_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp181_, _tmp182_);
																					_tmp184_ = _tmp183_;
																					vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp177_, (ValaCCodeExpression*) _tmp184_);
																					_vala_ccode_node_unref0 (_tmp184_);
																					_vala_ccode_node_unref0 (_tmp181_);
																				}
																				_vala_ccode_node_unref0 (left_chain);
																				_vala_ccode_node_unref0 (cright);
																				_vala_ccode_node_unref0 (cleft);
																				return;
																			} else {
																				g_assert_not_reached ();
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}
	_tmp186_ = expr;
	_tmp187_ = vala_binary_expression_get_operator (_tmp186_);
	_tmp188_ = _tmp187_;
	if (_tmp188_ == VALA_BINARY_OPERATOR_EQUALITY) {
		_tmp185_ = TRUE;
	} else {
		ValaBinaryExpression* _tmp189_;
		ValaBinaryOperator _tmp190_;
		ValaBinaryOperator _tmp191_;
		_tmp189_ = expr;
		_tmp190_ = vala_binary_expression_get_operator (_tmp189_);
		_tmp191_ = _tmp190_;
		_tmp185_ = _tmp191_ == VALA_BINARY_OPERATOR_INEQUALITY;
	}
	if (_tmp185_) {
		ValaDataType* left_type = NULL;
		ValaBinaryExpression* _tmp192_;
		ValaExpression* _tmp193_;
		ValaExpression* _tmp194_;
		ValaDataType* _tmp195_;
		ValaDataType* _tmp196_;
		ValaDataType* _tmp197_;
		ValaDataType* right_type = NULL;
		ValaBinaryExpression* _tmp198_;
		ValaExpression* _tmp199_;
		ValaExpression* _tmp200_;
		ValaDataType* _tmp201_;
		ValaDataType* _tmp202_;
		ValaDataType* _tmp203_;
		gboolean _tmp204_ = FALSE;
		ValaDataType* _tmp205_;
		_tmp192_ = expr;
		_tmp193_ = vala_binary_expression_get_left (_tmp192_);
		_tmp194_ = _tmp193_;
		_tmp195_ = vala_expression_get_target_type (_tmp194_);
		_tmp196_ = _tmp195_;
		_tmp197_ = _vala_code_node_ref0 (_tmp196_);
		left_type = _tmp197_;
		_tmp198_ = expr;
		_tmp199_ = vala_binary_expression_get_right (_tmp198_);
		_tmp200_ = _tmp199_;
		_tmp201_ = vala_expression_get_target_type (_tmp200_);
		_tmp202_ = _tmp201_;
		_tmp203_ = _vala_code_node_ref0 (_tmp202_);
		right_type = _tmp203_;
		vala_ccode_base_module_make_comparable_cexpression (self, &left_type, &cleft, &right_type, &cright);
		_tmp205_ = left_type;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp205_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
			ValaDataType* _tmp206_;
			_tmp206_ = right_type;
			_tmp204_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp206_, VALA_TYPE_STRUCT_VALUE_TYPE);
		} else {
			_tmp204_ = FALSE;
		}
		if (_tmp204_) {
			gchar* equalfunc = NULL;
			ValaDataType* _tmp207_;
			ValaTypeSymbol* _tmp208_;
			ValaTypeSymbol* _tmp209_;
			gchar* _tmp210_;
			ValaCCodeFunctionCall* ccall = NULL;
			const gchar* _tmp211_;
			ValaCCodeIdentifier* _tmp212_;
			ValaCCodeIdentifier* _tmp213_;
			ValaCCodeFunctionCall* _tmp214_;
			ValaCCodeFunctionCall* _tmp215_;
			ValaCCodeFunctionCall* _tmp216_;
			ValaCCodeExpression* _tmp217_;
			ValaCCodeFunctionCall* _tmp218_;
			ValaCCodeExpression* _tmp219_;
			ValaCCodeFunctionCall* _tmp220_;
			ValaCCodeExpression* _tmp221_;
			ValaCCodeConstant* _tmp222_;
			_tmp207_ = left_type;
			_tmp208_ = vala_data_type_get_data_type (_tmp207_);
			_tmp209_ = _tmp208_;
			_tmp210_ = vala_ccode_base_module_generate_struct_equal_function (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp209_, VALA_TYPE_STRUCT, ValaStruct));
			equalfunc = _tmp210_;
			_tmp211_ = equalfunc;
			_tmp212_ = vala_ccode_identifier_new (_tmp211_);
			_tmp213_ = _tmp212_;
			_tmp214_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp213_);
			_tmp215_ = _tmp214_;
			_vala_ccode_node_unref0 (_tmp213_);
			ccall = _tmp215_;
			_tmp216_ = ccall;
			_tmp217_ = cleft;
			vala_ccode_function_call_add_argument (_tmp216_, _tmp217_);
			_tmp218_ = ccall;
			_tmp219_ = cright;
			vala_ccode_function_call_add_argument (_tmp218_, _tmp219_);
			_tmp220_ = ccall;
			_tmp221_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp220_);
			_vala_ccode_node_unref0 (cleft);
			cleft = _tmp221_;
			_tmp222_ = vala_ccode_constant_new ("TRUE");
			_vala_ccode_node_unref0 (cright);
			cright = (ValaCCodeExpression*) _tmp222_;
			_vala_ccode_node_unref0 (ccall);
			_g_free0 (equalfunc);
		} else {
			gboolean _tmp223_ = FALSE;
			gboolean _tmp224_ = FALSE;
			gboolean _tmp225_ = FALSE;
			gboolean _tmp226_ = FALSE;
			gboolean _tmp227_ = FALSE;
			gboolean _tmp228_ = FALSE;
			ValaDataType* _tmp229_;
			_tmp229_ = left_type;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp229_, VALA_TYPE_INTEGER_TYPE)) {
				_tmp228_ = TRUE;
			} else {
				ValaDataType* _tmp230_;
				_tmp230_ = left_type;
				_tmp228_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp230_, VALA_TYPE_FLOATING_TYPE);
			}
			if (_tmp228_) {
				_tmp227_ = TRUE;
			} else {
				ValaDataType* _tmp231_;
				_tmp231_ = left_type;
				_tmp227_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp231_, VALA_TYPE_BOOLEAN_TYPE);
			}
			if (_tmp227_) {
				_tmp226_ = TRUE;
			} else {
				ValaDataType* _tmp232_;
				_tmp232_ = left_type;
				_tmp226_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp232_, VALA_TYPE_ENUM_VALUE_TYPE);
			}
			if (_tmp226_) {
				ValaDataType* _tmp233_;
				gboolean _tmp234_;
				gboolean _tmp235_;
				_tmp233_ = left_type;
				_tmp234_ = vala_data_type_get_nullable (_tmp233_);
				_tmp235_ = _tmp234_;
				_tmp225_ = _tmp235_;
			} else {
				_tmp225_ = FALSE;
			}
			if (_tmp225_) {
				gboolean _tmp236_ = FALSE;
				gboolean _tmp237_ = FALSE;
				gboolean _tmp238_ = FALSE;
				ValaDataType* _tmp239_;
				_tmp239_ = right_type;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp239_, VALA_TYPE_INTEGER_TYPE)) {
					_tmp238_ = TRUE;
				} else {
					ValaDataType* _tmp240_;
					_tmp240_ = right_type;
					_tmp238_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp240_, VALA_TYPE_FLOATING_TYPE);
				}
				if (_tmp238_) {
					_tmp237_ = TRUE;
				} else {
					ValaDataType* _tmp241_;
					_tmp241_ = right_type;
					_tmp237_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp241_, VALA_TYPE_BOOLEAN_TYPE);
				}
				if (_tmp237_) {
					_tmp236_ = TRUE;
				} else {
					ValaDataType* _tmp242_;
					_tmp242_ = right_type;
					_tmp236_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp242_, VALA_TYPE_ENUM_VALUE_TYPE);
				}
				_tmp224_ = _tmp236_;
			} else {
				_tmp224_ = FALSE;
			}
			if (_tmp224_) {
				ValaDataType* _tmp243_;
				gboolean _tmp244_;
				gboolean _tmp245_;
				_tmp243_ = right_type;
				_tmp244_ = vala_data_type_get_nullable (_tmp243_);
				_tmp245_ = _tmp244_;
				_tmp223_ = _tmp245_;
			} else {
				_tmp223_ = FALSE;
			}
			if (_tmp223_) {
				gchar* equalfunc = NULL;
				ValaDataType* _tmp246_;
				ValaTypeSymbol* _tmp247_;
				ValaTypeSymbol* _tmp248_;
				gchar* _tmp249_;
				ValaCCodeFunctionCall* ccall = NULL;
				const gchar* _tmp250_;
				ValaCCodeIdentifier* _tmp251_;
				ValaCCodeIdentifier* _tmp252_;
				ValaCCodeFunctionCall* _tmp253_;
				ValaCCodeFunctionCall* _tmp254_;
				ValaCCodeFunctionCall* _tmp255_;
				ValaCCodeExpression* _tmp256_;
				ValaCCodeFunctionCall* _tmp257_;
				ValaCCodeExpression* _tmp258_;
				ValaCCodeFunctionCall* _tmp259_;
				ValaCCodeExpression* _tmp260_;
				ValaCCodeConstant* _tmp261_;
				_tmp246_ = left_type;
				_tmp247_ = vala_data_type_get_data_type (_tmp246_);
				_tmp248_ = _tmp247_;
				_tmp249_ = vala_ccode_base_module_generate_numeric_equal_function (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp248_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
				equalfunc = _tmp249_;
				_tmp250_ = equalfunc;
				_tmp251_ = vala_ccode_identifier_new (_tmp250_);
				_tmp252_ = _tmp251_;
				_tmp253_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp252_);
				_tmp254_ = _tmp253_;
				_vala_ccode_node_unref0 (_tmp252_);
				ccall = _tmp254_;
				_tmp255_ = ccall;
				_tmp256_ = cleft;
				vala_ccode_function_call_add_argument (_tmp255_, _tmp256_);
				_tmp257_ = ccall;
				_tmp258_ = cright;
				vala_ccode_function_call_add_argument (_tmp257_, _tmp258_);
				_tmp259_ = ccall;
				_tmp260_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp259_);
				_vala_ccode_node_unref0 (cleft);
				cleft = _tmp260_;
				_tmp261_ = vala_ccode_constant_new ("TRUE");
				_vala_ccode_node_unref0 (cright);
				cright = (ValaCCodeExpression*) _tmp261_;
				_vala_ccode_node_unref0 (ccall);
				_g_free0 (equalfunc);
			}
		}
		_vala_code_node_unref0 (right_type);
		_vala_code_node_unref0 (left_type);
	}
	_tmp265_ = expr;
	_tmp266_ = vala_binary_expression_get_left (_tmp265_);
	_tmp267_ = _tmp266_;
	_tmp268_ = vala_expression_get_value_type (_tmp267_);
	_tmp269_ = _tmp268_;
	if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp269_, VALA_TYPE_NULL_TYPE)) {
		ValaBinaryExpression* _tmp270_;
		ValaExpression* _tmp271_;
		ValaExpression* _tmp272_;
		ValaDataType* _tmp273_;
		ValaDataType* _tmp274_;
		ValaDataType* _tmp275_;
		gboolean _tmp276_;
		_tmp270_ = expr;
		_tmp271_ = vala_binary_expression_get_left (_tmp270_);
		_tmp272_ = _tmp271_;
		_tmp273_ = vala_expression_get_value_type (_tmp272_);
		_tmp274_ = _tmp273_;
		_tmp275_ = self->string_type;
		_tmp276_ = vala_data_type_compatible (_tmp274_, _tmp275_);
		_tmp264_ = _tmp276_;
	} else {
		_tmp264_ = FALSE;
	}
	if (_tmp264_) {
		ValaBinaryExpression* _tmp277_;
		ValaExpression* _tmp278_;
		ValaExpression* _tmp279_;
		ValaDataType* _tmp280_;
		ValaDataType* _tmp281_;
		_tmp277_ = expr;
		_tmp278_ = vala_binary_expression_get_right (_tmp277_);
		_tmp279_ = _tmp278_;
		_tmp280_ = vala_expression_get_value_type (_tmp279_);
		_tmp281_ = _tmp280_;
		_tmp263_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp281_, VALA_TYPE_NULL_TYPE);
	} else {
		_tmp263_ = FALSE;
	}
	if (_tmp263_) {
		ValaBinaryExpression* _tmp282_;
		ValaExpression* _tmp283_;
		ValaExpression* _tmp284_;
		ValaDataType* _tmp285_;
		ValaDataType* _tmp286_;
		ValaDataType* _tmp287_;
		gboolean _tmp288_;
		_tmp282_ = expr;
		_tmp283_ = vala_binary_expression_get_right (_tmp282_);
		_tmp284_ = _tmp283_;
		_tmp285_ = vala_expression_get_value_type (_tmp284_);
		_tmp286_ = _tmp285_;
		_tmp287_ = self->string_type;
		_tmp288_ = vala_data_type_compatible (_tmp286_, _tmp287_);
		_tmp262_ = _tmp288_;
	} else {
		_tmp262_ = FALSE;
	}
	if (_tmp262_) {
		ValaBinaryExpression* _tmp289_;
		ValaBinaryOperator _tmp290_;
		ValaBinaryOperator _tmp291_;
		_tmp289_ = expr;
		_tmp290_ = vala_binary_expression_get_operator (_tmp289_);
		_tmp291_ = _tmp290_;
		if (_tmp291_ == VALA_BINARY_OPERATOR_PLUS) {
			gboolean _tmp292_ = FALSE;
			ValaBinaryExpression* _tmp293_;
			ValaExpression* _tmp294_;
			ValaExpression* _tmp295_;
			gboolean _tmp296_;
			_tmp293_ = expr;
			_tmp294_ = vala_binary_expression_get_left (_tmp293_);
			_tmp295_ = _tmp294_;
			_tmp296_ = vala_expression_is_constant (_tmp295_);
			if (_tmp296_) {
				ValaBinaryExpression* _tmp297_;
				ValaExpression* _tmp298_;
				ValaExpression* _tmp299_;
				gboolean _tmp300_;
				_tmp297_ = expr;
				_tmp298_ = vala_binary_expression_get_right (_tmp297_);
				_tmp299_ = _tmp298_;
				_tmp300_ = vala_expression_is_constant (_tmp299_);
				_tmp292_ = _tmp300_;
			} else {
				_tmp292_ = FALSE;
			}
			if (_tmp292_) {
				gchar* left = NULL;
				gchar* right = NULL;
				ValaCCodeExpression* _tmp301_;
				ValaCCodeExpression* _tmp311_;
				ValaBinaryExpression* _tmp321_;
				const gchar* _tmp322_;
				const gchar* _tmp323_;
				gchar* _tmp324_;
				gchar* _tmp325_;
				ValaCCodeConstant* _tmp326_;
				ValaCCodeConstant* _tmp327_;
				_tmp301_ = cleft;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp301_, VALA_TYPE_CCODE_IDENTIFIER)) {
					ValaCCodeExpression* _tmp302_;
					const gchar* _tmp303_;
					const gchar* _tmp304_;
					gchar* _tmp305_;
					_tmp302_ = cleft;
					_tmp303_ = vala_ccode_identifier_get_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp302_, VALA_TYPE_CCODE_IDENTIFIER, ValaCCodeIdentifier));
					_tmp304_ = _tmp303_;
					_tmp305_ = g_strdup (_tmp304_);
					_g_free0 (left);
					left = _tmp305_;
				} else {
					ValaCCodeExpression* _tmp306_;
					_tmp306_ = cleft;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp306_, VALA_TYPE_CCODE_CONSTANT)) {
						ValaCCodeExpression* _tmp307_;
						const gchar* _tmp308_;
						const gchar* _tmp309_;
						gchar* _tmp310_;
						_tmp307_ = cleft;
						_tmp308_ = vala_ccode_constant_get_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp307_, VALA_TYPE_CCODE_CONSTANT, ValaCCodeConstant));
						_tmp309_ = _tmp308_;
						_tmp310_ = g_strdup (_tmp309_);
						_g_free0 (left);
						left = _tmp310_;
					} else {
						g_assert_not_reached ();
					}
				}
				_tmp311_ = cright;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp311_, VALA_TYPE_CCODE_IDENTIFIER)) {
					ValaCCodeExpression* _tmp312_;
					const gchar* _tmp313_;
					const gchar* _tmp314_;
					gchar* _tmp315_;
					_tmp312_ = cright;
					_tmp313_ = vala_ccode_identifier_get_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp312_, VALA_TYPE_CCODE_IDENTIFIER, ValaCCodeIdentifier));
					_tmp314_ = _tmp313_;
					_tmp315_ = g_strdup (_tmp314_);
					_g_free0 (right);
					right = _tmp315_;
				} else {
					ValaCCodeExpression* _tmp316_;
					_tmp316_ = cright;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp316_, VALA_TYPE_CCODE_CONSTANT)) {
						ValaCCodeExpression* _tmp317_;
						const gchar* _tmp318_;
						const gchar* _tmp319_;
						gchar* _tmp320_;
						_tmp317_ = cright;
						_tmp318_ = vala_ccode_constant_get_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp317_, VALA_TYPE_CCODE_CONSTANT, ValaCCodeConstant));
						_tmp319_ = _tmp318_;
						_tmp320_ = g_strdup (_tmp319_);
						_g_free0 (right);
						right = _tmp320_;
					} else {
						g_assert_not_reached ();
					}
				}
				_tmp321_ = expr;
				_tmp322_ = left;
				_tmp323_ = right;
				_tmp324_ = g_strdup_printf ("%s %s", _tmp322_, _tmp323_);
				_tmp325_ = _tmp324_;
				_tmp326_ = vala_ccode_constant_new (_tmp325_);
				_tmp327_ = _tmp326_;
				vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp321_, (ValaCCodeExpression*) _tmp327_);
				_vala_ccode_node_unref0 (_tmp327_);
				_g_free0 (_tmp325_);
				_g_free0 (right);
				_g_free0 (left);
				_vala_ccode_node_unref0 (left_chain);
				_vala_ccode_node_unref0 (cright);
				_vala_ccode_node_unref0 (cleft);
				return;
			} else {
				ValaTargetValue* temp_value = NULL;
				ValaBinaryExpression* _tmp328_;
				ValaDataType* _tmp329_;
				ValaDataType* _tmp330_;
				ValaBinaryExpression* _tmp331_;
				ValaTargetValue* _tmp332_;
				ValaCCodeFunctionCall* ccall = NULL;
				ValaCCodeIdentifier* _tmp333_;
				ValaCCodeIdentifier* _tmp334_;
				ValaCCodeFunctionCall* _tmp335_;
				ValaCCodeFunctionCall* _tmp336_;
				ValaCCodeFunctionCall* _tmp337_;
				ValaCCodeExpression* _tmp338_;
				ValaCCodeFunctionCall* _tmp339_;
				ValaCCodeExpression* _tmp340_;
				ValaCCodeFunctionCall* _tmp341_;
				ValaCCodeConstant* _tmp342_;
				ValaCCodeConstant* _tmp343_;
				ValaCCodeFunction* _tmp344_;
				ValaCCodeFunction* _tmp345_;
				ValaTargetValue* _tmp346_;
				ValaCCodeExpression* _tmp347_;
				ValaCCodeExpression* _tmp348_;
				ValaCCodeFunctionCall* _tmp349_;
				ValaBinaryExpression* _tmp350_;
				ValaTargetValue* _tmp351_;
				_tmp328_ = expr;
				_tmp329_ = vala_expression_get_value_type ((ValaExpression*) _tmp328_);
				_tmp330_ = _tmp329_;
				_tmp331_ = expr;
				_tmp332_ = vala_ccode_base_module_create_temp_value (self, _tmp330_, FALSE, (ValaCodeNode*) _tmp331_, NULL);
				temp_value = _tmp332_;
				_tmp333_ = vala_ccode_identifier_new ("g_strconcat");
				_tmp334_ = _tmp333_;
				_tmp335_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp334_);
				_tmp336_ = _tmp335_;
				_vala_ccode_node_unref0 (_tmp334_);
				ccall = _tmp336_;
				_tmp337_ = ccall;
				_tmp338_ = cleft;
				vala_ccode_function_call_add_argument (_tmp337_, _tmp338_);
				_tmp339_ = ccall;
				_tmp340_ = cright;
				vala_ccode_function_call_add_argument (_tmp339_, _tmp340_);
				_tmp341_ = ccall;
				_tmp342_ = vala_ccode_constant_new ("NULL");
				_tmp343_ = _tmp342_;
				vala_ccode_function_call_add_argument (_tmp341_, (ValaCCodeExpression*) _tmp343_);
				_vala_ccode_node_unref0 (_tmp343_);
				_tmp344_ = vala_ccode_base_module_get_ccode (self);
				_tmp345_ = _tmp344_;
				_tmp346_ = temp_value;
				_tmp347_ = vala_ccode_base_module_get_cvalue_ (self, _tmp346_);
				_tmp348_ = _tmp347_;
				_tmp349_ = ccall;
				vala_ccode_function_add_assignment (_tmp345_, _tmp348_, (ValaCCodeExpression*) _tmp349_);
				_vala_ccode_node_unref0 (_tmp348_);
				_tmp350_ = expr;
				_tmp351_ = temp_value;
				vala_expression_set_target_value ((ValaExpression*) _tmp350_, _tmp351_);
				_vala_ccode_node_unref0 (ccall);
				_vala_target_value_unref0 (temp_value);
				_vala_ccode_node_unref0 (left_chain);
				_vala_ccode_node_unref0 (cright);
				_vala_ccode_node_unref0 (cleft);
				return;
			}
		} else {
			gboolean _tmp352_ = FALSE;
			gboolean _tmp353_ = FALSE;
			gboolean _tmp354_ = FALSE;
			gboolean _tmp355_ = FALSE;
			gboolean _tmp356_ = FALSE;
			ValaBinaryExpression* _tmp357_;
			ValaBinaryOperator _tmp358_;
			ValaBinaryOperator _tmp359_;
			_tmp357_ = expr;
			_tmp358_ = vala_binary_expression_get_operator (_tmp357_);
			_tmp359_ = _tmp358_;
			if (_tmp359_ == VALA_BINARY_OPERATOR_EQUALITY) {
				_tmp356_ = TRUE;
			} else {
				ValaBinaryExpression* _tmp360_;
				ValaBinaryOperator _tmp361_;
				ValaBinaryOperator _tmp362_;
				_tmp360_ = expr;
				_tmp361_ = vala_binary_expression_get_operator (_tmp360_);
				_tmp362_ = _tmp361_;
				_tmp356_ = _tmp362_ == VALA_BINARY_OPERATOR_INEQUALITY;
			}
			if (_tmp356_) {
				_tmp355_ = TRUE;
			} else {
				ValaBinaryExpression* _tmp363_;
				ValaBinaryOperator _tmp364_;
				ValaBinaryOperator _tmp365_;
				_tmp363_ = expr;
				_tmp364_ = vala_binary_expression_get_operator (_tmp363_);
				_tmp365_ = _tmp364_;
				_tmp355_ = _tmp365_ == VALA_BINARY_OPERATOR_LESS_THAN;
			}
			if (_tmp355_) {
				_tmp354_ = TRUE;
			} else {
				ValaBinaryExpression* _tmp366_;
				ValaBinaryOperator _tmp367_;
				ValaBinaryOperator _tmp368_;
				_tmp366_ = expr;
				_tmp367_ = vala_binary_expression_get_operator (_tmp366_);
				_tmp368_ = _tmp367_;
				_tmp354_ = _tmp368_ == VALA_BINARY_OPERATOR_GREATER_THAN;
			}
			if (_tmp354_) {
				_tmp353_ = TRUE;
			} else {
				ValaBinaryExpression* _tmp369_;
				ValaBinaryOperator _tmp370_;
				ValaBinaryOperator _tmp371_;
				_tmp369_ = expr;
				_tmp370_ = vala_binary_expression_get_operator (_tmp369_);
				_tmp371_ = _tmp370_;
				_tmp353_ = _tmp371_ == VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL;
			}
			if (_tmp353_) {
				_tmp352_ = TRUE;
			} else {
				ValaBinaryExpression* _tmp372_;
				ValaBinaryOperator _tmp373_;
				ValaBinaryOperator _tmp374_;
				_tmp372_ = expr;
				_tmp373_ = vala_binary_expression_get_operator (_tmp372_);
				_tmp374_ = _tmp373_;
				_tmp352_ = _tmp374_ == VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL;
			}
			if (_tmp352_) {
				ValaCCodeFunctionCall* ccall = NULL;
				ValaCCodeIdentifier* _tmp375_;
				ValaCCodeIdentifier* _tmp376_;
				ValaCCodeFunctionCall* _tmp377_;
				ValaCCodeFunctionCall* _tmp378_;
				ValaCCodeFunctionCall* _tmp379_;
				ValaCCodeExpression* _tmp380_;
				ValaCCodeFunctionCall* _tmp381_;
				ValaCCodeExpression* _tmp382_;
				ValaCCodeFunctionCall* _tmp383_;
				ValaCCodeExpression* _tmp384_;
				ValaCCodeConstant* _tmp385_;
				_tmp375_ = vala_ccode_identifier_new ("g_strcmp0");
				_tmp376_ = _tmp375_;
				_tmp377_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp376_);
				_tmp378_ = _tmp377_;
				_vala_ccode_node_unref0 (_tmp376_);
				ccall = _tmp378_;
				_tmp379_ = ccall;
				_tmp380_ = cleft;
				vala_ccode_function_call_add_argument (_tmp379_, _tmp380_);
				_tmp381_ = ccall;
				_tmp382_ = cright;
				vala_ccode_function_call_add_argument (_tmp381_, _tmp382_);
				_tmp383_ = ccall;
				_tmp384_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp383_);
				_vala_ccode_node_unref0 (cleft);
				cleft = _tmp384_;
				_tmp385_ = vala_ccode_constant_new ("0");
				_vala_ccode_node_unref0 (cright);
				cright = (ValaCCodeExpression*) _tmp385_;
				_vala_ccode_node_unref0 (ccall);
			}
		}
	}
	_tmp386_ = expr;
	_tmp387_ = op;
	_tmp388_ = cleft;
	_tmp389_ = cright;
	_tmp390_ = vala_ccode_binary_expression_new (_tmp387_, _tmp388_, _tmp389_);
	_tmp391_ = _tmp390_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp386_, (ValaCCodeExpression*) _tmp391_);
	_vala_ccode_node_unref0 (_tmp391_);
	_tmp392_ = left_chain;
	if (_tmp392_ != NULL) {
		ValaBinaryExpression* _tmp393_;
		ValaCCodeExpression* _tmp394_;
		ValaBinaryExpression* _tmp395_;
		ValaCCodeExpression* _tmp396_;
		ValaCCodeExpression* _tmp397_;
		ValaCCodeBinaryExpression* _tmp398_;
		ValaCCodeBinaryExpression* _tmp399_;
		_tmp393_ = expr;
		_tmp394_ = left_chain;
		_tmp395_ = expr;
		_tmp396_ = vala_ccode_base_module_get_cvalue (self, (ValaExpression*) _tmp395_);
		_tmp397_ = _tmp396_;
		_tmp398_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_AND, _tmp394_, _tmp397_);
		_tmp399_ = _tmp398_;
		vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp393_, (ValaCCodeExpression*) _tmp399_);
		_vala_ccode_node_unref0 (_tmp399_);
		_vala_ccode_node_unref0 (_tmp397_);
	}
	_vala_ccode_node_unref0 (left_chain);
	_vala_ccode_node_unref0 (cright);
	_vala_ccode_node_unref0 (cleft);
}


static ValaCCodeExpression* vala_ccode_base_module_create_type_check (ValaCCodeBaseModule* self, ValaCCodeNode* ccodenode, ValaDataType* type) {
	ValaCCodeExpression* result = NULL;
	ValaErrorType* et = NULL;
	ValaDataType* _tmp0_;
	ValaErrorType* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaErrorType* _tmp3_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (ccodenode != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ERROR_TYPE) ? ((ValaErrorType*) _tmp0_) : NULL);
	et = _tmp1_;
	_tmp3_ = et;
	if (_tmp3_ != NULL) {
		ValaErrorType* _tmp4_;
		ValaErrorCode* _tmp5_;
		ValaErrorCode* _tmp6_;
		_tmp4_ = et;
		_tmp5_ = vala_error_type_get_error_code (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp2_ = _tmp6_ != NULL;
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		ValaCCodeFunctionCall* matches_call = NULL;
		ValaCCodeIdentifier* _tmp7_;
		ValaCCodeIdentifier* _tmp8_;
		ValaCCodeFunctionCall* _tmp9_;
		ValaCCodeFunctionCall* _tmp10_;
		ValaCCodeFunctionCall* _tmp11_;
		ValaCCodeNode* _tmp12_;
		ValaCCodeFunctionCall* _tmp13_;
		ValaErrorType* _tmp14_;
		ValaErrorDomain* _tmp15_;
		ValaErrorDomain* _tmp16_;
		gchar* _tmp17_;
		gchar* _tmp18_;
		ValaCCodeIdentifier* _tmp19_;
		ValaCCodeIdentifier* _tmp20_;
		ValaCCodeFunctionCall* _tmp21_;
		ValaErrorType* _tmp22_;
		ValaErrorCode* _tmp23_;
		ValaErrorCode* _tmp24_;
		gchar* _tmp25_;
		gchar* _tmp26_;
		ValaCCodeIdentifier* _tmp27_;
		ValaCCodeIdentifier* _tmp28_;
		_tmp7_ = vala_ccode_identifier_new ("g_error_matches");
		_tmp8_ = _tmp7_;
		_tmp9_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp8_);
		_tmp10_ = _tmp9_;
		_vala_ccode_node_unref0 (_tmp8_);
		matches_call = _tmp10_;
		_tmp11_ = matches_call;
		_tmp12_ = ccodenode;
		vala_ccode_function_call_add_argument (_tmp11_, G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression));
		_tmp13_ = matches_call;
		_tmp14_ = et;
		_tmp15_ = vala_error_type_get_error_domain (_tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp16_, NULL);
		_tmp18_ = _tmp17_;
		_tmp19_ = vala_ccode_identifier_new (_tmp18_);
		_tmp20_ = _tmp19_;
		vala_ccode_function_call_add_argument (_tmp13_, (ValaCCodeExpression*) _tmp20_);
		_vala_ccode_node_unref0 (_tmp20_);
		_g_free0 (_tmp18_);
		_tmp21_ = matches_call;
		_tmp22_ = et;
		_tmp23_ = vala_error_type_get_error_code (_tmp22_);
		_tmp24_ = _tmp23_;
		_tmp25_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp24_);
		_tmp26_ = _tmp25_;
		_tmp27_ = vala_ccode_identifier_new (_tmp26_);
		_tmp28_ = _tmp27_;
		vala_ccode_function_call_add_argument (_tmp21_, (ValaCCodeExpression*) _tmp28_);
		_vala_ccode_node_unref0 (_tmp28_);
		_g_free0 (_tmp26_);
		result = (ValaCCodeExpression*) matches_call;
		_vala_code_node_unref0 (et);
		return result;
	} else {
		gboolean _tmp29_ = FALSE;
		ValaErrorType* _tmp30_;
		_tmp30_ = et;
		if (_tmp30_ != NULL) {
			ValaErrorType* _tmp31_;
			ValaErrorDomain* _tmp32_;
			ValaErrorDomain* _tmp33_;
			_tmp31_ = et;
			_tmp32_ = vala_error_type_get_error_domain (_tmp31_);
			_tmp33_ = _tmp32_;
			_tmp29_ = _tmp33_ != NULL;
		} else {
			_tmp29_ = FALSE;
		}
		if (_tmp29_) {
			ValaCCodeMemberAccess* instance_domain = NULL;
			ValaCCodeNode* _tmp34_;
			ValaCCodeMemberAccess* _tmp35_;
			ValaCCodeIdentifier* type_domain = NULL;
			ValaErrorType* _tmp36_;
			ValaErrorDomain* _tmp37_;
			ValaErrorDomain* _tmp38_;
			gchar* _tmp39_;
			gchar* _tmp40_;
			ValaCCodeIdentifier* _tmp41_;
			ValaCCodeIdentifier* _tmp42_;
			ValaCCodeMemberAccess* _tmp43_;
			ValaCCodeIdentifier* _tmp44_;
			ValaCCodeBinaryExpression* _tmp45_;
			_tmp34_ = ccodenode;
			_tmp35_ = vala_ccode_member_access_new_pointer (G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression), "domain");
			instance_domain = _tmp35_;
			_tmp36_ = et;
			_tmp37_ = vala_error_type_get_error_domain (_tmp36_);
			_tmp38_ = _tmp37_;
			_tmp39_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp38_, NULL);
			_tmp40_ = _tmp39_;
			_tmp41_ = vala_ccode_identifier_new (_tmp40_);
			_tmp42_ = _tmp41_;
			_g_free0 (_tmp40_);
			type_domain = _tmp42_;
			_tmp43_ = instance_domain;
			_tmp44_ = type_domain;
			_tmp45_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp43_, (ValaCCodeExpression*) _tmp44_);
			result = (ValaCCodeExpression*) _tmp45_;
			_vala_ccode_node_unref0 (type_domain);
			_vala_ccode_node_unref0 (instance_domain);
			_vala_code_node_unref0 (et);
			return result;
		} else {
			ValaCCodeExpression* type_id = NULL;
			ValaDataType* _tmp46_;
			ValaCCodeExpression* _tmp47_;
			ValaCCodeExpression* _tmp48_;
			ValaCCodeFunctionCall* ccheck = NULL;
			ValaCCodeIdentifier* _tmp50_;
			ValaCCodeIdentifier* _tmp51_;
			ValaCCodeFunctionCall* _tmp52_;
			ValaCCodeFunctionCall* _tmp53_;
			ValaCCodeFunctionCall* _tmp54_;
			ValaCCodeNode* _tmp55_;
			ValaCCodeFunctionCall* _tmp56_;
			ValaCCodeExpression* _tmp57_;
			_tmp46_ = type;
			_tmp47_ = vala_ccode_base_module_get_type_id_expression (self, _tmp46_, FALSE);
			type_id = _tmp47_;
			_tmp48_ = type_id;
			if (_tmp48_ == NULL) {
				ValaCCodeInvalidExpression* _tmp49_;
				_tmp49_ = vala_ccode_invalid_expression_new ();
				result = (ValaCCodeExpression*) _tmp49_;
				_vala_ccode_node_unref0 (type_id);
				_vala_code_node_unref0 (et);
				return result;
			}
			_tmp50_ = vala_ccode_identifier_new ("G_TYPE_CHECK_INSTANCE_TYPE");
			_tmp51_ = _tmp50_;
			_tmp52_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp51_);
			_tmp53_ = _tmp52_;
			_vala_ccode_node_unref0 (_tmp51_);
			ccheck = _tmp53_;
			_tmp54_ = ccheck;
			_tmp55_ = ccodenode;
			vala_ccode_function_call_add_argument (_tmp54_, G_TYPE_CHECK_INSTANCE_CAST (_tmp55_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression));
			_tmp56_ = ccheck;
			_tmp57_ = type_id;
			vala_ccode_function_call_add_argument (_tmp56_, _tmp57_);
			result = (ValaCCodeExpression*) ccheck;
			_vala_ccode_node_unref0 (type_id);
			_vala_code_node_unref0 (et);
			return result;
		}
	}
	_vala_code_node_unref0 (et);
}


static gchar* vala_ccode_base_module_generate_array_contains_wrapper (ValaCCodeBaseModule* self, ValaArrayType* array_type) {
	gchar* result = NULL;
	gchar* array_contains_func = NULL;
	ValaArrayType* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	const gchar* _tmp7_;
	gboolean _tmp8_;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	ValaCCodeFunction* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaArrayType* _tmp13_;
	ValaDataType* _tmp14_;
	ValaDataType* _tmp15_;
	gchar* _tmp16_;
	gchar* _tmp17_;
	gchar* _tmp18_;
	gchar* _tmp19_;
	ValaCCodeParameter* _tmp20_;
	ValaCCodeParameter* _tmp21_;
	ValaCCodeFunction* _tmp22_;
	ValaCCodeParameter* _tmp23_;
	ValaCCodeParameter* _tmp24_;
	ValaArrayType* _tmp25_;
	ValaDataType* _tmp26_;
	ValaDataType* _tmp27_;
	ValaCCodeFunction* _tmp46_;
	ValaCCodeFunction* _tmp47_;
	ValaCCodeFunction* _tmp48_;
	ValaCCodeVariableDeclarator* _tmp49_;
	ValaCCodeVariableDeclarator* _tmp50_;
	ValaCCodeAssignment* cloop_initializer = NULL;
	ValaCCodeIdentifier* _tmp51_;
	ValaCCodeIdentifier* _tmp52_;
	ValaCCodeConstant* _tmp53_;
	ValaCCodeConstant* _tmp54_;
	ValaCCodeAssignment* _tmp55_;
	ValaCCodeAssignment* _tmp56_;
	ValaCCodeBinaryExpression* cloop_condition = NULL;
	ValaCCodeIdentifier* _tmp57_;
	ValaCCodeIdentifier* _tmp58_;
	ValaCCodeIdentifier* _tmp59_;
	ValaCCodeIdentifier* _tmp60_;
	ValaCCodeBinaryExpression* _tmp61_;
	ValaCCodeBinaryExpression* _tmp62_;
	ValaCCodeUnaryExpression* cloop_iterator = NULL;
	ValaCCodeIdentifier* _tmp63_;
	ValaCCodeIdentifier* _tmp64_;
	ValaCCodeUnaryExpression* _tmp65_;
	ValaCCodeUnaryExpression* _tmp66_;
	ValaCCodeFunction* _tmp67_;
	ValaCCodeFunction* _tmp68_;
	ValaCCodeAssignment* _tmp69_;
	ValaCCodeBinaryExpression* _tmp70_;
	ValaCCodeUnaryExpression* _tmp71_;
	ValaCCodeElementAccess* celement = NULL;
	ValaCCodeIdentifier* _tmp72_;
	ValaCCodeIdentifier* _tmp73_;
	ValaCCodeIdentifier* _tmp74_;
	ValaCCodeIdentifier* _tmp75_;
	ValaCCodeElementAccess* _tmp76_;
	ValaCCodeElementAccess* _tmp77_;
	ValaCCodeIdentifier* cneedle = NULL;
	ValaCCodeIdentifier* _tmp78_;
	ValaCCodeBinaryExpression* cif_condition = NULL;
	ValaArrayType* _tmp79_;
	ValaDataType* _tmp80_;
	ValaDataType* _tmp81_;
	ValaDataType* _tmp82_;
	gboolean _tmp83_;
	ValaCCodeFunction* _tmp123_;
	ValaCCodeFunction* _tmp124_;
	ValaCCodeBinaryExpression* _tmp125_;
	ValaCCodeFunction* _tmp126_;
	ValaCCodeFunction* _tmp127_;
	ValaCCodeConstant* _tmp128_;
	ValaCCodeConstant* _tmp129_;
	ValaCCodeFunction* _tmp130_;
	ValaCCodeFunction* _tmp131_;
	ValaCCodeFunction* _tmp132_;
	ValaCCodeFunction* _tmp133_;
	ValaCCodeFunction* _tmp134_;
	ValaCCodeFunction* _tmp135_;
	ValaCCodeConstant* _tmp136_;
	ValaCCodeConstant* _tmp137_;
	ValaCCodeFile* _tmp138_;
	ValaCCodeFunction* _tmp139_;
	ValaCCodeFile* _tmp140_;
	ValaCCodeFunction* _tmp141_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (array_type != NULL, NULL);
	_tmp0_ = array_type;
	_tmp1_ = vala_array_type_get_element_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp2_, NULL);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup_printf ("_vala_%s_array_contains", _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	array_contains_func = _tmp6_;
	_tmp7_ = array_contains_func;
	_tmp8_ = vala_ccode_base_module_add_wrapper (self, _tmp7_);
	if (!_tmp8_) {
		result = array_contains_func;
		return result;
	}
	_tmp9_ = array_contains_func;
	_tmp10_ = vala_ccode_function_new (_tmp9_, "gboolean");
	function = _tmp10_;
	_tmp11_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp11_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp12_ = function;
	_tmp13_ = array_type;
	_tmp14_ = vala_array_type_get_element_type (_tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp15_);
	_tmp17_ = _tmp16_;
	_tmp18_ = g_strdup_printf ("%s *", _tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = vala_ccode_parameter_new ("stack", _tmp19_);
	_tmp21_ = _tmp20_;
	vala_ccode_function_add_parameter (_tmp12_, _tmp21_);
	_vala_ccode_node_unref0 (_tmp21_);
	_g_free0 (_tmp19_);
	_g_free0 (_tmp17_);
	_tmp22_ = function;
	_tmp23_ = vala_ccode_parameter_new ("stack_length", "int");
	_tmp24_ = _tmp23_;
	vala_ccode_function_add_parameter (_tmp22_, _tmp24_);
	_vala_ccode_node_unref0 (_tmp24_);
	_tmp25_ = array_type;
	_tmp26_ = vala_array_type_get_element_type (_tmp25_);
	_tmp27_ = _tmp26_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp27_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
		ValaCCodeFunction* _tmp28_;
		ValaArrayType* _tmp29_;
		ValaDataType* _tmp30_;
		ValaDataType* _tmp31_;
		gchar* _tmp32_;
		gchar* _tmp33_;
		gchar* _tmp34_;
		gchar* _tmp35_;
		ValaCCodeParameter* _tmp36_;
		ValaCCodeParameter* _tmp37_;
		_tmp28_ = function;
		_tmp29_ = array_type;
		_tmp30_ = vala_array_type_get_element_type (_tmp29_);
		_tmp31_ = _tmp30_;
		_tmp32_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp31_);
		_tmp33_ = _tmp32_;
		_tmp34_ = g_strdup_printf ("%s *", _tmp33_);
		_tmp35_ = _tmp34_;
		_tmp36_ = vala_ccode_parameter_new ("needle", _tmp35_);
		_tmp37_ = _tmp36_;
		vala_ccode_function_add_parameter (_tmp28_, _tmp37_);
		_vala_ccode_node_unref0 (_tmp37_);
		_g_free0 (_tmp35_);
		_g_free0 (_tmp33_);
	} else {
		ValaCCodeFunction* _tmp38_;
		ValaArrayType* _tmp39_;
		ValaDataType* _tmp40_;
		ValaDataType* _tmp41_;
		gchar* _tmp42_;
		gchar* _tmp43_;
		ValaCCodeParameter* _tmp44_;
		ValaCCodeParameter* _tmp45_;
		_tmp38_ = function;
		_tmp39_ = array_type;
		_tmp40_ = vala_array_type_get_element_type (_tmp39_);
		_tmp41_ = _tmp40_;
		_tmp42_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp41_);
		_tmp43_ = _tmp42_;
		_tmp44_ = vala_ccode_parameter_new ("needle", _tmp43_);
		_tmp45_ = _tmp44_;
		vala_ccode_function_add_parameter (_tmp38_, _tmp45_);
		_vala_ccode_node_unref0 (_tmp45_);
		_g_free0 (_tmp43_);
	}
	_tmp46_ = function;
	vala_ccode_base_module_push_function (self, _tmp46_);
	_tmp47_ = vala_ccode_base_module_get_ccode (self);
	_tmp48_ = _tmp47_;
	_tmp49_ = vala_ccode_variable_declarator_new ("i", NULL, NULL);
	_tmp50_ = _tmp49_;
	vala_ccode_function_add_declaration (_tmp48_, "int", (ValaCCodeDeclarator*) _tmp50_, 0);
	_vala_ccode_node_unref0 (_tmp50_);
	_tmp51_ = vala_ccode_identifier_new ("i");
	_tmp52_ = _tmp51_;
	_tmp53_ = vala_ccode_constant_new ("0");
	_tmp54_ = _tmp53_;
	_tmp55_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp52_, (ValaCCodeExpression*) _tmp54_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
	_tmp56_ = _tmp55_;
	_vala_ccode_node_unref0 (_tmp54_);
	_vala_ccode_node_unref0 (_tmp52_);
	cloop_initializer = _tmp56_;
	_tmp57_ = vala_ccode_identifier_new ("i");
	_tmp58_ = _tmp57_;
	_tmp59_ = vala_ccode_identifier_new ("stack_length");
	_tmp60_ = _tmp59_;
	_tmp61_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_LESS_THAN, (ValaCCodeExpression*) _tmp58_, (ValaCCodeExpression*) _tmp60_);
	_tmp62_ = _tmp61_;
	_vala_ccode_node_unref0 (_tmp60_);
	_vala_ccode_node_unref0 (_tmp58_);
	cloop_condition = _tmp62_;
	_tmp63_ = vala_ccode_identifier_new ("i");
	_tmp64_ = _tmp63_;
	_tmp65_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp64_);
	_tmp66_ = _tmp65_;
	_vala_ccode_node_unref0 (_tmp64_);
	cloop_iterator = _tmp66_;
	_tmp67_ = vala_ccode_base_module_get_ccode (self);
	_tmp68_ = _tmp67_;
	_tmp69_ = cloop_initializer;
	_tmp70_ = cloop_condition;
	_tmp71_ = cloop_iterator;
	vala_ccode_function_open_for (_tmp68_, (ValaCCodeExpression*) _tmp69_, (ValaCCodeExpression*) _tmp70_, (ValaCCodeExpression*) _tmp71_);
	_tmp72_ = vala_ccode_identifier_new ("stack");
	_tmp73_ = _tmp72_;
	_tmp74_ = vala_ccode_identifier_new ("i");
	_tmp75_ = _tmp74_;
	_tmp76_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp73_, (ValaCCodeExpression*) _tmp75_);
	_tmp77_ = _tmp76_;
	_vala_ccode_node_unref0 (_tmp75_);
	_vala_ccode_node_unref0 (_tmp73_);
	celement = _tmp77_;
	_tmp78_ = vala_ccode_identifier_new ("needle");
	cneedle = _tmp78_;
	_tmp79_ = array_type;
	_tmp80_ = vala_array_type_get_element_type (_tmp79_);
	_tmp81_ = _tmp80_;
	_tmp82_ = self->string_type;
	_tmp83_ = vala_data_type_compatible (_tmp81_, _tmp82_);
	if (_tmp83_) {
		ValaCCodeFunctionCall* ccall = NULL;
		ValaCCodeIdentifier* _tmp84_;
		ValaCCodeIdentifier* _tmp85_;
		ValaCCodeFunctionCall* _tmp86_;
		ValaCCodeFunctionCall* _tmp87_;
		ValaCCodeFunctionCall* _tmp88_;
		ValaCCodeElementAccess* _tmp89_;
		ValaCCodeFunctionCall* _tmp90_;
		ValaCCodeIdentifier* _tmp91_;
		ValaCCodeFunctionCall* _tmp92_;
		ValaCCodeConstant* _tmp93_;
		ValaCCodeConstant* _tmp94_;
		ValaCCodeBinaryExpression* _tmp95_;
		_tmp84_ = vala_ccode_identifier_new ("g_strcmp0");
		_tmp85_ = _tmp84_;
		_tmp86_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp85_);
		_tmp87_ = _tmp86_;
		_vala_ccode_node_unref0 (_tmp85_);
		ccall = _tmp87_;
		_tmp88_ = ccall;
		_tmp89_ = celement;
		vala_ccode_function_call_add_argument (_tmp88_, (ValaCCodeExpression*) _tmp89_);
		_tmp90_ = ccall;
		_tmp91_ = cneedle;
		vala_ccode_function_call_add_argument (_tmp90_, (ValaCCodeExpression*) _tmp91_);
		_tmp92_ = ccall;
		_tmp93_ = vala_ccode_constant_new ("0");
		_tmp94_ = _tmp93_;
		_tmp95_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp92_, (ValaCCodeExpression*) _tmp94_);
		_vala_ccode_node_unref0 (cif_condition);
		cif_condition = _tmp95_;
		_vala_ccode_node_unref0 (_tmp94_);
		_vala_ccode_node_unref0 (ccall);
	} else {
		ValaArrayType* _tmp96_;
		ValaDataType* _tmp97_;
		ValaDataType* _tmp98_;
		_tmp96_ = array_type;
		_tmp97_ = vala_array_type_get_element_type (_tmp96_);
		_tmp98_ = _tmp97_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp98_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
			gchar* equalfunc = NULL;
			ValaArrayType* _tmp99_;
			ValaDataType* _tmp100_;
			ValaDataType* _tmp101_;
			ValaTypeSymbol* _tmp102_;
			ValaTypeSymbol* _tmp103_;
			gchar* _tmp104_;
			ValaCCodeFunctionCall* ccall = NULL;
			const gchar* _tmp105_;
			ValaCCodeIdentifier* _tmp106_;
			ValaCCodeIdentifier* _tmp107_;
			ValaCCodeFunctionCall* _tmp108_;
			ValaCCodeFunctionCall* _tmp109_;
			ValaCCodeFunctionCall* _tmp110_;
			ValaCCodeElementAccess* _tmp111_;
			ValaCCodeUnaryExpression* _tmp112_;
			ValaCCodeUnaryExpression* _tmp113_;
			ValaCCodeFunctionCall* _tmp114_;
			ValaCCodeIdentifier* _tmp115_;
			ValaCCodeFunctionCall* _tmp116_;
			ValaCCodeConstant* _tmp117_;
			ValaCCodeConstant* _tmp118_;
			ValaCCodeBinaryExpression* _tmp119_;
			_tmp99_ = array_type;
			_tmp100_ = vala_array_type_get_element_type (_tmp99_);
			_tmp101_ = _tmp100_;
			_tmp102_ = vala_data_type_get_data_type (_tmp101_);
			_tmp103_ = _tmp102_;
			_tmp104_ = vala_ccode_base_module_generate_struct_equal_function (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp103_, VALA_TYPE_STRUCT, ValaStruct));
			equalfunc = _tmp104_;
			_tmp105_ = equalfunc;
			_tmp106_ = vala_ccode_identifier_new (_tmp105_);
			_tmp107_ = _tmp106_;
			_tmp108_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp107_);
			_tmp109_ = _tmp108_;
			_vala_ccode_node_unref0 (_tmp107_);
			ccall = _tmp109_;
			_tmp110_ = ccall;
			_tmp111_ = celement;
			_tmp112_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp111_);
			_tmp113_ = _tmp112_;
			vala_ccode_function_call_add_argument (_tmp110_, (ValaCCodeExpression*) _tmp113_);
			_vala_ccode_node_unref0 (_tmp113_);
			_tmp114_ = ccall;
			_tmp115_ = cneedle;
			vala_ccode_function_call_add_argument (_tmp114_, (ValaCCodeExpression*) _tmp115_);
			_tmp116_ = ccall;
			_tmp117_ = vala_ccode_constant_new ("TRUE");
			_tmp118_ = _tmp117_;
			_tmp119_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp116_, (ValaCCodeExpression*) _tmp118_);
			_vala_ccode_node_unref0 (cif_condition);
			cif_condition = _tmp119_;
			_vala_ccode_node_unref0 (_tmp118_);
			_vala_ccode_node_unref0 (ccall);
			_g_free0 (equalfunc);
		} else {
			ValaCCodeIdentifier* _tmp120_;
			ValaCCodeElementAccess* _tmp121_;
			ValaCCodeBinaryExpression* _tmp122_;
			_tmp120_ = cneedle;
			_tmp121_ = celement;
			_tmp122_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp120_, (ValaCCodeExpression*) _tmp121_);
			_vala_ccode_node_unref0 (cif_condition);
			cif_condition = _tmp122_;
		}
	}
	_tmp123_ = vala_ccode_base_module_get_ccode (self);
	_tmp124_ = _tmp123_;
	_tmp125_ = cif_condition;
	vala_ccode_function_open_if (_tmp124_, (ValaCCodeExpression*) _tmp125_);
	_tmp126_ = vala_ccode_base_module_get_ccode (self);
	_tmp127_ = _tmp126_;
	_tmp128_ = vala_ccode_constant_new ("TRUE");
	_tmp129_ = _tmp128_;
	vala_ccode_function_add_return (_tmp127_, (ValaCCodeExpression*) _tmp129_);
	_vala_ccode_node_unref0 (_tmp129_);
	_tmp130_ = vala_ccode_base_module_get_ccode (self);
	_tmp131_ = _tmp130_;
	vala_ccode_function_close (_tmp131_);
	_tmp132_ = vala_ccode_base_module_get_ccode (self);
	_tmp133_ = _tmp132_;
	vala_ccode_function_close (_tmp133_);
	_tmp134_ = vala_ccode_base_module_get_ccode (self);
	_tmp135_ = _tmp134_;
	_tmp136_ = vala_ccode_constant_new ("FALSE");
	_tmp137_ = _tmp136_;
	vala_ccode_function_add_return (_tmp135_, (ValaCCodeExpression*) _tmp137_);
	_vala_ccode_node_unref0 (_tmp137_);
	vala_ccode_base_module_pop_function (self);
	_tmp138_ = self->cfile;
	_tmp139_ = function;
	vala_ccode_file_add_function_declaration (_tmp138_, _tmp139_);
	_tmp140_ = self->cfile;
	_tmp141_ = function;
	vala_ccode_file_add_function (_tmp140_, _tmp141_);
	result = array_contains_func;
	_vala_ccode_node_unref0 (cif_condition);
	_vala_ccode_node_unref0 (cneedle);
	_vala_ccode_node_unref0 (celement);
	_vala_ccode_node_unref0 (cloop_iterator);
	_vala_ccode_node_unref0 (cloop_condition);
	_vala_ccode_node_unref0 (cloop_initializer);
	_vala_ccode_node_unref0 (function);
	return result;
}


static void vala_ccode_base_module_real_visit_type_check (ValaCodeVisitor* base, ValaTypeCheck* expr) {
	ValaCCodeBaseModule * self;
	ValaTypeCheck* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaCCodeFile* _tmp3_;
	ValaDataType* type = NULL;
	ValaTypeCheck* _tmp4_;
	ValaExpression* _tmp5_;
	ValaExpression* _tmp6_;
	ValaDataType* _tmp7_;
	ValaDataType* _tmp8_;
	ValaDataType* _tmp9_;
	ValaPointerType* pointer_type = NULL;
	ValaDataType* _tmp10_;
	ValaPointerType* _tmp11_;
	ValaPointerType* _tmp12_;
	ValaClass* cl = NULL;
	ValaDataType* _tmp17_;
	ValaTypeSymbol* _tmp18_;
	ValaTypeSymbol* _tmp19_;
	ValaClass* _tmp20_;
	ValaInterface* iface = NULL;
	ValaDataType* _tmp21_;
	ValaTypeSymbol* _tmp22_;
	ValaTypeSymbol* _tmp23_;
	ValaInterface* _tmp24_;
	gboolean _tmp25_ = FALSE;
	gboolean _tmp26_ = FALSE;
	gboolean _tmp27_ = FALSE;
	gboolean _tmp28_ = FALSE;
	ValaClass* _tmp29_;
	ValaTypeCheck* _tmp50_;
	ValaCCodeExpression* _tmp51_;
	ValaCCodeExpression* _tmp52_;
	gboolean _tmp53_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_typecheck_get_type_reference (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->cfile;
	vala_ccode_base_module_generate_type_declaration (self, _tmp2_, _tmp3_);
	_tmp4_ = expr;
	_tmp5_ = vala_typecheck_get_expression (_tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = vala_expression_get_value_type (_tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = _vala_code_node_ref0 (_tmp8_);
	type = _tmp9_;
	_tmp10_ = type;
	_tmp11_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_POINTER_TYPE) ? ((ValaPointerType*) _tmp10_) : NULL);
	pointer_type = _tmp11_;
	_tmp12_ = pointer_type;
	if (_tmp12_ != NULL) {
		ValaPointerType* _tmp13_;
		ValaDataType* _tmp14_;
		ValaDataType* _tmp15_;
		ValaDataType* _tmp16_;
		_tmp13_ = pointer_type;
		_tmp14_ = vala_pointer_type_get_base_type (_tmp13_);
		_tmp15_ = _tmp14_;
		_tmp16_ = _vala_code_node_ref0 (_tmp15_);
		_vala_code_node_unref0 (type);
		type = _tmp16_;
	}
	_tmp17_ = type;
	_tmp18_ = vala_data_type_get_data_type (_tmp17_);
	_tmp19_ = _tmp18_;
	_tmp20_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp19_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp19_) : NULL);
	cl = _tmp20_;
	_tmp21_ = type;
	_tmp22_ = vala_data_type_get_data_type (_tmp21_);
	_tmp23_ = _tmp22_;
	_tmp24_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_INTERFACE) ? ((ValaInterface*) _tmp23_) : NULL);
	iface = _tmp24_;
	_tmp29_ = cl;
	if (_tmp29_ != NULL) {
		ValaClass* _tmp30_;
		gboolean _tmp31_;
		gboolean _tmp32_;
		_tmp30_ = cl;
		_tmp31_ = vala_class_get_is_compact (_tmp30_);
		_tmp32_ = _tmp31_;
		_tmp28_ = !_tmp32_;
	} else {
		_tmp28_ = FALSE;
	}
	if (_tmp28_) {
		_tmp27_ = TRUE;
	} else {
		ValaInterface* _tmp33_;
		_tmp33_ = iface;
		_tmp27_ = _tmp33_ != NULL;
	}
	if (_tmp27_) {
		_tmp26_ = TRUE;
	} else {
		ValaDataType* _tmp34_;
		_tmp34_ = type;
		_tmp26_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp34_, VALA_TYPE_GENERIC_TYPE);
	}
	if (_tmp26_) {
		_tmp25_ = TRUE;
	} else {
		ValaDataType* _tmp35_;
		_tmp35_ = type;
		_tmp25_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp35_, VALA_TYPE_ERROR_TYPE);
	}
	if (_tmp25_) {
		ValaTypeCheck* _tmp36_;
		ValaTypeCheck* _tmp37_;
		ValaExpression* _tmp38_;
		ValaExpression* _tmp39_;
		ValaCCodeExpression* _tmp40_;
		ValaCCodeExpression* _tmp41_;
		ValaTypeCheck* _tmp42_;
		ValaDataType* _tmp43_;
		ValaDataType* _tmp44_;
		ValaCCodeExpression* _tmp45_;
		ValaCCodeExpression* _tmp46_;
		_tmp36_ = expr;
		_tmp37_ = expr;
		_tmp38_ = vala_typecheck_get_expression (_tmp37_);
		_tmp39_ = _tmp38_;
		_tmp40_ = vala_ccode_base_module_get_cvalue (self, _tmp39_);
		_tmp41_ = _tmp40_;
		_tmp42_ = expr;
		_tmp43_ = vala_typecheck_get_type_reference (_tmp42_);
		_tmp44_ = _tmp43_;
		_tmp45_ = vala_ccode_base_module_create_type_check (self, (ValaCCodeNode*) _tmp41_, _tmp44_);
		_tmp46_ = _tmp45_;
		vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp36_, _tmp46_);
		_vala_ccode_node_unref0 (_tmp46_);
		_vala_ccode_node_unref0 (_tmp41_);
	} else {
		ValaTypeCheck* _tmp47_;
		ValaCCodeInvalidExpression* _tmp48_;
		ValaCCodeInvalidExpression* _tmp49_;
		_tmp47_ = expr;
		_tmp48_ = vala_ccode_invalid_expression_new ();
		_tmp49_ = _tmp48_;
		vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp47_, (ValaCCodeExpression*) _tmp49_);
		_vala_ccode_node_unref0 (_tmp49_);
	}
	_tmp50_ = expr;
	_tmp51_ = vala_ccode_base_module_get_cvalue (self, (ValaExpression*) _tmp50_);
	_tmp52_ = _tmp51_;
	_tmp53_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp52_, VALA_TYPE_CCODE_INVALID_EXPRESSION);
	_vala_ccode_node_unref0 (_tmp52_);
	if (_tmp53_) {
		ValaTypeCheck* _tmp54_;
		ValaSourceReference* _tmp55_;
		ValaSourceReference* _tmp56_;
		_tmp54_ = expr;
		_tmp55_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp54_);
		_tmp56_ = _tmp55_;
		vala_report_error (_tmp56_, "type check expressions not supported for compact classes, structs, and" \
" enums");
	}
	_vala_code_node_unref0 (iface);
	_vala_code_node_unref0 (cl);
	_vala_code_node_unref0 (pointer_type);
	_vala_code_node_unref0 (type);
}


static void vala_ccode_base_module_real_visit_lambda_expression (ValaCodeVisitor* base, ValaLambdaExpression* lambda) {
	ValaCCodeBaseModule * self;
	ValaDelegateType* delegate_type = NULL;
	ValaLambdaExpression* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaDelegateType* _tmp3_;
	ValaDelegate* d = NULL;
	ValaDelegateType* _tmp4_;
	ValaDelegate* _tmp5_;
	ValaDelegate* _tmp6_;
	ValaDelegate* _tmp7_;
	ValaLambdaExpression* _tmp8_;
	ValaMethod* _tmp9_;
	ValaMethod* _tmp10_;
	ValaDelegate* _tmp11_;
	gboolean _tmp12_;
	ValaLambdaExpression* _tmp13_;
	ValaMethod* _tmp14_;
	ValaMethod* _tmp15_;
	ValaDelegate* _tmp16_;
	gboolean _tmp17_;
	ValaLambdaExpression* _tmp18_;
	ValaMethod* _tmp19_;
	ValaMethod* _tmp20_;
	ValaDelegate* _tmp21_;
	gchar* _tmp22_;
	gchar* _tmp23_;
	ValaLambdaExpression* _tmp24_;
	gboolean expr_owned = FALSE;
	ValaLambdaExpression* _tmp25_;
	ValaDataType* _tmp26_;
	ValaDataType* _tmp27_;
	gboolean _tmp28_;
	gboolean _tmp29_;
	ValaLambdaExpression* _tmp30_;
	ValaLambdaExpression* _tmp31_;
	ValaMethod* _tmp32_;
	ValaMethod* _tmp33_;
	gchar* _tmp34_;
	gchar* _tmp35_;
	ValaCCodeIdentifier* _tmp36_;
	ValaCCodeIdentifier* _tmp37_;
	ValaLambdaExpression* _tmp38_;
	ValaMethod* _tmp39_;
	ValaMethod* _tmp40_;
	gboolean _tmp41_;
	gboolean _tmp42_;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (lambda != NULL);
	_tmp0_ = lambda;
	_tmp1_ = vala_expression_get_target_type ((ValaExpression*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
	delegate_type = _tmp3_;
	_tmp4_ = delegate_type;
	_tmp5_ = vala_delegate_type_get_delegate_symbol (_tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = _vala_code_node_ref0 (_tmp6_);
	d = _tmp7_;
	_tmp8_ = lambda;
	_tmp9_ = vala_lambda_expression_get_method (_tmp8_);
	_tmp10_ = _tmp9_;
	_tmp11_ = d;
	_tmp12_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp11_);
	vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp10_, "CCode", "array_length", _tmp12_, NULL);
	_tmp13_ = lambda;
	_tmp14_ = vala_lambda_expression_get_method (_tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = d;
	_tmp17_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp16_);
	vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp15_, "CCode", "array_null_terminated", _tmp17_, NULL);
	_tmp18_ = lambda;
	_tmp19_ = vala_lambda_expression_get_method (_tmp18_);
	_tmp20_ = _tmp19_;
	_tmp21_ = d;
	_tmp22_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp21_);
	_tmp23_ = _tmp22_;
	vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp20_, "CCode", "array_length_type", _tmp23_, NULL);
	_g_free0 (_tmp23_);
	_tmp24_ = lambda;
	vala_code_node_accept_children ((ValaCodeNode*) _tmp24_, (ValaCodeVisitor*) self);
	_tmp25_ = lambda;
	_tmp26_ = vala_expression_get_value_type ((ValaExpression*) _tmp25_);
	_tmp27_ = _tmp26_;
	_tmp28_ = vala_data_type_get_value_owned (_tmp27_);
	_tmp29_ = _tmp28_;
	expr_owned = _tmp29_;
	_tmp30_ = lambda;
	_tmp31_ = lambda;
	_tmp32_ = vala_lambda_expression_get_method (_tmp31_);
	_tmp33_ = _tmp32_;
	_tmp34_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp33_);
	_tmp35_ = _tmp34_;
	_tmp36_ = vala_ccode_identifier_new (_tmp35_);
	_tmp37_ = _tmp36_;
	vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp30_, (ValaCCodeExpression*) _tmp37_);
	_vala_ccode_node_unref0 (_tmp37_);
	_g_free0 (_tmp35_);
	_tmp38_ = lambda;
	_tmp39_ = vala_lambda_expression_get_method (_tmp38_);
	_tmp40_ = _tmp39_;
	_tmp41_ = vala_method_get_closure (_tmp40_);
	_tmp42_ = _tmp41_;
	if (_tmp42_) {
		gint block_id = 0;
		ValaBlock* _tmp43_;
		ValaBlock* _tmp44_;
		gint _tmp45_;
		ValaCCodeExpression* delegate_target = NULL;
		gint _tmp46_;
		gchar* _tmp47_;
		gchar* _tmp48_;
		ValaCCodeExpression* _tmp49_;
		ValaCCodeExpression* _tmp50_;
		gboolean _tmp51_ = FALSE;
		gboolean _tmp52_;
		ValaLambdaExpression* _tmp76_;
		ValaCCodeExpression* _tmp77_;
		_tmp43_ = vala_ccode_base_module_get_current_closure_block (self);
		_tmp44_ = _tmp43_;
		_tmp45_ = vala_ccode_base_module_get_block_id (self, _tmp44_);
		block_id = _tmp45_;
		_tmp46_ = block_id;
		_tmp47_ = g_strdup_printf ("_data%d_", _tmp46_);
		_tmp48_ = _tmp47_;
		_tmp49_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp48_);
		_tmp50_ = _tmp49_;
		_g_free0 (_tmp48_);
		delegate_target = _tmp50_;
		_tmp52_ = expr_owned;
		if (_tmp52_) {
			_tmp51_ = TRUE;
		} else {
			ValaDelegateType* _tmp53_;
			gboolean _tmp54_;
			gboolean _tmp55_;
			_tmp53_ = delegate_type;
			_tmp54_ = vala_delegate_type_get_is_called_once (_tmp53_);
			_tmp55_ = _tmp54_;
			_tmp51_ = _tmp55_;
		}
		if (_tmp51_) {
			ValaCCodeFunctionCall* ref_call = NULL;
			gint _tmp56_;
			gchar* _tmp57_;
			gchar* _tmp58_;
			ValaCCodeIdentifier* _tmp59_;
			ValaCCodeIdentifier* _tmp60_;
			ValaCCodeFunctionCall* _tmp61_;
			ValaCCodeFunctionCall* _tmp62_;
			ValaCCodeFunctionCall* _tmp63_;
			ValaCCodeExpression* _tmp64_;
			ValaCCodeFunctionCall* _tmp65_;
			ValaCCodeExpression* _tmp66_;
			ValaLambdaExpression* _tmp67_;
			gint _tmp68_;
			gchar* _tmp69_;
			gchar* _tmp70_;
			ValaCCodeIdentifier* _tmp71_;
			ValaCCodeIdentifier* _tmp72_;
			_tmp56_ = block_id;
			_tmp57_ = g_strdup_printf ("block%d_data_ref", _tmp56_);
			_tmp58_ = _tmp57_;
			_tmp59_ = vala_ccode_identifier_new (_tmp58_);
			_tmp60_ = _tmp59_;
			_tmp61_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp60_);
			_tmp62_ = _tmp61_;
			_vala_ccode_node_unref0 (_tmp60_);
			_g_free0 (_tmp58_);
			ref_call = _tmp62_;
			_tmp63_ = ref_call;
			_tmp64_ = delegate_target;
			vala_ccode_function_call_add_argument (_tmp63_, _tmp64_);
			_tmp65_ = ref_call;
			_tmp66_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp65_);
			_vala_ccode_node_unref0 (delegate_target);
			delegate_target = _tmp66_;
			_tmp67_ = lambda;
			_tmp68_ = block_id;
			_tmp69_ = g_strdup_printf ("block%d_data_unref", _tmp68_);
			_tmp70_ = _tmp69_;
			_tmp71_ = vala_ccode_identifier_new (_tmp70_);
			_tmp72_ = _tmp71_;
			vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp67_, (ValaCCodeExpression*) _tmp72_);
			_vala_ccode_node_unref0 (_tmp72_);
			_g_free0 (_tmp70_);
			_vala_ccode_node_unref0 (ref_call);
		} else {
			ValaLambdaExpression* _tmp73_;
			ValaCCodeConstant* _tmp74_;
			ValaCCodeConstant* _tmp75_;
			_tmp73_ = lambda;
			_tmp74_ = vala_ccode_constant_new ("NULL");
			_tmp75_ = _tmp74_;
			vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp73_, (ValaCCodeExpression*) _tmp75_);
			_vala_ccode_node_unref0 (_tmp75_);
		}
		_tmp76_ = lambda;
		_tmp77_ = delegate_target;
		vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp76_, _tmp77_);
		_vala_ccode_node_unref0 (delegate_target);
	} else {
		ValaDataType* _tmp78_;
		ValaDataType* _tmp79_;
		gboolean _tmp80_;
		_tmp78_ = vala_ccode_base_module_get_this_type (self);
		_tmp79_ = _tmp78_;
		_tmp80_ = _tmp79_ != NULL;
		_vala_code_node_unref0 (_tmp79_);
		if (_tmp80_) {
			ValaCCodeExpression* delegate_target = NULL;
			ValaCCodeExpression* _tmp81_;
			ValaCCodeExpression* _tmp82_;
			ValaDataType* _tmp83_;
			ValaDataType* _tmp84_;
			ValaCCodeExpression* _tmp85_;
			gboolean _tmp86_ = FALSE;
			gboolean _tmp87_;
			ValaLambdaExpression* _tmp126_;
			ValaCCodeExpression* _tmp127_;
			_tmp81_ = vala_ccode_base_module_get_result_cexpression (self, "self");
			delegate_target = _tmp81_;
			_tmp82_ = delegate_target;
			_tmp83_ = vala_ccode_base_module_get_this_type (self);
			_tmp84_ = _tmp83_;
			_tmp85_ = vala_ccode_base_module_convert_to_generic_pointer (self, _tmp82_, _tmp84_);
			_vala_ccode_node_unref0 (delegate_target);
			delegate_target = _tmp85_;
			_vala_code_node_unref0 (_tmp84_);
			_tmp87_ = expr_owned;
			if (_tmp87_) {
				_tmp86_ = TRUE;
			} else {
				ValaDelegateType* _tmp88_;
				gboolean _tmp89_;
				gboolean _tmp90_;
				_tmp88_ = delegate_type;
				_tmp89_ = vala_delegate_type_get_is_called_once (_tmp88_);
				_tmp90_ = _tmp89_;
				_tmp86_ = _tmp90_;
			}
			if (_tmp86_) {
				ValaDataType* _tmp91_;
				ValaDataType* _tmp92_;
				gboolean _tmp93_;
				_tmp91_ = vala_ccode_base_module_get_this_type (self);
				_tmp92_ = _tmp91_;
				_tmp93_ = _tmp92_ != NULL;
				_vala_code_node_unref0 (_tmp92_);
				if (_tmp93_) {
					ValaCCodeFunctionCall* ref_call = NULL;
					ValaDataType* _tmp94_;
					ValaDataType* _tmp95_;
					ValaLambdaExpression* _tmp96_;
					ValaSourceReference* _tmp97_;
					ValaSourceReference* _tmp98_;
					ValaCCodeExpression* _tmp99_;
					ValaCCodeExpression* _tmp100_;
					ValaCCodeFunctionCall* _tmp101_;
					ValaCCodeFunctionCall* _tmp102_;
					ValaCCodeFunctionCall* _tmp103_;
					ValaCCodeExpression* _tmp104_;
					ValaCCodeFunctionCall* _tmp105_;
					ValaCCodeExpression* _tmp106_;
					ValaLambdaExpression* _tmp107_;
					ValaDataType* _tmp108_;
					ValaDataType* _tmp109_;
					ValaCCodeExpression* _tmp110_;
					ValaCCodeExpression* _tmp111_;
					_tmp94_ = vala_ccode_base_module_get_this_type (self);
					_tmp95_ = _tmp94_;
					_tmp96_ = lambda;
					_tmp97_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp96_);
					_tmp98_ = _tmp97_;
					_tmp99_ = vala_ccode_base_module_get_dup_func_expression (self, _tmp95_, _tmp98_, FALSE);
					_tmp100_ = _tmp99_;
					_tmp101_ = vala_ccode_function_call_new (_tmp100_);
					_tmp102_ = _tmp101_;
					_vala_ccode_node_unref0 (_tmp100_);
					_vala_code_node_unref0 (_tmp95_);
					ref_call = _tmp102_;
					_tmp103_ = ref_call;
					_tmp104_ = delegate_target;
					vala_ccode_function_call_add_argument (_tmp103_, _tmp104_);
					_tmp105_ = ref_call;
					_tmp106_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp105_);
					_vala_ccode_node_unref0 (delegate_target);
					delegate_target = _tmp106_;
					_tmp107_ = lambda;
					_tmp108_ = vala_ccode_base_module_get_this_type (self);
					_tmp109_ = _tmp108_;
					_tmp110_ = vala_ccode_base_module_get_destroy_func_expression (self, _tmp109_, FALSE);
					_tmp111_ = _tmp110_;
					vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp107_, _tmp111_);
					_vala_ccode_node_unref0 (_tmp111_);
					_vala_code_node_unref0 (_tmp109_);
					_vala_ccode_node_unref0 (ref_call);
				} else {
					ValaCCodeFunctionCall* ref_call = NULL;
					ValaCCodeIdentifier* _tmp112_;
					ValaCCodeIdentifier* _tmp113_;
					ValaCCodeFunctionCall* _tmp114_;
					ValaCCodeFunctionCall* _tmp115_;
					ValaCCodeFunctionCall* _tmp116_;
					ValaCCodeExpression* _tmp117_;
					ValaCCodeFunctionCall* _tmp118_;
					ValaCCodeExpression* _tmp119_;
					ValaLambdaExpression* _tmp120_;
					ValaCCodeIdentifier* _tmp121_;
					ValaCCodeIdentifier* _tmp122_;
					_tmp112_ = vala_ccode_identifier_new ("g_object_ref");
					_tmp113_ = _tmp112_;
					_tmp114_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp113_);
					_tmp115_ = _tmp114_;
					_vala_ccode_node_unref0 (_tmp113_);
					ref_call = _tmp115_;
					_tmp116_ = ref_call;
					_tmp117_ = delegate_target;
					vala_ccode_function_call_add_argument (_tmp116_, _tmp117_);
					_tmp118_ = ref_call;
					_tmp119_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp118_);
					_vala_ccode_node_unref0 (delegate_target);
					delegate_target = _tmp119_;
					_tmp120_ = lambda;
					_tmp121_ = vala_ccode_identifier_new ("g_object_unref");
					_tmp122_ = _tmp121_;
					vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp120_, (ValaCCodeExpression*) _tmp122_);
					_vala_ccode_node_unref0 (_tmp122_);
					_vala_ccode_node_unref0 (ref_call);
				}
			} else {
				ValaLambdaExpression* _tmp123_;
				ValaCCodeConstant* _tmp124_;
				ValaCCodeConstant* _tmp125_;
				_tmp123_ = lambda;
				_tmp124_ = vala_ccode_constant_new ("NULL");
				_tmp125_ = _tmp124_;
				vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp123_, (ValaCCodeExpression*) _tmp125_);
				_vala_ccode_node_unref0 (_tmp125_);
			}
			_tmp126_ = lambda;
			_tmp127_ = delegate_target;
			vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp126_, _tmp127_);
			_vala_ccode_node_unref0 (delegate_target);
		} else {
			ValaLambdaExpression* _tmp128_;
			ValaCCodeConstant* _tmp129_;
			ValaCCodeConstant* _tmp130_;
			ValaLambdaExpression* _tmp131_;
			ValaCCodeConstant* _tmp132_;
			ValaCCodeConstant* _tmp133_;
			_tmp128_ = lambda;
			_tmp129_ = vala_ccode_constant_new ("NULL");
			_tmp130_ = _tmp129_;
			vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp128_, (ValaCCodeExpression*) _tmp130_);
			_vala_ccode_node_unref0 (_tmp130_);
			_tmp131_ = lambda;
			_tmp132_ = vala_ccode_constant_new ("NULL");
			_tmp133_ = _tmp132_;
			vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp131_, (ValaCCodeExpression*) _tmp133_);
			_vala_ccode_node_unref0 (_tmp133_);
		}
	}
	_vala_code_node_unref0 (d);
	_vala_code_node_unref0 (delegate_type);
}


ValaCCodeExpression* vala_ccode_base_module_convert_from_generic_pointer (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr, ValaDataType* actual_type) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeExpression* _result_ = NULL;
	ValaCCodeExpression* _tmp0_;
	ValaCCodeExpression* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaDataType* _tmp3_;
	gboolean _tmp4_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (cexpr != NULL, NULL);
	g_return_val_if_fail (actual_type != NULL, NULL);
	_tmp0_ = cexpr;
	_tmp1_ = _vala_ccode_node_ref0 (_tmp0_);
	_result_ = _tmp1_;
	_tmp3_ = actual_type;
	_tmp4_ = vala_ccode_base_module_is_reference_type_argument (self, _tmp3_);
	if (_tmp4_) {
		_tmp2_ = TRUE;
	} else {
		ValaDataType* _tmp5_;
		gboolean _tmp6_;
		_tmp5_ = actual_type;
		_tmp6_ = vala_ccode_base_module_is_nullable_value_type_argument (self, _tmp5_);
		_tmp2_ = _tmp6_;
	}
	if (_tmp2_) {
		ValaCCodeExpression* _tmp7_;
		ValaDataType* _tmp8_;
		gchar* _tmp9_;
		gchar* _tmp10_;
		ValaCCodeCastExpression* _tmp11_;
		_tmp7_ = cexpr;
		_tmp8_ = actual_type;
		_tmp9_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp8_);
		_tmp10_ = _tmp9_;
		_tmp11_ = vala_ccode_cast_expression_new (_tmp7_, _tmp10_);
		_vala_ccode_node_unref0 (_result_);
		_result_ = (ValaCCodeExpression*) _tmp11_;
		_g_free0 (_tmp10_);
	} else {
		ValaDataType* _tmp12_;
		gboolean _tmp13_;
		_tmp12_ = actual_type;
		_tmp13_ = vala_ccode_base_module_is_signed_integer_type_argument (self, _tmp12_);
		if (_tmp13_) {
			ValaCCodeExpression* _tmp14_;
			ValaCCodeCastExpression* _tmp15_;
			ValaCCodeCastExpression* _tmp16_;
			ValaDataType* _tmp17_;
			gchar* _tmp18_;
			gchar* _tmp19_;
			ValaCCodeCastExpression* _tmp20_;
			_tmp14_ = cexpr;
			_tmp15_ = vala_ccode_cast_expression_new (_tmp14_, "gintptr");
			_tmp16_ = _tmp15_;
			_tmp17_ = actual_type;
			_tmp18_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp17_);
			_tmp19_ = _tmp18_;
			_tmp20_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp16_, _tmp19_);
			_vala_ccode_node_unref0 (_result_);
			_result_ = (ValaCCodeExpression*) _tmp20_;
			_g_free0 (_tmp19_);
			_vala_ccode_node_unref0 (_tmp16_);
		} else {
			ValaDataType* _tmp21_;
			gboolean _tmp22_;
			_tmp21_ = actual_type;
			_tmp22_ = vala_ccode_base_module_is_unsigned_integer_type_argument (self, _tmp21_);
			if (_tmp22_) {
				ValaCCodeExpression* _tmp23_;
				ValaCCodeCastExpression* _tmp24_;
				ValaCCodeCastExpression* _tmp25_;
				ValaDataType* _tmp26_;
				gchar* _tmp27_;
				gchar* _tmp28_;
				ValaCCodeCastExpression* _tmp29_;
				_tmp23_ = cexpr;
				_tmp24_ = vala_ccode_cast_expression_new (_tmp23_, "guintptr");
				_tmp25_ = _tmp24_;
				_tmp26_ = actual_type;
				_tmp27_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp26_);
				_tmp28_ = _tmp27_;
				_tmp29_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp25_, _tmp28_);
				_vala_ccode_node_unref0 (_result_);
				_result_ = (ValaCCodeExpression*) _tmp29_;
				_g_free0 (_tmp28_);
				_vala_ccode_node_unref0 (_tmp25_);
			}
		}
	}
	result = _result_;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_convert_to_generic_pointer (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr, ValaDataType* actual_type) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeExpression* _result_ = NULL;
	ValaCCodeExpression* _tmp0_;
	ValaCCodeExpression* _tmp1_;
	ValaDataType* _tmp2_;
	gboolean _tmp3_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (cexpr != NULL, NULL);
	g_return_val_if_fail (actual_type != NULL, NULL);
	_tmp0_ = cexpr;
	_tmp1_ = _vala_ccode_node_ref0 (_tmp0_);
	_result_ = _tmp1_;
	_tmp2_ = actual_type;
	_tmp3_ = vala_ccode_base_module_is_signed_integer_type_argument (self, _tmp2_);
	if (_tmp3_) {
		ValaCCodeExpression* _tmp4_;
		ValaCCodeCastExpression* _tmp5_;
		ValaCCodeCastExpression* _tmp6_;
		ValaCCodeCastExpression* _tmp7_;
		_tmp4_ = cexpr;
		_tmp5_ = vala_ccode_cast_expression_new (_tmp4_, "gintptr");
		_tmp6_ = _tmp5_;
		_tmp7_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp6_, "gpointer");
		_vala_ccode_node_unref0 (_result_);
		_result_ = (ValaCCodeExpression*) _tmp7_;
		_vala_ccode_node_unref0 (_tmp6_);
	} else {
		ValaDataType* _tmp8_;
		gboolean _tmp9_;
		_tmp8_ = actual_type;
		_tmp9_ = vala_ccode_base_module_is_unsigned_integer_type_argument (self, _tmp8_);
		if (_tmp9_) {
			ValaCCodeExpression* _tmp10_;
			ValaCCodeCastExpression* _tmp11_;
			ValaCCodeCastExpression* _tmp12_;
			ValaCCodeCastExpression* _tmp13_;
			_tmp10_ = cexpr;
			_tmp11_ = vala_ccode_cast_expression_new (_tmp10_, "guintptr");
			_tmp12_ = _tmp11_;
			_tmp13_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp12_, "gpointer");
			_vala_ccode_node_unref0 (_result_);
			_result_ = (ValaCCodeExpression*) _tmp13_;
			_vala_ccode_node_unref0 (_tmp12_);
		}
	}
	result = _result_;
	return result;
}


ValaTargetValue* vala_ccode_base_module_transform_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* target_type, ValaCodeNode* node) {
	ValaTargetValue* result = NULL;
	ValaDataType* type = NULL;
	ValaTargetValue* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaDataType* _tmp3_;
	ValaGLibValue* _result_ = NULL;
	ValaTargetValue* _tmp4_;
	ValaGLibValue* _tmp5_;
	gboolean _tmp6_ = FALSE;
	ValaDataType* _tmp7_;
	gboolean _tmp8_;
	gboolean _tmp9_;
	gboolean _tmp59_ = FALSE;
	gboolean _tmp60_ = FALSE;
	gboolean _tmp61_ = FALSE;
	ValaDataType* _tmp62_;
	gboolean boxing = FALSE;
	gboolean _tmp70_ = FALSE;
	gboolean _tmp71_ = FALSE;
	gboolean _tmp72_ = FALSE;
	ValaDataType* _tmp73_;
	gboolean unboxing = FALSE;
	gboolean _tmp81_ = FALSE;
	gboolean _tmp82_ = FALSE;
	gboolean _tmp83_ = FALSE;
	ValaDataType* _tmp84_;
	gboolean gvalue_boxing = FALSE;
	gboolean _tmp93_ = FALSE;
	gboolean _tmp94_ = FALSE;
	gboolean _tmp95_ = FALSE;
	ValaDataType* _tmp96_;
	gboolean gvariant_boxing = FALSE;
	gboolean _tmp106_ = FALSE;
	gboolean _tmp107_ = FALSE;
	ValaDataType* _tmp108_;
	gboolean _tmp109_;
	gboolean _tmp110_;
	ValaDataType* _tmp146_;
	ValaGLibValue* _tmp147_;
	ValaDataType* _tmp148_;
	ValaDataType* _tmp149_;
	ValaDataType* _tmp150_;
	gboolean _tmp151_;
	gboolean array_needs_copy = FALSE;
	gboolean _tmp393_ = FALSE;
	ValaDataType* _tmp394_;
	gboolean _tmp415_ = FALSE;
	gboolean _tmp416_ = FALSE;
	gboolean _tmp417_ = FALSE;
	gboolean _tmp418_ = FALSE;
	gboolean _tmp419_ = FALSE;
	gboolean _tmp420_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (value != NULL, NULL);
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = value;
	_tmp1_ = vala_target_value_get_value_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (_tmp2_);
	type = _tmp3_;
	_tmp4_ = value;
	_tmp5_ = vala_glib_value_copy (G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	_result_ = _tmp5_;
	_tmp7_ = type;
	_tmp8_ = vala_data_type_get_value_owned (_tmp7_);
	_tmp9_ = _tmp8_;
	if (_tmp9_) {
		ValaDataType* _tmp10_;
		gboolean _tmp11_;
		gboolean _tmp12_;
		_tmp10_ = type;
		_tmp11_ = vala_data_type_get_floating_reference (_tmp10_);
		_tmp12_ = _tmp11_;
		_tmp6_ = _tmp12_;
	} else {
		_tmp6_ = FALSE;
	}
	if (_tmp6_) {
		ValaObjectTypeSymbol* cl = NULL;
		ValaDataType* _tmp13_;
		ValaTypeSymbol* _tmp14_;
		ValaTypeSymbol* _tmp15_;
		ValaObjectTypeSymbol* _tmp16_;
		gchar* _tmp17_ = NULL;
		ValaObjectTypeSymbol* _tmp18_;
		gchar* sink_func = NULL;
		gchar* _tmp22_;
		const gchar* _tmp23_;
		_tmp13_ = type;
		_tmp14_ = vala_data_type_get_data_type (_tmp13_);
		_tmp15_ = _tmp14_;
		_tmp16_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_OBJECT_TYPE_SYMBOL) ? ((ValaObjectTypeSymbol*) _tmp15_) : NULL);
		cl = _tmp16_;
		_tmp18_ = cl;
		if (_tmp18_ != NULL) {
			ValaObjectTypeSymbol* _tmp19_;
			gchar* _tmp20_;
			_tmp19_ = cl;
			_tmp20_ = vala_ccode_base_module_get_ccode_ref_sink_function (_tmp19_);
			_g_free0 (_tmp17_);
			_tmp17_ = _tmp20_;
		} else {
			gchar* _tmp21_;
			_tmp21_ = g_strdup ("");
			_g_free0 (_tmp17_);
			_tmp17_ = _tmp21_;
		}
		_tmp22_ = g_strdup (_tmp17_);
		sink_func = _tmp22_;
		_tmp23_ = sink_func;
		if (g_strcmp0 (_tmp23_, "") != 0) {
			ValaDataType* _tmp24_;
			gboolean _tmp25_;
			gboolean _tmp26_;
			ValaCCodeFunctionCall* csink = NULL;
			const gchar* _tmp36_;
			ValaCCodeIdentifier* _tmp37_;
			ValaCCodeIdentifier* _tmp38_;
			ValaCCodeFunctionCall* _tmp39_;
			ValaCCodeFunctionCall* _tmp40_;
			ValaCCodeFunctionCall* _tmp41_;
			ValaGLibValue* _tmp42_;
			ValaCCodeExpression* _tmp43_;
			ValaCCodeFunction* _tmp44_;
			ValaCCodeFunction* _tmp45_;
			ValaCCodeFunctionCall* _tmp46_;
			ValaDataType* _tmp47_;
			gboolean _tmp48_;
			gboolean _tmp49_;
			_tmp24_ = type;
			_tmp25_ = vala_data_type_get_nullable (_tmp24_);
			_tmp26_ = _tmp25_;
			if (_tmp26_) {
				ValaCCodeBinaryExpression* is_not_null = NULL;
				ValaGLibValue* _tmp27_;
				ValaCCodeExpression* _tmp28_;
				ValaCCodeIdentifier* _tmp29_;
				ValaCCodeIdentifier* _tmp30_;
				ValaCCodeBinaryExpression* _tmp31_;
				ValaCCodeBinaryExpression* _tmp32_;
				ValaCCodeFunction* _tmp33_;
				ValaCCodeFunction* _tmp34_;
				ValaCCodeBinaryExpression* _tmp35_;
				_tmp27_ = _result_;
				_tmp28_ = _tmp27_->cvalue;
				_tmp29_ = vala_ccode_identifier_new ("NULL");
				_tmp30_ = _tmp29_;
				_tmp31_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, _tmp28_, (ValaCCodeExpression*) _tmp30_);
				_tmp32_ = _tmp31_;
				_vala_ccode_node_unref0 (_tmp30_);
				is_not_null = _tmp32_;
				_tmp33_ = vala_ccode_base_module_get_ccode (self);
				_tmp34_ = _tmp33_;
				_tmp35_ = is_not_null;
				vala_ccode_function_open_if (_tmp34_, (ValaCCodeExpression*) _tmp35_);
				_vala_ccode_node_unref0 (is_not_null);
			}
			_tmp36_ = sink_func;
			_tmp37_ = vala_ccode_identifier_new (_tmp36_);
			_tmp38_ = _tmp37_;
			_tmp39_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp38_);
			_tmp40_ = _tmp39_;
			_vala_ccode_node_unref0 (_tmp38_);
			csink = _tmp40_;
			_tmp41_ = csink;
			_tmp42_ = _result_;
			_tmp43_ = _tmp42_->cvalue;
			vala_ccode_function_call_add_argument (_tmp41_, _tmp43_);
			_tmp44_ = vala_ccode_base_module_get_ccode (self);
			_tmp45_ = _tmp44_;
			_tmp46_ = csink;
			vala_ccode_function_add_expression (_tmp45_, (ValaCCodeExpression*) _tmp46_);
			_tmp47_ = type;
			_tmp48_ = vala_data_type_get_nullable (_tmp47_);
			_tmp49_ = _tmp48_;
			if (_tmp49_) {
				ValaCCodeFunction* _tmp50_;
				ValaCCodeFunction* _tmp51_;
				_tmp50_ = vala_ccode_base_module_get_ccode (self);
				_tmp51_ = _tmp50_;
				vala_ccode_function_close (_tmp51_);
			}
			_vala_ccode_node_unref0 (csink);
		} else {
			ValaDataType* _tmp52_;
			ValaTypeSymbol* _tmp53_;
			ValaTypeSymbol* _tmp54_;
			const gchar* _tmp55_;
			const gchar* _tmp56_;
			gchar* _tmp57_;
			gchar* _tmp58_;
			_tmp52_ = type;
			_tmp53_ = vala_data_type_get_data_type (_tmp52_);
			_tmp54_ = _tmp53_;
			_tmp55_ = vala_symbol_get_name ((ValaSymbol*) _tmp54_);
			_tmp56_ = _tmp55_;
			_tmp57_ = g_strdup_printf ("type `%s' does not support floating references", _tmp56_);
			_tmp58_ = _tmp57_;
			vala_report_error (NULL, _tmp58_);
			_g_free0 (_tmp58_);
		}
		_g_free0 (sink_func);
		_g_free0 (_tmp17_);
		_vala_code_node_unref0 (cl);
	}
	_tmp62_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp62_, VALA_TYPE_VALUE_TYPE)) {
		ValaDataType* _tmp63_;
		gboolean _tmp64_;
		gboolean _tmp65_;
		_tmp63_ = type;
		_tmp64_ = vala_data_type_get_nullable (_tmp63_);
		_tmp65_ = _tmp64_;
		_tmp61_ = !_tmp65_;
	} else {
		_tmp61_ = FALSE;
	}
	if (_tmp61_) {
		ValaDataType* _tmp66_;
		_tmp66_ = target_type;
		_tmp60_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp66_, VALA_TYPE_VALUE_TYPE);
	} else {
		_tmp60_ = FALSE;
	}
	if (_tmp60_) {
		ValaDataType* _tmp67_;
		gboolean _tmp68_;
		gboolean _tmp69_;
		_tmp67_ = target_type;
		_tmp68_ = vala_data_type_get_nullable (_tmp67_);
		_tmp69_ = _tmp68_;
		_tmp59_ = _tmp69_;
	} else {
		_tmp59_ = FALSE;
	}
	boxing = _tmp59_;
	_tmp73_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp73_, VALA_TYPE_VALUE_TYPE)) {
		ValaDataType* _tmp74_;
		gboolean _tmp75_;
		gboolean _tmp76_;
		_tmp74_ = type;
		_tmp75_ = vala_data_type_get_nullable (_tmp74_);
		_tmp76_ = _tmp75_;
		_tmp72_ = _tmp76_;
	} else {
		_tmp72_ = FALSE;
	}
	if (_tmp72_) {
		ValaDataType* _tmp77_;
		_tmp77_ = target_type;
		_tmp71_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp77_, VALA_TYPE_VALUE_TYPE);
	} else {
		_tmp71_ = FALSE;
	}
	if (_tmp71_) {
		ValaDataType* _tmp78_;
		gboolean _tmp79_;
		gboolean _tmp80_;
		_tmp78_ = target_type;
		_tmp79_ = vala_data_type_get_nullable (_tmp78_);
		_tmp80_ = _tmp79_;
		_tmp70_ = !_tmp80_;
	} else {
		_tmp70_ = FALSE;
	}
	unboxing = _tmp70_;
	_tmp84_ = target_type;
	if (_tmp84_ != NULL) {
		ValaDataType* _tmp85_;
		ValaTypeSymbol* _tmp86_;
		ValaTypeSymbol* _tmp87_;
		ValaStruct* _tmp88_;
		_tmp85_ = target_type;
		_tmp86_ = vala_data_type_get_data_type (_tmp85_);
		_tmp87_ = _tmp86_;
		_tmp88_ = self->gvalue_type;
		_tmp83_ = _tmp87_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp88_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	} else {
		_tmp83_ = FALSE;
	}
	if (_tmp83_) {
		ValaDataType* _tmp89_;
		_tmp89_ = type;
		_tmp82_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp89_, VALA_TYPE_NULL_TYPE);
	} else {
		_tmp82_ = FALSE;
	}
	if (_tmp82_) {
		ValaDataType* _tmp90_;
		gchar* _tmp91_;
		gchar* _tmp92_;
		_tmp90_ = type;
		_tmp91_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp90_);
		_tmp92_ = _tmp91_;
		_tmp81_ = g_strcmp0 (_tmp92_, "G_TYPE_VALUE") != 0;
		_g_free0 (_tmp92_);
	} else {
		_tmp81_ = FALSE;
	}
	gvalue_boxing = _tmp81_;
	_tmp96_ = target_type;
	if (_tmp96_ != NULL) {
		ValaDataType* _tmp97_;
		ValaTypeSymbol* _tmp98_;
		ValaTypeSymbol* _tmp99_;
		ValaClass* _tmp100_;
		_tmp97_ = target_type;
		_tmp98_ = vala_data_type_get_data_type (_tmp97_);
		_tmp99_ = _tmp98_;
		_tmp100_ = self->gvariant_type;
		_tmp95_ = _tmp99_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp100_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	} else {
		_tmp95_ = FALSE;
	}
	if (_tmp95_) {
		ValaDataType* _tmp101_;
		_tmp101_ = type;
		_tmp94_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp101_, VALA_TYPE_NULL_TYPE);
	} else {
		_tmp94_ = FALSE;
	}
	if (_tmp94_) {
		ValaDataType* _tmp102_;
		ValaTypeSymbol* _tmp103_;
		ValaTypeSymbol* _tmp104_;
		ValaClass* _tmp105_;
		_tmp102_ = type;
		_tmp103_ = vala_data_type_get_data_type (_tmp102_);
		_tmp104_ = _tmp103_;
		_tmp105_ = self->gvariant_type;
		_tmp93_ = _tmp104_ != G_TYPE_CHECK_INSTANCE_CAST (_tmp105_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
	} else {
		_tmp93_ = FALSE;
	}
	gvariant_boxing = _tmp93_;
	_tmp108_ = type;
	_tmp109_ = vala_data_type_get_value_owned (_tmp108_);
	_tmp110_ = _tmp109_;
	if (_tmp110_) {
		gboolean _tmp111_ = FALSE;
		gboolean _tmp112_ = FALSE;
		gboolean _tmp113_ = FALSE;
		gboolean _tmp114_ = FALSE;
		ValaDataType* _tmp115_;
		_tmp115_ = target_type;
		if (_tmp115_ == NULL) {
			_tmp114_ = TRUE;
		} else {
			ValaDataType* _tmp116_;
			gboolean _tmp117_;
			gboolean _tmp118_;
			_tmp116_ = target_type;
			_tmp117_ = vala_data_type_get_value_owned (_tmp116_);
			_tmp118_ = _tmp117_;
			_tmp114_ = !_tmp118_;
		}
		if (_tmp114_) {
			_tmp113_ = TRUE;
		} else {
			gboolean _tmp119_;
			_tmp119_ = boxing;
			_tmp113_ = _tmp119_;
		}
		if (_tmp113_) {
			_tmp112_ = TRUE;
		} else {
			gboolean _tmp120_;
			_tmp120_ = unboxing;
			_tmp112_ = _tmp120_;
		}
		if (_tmp112_) {
			_tmp111_ = TRUE;
		} else {
			gboolean _tmp121_;
			_tmp121_ = gvariant_boxing;
			_tmp111_ = _tmp121_;
		}
		_tmp107_ = _tmp111_;
	} else {
		_tmp107_ = FALSE;
	}
	if (_tmp107_) {
		gboolean _tmp122_;
		_tmp122_ = gvalue_boxing;
		_tmp106_ = !_tmp122_;
	} else {
		_tmp106_ = FALSE;
	}
	if (_tmp106_) {
		ValaDataType* _tmp123_;
		_tmp123_ = target_type;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp123_, VALA_TYPE_POINTER_TYPE)) {
		} else {
			ValaDataType* _tmp124_;
			gboolean _tmp125_;
			_tmp124_ = type;
			_tmp125_ = vala_ccode_base_module_requires_destroy (self, _tmp124_);
			if (_tmp125_) {
				ValaDataType* _tmp126_;
				gboolean _tmp127_;
				_tmp126_ = type;
				_tmp127_ = vala_ccode_base_module_is_lvalue_access_allowed (self, _tmp126_);
				if (!_tmp127_) {
					ValaArrayList* _tmp128_;
					ValaArrayList* _tmp129_;
					ValaGLibValue* _tmp130_;
					ValaGLibValue* _tmp131_;
					ValaGLibValue* _tmp132_;
					_tmp128_ = vala_ccode_base_module_get_temp_ref_values (self);
					_tmp129_ = _tmp128_;
					_tmp130_ = _result_;
					_tmp131_ = vala_glib_value_copy (_tmp130_);
					_tmp132_ = _tmp131_;
					vala_list_insert ((ValaList*) _tmp129_, 0, (ValaTargetValue*) _tmp132_);
					_vala_target_value_unref0 (_tmp132_);
				} else {
					ValaTargetValue* temp_value = NULL;
					ValaDataType* _tmp133_;
					ValaCodeNode* _tmp134_;
					ValaTargetValue* _tmp135_;
					ValaArrayList* _tmp136_;
					ValaArrayList* _tmp137_;
					ValaTargetValue* _tmp138_;
					ValaGLibValue* _tmp139_;
					ValaGLibValue* _tmp140_;
					ValaTargetValue* _tmp141_;
					ValaGLibValue* _tmp142_;
					ValaGLibValue* _tmp143_;
					ValaTargetValue* _tmp144_;
					ValaCCodeExpression* _tmp145_;
					_tmp133_ = type;
					_tmp134_ = node;
					_tmp135_ = vala_ccode_base_module_create_temp_value (self, _tmp133_, FALSE, _tmp134_, NULL);
					temp_value = _tmp135_;
					_tmp136_ = vala_ccode_base_module_get_temp_ref_values (self);
					_tmp137_ = _tmp136_;
					_tmp138_ = temp_value;
					_tmp139_ = vala_glib_value_copy (G_TYPE_CHECK_INSTANCE_CAST (_tmp138_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
					_tmp140_ = _tmp139_;
					vala_list_insert ((ValaList*) _tmp137_, 0, (ValaTargetValue*) _tmp140_);
					_vala_target_value_unref0 (_tmp140_);
					_tmp141_ = temp_value;
					_tmp142_ = _result_;
					vala_ccode_base_module_store_value (self, _tmp141_, (ValaTargetValue*) _tmp142_);
					_tmp143_ = _result_;
					_tmp144_ = temp_value;
					_tmp145_ = vala_ccode_base_module_get_cvalue_ (self, _tmp144_);
					_vala_ccode_node_unref0 (_tmp143_->cvalue);
					_tmp143_->cvalue = _tmp145_;
					_vala_target_value_unref0 (temp_value);
				}
			}
		}
	}
	_tmp146_ = target_type;
	if (_tmp146_ == NULL) {
		result = (ValaTargetValue*) _result_;
		_vala_code_node_unref0 (type);
		return result;
	}
	_tmp147_ = _result_;
	_tmp148_ = target_type;
	_tmp149_ = vala_data_type_copy (_tmp148_);
	_tmp150_ = _tmp149_;
	vala_target_value_set_value_type ((ValaTargetValue*) _tmp147_, _tmp150_);
	_vala_code_node_unref0 (_tmp150_);
	_tmp151_ = gvalue_boxing;
	if (_tmp151_) {
		ValaTargetValue* temp_value = NULL;
		ValaDataType* _tmp152_;
		ValaCodeNode* _tmp153_;
		gboolean _tmp154_;
		ValaTargetValue* _tmp155_;
		ValaDataType* _tmp156_;
		gboolean _tmp157_;
		gboolean _tmp158_;
		ValaDataType* _tmp164_;
		gboolean _tmp165_;
		gboolean _tmp166_;
		ValaCCodeFunctionCall* ccall = NULL;
		ValaCCodeIdentifier* _tmp186_;
		ValaCCodeIdentifier* _tmp187_;
		ValaCCodeFunctionCall* _tmp188_;
		ValaCCodeFunctionCall* _tmp189_;
		ValaDataType* _tmp190_;
		gboolean _tmp191_;
		gboolean _tmp192_;
		gchar* type_id = NULL;
		ValaDataType* _tmp203_;
		gchar* _tmp204_;
		const gchar* _tmp205_;
		ValaCCodeFunctionCall* _tmp214_;
		const gchar* _tmp215_;
		ValaCCodeIdentifier* _tmp216_;
		ValaCCodeIdentifier* _tmp217_;
		ValaCCodeFunction* _tmp218_;
		ValaCCodeFunction* _tmp219_;
		ValaCCodeFunctionCall* _tmp220_;
		ValaDataType* _tmp221_;
		gboolean _tmp222_;
		ValaDataType* _tmp231_;
		gboolean _tmp232_;
		gboolean _tmp233_;
		ValaDataType* _tmp244_;
		gboolean _tmp245_;
		ValaCCodeFunction* _tmp254_;
		ValaCCodeFunction* _tmp255_;
		ValaCCodeFunctionCall* _tmp256_;
		ValaTargetValue* _tmp257_;
		ValaGLibValue* _tmp258_;
		_tmp152_ = target_type;
		_tmp153_ = node;
		_tmp154_ = TRUE;
		_tmp155_ = vala_ccode_base_module_create_temp_value (self, _tmp152_, TRUE, _tmp153_, &_tmp154_);
		temp_value = _tmp155_;
		_tmp156_ = target_type;
		_tmp157_ = vala_data_type_get_value_owned (_tmp156_);
		_tmp158_ = _tmp157_;
		if (!_tmp158_) {
			ValaArrayList* _tmp159_;
			ValaArrayList* _tmp160_;
			ValaTargetValue* _tmp161_;
			ValaGLibValue* _tmp162_;
			ValaGLibValue* _tmp163_;
			_tmp159_ = vala_ccode_base_module_get_temp_ref_values (self);
			_tmp160_ = _tmp159_;
			_tmp161_ = temp_value;
			_tmp162_ = vala_glib_value_copy (G_TYPE_CHECK_INSTANCE_CAST (_tmp161_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
			_tmp163_ = _tmp162_;
			vala_list_insert ((ValaList*) _tmp160_, 0, (ValaTargetValue*) _tmp163_);
			_vala_target_value_unref0 (_tmp163_);
		}
		_tmp164_ = target_type;
		_tmp165_ = vala_data_type_get_nullable (_tmp164_);
		_tmp166_ = _tmp165_;
		if (_tmp166_) {
			ValaCCodeFunctionCall* newcall = NULL;
			ValaCCodeIdentifier* _tmp167_;
			ValaCCodeIdentifier* _tmp168_;
			ValaCCodeFunctionCall* _tmp169_;
			ValaCCodeFunctionCall* _tmp170_;
			ValaCCodeFunctionCall* _tmp171_;
			ValaCCodeConstant* _tmp172_;
			ValaCCodeConstant* _tmp173_;
			ValaCCodeFunctionCall* _tmp174_;
			ValaCCodeConstant* _tmp175_;
			ValaCCodeConstant* _tmp176_;
			ValaCCodeAssignment* newassignment = NULL;
			ValaTargetValue* _tmp177_;
			ValaCCodeExpression* _tmp178_;
			ValaCCodeExpression* _tmp179_;
			ValaCCodeFunctionCall* _tmp180_;
			ValaCCodeAssignment* _tmp181_;
			ValaCCodeAssignment* _tmp182_;
			ValaCCodeFunction* _tmp183_;
			ValaCCodeFunction* _tmp184_;
			ValaCCodeAssignment* _tmp185_;
			_tmp167_ = vala_ccode_identifier_new ("g_new0");
			_tmp168_ = _tmp167_;
			_tmp169_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp168_);
			_tmp170_ = _tmp169_;
			_vala_ccode_node_unref0 (_tmp168_);
			newcall = _tmp170_;
			_tmp171_ = newcall;
			_tmp172_ = vala_ccode_constant_new ("GValue");
			_tmp173_ = _tmp172_;
			vala_ccode_function_call_add_argument (_tmp171_, (ValaCCodeExpression*) _tmp173_);
			_vala_ccode_node_unref0 (_tmp173_);
			_tmp174_ = newcall;
			_tmp175_ = vala_ccode_constant_new ("1");
			_tmp176_ = _tmp175_;
			vala_ccode_function_call_add_argument (_tmp174_, (ValaCCodeExpression*) _tmp176_);
			_vala_ccode_node_unref0 (_tmp176_);
			_tmp177_ = temp_value;
			_tmp178_ = vala_ccode_base_module_get_cvalue_ (self, _tmp177_);
			_tmp179_ = _tmp178_;
			_tmp180_ = newcall;
			_tmp181_ = vala_ccode_assignment_new (_tmp179_, (ValaCCodeExpression*) _tmp180_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
			_tmp182_ = _tmp181_;
			_vala_ccode_node_unref0 (_tmp179_);
			newassignment = _tmp182_;
			_tmp183_ = vala_ccode_base_module_get_ccode (self);
			_tmp184_ = _tmp183_;
			_tmp185_ = newassignment;
			vala_ccode_function_add_expression (_tmp184_, (ValaCCodeExpression*) _tmp185_);
			_vala_ccode_node_unref0 (newassignment);
			_vala_ccode_node_unref0 (newcall);
		}
		_tmp186_ = vala_ccode_identifier_new ("g_value_init");
		_tmp187_ = _tmp186_;
		_tmp188_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp187_);
		_tmp189_ = _tmp188_;
		_vala_ccode_node_unref0 (_tmp187_);
		ccall = _tmp189_;
		_tmp190_ = target_type;
		_tmp191_ = vala_data_type_get_nullable (_tmp190_);
		_tmp192_ = _tmp191_;
		if (_tmp192_) {
			ValaCCodeFunctionCall* _tmp193_;
			ValaTargetValue* _tmp194_;
			ValaCCodeExpression* _tmp195_;
			ValaCCodeExpression* _tmp196_;
			_tmp193_ = ccall;
			_tmp194_ = temp_value;
			_tmp195_ = vala_ccode_base_module_get_cvalue_ (self, _tmp194_);
			_tmp196_ = _tmp195_;
			vala_ccode_function_call_add_argument (_tmp193_, _tmp196_);
			_vala_ccode_node_unref0 (_tmp196_);
		} else {
			ValaCCodeFunctionCall* _tmp197_;
			ValaTargetValue* _tmp198_;
			ValaCCodeExpression* _tmp199_;
			ValaCCodeExpression* _tmp200_;
			ValaCCodeUnaryExpression* _tmp201_;
			ValaCCodeUnaryExpression* _tmp202_;
			_tmp197_ = ccall;
			_tmp198_ = temp_value;
			_tmp199_ = vala_ccode_base_module_get_cvalue_ (self, _tmp198_);
			_tmp200_ = _tmp199_;
			_tmp201_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp200_);
			_tmp202_ = _tmp201_;
			vala_ccode_function_call_add_argument (_tmp197_, (ValaCCodeExpression*) _tmp202_);
			_vala_ccode_node_unref0 (_tmp202_);
			_vala_ccode_node_unref0 (_tmp200_);
		}
		_tmp203_ = type;
		_tmp204_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp203_);
		type_id = _tmp204_;
		_tmp205_ = type_id;
		if (g_strcmp0 (_tmp205_, "") == 0) {
			ValaCodeNode* _tmp206_;
			ValaSourceReference* _tmp207_;
			ValaSourceReference* _tmp208_;
			ValaDataType* _tmp209_;
			gchar* _tmp210_;
			gchar* _tmp211_;
			gchar* _tmp212_;
			gchar* _tmp213_;
			_tmp206_ = node;
			_tmp207_ = vala_code_node_get_source_reference (_tmp206_);
			_tmp208_ = _tmp207_;
			_tmp209_ = type;
			_tmp210_ = vala_code_node_to_string ((ValaCodeNode*) _tmp209_);
			_tmp211_ = _tmp210_;
			_tmp212_ = g_strdup_printf ("GValue boxing of type `%s' is not supported", _tmp211_);
			_tmp213_ = _tmp212_;
			vala_report_error (_tmp208_, _tmp213_);
			_g_free0 (_tmp213_);
			_g_free0 (_tmp211_);
		}
		_tmp214_ = ccall;
		_tmp215_ = type_id;
		_tmp216_ = vala_ccode_identifier_new (_tmp215_);
		_tmp217_ = _tmp216_;
		vala_ccode_function_call_add_argument (_tmp214_, (ValaCCodeExpression*) _tmp217_);
		_vala_ccode_node_unref0 (_tmp217_);
		_tmp218_ = vala_ccode_base_module_get_ccode (self);
		_tmp219_ = _tmp218_;
		_tmp220_ = ccall;
		vala_ccode_function_add_expression (_tmp219_, (ValaCCodeExpression*) _tmp220_);
		_tmp221_ = type;
		_tmp222_ = vala_ccode_base_module_requires_destroy (self, _tmp221_);
		if (_tmp222_) {
			ValaDataType* _tmp223_;
			ValaCCodeIdentifier* _tmp224_;
			ValaCCodeIdentifier* _tmp225_;
			ValaCCodeFunctionCall* _tmp226_;
			_tmp223_ = type;
			_tmp224_ = vala_ccode_base_module_get_value_taker_function (self, _tmp223_);
			_tmp225_ = _tmp224_;
			_tmp226_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp225_);
			_vala_ccode_node_unref0 (ccall);
			ccall = _tmp226_;
			_vala_ccode_node_unref0 (_tmp225_);
		} else {
			ValaDataType* _tmp227_;
			ValaCCodeIdentifier* _tmp228_;
			ValaCCodeIdentifier* _tmp229_;
			ValaCCodeFunctionCall* _tmp230_;
			_tmp227_ = type;
			_tmp228_ = vala_ccode_base_module_get_value_setter_function (self, _tmp227_);
			_tmp229_ = _tmp228_;
			_tmp230_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp229_);
			_vala_ccode_node_unref0 (ccall);
			ccall = _tmp230_;
			_vala_ccode_node_unref0 (_tmp229_);
		}
		_tmp231_ = target_type;
		_tmp232_ = vala_data_type_get_nullable (_tmp231_);
		_tmp233_ = _tmp232_;
		if (_tmp233_) {
			ValaCCodeFunctionCall* _tmp234_;
			ValaTargetValue* _tmp235_;
			ValaCCodeExpression* _tmp236_;
			ValaCCodeExpression* _tmp237_;
			_tmp234_ = ccall;
			_tmp235_ = temp_value;
			_tmp236_ = vala_ccode_base_module_get_cvalue_ (self, _tmp235_);
			_tmp237_ = _tmp236_;
			vala_ccode_function_call_add_argument (_tmp234_, _tmp237_);
			_vala_ccode_node_unref0 (_tmp237_);
		} else {
			ValaCCodeFunctionCall* _tmp238_;
			ValaTargetValue* _tmp239_;
			ValaCCodeExpression* _tmp240_;
			ValaCCodeExpression* _tmp241_;
			ValaCCodeUnaryExpression* _tmp242_;
			ValaCCodeUnaryExpression* _tmp243_;
			_tmp238_ = ccall;
			_tmp239_ = temp_value;
			_tmp240_ = vala_ccode_base_module_get_cvalue_ (self, _tmp239_);
			_tmp241_ = _tmp240_;
			_tmp242_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp241_);
			_tmp243_ = _tmp242_;
			vala_ccode_function_call_add_argument (_tmp238_, (ValaCCodeExpression*) _tmp243_);
			_vala_ccode_node_unref0 (_tmp243_);
			_vala_ccode_node_unref0 (_tmp241_);
		}
		_tmp244_ = type;
		_tmp245_ = vala_data_type_is_real_non_null_struct_type (_tmp244_);
		if (_tmp245_) {
			ValaCCodeFunctionCall* _tmp246_;
			ValaGLibValue* _tmp247_;
			ValaCCodeExpression* _tmp248_;
			ValaCCodeUnaryExpression* _tmp249_;
			ValaCCodeUnaryExpression* _tmp250_;
			_tmp246_ = ccall;
			_tmp247_ = _result_;
			_tmp248_ = _tmp247_->cvalue;
			_tmp249_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp248_);
			_tmp250_ = _tmp249_;
			vala_ccode_function_call_add_argument (_tmp246_, (ValaCCodeExpression*) _tmp250_);
			_vala_ccode_node_unref0 (_tmp250_);
		} else {
			ValaCCodeFunctionCall* _tmp251_;
			ValaGLibValue* _tmp252_;
			ValaCCodeExpression* _tmp253_;
			_tmp251_ = ccall;
			_tmp252_ = _result_;
			_tmp253_ = _tmp252_->cvalue;
			vala_ccode_function_call_add_argument (_tmp251_, _tmp253_);
		}
		_tmp254_ = vala_ccode_base_module_get_ccode (self);
		_tmp255_ = _tmp254_;
		_tmp256_ = ccall;
		vala_ccode_function_add_expression (_tmp255_, (ValaCCodeExpression*) _tmp256_);
		_tmp257_ = temp_value;
		_tmp258_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp257_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
		_vala_target_value_unref0 (_result_);
		_result_ = _tmp258_;
		_g_free0 (type_id);
		_vala_ccode_node_unref0 (ccall);
		_vala_target_value_unref0 (temp_value);
	} else {
		gboolean _tmp259_;
		_tmp259_ = gvariant_boxing;
		if (_tmp259_) {
			gchar* variant_func = NULL;
			gint _tmp260_;
			gint _tmp261_;
			gchar* _tmp262_;
			ValaCCodeFunctionCall* ccall = NULL;
			const gchar* _tmp263_;
			ValaCCodeIdentifier* _tmp264_;
			ValaCCodeIdentifier* _tmp265_;
			ValaCCodeFunctionCall* _tmp266_;
			ValaCCodeFunctionCall* _tmp267_;
			ValaCCodeFunctionCall* _tmp268_;
			ValaGLibValue* _tmp269_;
			ValaCCodeExpression* _tmp270_;
			ValaCCodeFunction* cfunc = NULL;
			const gchar* _tmp271_;
			ValaCCodeFunction* _tmp272_;
			ValaCCodeFunction* _tmp273_;
			ValaCCodeFunction* _tmp274_;
			ValaDataType* _tmp275_;
			gchar* _tmp276_;
			gchar* _tmp277_;
			ValaCCodeParameter* _tmp278_;
			ValaCCodeParameter* _tmp279_;
			ValaDataType* _tmp280_;
			ValaCCodeFunction* _tmp300_;
			ValaCCodeFunctionCall* sink = NULL;
			ValaCCodeIdentifier* _tmp301_;
			ValaCCodeIdentifier* _tmp302_;
			ValaCCodeFunctionCall* _tmp303_;
			ValaCCodeFunctionCall* _tmp304_;
			ValaCCodeFunctionCall* _tmp305_;
			ValaDataType* _tmp306_;
			ValaCCodeIdentifier* _tmp307_;
			ValaCCodeIdentifier* _tmp308_;
			ValaCCodeExpression* _tmp309_;
			ValaCCodeExpression* _tmp310_;
			ValaCCodeFunction* _tmp311_;
			ValaCCodeFunction* _tmp312_;
			ValaCCodeFunctionCall* _tmp313_;
			ValaCCodeFile* _tmp314_;
			ValaCCodeFunction* _tmp315_;
			ValaCCodeFile* _tmp316_;
			ValaCCodeFunction* _tmp317_;
			ValaGLibValue* _tmp318_;
			ValaCCodeFunctionCall* _tmp319_;
			ValaCCodeExpression* _tmp320_;
			ValaGLibValue* _tmp321_;
			ValaDataType* _tmp322_;
			ValaDataType* _tmp323_;
			ValaGLibValue* _tmp324_;
			ValaCodeNode* _tmp325_;
			ValaTargetValue* _tmp326_;
			ValaDataType* _tmp327_;
			gboolean _tmp328_;
			gboolean _tmp329_;
			_tmp260_ = self->priv->next_variant_function_id;
			self->priv->next_variant_function_id = _tmp260_ + 1;
			_tmp261_ = self->priv->next_variant_function_id;
			_tmp262_ = g_strdup_printf ("_variant_new%d", _tmp261_);
			variant_func = _tmp262_;
			_tmp263_ = variant_func;
			_tmp264_ = vala_ccode_identifier_new (_tmp263_);
			_tmp265_ = _tmp264_;
			_tmp266_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp265_);
			_tmp267_ = _tmp266_;
			_vala_ccode_node_unref0 (_tmp265_);
			ccall = _tmp267_;
			_tmp268_ = ccall;
			_tmp269_ = _result_;
			_tmp270_ = _tmp269_->cvalue;
			vala_ccode_function_call_add_argument (_tmp268_, _tmp270_);
			_tmp271_ = variant_func;
			_tmp272_ = vala_ccode_function_new (_tmp271_, "GVariant*");
			cfunc = _tmp272_;
			_tmp273_ = cfunc;
			vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp273_, VALA_CCODE_MODIFIERS_STATIC);
			_tmp274_ = cfunc;
			_tmp275_ = type;
			_tmp276_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp275_);
			_tmp277_ = _tmp276_;
			_tmp278_ = vala_ccode_parameter_new ("value", _tmp277_);
			_tmp279_ = _tmp278_;
			vala_ccode_function_add_parameter (_tmp274_, _tmp279_);
			_vala_ccode_node_unref0 (_tmp279_);
			_g_free0 (_tmp277_);
			_tmp280_ = type;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp280_, VALA_TYPE_ARRAY_TYPE)) {
				ValaArrayType* array_type = NULL;
				ValaDataType* _tmp281_;
				ValaArrayType* _tmp282_;
				_tmp281_ = type;
				_tmp282_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp281_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
				array_type = _tmp282_;
				{
					gint dim = 0;
					dim = 1;
					{
						gboolean _tmp283_ = FALSE;
						_tmp283_ = TRUE;
						while (TRUE) {
							gint _tmp285_;
							ValaArrayType* _tmp286_;
							gint _tmp287_;
							gint _tmp288_;
							ValaCCodeFunctionCall* _tmp289_;
							ValaTargetValue* _tmp290_;
							gint _tmp291_;
							ValaCCodeExpression* _tmp292_;
							ValaCCodeExpression* _tmp293_;
							ValaCCodeFunction* _tmp294_;
							gint _tmp295_;
							gchar* _tmp296_;
							gchar* _tmp297_;
							ValaCCodeParameter* _tmp298_;
							ValaCCodeParameter* _tmp299_;
							if (!_tmp283_) {
								gint _tmp284_;
								_tmp284_ = dim;
								dim = _tmp284_ + 1;
							}
							_tmp283_ = FALSE;
							_tmp285_ = dim;
							_tmp286_ = array_type;
							_tmp287_ = vala_array_type_get_rank (_tmp286_);
							_tmp288_ = _tmp287_;
							if (!(_tmp285_ <= _tmp288_)) {
								break;
							}
							_tmp289_ = ccall;
							_tmp290_ = value;
							_tmp291_ = dim;
							_tmp292_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp290_, _tmp291_);
							_tmp293_ = _tmp292_;
							vala_ccode_function_call_add_argument (_tmp289_, _tmp293_);
							_vala_ccode_node_unref0 (_tmp293_);
							_tmp294_ = cfunc;
							_tmp295_ = dim;
							_tmp296_ = vala_ccode_base_module_get_array_length_cname (self, "value", _tmp295_);
							_tmp297_ = _tmp296_;
							_tmp298_ = vala_ccode_parameter_new (_tmp297_, "gint");
							_tmp299_ = _tmp298_;
							vala_ccode_function_add_parameter (_tmp294_, _tmp299_);
							_vala_ccode_node_unref0 (_tmp299_);
							_g_free0 (_tmp297_);
						}
					}
				}
				_vala_code_node_unref0 (array_type);
			}
			_tmp300_ = cfunc;
			vala_ccode_base_module_push_function (self, _tmp300_);
			_tmp301_ = vala_ccode_identifier_new ("g_variant_ref_sink");
			_tmp302_ = _tmp301_;
			_tmp303_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp302_);
			_tmp304_ = _tmp303_;
			_vala_ccode_node_unref0 (_tmp302_);
			sink = _tmp304_;
			_tmp305_ = sink;
			_tmp306_ = type;
			_tmp307_ = vala_ccode_identifier_new ("value");
			_tmp308_ = _tmp307_;
			_tmp309_ = vala_ccode_base_module_serialize_expression (self, _tmp306_, (ValaCCodeExpression*) _tmp308_);
			_tmp310_ = _tmp309_;
			vala_ccode_function_call_add_argument (_tmp305_, _tmp310_);
			_vala_ccode_node_unref0 (_tmp310_);
			_vala_ccode_node_unref0 (_tmp308_);
			_tmp311_ = vala_ccode_base_module_get_ccode (self);
			_tmp312_ = _tmp311_;
			_tmp313_ = sink;
			vala_ccode_function_add_return (_tmp312_, (ValaCCodeExpression*) _tmp313_);
			vala_ccode_base_module_pop_function (self);
			_tmp314_ = self->cfile;
			_tmp315_ = cfunc;
			vala_ccode_file_add_function_declaration (_tmp314_, _tmp315_);
			_tmp316_ = self->cfile;
			_tmp317_ = cfunc;
			vala_ccode_file_add_function (_tmp316_, _tmp317_);
			_tmp318_ = _result_;
			_tmp319_ = ccall;
			_tmp320_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp319_);
			_vala_ccode_node_unref0 (_tmp318_->cvalue);
			_tmp318_->cvalue = _tmp320_;
			_tmp321_ = _result_;
			_tmp322_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp321_);
			_tmp323_ = _tmp322_;
			vala_data_type_set_value_owned (_tmp323_, TRUE);
			_tmp324_ = _result_;
			_tmp325_ = node;
			_tmp326_ = vala_ccode_base_module_store_temp_value (self, (ValaTargetValue*) _tmp324_, _tmp325_, NULL);
			_vala_target_value_unref0 (_result_);
			_result_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp326_, VALA_TYPE_GLIB_VALUE, ValaGLibValue);
			_tmp327_ = target_type;
			_tmp328_ = vala_data_type_get_value_owned (_tmp327_);
			_tmp329_ = _tmp328_;
			if (!_tmp329_) {
				ValaArrayList* _tmp330_;
				ValaArrayList* _tmp331_;
				ValaGLibValue* _tmp332_;
				ValaGLibValue* _tmp333_;
				ValaGLibValue* _tmp334_;
				_tmp330_ = vala_ccode_base_module_get_temp_ref_values (self);
				_tmp331_ = _tmp330_;
				_tmp332_ = _result_;
				_tmp333_ = vala_glib_value_copy (G_TYPE_CHECK_INSTANCE_CAST (_tmp332_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
				_tmp334_ = _tmp333_;
				vala_list_insert ((ValaList*) _tmp331_, 0, (ValaTargetValue*) _tmp334_);
				_vala_target_value_unref0 (_tmp334_);
			}
			_vala_ccode_node_unref0 (sink);
			_vala_ccode_node_unref0 (cfunc);
			_vala_ccode_node_unref0 (ccall);
			_g_free0 (variant_func);
		} else {
			gboolean _tmp335_;
			_tmp335_ = boxing;
			if (_tmp335_) {
				ValaGLibValue* _tmp336_;
				ValaDataType* _tmp337_;
				ValaDataType* _tmp338_;
				gboolean _tmp339_ = FALSE;
				ValaGLibValue* _tmp340_;
				gboolean _tmp341_;
				ValaGLibValue* _tmp363_;
				ValaGLibValue* _tmp364_;
				ValaCCodeExpression* _tmp365_;
				ValaCCodeUnaryExpression* _tmp366_;
				ValaGLibValue* _tmp367_;
				ValaGLibValue* _tmp368_;
				ValaDataType* _tmp369_;
				ValaDataType* _tmp370_;
				_tmp336_ = _result_;
				_tmp337_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp336_);
				_tmp338_ = _tmp337_;
				vala_data_type_set_nullable (_tmp338_, FALSE);
				_tmp340_ = _result_;
				_tmp341_ = _tmp340_->lvalue;
				if (!_tmp341_) {
					_tmp339_ = TRUE;
				} else {
					ValaGLibValue* _tmp342_;
					ValaDataType* _tmp343_;
					ValaDataType* _tmp344_;
					ValaTargetValue* _tmp345_;
					ValaDataType* _tmp346_;
					ValaDataType* _tmp347_;
					gboolean _tmp348_;
					_tmp342_ = _result_;
					_tmp343_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp342_);
					_tmp344_ = _tmp343_;
					_tmp345_ = value;
					_tmp346_ = vala_target_value_get_value_type (_tmp345_);
					_tmp347_ = _tmp346_;
					_tmp348_ = vala_data_type_equals (_tmp344_, _tmp347_);
					_tmp339_ = !_tmp348_;
				}
				if (_tmp339_) {
					ValaGLibValue* _tmp349_;
					ValaGLibValue* _tmp350_;
					ValaCCodeExpression* _tmp351_;
					ValaTargetValue* _tmp352_;
					ValaDataType* _tmp353_;
					ValaDataType* _tmp354_;
					ValaGLibValue* _tmp355_;
					ValaDataType* _tmp356_;
					ValaDataType* _tmp357_;
					ValaCodeNode* _tmp358_;
					ValaCCodeExpression* _tmp359_;
					ValaGLibValue* _tmp360_;
					ValaCodeNode* _tmp361_;
					ValaTargetValue* _tmp362_;
					_tmp349_ = _result_;
					_tmp350_ = _result_;
					_tmp351_ = _tmp350_->cvalue;
					_tmp352_ = value;
					_tmp353_ = vala_target_value_get_value_type (_tmp352_);
					_tmp354_ = _tmp353_;
					_tmp355_ = _result_;
					_tmp356_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp355_);
					_tmp357_ = _tmp356_;
					_tmp358_ = node;
					_tmp359_ = vala_ccode_base_module_get_implicit_cast_expression (self, _tmp351_, _tmp354_, _tmp357_, _tmp358_);
					_vala_ccode_node_unref0 (_tmp349_->cvalue);
					_tmp349_->cvalue = _tmp359_;
					_tmp360_ = _result_;
					_tmp361_ = node;
					_tmp362_ = vala_ccode_base_module_store_temp_value (self, (ValaTargetValue*) _tmp360_, _tmp361_, NULL);
					_vala_target_value_unref0 (_result_);
					_result_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp362_, VALA_TYPE_GLIB_VALUE, ValaGLibValue);
				}
				_tmp363_ = _result_;
				_tmp364_ = _result_;
				_tmp365_ = _tmp364_->cvalue;
				_tmp366_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp365_);
				_vala_ccode_node_unref0 (_tmp363_->cvalue);
				_tmp363_->cvalue = (ValaCCodeExpression*) _tmp366_;
				_tmp367_ = _result_;
				_tmp367_->lvalue = FALSE;
				_tmp368_ = _result_;
				_tmp369_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp368_);
				_tmp370_ = _tmp369_;
				vala_data_type_set_nullable (_tmp370_, TRUE);
			} else {
				gboolean _tmp371_;
				_tmp371_ = unboxing;
				if (_tmp371_) {
					ValaGLibValue* _tmp372_;
					ValaGLibValue* _tmp373_;
					ValaCCodeExpression* _tmp374_;
					ValaCCodeUnaryExpression* _tmp375_;
					_tmp372_ = _result_;
					_tmp373_ = _result_;
					_tmp374_ = _tmp373_->cvalue;
					_tmp375_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp374_);
					_vala_ccode_node_unref0 (_tmp372_->cvalue);
					_tmp372_->cvalue = (ValaCCodeExpression*) _tmp375_;
				} else {
					ValaCCodeExpression* old_cexpr = NULL;
					ValaGLibValue* _tmp376_;
					ValaCCodeExpression* _tmp377_;
					ValaCCodeExpression* _tmp378_;
					ValaGLibValue* _tmp379_;
					ValaGLibValue* _tmp380_;
					ValaCCodeExpression* _tmp381_;
					ValaDataType* _tmp382_;
					ValaDataType* _tmp383_;
					ValaCodeNode* _tmp384_;
					ValaCCodeExpression* _tmp385_;
					gboolean _tmp386_ = FALSE;
					ValaGLibValue* _tmp387_;
					gboolean _tmp388_;
					ValaGLibValue* _tmp392_;
					_tmp376_ = _result_;
					_tmp377_ = _tmp376_->cvalue;
					_tmp378_ = _vala_ccode_node_ref0 (_tmp377_);
					old_cexpr = _tmp378_;
					_tmp379_ = _result_;
					_tmp380_ = _result_;
					_tmp381_ = _tmp380_->cvalue;
					_tmp382_ = type;
					_tmp383_ = target_type;
					_tmp384_ = node;
					_tmp385_ = vala_ccode_base_module_get_implicit_cast_expression (self, _tmp381_, _tmp382_, _tmp383_, _tmp384_);
					_vala_ccode_node_unref0 (_tmp379_->cvalue);
					_tmp379_->cvalue = _tmp385_;
					_tmp387_ = _result_;
					_tmp388_ = _tmp387_->lvalue;
					if (_tmp388_) {
						ValaGLibValue* _tmp389_;
						ValaCCodeExpression* _tmp390_;
						ValaCCodeExpression* _tmp391_;
						_tmp389_ = _result_;
						_tmp390_ = _tmp389_->cvalue;
						_tmp391_ = old_cexpr;
						_tmp386_ = _tmp390_ == _tmp391_;
					} else {
						_tmp386_ = FALSE;
					}
					_tmp392_ = _result_;
					_tmp392_->lvalue = _tmp386_;
					_vala_ccode_node_unref0 (old_cexpr);
				}
			}
		}
	}
	array_needs_copy = FALSE;
	_tmp394_ = type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp394_, VALA_TYPE_ARRAY_TYPE)) {
		ValaDataType* _tmp395_;
		_tmp395_ = target_type;
		_tmp393_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp395_, VALA_TYPE_ARRAY_TYPE);
	} else {
		_tmp393_ = FALSE;
	}
	if (_tmp393_) {
		ValaArrayType* array = NULL;
		ValaDataType* _tmp396_;
		ValaArrayType* _tmp397_;
		ValaArrayType* target_array = NULL;
		ValaDataType* _tmp398_;
		ValaArrayType* _tmp399_;
		gboolean _tmp400_ = FALSE;
		ValaArrayType* _tmp401_;
		ValaDataType* _tmp402_;
		ValaDataType* _tmp403_;
		gboolean _tmp404_;
		gboolean _tmp405_;
		_tmp396_ = type;
		_tmp397_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp396_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		array = _tmp397_;
		_tmp398_ = target_type;
		_tmp399_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp398_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		target_array = _tmp399_;
		_tmp401_ = target_array;
		_tmp402_ = vala_array_type_get_element_type (_tmp401_);
		_tmp403_ = _tmp402_;
		_tmp404_ = vala_data_type_get_value_owned (_tmp403_);
		_tmp405_ = _tmp404_;
		if (_tmp405_) {
			ValaArrayType* _tmp406_;
			ValaDataType* _tmp407_;
			ValaDataType* _tmp408_;
			gboolean _tmp409_;
			gboolean _tmp410_;
			_tmp406_ = array;
			_tmp407_ = vala_array_type_get_element_type (_tmp406_);
			_tmp408_ = _tmp407_;
			_tmp409_ = vala_data_type_get_value_owned (_tmp408_);
			_tmp410_ = _tmp409_;
			_tmp400_ = !_tmp410_;
		} else {
			_tmp400_ = FALSE;
		}
		if (_tmp400_) {
			ValaArrayType* _tmp411_;
			ValaDataType* _tmp412_;
			ValaDataType* _tmp413_;
			gboolean _tmp414_;
			_tmp411_ = target_array;
			_tmp412_ = vala_array_type_get_element_type (_tmp411_);
			_tmp413_ = _tmp412_;
			_tmp414_ = vala_ccode_base_module_requires_copy (self, _tmp413_);
			array_needs_copy = _tmp414_;
		}
		_vala_code_node_unref0 (target_array);
		_vala_code_node_unref0 (array);
	}
	_tmp420_ = gvalue_boxing;
	if (!_tmp420_) {
		gboolean _tmp421_;
		_tmp421_ = gvariant_boxing;
		_tmp419_ = !_tmp421_;
	} else {
		_tmp419_ = FALSE;
	}
	if (_tmp419_) {
		ValaDataType* _tmp422_;
		gboolean _tmp423_;
		gboolean _tmp424_;
		_tmp422_ = target_type;
		_tmp423_ = vala_data_type_get_value_owned (_tmp422_);
		_tmp424_ = _tmp423_;
		_tmp418_ = _tmp424_;
	} else {
		_tmp418_ = FALSE;
	}
	if (_tmp418_) {
		gboolean _tmp425_ = FALSE;
		gboolean _tmp426_ = FALSE;
		gboolean _tmp427_ = FALSE;
		ValaDataType* _tmp428_;
		gboolean _tmp429_;
		gboolean _tmp430_;
		_tmp428_ = type;
		_tmp429_ = vala_data_type_get_value_owned (_tmp428_);
		_tmp430_ = _tmp429_;
		if (!_tmp430_) {
			_tmp427_ = TRUE;
		} else {
			gboolean _tmp431_;
			_tmp431_ = boxing;
			_tmp427_ = _tmp431_;
		}
		if (_tmp427_) {
			_tmp426_ = TRUE;
		} else {
			gboolean _tmp432_;
			_tmp432_ = unboxing;
			_tmp426_ = _tmp432_;
		}
		if (_tmp426_) {
			_tmp425_ = TRUE;
		} else {
			gboolean _tmp433_;
			_tmp433_ = array_needs_copy;
			_tmp425_ = _tmp433_;
		}
		_tmp417_ = _tmp425_;
	} else {
		_tmp417_ = FALSE;
	}
	if (_tmp417_) {
		ValaDataType* _tmp434_;
		gboolean _tmp435_;
		_tmp434_ = target_type;
		_tmp435_ = vala_ccode_base_module_requires_copy (self, _tmp434_);
		_tmp416_ = _tmp435_;
	} else {
		_tmp416_ = FALSE;
	}
	if (_tmp416_) {
		ValaDataType* _tmp436_;
		_tmp436_ = type;
		_tmp415_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp436_, VALA_TYPE_NULL_TYPE);
	} else {
		_tmp415_ = FALSE;
	}
	if (_tmp415_) {
		ValaGLibValue* copy = NULL;
		ValaGLibValue* _tmp437_;
		ValaCodeNode* _tmp438_;
		ValaTargetValue* _tmp439_;
		gboolean _tmp440_ = FALSE;
		ValaDataType* _tmp441_;
		ValaTypeSymbol* _tmp442_;
		ValaTypeSymbol* _tmp443_;
		ValaGLibValue* _tmp455_;
		ValaGLibValue* _tmp456_;
		_tmp437_ = _result_;
		_tmp438_ = node;
		_tmp439_ = vala_ccode_base_module_copy_value (self, (ValaTargetValue*) _tmp437_, _tmp438_);
		copy = G_TYPE_CHECK_INSTANCE_CAST (_tmp439_, VALA_TYPE_GLIB_VALUE, ValaGLibValue);
		_tmp441_ = target_type;
		_tmp442_ = vala_data_type_get_data_type (_tmp441_);
		_tmp443_ = _tmp442_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp443_, VALA_TYPE_INTERFACE)) {
			ValaGLibValue* _tmp444_;
			_tmp444_ = copy;
			_tmp440_ = _tmp444_ == NULL;
		} else {
			_tmp440_ = FALSE;
		}
		if (_tmp440_) {
			ValaCodeNode* _tmp445_;
			ValaSourceReference* _tmp446_;
			ValaSourceReference* _tmp447_;
			ValaDataType* _tmp448_;
			ValaTypeSymbol* _tmp449_;
			ValaTypeSymbol* _tmp450_;
			gchar* _tmp451_;
			gchar* _tmp452_;
			gchar* _tmp453_;
			gchar* _tmp454_;
			_tmp445_ = node;
			_tmp446_ = vala_code_node_get_source_reference (_tmp445_);
			_tmp447_ = _tmp446_;
			_tmp448_ = target_type;
			_tmp449_ = vala_data_type_get_data_type (_tmp448_);
			_tmp450_ = _tmp449_;
			_tmp451_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp450_);
			_tmp452_ = _tmp451_;
			_tmp453_ = g_strdup_printf ("missing class prerequisite for interface `%s', add GLib.Object to inte" \
"rface declaration if unsure", _tmp452_);
			_tmp454_ = _tmp453_;
			vala_report_error (_tmp447_, _tmp454_);
			_g_free0 (_tmp454_);
			_g_free0 (_tmp452_);
			result = (ValaTargetValue*) _result_;
			_vala_target_value_unref0 (copy);
			_vala_code_node_unref0 (type);
			return result;
		}
		_tmp455_ = copy;
		_tmp456_ = _vala_target_value_ref0 (_tmp455_);
		_vala_target_value_unref0 (_result_);
		_result_ = _tmp456_;
		_vala_target_value_unref0 (copy);
	}
	result = (ValaTargetValue*) _result_;
	_vala_code_node_unref0 (type);
	return result;
}


static ValaCCodeExpression* vala_ccode_base_module_real_get_implicit_cast_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeExpression* cexpr = NULL;
	ValaCCodeExpression* _tmp0_;
	ValaCCodeExpression* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaDataType* _tmp3_;
	ValaTypeSymbol* _tmp4_;
	ValaTypeSymbol* _tmp5_;
	ValaDataType* _tmp12_;
	ValaDataType* _tmp13_;
	ValaCCodeFile* _tmp14_;
	ValaClass* cl = NULL;
	ValaDataType* _tmp15_;
	ValaTypeSymbol* _tmp16_;
	ValaTypeSymbol* _tmp17_;
	ValaClass* _tmp18_;
	ValaInterface* iface = NULL;
	ValaDataType* _tmp19_;
	ValaTypeSymbol* _tmp20_;
	ValaTypeSymbol* _tmp21_;
	ValaInterface* _tmp22_;
	gboolean _tmp23_ = FALSE;
	ValaCodeContext* _tmp24_;
	gboolean _tmp25_;
	gboolean _tmp26_;
	g_return_val_if_fail (source_cexpr != NULL, NULL);
	_tmp0_ = source_cexpr;
	_tmp1_ = _vala_ccode_node_ref0 (_tmp0_);
	cexpr = _tmp1_;
	_tmp3_ = expression_type;
	_tmp4_ = vala_data_type_get_data_type (_tmp3_);
	_tmp5_ = _tmp4_;
	if (_tmp5_ != NULL) {
		ValaDataType* _tmp6_;
		ValaTypeSymbol* _tmp7_;
		ValaTypeSymbol* _tmp8_;
		ValaDataType* _tmp9_;
		ValaTypeSymbol* _tmp10_;
		ValaTypeSymbol* _tmp11_;
		_tmp6_ = expression_type;
		_tmp7_ = vala_data_type_get_data_type (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = target_type;
		_tmp10_ = vala_data_type_get_data_type (_tmp9_);
		_tmp11_ = _tmp10_;
		_tmp2_ = _tmp8_ == _tmp11_;
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		result = cexpr;
		return result;
	}
	_tmp12_ = expression_type;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_NULL_TYPE)) {
		result = cexpr;
		return result;
	}
	_tmp13_ = target_type;
	_tmp14_ = self->cfile;
	vala_ccode_base_module_generate_type_declaration (self, _tmp13_, _tmp14_);
	_tmp15_ = target_type;
	_tmp16_ = vala_data_type_get_data_type (_tmp15_);
	_tmp17_ = _tmp16_;
	_tmp18_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp17_) : NULL);
	cl = _tmp18_;
	_tmp19_ = target_type;
	_tmp20_ = vala_data_type_get_data_type (_tmp19_);
	_tmp21_ = _tmp20_;
	_tmp22_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp21_, VALA_TYPE_INTERFACE) ? ((ValaInterface*) _tmp21_) : NULL);
	iface = _tmp22_;
	_tmp24_ = self->priv->_context;
	_tmp25_ = vala_code_context_get_checking (_tmp24_);
	_tmp26_ = _tmp25_;
	if (_tmp26_) {
		gboolean _tmp27_ = FALSE;
		ValaInterface* _tmp28_;
		_tmp28_ = iface;
		if (_tmp28_ != NULL) {
			_tmp27_ = TRUE;
		} else {
			gboolean _tmp29_ = FALSE;
			ValaClass* _tmp30_;
			_tmp30_ = cl;
			if (_tmp30_ != NULL) {
				ValaClass* _tmp31_;
				gboolean _tmp32_;
				gboolean _tmp33_;
				_tmp31_ = cl;
				_tmp32_ = vala_class_get_is_compact (_tmp31_);
				_tmp33_ = _tmp32_;
				_tmp29_ = !_tmp33_;
			} else {
				_tmp29_ = FALSE;
			}
			_tmp27_ = _tmp29_;
		}
		_tmp23_ = _tmp27_;
	} else {
		_tmp23_ = FALSE;
	}
	if (_tmp23_) {
		ValaCCodeExpression* _tmp34_;
		ValaDataType* _tmp35_;
		ValaTypeSymbol* _tmp36_;
		ValaTypeSymbol* _tmp37_;
		ValaCCodeFunctionCall* _tmp38_;
		_tmp34_ = cexpr;
		_tmp35_ = target_type;
		_tmp36_ = vala_data_type_get_data_type (_tmp35_);
		_tmp37_ = _tmp36_;
		_tmp38_ = vala_ccode_base_module_generate_instance_cast (self, _tmp34_, _tmp37_);
		result = (ValaCCodeExpression*) _tmp38_;
		_vala_code_node_unref0 (iface);
		_vala_code_node_unref0 (cl);
		_vala_ccode_node_unref0 (cexpr);
		return result;
	} else {
		gboolean _tmp39_ = FALSE;
		ValaDataType* _tmp40_;
		ValaTypeSymbol* _tmp41_;
		ValaTypeSymbol* _tmp42_;
		_tmp40_ = target_type;
		_tmp41_ = vala_data_type_get_data_type (_tmp40_);
		_tmp42_ = _tmp41_;
		if (_tmp42_ != NULL) {
			ValaDataType* _tmp43_;
			gchar* _tmp44_;
			gchar* _tmp45_;
			ValaDataType* _tmp46_;
			gchar* _tmp47_;
			gchar* _tmp48_;
			_tmp43_ = expression_type;
			_tmp44_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp43_);
			_tmp45_ = _tmp44_;
			_tmp46_ = target_type;
			_tmp47_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp46_);
			_tmp48_ = _tmp47_;
			_tmp39_ = g_strcmp0 (_tmp45_, _tmp48_) != 0;
			_g_free0 (_tmp48_);
			_g_free0 (_tmp45_);
		} else {
			_tmp39_ = FALSE;
		}
		if (_tmp39_) {
			ValaStruct* st = NULL;
			ValaDataType* _tmp49_;
			ValaTypeSymbol* _tmp50_;
			ValaTypeSymbol* _tmp51_;
			ValaStruct* _tmp52_;
			gboolean _tmp53_ = FALSE;
			ValaDataType* _tmp54_;
			ValaTypeSymbol* _tmp55_;
			ValaTypeSymbol* _tmp56_;
			gboolean _tmp57_;
			_tmp49_ = target_type;
			_tmp50_ = vala_data_type_get_data_type (_tmp49_);
			_tmp51_ = _tmp50_;
			_tmp52_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp51_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp51_) : NULL);
			st = _tmp52_;
			_tmp54_ = target_type;
			_tmp55_ = vala_data_type_get_data_type (_tmp54_);
			_tmp56_ = _tmp55_;
			_tmp57_ = vala_typesymbol_is_reference_type (_tmp56_);
			if (_tmp57_) {
				_tmp53_ = TRUE;
			} else {
				gboolean _tmp58_ = FALSE;
				ValaStruct* _tmp59_;
				_tmp59_ = st;
				if (_tmp59_ != NULL) {
					ValaStruct* _tmp60_;
					gboolean _tmp61_;
					_tmp60_ = st;
					_tmp61_ = vala_struct_is_simple_type (_tmp60_);
					_tmp58_ = _tmp61_;
				} else {
					_tmp58_ = FALSE;
				}
				_tmp53_ = _tmp58_;
			}
			if (_tmp53_) {
				ValaCCodeExpression* _tmp62_;
				ValaDataType* _tmp63_;
				gchar* _tmp64_;
				gchar* _tmp65_;
				ValaCCodeCastExpression* _tmp66_;
				ValaCCodeExpression* _tmp67_;
				_tmp62_ = cexpr;
				_tmp63_ = target_type;
				_tmp64_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp63_);
				_tmp65_ = _tmp64_;
				_tmp66_ = vala_ccode_cast_expression_new (_tmp62_, _tmp65_);
				_tmp67_ = (ValaCCodeExpression*) _tmp66_;
				_g_free0 (_tmp65_);
				result = _tmp67_;
				_vala_code_node_unref0 (st);
				_vala_code_node_unref0 (iface);
				_vala_code_node_unref0 (cl);
				_vala_ccode_node_unref0 (cexpr);
				return result;
			} else {
				result = cexpr;
				_vala_code_node_unref0 (st);
				_vala_code_node_unref0 (iface);
				_vala_code_node_unref0 (cl);
				return result;
			}
			_vala_code_node_unref0 (st);
		} else {
			result = cexpr;
			_vala_code_node_unref0 (iface);
			_vala_code_node_unref0 (cl);
			return result;
		}
	}
	_vala_code_node_unref0 (iface);
	_vala_code_node_unref0 (cl);
	_vala_ccode_node_unref0 (cexpr);
}


ValaCCodeExpression* vala_ccode_base_module_get_implicit_cast_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_implicit_cast_expression (self, source_cexpr, expression_type, target_type, node);
}


void vala_ccode_base_module_store_property (ValaCCodeBaseModule* self, ValaProperty* prop, ValaExpression* instance, ValaTargetValue* value) {
	ValaExpression* _tmp0_;
	gchar* set_func = NULL;
	gchar* _tmp102_;
	ValaProperty* base_property = NULL;
	ValaProperty* _tmp103_;
	ValaProperty* _tmp104_;
	ValaProperty* _tmp105_;
	gboolean _tmp106_;
	ValaCCodeFunctionCall* ccall = NULL;
	const gchar* _tmp142_;
	ValaCCodeIdentifier* _tmp143_;
	ValaCCodeIdentifier* _tmp144_;
	ValaCCodeFunctionCall* _tmp145_;
	ValaCCodeFunctionCall* _tmp146_;
	ValaProperty* _tmp147_;
	ValaMemberBinding _tmp148_;
	ValaMemberBinding _tmp149_;
	ValaProperty* _tmp175_;
	gboolean _tmp176_;
	ValaCCodeExpression* cexpr = NULL;
	ValaTargetValue* _tmp181_;
	ValaCCodeExpression* _tmp182_;
	ValaProperty* _tmp183_;
	ValaDataType* _tmp184_;
	ValaDataType* _tmp185_;
	gboolean _tmp186_;
	ValaArrayType* array_type = NULL;
	ValaProperty* _tmp189_;
	ValaDataType* _tmp190_;
	ValaDataType* _tmp191_;
	ValaArrayType* _tmp192_;
	ValaCCodeFunctionCall* _tmp193_;
	ValaCCodeExpression* _tmp194_;
	gboolean _tmp195_ = FALSE;
	ValaArrayType* _tmp196_;
	ValaProperty* _tmp237_;
	gboolean _tmp238_;
	ValaCCodeFunction* _tmp242_;
	ValaCCodeFunction* _tmp243_;
	ValaCCodeFunctionCall* _tmp244_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (prop != NULL);
	g_return_if_fail (value != NULL);
	_tmp0_ = instance;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_BASE_ACCESS)) {
		ValaProperty* _tmp1_;
		ValaProperty* _tmp2_;
		ValaProperty* _tmp3_;
		_tmp1_ = prop;
		_tmp2_ = vala_property_get_base_property (_tmp1_);
		_tmp3_ = _tmp2_;
		if (_tmp3_ != NULL) {
			ValaClass* base_class = NULL;
			ValaProperty* _tmp4_;
			ValaProperty* _tmp5_;
			ValaProperty* _tmp6_;
			ValaSymbol* _tmp7_;
			ValaSymbol* _tmp8_;
			ValaClass* _tmp9_;
			ValaCCodeFunctionCall* vcast = NULL;
			ValaClass* _tmp10_;
			gchar* _tmp11_;
			gchar* _tmp12_;
			gchar* _tmp13_;
			gchar* _tmp14_;
			ValaCCodeIdentifier* _tmp15_;
			ValaCCodeIdentifier* _tmp16_;
			ValaCCodeFunctionCall* _tmp17_;
			ValaCCodeFunctionCall* _tmp18_;
			ValaCCodeFunctionCall* _tmp19_;
			ValaClass* _tmp20_;
			ValaClass* _tmp21_;
			gchar* _tmp22_;
			gchar* _tmp23_;
			gchar* _tmp24_;
			gchar* _tmp25_;
			ValaCCodeIdentifier* _tmp26_;
			ValaCCodeIdentifier* _tmp27_;
			ValaCCodeFunctionCall* ccall = NULL;
			ValaCCodeFunctionCall* _tmp28_;
			ValaProperty* _tmp29_;
			const gchar* _tmp30_;
			const gchar* _tmp31_;
			gchar* _tmp32_;
			gchar* _tmp33_;
			ValaCCodeMemberAccess* _tmp34_;
			ValaCCodeMemberAccess* _tmp35_;
			ValaCCodeFunctionCall* _tmp36_;
			ValaCCodeFunctionCall* _tmp37_;
			ValaCCodeFunctionCall* _tmp38_;
			ValaExpression* _tmp39_;
			ValaCCodeExpression* _tmp40_;
			ValaCCodeExpression* _tmp41_;
			ValaCCodeExpression* cexpr = NULL;
			ValaTargetValue* _tmp42_;
			ValaCCodeExpression* _tmp43_;
			ValaProperty* _tmp44_;
			ValaDataType* _tmp45_;
			ValaDataType* _tmp46_;
			gboolean _tmp47_;
			ValaCCodeFunctionCall* _tmp50_;
			ValaCCodeExpression* _tmp51_;
			ValaCCodeFunction* _tmp52_;
			ValaCCodeFunction* _tmp53_;
			ValaCCodeFunctionCall* _tmp54_;
			_tmp4_ = prop;
			_tmp5_ = vala_property_get_base_property (_tmp4_);
			_tmp6_ = _tmp5_;
			_tmp7_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp6_);
			_tmp8_ = _tmp7_;
			_tmp9_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_CLASS, ValaClass));
			base_class = _tmp9_;
			_tmp10_ = base_class;
			_tmp11_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp10_, NULL);
			_tmp12_ = _tmp11_;
			_tmp13_ = g_strdup_printf ("%s_CLASS", _tmp12_);
			_tmp14_ = _tmp13_;
			_tmp15_ = vala_ccode_identifier_new (_tmp14_);
			_tmp16_ = _tmp15_;
			_tmp17_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp16_);
			_tmp18_ = _tmp17_;
			_vala_ccode_node_unref0 (_tmp16_);
			_g_free0 (_tmp14_);
			_g_free0 (_tmp12_);
			vcast = _tmp18_;
			_tmp19_ = vcast;
			_tmp20_ = vala_ccode_base_module_get_current_class (self);
			_tmp21_ = _tmp20_;
			_tmp22_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp21_, NULL);
			_tmp23_ = _tmp22_;
			_tmp24_ = g_strdup_printf ("%s_parent_class", _tmp23_);
			_tmp25_ = _tmp24_;
			_tmp26_ = vala_ccode_identifier_new (_tmp25_);
			_tmp27_ = _tmp26_;
			vala_ccode_function_call_add_argument (_tmp19_, (ValaCCodeExpression*) _tmp27_);
			_vala_ccode_node_unref0 (_tmp27_);
			_g_free0 (_tmp25_);
			_g_free0 (_tmp23_);
			_tmp28_ = vcast;
			_tmp29_ = prop;
			_tmp30_ = vala_symbol_get_name ((ValaSymbol*) _tmp29_);
			_tmp31_ = _tmp30_;
			_tmp32_ = g_strdup_printf ("set_%s", _tmp31_);
			_tmp33_ = _tmp32_;
			_tmp34_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp28_, _tmp33_);
			_tmp35_ = _tmp34_;
			_tmp36_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp35_);
			_tmp37_ = _tmp36_;
			_vala_ccode_node_unref0 (_tmp35_);
			_g_free0 (_tmp33_);
			ccall = _tmp37_;
			_tmp38_ = ccall;
			_tmp39_ = instance;
			_tmp40_ = vala_ccode_base_module_get_ccodenode (self, _tmp39_);
			_tmp41_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp40_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression);
			vala_ccode_function_call_add_argument (_tmp38_, _tmp41_);
			_vala_ccode_node_unref0 (_tmp41_);
			_tmp42_ = value;
			_tmp43_ = vala_ccode_base_module_get_cvalue_ (self, _tmp42_);
			cexpr = _tmp43_;
			_tmp44_ = prop;
			_tmp45_ = vala_property_get_property_type (_tmp44_);
			_tmp46_ = _tmp45_;
			_tmp47_ = vala_data_type_is_real_non_null_struct_type (_tmp46_);
			if (_tmp47_) {
				ValaCCodeExpression* _tmp48_;
				ValaCCodeUnaryExpression* _tmp49_;
				_tmp48_ = cexpr;
				_tmp49_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp48_);
				_vala_ccode_node_unref0 (cexpr);
				cexpr = (ValaCCodeExpression*) _tmp49_;
			}
			_tmp50_ = ccall;
			_tmp51_ = cexpr;
			vala_ccode_function_call_add_argument (_tmp50_, _tmp51_);
			_tmp52_ = vala_ccode_base_module_get_ccode (self);
			_tmp53_ = _tmp52_;
			_tmp54_ = ccall;
			vala_ccode_function_add_expression (_tmp53_, (ValaCCodeExpression*) _tmp54_);
			_vala_ccode_node_unref0 (cexpr);
			_vala_ccode_node_unref0 (ccall);
			_vala_ccode_node_unref0 (vcast);
			_vala_code_node_unref0 (base_class);
		} else {
			ValaProperty* _tmp55_;
			ValaProperty* _tmp56_;
			ValaProperty* _tmp57_;
			_tmp55_ = prop;
			_tmp56_ = vala_property_get_base_interface_property (_tmp55_);
			_tmp57_ = _tmp56_;
			if (_tmp57_ != NULL) {
				ValaInterface* base_iface = NULL;
				ValaProperty* _tmp58_;
				ValaProperty* _tmp59_;
				ValaProperty* _tmp60_;
				ValaSymbol* _tmp61_;
				ValaSymbol* _tmp62_;
				ValaInterface* _tmp63_;
				gchar* parent_iface_var = NULL;
				ValaClass* _tmp64_;
				ValaClass* _tmp65_;
				gchar* _tmp66_;
				gchar* _tmp67_;
				ValaInterface* _tmp68_;
				gchar* _tmp69_;
				gchar* _tmp70_;
				gchar* _tmp71_;
				gchar* _tmp72_;
				ValaCCodeFunctionCall* ccall = NULL;
				const gchar* _tmp73_;
				ValaCCodeIdentifier* _tmp74_;
				ValaCCodeIdentifier* _tmp75_;
				ValaProperty* _tmp76_;
				const gchar* _tmp77_;
				const gchar* _tmp78_;
				gchar* _tmp79_;
				gchar* _tmp80_;
				ValaCCodeMemberAccess* _tmp81_;
				ValaCCodeMemberAccess* _tmp82_;
				ValaCCodeFunctionCall* _tmp83_;
				ValaCCodeFunctionCall* _tmp84_;
				ValaCCodeFunctionCall* _tmp85_;
				ValaExpression* _tmp86_;
				ValaCCodeExpression* _tmp87_;
				ValaCCodeExpression* _tmp88_;
				ValaCCodeExpression* cexpr = NULL;
				ValaTargetValue* _tmp89_;
				ValaCCodeExpression* _tmp90_;
				ValaProperty* _tmp91_;
				ValaDataType* _tmp92_;
				ValaDataType* _tmp93_;
				gboolean _tmp94_;
				ValaCCodeFunctionCall* _tmp97_;
				ValaCCodeExpression* _tmp98_;
				ValaCCodeFunction* _tmp99_;
				ValaCCodeFunction* _tmp100_;
				ValaCCodeFunctionCall* _tmp101_;
				_tmp58_ = prop;
				_tmp59_ = vala_property_get_base_interface_property (_tmp58_);
				_tmp60_ = _tmp59_;
				_tmp61_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp60_);
				_tmp62_ = _tmp61_;
				_tmp63_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp62_, VALA_TYPE_INTERFACE, ValaInterface));
				base_iface = _tmp63_;
				_tmp64_ = vala_ccode_base_module_get_current_class (self);
				_tmp65_ = _tmp64_;
				_tmp66_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp65_, NULL);
				_tmp67_ = _tmp66_;
				_tmp68_ = base_iface;
				_tmp69_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp68_, NULL);
				_tmp70_ = _tmp69_;
				_tmp71_ = g_strdup_printf ("%s_%s_parent_iface", _tmp67_, _tmp70_);
				_tmp72_ = _tmp71_;
				_g_free0 (_tmp70_);
				_g_free0 (_tmp67_);
				parent_iface_var = _tmp72_;
				_tmp73_ = parent_iface_var;
				_tmp74_ = vala_ccode_identifier_new (_tmp73_);
				_tmp75_ = _tmp74_;
				_tmp76_ = prop;
				_tmp77_ = vala_symbol_get_name ((ValaSymbol*) _tmp76_);
				_tmp78_ = _tmp77_;
				_tmp79_ = g_strdup_printf ("set_%s", _tmp78_);
				_tmp80_ = _tmp79_;
				_tmp81_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp75_, _tmp80_);
				_tmp82_ = _tmp81_;
				_tmp83_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp82_);
				_tmp84_ = _tmp83_;
				_vala_ccode_node_unref0 (_tmp82_);
				_g_free0 (_tmp80_);
				_vala_ccode_node_unref0 (_tmp75_);
				ccall = _tmp84_;
				_tmp85_ = ccall;
				_tmp86_ = instance;
				_tmp87_ = vala_ccode_base_module_get_ccodenode (self, _tmp86_);
				_tmp88_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp87_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression);
				vala_ccode_function_call_add_argument (_tmp85_, _tmp88_);
				_vala_ccode_node_unref0 (_tmp88_);
				_tmp89_ = value;
				_tmp90_ = vala_ccode_base_module_get_cvalue_ (self, _tmp89_);
				cexpr = _tmp90_;
				_tmp91_ = prop;
				_tmp92_ = vala_property_get_property_type (_tmp91_);
				_tmp93_ = _tmp92_;
				_tmp94_ = vala_data_type_is_real_non_null_struct_type (_tmp93_);
				if (_tmp94_) {
					ValaCCodeExpression* _tmp95_;
					ValaCCodeUnaryExpression* _tmp96_;
					_tmp95_ = cexpr;
					_tmp96_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp95_);
					_vala_ccode_node_unref0 (cexpr);
					cexpr = (ValaCCodeExpression*) _tmp96_;
				}
				_tmp97_ = ccall;
				_tmp98_ = cexpr;
				vala_ccode_function_call_add_argument (_tmp97_, _tmp98_);
				_tmp99_ = vala_ccode_base_module_get_ccode (self);
				_tmp100_ = _tmp99_;
				_tmp101_ = ccall;
				vala_ccode_function_add_expression (_tmp100_, (ValaCCodeExpression*) _tmp101_);
				_vala_ccode_node_unref0 (cexpr);
				_vala_ccode_node_unref0 (ccall);
				_g_free0 (parent_iface_var);
				_vala_code_node_unref0 (base_iface);
			}
		}
		return;
	}
	_tmp102_ = g_strdup ("g_object_set");
	set_func = _tmp102_;
	_tmp103_ = prop;
	_tmp104_ = _vala_code_node_ref0 (_tmp103_);
	base_property = _tmp104_;
	_tmp105_ = prop;
	_tmp106_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp105_);
	if (!_tmp106_) {
		ValaProperty* _tmp107_;
		ValaProperty* _tmp108_;
		ValaProperty* _tmp109_;
		ValaProperty* _tmp121_;
		_tmp107_ = prop;
		_tmp108_ = vala_property_get_base_property (_tmp107_);
		_tmp109_ = _tmp108_;
		if (_tmp109_ != NULL) {
			ValaProperty* _tmp110_;
			ValaProperty* _tmp111_;
			ValaProperty* _tmp112_;
			ValaProperty* _tmp113_;
			_tmp110_ = prop;
			_tmp111_ = vala_property_get_base_property (_tmp110_);
			_tmp112_ = _tmp111_;
			_tmp113_ = _vala_code_node_ref0 (_tmp112_);
			_vala_code_node_unref0 (base_property);
			base_property = _tmp113_;
		} else {
			ValaProperty* _tmp114_;
			ValaProperty* _tmp115_;
			ValaProperty* _tmp116_;
			_tmp114_ = prop;
			_tmp115_ = vala_property_get_base_interface_property (_tmp114_);
			_tmp116_ = _tmp115_;
			if (_tmp116_ != NULL) {
				ValaProperty* _tmp117_;
				ValaProperty* _tmp118_;
				ValaProperty* _tmp119_;
				ValaProperty* _tmp120_;
				_tmp117_ = prop;
				_tmp118_ = vala_property_get_base_interface_property (_tmp117_);
				_tmp119_ = _tmp118_;
				_tmp120_ = _vala_code_node_ref0 (_tmp119_);
				_vala_code_node_unref0 (base_property);
				base_property = _tmp120_;
			}
		}
		_tmp121_ = prop;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp121_, VALA_TYPE_DYNAMIC_PROPERTY)) {
			ValaProperty* _tmp122_;
			gchar* _tmp123_;
			_tmp122_ = prop;
			_tmp123_ = vala_ccode_base_module_get_dynamic_property_setter_cname (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp122_, VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicProperty));
			_g_free0 (set_func);
			set_func = _tmp123_;
		} else {
			ValaProperty* _tmp124_;
			ValaPropertyAccessor* _tmp125_;
			ValaPropertyAccessor* _tmp126_;
			ValaCCodeFile* _tmp127_;
			ValaProperty* _tmp128_;
			ValaPropertyAccessor* _tmp129_;
			ValaPropertyAccessor* _tmp130_;
			gchar* _tmp131_;
			gboolean _tmp132_ = FALSE;
			ValaProperty* _tmp133_;
			gboolean _tmp134_;
			gboolean _tmp135_;
			_tmp124_ = base_property;
			_tmp125_ = vala_property_get_set_accessor (_tmp124_);
			_tmp126_ = _tmp125_;
			_tmp127_ = self->cfile;
			vala_ccode_base_module_generate_property_accessor_declaration (self, _tmp126_, _tmp127_);
			_tmp128_ = base_property;
			_tmp129_ = vala_property_get_set_accessor (_tmp128_);
			_tmp130_ = _tmp129_;
			_tmp131_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp130_);
			_g_free0 (set_func);
			set_func = _tmp131_;
			_tmp133_ = prop;
			_tmp134_ = vala_symbol_get_external ((ValaSymbol*) _tmp133_);
			_tmp135_ = _tmp134_;
			if (!_tmp135_) {
				ValaProperty* _tmp136_;
				gboolean _tmp137_;
				gboolean _tmp138_;
				_tmp136_ = prop;
				_tmp137_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp136_);
				_tmp138_ = _tmp137_;
				_tmp132_ = _tmp138_;
			} else {
				_tmp132_ = FALSE;
			}
			if (_tmp132_) {
				ValaProperty* _tmp139_;
				gboolean _tmp140_;
				_tmp139_ = prop;
				_tmp140_ = vala_ccode_base_module_add_generated_external_symbol (self, (ValaSymbol*) _tmp139_);
				if (_tmp140_) {
					ValaProperty* _tmp141_;
					_tmp141_ = prop;
					vala_code_visitor_visit_property ((ValaCodeVisitor*) self, _tmp141_);
				}
			}
		}
	}
	_tmp142_ = set_func;
	_tmp143_ = vala_ccode_identifier_new (_tmp142_);
	_tmp144_ = _tmp143_;
	_tmp145_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp144_);
	_tmp146_ = _tmp145_;
	_vala_ccode_node_unref0 (_tmp144_);
	ccall = _tmp146_;
	_tmp147_ = prop;
	_tmp148_ = vala_property_get_binding (_tmp147_);
	_tmp149_ = _tmp148_;
	if (_tmp149_ == VALA_MEMBER_BINDING_INSTANCE) {
		ValaCCodeExpression* cinstance = NULL;
		ValaExpression* _tmp150_;
		ValaCCodeExpression* _tmp151_;
		gboolean _tmp152_ = FALSE;
		ValaProperty* _tmp153_;
		ValaSymbol* _tmp154_;
		ValaSymbol* _tmp155_;
		ValaCCodeFunctionCall* _tmp173_;
		ValaCCodeExpression* _tmp174_;
		_tmp150_ = instance;
		_tmp151_ = vala_ccode_base_module_get_ccodenode (self, _tmp150_);
		cinstance = G_TYPE_CHECK_INSTANCE_CAST (_tmp151_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression);
		_tmp153_ = prop;
		_tmp154_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp153_);
		_tmp155_ = _tmp154_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp155_, VALA_TYPE_STRUCT)) {
			ValaProperty* _tmp156_;
			ValaSymbol* _tmp157_;
			ValaSymbol* _tmp158_;
			gboolean _tmp159_;
			_tmp156_ = prop;
			_tmp157_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp156_);
			_tmp158_ = _tmp157_;
			_tmp159_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp158_, VALA_TYPE_STRUCT, ValaStruct));
			_tmp152_ = !_tmp159_;
		} else {
			_tmp152_ = FALSE;
		}
		if (_tmp152_) {
			ValaTargetValue* instance_value = NULL;
			ValaExpression* _tmp160_;
			ValaTargetValue* _tmp161_;
			ValaTargetValue* _tmp162_;
			ValaTargetValue* _tmp163_;
			ValaTargetValue* _tmp164_;
			gboolean _tmp165_;
			ValaTargetValue* _tmp169_;
			ValaCCodeExpression* _tmp170_;
			ValaCCodeExpression* _tmp171_;
			ValaCCodeUnaryExpression* _tmp172_;
			_tmp160_ = instance;
			_tmp161_ = vala_expression_get_target_value (_tmp160_);
			_tmp162_ = _tmp161_;
			_tmp163_ = _vala_target_value_ref0 (_tmp162_);
			instance_value = _tmp163_;
			_tmp164_ = instance_value;
			_tmp165_ = vala_ccode_base_module_get_lvalue (self, _tmp164_);
			if (!_tmp165_) {
				ValaTargetValue* _tmp166_;
				ValaExpression* _tmp167_;
				ValaTargetValue* _tmp168_;
				_tmp166_ = instance_value;
				_tmp167_ = instance;
				_tmp168_ = vala_ccode_base_module_store_temp_value (self, _tmp166_, (ValaCodeNode*) _tmp167_, NULL);
				_vala_target_value_unref0 (instance_value);
				instance_value = _tmp168_;
			}
			_tmp169_ = instance_value;
			_tmp170_ = vala_ccode_base_module_get_cvalue_ (self, _tmp169_);
			_tmp171_ = _tmp170_;
			_tmp172_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp171_);
			_vala_ccode_node_unref0 (cinstance);
			cinstance = (ValaCCodeExpression*) _tmp172_;
			_vala_ccode_node_unref0 (_tmp171_);
			_vala_target_value_unref0 (instance_value);
		}
		_tmp173_ = ccall;
		_tmp174_ = cinstance;
		vala_ccode_function_call_add_argument (_tmp173_, _tmp174_);
		_vala_ccode_node_unref0 (cinstance);
	}
	_tmp175_ = prop;
	_tmp176_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp175_);
	if (_tmp176_) {
		ValaCCodeFunctionCall* _tmp177_;
		ValaProperty* _tmp178_;
		ValaCCodeConstant* _tmp179_;
		ValaCCodeConstant* _tmp180_;
		_tmp177_ = ccall;
		_tmp178_ = prop;
		_tmp179_ = vala_ccode_base_module_get_property_canonical_cconstant (self, _tmp178_);
		_tmp180_ = _tmp179_;
		vala_ccode_function_call_add_argument (_tmp177_, (ValaCCodeExpression*) _tmp180_);
		_vala_ccode_node_unref0 (_tmp180_);
	}
	_tmp181_ = value;
	_tmp182_ = vala_ccode_base_module_get_cvalue_ (self, _tmp181_);
	cexpr = _tmp182_;
	_tmp183_ = prop;
	_tmp184_ = vala_property_get_property_type (_tmp183_);
	_tmp185_ = _tmp184_;
	_tmp186_ = vala_data_type_is_real_non_null_struct_type (_tmp185_);
	if (_tmp186_) {
		ValaCCodeExpression* _tmp187_;
		ValaCCodeUnaryExpression* _tmp188_;
		_tmp187_ = cexpr;
		_tmp188_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp187_);
		_vala_ccode_node_unref0 (cexpr);
		cexpr = (ValaCCodeExpression*) _tmp188_;
	}
	_tmp189_ = prop;
	_tmp190_ = vala_property_get_property_type (_tmp189_);
	_tmp191_ = _tmp190_;
	_tmp192_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp191_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp191_) : NULL);
	array_type = _tmp192_;
	_tmp193_ = ccall;
	_tmp194_ = cexpr;
	vala_ccode_function_call_add_argument (_tmp193_, _tmp194_);
	_tmp196_ = array_type;
	if (_tmp196_ != NULL) {
		ValaProperty* _tmp197_;
		gboolean _tmp198_;
		_tmp197_ = prop;
		_tmp198_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp197_);
		_tmp195_ = _tmp198_;
	} else {
		_tmp195_ = FALSE;
	}
	if (_tmp195_) {
		{
			gint dim = 0;
			dim = 1;
			{
				gboolean _tmp199_ = FALSE;
				_tmp199_ = TRUE;
				while (TRUE) {
					gint _tmp201_;
					ValaArrayType* _tmp202_;
					gint _tmp203_;
					gint _tmp204_;
					ValaCCodeFunctionCall* _tmp205_;
					ValaTargetValue* _tmp206_;
					gint _tmp207_;
					ValaCCodeExpression* _tmp208_;
					ValaCCodeExpression* _tmp209_;
					if (!_tmp199_) {
						gint _tmp200_;
						_tmp200_ = dim;
						dim = _tmp200_ + 1;
					}
					_tmp199_ = FALSE;
					_tmp201_ = dim;
					_tmp202_ = array_type;
					_tmp203_ = vala_array_type_get_rank (_tmp202_);
					_tmp204_ = _tmp203_;
					if (!(_tmp201_ <= _tmp204_)) {
						break;
					}
					_tmp205_ = ccall;
					_tmp206_ = value;
					_tmp207_ = dim;
					_tmp208_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp206_, _tmp207_);
					_tmp209_ = _tmp208_;
					vala_ccode_function_call_add_argument (_tmp205_, _tmp209_);
					_vala_ccode_node_unref0 (_tmp209_);
				}
			}
		}
	} else {
		ValaProperty* _tmp210_;
		ValaDataType* _tmp211_;
		ValaDataType* _tmp212_;
		_tmp210_ = prop;
		_tmp211_ = vala_property_get_property_type (_tmp210_);
		_tmp212_ = _tmp211_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp212_, VALA_TYPE_DELEGATE_TYPE)) {
			ValaDelegateType* delegate_type = NULL;
			ValaProperty* _tmp213_;
			ValaDataType* _tmp214_;
			ValaDataType* _tmp215_;
			ValaDelegateType* _tmp216_;
			ValaDelegateType* _tmp217_;
			ValaDelegate* _tmp218_;
			ValaDelegate* _tmp219_;
			gboolean _tmp220_;
			gboolean _tmp221_;
			_tmp213_ = prop;
			_tmp214_ = vala_property_get_property_type (_tmp213_);
			_tmp215_ = _tmp214_;
			_tmp216_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp215_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
			delegate_type = _tmp216_;
			_tmp217_ = delegate_type;
			_tmp218_ = vala_delegate_type_get_delegate_symbol (_tmp217_);
			_tmp219_ = _tmp218_;
			_tmp220_ = vala_delegate_get_has_target (_tmp219_);
			_tmp221_ = _tmp220_;
			if (_tmp221_) {
				ValaCCodeFunctionCall* _tmp222_;
				ValaTargetValue* _tmp223_;
				ValaCCodeExpression* _tmp224_;
				ValaCCodeExpression* _tmp225_;
				ValaProperty* _tmp226_;
				ValaPropertyAccessor* _tmp227_;
				ValaPropertyAccessor* _tmp228_;
				ValaDataType* _tmp229_;
				ValaDataType* _tmp230_;
				gboolean _tmp231_;
				gboolean _tmp232_;
				_tmp222_ = ccall;
				_tmp223_ = value;
				_tmp224_ = vala_ccode_base_module_get_delegate_target_cvalue (self, _tmp223_);
				_tmp225_ = _tmp224_;
				vala_ccode_function_call_add_argument (_tmp222_, _tmp225_);
				_vala_ccode_node_unref0 (_tmp225_);
				_tmp226_ = base_property;
				_tmp227_ = vala_property_get_set_accessor (_tmp226_);
				_tmp228_ = _tmp227_;
				_tmp229_ = vala_property_accessor_get_value_type (_tmp228_);
				_tmp230_ = _tmp229_;
				_tmp231_ = vala_data_type_get_value_owned (_tmp230_);
				_tmp232_ = _tmp231_;
				if (_tmp232_) {
					ValaCCodeFunctionCall* _tmp233_;
					ValaTargetValue* _tmp234_;
					ValaCCodeExpression* _tmp235_;
					ValaCCodeExpression* _tmp236_;
					_tmp233_ = ccall;
					_tmp234_ = value;
					_tmp235_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp234_);
					_tmp236_ = _tmp235_;
					vala_ccode_function_call_add_argument (_tmp233_, _tmp236_);
					_vala_ccode_node_unref0 (_tmp236_);
				}
			}
			_vala_code_node_unref0 (delegate_type);
		}
	}
	_tmp237_ = prop;
	_tmp238_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp237_);
	if (_tmp238_) {
		ValaCCodeFunctionCall* _tmp239_;
		ValaCCodeConstant* _tmp240_;
		ValaCCodeConstant* _tmp241_;
		_tmp239_ = ccall;
		_tmp240_ = vala_ccode_constant_new ("NULL");
		_tmp241_ = _tmp240_;
		vala_ccode_function_call_add_argument (_tmp239_, (ValaCCodeExpression*) _tmp241_);
		_vala_ccode_node_unref0 (_tmp241_);
	}
	_tmp242_ = vala_ccode_base_module_get_ccode (self);
	_tmp243_ = _tmp242_;
	_tmp244_ = ccall;
	vala_ccode_function_add_expression (_tmp243_, (ValaCCodeExpression*) _tmp244_);
	_vala_code_node_unref0 (array_type);
	_vala_ccode_node_unref0 (cexpr);
	_vala_ccode_node_unref0 (ccall);
	_vala_code_node_unref0 (base_property);
	_g_free0 (set_func);
}


gboolean vala_ccode_base_module_add_wrapper (ValaCCodeBaseModule* self, const gchar* wrapper_name) {
	gboolean result = FALSE;
	ValaSet* _tmp0_;
	const gchar* _tmp1_;
	gboolean _tmp2_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (wrapper_name != NULL, FALSE);
	_tmp0_ = self->wrappers;
	_tmp1_ = wrapper_name;
	_tmp2_ = vala_collection_add ((ValaCollection*) _tmp0_, _tmp1_);
	result = _tmp2_;
	return result;
}


gboolean vala_ccode_base_module_add_generated_external_symbol (ValaCCodeBaseModule* self, ValaSymbol* external_symbol) {
	gboolean result = FALSE;
	ValaSet* _tmp0_;
	ValaSymbol* _tmp1_;
	gboolean _tmp2_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (external_symbol != NULL, FALSE);
	_tmp0_ = self->priv->generated_external_symbols;
	_tmp1_ = external_symbol;
	_tmp2_ = vala_collection_add ((ValaCollection*) _tmp0_, _tmp1_);
	result = _tmp2_;
	return result;
}


ValaDataType* vala_ccode_base_module_get_data_type_for_symbol (ValaTypeSymbol* sym) {
	ValaDataType* result = NULL;
	ValaDataType* type = NULL;
	ValaTypeSymbol* _tmp0_;
	g_return_val_if_fail (sym != NULL, NULL);
	type = NULL;
	_tmp0_ = sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
		ValaTypeSymbol* _tmp1_;
		ValaObjectType* _tmp2_;
		_tmp1_ = sym;
		_tmp2_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass));
		_vala_code_node_unref0 (type);
		type = (ValaDataType*) _tmp2_;
	} else {
		ValaTypeSymbol* _tmp3_;
		_tmp3_ = sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_INTERFACE)) {
			ValaTypeSymbol* _tmp4_;
			ValaObjectType* _tmp5_;
			_tmp4_ = sym;
			_tmp5_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_INTERFACE, ValaInterface));
			_vala_code_node_unref0 (type);
			type = (ValaDataType*) _tmp5_;
		} else {
			ValaTypeSymbol* _tmp6_;
			_tmp6_ = sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_STRUCT)) {
				ValaStruct* st = NULL;
				ValaTypeSymbol* _tmp7_;
				ValaStruct* _tmp8_;
				ValaStruct* _tmp9_;
				gboolean _tmp10_;
				_tmp7_ = sym;
				_tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_STRUCT, ValaStruct));
				st = _tmp8_;
				_tmp9_ = st;
				_tmp10_ = vala_struct_is_boolean_type (_tmp9_);
				if (_tmp10_) {
					ValaStruct* _tmp11_;
					ValaBooleanType* _tmp12_;
					_tmp11_ = st;
					_tmp12_ = vala_boolean_type_new (_tmp11_);
					_vala_code_node_unref0 (type);
					type = (ValaDataType*) _tmp12_;
				} else {
					ValaStruct* _tmp13_;
					gboolean _tmp14_;
					_tmp13_ = st;
					_tmp14_ = vala_struct_is_integer_type (_tmp13_);
					if (_tmp14_) {
						ValaStruct* _tmp15_;
						ValaIntegerType* _tmp16_;
						_tmp15_ = st;
						_tmp16_ = vala_integer_type_new (_tmp15_, NULL, NULL);
						_vala_code_node_unref0 (type);
						type = (ValaDataType*) _tmp16_;
					} else {
						ValaStruct* _tmp17_;
						gboolean _tmp18_;
						_tmp17_ = st;
						_tmp18_ = vala_struct_is_floating_type (_tmp17_);
						if (_tmp18_) {
							ValaStruct* _tmp19_;
							ValaFloatingType* _tmp20_;
							_tmp19_ = st;
							_tmp20_ = vala_floating_type_new (_tmp19_);
							_vala_code_node_unref0 (type);
							type = (ValaDataType*) _tmp20_;
						} else {
							ValaStruct* _tmp21_;
							ValaStructValueType* _tmp22_;
							_tmp21_ = st;
							_tmp22_ = vala_struct_value_type_new (_tmp21_);
							_vala_code_node_unref0 (type);
							type = (ValaDataType*) _tmp22_;
						}
					}
				}
				_vala_code_node_unref0 (st);
			} else {
				ValaTypeSymbol* _tmp23_;
				_tmp23_ = sym;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_ENUM)) {
					ValaTypeSymbol* _tmp24_;
					ValaEnumValueType* _tmp25_;
					_tmp24_ = sym;
					_tmp25_ = vala_enum_value_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, VALA_TYPE_ENUM, ValaEnum));
					_vala_code_node_unref0 (type);
					type = (ValaDataType*) _tmp25_;
				} else {
					ValaTypeSymbol* _tmp26_;
					_tmp26_ = sym;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp26_, VALA_TYPE_ERROR_DOMAIN)) {
						ValaTypeSymbol* _tmp27_;
						ValaErrorType* _tmp28_;
						_tmp27_ = sym;
						_tmp28_ = vala_error_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp27_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain), NULL, NULL);
						_vala_code_node_unref0 (type);
						type = (ValaDataType*) _tmp28_;
					} else {
						ValaTypeSymbol* _tmp29_;
						_tmp29_ = sym;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_ERROR_CODE)) {
							ValaTypeSymbol* _tmp30_;
							ValaSymbol* _tmp31_;
							ValaSymbol* _tmp32_;
							ValaTypeSymbol* _tmp33_;
							ValaErrorType* _tmp34_;
							_tmp30_ = sym;
							_tmp31_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp30_);
							_tmp32_ = _tmp31_;
							_tmp33_ = sym;
							_tmp34_ = vala_error_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp32_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain), G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_ERROR_CODE, ValaErrorCode), NULL);
							_vala_code_node_unref0 (type);
							type = (ValaDataType*) _tmp34_;
						} else {
							ValaTypeSymbol* _tmp35_;
							gchar* _tmp36_;
							gchar* _tmp37_;
							gchar* _tmp38_;
							gchar* _tmp39_;
							ValaInvalidType* _tmp40_;
							_tmp35_ = sym;
							_tmp36_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp35_);
							_tmp37_ = _tmp36_;
							_tmp38_ = g_strdup_printf ("internal error: `%s' is not a supported type", _tmp37_);
							_tmp39_ = _tmp38_;
							vala_report_error (NULL, _tmp39_);
							_g_free0 (_tmp39_);
							_g_free0 (_tmp37_);
							_tmp40_ = vala_invalid_type_new ();
							result = (ValaDataType*) _tmp40_;
							_vala_code_node_unref0 (type);
							return result;
						}
					}
				}
			}
		}
	}
	result = type;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_default_value_for_type (ValaCCodeBaseModule* self, ValaDataType* type, gboolean initializer_expression) {
	ValaCCodeExpression* result = NULL;
	ValaStruct* st = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	ValaStruct* _tmp3_;
	ValaArrayType* array_type = NULL;
	ValaDataType* _tmp4_;
	ValaArrayType* _tmp5_;
	gboolean _tmp6_ = FALSE;
	gboolean _tmp7_ = FALSE;
	ValaDataType* _tmp8_;
	ValaTypeSymbol* _tmp9_;
	ValaTypeSymbol* _tmp10_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp2_) : NULL);
	st = _tmp3_;
	_tmp4_ = type;
	_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp4_) : NULL);
	array_type = _tmp5_;
	_tmp8_ = type;
	_tmp9_ = vala_data_type_get_data_type (_tmp8_);
	_tmp10_ = _tmp9_;
	if (_tmp10_ != NULL) {
		ValaDataType* _tmp11_;
		gboolean _tmp12_;
		gboolean _tmp13_;
		_tmp11_ = type;
		_tmp12_ = vala_data_type_get_nullable (_tmp11_);
		_tmp13_ = _tmp12_;
		_tmp7_ = !_tmp13_;
	} else {
		_tmp7_ = FALSE;
	}
	if (_tmp7_) {
		ValaDataType* _tmp14_;
		ValaTypeSymbol* _tmp15_;
		ValaTypeSymbol* _tmp16_;
		gchar* _tmp17_;
		gchar* _tmp18_;
		_tmp14_ = type;
		_tmp15_ = vala_data_type_get_data_type (_tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = vala_ccode_base_module_get_ccode_default_value (_tmp16_);
		_tmp18_ = _tmp17_;
		_tmp6_ = g_strcmp0 (_tmp18_, "") != 0;
		_g_free0 (_tmp18_);
	} else {
		_tmp6_ = FALSE;
	}
	if (_tmp6_) {
		ValaDataType* _tmp19_;
		ValaTypeSymbol* _tmp20_;
		ValaTypeSymbol* _tmp21_;
		gchar* _tmp22_;
		gchar* _tmp23_;
		ValaCCodeConstant* _tmp24_;
		ValaCCodeExpression* _tmp25_;
		_tmp19_ = type;
		_tmp20_ = vala_data_type_get_data_type (_tmp19_);
		_tmp21_ = _tmp20_;
		_tmp22_ = vala_ccode_base_module_get_ccode_default_value (_tmp21_);
		_tmp23_ = _tmp22_;
		_tmp24_ = vala_ccode_constant_new (_tmp23_);
		_tmp25_ = (ValaCCodeExpression*) _tmp24_;
		_g_free0 (_tmp23_);
		result = _tmp25_;
		_vala_code_node_unref0 (array_type);
		_vala_code_node_unref0 (st);
		return result;
	} else {
		gboolean _tmp26_ = FALSE;
		gboolean _tmp27_ = FALSE;
		gboolean _tmp28_;
		_tmp28_ = initializer_expression;
		if (_tmp28_) {
			ValaDataType* _tmp29_;
			gboolean _tmp30_;
			gboolean _tmp31_;
			_tmp29_ = type;
			_tmp30_ = vala_data_type_get_nullable (_tmp29_);
			_tmp31_ = _tmp30_;
			_tmp27_ = !_tmp31_;
		} else {
			_tmp27_ = FALSE;
		}
		if (_tmp27_) {
			gboolean _tmp32_ = FALSE;
			ValaStruct* _tmp33_;
			_tmp33_ = st;
			if (_tmp33_ != NULL) {
				_tmp32_ = TRUE;
			} else {
				gboolean _tmp34_ = FALSE;
				ValaArrayType* _tmp35_;
				_tmp35_ = array_type;
				if (_tmp35_ != NULL) {
					ValaArrayType* _tmp36_;
					gboolean _tmp37_;
					gboolean _tmp38_;
					_tmp36_ = array_type;
					_tmp37_ = vala_array_type_get_fixed_length (_tmp36_);
					_tmp38_ = _tmp37_;
					_tmp34_ = _tmp38_;
				} else {
					_tmp34_ = FALSE;
				}
				_tmp32_ = _tmp34_;
			}
			_tmp26_ = _tmp32_;
		} else {
			_tmp26_ = FALSE;
		}
		if (_tmp26_) {
			ValaCCodeInitializerList* clist = NULL;
			ValaCCodeInitializerList* _tmp39_;
			ValaCCodeInitializerList* _tmp40_;
			ValaCCodeConstant* _tmp41_;
			ValaCCodeConstant* _tmp42_;
			_tmp39_ = vala_ccode_initializer_list_new ();
			clist = _tmp39_;
			_tmp40_ = clist;
			_tmp41_ = vala_ccode_constant_new ("0");
			_tmp42_ = _tmp41_;
			vala_ccode_initializer_list_append (_tmp40_, (ValaCCodeExpression*) _tmp42_);
			_vala_ccode_node_unref0 (_tmp42_);
			result = (ValaCCodeExpression*) clist;
			_vala_code_node_unref0 (array_type);
			_vala_code_node_unref0 (st);
			return result;
		} else {
			gboolean _tmp43_ = FALSE;
			gboolean _tmp44_ = FALSE;
			gboolean _tmp45_ = FALSE;
			gboolean _tmp46_ = FALSE;
			gboolean _tmp47_ = FALSE;
			ValaDataType* _tmp48_;
			ValaTypeSymbol* _tmp49_;
			ValaTypeSymbol* _tmp50_;
			_tmp48_ = type;
			_tmp49_ = vala_data_type_get_data_type (_tmp48_);
			_tmp50_ = _tmp49_;
			if (_tmp50_ != NULL) {
				ValaDataType* _tmp51_;
				ValaTypeSymbol* _tmp52_;
				ValaTypeSymbol* _tmp53_;
				gboolean _tmp54_;
				_tmp51_ = type;
				_tmp52_ = vala_data_type_get_data_type (_tmp51_);
				_tmp53_ = _tmp52_;
				_tmp54_ = vala_typesymbol_is_reference_type (_tmp53_);
				_tmp47_ = _tmp54_;
			} else {
				_tmp47_ = FALSE;
			}
			if (_tmp47_) {
				_tmp46_ = TRUE;
			} else {
				ValaDataType* _tmp55_;
				gboolean _tmp56_;
				gboolean _tmp57_;
				_tmp55_ = type;
				_tmp56_ = vala_data_type_get_nullable (_tmp55_);
				_tmp57_ = _tmp56_;
				_tmp46_ = _tmp57_;
			}
			if (_tmp46_) {
				_tmp45_ = TRUE;
			} else {
				ValaDataType* _tmp58_;
				_tmp58_ = type;
				_tmp45_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp58_, VALA_TYPE_POINTER_TYPE);
			}
			if (_tmp45_) {
				_tmp44_ = TRUE;
			} else {
				ValaDataType* _tmp59_;
				_tmp59_ = type;
				_tmp44_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp59_, VALA_TYPE_DELEGATE_TYPE);
			}
			if (_tmp44_) {
				_tmp43_ = TRUE;
			} else {
				gboolean _tmp60_ = FALSE;
				ValaArrayType* _tmp61_;
				_tmp61_ = array_type;
				if (_tmp61_ != NULL) {
					ValaArrayType* _tmp62_;
					gboolean _tmp63_;
					gboolean _tmp64_;
					_tmp62_ = array_type;
					_tmp63_ = vala_array_type_get_fixed_length (_tmp62_);
					_tmp64_ = _tmp63_;
					_tmp60_ = !_tmp64_;
				} else {
					_tmp60_ = FALSE;
				}
				_tmp43_ = _tmp60_;
			}
			if (_tmp43_) {
				ValaCCodeConstant* _tmp65_;
				_tmp65_ = vala_ccode_constant_new ("NULL");
				result = (ValaCCodeExpression*) _tmp65_;
				_vala_code_node_unref0 (array_type);
				_vala_code_node_unref0 (st);
				return result;
			} else {
				ValaDataType* _tmp66_;
				ValaTypeParameter* _tmp67_;
				ValaTypeParameter* _tmp68_;
				_tmp66_ = type;
				_tmp67_ = vala_data_type_get_type_parameter (_tmp66_);
				_tmp68_ = _tmp67_;
				if (_tmp68_ != NULL) {
					ValaCCodeConstant* _tmp69_;
					_tmp69_ = vala_ccode_constant_new ("NULL");
					result = (ValaCCodeExpression*) _tmp69_;
					_vala_code_node_unref0 (array_type);
					_vala_code_node_unref0 (st);
					return result;
				} else {
					ValaDataType* _tmp70_;
					_tmp70_ = type;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp70_, VALA_TYPE_ERROR_TYPE)) {
						ValaCCodeConstant* _tmp71_;
						_tmp71_ = vala_ccode_constant_new ("NULL");
						result = (ValaCCodeExpression*) _tmp71_;
						_vala_code_node_unref0 (array_type);
						_vala_code_node_unref0 (st);
						return result;
					}
				}
			}
		}
	}
	result = NULL;
	_vala_code_node_unref0 (array_type);
	_vala_code_node_unref0 (st);
	return result;
}


static void vala_ccode_base_module_create_property_type_check_statement (ValaCCodeBaseModule* self, ValaProperty* prop, gboolean check_return_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name) {
	gboolean _tmp0_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (prop != NULL);
	g_return_if_fail (t != NULL);
	g_return_if_fail (var_name != NULL);
	_tmp0_ = check_return_type;
	if (_tmp0_) {
		ValaProperty* _tmp1_;
		ValaProperty* _tmp2_;
		ValaDataType* _tmp3_;
		ValaDataType* _tmp4_;
		ValaTypeSymbol* _tmp5_;
		gboolean _tmp6_;
		const gchar* _tmp7_;
		_tmp1_ = prop;
		_tmp2_ = prop;
		_tmp3_ = vala_property_get_property_type (_tmp2_);
		_tmp4_ = _tmp3_;
		_tmp5_ = t;
		_tmp6_ = non_null;
		_tmp7_ = var_name;
		vala_ccode_base_module_create_type_check_statement (self, (ValaCodeNode*) _tmp1_, _tmp4_, _tmp5_, _tmp6_, _tmp7_);
	} else {
		ValaProperty* _tmp8_;
		ValaVoidType* _tmp9_;
		ValaVoidType* _tmp10_;
		ValaTypeSymbol* _tmp11_;
		gboolean _tmp12_;
		const gchar* _tmp13_;
		_tmp8_ = prop;
		_tmp9_ = vala_void_type_new (NULL);
		_tmp10_ = _tmp9_;
		_tmp11_ = t;
		_tmp12_ = non_null;
		_tmp13_ = var_name;
		vala_ccode_base_module_create_type_check_statement (self, (ValaCodeNode*) _tmp8_, (ValaDataType*) _tmp10_, _tmp11_, _tmp12_, _tmp13_);
		_vala_code_node_unref0 (_tmp10_);
	}
}


static void vala_ccode_base_module_real_create_type_check_statement (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name) {
	g_return_if_fail (method_node != NULL);
	g_return_if_fail (ret_type != NULL);
	g_return_if_fail (t != NULL);
	g_return_if_fail (var_name != NULL);
}


void vala_ccode_base_module_create_type_check_statement (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->create_type_check_statement (self, method_node, ret_type, t, non_null, var_name);
}


gint vala_ccode_base_module_get_param_pos (ValaCCodeBaseModule* self, gdouble param_pos, gboolean ellipsis) {
	gint result = 0;
	gboolean _tmp0_;
	g_return_val_if_fail (self != NULL, 0);
	_tmp0_ = ellipsis;
	if (!_tmp0_) {
		gdouble _tmp1_;
		_tmp1_ = param_pos;
		if (_tmp1_ >= ((gdouble) 0)) {
			gdouble _tmp2_;
			_tmp2_ = param_pos;
			result = (gint) (_tmp2_ * 1000);
			return result;
		} else {
			gdouble _tmp3_;
			_tmp3_ = param_pos;
			result = (gint) ((100 + _tmp3_) * 1000);
			return result;
		}
	} else {
		gdouble _tmp4_;
		_tmp4_ = param_pos;
		if (_tmp4_ >= ((gdouble) 0)) {
			gdouble _tmp5_;
			_tmp5_ = param_pos;
			result = (gint) ((100 + _tmp5_) * 1000);
			return result;
		} else {
			gdouble _tmp6_;
			_tmp6_ = param_pos;
			result = (gint) ((200 + _tmp6_) * 1000);
			return result;
		}
	}
}


ValaCCodeExpression* vala_ccode_base_module_get_ccodenode (ValaCCodeBaseModule* self, ValaExpression* node) {
	ValaCCodeExpression* result = NULL;
	ValaExpression* _tmp0_;
	ValaCCodeExpression* _tmp1_;
	ValaCCodeExpression* _tmp2_;
	gboolean _tmp3_;
	ValaExpression* _tmp5_;
	ValaCCodeExpression* _tmp6_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_cvalue (self, _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _tmp2_ == NULL;
	_vala_ccode_node_unref0 (_tmp2_);
	if (_tmp3_) {
		ValaExpression* _tmp4_;
		_tmp4_ = node;
		vala_code_node_emit ((ValaCodeNode*) _tmp4_, (ValaCodeGenerator*) self);
	}
	_tmp5_ = node;
	_tmp6_ = vala_ccode_base_module_get_cvalue (self, _tmp5_);
	result = _tmp6_;
	return result;
}


gboolean vala_ccode_base_module_is_lvalue_access_allowed (ValaCCodeBaseModule* self, ValaDataType* type) {
	gboolean result = FALSE;
	ValaArrayType* array_type = NULL;
	ValaDataType* _tmp0_;
	ValaArrayType* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaArrayType* _tmp3_;
	ValaDataType* _tmp7_;
	ValaTypeSymbol* _tmp8_;
	ValaTypeSymbol* _tmp9_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (type != NULL, FALSE);
	_tmp0_ = type;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp0_) : NULL);
	array_type = _tmp1_;
	_tmp3_ = array_type;
	if (_tmp3_ != NULL) {
		ValaArrayType* _tmp4_;
		gboolean _tmp5_;
		gboolean _tmp6_;
		_tmp4_ = array_type;
		_tmp5_ = vala_array_type_get_inline_allocated (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp2_ = _tmp6_;
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		result = FALSE;
		_vala_code_node_unref0 (array_type);
		return result;
	}
	_tmp7_ = type;
	_tmp8_ = vala_data_type_get_data_type (_tmp7_);
	_tmp9_ = _tmp8_;
	if (_tmp9_ != NULL) {
		ValaDataType* _tmp10_;
		ValaTypeSymbol* _tmp11_;
		ValaTypeSymbol* _tmp12_;
		gboolean _tmp13_;
		_tmp10_ = type;
		_tmp11_ = vala_data_type_get_data_type (_tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp12_, "CCode", "lvalue_access", TRUE);
		result = _tmp13_;
		_vala_code_node_unref0 (array_type);
		return result;
	}
	result = TRUE;
	_vala_code_node_unref0 (array_type);
	return result;
}


static gpointer _vala_attribute_cache_ref0 (gpointer self) {
	return self ? vala_attribute_cache_ref (self) : NULL;
}


ValaCCodeAttribute* vala_ccode_base_module_get_ccode_attribute (ValaCodeNode* node) {
	ValaCCodeAttribute* result = NULL;
	ValaAttributeCache* attr = NULL;
	ValaCodeNode* _tmp0_;
	gint _tmp1_;
	ValaAttributeCache* _tmp2_;
	ValaAttributeCache* _tmp3_;
	ValaAttributeCache* _tmp9_;
	ValaCCodeAttribute* _tmp10_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_ccode_attribute_cache_index;
	_tmp2_ = vala_code_node_get_attribute_cache (_tmp0_, _tmp1_);
	attr = _tmp2_;
	_tmp3_ = attr;
	if (_tmp3_ == NULL) {
		ValaCodeNode* _tmp4_;
		ValaCCodeAttribute* _tmp5_;
		ValaCodeNode* _tmp6_;
		gint _tmp7_;
		ValaAttributeCache* _tmp8_;
		_tmp4_ = node;
		_tmp5_ = vala_ccode_attribute_new (_tmp4_);
		_vala_attribute_cache_unref0 (attr);
		attr = (ValaAttributeCache*) _tmp5_;
		_tmp6_ = node;
		_tmp7_ = vala_ccode_base_module_ccode_attribute_cache_index;
		_tmp8_ = attr;
		vala_code_node_set_attribute_cache (_tmp6_, _tmp7_, _tmp8_);
	}
	_tmp9_ = attr;
	_tmp10_ = _vala_attribute_cache_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_CCODE_ATTRIBUTE, ValaCCodeAttribute));
	result = _tmp10_;
	_vala_attribute_cache_unref0 (attr);
	return result;
}


gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_const_name (ValaCodeNode* node) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_const_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_type_name (ValaInterface* iface) {
	gchar* result = NULL;
	ValaInterface* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (iface != NULL, NULL);
	_tmp0_ = iface;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_type_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_lower_case_name (ValaCodeNode* node, const gchar* infix) {
	gchar* result = NULL;
	ValaSymbol* sym = NULL;
	ValaCodeNode* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_SYMBOL) ? ((ValaSymbol*) _tmp0_) : NULL);
	sym = _tmp1_;
	_tmp2_ = sym;
	if (_tmp2_ != NULL) {
		const gchar* _tmp3_;
		ValaSymbol* _tmp4_;
		_tmp3_ = infix;
		if (_tmp3_ == NULL) {
			infix = "";
		}
		_tmp4_ = sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_DELEGATE)) {
			ValaSymbol* _tmp5_;
			ValaSymbol* _tmp6_;
			ValaSymbol* _tmp7_;
			gchar* _tmp8_;
			gchar* _tmp9_;
			const gchar* _tmp10_;
			ValaSymbol* _tmp11_;
			const gchar* _tmp12_;
			const gchar* _tmp13_;
			gchar* _tmp14_;
			gchar* _tmp15_;
			gchar* _tmp16_;
			gchar* _tmp17_;
			_tmp5_ = sym;
			_tmp6_ = vala_symbol_get_parent_symbol (_tmp5_);
			_tmp7_ = _tmp6_;
			_tmp8_ = vala_ccode_base_module_get_ccode_lower_case_prefix (_tmp7_);
			_tmp9_ = _tmp8_;
			_tmp10_ = infix;
			_tmp11_ = sym;
			_tmp12_ = vala_symbol_get_name (_tmp11_);
			_tmp13_ = _tmp12_;
			_tmp14_ = vala_symbol_camel_case_to_lower_case (_tmp13_);
			_tmp15_ = _tmp14_;
			_tmp16_ = g_strdup_printf ("%s%s%s", _tmp9_, _tmp10_, _tmp15_);
			_tmp17_ = _tmp16_;
			_g_free0 (_tmp15_);
			_g_free0 (_tmp9_);
			result = _tmp17_;
			_vala_code_node_unref0 (sym);
			return result;
		} else {
			ValaSymbol* _tmp18_;
			_tmp18_ = sym;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp18_, VALA_TYPE_ERROR_CODE)) {
				ValaSymbol* _tmp19_;
				gchar* _tmp20_;
				gchar* _tmp21_;
				gchar* _tmp22_;
				gchar* _tmp23_;
				_tmp19_ = sym;
				_tmp20_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp19_);
				_tmp21_ = _tmp20_;
				_tmp22_ = g_utf8_strdown (_tmp21_, (gssize) -1);
				_tmp23_ = _tmp22_;
				_g_free0 (_tmp21_);
				result = _tmp23_;
				_vala_code_node_unref0 (sym);
				return result;
			} else {
				ValaSymbol* _tmp24_;
				ValaSymbol* _tmp25_;
				ValaSymbol* _tmp26_;
				gchar* _tmp27_;
				gchar* _tmp28_;
				const gchar* _tmp29_;
				ValaSymbol* _tmp30_;
				gchar* _tmp31_;
				gchar* _tmp32_;
				gchar* _tmp33_;
				gchar* _tmp34_;
				_tmp24_ = sym;
				_tmp25_ = vala_symbol_get_parent_symbol (_tmp24_);
				_tmp26_ = _tmp25_;
				_tmp27_ = vala_ccode_base_module_get_ccode_lower_case_prefix (_tmp26_);
				_tmp28_ = _tmp27_;
				_tmp29_ = infix;
				_tmp30_ = sym;
				_tmp31_ = vala_ccode_base_module_get_ccode_lower_case_suffix (_tmp30_);
				_tmp32_ = _tmp31_;
				_tmp33_ = g_strdup_printf ("%s%s%s", _tmp28_, _tmp29_, _tmp32_);
				_tmp34_ = _tmp33_;
				_g_free0 (_tmp32_);
				_g_free0 (_tmp28_);
				result = _tmp34_;
				_vala_code_node_unref0 (sym);
				return result;
			}
		}
	} else {
		ValaCodeNode* _tmp35_;
		_tmp35_ = node;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp35_, VALA_TYPE_ERROR_TYPE)) {
			ValaErrorType* type = NULL;
			ValaCodeNode* _tmp36_;
			ValaErrorType* _tmp37_;
			ValaErrorType* _tmp38_;
			ValaErrorDomain* _tmp39_;
			ValaErrorDomain* _tmp40_;
			_tmp36_ = node;
			_tmp37_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp36_, VALA_TYPE_ERROR_TYPE, ValaErrorType));
			type = _tmp37_;
			_tmp38_ = type;
			_tmp39_ = vala_error_type_get_error_domain (_tmp38_);
			_tmp40_ = _tmp39_;
			if (_tmp40_ == NULL) {
				const gchar* _tmp41_;
				_tmp41_ = infix;
				if (_tmp41_ == NULL) {
					gchar* _tmp42_;
					_tmp42_ = g_strdup ("g_error");
					result = _tmp42_;
					_vala_code_node_unref0 (type);
					_vala_code_node_unref0 (sym);
					return result;
				} else {
					const gchar* _tmp43_;
					gchar* _tmp44_;
					_tmp43_ = infix;
					_tmp44_ = g_strdup_printf ("g_%s_error", _tmp43_);
					result = _tmp44_;
					_vala_code_node_unref0 (type);
					_vala_code_node_unref0 (sym);
					return result;
				}
			} else {
				ValaErrorType* _tmp45_;
				ValaErrorCode* _tmp46_;
				ValaErrorCode* _tmp47_;
				_tmp45_ = type;
				_tmp46_ = vala_error_type_get_error_code (_tmp45_);
				_tmp47_ = _tmp46_;
				if (_tmp47_ == NULL) {
					ValaErrorType* _tmp48_;
					ValaErrorDomain* _tmp49_;
					ValaErrorDomain* _tmp50_;
					const gchar* _tmp51_;
					gchar* _tmp52_;
					_tmp48_ = type;
					_tmp49_ = vala_error_type_get_error_domain (_tmp48_);
					_tmp50_ = _tmp49_;
					_tmp51_ = infix;
					_tmp52_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp50_, _tmp51_);
					result = _tmp52_;
					_vala_code_node_unref0 (type);
					_vala_code_node_unref0 (sym);
					return result;
				} else {
					ValaErrorType* _tmp53_;
					ValaErrorCode* _tmp54_;
					ValaErrorCode* _tmp55_;
					const gchar* _tmp56_;
					gchar* _tmp57_;
					_tmp53_ = type;
					_tmp54_ = vala_error_type_get_error_code (_tmp53_);
					_tmp55_ = _tmp54_;
					_tmp56_ = infix;
					_tmp57_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp55_, _tmp56_);
					result = _tmp57_;
					_vala_code_node_unref0 (type);
					_vala_code_node_unref0 (sym);
					return result;
				}
			}
			_vala_code_node_unref0 (type);
		} else {
			ValaCodeNode* _tmp58_;
			_tmp58_ = node;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp58_, VALA_TYPE_DELEGATE_TYPE)) {
				ValaDelegateType* type = NULL;
				ValaCodeNode* _tmp59_;
				ValaDelegateType* _tmp60_;
				ValaDelegateType* _tmp61_;
				ValaDelegate* _tmp62_;
				ValaDelegate* _tmp63_;
				const gchar* _tmp64_;
				gchar* _tmp65_;
				_tmp59_ = node;
				_tmp60_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp59_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
				type = _tmp60_;
				_tmp61_ = type;
				_tmp62_ = vala_delegate_type_get_delegate_symbol (_tmp61_);
				_tmp63_ = _tmp62_;
				_tmp64_ = infix;
				_tmp65_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp63_, _tmp64_);
				result = _tmp65_;
				_vala_code_node_unref0 (type);
				_vala_code_node_unref0 (sym);
				return result;
			} else {
				ValaCodeNode* _tmp66_;
				_tmp66_ = node;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp66_, VALA_TYPE_POINTER_TYPE)) {
					ValaPointerType* type = NULL;
					ValaCodeNode* _tmp67_;
					ValaPointerType* _tmp68_;
					ValaPointerType* _tmp69_;
					ValaDataType* _tmp70_;
					ValaDataType* _tmp71_;
					const gchar* _tmp72_;
					gchar* _tmp73_;
					_tmp67_ = node;
					_tmp68_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp67_, VALA_TYPE_POINTER_TYPE, ValaPointerType));
					type = _tmp68_;
					_tmp69_ = type;
					_tmp70_ = vala_pointer_type_get_base_type (_tmp69_);
					_tmp71_ = _tmp70_;
					_tmp72_ = infix;
					_tmp73_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp71_, _tmp72_);
					result = _tmp73_;
					_vala_code_node_unref0 (type);
					_vala_code_node_unref0 (sym);
					return result;
				} else {
					ValaCodeNode* _tmp74_;
					_tmp74_ = node;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp74_, VALA_TYPE_GENERIC_TYPE)) {
						gchar* _tmp75_;
						_tmp75_ = g_strdup ("valageneric");
						result = _tmp75_;
						_vala_code_node_unref0 (sym);
						return result;
					} else {
						ValaCodeNode* _tmp76_;
						_tmp76_ = node;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp76_, VALA_TYPE_VOID_TYPE)) {
							gchar* _tmp77_;
							_tmp77_ = g_strdup ("valavoid");
							result = _tmp77_;
							_vala_code_node_unref0 (sym);
							return result;
						} else {
							ValaDataType* type = NULL;
							ValaCodeNode* _tmp78_;
							ValaDataType* _tmp79_;
							ValaDataType* _tmp80_;
							ValaTypeSymbol* _tmp81_;
							ValaTypeSymbol* _tmp82_;
							const gchar* _tmp83_;
							gchar* _tmp84_;
							_tmp78_ = node;
							_tmp79_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp78_, VALA_TYPE_DATA_TYPE, ValaDataType));
							type = _tmp79_;
							_tmp80_ = type;
							_tmp81_ = vala_data_type_get_data_type (_tmp80_);
							_tmp82_ = _tmp81_;
							_tmp83_ = infix;
							_tmp84_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp82_, _tmp83_);
							result = _tmp84_;
							_vala_code_node_unref0 (type);
							_vala_code_node_unref0 (sym);
							return result;
						}
					}
				}
			}
		}
	}
	_vala_code_node_unref0 (sym);
}


gchar* vala_ccode_base_module_get_ccode_upper_case_name (ValaSymbol* sym, const gchar* infix) {
	gchar* result = NULL;
	ValaSymbol* _tmp0_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_PROPERTY)) {
		ValaSymbol* _tmp1_;
		ValaSymbol* _tmp2_;
		ValaSymbol* _tmp3_;
		gchar* _tmp4_;
		gchar* _tmp5_;
		ValaSymbol* _tmp6_;
		const gchar* _tmp7_;
		const gchar* _tmp8_;
		gchar* _tmp9_;
		gchar* _tmp10_;
		gchar* _tmp11_;
		gchar* _tmp12_;
		gchar* _tmp13_;
		gchar* _tmp14_;
		_tmp1_ = sym;
		_tmp2_ = vala_symbol_get_parent_symbol (_tmp1_);
		_tmp3_ = _tmp2_;
		_tmp4_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp3_, NULL);
		_tmp5_ = _tmp4_;
		_tmp6_ = sym;
		_tmp7_ = vala_symbol_get_name (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = vala_symbol_camel_case_to_lower_case (_tmp8_);
		_tmp10_ = _tmp9_;
		_tmp11_ = g_strdup_printf ("%s_%s", _tmp5_, _tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = g_ascii_strup (_tmp12_, (gssize) -1);
		_tmp14_ = _tmp13_;
		_g_free0 (_tmp12_);
		_g_free0 (_tmp10_);
		_g_free0 (_tmp5_);
		result = _tmp14_;
		return result;
	} else {
		ValaSymbol* _tmp15_;
		const gchar* _tmp16_;
		gchar* _tmp17_;
		gchar* _tmp18_;
		gchar* _tmp19_;
		gchar* _tmp20_;
		_tmp15_ = sym;
		_tmp16_ = infix;
		_tmp17_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp15_, _tmp16_);
		_tmp18_ = _tmp17_;
		_tmp19_ = g_ascii_strup (_tmp18_, (gssize) -1);
		_tmp20_ = _tmp19_;
		_g_free0 (_tmp18_);
		result = _tmp20_;
		return result;
	}
}


gchar* vala_ccode_base_module_get_ccode_header_filenames (ValaSymbol* sym) {
	gchar* result = NULL;
	ValaSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_header_filenames (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_prefix (ValaSymbol* sym) {
	gchar* result = NULL;
	ValaSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_prefix (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_lower_case_prefix (ValaSymbol* sym) {
	gchar* result = NULL;
	ValaSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_lower_case_prefix (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_lower_case_suffix (ValaSymbol* sym) {
	gchar* result = NULL;
	ValaSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_lower_case_suffix (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_ref_function (ValaTypeSymbol* sym) {
	gchar* result = NULL;
	ValaTypeSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_ref_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_quark_name (ValaErrorDomain* edomain) {
	gchar* result = NULL;
	ValaErrorDomain* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	g_return_val_if_fail (edomain != NULL, NULL);
	_tmp0_ = edomain;
	_tmp1_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp0_, NULL);
	_tmp2_ = _tmp1_;
	_tmp3_ = g_strconcat (_tmp2_, "-quark", NULL);
	_tmp4_ = _tmp3_;
	_g_free0 (_tmp2_);
	result = _tmp4_;
	return result;
}


gboolean vala_ccode_base_module_is_reference_counting (ValaTypeSymbol* sym) {
	gboolean result = FALSE;
	ValaTypeSymbol* _tmp0_;
	g_return_val_if_fail (sym != NULL, FALSE);
	_tmp0_ = sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
		ValaTypeSymbol* _tmp1_;
		gchar* _tmp2_;
		gchar* _tmp3_;
		gboolean _tmp4_;
		_tmp1_ = sym;
		_tmp2_ = vala_ccode_base_module_get_ccode_ref_function (_tmp1_);
		_tmp3_ = _tmp2_;
		_tmp4_ = _tmp3_ != NULL;
		_g_free0 (_tmp3_);
		result = _tmp4_;
		return result;
	} else {
		ValaTypeSymbol* _tmp5_;
		_tmp5_ = sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_INTERFACE)) {
			result = TRUE;
			return result;
		} else {
			result = FALSE;
			return result;
		}
	}
}


gboolean vala_ccode_base_module_get_ccode_ref_function_void (ValaClass* cl) {
	gboolean result = FALSE;
	ValaClass* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	g_return_val_if_fail (cl != NULL, FALSE);
	_tmp0_ = cl;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_ref_function_void (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _tmp4_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp5_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_free_function_address_of (ValaClass* cl) {
	gboolean result = FALSE;
	ValaClass* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	g_return_val_if_fail (cl != NULL, FALSE);
	_tmp0_ = cl;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_free_function_address_of (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _tmp4_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp5_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_unref_function (ValaObjectTypeSymbol* sym) {
	gchar* result = NULL;
	ValaObjectTypeSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_unref_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_ref_sink_function (ValaObjectTypeSymbol* sym) {
	gchar* result = NULL;
	ValaObjectTypeSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_ref_sink_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_copy_function (ValaTypeSymbol* sym) {
	gchar* result = NULL;
	ValaTypeSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_copy_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_destroy_function (ValaTypeSymbol* sym) {
	gchar* result = NULL;
	ValaTypeSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_destroy_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_dup_function (ValaTypeSymbol* sym) {
	gchar* result = NULL;
	ValaTypeSymbol* _tmp0_;
	ValaTypeSymbol* _tmp9_;
	gchar* _tmp10_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_STRUCT)) {
		ValaTypeSymbol* _tmp1_;
		gboolean _tmp2_;
		gboolean _tmp3_;
		_tmp1_ = sym;
		_tmp2_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp1_);
		_tmp3_ = _tmp2_;
		if (_tmp3_) {
			result = NULL;
			return result;
		} else {
			ValaTypeSymbol* _tmp4_;
			gchar* _tmp5_;
			gchar* _tmp6_;
			gchar* _tmp7_;
			gchar* _tmp8_;
			_tmp4_ = sym;
			_tmp5_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp4_);
			_tmp6_ = _tmp5_;
			_tmp7_ = g_strconcat (_tmp6_, "dup", NULL);
			_tmp8_ = _tmp7_;
			_g_free0 (_tmp6_);
			result = _tmp8_;
			return result;
		}
	}
	_tmp9_ = sym;
	_tmp10_ = vala_ccode_base_module_get_ccode_copy_function (_tmp9_);
	result = _tmp10_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_free_function (ValaTypeSymbol* sym) {
	gchar* result = NULL;
	ValaTypeSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_free_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_is_gboxed (ValaTypeSymbol* sym) {
	gboolean result = FALSE;
	ValaTypeSymbol* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gboolean _tmp3_;
	g_return_val_if_fail (sym != NULL, FALSE);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_free_function (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = g_strcmp0 (_tmp2_, "g_boxed_free") == 0;
	_g_free0 (_tmp2_);
	result = _tmp3_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_finish_instance (ValaCodeNode* node) {
	gboolean result = FALSE;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	g_return_val_if_fail (node != NULL, FALSE);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_finish_instance (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _tmp4_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp5_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_type_id (ValaCodeNode* node) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_type_id (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_marshaller_type_name (ValaCodeNode* node) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_marshaller_type_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_get_value_function (ValaCodeNode* sym) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_get_value_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_set_value_function (ValaCodeNode* sym) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_set_value_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_take_value_function (ValaCodeNode* sym) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_take_value_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_param_spec_function (ValaCodeNode* sym) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_param_spec_function (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_type_check_function (ValaTypeSymbol* sym) {
	gchar* result = NULL;
	ValaClass* cl = NULL;
	ValaTypeSymbol* _tmp0_;
	ValaClass* _tmp1_;
	gchar* a = NULL;
	ValaTypeSymbol* _tmp2_;
	gchar* _tmp3_;
	gboolean _tmp4_ = FALSE;
	ValaClass* _tmp5_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp0_) : NULL);
	cl = _tmp1_;
	_tmp2_ = sym;
	_tmp3_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp2_, "CCode", "type_check_function", NULL);
	a = _tmp3_;
	_tmp5_ = cl;
	if (_tmp5_ != NULL) {
		const gchar* _tmp6_;
		_tmp6_ = a;
		_tmp4_ = _tmp6_ != NULL;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		result = a;
		_vala_code_node_unref0 (cl);
		return result;
	} else {
		gboolean _tmp7_ = FALSE;
		gboolean _tmp8_ = FALSE;
		gboolean _tmp9_ = FALSE;
		gboolean _tmp10_ = FALSE;
		ValaClass* _tmp11_;
		_tmp11_ = cl;
		if (_tmp11_ != NULL) {
			ValaClass* _tmp12_;
			gboolean _tmp13_;
			gboolean _tmp14_;
			_tmp12_ = cl;
			_tmp13_ = vala_class_get_is_compact (_tmp12_);
			_tmp14_ = _tmp13_;
			_tmp10_ = _tmp14_;
		} else {
			_tmp10_ = FALSE;
		}
		if (_tmp10_) {
			_tmp9_ = TRUE;
		} else {
			ValaTypeSymbol* _tmp15_;
			_tmp15_ = sym;
			_tmp9_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_STRUCT);
		}
		if (_tmp9_) {
			_tmp8_ = TRUE;
		} else {
			ValaTypeSymbol* _tmp16_;
			_tmp16_ = sym;
			_tmp8_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_ENUM);
		}
		if (_tmp8_) {
			_tmp7_ = TRUE;
		} else {
			ValaTypeSymbol* _tmp17_;
			_tmp17_ = sym;
			_tmp7_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_DELEGATE);
		}
		if (_tmp7_) {
			gchar* _tmp18_;
			_tmp18_ = g_strdup ("");
			result = _tmp18_;
			_g_free0 (a);
			_vala_code_node_unref0 (cl);
			return result;
		} else {
			ValaTypeSymbol* _tmp19_;
			gchar* _tmp20_;
			_tmp19_ = sym;
			_tmp20_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp19_, "IS_");
			result = _tmp20_;
			_g_free0 (a);
			_vala_code_node_unref0 (cl);
			return result;
		}
	}
	_g_free0 (a);
	_vala_code_node_unref0 (cl);
}


gchar* vala_ccode_base_module_get_ccode_default_value (ValaTypeSymbol* sym) {
	gchar* result = NULL;
	ValaTypeSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_default_value (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_has_copy_function (ValaStruct* st) {
	gboolean result = FALSE;
	ValaStruct* _tmp0_;
	gboolean _tmp1_;
	g_return_val_if_fail (st != NULL, FALSE);
	_tmp0_ = st;
	_tmp1_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp0_, "CCode", "has_copy_function", TRUE);
	result = _tmp1_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_has_destroy_function (ValaStruct* st) {
	gboolean result = FALSE;
	ValaStruct* _tmp0_;
	gboolean _tmp1_;
	g_return_val_if_fail (st != NULL, FALSE);
	_tmp0_ = st;
	_tmp1_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp0_, "CCode", "has_destroy_function", TRUE);
	result = _tmp1_;
	return result;
}


gdouble vala_ccode_base_module_get_ccode_instance_pos (ValaCodeNode* node) {
	gdouble result = 0.0;
	ValaCodeNode* _tmp0_;
	g_return_val_if_fail (node != NULL, 0.0);
	_tmp0_ = node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_DELEGATE)) {
		ValaCodeNode* _tmp1_;
		gdouble _tmp2_;
		_tmp1_ = node;
		_tmp2_ = vala_code_node_get_attribute_double (_tmp1_, "CCode", "instance_pos", (gdouble) -2);
		result = _tmp2_;
		return result;
	} else {
		ValaCodeNode* _tmp3_;
		gdouble _tmp4_;
		_tmp3_ = node;
		_tmp4_ = vala_code_node_get_attribute_double (_tmp3_, "CCode", "instance_pos", (gdouble) 0);
		result = _tmp4_;
		return result;
	}
}


gboolean vala_ccode_base_module_get_ccode_array_length (ValaCodeNode* node) {
	gboolean result = FALSE;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	g_return_val_if_fail (node != NULL, FALSE);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_array_length (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _tmp4_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp5_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_array_length_type (ValaCodeNode* node) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_array_length_type (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_array_null_terminated (ValaCodeNode* node) {
	gboolean result = FALSE;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	g_return_val_if_fail (node != NULL, FALSE);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_array_null_terminated (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _tmp4_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp5_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_array_length_name (ValaCodeNode* node) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_array_length_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_array_length_expr (ValaCodeNode* node) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_array_length_expr (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gdouble vala_ccode_base_module_get_ccode_array_length_pos (ValaCodeNode* node) {
	gdouble result = 0.0;
	ValaAttribute* a = NULL;
	ValaCodeNode* _tmp0_;
	ValaAttribute* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaAttribute* _tmp3_;
	ValaCodeNode* _tmp8_;
	g_return_val_if_fail (node != NULL, 0.0);
	_tmp0_ = node;
	_tmp1_ = vala_code_node_get_attribute (_tmp0_, "CCode");
	a = _tmp1_;
	_tmp3_ = a;
	if (_tmp3_ != NULL) {
		ValaAttribute* _tmp4_;
		gboolean _tmp5_;
		_tmp4_ = a;
		_tmp5_ = vala_attribute_has_argument (_tmp4_, "array_length_pos");
		_tmp2_ = _tmp5_;
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		ValaAttribute* _tmp6_;
		gdouble _tmp7_;
		_tmp6_ = a;
		_tmp7_ = vala_attribute_get_double (_tmp6_, "array_length_pos", (gdouble) 0);
		result = _tmp7_;
		_vala_code_node_unref0 (a);
		return result;
	}
	_tmp8_ = node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_PARAMETER)) {
		ValaParameter* param = NULL;
		ValaCodeNode* _tmp9_;
		ValaParameter* _tmp10_;
		ValaParameter* _tmp11_;
		gdouble _tmp12_;
		_tmp9_ = node;
		_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_PARAMETER, ValaParameter));
		param = _tmp10_;
		_tmp11_ = param;
		_tmp12_ = vala_ccode_base_module_get_ccode_pos (_tmp11_);
		result = _tmp12_ + 0.1;
		_vala_code_node_unref0 (param);
		_vala_code_node_unref0 (a);
		return result;
	} else {
		result = (gdouble) -3;
		_vala_code_node_unref0 (a);
		return result;
	}
	_vala_code_node_unref0 (a);
}


gdouble vala_ccode_base_module_get_ccode_delegate_target_pos (ValaCodeNode* node) {
	gdouble result = 0.0;
	ValaAttribute* a = NULL;
	ValaCodeNode* _tmp0_;
	ValaAttribute* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaAttribute* _tmp3_;
	ValaCodeNode* _tmp8_;
	g_return_val_if_fail (node != NULL, 0.0);
	_tmp0_ = node;
	_tmp1_ = vala_code_node_get_attribute (_tmp0_, "CCode");
	a = _tmp1_;
	_tmp3_ = a;
	if (_tmp3_ != NULL) {
		ValaAttribute* _tmp4_;
		gboolean _tmp5_;
		_tmp4_ = a;
		_tmp5_ = vala_attribute_has_argument (_tmp4_, "delegate_target_pos");
		_tmp2_ = _tmp5_;
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		ValaAttribute* _tmp6_;
		gdouble _tmp7_;
		_tmp6_ = a;
		_tmp7_ = vala_attribute_get_double (_tmp6_, "delegate_target_pos", (gdouble) 0);
		result = _tmp7_;
		_vala_code_node_unref0 (a);
		return result;
	}
	_tmp8_ = node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_PARAMETER)) {
		ValaParameter* param = NULL;
		ValaCodeNode* _tmp9_;
		ValaParameter* _tmp10_;
		ValaParameter* _tmp11_;
		gdouble _tmp12_;
		_tmp9_ = node;
		_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_PARAMETER, ValaParameter));
		param = _tmp10_;
		_tmp11_ = param;
		_tmp12_ = vala_ccode_base_module_get_ccode_pos (_tmp11_);
		result = _tmp12_ + 0.1;
		_vala_code_node_unref0 (param);
		_vala_code_node_unref0 (a);
		return result;
	} else {
		result = (gdouble) -3;
		_vala_code_node_unref0 (a);
		return result;
	}
	_vala_code_node_unref0 (a);
}


gdouble vala_ccode_base_module_get_ccode_destroy_notify_pos (ValaCodeNode* node) {
	gdouble result = 0.0;
	ValaAttribute* a = NULL;
	ValaCodeNode* _tmp0_;
	ValaAttribute* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaAttribute* _tmp3_;
	ValaCodeNode* _tmp8_;
	g_return_val_if_fail (node != NULL, 0.0);
	_tmp0_ = node;
	_tmp1_ = vala_code_node_get_attribute (_tmp0_, "CCode");
	a = _tmp1_;
	_tmp3_ = a;
	if (_tmp3_ != NULL) {
		ValaAttribute* _tmp4_;
		gboolean _tmp5_;
		_tmp4_ = a;
		_tmp5_ = vala_attribute_has_argument (_tmp4_, "destroy_notify_pos");
		_tmp2_ = _tmp5_;
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		ValaAttribute* _tmp6_;
		gdouble _tmp7_;
		_tmp6_ = a;
		_tmp7_ = vala_attribute_get_double (_tmp6_, "destroy_notify_pos", (gdouble) 0);
		result = _tmp7_;
		_vala_code_node_unref0 (a);
		return result;
	}
	_tmp8_ = node;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_PARAMETER)) {
		ValaParameter* param = NULL;
		ValaCodeNode* _tmp9_;
		ValaParameter* _tmp10_;
		ValaParameter* _tmp11_;
		gdouble _tmp12_;
		_tmp9_ = node;
		_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_PARAMETER, ValaParameter));
		param = _tmp10_;
		_tmp11_ = param;
		_tmp12_ = vala_ccode_base_module_get_ccode_pos (_tmp11_);
		result = _tmp12_ + 0.1;
		_vala_code_node_unref0 (param);
		_vala_code_node_unref0 (a);
		return result;
	} else {
		result = (gdouble) -3;
		_vala_code_node_unref0 (a);
		return result;
	}
	_vala_code_node_unref0 (a);
}


gboolean vala_ccode_base_module_get_ccode_delegate_target (ValaCodeNode* node) {
	gboolean result = FALSE;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	g_return_val_if_fail (node != NULL, FALSE);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_delegate_target (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _tmp4_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp5_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_delegate_target_name (ValaVariable* variable) {
	gchar* result = NULL;
	ValaVariable* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (variable != NULL, NULL);
	_tmp0_ = variable;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_delegate_target_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gdouble vala_ccode_base_module_get_ccode_pos (ValaParameter* param) {
	gdouble result = 0.0;
	ValaParameter* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	gdouble _tmp3_;
	gdouble _tmp4_;
	gdouble _tmp5_;
	g_return_val_if_fail (param != NULL, 0.0);
	_tmp0_ = param;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_pos (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = _tmp4_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp5_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_type (ValaCodeNode* node) {
	gchar* result = NULL;
	ValaCodeNode* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_ctype (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_simple_generics (ValaMethod* m) {
	gboolean result = FALSE;
	ValaMethod* _tmp0_;
	gboolean _tmp1_;
	g_return_val_if_fail (m != NULL, FALSE);
	_tmp0_ = m;
	_tmp1_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp0_, "CCode", "simple_generics", FALSE);
	result = _tmp1_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_real_name (ValaSymbol* sym) {
	gchar* result = NULL;
	ValaSymbol* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (sym != NULL, NULL);
	_tmp0_ = sym;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_real_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_constructv_name (ValaCreationMethod* m) {
	gchar* result = NULL;
	static const char infix[] = "constructv";
	ValaClass* parent = NULL;
	ValaCreationMethod* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaClass* _tmp3_;
	ValaCreationMethod* _tmp4_;
	const gchar* _tmp5_;
	const gchar* _tmp6_;
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp2_) : NULL);
	parent = _tmp3_;
	_tmp4_ = m;
	_tmp5_ = vala_symbol_get_name ((ValaSymbol*) _tmp4_);
	_tmp6_ = _tmp5_;
	if (g_strcmp0 (_tmp6_, ".new") == 0) {
		ValaClass* _tmp7_;
		gchar* _tmp8_;
		gchar* _tmp9_;
		gchar* _tmp10_;
		gchar* _tmp11_;
		_tmp7_ = parent;
		_tmp8_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = g_strdup_printf ("%s%s", _tmp9_, infix);
		_tmp11_ = _tmp10_;
		_g_free0 (_tmp9_);
		result = _tmp11_;
		_vala_code_node_unref0 (parent);
		return result;
	} else {
		ValaClass* _tmp12_;
		gchar* _tmp13_;
		gchar* _tmp14_;
		ValaCreationMethod* _tmp15_;
		const gchar* _tmp16_;
		const gchar* _tmp17_;
		gchar* _tmp18_;
		gchar* _tmp19_;
		_tmp12_ = parent;
		_tmp13_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp12_);
		_tmp14_ = _tmp13_;
		_tmp15_ = m;
		_tmp16_ = vala_symbol_get_name ((ValaSymbol*) _tmp15_);
		_tmp17_ = _tmp16_;
		_tmp18_ = g_strdup_printf ("%s%s_%s", _tmp14_, infix, _tmp17_);
		_tmp19_ = _tmp18_;
		_g_free0 (_tmp14_);
		result = _tmp19_;
		_vala_code_node_unref0 (parent);
		return result;
	}
	_vala_code_node_unref0 (parent);
}


gchar* vala_ccode_base_module_get_ccode_vfunc_name (ValaMethod* m) {
	gchar* result = NULL;
	ValaMethod* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_vfunc_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_finish_name (ValaMethod* m) {
	gchar* result = NULL;
	ValaMethod* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_finish_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_finish_vfunc_name (ValaMethod* m) {
	gchar* result = NULL;
	ValaMethod* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_finish_vfunc_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_finish_real_name (ValaMethod* m) {
	gchar* result = NULL;
	ValaMethod* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_finish_real_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_no_accessor_method (ValaProperty* p) {
	gboolean result = FALSE;
	ValaProperty* _tmp0_;
	ValaAttribute* _tmp1_;
	ValaAttribute* _tmp2_;
	gboolean _tmp3_;
	g_return_val_if_fail (p != NULL, FALSE);
	_tmp0_ = p;
	_tmp1_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp0_, "NoAccessorMethod");
	_tmp2_ = _tmp1_;
	_tmp3_ = _tmp2_ != NULL;
	_vala_code_node_unref0 (_tmp2_);
	result = _tmp3_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_concrete_accessor (ValaProperty* p) {
	gboolean result = FALSE;
	ValaProperty* _tmp0_;
	ValaAttribute* _tmp1_;
	ValaAttribute* _tmp2_;
	gboolean _tmp3_;
	g_return_val_if_fail (p != NULL, FALSE);
	_tmp0_ = p;
	_tmp1_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp0_, "ConcreteAccessor");
	_tmp2_ = _tmp1_;
	_tmp3_ = _tmp2_ != NULL;
	_vala_code_node_unref0 (_tmp2_);
	result = _tmp3_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_has_type_id (ValaTypeSymbol* sym) {
	gboolean result = FALSE;
	ValaTypeSymbol* _tmp0_;
	gboolean _tmp1_;
	g_return_val_if_fail (sym != NULL, FALSE);
	_tmp0_ = sym;
	_tmp1_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp0_, "CCode", "has_type_id", TRUE);
	result = _tmp1_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_has_new_function (ValaMethod* m) {
	gboolean result = FALSE;
	ValaMethod* _tmp0_;
	gboolean _tmp1_;
	g_return_val_if_fail (m != NULL, FALSE);
	_tmp0_ = m;
	_tmp1_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp0_, "CCode", "has_new_function", TRUE);
	result = _tmp1_;
	return result;
}


gboolean vala_ccode_base_module_get_ccode_has_generic_type_parameter (ValaMethod* m) {
	gboolean result = FALSE;
	ValaAttribute* a = NULL;
	ValaMethod* _tmp0_;
	ValaAttribute* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaAttribute* _tmp3_;
	g_return_val_if_fail (m != NULL, FALSE);
	_tmp0_ = m;
	_tmp1_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp0_, "CCode");
	a = _tmp1_;
	_tmp3_ = a;
	if (_tmp3_ != NULL) {
		ValaAttribute* _tmp4_;
		gboolean _tmp5_;
		_tmp4_ = a;
		_tmp5_ = vala_attribute_has_argument (_tmp4_, "generic_type_pos");
		_tmp2_ = _tmp5_;
	} else {
		_tmp2_ = FALSE;
	}
	result = _tmp2_;
	_vala_code_node_unref0 (a);
	return result;
}


gdouble vala_ccode_base_module_get_ccode_generic_type_pos (ValaMethod* m) {
	gdouble result = 0.0;
	ValaMethod* _tmp0_;
	gdouble _tmp1_;
	g_return_val_if_fail (m != NULL, 0.0);
	_tmp0_ = m;
	_tmp1_ = vala_code_node_get_attribute_double ((ValaCodeNode*) _tmp0_, "CCode", "generic_type_pos", (gdouble) 0);
	result = _tmp1_;
	return result;
}


gchar* vala_ccode_base_module_get_ccode_sentinel (ValaMethod* m) {
	gchar* result = NULL;
	ValaMethod* _tmp0_;
	ValaCCodeAttribute* _tmp1_;
	ValaCCodeAttribute* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = m;
	_tmp1_ = vala_ccode_base_module_get_ccode_attribute ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_attribute_get_sentinel (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_attribute_cache_unref0 (_tmp2_);
	result = _tmp6_;
	return result;
}


ValaCCodeDeclaratorSuffix* vala_ccode_base_module_get_ccode_declarator_suffix (ValaCCodeBaseModule* self, ValaDataType* type) {
	ValaCCodeDeclaratorSuffix* result = NULL;
	ValaArrayType* array_type = NULL;
	ValaDataType* _tmp0_;
	ValaArrayType* _tmp1_;
	ValaArrayType* _tmp2_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = type;
	_tmp1_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp0_) : NULL);
	array_type = _tmp1_;
	_tmp2_ = array_type;
	if (_tmp2_ != NULL) {
		ValaArrayType* _tmp3_;
		gboolean _tmp4_;
		gboolean _tmp5_;
		_tmp3_ = array_type;
		_tmp4_ = vala_array_type_get_fixed_length (_tmp3_);
		_tmp5_ = _tmp4_;
		if (_tmp5_) {
			ValaArrayType* _tmp6_;
			ValaExpression* _tmp7_;
			ValaExpression* _tmp8_;
			ValaCCodeExpression* _tmp9_;
			ValaCCodeExpression* _tmp10_;
			ValaCCodeDeclaratorSuffix* _tmp11_;
			ValaCCodeDeclaratorSuffix* _tmp12_;
			_tmp6_ = array_type;
			_tmp7_ = vala_array_type_get_length (_tmp6_);
			_tmp8_ = _tmp7_;
			_tmp9_ = vala_ccode_base_module_get_ccodenode (self, _tmp8_);
			_tmp10_ = _tmp9_;
			_tmp11_ = vala_ccode_declarator_suffix_new_with_array (_tmp10_);
			_tmp12_ = _tmp11_;
			_vala_ccode_node_unref0 (_tmp10_);
			result = _tmp12_;
			_vala_code_node_unref0 (array_type);
			return result;
		} else {
			ValaArrayType* _tmp13_;
			gboolean _tmp14_;
			gboolean _tmp15_;
			_tmp13_ = array_type;
			_tmp14_ = vala_array_type_get_inline_allocated (_tmp13_);
			_tmp15_ = _tmp14_;
			if (_tmp15_) {
				ValaCCodeDeclaratorSuffix* _tmp16_;
				_tmp16_ = vala_ccode_declarator_suffix_new_with_array (NULL);
				result = _tmp16_;
				_vala_code_node_unref0 (array_type);
				return result;
			}
		}
	}
	result = NULL;
	_vala_code_node_unref0 (array_type);
	return result;
}


ValaCCodeConstant* vala_ccode_base_module_get_signal_canonical_constant (ValaCCodeBaseModule* self, ValaSignal* sig, const gchar* detail) {
	ValaCCodeConstant* result = NULL;
	gchar* _tmp0_ = NULL;
	const gchar* _tmp1_;
	ValaSignal* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	ValaCCodeConstant* _tmp12_;
	ValaCCodeConstant* _tmp13_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (sig != NULL, NULL);
	_tmp1_ = detail;
	if (_tmp1_ != NULL) {
		const gchar* _tmp2_;
		gchar* _tmp3_;
		_tmp2_ = detail;
		_tmp3_ = g_strdup_printf ("::%s", _tmp2_);
		_g_free0 (_tmp0_);
		_tmp0_ = _tmp3_;
	} else {
		gchar* _tmp4_;
		_tmp4_ = g_strdup ("");
		_g_free0 (_tmp0_);
		_tmp0_ = _tmp4_;
	}
	_tmp5_ = sig;
	_tmp6_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = string_replace (_tmp7_, "_", "-");
	_tmp9_ = _tmp8_;
	_tmp10_ = g_strdup_printf ("\"%s%s\"", _tmp9_, _tmp0_);
	_tmp11_ = _tmp10_;
	_tmp12_ = vala_ccode_constant_new (_tmp11_);
	_tmp13_ = _tmp12_;
	_g_free0 (_tmp11_);
	_g_free0 (_tmp9_);
	_g_free0 (_tmp7_);
	result = _tmp13_;
	_g_free0 (_tmp0_);
	return result;
}


ValaCCodeConstant* vala_ccode_base_module_get_enum_value_canonical_cconstant (ValaEnumValue* ev) {
	ValaCCodeConstant* result = NULL;
	ValaEnumValue* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	ValaCCodeConstant* _tmp9_;
	ValaCCodeConstant* _tmp10_;
	g_return_val_if_fail (ev != NULL, NULL);
	_tmp0_ = ev;
	_tmp1_ = vala_symbol_get_name ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = g_utf8_strdown (_tmp2_, (gssize) -1);
	_tmp4_ = _tmp3_;
	_tmp5_ = string_replace (_tmp4_, "_", "-");
	_tmp6_ = _tmp5_;
	_tmp7_ = g_strdup_printf ("\"%s\"", _tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = vala_ccode_constant_new (_tmp8_);
	_tmp10_ = _tmp9_;
	_g_free0 (_tmp8_);
	_g_free0 (_tmp6_);
	_g_free0 (_tmp4_);
	result = _tmp10_;
	return result;
}


gboolean vala_ccode_base_module_get_signal_has_emitter (ValaCCodeBaseModule* self, ValaSignal* sig) {
	gboolean result = FALSE;
	ValaSignal* _tmp0_;
	ValaAttribute* _tmp1_;
	ValaAttribute* _tmp2_;
	gboolean _tmp3_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (sig != NULL, FALSE);
	_tmp0_ = sig;
	_tmp1_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp0_, "HasEmitter");
	_tmp2_ = _tmp1_;
	_tmp3_ = _tmp2_ != NULL;
	_vala_code_node_unref0 (_tmp2_);
	result = _tmp3_;
	return result;
}


ValaCCodeConstant* vala_ccode_base_module_get_property_canonical_cconstant (ValaCCodeBaseModule* self, ValaProperty* prop) {
	ValaCCodeConstant* result = NULL;
	ValaProperty* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	ValaCCodeConstant* _tmp7_;
	ValaCCodeConstant* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (prop != NULL, NULL);
	_tmp0_ = prop;
	_tmp1_ = vala_symbol_get_name ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = string_replace (_tmp2_, "_", "-");
	_tmp4_ = _tmp3_;
	_tmp5_ = g_strdup_printf ("\"%s\"", _tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = vala_ccode_constant_new (_tmp6_);
	_tmp8_ = _tmp7_;
	_g_free0 (_tmp6_);
	_g_free0 (_tmp4_);
	result = _tmp8_;
	return result;
}


static void vala_ccode_base_module_real_visit_class (ValaCodeVisitor* base, ValaClass* cl) {
	ValaCCodeBaseModule * self;
	self = (ValaCCodeBaseModule*) base;
	g_return_if_fail (cl != NULL);
}


void vala_ccode_base_module_create_postcondition_statement (ValaCCodeBaseModule* self, ValaExpression* postcondition) {
	ValaCCodeFunctionCall* cassert = NULL;
	ValaCCodeIdentifier* _tmp0_;
	ValaCCodeIdentifier* _tmp1_;
	ValaCCodeFunctionCall* _tmp2_;
	ValaCCodeFunctionCall* _tmp3_;
	ValaExpression* _tmp4_;
	gchar* message = NULL;
	ValaExpression* _tmp5_;
	ValaSourceReference* _tmp6_;
	ValaSourceReference* _tmp7_;
	ValaSourceLocation _tmp8_ = {0};
	ValaSourceLocation _tmp9_;
	gchar* _tmp10_;
	ValaExpression* _tmp11_;
	ValaSourceReference* _tmp12_;
	ValaSourceReference* _tmp13_;
	ValaSourceLocation _tmp14_ = {0};
	ValaSourceLocation _tmp15_;
	gchar* _tmp16_;
	ValaExpression* _tmp17_;
	ValaSourceReference* _tmp18_;
	ValaSourceReference* _tmp19_;
	ValaSourceLocation _tmp20_ = {0};
	ValaSourceLocation _tmp21_;
	gchar* _tmp22_;
	gchar* _tmp23_;
	ValaExpression* _tmp24_;
	ValaCCodeExpression* _tmp25_;
	ValaCCodeExpression* _tmp26_;
	gchar* _tmp27_;
	gchar* _tmp28_;
	gchar* _tmp29_;
	gchar* _tmp30_;
	gchar* _tmp31_;
	gchar* _tmp32_;
	ValaCCodeConstant* _tmp33_;
	ValaCCodeConstant* _tmp34_;
	ValaCCodeFunction* _tmp35_;
	ValaCCodeFunction* _tmp36_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (postcondition != NULL);
	_tmp0_ = vala_ccode_identifier_new ("_vala_warn_if_fail");
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1_);
	_tmp3_ = _tmp2_;
	_vala_ccode_node_unref0 (_tmp1_);
	cassert = _tmp3_;
	_tmp4_ = postcondition;
	vala_code_node_emit ((ValaCodeNode*) _tmp4_, (ValaCodeGenerator*) self);
	_tmp5_ = postcondition;
	_tmp6_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp5_);
	_tmp7_ = _tmp6_;
	vala_source_reference_get_begin (_tmp7_, &_tmp8_);
	_tmp9_ = _tmp8_;
	_tmp10_ = _tmp9_.pos;
	_tmp11_ = postcondition;
	_tmp12_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp11_);
	_tmp13_ = _tmp12_;
	vala_source_reference_get_end (_tmp13_, &_tmp14_);
	_tmp15_ = _tmp14_;
	_tmp16_ = _tmp15_.pos;
	_tmp17_ = postcondition;
	_tmp18_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp17_);
	_tmp19_ = _tmp18_;
	vala_source_reference_get_begin (_tmp19_, &_tmp20_);
	_tmp21_ = _tmp20_;
	_tmp22_ = _tmp21_.pos;
	_tmp23_ = string_substring ((const gchar*) _tmp10_, (glong) 0, (glong) ((gint) (_tmp16_ - _tmp22_)));
	message = _tmp23_;
	_tmp24_ = postcondition;
	_tmp25_ = vala_ccode_base_module_get_cvalue (self, _tmp24_);
	_tmp26_ = _tmp25_;
	vala_ccode_function_call_add_argument (cassert, _tmp26_);
	_vala_ccode_node_unref0 (_tmp26_);
	_tmp27_ = string_replace (message, "\n", " ");
	_tmp28_ = _tmp27_;
	_tmp29_ = g_strescape (_tmp28_, "");
	_tmp30_ = _tmp29_;
	_tmp31_ = g_strdup_printf ("\"%s\"", _tmp30_);
	_tmp32_ = _tmp31_;
	_tmp33_ = vala_ccode_constant_new (_tmp32_);
	_tmp34_ = _tmp33_;
	vala_ccode_function_call_add_argument (cassert, (ValaCCodeExpression*) _tmp34_);
	_vala_ccode_node_unref0 (_tmp34_);
	_g_free0 (_tmp32_);
	_g_free0 (_tmp30_);
	_g_free0 (_tmp28_);
	self->requires_assert = TRUE;
	_tmp35_ = vala_ccode_base_module_get_ccode (self);
	_tmp36_ = _tmp35_;
	vala_ccode_function_add_expression (_tmp36_, (ValaCCodeExpression*) cassert);
	_g_free0 (message);
	_vala_ccode_node_unref0 (cassert);
}


static gboolean vala_ccode_base_module_real_is_gobject_property (ValaCCodeBaseModule* self, ValaProperty* prop) {
	gboolean result = FALSE;
	g_return_val_if_fail (prop != NULL, FALSE);
	result = FALSE;
	return result;
}


gboolean vala_ccode_base_module_is_gobject_property (ValaCCodeBaseModule* self, ValaProperty* prop) {
	g_return_val_if_fail (self != NULL, FALSE);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->is_gobject_property (self, prop);
}


ValaDataType* vala_ccode_base_module_get_this_type (ValaCCodeBaseModule* self) {
	ValaDataType* result = NULL;
	gboolean _tmp0_ = FALSE;
	ValaMethod* _tmp1_;
	ValaMethod* _tmp2_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp1_ = vala_ccode_base_module_get_current_method (self);
	_tmp2_ = _tmp1_;
	if (_tmp2_ != NULL) {
		ValaMethod* _tmp3_;
		ValaMethod* _tmp4_;
		ValaMemberBinding _tmp5_;
		ValaMemberBinding _tmp6_;
		_tmp3_ = vala_ccode_base_module_get_current_method (self);
		_tmp4_ = _tmp3_;
		_tmp5_ = vala_method_get_binding (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp0_ = _tmp6_ == VALA_MEMBER_BINDING_INSTANCE;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		ValaMethod* _tmp7_;
		ValaMethod* _tmp8_;
		ValaParameter* _tmp9_;
		ValaParameter* _tmp10_;
		ValaDataType* _tmp11_;
		ValaDataType* _tmp12_;
		ValaDataType* _tmp13_;
		_tmp7_ = vala_ccode_base_module_get_current_method (self);
		_tmp8_ = _tmp7_;
		_tmp9_ = vala_method_get_this_parameter (_tmp8_);
		_tmp10_ = _tmp9_;
		_tmp11_ = vala_variable_get_variable_type ((ValaVariable*) _tmp10_);
		_tmp12_ = _tmp11_;
		_tmp13_ = _vala_code_node_ref0 (_tmp12_);
		result = _tmp13_;
		return result;
	} else {
		gboolean _tmp14_ = FALSE;
		ValaPropertyAccessor* _tmp15_;
		ValaPropertyAccessor* _tmp16_;
		_tmp15_ = vala_ccode_base_module_get_current_property_accessor (self);
		_tmp16_ = _tmp15_;
		if (_tmp16_ != NULL) {
			ValaPropertyAccessor* _tmp17_;
			ValaPropertyAccessor* _tmp18_;
			ValaProperty* _tmp19_;
			ValaProperty* _tmp20_;
			ValaMemberBinding _tmp21_;
			ValaMemberBinding _tmp22_;
			_tmp17_ = vala_ccode_base_module_get_current_property_accessor (self);
			_tmp18_ = _tmp17_;
			_tmp19_ = vala_property_accessor_get_prop (_tmp18_);
			_tmp20_ = _tmp19_;
			_tmp21_ = vala_property_get_binding (_tmp20_);
			_tmp22_ = _tmp21_;
			_tmp14_ = _tmp22_ == VALA_MEMBER_BINDING_INSTANCE;
		} else {
			_tmp14_ = FALSE;
		}
		if (_tmp14_) {
			ValaPropertyAccessor* _tmp23_;
			ValaPropertyAccessor* _tmp24_;
			ValaProperty* _tmp25_;
			ValaProperty* _tmp26_;
			ValaParameter* _tmp27_;
			ValaParameter* _tmp28_;
			ValaDataType* _tmp29_;
			ValaDataType* _tmp30_;
			ValaDataType* _tmp31_;
			_tmp23_ = vala_ccode_base_module_get_current_property_accessor (self);
			_tmp24_ = _tmp23_;
			_tmp25_ = vala_property_accessor_get_prop (_tmp24_);
			_tmp26_ = _tmp25_;
			_tmp27_ = vala_property_get_this_parameter (_tmp26_);
			_tmp28_ = _tmp27_;
			_tmp29_ = vala_variable_get_variable_type ((ValaVariable*) _tmp28_);
			_tmp30_ = _tmp29_;
			_tmp31_ = _vala_code_node_ref0 (_tmp30_);
			result = _tmp31_;
			return result;
		} else {
			gboolean _tmp32_ = FALSE;
			ValaConstructor* _tmp33_;
			ValaConstructor* _tmp34_;
			_tmp33_ = vala_ccode_base_module_get_current_constructor (self);
			_tmp34_ = _tmp33_;
			if (_tmp34_ != NULL) {
				ValaConstructor* _tmp35_;
				ValaConstructor* _tmp36_;
				ValaMemberBinding _tmp37_;
				ValaMemberBinding _tmp38_;
				_tmp35_ = vala_ccode_base_module_get_current_constructor (self);
				_tmp36_ = _tmp35_;
				_tmp37_ = vala_constructor_get_binding (_tmp36_);
				_tmp38_ = _tmp37_;
				_tmp32_ = _tmp38_ == VALA_MEMBER_BINDING_INSTANCE;
			} else {
				_tmp32_ = FALSE;
			}
			if (_tmp32_) {
				ValaConstructor* _tmp39_;
				ValaConstructor* _tmp40_;
				ValaParameter* _tmp41_;
				ValaParameter* _tmp42_;
				ValaDataType* _tmp43_;
				ValaDataType* _tmp44_;
				ValaDataType* _tmp45_;
				_tmp39_ = vala_ccode_base_module_get_current_constructor (self);
				_tmp40_ = _tmp39_;
				_tmp41_ = vala_constructor_get_this_parameter (_tmp40_);
				_tmp42_ = _tmp41_;
				_tmp43_ = vala_variable_get_variable_type ((ValaVariable*) _tmp42_);
				_tmp44_ = _tmp43_;
				_tmp45_ = _vala_code_node_ref0 (_tmp44_);
				result = _tmp45_;
				return result;
			} else {
				gboolean _tmp46_ = FALSE;
				ValaDestructor* _tmp47_;
				ValaDestructor* _tmp48_;
				_tmp47_ = vala_ccode_base_module_get_current_destructor (self);
				_tmp48_ = _tmp47_;
				if (_tmp48_ != NULL) {
					ValaDestructor* _tmp49_;
					ValaDestructor* _tmp50_;
					ValaMemberBinding _tmp51_;
					ValaMemberBinding _tmp52_;
					_tmp49_ = vala_ccode_base_module_get_current_destructor (self);
					_tmp50_ = _tmp49_;
					_tmp51_ = vala_destructor_get_binding (_tmp50_);
					_tmp52_ = _tmp51_;
					_tmp46_ = _tmp52_ == VALA_MEMBER_BINDING_INSTANCE;
				} else {
					_tmp46_ = FALSE;
				}
				if (_tmp46_) {
					ValaDestructor* _tmp53_;
					ValaDestructor* _tmp54_;
					ValaParameter* _tmp55_;
					ValaParameter* _tmp56_;
					ValaDataType* _tmp57_;
					ValaDataType* _tmp58_;
					ValaDataType* _tmp59_;
					_tmp53_ = vala_ccode_base_module_get_current_destructor (self);
					_tmp54_ = _tmp53_;
					_tmp55_ = vala_destructor_get_this_parameter (_tmp54_);
					_tmp56_ = _tmp55_;
					_tmp57_ = vala_variable_get_variable_type ((ValaVariable*) _tmp56_);
					_tmp58_ = _tmp57_;
					_tmp59_ = _vala_code_node_ref0 (_tmp58_);
					result = _tmp59_;
					return result;
				}
			}
		}
	}
	result = NULL;
	return result;
}


ValaCCodeFunctionCall* vala_ccode_base_module_generate_instance_cast (ValaCCodeBaseModule* self, ValaCCodeExpression* expr, ValaTypeSymbol* type) {
	ValaCCodeFunctionCall* result = NULL;
	ValaCCodeFunctionCall* _result_ = NULL;
	ValaCCodeIdentifier* _tmp0_;
	ValaCCodeIdentifier* _tmp1_;
	ValaCCodeFunctionCall* _tmp2_;
	ValaCCodeFunctionCall* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	ValaTypeSymbol* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	ValaCCodeIdentifier* _tmp8_;
	ValaCCodeIdentifier* _tmp9_;
	ValaTypeSymbol* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	ValaCCodeIdentifier* _tmp13_;
	ValaCCodeIdentifier* _tmp14_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (expr != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = vala_ccode_identifier_new ("G_TYPE_CHECK_INSTANCE_CAST");
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1_);
	_tmp3_ = _tmp2_;
	_vala_ccode_node_unref0 (_tmp1_);
	_result_ = _tmp3_;
	_tmp4_ = expr;
	vala_ccode_function_call_add_argument (_result_, _tmp4_);
	_tmp5_ = type;
	_tmp6_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = vala_ccode_identifier_new (_tmp7_);
	_tmp9_ = _tmp8_;
	vala_ccode_function_call_add_argument (_result_, (ValaCCodeExpression*) _tmp9_);
	_vala_ccode_node_unref0 (_tmp9_);
	_g_free0 (_tmp7_);
	_tmp10_ = type;
	_tmp11_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp10_);
	_tmp12_ = _tmp11_;
	_tmp13_ = vala_ccode_identifier_new (_tmp12_);
	_tmp14_ = _tmp13_;
	vala_ccode_function_call_add_argument (_result_, (ValaCCodeExpression*) _tmp14_);
	_vala_ccode_node_unref0 (_tmp14_);
	_g_free0 (_tmp12_);
	result = _result_;
	return result;
}


static void vala_ccode_base_module_generate_struct_destroy_function (ValaCCodeBaseModule* self, ValaStruct* st) {
	ValaCCodeFile* _tmp0_;
	ValaStruct* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	ValaCCodeFunction* function = NULL;
	ValaStruct* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	ValaCCodeFunction* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	ValaCCodeFunction* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaStruct* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
	gchar* _tmp16_;
	gchar* _tmp17_;
	ValaCCodeParameter* _tmp18_;
	ValaCCodeParameter* _tmp19_;
	ValaCCodeBaseModuleEmitContext* _tmp20_;
	ValaCCodeBaseModuleEmitContext* _tmp21_;
	ValaCCodeFunction* _tmp22_;
	ValaTargetValue* this_value = NULL;
	ValaStruct* _tmp23_;
	ValaTargetValue* _tmp24_;
	ValaCCodeFile* _tmp49_;
	ValaCCodeFunction* _tmp50_;
	ValaCCodeFile* _tmp51_;
	ValaCCodeFunction* _tmp52_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (st != NULL);
	_tmp0_ = self->cfile;
	_tmp1_ = st;
	_tmp2_ = vala_ccode_base_module_get_ccode_destroy_function ((ValaTypeSymbol*) _tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_file_add_declaration (_tmp0_, _tmp3_);
	_tmp5_ = _tmp4_;
	_g_free0 (_tmp3_);
	if (_tmp5_) {
		return;
	}
	_tmp6_ = st;
	_tmp7_ = vala_ccode_base_module_get_ccode_destroy_function ((ValaTypeSymbol*) _tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = vala_ccode_function_new (_tmp8_, "void");
	_tmp10_ = _tmp9_;
	_g_free0 (_tmp8_);
	function = _tmp10_;
	_tmp11_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp11_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp12_ = function;
	_tmp13_ = st;
	_tmp14_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = g_strdup_printf ("%s *", _tmp15_);
	_tmp17_ = _tmp16_;
	_tmp18_ = vala_ccode_parameter_new ("self", _tmp17_);
	_tmp19_ = _tmp18_;
	vala_ccode_function_add_parameter (_tmp12_, _tmp19_);
	_vala_ccode_node_unref0 (_tmp19_);
	_g_free0 (_tmp17_);
	_g_free0 (_tmp15_);
	_tmp20_ = vala_ccode_base_module_emit_context_new (NULL);
	_tmp21_ = _tmp20_;
	vala_ccode_base_module_push_context (self, _tmp21_);
	_vala_ccode_base_module_emit_context_unref0 (_tmp21_);
	_tmp22_ = function;
	vala_ccode_base_module_push_function (self, _tmp22_);
	_tmp23_ = st;
	_tmp24_ = vala_ccode_base_module_load_this_parameter (self, (ValaTypeSymbol*) _tmp23_);
	this_value = _tmp24_;
	{
		ValaList* _f_list = NULL;
		ValaStruct* _tmp25_;
		ValaList* _tmp26_;
		gint _f_size = 0;
		ValaList* _tmp27_;
		gint _tmp28_;
		gint _tmp29_;
		gint _f_index = 0;
		_tmp25_ = st;
		_tmp26_ = vala_struct_get_fields (_tmp25_);
		_f_list = _tmp26_;
		_tmp27_ = _f_list;
		_tmp28_ = vala_collection_get_size ((ValaCollection*) _tmp27_);
		_tmp29_ = _tmp28_;
		_f_size = _tmp29_;
		_f_index = -1;
		while (TRUE) {
			gint _tmp30_;
			gint _tmp31_;
			gint _tmp32_;
			ValaField* f = NULL;
			ValaList* _tmp33_;
			gint _tmp34_;
			gpointer _tmp35_;
			ValaField* _tmp36_;
			ValaMemberBinding _tmp37_;
			ValaMemberBinding _tmp38_;
			_tmp30_ = _f_index;
			_f_index = _tmp30_ + 1;
			_tmp31_ = _f_index;
			_tmp32_ = _f_size;
			if (!(_tmp31_ < _tmp32_)) {
				break;
			}
			_tmp33_ = _f_list;
			_tmp34_ = _f_index;
			_tmp35_ = vala_list_get (_tmp33_, _tmp34_);
			f = (ValaField*) _tmp35_;
			_tmp36_ = f;
			_tmp37_ = vala_field_get_binding (_tmp36_);
			_tmp38_ = _tmp37_;
			if (_tmp38_ == VALA_MEMBER_BINDING_INSTANCE) {
				ValaField* _tmp39_;
				ValaDataType* _tmp40_;
				ValaDataType* _tmp41_;
				gboolean _tmp42_;
				_tmp39_ = f;
				_tmp40_ = vala_variable_get_variable_type ((ValaVariable*) _tmp39_);
				_tmp41_ = _tmp40_;
				_tmp42_ = vala_ccode_base_module_requires_destroy (self, _tmp41_);
				if (_tmp42_) {
					ValaCCodeFunction* _tmp43_;
					ValaCCodeFunction* _tmp44_;
					ValaField* _tmp45_;
					ValaTargetValue* _tmp46_;
					ValaCCodeExpression* _tmp47_;
					ValaCCodeExpression* _tmp48_;
					_tmp43_ = vala_ccode_base_module_get_ccode (self);
					_tmp44_ = _tmp43_;
					_tmp45_ = f;
					_tmp46_ = this_value;
					_tmp47_ = vala_ccode_base_module_destroy_field (self, _tmp45_, _tmp46_);
					_tmp48_ = _tmp47_;
					vala_ccode_function_add_expression (_tmp44_, _tmp48_);
					_vala_ccode_node_unref0 (_tmp48_);
				}
			}
			_vala_code_node_unref0 (f);
		}
		_vala_iterable_unref0 (_f_list);
	}
	vala_ccode_base_module_pop_function (self);
	vala_ccode_base_module_pop_context (self);
	_tmp49_ = self->cfile;
	_tmp50_ = function;
	vala_ccode_file_add_function_declaration (_tmp49_, _tmp50_);
	_tmp51_ = self->cfile;
	_tmp52_ = function;
	vala_ccode_file_add_function (_tmp51_, _tmp52_);
	_vala_target_value_unref0 (this_value);
	_vala_ccode_node_unref0 (function);
}


static void vala_ccode_base_module_generate_struct_copy_function (ValaCCodeBaseModule* self, ValaStruct* st) {
	ValaCCodeFile* _tmp0_;
	ValaStruct* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	ValaCCodeFunction* function = NULL;
	ValaStruct* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	ValaCCodeFunction* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	ValaCCodeFunction* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaStruct* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
	gchar* _tmp16_;
	gchar* _tmp17_;
	ValaCCodeParameter* _tmp18_;
	ValaCCodeParameter* _tmp19_;
	ValaCCodeFunction* _tmp20_;
	ValaStruct* _tmp21_;
	gchar* _tmp22_;
	gchar* _tmp23_;
	gchar* _tmp24_;
	gchar* _tmp25_;
	ValaCCodeParameter* _tmp26_;
	ValaCCodeParameter* _tmp27_;
	ValaCCodeBaseModuleEmitContext* _tmp28_;
	ValaCCodeBaseModuleEmitContext* _tmp29_;
	ValaCCodeFunction* _tmp30_;
	ValaGLibValue* dest_struct = NULL;
	ValaStruct* _tmp31_;
	ValaDataType* _tmp32_;
	ValaDataType* _tmp33_;
	ValaCCodeIdentifier* _tmp34_;
	ValaCCodeIdentifier* _tmp35_;
	ValaGLibValue* _tmp36_;
	ValaGLibValue* _tmp37_;
	ValaCCodeFile* _tmp69_;
	ValaCCodeFunction* _tmp70_;
	ValaCCodeFile* _tmp71_;
	ValaCCodeFunction* _tmp72_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (st != NULL);
	_tmp0_ = self->cfile;
	_tmp1_ = st;
	_tmp2_ = vala_ccode_base_module_get_ccode_copy_function ((ValaTypeSymbol*) _tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_file_add_declaration (_tmp0_, _tmp3_);
	_tmp5_ = _tmp4_;
	_g_free0 (_tmp3_);
	if (_tmp5_) {
		return;
	}
	_tmp6_ = st;
	_tmp7_ = vala_ccode_base_module_get_ccode_copy_function ((ValaTypeSymbol*) _tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = vala_ccode_function_new (_tmp8_, "void");
	_tmp10_ = _tmp9_;
	_g_free0 (_tmp8_);
	function = _tmp10_;
	_tmp11_ = function;
	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp11_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp12_ = function;
	_tmp13_ = st;
	_tmp14_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = g_strdup_printf ("const %s *", _tmp15_);
	_tmp17_ = _tmp16_;
	_tmp18_ = vala_ccode_parameter_new ("self", _tmp17_);
	_tmp19_ = _tmp18_;
	vala_ccode_function_add_parameter (_tmp12_, _tmp19_);
	_vala_ccode_node_unref0 (_tmp19_);
	_g_free0 (_tmp17_);
	_g_free0 (_tmp15_);
	_tmp20_ = function;
	_tmp21_ = st;
	_tmp22_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp21_);
	_tmp23_ = _tmp22_;
	_tmp24_ = g_strdup_printf ("%s *", _tmp23_);
	_tmp25_ = _tmp24_;
	_tmp26_ = vala_ccode_parameter_new ("dest", _tmp25_);
	_tmp27_ = _tmp26_;
	vala_ccode_function_add_parameter (_tmp20_, _tmp27_);
	_vala_ccode_node_unref0 (_tmp27_);
	_g_free0 (_tmp25_);
	_g_free0 (_tmp23_);
	_tmp28_ = vala_ccode_base_module_emit_context_new (NULL);
	_tmp29_ = _tmp28_;
	vala_ccode_base_module_push_context (self, _tmp29_);
	_vala_ccode_base_module_emit_context_unref0 (_tmp29_);
	_tmp30_ = function;
	vala_ccode_base_module_push_function (self, _tmp30_);
	_tmp31_ = st;
	_tmp32_ = vala_ccode_base_module_get_data_type_for_symbol ((ValaTypeSymbol*) _tmp31_);
	_tmp33_ = _tmp32_;
	_tmp34_ = vala_ccode_identifier_new ("(*dest)");
	_tmp35_ = _tmp34_;
	_tmp36_ = vala_glib_value_new (_tmp33_, (ValaCCodeExpression*) _tmp35_, TRUE);
	_tmp37_ = _tmp36_;
	_vala_ccode_node_unref0 (_tmp35_);
	_vala_code_node_unref0 (_tmp33_);
	dest_struct = _tmp37_;
	{
		ValaList* _f_list = NULL;
		ValaStruct* _tmp38_;
		ValaList* _tmp39_;
		gint _f_size = 0;
		ValaList* _tmp40_;
		gint _tmp41_;
		gint _tmp42_;
		gint _f_index = 0;
		_tmp38_ = st;
		_tmp39_ = vala_struct_get_fields (_tmp38_);
		_f_list = _tmp39_;
		_tmp40_ = _f_list;
		_tmp41_ = vala_collection_get_size ((ValaCollection*) _tmp40_);
		_tmp42_ = _tmp41_;
		_f_size = _tmp42_;
		_f_index = -1;
		while (TRUE) {
			gint _tmp43_;
			gint _tmp44_;
			gint _tmp45_;
			ValaField* f = NULL;
			ValaList* _tmp46_;
			gint _tmp47_;
			gpointer _tmp48_;
			ValaField* _tmp49_;
			ValaMemberBinding _tmp50_;
			ValaMemberBinding _tmp51_;
			_tmp43_ = _f_index;
			_f_index = _tmp43_ + 1;
			_tmp44_ = _f_index;
			_tmp45_ = _f_size;
			if (!(_tmp44_ < _tmp45_)) {
				break;
			}
			_tmp46_ = _f_list;
			_tmp47_ = _f_index;
			_tmp48_ = vala_list_get (_tmp46_, _tmp47_);
			f = (ValaField*) _tmp48_;
			_tmp49_ = f;
			_tmp50_ = vala_field_get_binding (_tmp49_);
			_tmp51_ = _tmp50_;
			if (_tmp51_ == VALA_MEMBER_BINDING_INSTANCE) {
				ValaTargetValue* value = NULL;
				ValaField* _tmp52_;
				ValaStruct* _tmp53_;
				ValaTargetValue* _tmp54_;
				ValaTargetValue* _tmp55_;
				ValaTargetValue* _tmp56_;
				ValaTargetValue* _tmp57_;
				ValaField* _tmp58_;
				ValaDataType* _tmp59_;
				ValaDataType* _tmp60_;
				gboolean _tmp61_;
				ValaField* _tmp66_;
				ValaGLibValue* _tmp67_;
				ValaTargetValue* _tmp68_;
				_tmp52_ = f;
				_tmp53_ = st;
				_tmp54_ = vala_ccode_base_module_load_this_parameter (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp53_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
				_tmp55_ = _tmp54_;
				_tmp56_ = vala_code_generator_load_field ((ValaCodeGenerator*) self, _tmp52_, _tmp55_);
				_tmp57_ = _tmp56_;
				_vala_target_value_unref0 (_tmp55_);
				value = _tmp57_;
				_tmp58_ = f;
				_tmp59_ = vala_variable_get_variable_type ((ValaVariable*) _tmp58_);
				_tmp60_ = _tmp59_;
				_tmp61_ = vala_ccode_base_module_requires_copy (self, _tmp60_);
				if (_tmp61_) {
					ValaTargetValue* _tmp62_;
					ValaField* _tmp63_;
					ValaTargetValue* _tmp64_;
					ValaTargetValue* _tmp65_;
					_tmp62_ = value;
					_tmp63_ = f;
					_tmp64_ = vala_ccode_base_module_copy_value (self, _tmp62_, (ValaCodeNode*) _tmp63_);
					_vala_target_value_unref0 (value);
					value = _tmp64_;
					_tmp65_ = value;
					if (_tmp65_ == NULL) {
						_vala_target_value_unref0 (value);
						_vala_code_node_unref0 (f);
						continue;
					}
				}
				_tmp66_ = f;
				_tmp67_ = dest_struct;
				_tmp68_ = value;
				vala_code_generator_store_field ((ValaCodeGenerator*) self, _tmp66_, (ValaTargetValue*) _tmp67_, _tmp68_);
				_vala_target_value_unref0 (value);
			}
			_vala_code_node_unref0 (f);
		}
		_vala_iterable_unref0 (_f_list);
	}
	vala_ccode_base_module_pop_function (self);
	vala_ccode_base_module_pop_context (self);
	_tmp69_ = self->cfile;
	_tmp70_ = function;
	vala_ccode_file_add_function_declaration (_tmp69_, _tmp70_);
	_tmp71_ = self->cfile;
	_tmp72_ = function;
	vala_ccode_file_add_function (_tmp71_, _tmp72_);
	_vala_target_value_unref0 (dest_struct);
	_vala_ccode_node_unref0 (function);
}


void vala_ccode_base_module_return_default_value (ValaCCodeBaseModule* self, ValaDataType* return_type) {
	ValaStruct* st = NULL;
	ValaDataType* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	ValaTypeSymbol* _tmp2_;
	ValaStruct* _tmp3_;
	gboolean _tmp4_ = FALSE;
	gboolean _tmp5_ = FALSE;
	ValaStruct* _tmp6_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (return_type != NULL);
	_tmp0_ = return_type;
	_tmp1_ = vala_data_type_get_data_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp2_) : NULL);
	st = _tmp3_;
	_tmp6_ = st;
	if (_tmp6_ != NULL) {
		ValaStruct* _tmp7_;
		gboolean _tmp8_;
		_tmp7_ = st;
		_tmp8_ = vala_struct_is_simple_type (_tmp7_);
		_tmp5_ = _tmp8_;
	} else {
		_tmp5_ = FALSE;
	}
	if (_tmp5_) {
		ValaDataType* _tmp9_;
		gboolean _tmp10_;
		gboolean _tmp11_;
		_tmp9_ = return_type;
		_tmp10_ = vala_data_type_get_nullable (_tmp9_);
		_tmp11_ = _tmp10_;
		_tmp4_ = !_tmp11_;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		ValaLocalVariable* ret_temp_var = NULL;
		ValaDataType* _tmp12_;
		ValaLocalVariable* _tmp13_;
		ValaLocalVariable* _tmp14_;
		ValaCCodeFunction* _tmp15_;
		ValaCCodeFunction* _tmp16_;
		ValaLocalVariable* _tmp17_;
		const gchar* _tmp18_;
		const gchar* _tmp19_;
		ValaCCodeIdentifier* _tmp20_;
		ValaCCodeIdentifier* _tmp21_;
		_tmp12_ = return_type;
		_tmp13_ = vala_ccode_base_module_get_temp_variable (self, _tmp12_, TRUE, NULL, TRUE);
		ret_temp_var = _tmp13_;
		_tmp14_ = ret_temp_var;
		vala_ccode_base_module_emit_temp_var (self, _tmp14_);
		_tmp15_ = vala_ccode_base_module_get_ccode (self);
		_tmp16_ = _tmp15_;
		_tmp17_ = ret_temp_var;
		_tmp18_ = vala_symbol_get_name ((ValaSymbol*) _tmp17_);
		_tmp19_ = _tmp18_;
		_tmp20_ = vala_ccode_identifier_new (_tmp19_);
		_tmp21_ = _tmp20_;
		vala_ccode_function_add_return (_tmp16_, (ValaCCodeExpression*) _tmp21_);
		_vala_ccode_node_unref0 (_tmp21_);
		_vala_code_node_unref0 (ret_temp_var);
	} else {
		ValaCCodeFunction* _tmp22_;
		ValaCCodeFunction* _tmp23_;
		ValaDataType* _tmp24_;
		ValaCCodeExpression* _tmp25_;
		ValaCCodeExpression* _tmp26_;
		_tmp22_ = vala_ccode_base_module_get_ccode (self);
		_tmp23_ = _tmp22_;
		_tmp24_ = return_type;
		_tmp25_ = vala_ccode_base_module_default_value_for_type (self, _tmp24_, FALSE);
		_tmp26_ = _tmp25_;
		vala_ccode_function_add_return (_tmp23_, _tmp26_);
		_vala_ccode_node_unref0 (_tmp26_);
	}
	_vala_code_node_unref0 (st);
}


static void vala_ccode_base_module_real_generate_dynamic_method_wrapper (ValaCCodeBaseModule* self, ValaDynamicMethod* method) {
	g_return_if_fail (method != NULL);
}


void vala_ccode_base_module_generate_dynamic_method_wrapper (ValaCCodeBaseModule* self, ValaDynamicMethod* method) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_dynamic_method_wrapper (self, method);
}


static gboolean vala_ccode_base_module_real_method_has_wrapper (ValaCCodeBaseModule* self, ValaMethod* method) {
	gboolean result = FALSE;
	g_return_val_if_fail (method != NULL, FALSE);
	result = FALSE;
	return result;
}


gboolean vala_ccode_base_module_method_has_wrapper (ValaCCodeBaseModule* self, ValaMethod* method) {
	g_return_val_if_fail (self != NULL, FALSE);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->method_has_wrapper (self, method);
}


static ValaCCodeFunctionCall* vala_ccode_base_module_real_get_param_spec (ValaCCodeBaseModule* self, ValaProperty* prop) {
	ValaCCodeFunctionCall* result = NULL;
	ValaCCodeIdentifier* _tmp0_;
	ValaCCodeIdentifier* _tmp1_;
	ValaCCodeFunctionCall* _tmp2_;
	ValaCCodeFunctionCall* _tmp3_;
	g_return_val_if_fail (prop != NULL, NULL);
	_tmp0_ = vala_ccode_identifier_new ("");
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1_);
	_tmp3_ = _tmp2_;
	_vala_ccode_node_unref0 (_tmp1_);
	result = _tmp3_;
	return result;
}


ValaCCodeFunctionCall* vala_ccode_base_module_get_param_spec (ValaCCodeBaseModule* self, ValaProperty* prop) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_param_spec (self, prop);
}


static ValaCCodeExpression* vala_ccode_base_module_real_get_signal_creation (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeIdentifier* _tmp0_;
	ValaCCodeIdentifier* _tmp1_;
	ValaCCodeFunctionCall* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	g_return_val_if_fail (sig != NULL, NULL);
	g_return_val_if_fail (type != NULL, NULL);
	_tmp0_ = vala_ccode_identifier_new ("");
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1_);
	_tmp3_ = (ValaCCodeExpression*) _tmp2_;
	_vala_ccode_node_unref0 (_tmp1_);
	result = _tmp3_;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_signal_creation (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_signal_creation (self, sig, type);
}


static void vala_ccode_base_module_real_register_dbus_info (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable) {
	g_return_if_fail (block != NULL);
	g_return_if_fail (bindable != NULL);
}


void vala_ccode_base_module_register_dbus_info (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->register_dbus_info (self, block, bindable);
}


static gchar* vala_ccode_base_module_real_get_dynamic_property_getter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node) {
	gchar* result = NULL;
	ValaDynamicProperty* _tmp0_;
	ValaSourceReference* _tmp1_;
	ValaSourceReference* _tmp2_;
	ValaDynamicProperty* _tmp3_;
	ValaDataType* _tmp4_;
	ValaDataType* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = node;
	_tmp4_ = vala_dynamic_property_get_dynamic_type (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = vala_code_node_to_string ((ValaCodeNode*) _tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = g_strdup_printf ("dynamic properties are not supported for %s", _tmp7_);
	_tmp9_ = _tmp8_;
	vala_report_error (_tmp2_, _tmp9_);
	_g_free0 (_tmp9_);
	_g_free0 (_tmp7_);
	_tmp10_ = g_strdup ("");
	result = _tmp10_;
	return result;
}


gchar* vala_ccode_base_module_get_dynamic_property_getter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_dynamic_property_getter_cname (self, node);
}


static gchar* vala_ccode_base_module_real_get_dynamic_property_setter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node) {
	gchar* result = NULL;
	ValaDynamicProperty* _tmp0_;
	ValaSourceReference* _tmp1_;
	ValaSourceReference* _tmp2_;
	ValaDynamicProperty* _tmp3_;
	ValaDataType* _tmp4_;
	ValaDataType* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = node;
	_tmp1_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = node;
	_tmp4_ = vala_dynamic_property_get_dynamic_type (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = vala_code_node_to_string ((ValaCodeNode*) _tmp5_);
	_tmp7_ = _tmp6_;
	_tmp8_ = g_strdup_printf ("dynamic properties are not supported for %s", _tmp7_);
	_tmp9_ = _tmp8_;
	vala_report_error (_tmp2_, _tmp9_);
	_g_free0 (_tmp9_);
	_g_free0 (_tmp7_);
	_tmp10_ = g_strdup ("");
	result = _tmp10_;
	return result;
}


gchar* vala_ccode_base_module_get_dynamic_property_setter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_dynamic_property_setter_cname (self, node);
}


static gchar* vala_ccode_base_module_real_get_dynamic_signal_cname (ValaCCodeBaseModule* self, ValaDynamicSignal* node) {
	gchar* result = NULL;
	gchar* _tmp0_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = g_strdup ("");
	result = _tmp0_;
	return result;
}


gchar* vala_ccode_base_module_get_dynamic_signal_cname (ValaCCodeBaseModule* self, ValaDynamicSignal* node) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_dynamic_signal_cname (self, node);
}


static gchar* vala_ccode_base_module_real_get_dynamic_signal_connect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node) {
	gchar* result = NULL;
	gchar* _tmp0_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = g_strdup ("");
	result = _tmp0_;
	return result;
}


gchar* vala_ccode_base_module_get_dynamic_signal_connect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_dynamic_signal_connect_wrapper_name (self, node);
}


static gchar* vala_ccode_base_module_real_get_dynamic_signal_connect_after_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node) {
	gchar* result = NULL;
	gchar* _tmp0_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = g_strdup ("");
	result = _tmp0_;
	return result;
}


gchar* vala_ccode_base_module_get_dynamic_signal_connect_after_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_dynamic_signal_connect_after_wrapper_name (self, node);
}


static gchar* vala_ccode_base_module_real_get_dynamic_signal_disconnect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node) {
	gchar* result = NULL;
	gchar* _tmp0_;
	g_return_val_if_fail (node != NULL, NULL);
	_tmp0_ = g_strdup ("");
	result = _tmp0_;
	return result;
}


gchar* vala_ccode_base_module_get_dynamic_signal_disconnect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_dynamic_signal_disconnect_wrapper_name (self, node);
}


static gchar* vala_ccode_base_module_real_get_array_length_cname (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim) {
	gchar* result = NULL;
	gchar* _tmp0_;
	g_return_val_if_fail (array_cname != NULL, NULL);
	_tmp0_ = g_strdup ("");
	result = _tmp0_;
	return result;
}


gchar* vala_ccode_base_module_get_array_length_cname (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_array_length_cname (self, array_cname, dim);
}


static gchar* vala_ccode_base_module_real_get_parameter_array_length_cname (ValaCCodeBaseModule* self, ValaParameter* param, gint dim) {
	gchar* result = NULL;
	gchar* _tmp0_;
	g_return_val_if_fail (param != NULL, NULL);
	_tmp0_ = g_strdup ("");
	result = _tmp0_;
	return result;
}


gchar* vala_ccode_base_module_get_parameter_array_length_cname (ValaCCodeBaseModule* self, ValaParameter* param, gint dim) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_parameter_array_length_cname (self, param, dim);
}


static ValaCCodeExpression* vala_ccode_base_module_real_get_array_length_cexpression (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeConstant* _tmp0_;
	g_return_val_if_fail (array_expr != NULL, NULL);
	_tmp0_ = vala_ccode_constant_new ("");
	result = (ValaCCodeExpression*) _tmp0_;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_array_length_cexpression (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_array_length_cexpression (self, array_expr, dim);
}


static ValaCCodeExpression* vala_ccode_base_module_real_get_array_length_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim) {
	ValaCCodeExpression* result = NULL;
	ValaCCodeInvalidExpression* _tmp0_;
	g_return_val_if_fail (value != NULL, NULL);
	_tmp0_ = vala_ccode_invalid_expression_new ();
	result = (ValaCCodeExpression*) _tmp0_;
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_array_length_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_array_length_cvalue (self, value, dim);
}


static gchar* vala_ccode_base_module_real_get_array_size_cname (ValaCCodeBaseModule* self, const gchar* array_cname) {
	gchar* result = NULL;
	gchar* _tmp0_;
	g_return_val_if_fail (array_cname != NULL, NULL);
	_tmp0_ = g_strdup ("");
	result = _tmp0_;
	return result;
}


gchar* vala_ccode_base_module_get_array_size_cname (ValaCCodeBaseModule* self, const gchar* array_cname) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->get_array_size_cname (self, array_cname);
}


static void vala_ccode_base_module_real_add_simple_check (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails) {
	g_return_if_fail (node != NULL);
}


void vala_ccode_base_module_add_simple_check (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails) {
	g_return_if_fail (self != NULL);
	VALA_CCODE_BASE_MODULE_GET_CLASS (self)->add_simple_check (self, node, always_fails);
}


static gchar* vala_ccode_base_module_real_generate_ready_function (ValaCCodeBaseModule* self, ValaMethod* m) {
	gchar* result = NULL;
	gchar* _tmp0_;
	g_return_val_if_fail (m != NULL, NULL);
	_tmp0_ = g_strdup ("");
	result = _tmp0_;
	return result;
}


gchar* vala_ccode_base_module_generate_ready_function (ValaCCodeBaseModule* self, ValaMethod* m) {
	g_return_val_if_fail (self != NULL, NULL);
	return VALA_CCODE_BASE_MODULE_GET_CLASS (self)->generate_ready_function (self, m);
}


ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr) {
	ValaCCodeExpression* result = NULL;
	ValaExpression* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaGLibValue* glib_value = NULL;
	ValaExpression* _tmp3_;
	ValaTargetValue* _tmp4_;
	ValaTargetValue* _tmp5_;
	ValaGLibValue* _tmp6_;
	ValaGLibValue* _tmp7_;
	ValaCCodeExpression* _tmp8_;
	ValaCCodeExpression* _tmp9_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (expr != NULL, NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_expression_get_target_value (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ == NULL) {
		result = NULL;
		return result;
	}
	_tmp3_ = expr;
	_tmp4_ = vala_expression_get_target_value (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp5_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp6_;
	_tmp7_ = glib_value;
	_tmp8_ = _tmp7_->cvalue;
	_tmp9_ = _vala_ccode_node_ref0 (_tmp8_);
	result = _tmp9_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	ValaCCodeExpression* result = NULL;
	ValaGLibValue* glib_value = NULL;
	ValaTargetValue* _tmp0_;
	ValaGLibValue* _tmp1_;
	ValaCCodeExpression* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (value != NULL, NULL);
	_tmp0_ = value;
	_tmp1_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp1_;
	_tmp2_ = glib_value->cvalue;
	_tmp3_ = _vala_ccode_node_ref0 (_tmp2_);
	result = _tmp3_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


void vala_ccode_base_module_set_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* cvalue) {
	ValaGLibValue* glib_value = NULL;
	ValaExpression* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaGLibValue* _tmp3_;
	ValaGLibValue* _tmp4_;
	ValaGLibValue* _tmp11_;
	ValaCCodeExpression* _tmp12_;
	ValaCCodeExpression* _tmp13_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_expression_get_target_value (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp3_;
	_tmp4_ = glib_value;
	if (_tmp4_ == NULL) {
		ValaExpression* _tmp5_;
		ValaDataType* _tmp6_;
		ValaDataType* _tmp7_;
		ValaGLibValue* _tmp8_;
		ValaExpression* _tmp9_;
		ValaGLibValue* _tmp10_;
		_tmp5_ = expr;
		_tmp6_ = vala_expression_get_value_type (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_glib_value_new (_tmp7_, NULL, FALSE);
		_vala_target_value_unref0 (glib_value);
		glib_value = _tmp8_;
		_tmp9_ = expr;
		_tmp10_ = glib_value;
		vala_expression_set_target_value (_tmp9_, (ValaTargetValue*) _tmp10_);
	}
	_tmp11_ = glib_value;
	_tmp12_ = cvalue;
	_tmp13_ = _vala_ccode_node_ref0 (_tmp12_);
	_vala_ccode_node_unref0 (_tmp11_->cvalue);
	_tmp11_->cvalue = _tmp13_;
	_vala_target_value_unref0 (glib_value);
}


ValaCCodeExpression* vala_ccode_base_module_get_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	ValaCCodeExpression* result = NULL;
	ValaGLibValue* glib_value = NULL;
	ValaTargetValue* _tmp0_;
	ValaGLibValue* _tmp1_;
	ValaCCodeExpression* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (value != NULL, NULL);
	_tmp0_ = value;
	_tmp1_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp1_;
	_tmp2_ = glib_value->array_size_cvalue;
	_tmp3_ = _vala_ccode_node_ref0 (_tmp2_);
	result = _tmp3_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


void vala_ccode_base_module_set_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCCodeExpression* cvalue) {
	ValaGLibValue* glib_value = NULL;
	ValaTargetValue* _tmp0_;
	ValaGLibValue* _tmp1_;
	ValaCCodeExpression* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (value != NULL);
	_tmp0_ = value;
	_tmp1_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp1_;
	_tmp2_ = cvalue;
	_tmp3_ = _vala_ccode_node_ref0 (_tmp2_);
	_vala_ccode_node_unref0 (glib_value->array_size_cvalue);
	glib_value->array_size_cvalue = _tmp3_;
	_vala_target_value_unref0 (glib_value);
}


ValaCCodeExpression* vala_ccode_base_module_get_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr) {
	ValaCCodeExpression* result = NULL;
	ValaExpression* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaGLibValue* glib_value = NULL;
	ValaExpression* _tmp3_;
	ValaTargetValue* _tmp4_;
	ValaTargetValue* _tmp5_;
	ValaGLibValue* _tmp6_;
	ValaGLibValue* _tmp7_;
	ValaCCodeExpression* _tmp8_;
	ValaCCodeExpression* _tmp9_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (expr != NULL, NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_expression_get_target_value (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ == NULL) {
		result = NULL;
		return result;
	}
	_tmp3_ = expr;
	_tmp4_ = vala_expression_get_target_value (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp5_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp6_;
	_tmp7_ = glib_value;
	_tmp8_ = _tmp7_->delegate_target_cvalue;
	_tmp9_ = _vala_ccode_node_ref0 (_tmp8_);
	result = _tmp9_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


void vala_ccode_base_module_set_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* delegate_target) {
	ValaGLibValue* glib_value = NULL;
	ValaExpression* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaGLibValue* _tmp3_;
	ValaGLibValue* _tmp4_;
	ValaGLibValue* _tmp11_;
	ValaCCodeExpression* _tmp12_;
	ValaCCodeExpression* _tmp13_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_expression_get_target_value (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp3_;
	_tmp4_ = glib_value;
	if (_tmp4_ == NULL) {
		ValaExpression* _tmp5_;
		ValaDataType* _tmp6_;
		ValaDataType* _tmp7_;
		ValaGLibValue* _tmp8_;
		ValaExpression* _tmp9_;
		ValaGLibValue* _tmp10_;
		_tmp5_ = expr;
		_tmp6_ = vala_expression_get_value_type (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_glib_value_new (_tmp7_, NULL, FALSE);
		_vala_target_value_unref0 (glib_value);
		glib_value = _tmp8_;
		_tmp9_ = expr;
		_tmp10_ = glib_value;
		vala_expression_set_target_value (_tmp9_, (ValaTargetValue*) _tmp10_);
	}
	_tmp11_ = glib_value;
	_tmp12_ = delegate_target;
	_tmp13_ = _vala_ccode_node_ref0 (_tmp12_);
	_vala_ccode_node_unref0 (_tmp11_->delegate_target_cvalue);
	_tmp11_->delegate_target_cvalue = _tmp13_;
	_vala_target_value_unref0 (glib_value);
}


ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr) {
	ValaCCodeExpression* result = NULL;
	ValaExpression* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaGLibValue* glib_value = NULL;
	ValaExpression* _tmp3_;
	ValaTargetValue* _tmp4_;
	ValaTargetValue* _tmp5_;
	ValaGLibValue* _tmp6_;
	ValaGLibValue* _tmp7_;
	ValaCCodeExpression* _tmp8_;
	ValaCCodeExpression* _tmp9_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (expr != NULL, NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_expression_get_target_value (_tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ == NULL) {
		result = NULL;
		return result;
	}
	_tmp3_ = expr;
	_tmp4_ = vala_expression_get_target_value (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp5_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp6_;
	_tmp7_ = glib_value;
	_tmp8_ = _tmp7_->delegate_target_destroy_notify_cvalue;
	_tmp9_ = _vala_ccode_node_ref0 (_tmp8_);
	result = _tmp9_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


void vala_ccode_base_module_set_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* destroy_notify) {
	ValaGLibValue* glib_value = NULL;
	ValaExpression* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaGLibValue* _tmp3_;
	ValaGLibValue* _tmp4_;
	ValaGLibValue* _tmp11_;
	ValaCCodeExpression* _tmp12_;
	ValaCCodeExpression* _tmp13_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_expression_get_target_value (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp3_;
	_tmp4_ = glib_value;
	if (_tmp4_ == NULL) {
		ValaExpression* _tmp5_;
		ValaDataType* _tmp6_;
		ValaDataType* _tmp7_;
		ValaGLibValue* _tmp8_;
		ValaExpression* _tmp9_;
		ValaGLibValue* _tmp10_;
		_tmp5_ = expr;
		_tmp6_ = vala_expression_get_value_type (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_glib_value_new (_tmp7_, NULL, FALSE);
		_vala_target_value_unref0 (glib_value);
		glib_value = _tmp8_;
		_tmp9_ = expr;
		_tmp10_ = glib_value;
		vala_expression_set_target_value (_tmp9_, (ValaTargetValue*) _tmp10_);
	}
	_tmp11_ = glib_value;
	_tmp12_ = destroy_notify;
	_tmp13_ = _vala_ccode_node_ref0 (_tmp12_);
	_vala_ccode_node_unref0 (_tmp11_->delegate_target_destroy_notify_cvalue);
	_tmp11_->delegate_target_destroy_notify_cvalue = _tmp13_;
	_vala_target_value_unref0 (glib_value);
}


void vala_ccode_base_module_append_array_length (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* size) {
	ValaGLibValue* glib_value = NULL;
	ValaExpression* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaGLibValue* _tmp3_;
	ValaGLibValue* _tmp4_;
	ValaGLibValue* _tmp11_;
	ValaCCodeExpression* _tmp12_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (expr != NULL);
	g_return_if_fail (size != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_expression_get_target_value (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp3_;
	_tmp4_ = glib_value;
	if (_tmp4_ == NULL) {
		ValaExpression* _tmp5_;
		ValaDataType* _tmp6_;
		ValaDataType* _tmp7_;
		ValaGLibValue* _tmp8_;
		ValaExpression* _tmp9_;
		ValaGLibValue* _tmp10_;
		_tmp5_ = expr;
		_tmp6_ = vala_expression_get_value_type (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_glib_value_new (_tmp7_, NULL, FALSE);
		_vala_target_value_unref0 (glib_value);
		glib_value = _tmp8_;
		_tmp9_ = expr;
		_tmp10_ = glib_value;
		vala_expression_set_target_value (_tmp9_, (ValaTargetValue*) _tmp10_);
	}
	_tmp11_ = glib_value;
	_tmp12_ = size;
	vala_glib_value_append_array_length_cvalue (_tmp11_, _tmp12_);
	_vala_target_value_unref0 (glib_value);
}


ValaList* vala_ccode_base_module_get_array_lengths (ValaCCodeBaseModule* self, ValaExpression* expr) {
	ValaList* result = NULL;
	ValaGLibValue* glib_value = NULL;
	ValaExpression* _tmp0_;
	ValaTargetValue* _tmp1_;
	ValaTargetValue* _tmp2_;
	ValaGLibValue* _tmp3_;
	ValaGLibValue* _tmp4_;
	ValaGLibValue* _tmp11_;
	ValaList* _tmp12_;
	ValaList* _tmp13_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (expr != NULL, NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_expression_get_target_value (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp3_;
	_tmp4_ = glib_value;
	if (_tmp4_ == NULL) {
		ValaExpression* _tmp5_;
		ValaDataType* _tmp6_;
		ValaDataType* _tmp7_;
		ValaGLibValue* _tmp8_;
		ValaExpression* _tmp9_;
		ValaGLibValue* _tmp10_;
		_tmp5_ = expr;
		_tmp6_ = vala_expression_get_value_type (_tmp5_);
		_tmp7_ = _tmp6_;
		_tmp8_ = vala_glib_value_new (_tmp7_, NULL, FALSE);
		_vala_target_value_unref0 (glib_value);
		glib_value = _tmp8_;
		_tmp9_ = expr;
		_tmp10_ = glib_value;
		vala_expression_set_target_value (_tmp9_, (ValaTargetValue*) _tmp10_);
	}
	_tmp11_ = glib_value;
	_tmp12_ = _tmp11_->array_length_cvalues;
	_tmp13_ = _vala_iterable_ref0 (_tmp12_);
	result = _tmp13_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


gboolean vala_ccode_base_module_get_lvalue (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	gboolean result = FALSE;
	ValaGLibValue* glib_value = NULL;
	ValaTargetValue* _tmp0_;
	ValaGLibValue* _tmp1_;
	gboolean _tmp2_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (value != NULL, FALSE);
	_tmp0_ = value;
	_tmp1_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp1_;
	_tmp2_ = glib_value->lvalue;
	result = _tmp2_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


gboolean vala_ccode_base_module_get_non_null (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	gboolean result = FALSE;
	ValaGLibValue* glib_value = NULL;
	ValaTargetValue* _tmp0_;
	ValaGLibValue* _tmp1_;
	gboolean _tmp2_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (value != NULL, FALSE);
	_tmp0_ = value;
	_tmp1_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp1_;
	_tmp2_ = glib_value->non_null;
	result = _tmp2_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


gchar* vala_ccode_base_module_get_ctype (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	gchar* result = NULL;
	ValaGLibValue* glib_value = NULL;
	ValaTargetValue* _tmp0_;
	ValaGLibValue* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (value != NULL, NULL);
	_tmp0_ = value;
	_tmp1_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp1_;
	_tmp2_ = glib_value->ctype;
	_tmp3_ = g_strdup (_tmp2_);
	result = _tmp3_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


gboolean vala_ccode_base_module_get_array_null_terminated (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	gboolean result = FALSE;
	ValaGLibValue* glib_value = NULL;
	ValaTargetValue* _tmp0_;
	ValaGLibValue* _tmp1_;
	gboolean _tmp2_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (value != NULL, FALSE);
	_tmp0_ = value;
	_tmp1_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp1_;
	_tmp2_ = glib_value->array_null_terminated;
	result = _tmp2_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


ValaCCodeExpression* vala_ccode_base_module_get_array_length_cexpr (ValaCCodeBaseModule* self, ValaTargetValue* value) {
	ValaCCodeExpression* result = NULL;
	ValaGLibValue* glib_value = NULL;
	ValaTargetValue* _tmp0_;
	ValaGLibValue* _tmp1_;
	ValaCCodeExpression* _tmp2_;
	ValaCCodeExpression* _tmp3_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (value != NULL, NULL);
	_tmp0_ = value;
	_tmp1_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));
	glib_value = _tmp1_;
	_tmp2_ = glib_value->array_length_cexpr;
	_tmp3_ = _vala_ccode_node_ref0 (_tmp2_);
	result = _tmp3_;
	_vala_target_value_unref0 (glib_value);
	return result;
}


ValaCodeContext* vala_ccode_base_module_get_context (ValaCCodeBaseModule* self) {
	ValaCodeContext* result;
	ValaCodeContext* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_context;
	result = _tmp0_;
	return result;
}


static gpointer _vala_code_context_ref0 (gpointer self) {
	return self ? vala_code_context_ref (self) : NULL;
}


void vala_ccode_base_module_set_context (ValaCCodeBaseModule* self, ValaCodeContext* value) {
	ValaCodeContext* _tmp0_;
	ValaCodeContext* _tmp1_;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	_tmp1_ = _vala_code_context_ref0 (_tmp0_);
	_vala_code_context_unref0 (self->priv->_context);
	self->priv->_context = _tmp1_;
}


ValaSymbol* vala_ccode_base_module_get_current_symbol (ValaCCodeBaseModule* self) {
	ValaSymbol* result;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaSymbol* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->current_symbol;
	result = _tmp1_;
	return result;
}


ValaTryStatement* vala_ccode_base_module_get_current_try (ValaCCodeBaseModule* self) {
	ValaTryStatement* result;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaTryStatement* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->current_try;
	result = _tmp1_;
	return result;
}


void vala_ccode_base_module_set_current_try (ValaCCodeBaseModule* self, ValaTryStatement* value) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaTryStatement* _tmp1_;
	ValaTryStatement* _tmp2_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = value;
	_tmp2_ = _vala_code_node_ref0 (_tmp1_);
	_vala_code_node_unref0 (_tmp0_->current_try);
	_tmp0_->current_try = _tmp2_;
}


ValaCatchClause* vala_ccode_base_module_get_current_catch (ValaCCodeBaseModule* self) {
	ValaCatchClause* result;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaCatchClause* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->current_catch;
	result = _tmp1_;
	return result;
}


void vala_ccode_base_module_set_current_catch (ValaCCodeBaseModule* self, ValaCatchClause* value) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaCatchClause* _tmp1_;
	ValaCatchClause* _tmp2_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = value;
	_tmp2_ = _vala_code_node_ref0 (_tmp1_);
	_vala_code_node_unref0 (_tmp0_->current_catch);
	_tmp0_->current_catch = _tmp2_;
}


ValaTypeSymbol* vala_ccode_base_module_get_current_type_symbol (ValaCCodeBaseModule* self) {
	ValaTypeSymbol* result;
	ValaSymbol* sym = NULL;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (_tmp1_);
	sym = _tmp2_;
	while (TRUE) {
		ValaSymbol* _tmp3_;
		ValaSymbol* _tmp4_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		ValaSymbol* _tmp8_;
		ValaSymbol* _tmp9_;
		_tmp3_ = sym;
		if (!(_tmp3_ != NULL)) {
			break;
		}
		_tmp4_ = sym;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_TYPESYMBOL)) {
			ValaSymbol* _tmp5_;
			_tmp5_ = sym;
			result = G_TYPE_CHECK_INSTANCE_CAST (_tmp5_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
			_vala_code_node_unref0 (sym);
			return result;
		}
		_tmp6_ = sym;
		_tmp7_ = vala_symbol_get_parent_symbol (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = _vala_code_node_ref0 (_tmp8_);
		_vala_code_node_unref0 (sym);
		sym = _tmp9_;
	}
	result = NULL;
	_vala_code_node_unref0 (sym);
	return result;
}


ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self) {
	ValaClass* result;
	ValaTypeSymbol* _tmp0_;
	ValaTypeSymbol* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_get_current_type_symbol (self);
	_tmp1_ = _tmp0_;
	result = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp1_) : NULL;
	return result;
}


ValaMethod* vala_ccode_base_module_get_current_method (ValaCCodeBaseModule* self) {
	ValaMethod* result;
	ValaSymbol* sym = NULL;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (_tmp1_);
	sym = _tmp2_;
	while (TRUE) {
		ValaSymbol* _tmp3_;
		ValaSymbol* _tmp4_;
		ValaSymbol* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		_tmp3_ = sym;
		if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_BLOCK)) {
			break;
		}
		_tmp4_ = sym;
		_tmp5_ = vala_symbol_get_parent_symbol (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = _vala_code_node_ref0 (_tmp6_);
		_vala_code_node_unref0 (sym);
		sym = _tmp7_;
	}
	_tmp8_ = sym;
	result = G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp8_) : NULL;
	_vala_code_node_unref0 (sym);
	return result;
}


ValaPropertyAccessor* vala_ccode_base_module_get_current_property_accessor (ValaCCodeBaseModule* self) {
	ValaPropertyAccessor* result;
	ValaSymbol* sym = NULL;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (_tmp1_);
	sym = _tmp2_;
	while (TRUE) {
		ValaSymbol* _tmp3_;
		ValaSymbol* _tmp4_;
		ValaSymbol* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		_tmp3_ = sym;
		if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_BLOCK)) {
			break;
		}
		_tmp4_ = sym;
		_tmp5_ = vala_symbol_get_parent_symbol (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = _vala_code_node_ref0 (_tmp6_);
		_vala_code_node_unref0 (sym);
		sym = _tmp7_;
	}
	_tmp8_ = sym;
	result = G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_PROPERTY_ACCESSOR) ? ((ValaPropertyAccessor*) _tmp8_) : NULL;
	_vala_code_node_unref0 (sym);
	return result;
}


ValaConstructor* vala_ccode_base_module_get_current_constructor (ValaCCodeBaseModule* self) {
	ValaConstructor* result;
	ValaSymbol* sym = NULL;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (_tmp1_);
	sym = _tmp2_;
	while (TRUE) {
		ValaSymbol* _tmp3_;
		ValaSymbol* _tmp4_;
		ValaSymbol* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		_tmp3_ = sym;
		if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_BLOCK)) {
			break;
		}
		_tmp4_ = sym;
		_tmp5_ = vala_symbol_get_parent_symbol (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = _vala_code_node_ref0 (_tmp6_);
		_vala_code_node_unref0 (sym);
		sym = _tmp7_;
	}
	_tmp8_ = sym;
	result = G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_CONSTRUCTOR) ? ((ValaConstructor*) _tmp8_) : NULL;
	_vala_code_node_unref0 (sym);
	return result;
}


ValaDestructor* vala_ccode_base_module_get_current_destructor (ValaCCodeBaseModule* self) {
	ValaDestructor* result;
	ValaSymbol* sym = NULL;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp8_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (_tmp1_);
	sym = _tmp2_;
	while (TRUE) {
		ValaSymbol* _tmp3_;
		ValaSymbol* _tmp4_;
		ValaSymbol* _tmp5_;
		ValaSymbol* _tmp6_;
		ValaSymbol* _tmp7_;
		_tmp3_ = sym;
		if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_BLOCK)) {
			break;
		}
		_tmp4_ = sym;
		_tmp5_ = vala_symbol_get_parent_symbol (_tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = _vala_code_node_ref0 (_tmp6_);
		_vala_code_node_unref0 (sym);
		sym = _tmp7_;
	}
	_tmp8_ = sym;
	result = G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_DESTRUCTOR) ? ((ValaDestructor*) _tmp8_) : NULL;
	_vala_code_node_unref0 (sym);
	return result;
}


ValaDataType* vala_ccode_base_module_get_current_return_type (ValaCCodeBaseModule* self) {
	ValaDataType* result;
	ValaMethod* m = NULL;
	ValaMethod* _tmp0_;
	ValaMethod* _tmp1_;
	ValaMethod* _tmp2_;
	ValaMethod* _tmp3_;
	ValaPropertyAccessor* acc = NULL;
	ValaPropertyAccessor* _tmp7_;
	ValaPropertyAccessor* _tmp8_;
	ValaPropertyAccessor* _tmp9_;
	ValaPropertyAccessor* _tmp10_;
	gboolean _tmp18_ = FALSE;
	gboolean _tmp19_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_get_current_method (self);
	_tmp1_ = _tmp0_;
	_tmp2_ = _vala_code_node_ref0 (_tmp1_);
	m = _tmp2_;
	_tmp3_ = m;
	if (_tmp3_ != NULL) {
		ValaMethod* _tmp4_;
		ValaDataType* _tmp5_;
		ValaDataType* _tmp6_;
		_tmp4_ = m;
		_tmp5_ = vala_callable_get_return_type ((ValaCallable*) _tmp4_);
		_tmp6_ = _tmp5_;
		result = _tmp6_;
		_vala_code_node_unref0 (m);
		return result;
	}
	_tmp7_ = vala_ccode_base_module_get_current_property_accessor (self);
	_tmp8_ = _tmp7_;
	_tmp9_ = _vala_code_node_ref0 (_tmp8_);
	acc = _tmp9_;
	_tmp10_ = acc;
	if (_tmp10_ != NULL) {
		ValaPropertyAccessor* _tmp11_;
		gboolean _tmp12_;
		gboolean _tmp13_;
		_tmp11_ = acc;
		_tmp12_ = vala_property_accessor_get_readable (_tmp11_);
		_tmp13_ = _tmp12_;
		if (_tmp13_) {
			ValaPropertyAccessor* _tmp14_;
			ValaDataType* _tmp15_;
			ValaDataType* _tmp16_;
			_tmp14_ = acc;
			_tmp15_ = vala_property_accessor_get_value_type (_tmp14_);
			_tmp16_ = _tmp15_;
			result = _tmp16_;
			_vala_code_node_unref0 (acc);
			_vala_code_node_unref0 (m);
			return result;
		} else {
			ValaDataType* _tmp17_;
			_tmp17_ = self->void_type;
			result = _tmp17_;
			_vala_code_node_unref0 (acc);
			_vala_code_node_unref0 (m);
			return result;
		}
	}
	_tmp19_ = vala_ccode_base_module_is_in_constructor (self);
	if (_tmp19_) {
		_tmp18_ = TRUE;
	} else {
		gboolean _tmp20_;
		_tmp20_ = vala_ccode_base_module_is_in_destructor (self);
		_tmp18_ = _tmp20_;
	}
	if (_tmp18_) {
		ValaDataType* _tmp21_;
		_tmp21_ = self->void_type;
		result = _tmp21_;
		_vala_code_node_unref0 (acc);
		_vala_code_node_unref0 (m);
		return result;
	}
	result = NULL;
	_vala_code_node_unref0 (acc);
	_vala_code_node_unref0 (m);
	return result;
}


ValaBlock* vala_ccode_base_module_get_current_closure_block (ValaCCodeBaseModule* self) {
	ValaBlock* result;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaBlock* _tmp2_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_ccode_base_module_get_current_symbol (self);
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_ccode_base_module_next_closure_block (self, _tmp1_);
	result = _tmp2_;
	return result;
}


ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self) {
	ValaCCodeFunction* result;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaCCodeFunction* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->ccode;
	result = _tmp1_;
	return result;
}


ValaArrayList* vala_ccode_base_module_get_temp_ref_values (ValaCCodeBaseModule* self) {
	ValaArrayList* result;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaArrayList* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->temp_ref_values;
	result = _tmp1_;
	return result;
}


gint vala_ccode_base_module_get_next_temp_var_id (ValaCCodeBaseModule* self) {
	gint result;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	gint _tmp1_;
	g_return_val_if_fail (self != NULL, 0);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->next_temp_var_id;
	result = _tmp1_;
	return result;
}


void vala_ccode_base_module_set_next_temp_var_id (ValaCCodeBaseModule* self, gint value) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	gint _tmp1_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = value;
	_tmp0_->next_temp_var_id = _tmp1_;
}


gboolean vala_ccode_base_module_get_in_creation_method (ValaCCodeBaseModule* self) {
	gboolean result;
	ValaMethod* _tmp0_;
	ValaMethod* _tmp1_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = vala_ccode_base_module_get_current_method (self);
	_tmp1_ = _tmp0_;
	result = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CREATION_METHOD);
	return result;
}


gboolean vala_ccode_base_module_get_current_method_inner_error (ValaCCodeBaseModule* self) {
	gboolean result;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	gboolean _tmp1_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->current_method_inner_error;
	result = _tmp1_;
	return result;
}


void vala_ccode_base_module_set_current_method_inner_error (ValaCCodeBaseModule* self, gboolean value) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	gboolean _tmp1_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = value;
	_tmp0_->current_method_inner_error = _tmp1_;
}


gboolean vala_ccode_base_module_get_current_method_return (ValaCCodeBaseModule* self) {
	gboolean result;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	gboolean _tmp1_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->current_method_return;
	result = _tmp1_;
	return result;
}


void vala_ccode_base_module_set_current_method_return (ValaCCodeBaseModule* self, gboolean value) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	gboolean _tmp1_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = value;
	_tmp0_->current_method_return = _tmp1_;
}


ValaMap* vala_ccode_base_module_get_variable_name_map (ValaCCodeBaseModule* self) {
	ValaMap* result;
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	ValaMap* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->emit_context;
	_tmp1_ = _tmp0_->variable_name_map;
	result = _tmp1_;
	return result;
}


ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_construct (GType object_type, ValaSymbol* symbol) {
	ValaCCodeBaseModuleEmitContext* self = NULL;
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	self = (ValaCCodeBaseModuleEmitContext*) g_type_create_instance (object_type);
	_tmp0_ = symbol;
	_tmp1_ = _vala_code_node_ref0 (_tmp0_);
	_vala_code_node_unref0 (self->current_symbol);
	self->current_symbol = _tmp1_;
	return self;
}


ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_new (ValaSymbol* symbol) {
	return vala_ccode_base_module_emit_context_construct (VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, symbol);
}


void vala_ccode_base_module_emit_context_push_symbol (ValaCCodeBaseModuleEmitContext* self, ValaSymbol* symbol) {
	ValaArrayList* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaSymbol* _tmp2_;
	ValaSymbol* _tmp3_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (symbol != NULL);
	_tmp0_ = self->symbol_stack;
	_tmp1_ = self->current_symbol;
	vala_collection_add ((ValaCollection*) _tmp0_, _tmp1_);
	_tmp2_ = symbol;
	_tmp3_ = _vala_code_node_ref0 (_tmp2_);
	_vala_code_node_unref0 (self->current_symbol);
	self->current_symbol = _tmp3_;
}


void vala_ccode_base_module_emit_context_pop_symbol (ValaCCodeBaseModuleEmitContext* self) {
	ValaArrayList* _tmp0_;
	ValaArrayList* _tmp1_;
	gint _tmp2_;
	gint _tmp3_;
	gpointer _tmp4_;
	ValaArrayList* _tmp5_;
	ValaArrayList* _tmp6_;
	gint _tmp7_;
	gint _tmp8_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->symbol_stack;
	_tmp1_ = self->symbol_stack;
	_tmp2_ = vala_collection_get_size ((ValaCollection*) _tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_list_get ((ValaList*) _tmp0_, _tmp3_ - 1);
	_vala_code_node_unref0 (self->current_symbol);
	self->current_symbol = (ValaSymbol*) _tmp4_;
	_tmp5_ = self->symbol_stack;
	_tmp6_ = self->symbol_stack;
	_tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);
	_tmp8_ = _tmp7_;
	vala_list_remove_at ((ValaList*) _tmp5_, _tmp8_ - 1);
}


static void vala_ccode_base_module_value_emit_context_init (GValue* value) {
	value->data[0].v_pointer = NULL;
}


static void vala_ccode_base_module_value_emit_context_free_value (GValue* value) {
	if (value->data[0].v_pointer) {
		vala_ccode_base_module_emit_context_unref (value->data[0].v_pointer);
	}
}


static void vala_ccode_base_module_value_emit_context_copy_value (const GValue* src_value, GValue* dest_value) {
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = vala_ccode_base_module_emit_context_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}


static gpointer vala_ccode_base_module_value_emit_context_peek_pointer (const GValue* value) {
	return value->data[0].v_pointer;
}


static gchar* vala_ccode_base_module_value_emit_context_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	if (collect_values[0].v_pointer) {
		ValaCCodeBaseModuleEmitContext * object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = vala_ccode_base_module_emit_context_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}


static gchar* vala_ccode_base_module_value_emit_context_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	ValaCCodeBaseModuleEmitContext ** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = vala_ccode_base_module_emit_context_ref (value->data[0].v_pointer);
	}
	return NULL;
}


GParamSpec* vala_ccode_base_module_param_spec_emit_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
	ValaCCodeBaseModuleParamSpecEmitContext* spec;
	g_return_val_if_fail (g_type_is_a (object_type, VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}


gpointer vala_ccode_base_module_value_get_emit_context (const GValue* value) {
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT), NULL);
	return value->data[0].v_pointer;
}


void vala_ccode_base_module_value_set_emit_context (GValue* value, gpointer v_object) {
	ValaCCodeBaseModuleEmitContext * old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		vala_ccode_base_module_emit_context_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		vala_ccode_base_module_emit_context_unref (old);
	}
}


void vala_ccode_base_module_value_take_emit_context (GValue* value, gpointer v_object) {
	ValaCCodeBaseModuleEmitContext * old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		vala_ccode_base_module_emit_context_unref (old);
	}
}


static void vala_ccode_base_module_emit_context_class_init (ValaCCodeBaseModuleEmitContextClass * klass) {
	vala_ccode_base_module_emit_context_parent_class = g_type_class_peek_parent (klass);
	((ValaCCodeBaseModuleEmitContextClass *) klass)->finalize = vala_ccode_base_module_emit_context_finalize;
}


static void vala_ccode_base_module_emit_context_instance_init (ValaCCodeBaseModuleEmitContext * self) {
	GEqualFunc _tmp0_;
	ValaArrayList* _tmp1_;
	GEqualFunc _tmp2_;
	ValaArrayList* _tmp3_;
	GEqualFunc _tmp4_;
	ValaArrayList* _tmp5_;
	GHashFunc _tmp6_;
	GEqualFunc _tmp7_;
	GEqualFunc _tmp8_;
	ValaHashMap* _tmp9_;
	GHashFunc _tmp10_;
	GEqualFunc _tmp11_;
	GEqualFunc _tmp12_;
	ValaHashMap* _tmp13_;
	GHashFunc _tmp14_;
	GEqualFunc _tmp15_;
	GEqualFunc _tmp16_;
	ValaHashMap* _tmp17_;
	_tmp0_ = g_direct_equal;
	_tmp1_ = vala_array_list_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp0_);
	self->symbol_stack = _tmp1_;
	_tmp2_ = g_direct_equal;
	_tmp3_ = vala_array_list_new (VALA_TYPE_CCODE_FUNCTION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp2_);
	self->ccode_stack = _tmp3_;
	_tmp4_ = g_direct_equal;
	_tmp5_ = vala_array_list_new (VALA_TYPE_TARGET_VALUE, (GBoxedCopyFunc) vala_target_value_ref, (GDestroyNotify) vala_target_value_unref, _tmp4_);
	self->temp_ref_values = _tmp5_;
	_tmp6_ = g_str_hash;
	_tmp7_ = g_str_equal;
	_tmp8_ = g_direct_equal;
	_tmp9_ = vala_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp6_, _tmp7_, _tmp8_);
	self->variable_name_map = (ValaMap*) _tmp9_;
	_tmp10_ = g_str_hash;
	_tmp11_ = g_str_equal;
	_tmp12_ = g_direct_equal;
	_tmp13_ = vala_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, G_TYPE_INT, NULL, NULL, _tmp10_, _tmp11_, _tmp12_);
	self->closure_variable_count_map = (ValaMap*) _tmp13_;
	_tmp14_ = g_direct_hash;
	_tmp15_ = g_direct_equal;
	_tmp16_ = g_direct_equal;
	_tmp17_ = vala_hash_map_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, G_TYPE_INT, NULL, NULL, _tmp14_, _tmp15_, _tmp16_);
	self->closure_variable_clash_map = (ValaMap*) _tmp17_;
	self->next_coroutine_state = 1;
	self->ref_count = 1;
}


static void vala_ccode_base_module_emit_context_finalize (ValaCCodeBaseModuleEmitContext * obj) {
	ValaCCodeBaseModuleEmitContext * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContext);
	g_signal_handlers_destroy (self);
	_vala_code_node_unref0 (self->current_symbol);
	_vala_iterable_unref0 (self->symbol_stack);
	_vala_code_node_unref0 (self->current_try);
	_vala_code_node_unref0 (self->current_catch);
	_vala_ccode_node_unref0 (self->ccode);
	_vala_iterable_unref0 (self->ccode_stack);
	_vala_iterable_unref0 (self->temp_ref_values);
	_vala_map_unref0 (self->variable_name_map);
	_vala_map_unref0 (self->closure_variable_count_map);
	_vala_map_unref0 (self->closure_variable_clash_map);
}


GType vala_ccode_base_module_emit_context_get_type (void) {
	static volatile gsize vala_ccode_base_module_emit_context_type_id__volatile = 0;
	if (g_once_init_enter (&vala_ccode_base_module_emit_context_type_id__volatile)) {
		static const GTypeValueTable g_define_type_value_table = { vala_ccode_base_module_value_emit_context_init, vala_ccode_base_module_value_emit_context_free_value, vala_ccode_base_module_value_emit_context_copy_value, vala_ccode_base_module_value_emit_context_peek_pointer, "p", vala_ccode_base_module_value_emit_context_collect_value, "p", vala_ccode_base_module_value_emit_context_lcopy_value };
		static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeBaseModuleEmitContextClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_base_module_emit_context_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeBaseModuleEmitContext), 0, (GInstanceInitFunc) vala_ccode_base_module_emit_context_instance_init, &g_define_type_value_table };
		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
		GType vala_ccode_base_module_emit_context_type_id;
		vala_ccode_base_module_emit_context_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaCCodeBaseModuleEmitContext", &g_define_type_info, &g_define_type_fundamental_info, 0);
		g_once_init_leave (&vala_ccode_base_module_emit_context_type_id__volatile, vala_ccode_base_module_emit_context_type_id);
	}
	return vala_ccode_base_module_emit_context_type_id__volatile;
}


gpointer vala_ccode_base_module_emit_context_ref (gpointer instance) {
	ValaCCodeBaseModuleEmitContext * self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}


void vala_ccode_base_module_emit_context_unref (gpointer instance) {
	ValaCCodeBaseModuleEmitContext * self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}


static void vala_ccode_base_module_class_init (ValaCCodeBaseModuleClass * klass) {
	gint _tmp0_;
	vala_ccode_base_module_parent_class = g_type_class_peek_parent (klass);
	((ValaCodeVisitorClass *) klass)->finalize = vala_ccode_base_module_finalize;
	g_type_class_add_private (klass, sizeof (ValaCCodeBaseModulePrivate));
	((ValaCodeGeneratorClass *) klass)->emit = (void (*) (ValaCodeGenerator *, ValaCodeContext*)) vala_ccode_base_module_real_emit;
	((ValaCCodeBaseModuleClass *) klass)->append_vala_array_free = (void (*) (ValaCCodeBaseModule *)) vala_ccode_base_module_real_append_vala_array_free;
	((ValaCCodeBaseModuleClass *) klass)->append_vala_array_move = (void (*) (ValaCCodeBaseModule *)) vala_ccode_base_module_real_append_vala_array_move;
	((ValaCCodeBaseModuleClass *) klass)->append_vala_array_length = (void (*) (ValaCCodeBaseModule *)) vala_ccode_base_module_real_append_vala_array_length;
	((ValaCodeVisitorClass *) klass)->visit_source_file = (void (*) (ValaCodeVisitor *, ValaSourceFile*)) vala_ccode_base_module_real_visit_source_file;
	((ValaCCodeBaseModuleClass *) klass)->generate_enum_declaration = (gboolean (*) (ValaCCodeBaseModule *, ValaEnum*, ValaCCodeFile*)) vala_ccode_base_module_real_generate_enum_declaration;
	((ValaCodeVisitorClass *) klass)->visit_enum = (void (*) (ValaCodeVisitor *, ValaEnum*)) vala_ccode_base_module_real_visit_enum;
	((ValaCodeVisitorClass *) klass)->visit_constant = (void (*) (ValaCodeVisitor *, ValaConstant*)) vala_ccode_base_module_real_visit_constant;
	((ValaCodeVisitorClass *) klass)->visit_field = (void (*) (ValaCodeVisitor *, ValaField*)) vala_ccode_base_module_real_visit_field;
	((ValaCodeVisitorClass *) klass)->visit_formal_parameter = (void (*) (ValaCodeVisitor *, ValaParameter*)) vala_ccode_base_module_real_visit_formal_parameter;
	((ValaCodeVisitorClass *) klass)->visit_property = (void (*) (ValaCodeVisitor *, ValaProperty*)) vala_ccode_base_module_real_visit_property;
	((ValaCCodeBaseModuleClass *) klass)->generate_class_struct_declaration = (void (*) (ValaCCodeBaseModule *, ValaClass*, ValaCCodeFile*)) vala_ccode_base_module_real_generate_class_struct_declaration;
	((ValaCCodeBaseModuleClass *) klass)->generate_struct_declaration = (void (*) (ValaCCodeBaseModule *, ValaStruct*, ValaCCodeFile*)) vala_ccode_base_module_real_generate_struct_declaration;
	((ValaCCodeBaseModuleClass *) klass)->generate_delegate_declaration = (void (*) (ValaCCodeBaseModule *, ValaDelegate*, ValaCCodeFile*)) vala_ccode_base_module_real_generate_delegate_declaration;
	((ValaCCodeBaseModuleClass *) klass)->generate_cparameters = (void (*) (ValaCCodeBaseModule *, ValaMethod*, ValaCCodeFile*, ValaMap*, ValaCCodeFunction*, ValaCCodeFunctionDeclarator*, ValaMap*, ValaCCodeFunctionCall*, gint)) vala_ccode_base_module_real_generate_cparameters;
	((ValaCodeVisitorClass *) klass)->visit_property_accessor = (void (*) (ValaCodeVisitor *, ValaPropertyAccessor*)) vala_ccode_base_module_real_visit_property_accessor;
	((ValaCodeVisitorClass *) klass)->visit_destructor = (void (*) (ValaCodeVisitor *, ValaDestructor*)) vala_ccode_base_module_real_visit_destructor;
	((ValaCodeVisitorClass *) klass)->visit_block = (void (*) (ValaCodeVisitor *, ValaBlock*)) vala_ccode_base_module_real_visit_block;
	((ValaCodeVisitorClass *) klass)->visit_declaration_statement = (void (*) (ValaCodeVisitor *, ValaDeclarationStatement*)) vala_ccode_base_module_real_visit_declaration_statement;
	((ValaCodeVisitorClass *) klass)->visit_local_variable = (void (*) (ValaCodeVisitor *, ValaLocalVariable*)) vala_ccode_base_module_real_visit_local_variable;
	((ValaCodeVisitorClass *) klass)->visit_initializer_list = (void (*) (ValaCodeVisitor *, ValaInitializerList*)) vala_ccode_base_module_real_visit_initializer_list;
	((ValaCCodeBaseModuleClass *) klass)->get_dup_func_expression = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaDataType*, ValaSourceReference*, gboolean)) vala_ccode_base_module_real_get_dup_func_expression;
	((ValaCCodeBaseModuleClass *) klass)->append_struct_array_free = (gchar* (*) (ValaCCodeBaseModule *, ValaStruct*)) vala_ccode_base_module_real_append_struct_array_free;
	((ValaCCodeBaseModuleClass *) klass)->destroy_value = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaTargetValue*, gboolean)) vala_ccode_base_module_real_destroy_value;
	((ValaCodeVisitorClass *) klass)->visit_end_full_expression = (void (*) (ValaCodeVisitor *, ValaExpression*)) vala_ccode_base_module_real_visit_end_full_expression;
	((ValaCodeVisitorClass *) klass)->visit_expression_statement = (void (*) (ValaCodeVisitor *, ValaExpressionStatement*)) vala_ccode_base_module_real_visit_expression_statement;
	((ValaCCodeBaseModuleClass *) klass)->append_scope_free = (void (*) (ValaCCodeBaseModule *, ValaSymbol*, ValaCodeNode*)) vala_ccode_base_module_real_append_scope_free;
	((ValaCodeVisitorClass *) klass)->visit_return_statement = (void (*) (ValaCodeVisitor *, ValaReturnStatement*)) vala_ccode_base_module_real_visit_return_statement;
	((ValaCodeVisitorClass *) klass)->visit_lock_statement = (void (*) (ValaCodeVisitor *, ValaLockStatement*)) vala_ccode_base_module_real_visit_lock_statement;
	((ValaCodeVisitorClass *) klass)->visit_unlock_statement = (void (*) (ValaCodeVisitor *, ValaUnlockStatement*)) vala_ccode_base_module_real_visit_unlock_statement;
	((ValaCodeVisitorClass *) klass)->visit_delete_statement = (void (*) (ValaCodeVisitor *, ValaDeleteStatement*)) vala_ccode_base_module_real_visit_delete_statement;
	((ValaCodeVisitorClass *) klass)->visit_expression = (void (*) (ValaCodeVisitor *, ValaExpression*)) vala_ccode_base_module_real_visit_expression;
	((ValaCodeVisitorClass *) klass)->visit_boolean_literal = (void (*) (ValaCodeVisitor *, ValaBooleanLiteral*)) vala_ccode_base_module_real_visit_boolean_literal;
	((ValaCodeVisitorClass *) klass)->visit_character_literal = (void (*) (ValaCodeVisitor *, ValaCharacterLiteral*)) vala_ccode_base_module_real_visit_character_literal;
	((ValaCodeVisitorClass *) klass)->visit_integer_literal = (void (*) (ValaCodeVisitor *, ValaIntegerLiteral*)) vala_ccode_base_module_real_visit_integer_literal;
	((ValaCodeVisitorClass *) klass)->visit_real_literal = (void (*) (ValaCodeVisitor *, ValaRealLiteral*)) vala_ccode_base_module_real_visit_real_literal;
	((ValaCodeVisitorClass *) klass)->visit_string_literal = (void (*) (ValaCodeVisitor *, ValaStringLiteral*)) vala_ccode_base_module_real_visit_string_literal;
	((ValaCodeVisitorClass *) klass)->visit_regex_literal = (void (*) (ValaCodeVisitor *, ValaRegexLiteral*)) vala_ccode_base_module_real_visit_regex_literal;
	((ValaCodeVisitorClass *) klass)->visit_null_literal = (void (*) (ValaCodeVisitor *, ValaNullLiteral*)) vala_ccode_base_module_real_visit_null_literal;
	((ValaCCodeBaseModuleClass *) klass)->get_local_cvalue = (ValaTargetValue* (*) (ValaCCodeBaseModule *, ValaLocalVariable*)) vala_ccode_base_module_real_get_local_cvalue;
	((ValaCCodeBaseModuleClass *) klass)->get_parameter_cvalue = (ValaTargetValue* (*) (ValaCCodeBaseModule *, ValaParameter*)) vala_ccode_base_module_real_get_parameter_cvalue;
	((ValaCCodeBaseModuleClass *) klass)->get_field_cvalue = (ValaTargetValue* (*) (ValaCCodeBaseModule *, ValaField*, ValaTargetValue*)) vala_ccode_base_module_real_get_field_cvalue;
	((ValaCCodeBaseModuleClass *) klass)->load_variable = (ValaTargetValue* (*) (ValaCCodeBaseModule *, ValaVariable*, ValaTargetValue*)) vala_ccode_base_module_real_load_variable;
	((ValaCCodeBaseModuleClass *) klass)->load_this_parameter = (ValaTargetValue* (*) (ValaCCodeBaseModule *, ValaTypeSymbol*)) vala_ccode_base_module_real_load_this_parameter;
	((ValaCCodeBaseModuleClass *) klass)->store_value = (void (*) (ValaCCodeBaseModule *, ValaTargetValue*, ValaTargetValue*)) vala_ccode_base_module_real_store_value;
	((ValaCCodeBaseModuleClass *) klass)->get_delegate_target_cname = (gchar* (*) (ValaCCodeBaseModule *, const gchar*)) vala_ccode_base_module_real_get_delegate_target_cname;
	((ValaCCodeBaseModuleClass *) klass)->get_delegate_target_cexpression = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaExpression*, ValaCCodeExpression* *)) vala_ccode_base_module_real_get_delegate_target_cexpression;
	((ValaCCodeBaseModuleClass *) klass)->get_delegate_target_cvalue = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaTargetValue*)) vala_ccode_base_module_real_get_delegate_target_cvalue;
	((ValaCCodeBaseModuleClass *) klass)->get_delegate_target_destroy_notify_cvalue = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaTargetValue*)) vala_ccode_base_module_real_get_delegate_target_destroy_notify_cvalue;
	((ValaCCodeBaseModuleClass *) klass)->get_delegate_target_destroy_notify_cname = (gchar* (*) (ValaCCodeBaseModule *, const gchar*)) vala_ccode_base_module_real_get_delegate_target_destroy_notify_cname;
	((ValaCodeVisitorClass *) klass)->visit_base_access = (void (*) (ValaCodeVisitor *, ValaBaseAccess*)) vala_ccode_base_module_real_visit_base_access;
	((ValaCodeVisitorClass *) klass)->visit_postfix_expression = (void (*) (ValaCodeVisitor *, ValaPostfixExpression*)) vala_ccode_base_module_real_visit_postfix_expression;
	((ValaCCodeBaseModuleClass *) klass)->copy_value = (ValaTargetValue* (*) (ValaCCodeBaseModule *, ValaTargetValue*, ValaCodeNode*)) vala_ccode_base_module_real_copy_value;
	((ValaCCodeBaseModuleClass *) klass)->generate_class_declaration = (void (*) (ValaCCodeBaseModule *, ValaClass*, ValaCCodeFile*)) vala_ccode_base_module_real_generate_class_declaration;
	((ValaCCodeBaseModuleClass *) klass)->generate_interface_declaration = (void (*) (ValaCCodeBaseModule *, ValaInterface*, ValaCCodeFile*)) vala_ccode_base_module_real_generate_interface_declaration;
	((ValaCCodeBaseModuleClass *) klass)->generate_method_declaration = (void (*) (ValaCCodeBaseModule *, ValaMethod*, ValaCCodeFile*)) vala_ccode_base_module_real_generate_method_declaration;
	((ValaCCodeBaseModuleClass *) klass)->generate_error_domain_declaration = (void (*) (ValaCCodeBaseModule *, ValaErrorDomain*, ValaCCodeFile*)) vala_ccode_base_module_real_generate_error_domain_declaration;
	((ValaCodeVisitorClass *) klass)->visit_object_creation_expression = (void (*) (ValaCodeVisitor *, ValaObjectCreationExpression*)) vala_ccode_base_module_real_visit_object_creation_expression;
	((ValaCodeVisitorClass *) klass)->visit_sizeof_expression = (void (*) (ValaCodeVisitor *, ValaSizeofExpression*)) vala_ccode_base_module_real_visit_sizeof_expression;
	((ValaCodeVisitorClass *) klass)->visit_typeof_expression = (void (*) (ValaCodeVisitor *, ValaTypeofExpression*)) vala_ccode_base_module_real_visit_typeof_expression;
	((ValaCodeVisitorClass *) klass)->visit_unary_expression = (void (*) (ValaCodeVisitor *, ValaUnaryExpression*)) vala_ccode_base_module_real_visit_unary_expression;
	((ValaCCodeBaseModuleClass *) klass)->deserialize_expression = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaDataType*, ValaCCodeExpression*, ValaCCodeExpression*, ValaCCodeExpression*, gboolean*)) vala_ccode_base_module_real_deserialize_expression;
	((ValaCCodeBaseModuleClass *) klass)->serialize_expression = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaDataType*, ValaCCodeExpression*)) vala_ccode_base_module_real_serialize_expression;
	((ValaCodeVisitorClass *) klass)->visit_cast_expression = (void (*) (ValaCodeVisitor *, ValaCastExpression*)) vala_ccode_base_module_real_visit_cast_expression;
	((ValaCodeVisitorClass *) klass)->visit_named_argument = (void (*) (ValaCodeVisitor *, ValaNamedArgument*)) vala_ccode_base_module_real_visit_named_argument;
	((ValaCodeVisitorClass *) klass)->visit_pointer_indirection = (void (*) (ValaCodeVisitor *, ValaPointerIndirection*)) vala_ccode_base_module_real_visit_pointer_indirection;
	((ValaCodeVisitorClass *) klass)->visit_addressof_expression = (void (*) (ValaCodeVisitor *, ValaAddressofExpression*)) vala_ccode_base_module_real_visit_addressof_expression;
	((ValaCodeVisitorClass *) klass)->visit_reference_transfer_expression = (void (*) (ValaCodeVisitor *, ValaReferenceTransferExpression*)) vala_ccode_base_module_real_visit_reference_transfer_expression;
	((ValaCodeVisitorClass *) klass)->visit_binary_expression = (void (*) (ValaCodeVisitor *, ValaBinaryExpression*)) vala_ccode_base_module_real_visit_binary_expression;
	((ValaCodeVisitorClass *) klass)->visit_type_check = (void (*) (ValaCodeVisitor *, ValaTypeCheck*)) vala_ccode_base_module_real_visit_type_check;
	((ValaCodeVisitorClass *) klass)->visit_lambda_expression = (void (*) (ValaCodeVisitor *, ValaLambdaExpression*)) vala_ccode_base_module_real_visit_lambda_expression;
	((ValaCCodeBaseModuleClass *) klass)->get_implicit_cast_expression = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaCCodeExpression*, ValaDataType*, ValaDataType*, ValaCodeNode*)) vala_ccode_base_module_real_get_implicit_cast_expression;
	((ValaCCodeBaseModuleClass *) klass)->create_type_check_statement = (void (*) (ValaCCodeBaseModule *, ValaCodeNode*, ValaDataType*, ValaTypeSymbol*, gboolean, const gchar*)) vala_ccode_base_module_real_create_type_check_statement;
	((ValaCodeVisitorClass *) klass)->visit_class = (void (*) (ValaCodeVisitor *, ValaClass*)) vala_ccode_base_module_real_visit_class;
	((ValaCCodeBaseModuleClass *) klass)->is_gobject_property = (gboolean (*) (ValaCCodeBaseModule *, ValaProperty*)) vala_ccode_base_module_real_is_gobject_property;
	((ValaCCodeBaseModuleClass *) klass)->generate_dynamic_method_wrapper = (void (*) (ValaCCodeBaseModule *, ValaDynamicMethod*)) vala_ccode_base_module_real_generate_dynamic_method_wrapper;
	((ValaCCodeBaseModuleClass *) klass)->method_has_wrapper = (gboolean (*) (ValaCCodeBaseModule *, ValaMethod*)) vala_ccode_base_module_real_method_has_wrapper;
	((ValaCCodeBaseModuleClass *) klass)->get_param_spec = (ValaCCodeFunctionCall* (*) (ValaCCodeBaseModule *, ValaProperty*)) vala_ccode_base_module_real_get_param_spec;
	((ValaCCodeBaseModuleClass *) klass)->get_signal_creation = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaSignal*, ValaTypeSymbol*)) vala_ccode_base_module_real_get_signal_creation;
	((ValaCCodeBaseModuleClass *) klass)->register_dbus_info = (void (*) (ValaCCodeBaseModule *, ValaCCodeBlock*, ValaObjectTypeSymbol*)) vala_ccode_base_module_real_register_dbus_info;
	((ValaCCodeBaseModuleClass *) klass)->get_dynamic_property_getter_cname = (gchar* (*) (ValaCCodeBaseModule *, ValaDynamicProperty*)) vala_ccode_base_module_real_get_dynamic_property_getter_cname;
	((ValaCCodeBaseModuleClass *) klass)->get_dynamic_property_setter_cname = (gchar* (*) (ValaCCodeBaseModule *, ValaDynamicProperty*)) vala_ccode_base_module_real_get_dynamic_property_setter_cname;
	((ValaCCodeBaseModuleClass *) klass)->get_dynamic_signal_cname = (gchar* (*) (ValaCCodeBaseModule *, ValaDynamicSignal*)) vala_ccode_base_module_real_get_dynamic_signal_cname;
	((ValaCCodeBaseModuleClass *) klass)->get_dynamic_signal_connect_wrapper_name = (gchar* (*) (ValaCCodeBaseModule *, ValaDynamicSignal*)) vala_ccode_base_module_real_get_dynamic_signal_connect_wrapper_name;
	((ValaCCodeBaseModuleClass *) klass)->get_dynamic_signal_connect_after_wrapper_name = (gchar* (*) (ValaCCodeBaseModule *, ValaDynamicSignal*)) vala_ccode_base_module_real_get_dynamic_signal_connect_after_wrapper_name;
	((ValaCCodeBaseModuleClass *) klass)->get_dynamic_signal_disconnect_wrapper_name = (gchar* (*) (ValaCCodeBaseModule *, ValaDynamicSignal*)) vala_ccode_base_module_real_get_dynamic_signal_disconnect_wrapper_name;
	((ValaCCodeBaseModuleClass *) klass)->get_array_length_cname = (gchar* (*) (ValaCCodeBaseModule *, const gchar*, gint)) vala_ccode_base_module_real_get_array_length_cname;
	((ValaCCodeBaseModuleClass *) klass)->get_parameter_array_length_cname = (gchar* (*) (ValaCCodeBaseModule *, ValaParameter*, gint)) vala_ccode_base_module_real_get_parameter_array_length_cname;
	((ValaCCodeBaseModuleClass *) klass)->get_array_length_cexpression = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaExpression*, gint)) vala_ccode_base_module_real_get_array_length_cexpression;
	((ValaCCodeBaseModuleClass *) klass)->get_array_length_cvalue = (ValaCCodeExpression* (*) (ValaCCodeBaseModule *, ValaTargetValue*, gint)) vala_ccode_base_module_real_get_array_length_cvalue;
	((ValaCCodeBaseModuleClass *) klass)->get_array_size_cname = (gchar* (*) (ValaCCodeBaseModule *, const gchar*)) vala_ccode_base_module_real_get_array_size_cname;
	((ValaCCodeBaseModuleClass *) klass)->add_simple_check = (void (*) (ValaCCodeBaseModule *, ValaCodeNode*, gboolean)) vala_ccode_base_module_real_add_simple_check;
	((ValaCCodeBaseModuleClass *) klass)->generate_ready_function = (gchar* (*) (ValaCCodeBaseModule *, ValaMethod*)) vala_ccode_base_module_real_generate_ready_function;
	_tmp0_ = vala_code_node_get_attribute_cache_index ();
	vala_ccode_base_module_ccode_attribute_cache_index = _tmp0_;
}


static void vala_ccode_base_module_instance_init (ValaCCodeBaseModule * self) {
	ValaCCodeBaseModuleEmitContext* _tmp0_;
	GEqualFunc _tmp1_;
	ValaArrayList* _tmp2_;
	GEqualFunc _tmp3_;
	ValaArrayList* _tmp4_;
	GHashFunc _tmp5_;
	GEqualFunc _tmp6_;
	GEqualFunc _tmp7_;
	ValaHashMap* _tmp8_;
	ValaVoidType* _tmp9_;
	self->priv = VALA_CCODE_BASE_MODULE_GET_PRIVATE (self);
	_tmp0_ = vala_ccode_base_module_emit_context_new (NULL);
	self->emit_context = _tmp0_;
	_tmp1_ = g_direct_equal;
	_tmp2_ = vala_array_list_new (VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, (GBoxedCopyFunc) vala_ccode_base_module_emit_context_ref, (GDestroyNotify) vala_ccode_base_module_emit_context_unref, _tmp1_);
	self->priv->emit_context_stack = (ValaList*) _tmp2_;
	self->current_line = NULL;
	_tmp3_ = g_direct_equal;
	_tmp4_ = vala_array_list_new (VALA_TYPE_CCODE_LINE_DIRECTIVE, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp3_);
	self->priv->line_directive_stack = (ValaList*) _tmp4_;
	self->next_regex_id = 0;
	self->priv->next_block_id = 0;
	_tmp5_ = g_direct_hash;
	_tmp6_ = g_direct_equal;
	_tmp7_ = g_direct_equal;
	_tmp8_ = vala_hash_map_new (VALA_TYPE_BLOCK, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, G_TYPE_INT, NULL, NULL, _tmp5_, _tmp6_, _tmp7_);
	self->priv->block_map = (ValaMap*) _tmp8_;
	_tmp9_ = vala_void_type_new (NULL);
	self->void_type = (ValaDataType*) _tmp9_;
	self->in_plugin = FALSE;
	self->priv->next_variant_function_id = 0;
}


static void vala_ccode_base_module_finalize (ValaCodeVisitor * obj) {
	ValaCCodeBaseModule * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModule);
	_vala_code_context_unref0 (self->priv->_context);
	_vala_code_node_unref0 (self->root_symbol);
	_vala_ccode_base_module_emit_context_unref0 (self->emit_context);
	_vala_iterable_unref0 (self->priv->emit_context_stack);
	_vala_ccode_node_unref0 (self->current_line);
	_vala_iterable_unref0 (self->priv->line_directive_stack);
	_vala_ccode_file_unref0 (self->header_file);
	_vala_ccode_file_unref0 (self->internal_header_file);
	_vala_ccode_file_unref0 (self->cfile);
	_vala_ccode_base_module_emit_context_unref0 (self->class_init_context);
	_vala_ccode_base_module_emit_context_unref0 (self->base_init_context);
	_vala_ccode_base_module_emit_context_unref0 (self->class_finalize_context);
	_vala_ccode_base_module_emit_context_unref0 (self->base_finalize_context);
	_vala_ccode_base_module_emit_context_unref0 (self->instance_init_context);
	_vala_ccode_base_module_emit_context_unref0 (self->instance_finalize_context);
	_vala_ccode_node_unref0 (self->param_spec_struct);
	_vala_ccode_node_unref0 (self->closure_struct);
	_vala_ccode_node_unref0 (self->prop_enum);
	_vala_ccode_node_unref0 (self->signal_enum);
	_vala_iterable_unref0 (self->user_marshal_set);
	_vala_iterable_unref0 (self->predefined_marshal_set);
	_vala_iterable_unref0 (self->priv->reserved_identifiers);
	_vala_map_unref0 (self->priv->block_map);
	_vala_code_node_unref0 (self->void_type);
	_vala_code_node_unref0 (self->bool_type);
	_vala_code_node_unref0 (self->char_type);
	_vala_code_node_unref0 (self->uchar_type);
	_vala_code_node_unref0 (self->unichar_type);
	_vala_code_node_unref0 (self->short_type);
	_vala_code_node_unref0 (self->ushort_type);
	_vala_code_node_unref0 (self->int_type);
	_vala_code_node_unref0 (self->uint_type);
	_vala_code_node_unref0 (self->long_type);
	_vala_code_node_unref0 (self->ulong_type);
	_vala_code_node_unref0 (self->int8_type);
	_vala_code_node_unref0 (self->uint8_type);
	_vala_code_node_unref0 (self->int16_type);
	_vala_code_node_unref0 (self->uint16_type);
	_vala_code_node_unref0 (self->int32_type);
	_vala_code_node_unref0 (self->uint32_type);
	_vala_code_node_unref0 (self->int64_type);
	_vala_code_node_unref0 (self->uint64_type);
	_vala_code_node_unref0 (self->string_type);
	_vala_code_node_unref0 (self->regex_type);
	_vala_code_node_unref0 (self->float_type);
	_vala_code_node_unref0 (self->double_type);
	_vala_code_node_unref0 (self->gtype_type);
	_vala_code_node_unref0 (self->gobject_type);
	_vala_code_node_unref0 (self->gerror_type);
	_vala_code_node_unref0 (self->glist_type);
	_vala_code_node_unref0 (self->gslist_type);
	_vala_code_node_unref0 (self->gnode_type);
	_vala_code_node_unref0 (self->gqueue_type);
	_vala_code_node_unref0 (self->gvaluearray_type);
	_vala_code_node_unref0 (self->gstringbuilder_type);
	_vala_code_node_unref0 (self->garray_type);
	_vala_code_node_unref0 (self->gbytearray_type);
	_vala_code_node_unref0 (self->gptrarray_type);
	_vala_code_node_unref0 (self->gthreadpool_type);
	_vala_code_node_unref0 (self->gdestroynotify_type);
	_vala_code_node_unref0 (self->gquark_type);
	_vala_code_node_unref0 (self->gvalue_type);
	_vala_code_node_unref0 (self->gvariant_type);
	_vala_code_node_unref0 (self->mutex_type);
	_vala_code_node_unref0 (self->gmutex_type);
	_vala_code_node_unref0 (self->grecmutex_type);
	_vala_code_node_unref0 (self->grwlock_type);
	_vala_code_node_unref0 (self->gcond_type);
	_vala_code_node_unref0 (self->gsource_type);
	_vala_code_node_unref0 (self->type_module_type);
	_vala_code_node_unref0 (self->dbus_proxy_type);
	_vala_code_node_unref0 (self->gtk_widget_type);
	_g_free0 (self->module_init_param_name);
	_vala_iterable_unref0 (self->wrappers);
	_vala_iterable_unref0 (self->priv->generated_external_symbols);
	VALA_CODE_VISITOR_CLASS (vala_ccode_base_module_parent_class)->finalize (obj);
}


/**
 * Code visitor generating C Code.
 */
GType vala_ccode_base_module_get_type (void) {
	static volatile gsize vala_ccode_base_module_type_id__volatile = 0;
	if (g_once_init_enter (&vala_ccode_base_module_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeBaseModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_base_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeBaseModule), 0, (GInstanceInitFunc) vala_ccode_base_module_instance_init, NULL };
		GType vala_ccode_base_module_type_id;
		vala_ccode_base_module_type_id = g_type_register_static (VALA_TYPE_CODE_GENERATOR, "ValaCCodeBaseModule", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
		g_once_init_leave (&vala_ccode_base_module_type_id__volatile, vala_ccode_base_module_type_id);
	}
	return vala_ccode_base_module_type_id__volatile;
}


G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue) {
	ValaGLibValue* self = NULL;
	ValaDataType* _tmp0_;
	ValaCCodeExpression* _tmp1_;
	ValaCCodeExpression* _tmp2_;
	gboolean _tmp3_;
	_tmp0_ = value_type;
	self = (ValaGLibValue*) vala_target_value_construct (object_type, _tmp0_);
	_tmp1_ = cvalue;
	_tmp2_ = _vala_ccode_node_ref0 (_tmp1_);
	_vala_ccode_node_unref0 (self->cvalue);
	self->cvalue = _tmp2_;
	_tmp3_ = lvalue;
	self->lvalue = _tmp3_;
	return self;
}


G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue) {
	return vala_glib_value_construct (VALA_TYPE_GLIB_VALUE, value_type, cvalue, lvalue);
}


G_GNUC_INTERNAL void vala_glib_value_append_array_length_cvalue (ValaGLibValue* self, ValaCCodeExpression* length_cvalue) {
	ValaList* _tmp0_;
	ValaList* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (length_cvalue != NULL);
	_tmp0_ = self->array_length_cvalues;
	if (_tmp0_ == NULL) {
		GEqualFunc _tmp1_;
		ValaArrayList* _tmp2_;
		_tmp1_ = g_direct_equal;
		_tmp2_ = vala_array_list_new (VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp1_);
		_vala_iterable_unref0 (self->array_length_cvalues);
		self->array_length_cvalues = (ValaList*) _tmp2_;
	}
	_tmp3_ = self->array_length_cvalues;
	_tmp4_ = length_cvalue;
	vala_collection_add ((ValaCollection*) _tmp3_, _tmp4_);
}


G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_copy (ValaGLibValue* self) {
	ValaGLibValue* result = NULL;
	ValaGLibValue* _result_ = NULL;
	ValaDataType* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaDataType* _tmp3_;
	ValaCCodeExpression* _tmp4_;
	gboolean _tmp5_;
	ValaGLibValue* _tmp6_;
	ValaGLibValue* _tmp7_;
	ValaGLibValue* _tmp8_;
	ValaDataType* _tmp9_;
	ValaDataType* _tmp10_;
	ValaGLibValue* _tmp11_;
	gboolean _tmp12_;
	ValaGLibValue* _tmp13_;
	const gchar* _tmp14_;
	gchar* _tmp15_;
	ValaList* _tmp16_;
	ValaGLibValue* _tmp30_;
	ValaCCodeExpression* _tmp31_;
	ValaCCodeExpression* _tmp32_;
	ValaGLibValue* _tmp33_;
	gboolean _tmp34_;
	ValaGLibValue* _tmp35_;
	ValaCCodeExpression* _tmp36_;
	ValaCCodeExpression* _tmp37_;
	ValaGLibValue* _tmp38_;
	ValaCCodeExpression* _tmp39_;
	ValaCCodeExpression* _tmp40_;
	ValaGLibValue* _tmp41_;
	ValaCCodeExpression* _tmp42_;
	ValaCCodeExpression* _tmp43_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = vala_target_value_get_value_type ((ValaTargetValue*) self);
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_data_type_copy (_tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = self->cvalue;
	_tmp5_ = self->lvalue;
	_tmp6_ = vala_glib_value_new (_tmp3_, _tmp4_, _tmp5_);
	_tmp7_ = _tmp6_;
	_vala_code_node_unref0 (_tmp3_);
	_result_ = _tmp7_;
	_tmp8_ = _result_;
	_tmp9_ = vala_target_value_get_actual_value_type ((ValaTargetValue*) self);
	_tmp10_ = _tmp9_;
	vala_target_value_set_actual_value_type ((ValaTargetValue*) _tmp8_, _tmp10_);
	_tmp11_ = _result_;
	_tmp12_ = self->non_null;
	_tmp11_->non_null = _tmp12_;
	_tmp13_ = _result_;
	_tmp14_ = self->ctype;
	_tmp15_ = g_strdup (_tmp14_);
	_g_free0 (_tmp13_->ctype);
	_tmp13_->ctype = _tmp15_;
	_tmp16_ = self->array_length_cvalues;
	if (_tmp16_ != NULL) {
		{
			ValaList* _cexpr_list = NULL;
			ValaList* _tmp17_;
			ValaList* _tmp18_;
			gint _cexpr_size = 0;
			ValaList* _tmp19_;
			gint _tmp20_;
			gint _tmp21_;
			gint _cexpr_index = 0;
			_tmp17_ = self->array_length_cvalues;
			_tmp18_ = _vala_iterable_ref0 (_tmp17_);
			_cexpr_list = _tmp18_;
			_tmp19_ = _cexpr_list;
			_tmp20_ = vala_collection_get_size ((ValaCollection*) _tmp19_);
			_tmp21_ = _tmp20_;
			_cexpr_size = _tmp21_;
			_cexpr_index = -1;
			while (TRUE) {
				gint _tmp22_;
				gint _tmp23_;
				gint _tmp24_;
				ValaCCodeExpression* cexpr = NULL;
				ValaList* _tmp25_;
				gint _tmp26_;
				gpointer _tmp27_;
				ValaGLibValue* _tmp28_;
				ValaCCodeExpression* _tmp29_;
				_tmp22_ = _cexpr_index;
				_cexpr_index = _tmp22_ + 1;
				_tmp23_ = _cexpr_index;
				_tmp24_ = _cexpr_size;
				if (!(_tmp23_ < _tmp24_)) {
					break;
				}
				_tmp25_ = _cexpr_list;
				_tmp26_ = _cexpr_index;
				_tmp27_ = vala_list_get (_tmp25_, _tmp26_);
				cexpr = (ValaCCodeExpression*) _tmp27_;
				_tmp28_ = _result_;
				_tmp29_ = cexpr;
				vala_glib_value_append_array_length_cvalue (_tmp28_, _tmp29_);
				_vala_ccode_node_unref0 (cexpr);
			}
			_vala_iterable_unref0 (_cexpr_list);
		}
	}
	_tmp30_ = _result_;
	_tmp31_ = self->array_size_cvalue;
	_tmp32_ = _vala_ccode_node_ref0 (_tmp31_);
	_vala_ccode_node_unref0 (_tmp30_->array_size_cvalue);
	_tmp30_->array_size_cvalue = _tmp32_;
	_tmp33_ = _result_;
	_tmp34_ = self->array_null_terminated;
	_tmp33_->array_null_terminated = _tmp34_;
	_tmp35_ = _result_;
	_tmp36_ = self->array_length_cexpr;
	_tmp37_ = _vala_ccode_node_ref0 (_tmp36_);
	_vala_ccode_node_unref0 (_tmp35_->array_length_cexpr);
	_tmp35_->array_length_cexpr = _tmp37_;
	_tmp38_ = _result_;
	_tmp39_ = self->delegate_target_cvalue;
	_tmp40_ = _vala_ccode_node_ref0 (_tmp39_);
	_vala_ccode_node_unref0 (_tmp38_->delegate_target_cvalue);
	_tmp38_->delegate_target_cvalue = _tmp40_;
	_tmp41_ = _result_;
	_tmp42_ = self->delegate_target_destroy_notify_cvalue;
	_tmp43_ = _vala_ccode_node_ref0 (_tmp42_);
	_vala_ccode_node_unref0 (_tmp41_->delegate_target_destroy_notify_cvalue);
	_tmp41_->delegate_target_destroy_notify_cvalue = _tmp43_;
	result = _result_;
	return result;
}


static void vala_glib_value_class_init (ValaGLibValueClass * klass) {
	vala_glib_value_parent_class = g_type_class_peek_parent (klass);
	((ValaTargetValueClass *) klass)->finalize = vala_glib_value_finalize;
}


static void vala_glib_value_instance_init (ValaGLibValue * self) {
}


static void vala_glib_value_finalize (ValaTargetValue * obj) {
	ValaGLibValue * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_GLIB_VALUE, ValaGLibValue);
	_vala_ccode_node_unref0 (self->cvalue);
	_g_free0 (self->ctype);
	_vala_iterable_unref0 (self->array_length_cvalues);
	_vala_ccode_node_unref0 (self->array_size_cvalue);
	_vala_ccode_node_unref0 (self->array_length_cexpr);
	_vala_ccode_node_unref0 (self->delegate_target_cvalue);
	_vala_ccode_node_unref0 (self->delegate_target_destroy_notify_cvalue);
	VALA_TARGET_VALUE_CLASS (vala_glib_value_parent_class)->finalize (obj);
}


G_GNUC_INTERNAL GType vala_glib_value_get_type (void) {
	static volatile gsize vala_glib_value_type_id__volatile = 0;
	if (g_once_init_enter (&vala_glib_value_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ValaGLibValueClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_glib_value_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGLibValue), 0, (GInstanceInitFunc) vala_glib_value_instance_init, NULL };
		GType vala_glib_value_type_id;
		vala_glib_value_type_id = g_type_register_static (VALA_TYPE_TARGET_VALUE, "ValaGLibValue", &g_define_type_info, 0);
		g_once_init_leave (&vala_glib_value_type_id__volatile, vala_glib_value_type_id);
	}
	return vala_glib_value_type_id__volatile;
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	if ((array != NULL) && (destroy_func != NULL)) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}


static gint _vala_array_length (gpointer array) {
	int length;
	length = 0;
	if (array) {
		while (((gpointer*) array)[length]) {
			length++;
		}
	}
	return length;
}



