Logo Search packages:      
Sourcecode: vala-0.14 version File versions  Download package

valaccodebasemodule.c

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

/* valaccodebasemodule.vala
 *
 * Copyright (C) 2006-2011  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 <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_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_file_unref (var), NULL)))
#define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_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_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)))
typedef struct _ValaCCodeBaseModuleParamSpecEmitContext ValaCCodeBaseModuleParamSpecEmitContext;

struct _ValaCCodeBaseModule {
      ValaCodeGenerator parent_instance;
      ValaCCodeBaseModulePrivate * priv;
      ValaSymbol* root_symbol;
      ValaCCodeBaseModuleEmitContext* emit_context;
      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;
      ValaSet* user_marshal_set;
      ValaSet* predefined_marshal_set;
      gint next_regex_id;
      gboolean in_constructor;
      gboolean in_static_or_class_context;
      gint next_coroutine_state;
      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* 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;
      ValaTypeSymbol* type_module_type;
      ValaTypeSymbol* dbus_proxy_type;
      gboolean in_plugin;
      gchar* module_init_param_name;
      gboolean gvaluecollector_h_needed;
      gboolean requires_array_free;
      gboolean requires_array_move;
      gboolean requires_array_length;
      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_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);
      gboolean (*is_gobject_property) (ValaCCodeBaseModule* self, ValaProperty* prop);
      gchar* (*get_custom_creturn_type) (ValaCCodeBaseModule* self, ValaMethod* m);
      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);
      ValaCCodeFunctionCall* (*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);
};

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

00228 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_vars;
      gint next_temp_var_id;
      gboolean current_method_inner_error;
      gboolean current_method_return;
      ValaMap* variable_name_map;
};

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

struct _ValaGLibValue {
      ValaTargetValue parent_instance;
      ValaGLibValuePrivate * priv;
      ValaCCodeExpression* cvalue;
      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;
};

00268 struct _ValaCCodeBaseModuleParamSpecEmitContext {
      GParamSpec parent_instance;
};


static gpointer vala_ccode_base_module_parent_class = NULL;
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);
void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self);
void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func);
ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);
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);
ValaCCodeIdentifier* vala_ccode_base_module_get_value_setter_function (ValaCCodeBaseModule* self, ValaDataType* type_reference);
ValaCCodeIdentifier* vala_ccode_base_module_get_value_taker_function (ValaCCodeBaseModule* self, ValaDataType* type_reference);
static ValaCCodeIdentifier* vala_ccode_base_module_get_value_getter_function (ValaCCodeBaseModule* self, ValaDataType* type_reference);
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);
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);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr);
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);
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);
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);
gchar* vala_ccode_base_module_get_array_length_cname (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim);
gchar* vala_ccode_base_module_get_delegate_target_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname);
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);
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);
ValaCCodeExpression* vala_ccode_base_module_get_array_length_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim);
ValaCCodeExpression* vala_ccode_base_module_get_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
ValaArrayList* vala_ccode_base_module_get_temp_ref_vars (ValaCCodeBaseModule* self);
ValaCCodeExpression* vala_ccode_base_module_destroy_local (ValaCCodeBaseModule* self, ValaLocalVariable* local);
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);
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);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value);
ValaTargetValue* vala_ccode_base_module_transform_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* target_type, ValaCodeNode* node);
ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue);
ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue);
GType vala_glib_value_get_type (void) G_GNUC_CONST;
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);
static void vala_ccode_base_module_capture_parameter (ValaCCodeBaseModule* self, ValaParameter* param, ValaCCodeStruct* data, gint block_id);
gboolean vala_ccode_base_module_requires_copy (ValaCCodeBaseModule* self, ValaDataType* type);
ValaTargetValue* vala_ccode_base_module_copy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
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);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
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);
ValaPropertyAccessor* vala_ccode_base_module_get_current_property_accessor (ValaCCodeBaseModule* self);
ValaTypeSymbol* vala_ccode_base_module_get_current_type_symbol (ValaCCodeBaseModule* self);
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_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
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_emit_context_pop_symbol (ValaCCodeBaseModuleEmitContext* self);
static void vala_ccode_base_module_real_visit_declaration_statement (ValaCodeVisitor* base, ValaDeclarationStatement* stmt);
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_has_simple_struct_initializer (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, gboolean always_init);
void vala_ccode_base_module_add_simple_check (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);
static void vala_ccode_base_module_real_visit_initializer_list (ValaCodeVisitor* base, ValaInitializerList* list);
void vala_ccode_base_module_set_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* cvalue);
ValaTargetValue* vala_ccode_base_module_get_local_cvalue (ValaCCodeBaseModule* self, ValaLocalVariable* local);
static ValaLocalVariable* vala_ccode_base_module_real_create_local (ValaCodeGenerator* base, ValaDataType* type);
static gboolean vala_ccode_base_module_is_in_generic_type (ValaCCodeBaseModule* self, ValaDataType* type);
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_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);
static gchar* vala_ccode_base_module_generate_struct_equal_function (ValaCCodeBaseModule* self, ValaStruct* st);
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);
static void vala_ccode_base_module_generate_struct_copy_function (ValaCCodeBaseModule* self, ValaStruct* st);
gchar* vala_ccode_base_module_generate_free_func_wrapper (ValaCCodeBaseModule* self, ValaDataType* type);
static void vala_ccode_base_module_generate_struct_destroy_function (ValaCCodeBaseModule* self, ValaStruct* st);
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_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);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
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);
ValaCCodeExpression* vala_ccode_base_module_get_array_length_cexpression (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cexpression (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify);
void vala_ccode_base_module_create_postcondition_statement (ValaCCodeBaseModule* self, ValaExpression* postcondition);
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);
static ValaTargetValue* vala_ccode_base_module_real_load_this_parameter (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
void vala_ccode_base_module_store_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
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);
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);
static gboolean vala_ccode_base_module_is_ref_function_void (ValaCCodeBaseModule* self, ValaDataType* type);
static ValaTargetValue* vala_ccode_base_module_real_copy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
ValaGLibValue* vala_glib_value_copy (ValaGLibValue* self);
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);
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);
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);
ValaCCodeExpression* vala_ccode_base_module_handle_struct_argument (ValaCCodeBaseModule* self, ValaParameter* param, ValaExpression* arg, ValaCCodeExpression* cexpr);
void vala_ccode_base_module_set_current_method_inner_error (ValaCCodeBaseModule* self, gboolean value);
gchar* vala_ccode_base_module_get_custom_creturn_type (ValaCCodeBaseModule* self, ValaMethod* m);
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);
void vala_glib_value_append_array_length_cvalue (ValaGLibValue* self, ValaCCodeExpression* length_cvalue);
ValaCCodeExpression* vala_ccode_base_module_try_cast_variant_to_type (ValaCCodeBaseModule* self, ValaCCodeExpression* ccodeexpr, ValaDataType* from, ValaDataType* to, ValaExpression* expr);
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);
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);
gchar* vala_ccode_base_module_get_type_check_function (ValaCCodeBaseModule* self, ValaTypeSymbol* 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);
ValaBlock* vala_ccode_base_module_get_current_closure_block (ValaCCodeBaseModule* self);
ValaDataType* vala_ccode_base_module_get_this_type (ValaCCodeBaseModule* self);
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);
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);
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_visit_class (ValaCodeVisitor* base, ValaClass* cl);
static gboolean vala_ccode_base_module_real_is_gobject_property (ValaCCodeBaseModule* self, ValaProperty* prop);
void vala_ccode_base_module_return_default_value (ValaCCodeBaseModule* self, ValaDataType* return_type);
static gchar* vala_ccode_base_module_real_get_custom_creturn_type (ValaCCodeBaseModule* self, ValaMethod* m);
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);
ValaCCodeFunctionCall* vala_ccode_base_module_get_signal_creation (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type);
static ValaCCodeFunctionCall* 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);
gchar* vala_ccode_base_module_generate_ready_function (ValaCCodeBaseModule* self, ValaMethod* m);
static gchar* vala_ccode_base_module_real_generate_ready_function (ValaCCodeBaseModule* self, ValaMethod* m);
void vala_ccode_base_module_set_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCCodeExpression* cvalue);
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_ = NULL;
      g_return_val_if_fail (self != NULL, FALSE);
      _tmp1_ = vala_ccode_base_module_get_current_method (self);
      if (_tmp1_ != NULL) {
            ValaMethod* _tmp2_ = NULL;
            gboolean _tmp3_;
            _tmp2_ = vala_ccode_base_module_get_current_method (self);
            _tmp3_ = vala_method_get_coroutine (_tmp2_);
            _tmp0_ = _tmp3_;
      } 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_ = NULL;
      ValaSymbol* _tmp1_ = NULL;
      ValaSymbol* _tmp2_;
      ValaSymbol* sym;
      g_return_val_if_fail (self != NULL, FALSE);
      _tmp0_ = vala_ccode_base_module_get_current_method (self);
      if (_tmp0_ != NULL) {
            result = FALSE;
            return result;
      }
      _tmp1_ = vala_ccode_base_module_get_current_symbol (self);
      _tmp2_ = _vala_code_node_ref0 (_tmp1_);
      sym = _tmp2_;
      while (TRUE) {
            ValaSymbol* _tmp3_ = NULL;
            ValaSymbol* _tmp4_;
            if (!(sym != NULL)) {
                  break;
            }
            if (VALA_IS_CONSTRUCTOR (sym)) {
                  result = TRUE;
                  _vala_code_node_unref0 (sym);
                  return result;
            }
            _tmp3_ = vala_symbol_get_parent_symbol (sym);
            _tmp4_ = _vala_code_node_ref0 (_tmp3_);
            _vala_code_node_unref0 (sym);
            sym = _tmp4_;
      }
      result = FALSE;
      _vala_code_node_unref0 (sym);
      return result;
}


gboolean vala_ccode_base_module_is_in_destructor (ValaCCodeBaseModule* self) {
      gboolean result = FALSE;
      ValaMethod* _tmp0_ = NULL;
      ValaSymbol* _tmp1_ = NULL;
      ValaSymbol* _tmp2_;
      ValaSymbol* sym;
      g_return_val_if_fail (self != NULL, FALSE);
      _tmp0_ = vala_ccode_base_module_get_current_method (self);
      if (_tmp0_ != NULL) {
            result = FALSE;
            return result;
      }
      _tmp1_ = vala_ccode_base_module_get_current_symbol (self);
      _tmp2_ = _vala_code_node_ref0 (_tmp1_);
      sym = _tmp2_;
      while (TRUE) {
            ValaSymbol* _tmp3_ = NULL;
            ValaSymbol* _tmp4_;
            if (!(sym != NULL)) {
                  break;
            }
            if (VALA_IS_DESTRUCTOR (sym)) {
                  result = TRUE;
                  _vala_code_node_unref0 (sym);
                  return result;
            }
            _tmp3_ = vala_symbol_get_parent_symbol (sym);
            _tmp4_ = _vala_code_node_ref0 (_tmp3_);
            _vala_code_node_unref0 (sym);
            sym = _tmp4_;
      }
      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) {
            ValaSymbol* _tmp0_;
            ValaMethod* method;
            gboolean _tmp1_ = FALSE;
            ValaSymbol* _tmp3_;
            ValaBlock* block;
            gboolean _tmp4_ = FALSE;
            gboolean _tmp5_ = FALSE;
            ValaSymbol* _tmp7_ = NULL;
            _tmp0_ = sym;
            method = VALA_IS_METHOD (_tmp0_) ? ((ValaMethod*) _tmp0_) : NULL;
            if (method != NULL) {
                  gboolean _tmp2_;
                  _tmp2_ = vala_method_get_closure (method);
                  _tmp1_ = !_tmp2_;
            } else {
                  _tmp1_ = FALSE;
            }
            if (_tmp1_) {
                  break;
            }
            _tmp3_ = sym;
            block = VALA_IS_BLOCK (_tmp3_) ? ((ValaBlock*) _tmp3_) : NULL;
            if (method == NULL) {
                  _tmp4_ = block == NULL;
            } else {
                  _tmp4_ = FALSE;
            }
            if (_tmp4_) {
                  break;
            }
            if (block != NULL) {
                  gboolean _tmp6_;
                  _tmp6_ = vala_block_get_captured (block);
                  _tmp5_ = _tmp6_;
            } else {
                  _tmp5_ = FALSE;
            }
            if (_tmp5_) {
                  result = block;
                  return result;
            }
            _tmp7_ = vala_symbol_get_parent_symbol (sym);
            sym = _tmp7_;
      }
      result = NULL;
      return result;
}


ValaCCodeBaseModule* vala_ccode_base_module_construct (GType object_type) {
      ValaCCodeBaseModule* self = NULL;
      ValaHashSet* _tmp0_ = NULL;
      ValaHashSet* _tmp1_ = NULL;
      self = (ValaCCodeBaseModule*) vala_code_generator_construct (object_type);
      _tmp0_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);
      _vala_iterable_unref0 (self->predefined_marshal_set);
      self->predefined_marshal_set = (ValaSet*) _tmp0_;
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:VOID");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:BOOLEAN");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:CHAR");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:UCHAR");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:INT");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:UINT");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:LONG");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:ULONG");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:ENUM");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:FLAGS");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:FLOAT");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:DOUBLE");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:STRING");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:POINTER");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:OBJECT");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "STRING:OBJECT,POINTER");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "VOID:UINT,POINTER");
      vala_collection_add ((ValaCollection*) self->predefined_marshal_set, "BOOLEAN:FLAGS");
      _tmp1_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);
      _vala_iterable_unref0 (self->priv->reserved_identifiers);
      self->priv->reserved_identifiers = (ValaSet*) _tmp1_;
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "_Bool");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "_Complex");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "_Imaginary");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "asm");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "auto");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "break");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "case");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "char");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "const");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "continue");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "default");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "do");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "double");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "else");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "enum");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "extern");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "float");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "for");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "goto");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "if");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "inline");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "int");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "long");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "register");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "restrict");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "return");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "short");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "signed");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "sizeof");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "static");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "struct");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "switch");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "typedef");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "union");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "unsigned");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "void");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "volatile");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "while");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "cdecl");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "error");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "result");
      vala_collection_add ((ValaCollection*) self->priv->reserved_identifiers, "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;
      ValaNamespace* _tmp0_ = NULL;
      ValaSymbol* _tmp1_;
      ValaScope* _tmp2_ = NULL;
      ValaSymbol* _tmp3_ = NULL;
      ValaStruct* _tmp4_;
      ValaBooleanType* _tmp5_ = NULL;
      ValaScope* _tmp6_ = NULL;
      ValaSymbol* _tmp7_ = NULL;
      ValaStruct* _tmp8_;
      ValaIntegerType* _tmp9_ = NULL;
      ValaScope* _tmp10_ = NULL;
      ValaSymbol* _tmp11_ = NULL;
      ValaStruct* _tmp12_;
      ValaIntegerType* _tmp13_ = NULL;
      ValaScope* _tmp14_ = NULL;
      ValaSymbol* _tmp15_ = NULL;
      ValaStruct* _tmp16_;
      ValaIntegerType* _tmp17_ = NULL;
      ValaScope* _tmp18_ = NULL;
      ValaSymbol* _tmp19_ = NULL;
      ValaStruct* _tmp20_;
      ValaIntegerType* _tmp21_ = NULL;
      ValaScope* _tmp22_ = NULL;
      ValaSymbol* _tmp23_ = NULL;
      ValaStruct* _tmp24_;
      ValaIntegerType* _tmp25_ = NULL;
      ValaScope* _tmp26_ = NULL;
      ValaSymbol* _tmp27_ = NULL;
      ValaStruct* _tmp28_;
      ValaIntegerType* _tmp29_ = NULL;
      ValaScope* _tmp30_ = NULL;
      ValaSymbol* _tmp31_ = NULL;
      ValaStruct* _tmp32_;
      ValaIntegerType* _tmp33_ = NULL;
      ValaScope* _tmp34_ = NULL;
      ValaSymbol* _tmp35_ = NULL;
      ValaStruct* _tmp36_;
      ValaIntegerType* _tmp37_ = NULL;
      ValaScope* _tmp38_ = NULL;
      ValaSymbol* _tmp39_ = NULL;
      ValaStruct* _tmp40_;
      ValaIntegerType* _tmp41_ = NULL;
      ValaScope* _tmp42_ = NULL;
      ValaSymbol* _tmp43_ = NULL;
      ValaStruct* _tmp44_;
      ValaIntegerType* _tmp45_ = NULL;
      ValaScope* _tmp46_ = NULL;
      ValaSymbol* _tmp47_ = NULL;
      ValaStruct* _tmp48_;
      ValaIntegerType* _tmp49_ = NULL;
      ValaScope* _tmp50_ = NULL;
      ValaSymbol* _tmp51_ = NULL;
      ValaStruct* _tmp52_;
      ValaIntegerType* _tmp53_ = NULL;
      ValaScope* _tmp54_ = NULL;
      ValaSymbol* _tmp55_ = NULL;
      ValaStruct* _tmp56_;
      ValaIntegerType* _tmp57_ = NULL;
      ValaScope* _tmp58_ = NULL;
      ValaSymbol* _tmp59_ = NULL;
      ValaStruct* _tmp60_;
      ValaIntegerType* _tmp61_ = NULL;
      ValaScope* _tmp62_ = NULL;
      ValaSymbol* _tmp63_ = NULL;
      ValaStruct* _tmp64_;
      ValaIntegerType* _tmp65_ = NULL;
      ValaScope* _tmp66_ = NULL;
      ValaSymbol* _tmp67_ = NULL;
      ValaStruct* _tmp68_;
      ValaIntegerType* _tmp69_ = NULL;
      ValaScope* _tmp70_ = NULL;
      ValaSymbol* _tmp71_ = NULL;
      ValaStruct* _tmp72_;
      ValaFloatingType* _tmp73_ = NULL;
      ValaScope* _tmp74_ = NULL;
      ValaSymbol* _tmp75_ = NULL;
      ValaStruct* _tmp76_;
      ValaFloatingType* _tmp77_ = NULL;
      ValaScope* _tmp78_ = NULL;
      ValaSymbol* _tmp79_ = NULL;
      ValaClass* _tmp80_;
      ValaObjectType* _tmp81_ = NULL;
      ValaScope* _tmp82_ = NULL;
      ValaSymbol* _tmp83_ = NULL;
      ValaStruct* unichar_struct;
      ValaProfile _tmp85_;
      ValaCCodeFile* _tmp147_ = NULL;
      ValaCCodeFile* _tmp148_ = NULL;
      ValaList* _tmp149_ = NULL;
      ValaList* source_files;
      const gchar* _tmp158_ = NULL;
      const gchar* _tmp167_ = NULL;
      const gchar* _tmp178_ = NULL;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (context != NULL);
      vala_ccode_base_module_set_context (self, context);
      _tmp0_ = vala_code_context_get_root (context);
      _tmp1_ = _vala_code_node_ref0 ((ValaSymbol*) _tmp0_);
      _vala_code_node_unref0 (self->root_symbol);
      self->root_symbol = _tmp1_;
      _tmp2_ = vala_symbol_get_scope (self->root_symbol);
      _tmp3_ = vala_scope_lookup (_tmp2_, "bool");
      _tmp4_ = VALA_STRUCT (_tmp3_);
      _tmp5_ = vala_boolean_type_new (_tmp4_);
      _vala_code_node_unref0 (self->bool_type);
      self->bool_type = (ValaDataType*) _tmp5_;
      _vala_code_node_unref0 (_tmp4_);
      _tmp6_ = vala_symbol_get_scope (self->root_symbol);
      _tmp7_ = vala_scope_lookup (_tmp6_, "char");
      _tmp8_ = VALA_STRUCT (_tmp7_);
      _tmp9_ = vala_integer_type_new (_tmp8_, NULL, NULL);
      _vala_code_node_unref0 (self->char_type);
      self->char_type = (ValaDataType*) _tmp9_;
      _vala_code_node_unref0 (_tmp8_);
      _tmp10_ = vala_symbol_get_scope (self->root_symbol);
      _tmp11_ = vala_scope_lookup (_tmp10_, "uchar");
      _tmp12_ = VALA_STRUCT (_tmp11_);
      _tmp13_ = vala_integer_type_new (_tmp12_, NULL, NULL);
      _vala_code_node_unref0 (self->uchar_type);
      self->uchar_type = (ValaDataType*) _tmp13_;
      _vala_code_node_unref0 (_tmp12_);
      _tmp14_ = vala_symbol_get_scope (self->root_symbol);
      _tmp15_ = vala_scope_lookup (_tmp14_, "short");
      _tmp16_ = VALA_STRUCT (_tmp15_);
      _tmp17_ = vala_integer_type_new (_tmp16_, NULL, NULL);
      _vala_code_node_unref0 (self->short_type);
      self->short_type = (ValaDataType*) _tmp17_;
      _vala_code_node_unref0 (_tmp16_);
      _tmp18_ = vala_symbol_get_scope (self->root_symbol);
      _tmp19_ = vala_scope_lookup (_tmp18_, "ushort");
      _tmp20_ = VALA_STRUCT (_tmp19_);
      _tmp21_ = vala_integer_type_new (_tmp20_, NULL, NULL);
      _vala_code_node_unref0 (self->ushort_type);
      self->ushort_type = (ValaDataType*) _tmp21_;
      _vala_code_node_unref0 (_tmp20_);
      _tmp22_ = vala_symbol_get_scope (self->root_symbol);
      _tmp23_ = vala_scope_lookup (_tmp22_, "int");
      _tmp24_ = VALA_STRUCT (_tmp23_);
      _tmp25_ = vala_integer_type_new (_tmp24_, NULL, NULL);
      _vala_code_node_unref0 (self->int_type);
      self->int_type = (ValaDataType*) _tmp25_;
      _vala_code_node_unref0 (_tmp24_);
      _tmp26_ = vala_symbol_get_scope (self->root_symbol);
      _tmp27_ = vala_scope_lookup (_tmp26_, "uint");
      _tmp28_ = VALA_STRUCT (_tmp27_);
      _tmp29_ = vala_integer_type_new (_tmp28_, NULL, NULL);
      _vala_code_node_unref0 (self->uint_type);
      self->uint_type = (ValaDataType*) _tmp29_;
      _vala_code_node_unref0 (_tmp28_);
      _tmp30_ = vala_symbol_get_scope (self->root_symbol);
      _tmp31_ = vala_scope_lookup (_tmp30_, "long");
      _tmp32_ = VALA_STRUCT (_tmp31_);
      _tmp33_ = vala_integer_type_new (_tmp32_, NULL, NULL);
      _vala_code_node_unref0 (self->long_type);
      self->long_type = (ValaDataType*) _tmp33_;
      _vala_code_node_unref0 (_tmp32_);
      _tmp34_ = vala_symbol_get_scope (self->root_symbol);
      _tmp35_ = vala_scope_lookup (_tmp34_, "ulong");
      _tmp36_ = VALA_STRUCT (_tmp35_);
      _tmp37_ = vala_integer_type_new (_tmp36_, NULL, NULL);
      _vala_code_node_unref0 (self->ulong_type);
      self->ulong_type = (ValaDataType*) _tmp37_;
      _vala_code_node_unref0 (_tmp36_);
      _tmp38_ = vala_symbol_get_scope (self->root_symbol);
      _tmp39_ = vala_scope_lookup (_tmp38_, "int8");
      _tmp40_ = VALA_STRUCT (_tmp39_);
      _tmp41_ = vala_integer_type_new (_tmp40_, NULL, NULL);
      _vala_code_node_unref0 (self->int8_type);
      self->int8_type = (ValaDataType*) _tmp41_;
      _vala_code_node_unref0 (_tmp40_);
      _tmp42_ = vala_symbol_get_scope (self->root_symbol);
      _tmp43_ = vala_scope_lookup (_tmp42_, "uint8");
      _tmp44_ = VALA_STRUCT (_tmp43_);
      _tmp45_ = vala_integer_type_new (_tmp44_, NULL, NULL);
      _vala_code_node_unref0 (self->uint8_type);
      self->uint8_type = (ValaDataType*) _tmp45_;
      _vala_code_node_unref0 (_tmp44_);
      _tmp46_ = vala_symbol_get_scope (self->root_symbol);
      _tmp47_ = vala_scope_lookup (_tmp46_, "int16");
      _tmp48_ = VALA_STRUCT (_tmp47_);
      _tmp49_ = vala_integer_type_new (_tmp48_, NULL, NULL);
      _vala_code_node_unref0 (self->int16_type);
      self->int16_type = (ValaDataType*) _tmp49_;
      _vala_code_node_unref0 (_tmp48_);
      _tmp50_ = vala_symbol_get_scope (self->root_symbol);
      _tmp51_ = vala_scope_lookup (_tmp50_, "uint16");
      _tmp52_ = VALA_STRUCT (_tmp51_);
      _tmp53_ = vala_integer_type_new (_tmp52_, NULL, NULL);
      _vala_code_node_unref0 (self->uint16_type);
      self->uint16_type = (ValaDataType*) _tmp53_;
      _vala_code_node_unref0 (_tmp52_);
      _tmp54_ = vala_symbol_get_scope (self->root_symbol);
      _tmp55_ = vala_scope_lookup (_tmp54_, "int32");
      _tmp56_ = VALA_STRUCT (_tmp55_);
      _tmp57_ = vala_integer_type_new (_tmp56_, NULL, NULL);
      _vala_code_node_unref0 (self->int32_type);
      self->int32_type = (ValaDataType*) _tmp57_;
      _vala_code_node_unref0 (_tmp56_);
      _tmp58_ = vala_symbol_get_scope (self->root_symbol);
      _tmp59_ = vala_scope_lookup (_tmp58_, "uint32");
      _tmp60_ = VALA_STRUCT (_tmp59_);
      _tmp61_ = vala_integer_type_new (_tmp60_, NULL, NULL);
      _vala_code_node_unref0 (self->uint32_type);
      self->uint32_type = (ValaDataType*) _tmp61_;
      _vala_code_node_unref0 (_tmp60_);
      _tmp62_ = vala_symbol_get_scope (self->root_symbol);
      _tmp63_ = vala_scope_lookup (_tmp62_, "int64");
      _tmp64_ = VALA_STRUCT (_tmp63_);
      _tmp65_ = vala_integer_type_new (_tmp64_, NULL, NULL);
      _vala_code_node_unref0 (self->int64_type);
      self->int64_type = (ValaDataType*) _tmp65_;
      _vala_code_node_unref0 (_tmp64_);
      _tmp66_ = vala_symbol_get_scope (self->root_symbol);
      _tmp67_ = vala_scope_lookup (_tmp66_, "uint64");
      _tmp68_ = VALA_STRUCT (_tmp67_);
      _tmp69_ = vala_integer_type_new (_tmp68_, NULL, NULL);
      _vala_code_node_unref0 (self->uint64_type);
      self->uint64_type = (ValaDataType*) _tmp69_;
      _vala_code_node_unref0 (_tmp68_);
      _tmp70_ = vala_symbol_get_scope (self->root_symbol);
      _tmp71_ = vala_scope_lookup (_tmp70_, "float");
      _tmp72_ = VALA_STRUCT (_tmp71_);
      _tmp73_ = vala_floating_type_new (_tmp72_);
      _vala_code_node_unref0 (self->float_type);
      self->float_type = (ValaDataType*) _tmp73_;
      _vala_code_node_unref0 (_tmp72_);
      _tmp74_ = vala_symbol_get_scope (self->root_symbol);
      _tmp75_ = vala_scope_lookup (_tmp74_, "double");
      _tmp76_ = VALA_STRUCT (_tmp75_);
      _tmp77_ = vala_floating_type_new (_tmp76_);
      _vala_code_node_unref0 (self->double_type);
      self->double_type = (ValaDataType*) _tmp77_;
      _vala_code_node_unref0 (_tmp76_);
      _tmp78_ = vala_symbol_get_scope (self->root_symbol);
      _tmp79_ = vala_scope_lookup (_tmp78_, "string");
      _tmp80_ = VALA_CLASS (_tmp79_);
      _tmp81_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp80_);
      _vala_code_node_unref0 (self->string_type);
      self->string_type = (ValaDataType*) _tmp81_;
      _vala_code_node_unref0 (_tmp80_);
      _tmp82_ = vala_symbol_get_scope (self->root_symbol);
      _tmp83_ = vala_scope_lookup (_tmp82_, "unichar");
      unichar_struct = VALA_STRUCT (_tmp83_);
      if (unichar_struct != NULL) {
            ValaIntegerType* _tmp84_ = NULL;
            _tmp84_ = vala_integer_type_new (unichar_struct, NULL, NULL);
            _vala_code_node_unref0 (self->unichar_type);
            self->unichar_type = (ValaDataType*) _tmp84_;
      }
      _tmp85_ = vala_code_context_get_profile (context);
      if (_tmp85_ == VALA_PROFILE_GOBJECT) {
            ValaScope* _tmp86_ = NULL;
            ValaSymbol* _tmp87_ = NULL;
            ValaSymbol* glib_ns;
            ValaScope* _tmp88_ = NULL;
            ValaSymbol* _tmp89_ = NULL;
            ValaScope* _tmp90_ = NULL;
            ValaSymbol* _tmp91_ = NULL;
            ValaErrorType* _tmp92_ = NULL;
            ValaScope* _tmp93_ = NULL;
            ValaSymbol* _tmp94_ = NULL;
            ValaScope* _tmp95_ = NULL;
            ValaSymbol* _tmp96_ = NULL;
            ValaScope* _tmp97_ = NULL;
            ValaSymbol* _tmp98_ = NULL;
            ValaScope* _tmp99_ = NULL;
            ValaSymbol* _tmp100_ = NULL;
            ValaScope* _tmp101_ = NULL;
            ValaSymbol* _tmp102_ = NULL;
            ValaScope* _tmp103_ = NULL;
            ValaSymbol* _tmp104_ = NULL;
            ValaScope* _tmp105_ = NULL;
            ValaSymbol* _tmp106_ = NULL;
            ValaScope* _tmp107_ = NULL;
            ValaSymbol* _tmp108_ = NULL;
            ValaScope* _tmp109_ = NULL;
            ValaSymbol* _tmp110_ = NULL;
            ValaScope* _tmp111_ = NULL;
            ValaSymbol* _tmp112_ = NULL;
            ValaDelegate* _tmp113_;
            ValaDelegateType* _tmp114_ = NULL;
            ValaScope* _tmp115_ = NULL;
            ValaSymbol* _tmp116_ = NULL;
            ValaStruct* _tmp117_;
            ValaIntegerType* _tmp118_ = NULL;
            ValaScope* _tmp119_ = NULL;
            ValaSymbol* _tmp120_ = NULL;
            ValaScope* _tmp121_ = NULL;
            ValaSymbol* _tmp122_ = NULL;
            ValaScope* _tmp123_ = NULL;
            ValaSymbol* _tmp124_ = NULL;
            ValaScope* _tmp125_ = NULL;
            ValaSymbol* _tmp126_ = NULL;
            ValaScope* _tmp127_ = NULL;
            ValaSymbol* _tmp128_ = NULL;
            ValaSymbol* _tmp129_;
            ValaScope* _tmp130_ = NULL;
            ValaSymbol* _tmp131_ = NULL;
            ValaClass* _tmp132_;
            ValaObjectType* _tmp133_ = NULL;
            ValaMethod* _tmp134_ = NULL;
            ValaScope* _tmp145_ = NULL;
            ValaSymbol* _tmp146_ = NULL;
            _tmp86_ = vala_symbol_get_scope (self->root_symbol);
            _tmp87_ = vala_scope_lookup (_tmp86_, "GLib");
            glib_ns = _tmp87_;
            _tmp88_ = vala_symbol_get_scope (glib_ns);
            _tmp89_ = vala_scope_lookup (_tmp88_, "Type");
            _vala_code_node_unref0 (self->gtype_type);
            self->gtype_type = VALA_TYPESYMBOL (_tmp89_);
            _tmp90_ = vala_symbol_get_scope (glib_ns);
            _tmp91_ = vala_scope_lookup (_tmp90_, "Object");
            _vala_code_node_unref0 (self->gobject_type);
            self->gobject_type = VALA_TYPESYMBOL (_tmp91_);
            _tmp92_ = vala_error_type_new (NULL, NULL, NULL);
            _vala_code_node_unref0 (self->gerror_type);
            self->gerror_type = _tmp92_;
            _tmp93_ = vala_symbol_get_scope (glib_ns);
            _tmp94_ = vala_scope_lookup (_tmp93_, "List");
            _vala_code_node_unref0 (self->glist_type);
            self->glist_type = VALA_CLASS (_tmp94_);
            _tmp95_ = vala_symbol_get_scope (glib_ns);
            _tmp96_ = vala_scope_lookup (_tmp95_, "SList");
            _vala_code_node_unref0 (self->gslist_type);
            self->gslist_type = VALA_CLASS (_tmp96_);
            _tmp97_ = vala_symbol_get_scope (glib_ns);
            _tmp98_ = vala_scope_lookup (_tmp97_, "Node");
            _vala_code_node_unref0 (self->gnode_type);
            self->gnode_type = VALA_CLASS (_tmp98_);
            _tmp99_ = vala_symbol_get_scope (glib_ns);
            _tmp100_ = vala_scope_lookup (_tmp99_, "ValueArray");
            _vala_code_node_unref0 (self->gvaluearray_type);
            self->gvaluearray_type = VALA_CLASS (_tmp100_);
            _tmp101_ = vala_symbol_get_scope (glib_ns);
            _tmp102_ = vala_scope_lookup (_tmp101_, "StringBuilder");
            _vala_code_node_unref0 (self->gstringbuilder_type);
            self->gstringbuilder_type = VALA_TYPESYMBOL (_tmp102_);
            _tmp103_ = vala_symbol_get_scope (glib_ns);
            _tmp104_ = vala_scope_lookup (_tmp103_, "Array");
            _vala_code_node_unref0 (self->garray_type);
            self->garray_type = VALA_TYPESYMBOL (_tmp104_);
            _tmp105_ = vala_symbol_get_scope (glib_ns);
            _tmp106_ = vala_scope_lookup (_tmp105_, "ByteArray");
            _vala_code_node_unref0 (self->gbytearray_type);
            self->gbytearray_type = VALA_TYPESYMBOL (_tmp106_);
            _tmp107_ = vala_symbol_get_scope (glib_ns);
            _tmp108_ = vala_scope_lookup (_tmp107_, "PtrArray");
            _vala_code_node_unref0 (self->gptrarray_type);
            self->gptrarray_type = VALA_TYPESYMBOL (_tmp108_);
            _tmp109_ = vala_symbol_get_scope (glib_ns);
            _tmp110_ = vala_scope_lookup (_tmp109_, "ThreadPool");
            _vala_code_node_unref0 (self->gthreadpool_type);
            self->gthreadpool_type = VALA_TYPESYMBOL (_tmp110_);
            _tmp111_ = vala_symbol_get_scope (glib_ns);
            _tmp112_ = vala_scope_lookup (_tmp111_, "DestroyNotify");
            _tmp113_ = VALA_DELEGATE (_tmp112_);
            _tmp114_ = vala_delegate_type_new (_tmp113_);
            _vala_code_node_unref0 (self->gdestroynotify_type);
            self->gdestroynotify_type = (ValaDataType*) _tmp114_;
            _vala_code_node_unref0 (_tmp113_);
            _tmp115_ = vala_symbol_get_scope (glib_ns);
            _tmp116_ = vala_scope_lookup (_tmp115_, "Quark");
            _tmp117_ = VALA_STRUCT (_tmp116_);
            _tmp118_ = vala_integer_type_new (_tmp117_, NULL, NULL);
            _vala_code_node_unref0 (self->gquark_type);
            self->gquark_type = (ValaDataType*) _tmp118_;
            _vala_code_node_unref0 (_tmp117_);
            _tmp119_ = vala_symbol_get_scope (glib_ns);
            _tmp120_ = vala_scope_lookup (_tmp119_, "Value");
            _vala_code_node_unref0 (self->gvalue_type);
            self->gvalue_type = VALA_STRUCT (_tmp120_);
            _tmp121_ = vala_symbol_get_scope (glib_ns);
            _tmp122_ = vala_scope_lookup (_tmp121_, "Variant");
            _vala_code_node_unref0 (self->gvariant_type);
            self->gvariant_type = VALA_CLASS (_tmp122_);
            _tmp123_ = vala_symbol_get_scope (glib_ns);
            _tmp124_ = vala_scope_lookup (_tmp123_, "StaticRecMutex");
            _vala_code_node_unref0 (self->mutex_type);
            self->mutex_type = VALA_STRUCT (_tmp124_);
            _tmp125_ = vala_symbol_get_scope (glib_ns);
            _tmp126_ = vala_scope_lookup (_tmp125_, "TypeModule");
            _vala_code_node_unref0 (self->type_module_type);
            self->type_module_type = VALA_TYPESYMBOL (_tmp126_);
            _tmp127_ = vala_symbol_get_scope (self->root_symbol);
            _tmp128_ = vala_scope_lookup (_tmp127_, "GLib");
            _tmp129_ = _tmp128_;
            _tmp130_ = vala_symbol_get_scope (_tmp129_);
            _tmp131_ = vala_scope_lookup (_tmp130_, "Regex");
            _tmp132_ = VALA_CLASS (_tmp131_);
            _tmp133_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp132_);
            _vala_code_node_unref0 (self->regex_type);
            self->regex_type = (ValaDataType*) _tmp133_;
            _vala_code_node_unref0 (_tmp132_);
            _vala_code_node_unref0 (_tmp129_);
            _tmp134_ = vala_code_context_get_module_init_method (context);
            if (_tmp134_ != NULL) {
                  {
                        ValaMethod* _tmp135_ = NULL;
                        ValaList* _tmp136_ = NULL;
                        ValaList* _parameter_list;
                        gint _tmp137_;
                        gint _parameter_size;
                        gint _parameter_index;
                        _tmp135_ = vala_code_context_get_module_init_method (context);
                        _tmp136_ = vala_method_get_parameters (_tmp135_);
                        _parameter_list = _tmp136_;
                        _tmp137_ = vala_collection_get_size ((ValaCollection*) _parameter_list);
                        _parameter_size = _tmp137_;
                        _parameter_index = -1;
                        while (TRUE) {
                              gpointer _tmp138_ = NULL;
                              ValaParameter* parameter;
                              ValaDataType* _tmp139_ = NULL;
                              ValaTypeSymbol* _tmp140_ = NULL;
                              _parameter_index = _parameter_index + 1;
                              if (!(_parameter_index < _parameter_size)) {
                                    break;
                              }
                              _tmp138_ = vala_list_get (_parameter_list, _parameter_index);
                              parameter = (ValaParameter*) _tmp138_;
                              _tmp139_ = vala_variable_get_variable_type ((ValaVariable*) parameter);
                              _tmp140_ = vala_data_type_get_data_type (_tmp139_);
                              if (_tmp140_ == self->type_module_type) {
                                    const gchar* _tmp141_ = NULL;
                                    gchar* _tmp142_;
                                    self->in_plugin = TRUE;
                                    _tmp141_ = vala_symbol_get_name ((ValaSymbol*) parameter);
                                    _tmp142_ = g_strdup (_tmp141_);
                                    _g_free0 (self->module_init_param_name);
                                    self->module_init_param_name = _tmp142_;
                                    _vala_code_node_unref0 (parameter);
                                    break;
                              }
                              _vala_code_node_unref0 (parameter);
                        }
                        _vala_iterable_unref0 (_parameter_list);
                  }
                  if (!self->in_plugin) {
                        ValaMethod* _tmp143_ = NULL;
                        ValaSourceReference* _tmp144_ = NULL;
                        _tmp143_ = vala_code_context_get_module_init_method (context);
                        _tmp144_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp143_);
                        vala_report_error (_tmp144_, "[ModuleInit] requires a parameter of type `GLib.TypeModule'");
                  }
            }
            _tmp145_ = vala_symbol_get_scope (glib_ns);
            _tmp146_ = vala_scope_lookup (_tmp145_, "DBusProxy");
            _vala_code_node_unref0 (self->dbus_proxy_type);
            self->dbus_proxy_type = VALA_TYPESYMBOL (_tmp146_);
            _vala_code_node_unref0 (glib_ns);
      }
      _tmp147_ = vala_ccode_file_new ();
      _vala_ccode_file_unref0 (self->header_file);
      self->header_file = _tmp147_;
      vala_ccode_file_set_is_header (self->header_file, TRUE);
      _tmp148_ = vala_ccode_file_new ();
      _vala_ccode_file_unref0 (self->internal_header_file);
      self->internal_header_file = _tmp148_;
      vala_ccode_file_set_is_header (self->internal_header_file, TRUE);
      _tmp149_ = vala_code_context_get_source_files (context);
      source_files = _tmp149_;
      {
            ValaList* _tmp150_;
            ValaList* _file_list;
            gint _tmp151_;
            gint _file_size;
            gint _file_index;
            _tmp150_ = _vala_iterable_ref0 (source_files);
            _file_list = _tmp150_;
            _tmp151_ = vala_collection_get_size ((ValaCollection*) _file_list);
            _file_size = _tmp151_;
            _file_index = -1;
            while (TRUE) {
                  gpointer _tmp152_ = NULL;
                  ValaSourceFile* file;
                  gboolean _tmp153_ = FALSE;
                  ValaSourceFileType _tmp154_;
                  _file_index = _file_index + 1;
                  if (!(_file_index < _file_size)) {
                        break;
                  }
                  _tmp152_ = vala_list_get (_file_list, _file_index);
                  file = (ValaSourceFile*) _tmp152_;
                  _tmp154_ = vala_source_file_get_file_type (file);
                  if (_tmp154_ == VALA_SOURCE_FILE_TYPE_SOURCE) {
                        _tmp153_ = TRUE;
                  } else {
                        gboolean _tmp155_ = FALSE;
                        const gchar* _tmp156_ = NULL;
                        _tmp156_ = vala_code_context_get_header_filename (context);
                        if (_tmp156_ != NULL) {
                              ValaSourceFileType _tmp157_;
                              _tmp157_ = vala_source_file_get_file_type (file);
                              _tmp155_ = _tmp157_ == VALA_SOURCE_FILE_TYPE_FAST;
                        } else {
                              _tmp155_ = FALSE;
                        }
                        _tmp153_ = _tmp155_;
                  }
                  if (_tmp153_) {
                        vala_source_file_accept (file, (ValaCodeVisitor*) self);
                  }
                  _vala_source_file_unref0 (file);
            }
            _vala_iterable_unref0 (_file_list);
      }
      _tmp158_ = vala_code_context_get_symbols_filename (context);
      if (_tmp158_ != NULL) {
            const gchar* _tmp159_ = NULL;
            FILE* _tmp160_ = NULL;
            FILE* stream;
            _tmp159_ = vala_code_context_get_symbols_filename (context);
            _tmp160_ = fopen (_tmp159_, "w");
            stream = _tmp160_;
            if (stream == NULL) {
                  const gchar* _tmp161_ = NULL;
                  gchar* _tmp162_ = NULL;
                  gchar* _tmp163_;
                  _tmp161_ = vala_code_context_get_symbols_filename (context);
                  _tmp162_ = g_strdup_printf ("unable to open `%s' for writing", _tmp161_);
                  _tmp163_ = _tmp162_;
                  vala_report_error (NULL, _tmp163_);
                  _g_free0 (_tmp163_);
                  _fclose0 (stream);
                  _vala_iterable_unref0 (source_files);
                  _vala_code_node_unref0 (unichar_struct);
                  return;
            }
            {
                  ValaList* _tmp164_ = NULL;
                  ValaList* _symbol_list;
                  gint _tmp165_;
                  gint _symbol_size;
                  gint _symbol_index;
                  _tmp164_ = vala_ccode_file_get_symbols (self->header_file);
                  _symbol_list = _tmp164_;
                  _tmp165_ = vala_collection_get_size ((ValaCollection*) _symbol_list);
                  _symbol_size = _tmp165_;
                  _symbol_index = -1;
                  while (TRUE) {
                        gpointer _tmp166_ = NULL;
                        gchar* symbol;
                        _symbol_index = _symbol_index + 1;
                        if (!(_symbol_index < _symbol_size)) {
                              break;
                        }
                        _tmp166_ = vala_list_get (_symbol_list, _symbol_index);
                        symbol = (gchar*) _tmp166_;
                        fputs (symbol, stream);
                        fputc ('\n', stream);
                        _g_free0 (symbol);
                  }
                  _vala_iterable_unref0 (_symbol_list);
            }
            _fclose0 (stream);
            stream = NULL;
            _fclose0 (stream);
      }
      _tmp167_ = vala_code_context_get_header_filename (context);
      if (_tmp167_ != NULL) {
            gboolean ret = FALSE;
            ValaProfile _tmp168_;
            _tmp168_ = vala_code_context_get_profile (context);
            if (_tmp168_ == VALA_PROFILE_GOBJECT) {
                  const gchar* _tmp169_ = NULL;
                  gboolean _tmp170_;
                  gboolean _tmp171_;
                  _tmp169_ = vala_code_context_get_header_filename (context);
                  _tmp170_ = vala_code_context_get_version_header (context);
                  _tmp171_ = vala_ccode_file_store (self->header_file, _tmp169_, NULL, _tmp170_, FALSE, "G_BEGIN_DECLS", "G_END_DECLS");
                  ret = _tmp171_;
            } else {
                  const gchar* _tmp172_ = NULL;
                  gboolean _tmp173_;
                  gboolean _tmp174_;
                  _tmp172_ = vala_code_context_get_header_filename (context);
                  _tmp173_ = vala_code_context_get_version_header (context);
                  _tmp174_ = vala_ccode_file_store (self->header_file, _tmp172_, NULL, _tmp173_, FALSE, NULL, NULL);
                  ret = _tmp174_;
            }
            if (!ret) {
                  const gchar* _tmp175_ = NULL;
                  gchar* _tmp176_ = NULL;
                  gchar* _tmp177_;
                  _tmp175_ = vala_code_context_get_header_filename (context);
                  _tmp176_ = g_strdup_printf ("unable to open `%s' for writing", _tmp175_);
                  _tmp177_ = _tmp176_;
                  vala_report_error (NULL, _tmp177_);
                  _g_free0 (_tmp177_);
            }
      }
      _tmp178_ = vala_code_context_get_internal_header_filename (context);
      if (_tmp178_ != NULL) {
            gboolean ret = FALSE;
            ValaProfile _tmp179_;
            _tmp179_ = vala_code_context_get_profile (context);
            if (_tmp179_ == VALA_PROFILE_GOBJECT) {
                  const gchar* _tmp180_ = NULL;
                  gboolean _tmp181_;
                  gboolean _tmp182_;
                  _tmp180_ = vala_code_context_get_internal_header_filename (context);
                  _tmp181_ = vala_code_context_get_version_header (context);
                  _tmp182_ = vala_ccode_file_store (self->internal_header_file, _tmp180_, NULL, _tmp181_, FALSE, "G_BEGIN_DECLS", "G_END_DECLS");
                  ret = _tmp182_;
            } else {
                  const gchar* _tmp183_ = NULL;
                  gboolean _tmp184_;
                  gboolean _tmp185_;
                  _tmp183_ = vala_code_context_get_internal_header_filename (context);
                  _tmp184_ = vala_code_context_get_version_header (context);
                  _tmp185_ = vala_ccode_file_store (self->internal_header_file, _tmp183_, NULL, _tmp184_, FALSE, NULL, NULL);
                  ret = _tmp185_;
            }
            if (!ret) {
                  const gchar* _tmp186_ = NULL;
                  gchar* _tmp187_ = NULL;
                  gchar* _tmp188_;
                  _tmp186_ = vala_code_context_get_internal_header_filename (context);
                  _tmp187_ = g_strdup_printf ("unable to open `%s' for writing", _tmp186_);
                  _tmp188_ = _tmp187_;
                  vala_report_error (NULL, _tmp188_);
                  _g_free0 (_tmp188_);
            }
      }
      _vala_iterable_unref0 (source_files);
      _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_;
      g_return_if_fail (self != NULL);
      g_return_if_fail (emit_context != NULL);
      if (self->emit_context != NULL) {
            vala_collection_add ((ValaCollection*) self->priv->emit_context_stack, self->emit_context);
      }
      _tmp0_ = _vala_ccode_base_module_emit_context_ref0 (emit_context);
      _vala_ccode_base_module_emit_context_unref0 (self->emit_context);
      self->emit_context = _tmp0_;
}


void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self) {
      gint _tmp0_;
      g_return_if_fail (self != NULL);
      _tmp0_ = vala_collection_get_size ((ValaCollection*) self->priv->emit_context_stack);
      if (_tmp0_ > 0) {
            gint _tmp1_;
            gpointer _tmp2_ = NULL;
            gint _tmp3_;
            _tmp1_ = vala_collection_get_size ((ValaCollection*) self->priv->emit_context_stack);
            _tmp2_ = vala_list_get (self->priv->emit_context_stack, _tmp1_ - 1);
            _vala_ccode_base_module_emit_context_unref0 (self->emit_context);
            self->emit_context = (ValaCCodeBaseModuleEmitContext*) _tmp2_;
            _tmp3_ = vala_collection_get_size ((ValaCollection*) self->priv->emit_context_stack);
            vala_list_remove_at (self->priv->emit_context_stack, _tmp3_ - 1);
      } else {
            _vala_ccode_base_module_emit_context_unref0 (self->emit_context);
            self->emit_context = NULL;
      }
}


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) {
      ValaCCodeFunction* _tmp0_ = NULL;
      ValaCCodeFunction* _tmp1_;
      g_return_if_fail (self != NULL);
      g_return_if_fail (func != NULL);
      _tmp0_ = vala_ccode_base_module_get_ccode (self);
      vala_collection_add ((ValaCollection*) self->emit_context->ccode_stack, _tmp0_);
      _tmp1_ = _vala_ccode_node_ref0 (func);
      _vala_ccode_node_unref0 (self->emit_context->ccode);
      self->emit_context->ccode = _tmp1_;
}


void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self) {
      gint _tmp0_;
      gpointer _tmp1_ = NULL;
      gint _tmp2_;
      g_return_if_fail (self != NULL);
      _tmp0_ = vala_collection_get_size ((ValaCollection*) self->emit_context->ccode_stack);
      _tmp1_ = vala_list_get ((ValaList*) self->emit_context->ccode_stack, _tmp0_ - 1);
      _vala_ccode_node_unref0 (self->emit_context->ccode);
      self->emit_context->ccode = (ValaCCodeFunction*) _tmp1_;
      _tmp2_ = vala_collection_get_size ((ValaCollection*) self->emit_context->ccode_stack);
      vala_list_remove_at ((ValaList*) self->emit_context->ccode_stack, _tmp2_ - 1);
}


gboolean vala_ccode_base_module_add_symbol_declaration (ValaCCodeBaseModule* self, ValaCCodeFile* decl_space, ValaSymbol* sym, const gchar* name) {
      gboolean result = FALSE;
      gboolean _tmp0_;
      ValaSourceReference* _tmp1_ = NULL;
      gboolean _tmp4_ = FALSE;
      gboolean _tmp5_;
      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_ = vala_ccode_file_add_declaration (decl_space, name);
      if (_tmp0_) {
            result = TRUE;
            return result;
      }
      _tmp1_ = vala_code_node_get_source_reference ((ValaCodeNode*) sym);
      if (_tmp1_ != NULL) {
            ValaSourceReference* _tmp2_ = NULL;
            ValaSourceFile* _tmp3_ = NULL;
            _tmp2_ = vala_code_node_get_source_reference ((ValaCodeNode*) sym);
            _tmp3_ = vala_source_reference_get_file (_tmp2_);
            vala_source_file_set_used (_tmp3_, TRUE);
      }
      _tmp5_ = vala_symbol_get_external_package (sym);
      if (_tmp5_) {
            _tmp4_ = TRUE;
      } else {
            gboolean _tmp6_ = FALSE;
            gboolean _tmp7_ = FALSE;
            gboolean _tmp8_;
            _tmp8_ = vala_ccode_file_get_is_header (decl_space);
            if (!_tmp8_) {
                  ValaCodeContext* _tmp9_ = NULL;
                  ValaCodeContext* _tmp10_;
                  gboolean _tmp11_;
                  _tmp9_ = vala_code_context_get ();
                  _tmp10_ = _tmp9_;
                  _tmp11_ = vala_code_context_get_use_header (_tmp10_);
                  _tmp7_ = _tmp11_;
                  _vala_code_context_unref0 (_tmp10_);
            } else {
                  _tmp7_ = FALSE;
            }
            if (_tmp7_) {
                  gboolean _tmp12_;
                  _tmp12_ = vala_symbol_is_internal_symbol (sym);
                  _tmp6_ = !_tmp12_;
            } else {
                  _tmp6_ = FALSE;
            }
            _tmp4_ = _tmp6_;
      }
      if (_tmp4_) {
            {
                  ValaList* _tmp13_ = NULL;
                  ValaList* _header_filename_list;
                  gint _tmp14_;
                  gint _header_filename_size;
                  gint _header_filename_index;
                  _tmp13_ = vala_symbol_get_cheader_filenames (sym);
                  _header_filename_list = _tmp13_;
                  _tmp14_ = vala_collection_get_size ((ValaCollection*) _header_filename_list);
                  _header_filename_size = _tmp14_;
                  _header_filename_index = -1;
                  while (TRUE) {
                        gpointer _tmp15_ = NULL;
                        gchar* header_filename;
                        gboolean _tmp16_;
                        _header_filename_index = _header_filename_index + 1;
                        if (!(_header_filename_index < _header_filename_size)) {
                              break;
                        }
                        _tmp15_ = vala_list_get (_header_filename_list, _header_filename_index);
                        header_filename = (gchar*) _tmp15_;
                        _tmp16_ = vala_symbol_get_external_package (sym);
                        vala_ccode_file_add_include (decl_space, header_filename, !_tmp16_);
                        _g_free0 (header_filename);
                  }
                  _vala_iterable_unref0 (_header_filename_list);
            }
            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;
      ValaDataType* _tmp0_;
      ValaArrayType* _tmp1_;
      ValaArrayType* array_type;
      ValaTypeSymbol* _tmp2_ = NULL;
      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 (VALA_IS_ARRAY_TYPE (_tmp0_) ? ((ValaArrayType*) _tmp0_) : NULL);
      array_type = _tmp1_;
      _tmp2_ = vala_data_type_get_data_type (type_reference);
      if (_tmp2_ != NULL) {
            ValaTypeSymbol* _tmp3_ = NULL;
            gchar* _tmp4_ = NULL;
            gchar* _tmp5_;
            ValaCCodeIdentifier* _tmp6_ = NULL;
            ValaCCodeIdentifier* _tmp7_;
            _tmp3_ = vala_data_type_get_data_type (type_reference);
            _tmp4_ = vala_typesymbol_get_set_value_function (_tmp3_);
            _tmp5_ = _tmp4_;
            _tmp6_ = vala_ccode_identifier_new (_tmp5_);
            _tmp7_ = _tmp6_;
            _g_free0 (_tmp5_);
            result = _tmp7_;
            _vala_code_node_unref0 (array_type);
            return result;
      } else {
            gboolean _tmp8_ = FALSE;
            if (array_type != NULL) {
                  ValaDataType* _tmp9_ = NULL;
                  ValaTypeSymbol* _tmp10_ = NULL;
                  ValaTypeSymbol* _tmp11_ = NULL;
                  _tmp9_ = vala_array_type_get_element_type (array_type);
                  _tmp10_ = vala_data_type_get_data_type (_tmp9_);
                  _tmp11_ = vala_data_type_get_data_type (self->string_type);
                  _tmp8_ = _tmp10_ == _tmp11_;
            } else {
                  _tmp8_ = FALSE;
            }
            if (_tmp8_) {
                  ValaCCodeIdentifier* _tmp12_ = NULL;
                  _tmp12_ = vala_ccode_identifier_new ("g_value_set_boxed");
                  result = _tmp12_;
                  _vala_code_node_unref0 (array_type);
                  return result;
            } else {
                  ValaCCodeIdentifier* _tmp13_ = NULL;
                  _tmp13_ = vala_ccode_identifier_new ("g_value_set_pointer");
                  result = _tmp13_;
                  _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;
      ValaDataType* _tmp0_;
      ValaArrayType* _tmp1_;
      ValaArrayType* array_type;
      ValaTypeSymbol* _tmp2_ = NULL;
      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 (VALA_IS_ARRAY_TYPE (_tmp0_) ? ((ValaArrayType*) _tmp0_) : NULL);
      array_type = _tmp1_;
      _tmp2_ = vala_data_type_get_data_type (type_reference);
      if (_tmp2_ != NULL) {
            ValaTypeSymbol* _tmp3_ = NULL;
            gchar* _tmp4_ = NULL;
            gchar* _tmp5_;
            ValaCCodeIdentifier* _tmp6_ = NULL;
            ValaCCodeIdentifier* _tmp7_;
            _tmp3_ = vala_data_type_get_data_type (type_reference);
            _tmp4_ = vala_typesymbol_get_take_value_function (_tmp3_);
            _tmp5_ = _tmp4_;
            _tmp6_ = vala_ccode_identifier_new (_tmp5_);
            _tmp7_ = _tmp6_;
            _g_free0 (_tmp5_);
            result = _tmp7_;
            _vala_code_node_unref0 (array_type);
            return result;
      } else {
            gboolean _tmp8_ = FALSE;
            if (array_type != NULL) {
                  ValaDataType* _tmp9_ = NULL;
                  ValaTypeSymbol* _tmp10_ = NULL;
                  ValaTypeSymbol* _tmp11_ = NULL;
                  _tmp9_ = vala_array_type_get_element_type (array_type);
                  _tmp10_ = vala_data_type_get_data_type (_tmp9_);
                  _tmp11_ = vala_data_type_get_data_type (self->string_type);
                  _tmp8_ = _tmp10_ == _tmp11_;
            } else {
                  _tmp8_ = FALSE;
            }
            if (_tmp8_) {
                  ValaCCodeIdentifier* _tmp12_ = NULL;
                  _tmp12_ = vala_ccode_identifier_new ("g_value_take_boxed");
                  result = _tmp12_;
                  _vala_code_node_unref0 (array_type);
                  return result;
            } else {
                  ValaCCodeIdentifier* _tmp13_ = NULL;
                  _tmp13_ = vala_ccode_identifier_new ("g_value_set_pointer");
                  result = _tmp13_;
                  _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;
      ValaDataType* _tmp0_;
      ValaArrayType* _tmp1_;
      ValaArrayType* array_type;
      ValaTypeSymbol* _tmp2_ = NULL;
      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 (VALA_IS_ARRAY_TYPE (_tmp0_) ? ((ValaArrayType*) _tmp0_) : NULL);
      array_type = _tmp1_;
      _tmp2_ = vala_data_type_get_data_type (type_reference);
      if (_tmp2_ != NULL) {
            ValaTypeSymbol* _tmp3_ = NULL;
            gchar* _tmp4_ = NULL;
            gchar* _tmp5_;
            ValaCCodeIdentifier* _tmp6_ = NULL;
            ValaCCodeIdentifier* _tmp7_;
            _tmp3_ = vala_data_type_get_data_type (type_reference);
            _tmp4_ = vala_typesymbol_get_get_value_function (_tmp3_);
            _tmp5_ = _tmp4_;
            _tmp6_ = vala_ccode_identifier_new (_tmp5_);
            _tmp7_ = _tmp6_;
            _g_free0 (_tmp5_);
            result = _tmp7_;
            _vala_code_node_unref0 (array_type);
            return result;
      } else {
            gboolean _tmp8_ = FALSE;
            if (array_type != NULL) {
                  ValaDataType* _tmp9_ = NULL;
                  ValaTypeSymbol* _tmp10_ = NULL;
                  ValaTypeSymbol* _tmp11_ = NULL;
                  _tmp9_ = vala_array_type_get_element_type (array_type);
                  _tmp10_ = vala_data_type_get_data_type (_tmp9_);
                  _tmp11_ = vala_data_type_get_data_type (self->string_type);
                  _tmp8_ = _tmp10_ == _tmp11_;
            } else {
                  _tmp8_ = FALSE;
            }
            if (_tmp8_) {
                  ValaCCodeIdentifier* _tmp12_ = NULL;
                  _tmp12_ = vala_ccode_identifier_new ("g_value_get_boxed");
                  result = _tmp12_;
                  _vala_code_node_unref0 (array_type);
                  return result;
            } else {
                  ValaCCodeIdentifier* _tmp13_ = NULL;
                  _tmp13_ = vala_ccode_identifier_new ("g_value_get_pointer");
                  result = _tmp13_;
                  _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) {
      g_return_if_fail (self != NULL);
}


void vala_ccode_base_module_append_vala_array_free (ValaCCodeBaseModule* self) {
      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) {
      g_return_if_fail (self != NULL);
}


void vala_ccode_base_module_append_vala_array_move (ValaCCodeBaseModule* self) {
      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) {
      g_return_if_fail (self != NULL);
}


void vala_ccode_base_module_append_vala_array_length (ValaCCodeBaseModule* self) {
      VALA_CCODE_BASE_MODULE_GET_CLASS (self)->append_vala_array_length (self);
}


static void vala_ccode_base_module_real_visit_source_file (ValaCodeVisitor* base, ValaSourceFile* source_file) {
      ValaCCodeBaseModule * self;
      ValaCCodeFile* _tmp0_ = NULL;
      ValaHashSet* _tmp1_ = NULL;
      ValaHashSet* _tmp2_ = NULL;
      ValaHashSet* _tmp3_ = NULL;
      ValaProfile _tmp4_;
      ValaReport* _tmp5_ = NULL;
      gint _tmp6_;
      ValaSourceFileType _tmp7_;
      ValaList* _tmp8_ = NULL;
      ValaList* comments;
      gchar* _tmp14_ = NULL;
      gchar* _tmp15_;
      const gchar* _tmp16_ = NULL;
      gboolean _tmp17_;
      gboolean _tmp18_;
      gboolean _tmp19_;
      gboolean _tmp20_;
      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_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);
      _vala_iterable_unref0 (self->user_marshal_set);
      self->user_marshal_set = (ValaSet*) _tmp1_;
      self->next_regex_id = 0;
      self->gvaluecollector_h_needed = FALSE;
      self->requires_array_free = FALSE;
      self->requires_array_move = FALSE;
      self->requires_array_length = FALSE;
      _tmp2_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);
      _vala_iterable_unref0 (self->wrappers);
      self->wrappers = (ValaSet*) _tmp2_;
      _tmp3_ = vala_hash_set_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_hash, g_direct_equal);
      _vala_iterable_unref0 (self->priv->generated_external_symbols);
      self->priv->generated_external_symbols = (ValaSet*) _tmp3_;
      _tmp4_ = vala_code_context_get_profile (self->priv->_context);
      if (_tmp4_ == VALA_PROFILE_GOBJECT) {
            vala_ccode_file_add_include (self->header_file, "glib.h", FALSE);
            vala_ccode_file_add_include (self->internal_header_file, "glib.h", FALSE);
            vala_ccode_file_add_include (self->cfile, "glib.h", FALSE);
            vala_ccode_file_add_include (self->cfile, "glib-object.h", FALSE);
      }
      vala_source_file_accept_children (source_file, (ValaCodeVisitor*) self);
      _tmp5_ = vala_code_context_get_report (self->priv->_context);
      _tmp6_ = vala_report_get_errors (_tmp5_);
      if (_tmp6_ > 0) {
            return;
      }
      _tmp7_ = vala_source_file_get_file_type (source_file);
      if (_tmp7_ == VALA_SOURCE_FILE_TYPE_FAST) {
            return;
      }
      if (self->requires_array_free) {
            vala_ccode_base_module_append_vala_array_free (self);
      }
      if (self->requires_array_move) {
            vala_ccode_base_module_append_vala_array_move (self);
      }
      if (self->requires_array_length) {
            vala_ccode_base_module_append_vala_array_length (self);
      }
      if (self->gvaluecollector_h_needed) {
            vala_ccode_file_add_include (self->cfile, "gobject/gvaluecollector.h", FALSE);
      }
      _tmp8_ = vala_source_file_get_comments (source_file);
      comments = _tmp8_;
      if (comments != NULL) {
            {
                  ValaList* _tmp9_;
                  ValaList* _comment_list;
                  gint _tmp10_;
                  gint _comment_size;
                  gint _comment_index;
                  _tmp9_ = _vala_iterable_ref0 (comments);
                  _comment_list = _tmp9_;
                  _tmp10_ = vala_collection_get_size ((ValaCollection*) _comment_list);
                  _comment_size = _tmp10_;
                  _comment_index = -1;
                  while (TRUE) {
                        gpointer _tmp11_ = NULL;
                        ValaComment* comment;
                        const gchar* _tmp12_ = NULL;
                        ValaCCodeComment* _tmp13_ = NULL;
                        ValaCCodeComment* ccomment;
                        _comment_index = _comment_index + 1;
                        if (!(_comment_index < _comment_size)) {
                              break;
                        }
                        _tmp11_ = vala_list_get (_comment_list, _comment_index);
                        comment = (ValaComment*) _tmp11_;
                        _tmp12_ = vala_comment_get_content (comment);
                        _tmp13_ = vala_ccode_comment_new (_tmp12_);
                        ccomment = _tmp13_;
                        vala_ccode_file_add_comment (self->cfile, ccomment);
                        _vala_ccode_node_unref0 (ccomment);
                        _vala_comment_unref0 (comment);
                  }
                  _vala_iterable_unref0 (_comment_list);
            }
      }
      _tmp14_ = vala_source_file_get_csource_filename (source_file);
      _tmp15_ = _tmp14_;
      _tmp16_ = vala_source_file_get_filename (source_file);
      _tmp17_ = vala_code_context_get_version_header (self->priv->_context);
      _tmp18_ = vala_code_context_get_debug (self->priv->_context);
      _tmp19_ = vala_ccode_file_store (self->cfile, _tmp15_, _tmp16_, _tmp17_, _tmp18_, NULL, NULL);
      _tmp20_ = !_tmp19_;
      _g_free0 (_tmp15_);
      if (_tmp20_) {
            gchar* _tmp21_ = NULL;
            gchar* _tmp22_;
            gchar* _tmp23_ = NULL;
            gchar* _tmp24_;
            _tmp21_ = vala_source_file_get_csource_filename (source_file);
            _tmp22_ = _tmp21_;
            _tmp23_ = g_strdup_printf ("unable to open `%s' for writing", _tmp22_);
            _tmp24_ = _tmp23_;
            vala_report_error (NULL, _tmp24_);
            _g_free0 (_tmp24_);
            _g_free0 (_tmp22_);
      }
      _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;
      gchar* _tmp0_ = NULL;
      gchar* _tmp1_;
      gboolean _tmp2_;
      gboolean _tmp3_;
      gchar* _tmp4_ = NULL;
      gchar* _tmp5_;
      ValaCCodeEnum* _tmp6_ = NULL;
      ValaCCodeEnum* _tmp7_;
      ValaCCodeEnum* cenum;
      gboolean _tmp8_;
      gint flag_shift;
      ValaCCodeNewline* _tmp29_ = NULL;
      ValaCCodeNewline* _tmp30_;
      gboolean _tmp31_;
      ValaCCodeNewline* _tmp32_ = NULL;
      ValaCCodeNewline* _tmp33_;
      gchar* _tmp34_ = NULL;
      gchar* _tmp35_;
      gchar* _tmp36_ = NULL;
      gchar* _tmp37_;
      gchar* macro;
      gchar* _tmp38_ = NULL;
      gchar* _tmp39_;
      ValaCCodeMacroReplacement* _tmp40_ = NULL;
      ValaCCodeMacroReplacement* _tmp41_;
      gchar* _tmp42_ = NULL;
      gchar* _tmp43_;
      gchar* _tmp44_ = NULL;
      gchar* _tmp45_;
      gchar* fun_name;
      ValaCCodeFunction* _tmp46_ = NULL;
      ValaCCodeFunction* regfun;
      ValaSymbolAccessibility _tmp47_;
      g_return_val_if_fail (self != NULL, FALSE);
      g_return_val_if_fail (en != NULL, FALSE);
      g_return_val_if_fail (decl_space != NULL, FALSE);
      _tmp0_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) en, FALSE);
      _tmp1_ = _tmp0_;
      _tmp2_ = vala_ccode_base_module_add_symbol_declaration (self, decl_space, (ValaSymbol*) en, _tmp1_);
      _tmp3_ = _tmp2_;
      _g_free0 (_tmp1_);
      if (_tmp3_) {
            result = FALSE;
            return result;
      }
      _tmp4_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) en, FALSE);
      _tmp5_ = _tmp4_;
      _tmp6_ = vala_ccode_enum_new (_tmp5_);
      _tmp7_ = _tmp6_;
      _g_free0 (_tmp5_);
      cenum = _tmp7_;
      _tmp8_ = vala_symbol_get_deprecated ((ValaSymbol*) en);
      vala_ccode_enum_set_deprecated (cenum, _tmp8_);
      flag_shift = 0;
      {
            ValaList* _tmp9_ = NULL;
            ValaList* _ev_list;
            gint _tmp10_;
            gint _ev_size;
            gint _ev_index;
            _tmp9_ = vala_enum_get_values (en);
            _ev_list = _tmp9_;
            _tmp10_ = vala_collection_get_size ((ValaCollection*) _ev_list);
            _ev_size = _tmp10_;
            _ev_index = -1;
            while (TRUE) {
                  gpointer _tmp11_ = NULL;
                  ValaEnumValue* ev;
                  ValaCCodeEnumValue* c_ev = NULL;
                  ValaExpression* _tmp12_ = NULL;
                  gboolean _tmp28_;
                  _ev_index = _ev_index + 1;
                  if (!(_ev_index < _ev_size)) {
                        break;
                  }
                  _tmp11_ = vala_list_get (_ev_list, _ev_index);
                  ev = (ValaEnumValue*) _tmp11_;
                  _tmp12_ = vala_constant_get_value ((ValaConstant*) ev);
                  if (_tmp12_ == NULL) {
                        gchar* _tmp13_ = NULL;
                        gchar* _tmp14_;
                        ValaCCodeEnumValue* _tmp15_ = NULL;
                        gboolean _tmp16_;
                        _tmp13_ = vala_constant_get_cname ((ValaConstant*) ev);
                        _tmp14_ = _tmp13_;
                        _tmp15_ = vala_ccode_enum_value_new (_tmp14_, NULL);
                        _vala_ccode_node_unref0 (c_ev);
                        c_ev = _tmp15_;
                        _g_free0 (_tmp14_);
                        _tmp16_ = vala_enum_get_is_flags (en);
                        if (_tmp16_) {
                              gchar* _tmp17_ = NULL;
                              gchar* _tmp18_;
                              ValaCCodeConstant* _tmp19_ = NULL;
                              ValaCCodeConstant* _tmp20_;
                              _tmp17_ = g_strdup_printf ("1 << %d", flag_shift);
                              _tmp18_ = _tmp17_;
                              _tmp19_ = vala_ccode_constant_new (_tmp18_);
                              _tmp20_ = _tmp19_;
                              vala_ccode_enum_value_set_value (c_ev, (ValaCCodeExpression*) _tmp20_);
                              _vala_ccode_node_unref0 (_tmp20_);
                              _g_free0 (_tmp18_);
                              flag_shift = flag_shift + 1;
                        }
                  } else {
                        ValaExpression* _tmp21_ = NULL;
                        gchar* _tmp22_ = NULL;
                        gchar* _tmp23_;
                        ValaExpression* _tmp24_ = NULL;
                        ValaCCodeExpression* _tmp25_ = NULL;
                        ValaCCodeExpression* _tmp26_;
                        ValaCCodeEnumValue* _tmp27_ = NULL;
                        _tmp21_ = vala_constant_get_value ((ValaConstant*) ev);
                        vala_code_node_emit ((ValaCodeNode*) _tmp21_, (ValaCodeGenerator*) self);
                        _tmp22_ = vala_constant_get_cname ((ValaConstant*) ev);
                        _tmp23_ = _tmp22_;
                        _tmp24_ = vala_constant_get_value ((ValaConstant*) ev);
                        _tmp25_ = vala_ccode_base_module_get_cvalue (self, _tmp24_);
                        _tmp26_ = _tmp25_;
                        _tmp27_ = vala_ccode_enum_value_new (_tmp23_, _tmp26_);
                        _vala_ccode_node_unref0 (c_ev);
                        c_ev = _tmp27_;
                        _vala_ccode_node_unref0 (_tmp26_);
                        _g_free0 (_tmp23_);
                  }
                  _tmp28_ = vala_symbol_get_deprecated ((ValaSymbol*) ev);
                  vala_ccode_enum_value_set_deprecated (c_ev, _tmp28_);
                  vala_ccode_enum_add_value (cenum, c_ev);
                  _vala_ccode_node_unref0 (c_ev);
                  _vala_code_node_unref0 (ev);
            }
            _vala_iterable_unref0 (_ev_list);
      }
      vala_ccode_file_add_type_definition (decl_space, (ValaCCodeNode*) cenum);
      _tmp29_ = vala_ccode_newline_new ();
      _tmp30_ = _tmp29_;
      vala_ccode_file_add_type_definition (decl_space, (ValaCCodeNode*) _tmp30_);
      _vala_ccode_node_unref0 (_tmp30_);
      _tmp31_ = vala_enum_get_has_type_id (en);
      if (!_tmp31_) {
            result = TRUE;
            _vala_ccode_node_unref0 (cenum);
            return result;
      }
      _tmp32_ = vala_ccode_newline_new ();
      _tmp33_ = _tmp32_;
      vala_ccode_file_add_type_declaration (decl_space, (ValaCCodeNode*) _tmp33_);
      _vala_ccode_node_unref0 (_tmp33_);
      _tmp34_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) en, NULL);
      _tmp35_ = _tmp34_;
      _tmp36_ = g_strdup_printf ("(%s_get_type ())", _tmp35_);
      _tmp37_ = _tmp36_;
      _g_free0 (_tmp35_);
      macro = _tmp37_;
      _tmp38_ = vala_typesymbol_get_type_id ((ValaTypeSymbol*) en);
      _tmp39_ = _tmp38_;
      _tmp40_ = vala_ccode_macro_replacement_new (_tmp39_, macro);
      _tmp41_ = _tmp40_;
      vala_ccode_file_add_type_declaration (decl_space, (ValaCCodeNode*) _tmp41_);
      _vala_ccode_node_unref0 (_tmp41_);
      _g_free0 (_tmp39_);
      _tmp42_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) en, NULL);
      _tmp43_ = _tmp42_;
      _tmp44_ = g_strdup_printf ("%s_get_type", _tmp43_);
      _tmp45_ = _tmp44_;
      _g_free0 (_tmp43_);
      fun_name = _tmp45_;
      _tmp46_ = vala_ccode_function_new (fun_name, "GType");
      regfun = _tmp46_;
      vala_ccode_function_set_attributes (regfun, "G_GNUC_CONST");
      _tmp47_ = vala_symbol_get_access ((ValaSymbol*) en);
      if (_tmp47_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) {
            vala_ccode_function_set_modifiers (regfun, VALA_CCODE_MODIFIERS_STATIC);
            vala_ccode_function_set_attributes (regfun, "G_GNUC_UNUSED");
      }
      vala_ccode_file_add_function_declaration (decl_space, regfun);
      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) {
      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;
      ValaComment* _tmp0_ = NULL;
      gboolean _tmp5_;
      gboolean _tmp6_;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (en != NULL);
      vala_code_node_accept_children ((ValaCodeNode*) en, (ValaCodeVisitor*) self);
      _tmp0_ = vala_symbol_get_comment ((ValaSymbol*) en);
      if (_tmp0_ != NULL) {
            ValaComment* _tmp1_ = NULL;
            const gchar* _tmp2_ = NULL;
            ValaCCodeComment* _tmp3_ = NULL;
            ValaCCodeComment* _tmp4_;
            _tmp1_ = vala_symbol_get_comment ((ValaSymbol*) en);
            _tmp2_ = vala_comment_get_content (_tmp1_);
            _tmp3_ = vala_ccode_comment_new (_tmp2_);
            _tmp4_ = _tmp3_;
            vala_ccode_file_add_type_member_definition (self->cfile, (ValaCCodeNode*) _tmp4_);
            _vala_ccode_node_unref0 (_tmp4_);
      }
      vala_ccode_base_module_generate_enum_declaration (self, en, self->cfile);
      _tmp5_ = vala_symbol_is_internal_symbol ((ValaSymbol*) en);
      if (!_tmp5_) {
            vala_ccode_base_module_generate_enum_declaration (self, en, self->header_file);
      }
      _tmp6_ = vala_symbol_is_private_symbol ((ValaSymbol*) en);
      if (!_tmp6_) {
            vala_ccode_base_module_generate_enum_declaration (self, en, self->internal_header_file);
      }
}


void vala_ccode_base_module_visit_member (ValaCCodeBaseModule* self, ValaSymbol* m) {
      gboolean _tmp0_ = FALSE;
      g_return_if_fail (self != NULL);
      g_return_if_fail (m != NULL);
      if (VALA_IS_LOCKABLE (m)) {
            gboolean _tmp1_;
            _tmp1_ = vala_lockable_get_lock_used (VALA_LOCKABLE (m));
            _tmp0_ = _tmp1_;
      } else {
            _tmp0_ = FALSE;
      }
      if (_tmp0_) {
            ValaCCodeIdentifier* _tmp2_ = NULL;
            ValaCCodeExpression* l;
            ValaCCodeBaseModuleEmitContext* _tmp3_;
            ValaCCodeBaseModuleEmitContext* init_context;
            ValaCCodeBaseModuleEmitContext* _tmp4_;
            ValaCCodeBaseModuleEmitContext* finalize_context;
            gboolean _tmp5_;
            ValaMethod* _tmp40_ = NULL;
            gchar* _tmp41_ = NULL;
            gchar* _tmp42_;
            ValaCCodeIdentifier* _tmp43_ = NULL;
            ValaCCodeIdentifier* _tmp44_;
            ValaCCodeFunctionCall* _tmp45_ = NULL;
            ValaCCodeFunctionCall* _tmp46_;
            ValaCCodeFunctionCall* initf;
            ValaCCodeUnaryExpression* _tmp47_ = NULL;
            ValaCCodeUnaryExpression* _tmp48_;
            ValaCCodeFunction* _tmp49_ = NULL;
            _tmp2_ = vala_ccode_identifier_new ("self");
            l = (ValaCCodeExpression*) _tmp2_;
            _tmp3_ = _vala_ccode_base_module_emit_context_ref0 (self->class_init_context);
            init_context = _tmp3_;
            _tmp4_ = _vala_ccode_base_module_emit_context_ref0 (self->class_finalize_context);
            finalize_context = _tmp4_;
            _tmp5_ = vala_symbol_is_instance_member (m);
            if (_tmp5_) {
                  ValaCCodeMemberAccess* _tmp6_ = NULL;
                  ValaCCodeMemberAccess* _tmp7_;
                  const gchar* _tmp8_ = NULL;
                  gchar* _tmp9_ = NULL;
                  gchar* _tmp10_;
                  ValaCCodeMemberAccess* _tmp11_ = NULL;
                  ValaCCodeBaseModuleEmitContext* _tmp12_;
                  ValaCCodeBaseModuleEmitContext* _tmp13_;
                  _tmp6_ = vala_ccode_member_access_new_pointer (l, "priv");
                  _tmp7_ = _tmp6_;
                  _tmp8_ = vala_symbol_get_name (m);
                  _tmp9_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp8_);
                  _tmp10_ = _tmp9_;
                  _tmp11_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp7_, _tmp10_);
                  _vala_ccode_node_unref0 (l);
                  l = (ValaCCodeExpression*) _tmp11_;
                  _g_free0 (_tmp10_);
                  _vala_ccode_node_unref0 (_tmp7_);
                  _tmp12_ = _vala_ccode_base_module_emit_context_ref0 (self->instance_init_context);
                  _vala_ccode_base_module_emit_context_unref0 (init_context);
                  init_context = _tmp12_;
                  _tmp13_ = _vala_ccode_base_module_emit_context_ref0 (self->instance_finalize_context);
                  _vala_ccode_base_module_emit_context_unref0 (finalize_context);
                  finalize_context = _tmp13_;
            } else {
                  gboolean _tmp14_;
                  _tmp14_ = vala_symbol_is_class_member (m);
                  if (_tmp14_) {
                        ValaSymbol* _tmp15_ = NULL;
                        ValaTypeSymbol* _tmp16_;
                        ValaTypeSymbol* parent;
                        gchar* _tmp17_ = NULL;
                        gchar* _tmp18_;
                        gchar* _tmp19_ = NULL;
                        gchar* _tmp20_;
                        ValaCCodeIdentifier* _tmp21_ = NULL;
                        ValaCCodeIdentifier* _tmp22_;
                        ValaCCodeFunctionCall* _tmp23_ = NULL;
                        ValaCCodeFunctionCall* _tmp24_;
                        ValaCCodeFunctionCall* get_class_private_call;
                        ValaCCodeIdentifier* _tmp25_ = NULL;
                        ValaCCodeIdentifier* _tmp26_;
                        const gchar* _tmp27_ = NULL;
                        gchar* _tmp28_ = NULL;
                        gchar* _tmp29_;
                        ValaCCodeMemberAccess* _tmp30_ = NULL;
                        _tmp15_ = vala_symbol_get_parent_symbol (m);
                        _tmp16_ = _vala_code_node_ref0 (VALA_TYPESYMBOL (_tmp15_));
                        parent = _tmp16_;
                        _tmp17_ = vala_typesymbol_get_upper_case_cname (parent, NULL);
                        _tmp18_ = _tmp17_;
                        _tmp19_ = g_strdup_printf ("%s_GET_CLASS_PRIVATE", _tmp18_);
                        _tmp20_ = _tmp19_;
                        _tmp21_ = vala_ccode_identifier_new (_tmp20_);
                        _tmp22_ = _tmp21_;
                        _tmp23_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp22_);
                        _tmp24_ = _tmp23_;
                        _vala_ccode_node_unref0 (_tmp22_);
                        _g_free0 (_tmp20_);
                        _g_free0 (_tmp18_);
                        get_class_private_call = _tmp24_;
                        _tmp25_ = vala_ccode_identifier_new ("klass");
                        _tmp26_ = _tmp25_;
                        vala_ccode_function_call_add_argument (get_class_private_call, (ValaCCodeExpression*) _tmp26_);
                        _vala_ccode_node_unref0 (_tmp26_);
                        _tmp27_ = vala_symbol_get_name (m);
                        _tmp28_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp27_);
                        _tmp29_ = _tmp28_;
                        _tmp30_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) get_class_private_call, _tmp29_);
                        _vala_ccode_node_unref0 (l);
                        l = (ValaCCodeExpression*) _tmp30_;
                        _g_free0 (_tmp29_);
                        _vala_ccode_node_unref0 (get_class_private_call);
                        _vala_code_node_unref0 (parent);
                  } else {
                        ValaSymbol* _tmp31_ = NULL;
                        gchar* _tmp32_ = NULL;
                        gchar* _tmp33_;
                        const gchar* _tmp34_ = NULL;
                        gchar* _tmp35_ = NULL;
                        gchar* _tmp36_;
                        gchar* _tmp37_ = NULL;
                        gchar* _tmp38_;
                        ValaCCodeIdentifier* _tmp39_ = NULL;
                        _tmp31_ = vala_symbol_get_parent_symbol (m);
                        _tmp32_ = vala_symbol_get_lower_case_cname (_tmp31_, NULL);
                        _tmp33_ = _tmp32_;
                        _tmp34_ = vala_symbol_get_name (m);
                        _tmp35_ = g_strdup_printf ("%s_%s", _tmp33_, _tmp34_);
                        _tmp36_ = _tmp35_;
                        _tmp37_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp36_);
                        _tmp38_ = _tmp37_;
                        _tmp39_ = vala_ccode_identifier_new (_tmp38_);
                        _vala_ccode_node_unref0 (l);
                        l = (ValaCCodeExpression*) _tmp39_;
                        _g_free0 (_tmp38_);
                        _g_free0 (_tmp36_);
                        _g_free0 (_tmp33_);
                  }
            }
            vala_ccode_base_module_push_context (self, init_context);
            _tmp40_ = vala_struct_get_default_construction_method (self->mutex_type);
            _tmp41_ = vala_method_get_cname (_tmp40_);
            _tmp42_ = _tmp41_;
            _tmp43_ = vala_ccode_identifier_new (_tmp42_);
            _tmp44_ = _tmp43_;
            _tmp45_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp44_);
            _tmp46_ = _tmp45_;
            _vala_ccode_node_unref0 (_tmp44_);
            _g_free0 (_tmp42_);
            initf = _tmp46_;
            _tmp47_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, l);
            _tmp48_ = _tmp47_;
            vala_ccode_function_call_add_argument (initf, (ValaCCodeExpression*) _tmp48_);
            _vala_ccode_node_unref0 (_tmp48_);
            _tmp49_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_expression (_tmp49_, (ValaCCodeExpression*) initf);
            vala_ccode_base_module_pop_context (self);
            if (finalize_context != NULL) {
                  ValaCCodeIdentifier* _tmp50_ = NULL;
                  ValaCCodeIdentifier* _tmp51_;
                  ValaCCodeFunctionCall* _tmp52_ = NULL;
                  ValaCCodeFunctionCall* _tmp53_;
                  ValaCCodeFunctionCall* fc;
                  ValaCCodeUnaryExpression* _tmp54_ = NULL;
                  ValaCCodeUnaryExpression* _tmp55_;
                  ValaCCodeFunction* _tmp56_ = NULL;
                  vala_ccode_base_module_push_context (self, finalize_context);
                  _tmp50_ = vala_ccode_identifier_new ("g_static_rec_mutex_free");
                  _tmp51_ = _tmp50_;
                  _tmp52_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp51_);
                  _tmp53_ = _tmp52_;
                  _vala_ccode_node_unref0 (_tmp51_);
                  fc = _tmp53_;
                  _tmp54_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, l);
                  _tmp55_ = _tmp54_;
                  vala_ccode_function_call_add_argument (fc, (ValaCCodeExpression*) _tmp55_);
                  _vala_ccode_node_unref0 (_tmp55_);
                  _tmp56_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_expression (_tmp56_, (ValaCCodeExpression*) fc);
                  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) {
      ValaSymbol* _tmp0_ = NULL;
      gchar* _tmp1_ = NULL;
      gchar* _tmp2_;
      gboolean _tmp3_;
      gboolean _tmp4_;
      gboolean _tmp5_;
      g_return_if_fail (self != NULL);
      g_return_if_fail (c != NULL);
      g_return_if_fail (decl_space != NULL);
      _tmp0_ = vala_symbol_get_parent_symbol ((ValaSymbol*) c);
      if (VALA_IS_BLOCK (_tmp0_)) {
            return;
      }
      _tmp1_ = vala_constant_get_cname (c);
      _tmp2_ = _tmp1_;
      _tmp3_ = vala_ccode_base_module_add_symbol_declaration (self, decl_space, (ValaSymbol*) c, _tmp2_);
      _tmp4_ = _tmp3_;
      _g_free0 (_tmp2_);
      if (_tmp4_) {
            return;
      }
      _tmp5_ = vala_symbol_get_external ((ValaSymbol*) c);
      if (!_tmp5_) {
            ValaDataType* _tmp6_ = NULL;
            ValaExpression* _tmp7_ = NULL;
            ValaExpression* _tmp8_ = NULL;
            ValaExpression* _tmp9_;
            ValaInitializerList* _tmp10_;
            ValaInitializerList* initializer_list;
            _tmp6_ = vala_constant_get_type_reference (c);
            vala_ccode_base_module_generate_type_declaration (self, _tmp6_, decl_space);
            _tmp7_ = vala_constant_get_value (c);
            vala_code_node_emit ((ValaCodeNode*) _tmp7_, (ValaCodeGenerator*) self);
            _tmp8_ = vala_constant_get_value (c);
            _tmp9_ = _tmp8_;
            _tmp10_ = _vala_code_node_ref0 (VALA_IS_INITIALIZER_LIST (_tmp9_) ? ((ValaInitializerList*) _tmp9_) : NULL);
            initializer_list = _tmp10_;
            if (initializer_list != NULL) {
                  ValaDataType* _tmp11_ = NULL;
                  gchar* _tmp12_ = NULL;
                  gchar* _tmp13_;
                  ValaCCodeDeclaration* _tmp14_ = NULL;
                  ValaCCodeDeclaration* _tmp15_;
                  ValaCCodeDeclaration* _cdecl_;
                  gchar* _tmp16_;
                  gchar* arr;
                  ValaDataType* _tmp17_ = NULL;
                  ValaExpression* _tmp20_ = NULL;
                  ValaCCodeExpression* _tmp21_ = NULL;
                  ValaCCodeExpression* cinitializer;
                  gchar* _tmp22_ = NULL;
                  gchar* _tmp23_;
                  gchar* _tmp24_ = NULL;
                  gchar* _tmp25_;
                  ValaCCodeVariableDeclarator* _tmp26_ = NULL;
                  ValaCCodeVariableDeclarator* _tmp27_;
                  gboolean _tmp28_;
                  _tmp11_ = vala_constant_get_type_reference (c);
                  _tmp12_ = vala_data_type_get_const_cname (_tmp11_);
                  _tmp13_ = _tmp12_;
                  _tmp14_ = vala_ccode_declaration_new (_tmp13_);
                  _tmp15_ = _tmp14_;
                  _g_free0 (_tmp13_);
                  _cdecl_ = _tmp15_;
                  _tmp16_ = g_strdup ("");
                  arr = _tmp16_;
                  _tmp17_ = vala_constant_get_type_reference (c);
                  if (VALA_IS_ARRAY_TYPE (_tmp17_)) {
                        gint _tmp18_;
                        gchar* _tmp19_ = NULL;
                        _tmp18_ = vala_initializer_list_get_size (initializer_list);
                        _tmp19_ = g_strdup_printf ("[%d]", _tmp18_);
                        _g_free0 (arr);
                        arr = _tmp19_;
                  }
                  _tmp20_ = vala_constant_get_value (c);
                  _tmp21_ = vala_ccode_base_module_get_cvalue (self, _tmp20_);
                  cinitializer = _tmp21_;
                  if (!definition) {
                        _vala_ccode_node_unref0 (cinitializer);
                        cinitializer = NULL;
                  }
                  _tmp22_ = vala_constant_get_cname (c);
                  _tmp23_ = _tmp22_;
                  _tmp24_ = g_strdup_printf ("%s%s", _tmp23_, arr);
                  _tmp25_ = _tmp24_;
                  _tmp26_ = vala_ccode_variable_declarator_new (_tmp25_, cinitializer, NULL);
                  _tmp27_ = _tmp26_;
                  vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp27_);
                  _vala_ccode_node_unref0 (_tmp27_);
                  _g_free0 (_tmp25_);
                  _g_free0 (_tmp23_);
                  _tmp28_ = vala_symbol_is_private_symbol ((ValaSymbol*) c);
                  if (_tmp28_) {
                        vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);
                  } else {
                        vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_EXTERN);
                  }
                  vala_ccode_file_add_constant_declaration (decl_space, (ValaCCodeNode*) _cdecl_);
                  _vala_ccode_node_unref0 (cinitializer);
                  _g_free0 (arr);
                  _vala_ccode_node_unref0 (_cdecl_);
            } else {
                  gchar* _tmp29_ = NULL;
                  gchar* _tmp30_;
                  ValaExpression* _tmp31_ = NULL;
                  ValaCCodeExpression* _tmp32_ = NULL;
                  ValaCCodeExpression* _tmp33_;
                  ValaCCodeMacroReplacement* _tmp34_ = NULL;
                  ValaCCodeMacroReplacement* _tmp35_;
                  ValaCCodeMacroReplacement* cdefine;
                  _tmp29_ = vala_constant_get_cname (c);
                  _tmp30_ = _tmp29_;
                  _tmp31_ = vala_constant_get_value (c);
                  _tmp32_ = vala_ccode_base_module_get_cvalue (self, _tmp31_);
                  _tmp33_ = _tmp32_;
                  _tmp34_ = vala_ccode_macro_replacement_new_with_expression (_tmp30_, _tmp33_);
                  _tmp35_ = _tmp34_;
                  _vala_ccode_node_unref0 (_tmp33_);
                  _g_free0 (_tmp30_);
                  cdefine = _tmp35_;
                  vala_ccode_file_add_type_member_declaration (decl_space, (ValaCCodeNode*) cdefine);
                  _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;
      ValaSymbol* _tmp0_ = NULL;
      gboolean _tmp21_;
      gboolean _tmp22_;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (c != NULL);
      _tmp0_ = vala_symbol_get_parent_symbol ((ValaSymbol*) c);
      if (VALA_IS_BLOCK (_tmp0_)) {
            ValaDataType* _tmp1_ = NULL;
            ValaExpression* _tmp2_ = NULL;
            ValaDataType* _tmp3_ = NULL;
            gchar* _tmp4_ = NULL;
            gchar* type_name;
            gchar* _tmp5_;
            gchar* arr;
            ValaDataType* _tmp6_ = NULL;
            ValaDataType* _tmp8_ = NULL;
            gboolean _tmp9_;
            ValaExpression* _tmp12_ = NULL;
            ValaCCodeExpression* _tmp13_ = NULL;
            ValaCCodeExpression* cinitializer;
            ValaCCodeFunction* _tmp14_ = NULL;
            gchar* _tmp15_ = NULL;
            gchar* _tmp16_;
            gchar* _tmp17_ = NULL;
            gchar* _tmp18_;
            ValaCCodeVariableDeclarator* _tmp19_ = NULL;
            ValaCCodeVariableDeclarator* _tmp20_;
            _tmp1_ = vala_constant_get_type_reference (c);
            vala_ccode_base_module_generate_type_declaration (self, _tmp1_, self->cfile);
            _tmp2_ = vala_constant_get_value (c);
            vala_code_node_emit ((ValaCodeNode*) _tmp2_, (ValaCodeGenerator*) self);
            _tmp3_ = vala_constant_get_type_reference (c);
            _tmp4_ = vala_data_type_get_const_cname (_tmp3_);
            type_name = _tmp4_;
            _tmp5_ = g_strdup ("");
            arr = _tmp5_;
            _tmp6_ = vala_constant_get_type_reference (c);
            if (VALA_IS_ARRAY_TYPE (_tmp6_)) {
                  gchar* _tmp7_;
                  _tmp7_ = g_strdup ("[]");
                  _g_free0 (arr);
                  arr = _tmp7_;
            }
            _tmp8_ = vala_constant_get_type_reference (c);
            _tmp9_ = vala_data_type_compatible (_tmp8_, self->string_type);
            if (_tmp9_) {
                  gchar* _tmp10_;
                  gchar* _tmp11_;
                  _tmp10_ = g_strdup ("const char");
                  _g_free0 (type_name);
                  type_name = _tmp10_;
                  _tmp11_ = g_strdup ("[]");
                  _g_free0 (arr);
                  arr = _tmp11_;
            }
            _tmp12_ = vala_constant_get_value (c);
            _tmp13_ = vala_ccode_base_module_get_cvalue (self, _tmp12_);
            cinitializer = _tmp13_;
            _tmp14_ = vala_ccode_base_module_get_ccode (self);
            _tmp15_ = vala_constant_get_cname (c);
            _tmp16_ = _tmp15_;
            _tmp17_ = g_strdup_printf ("%s%s", _tmp16_, arr);
            _tmp18_ = _tmp17_;
            _tmp19_ = vala_ccode_variable_declarator_new (_tmp18_, cinitializer, NULL);
            _tmp20_ = _tmp19_;
            vala_ccode_function_add_declaration (_tmp14_, type_name, (ValaCCodeDeclarator*) _tmp20_, VALA_CCODE_MODIFIERS_STATIC);
            _vala_ccode_node_unref0 (_tmp20_);
            _g_free0 (_tmp18_);
            _g_free0 (_tmp16_);
            _vala_ccode_node_unref0 (cinitializer);
            _g_free0 (arr);
            _g_free0 (type_name);
            return;
      }
      vala_ccode_base_module_generate_constant_declaration (self, c, self->cfile, TRUE);
      _tmp21_ = vala_symbol_is_internal_symbol ((ValaSymbol*) c);
      if (!_tmp21_) {
            vala_ccode_base_module_generate_constant_declaration (self, c, self->header_file, FALSE);
      }
      _tmp22_ = vala_symbol_is_private_symbol ((ValaSymbol*) c);
      if (!_tmp22_) {
            vala_ccode_base_module_generate_constant_declaration (self, c, self->internal_header_file, FALSE);
      }
}


void vala_ccode_base_module_generate_field_declaration (ValaCCodeBaseModule* self, ValaField* f, ValaCCodeFile* decl_space) {
      gchar* _tmp0_ = NULL;
      gchar* _tmp1_;
      gboolean _tmp2_;
      gboolean _tmp3_;
      ValaDataType* _tmp4_ = NULL;
      ValaDataType* _tmp5_ = NULL;
      gchar* _tmp6_ = NULL;
      gchar* field_ctype;
      gboolean _tmp7_;
      ValaCCodeDeclaration* _tmp9_ = NULL;
      ValaCCodeDeclaration* _cdecl_;
      gchar* _tmp10_ = NULL;
      gchar* _tmp11_;
      ValaDataType* _tmp12_ = NULL;
      gchar* _tmp13_ = NULL;
      gchar* _tmp14_;
      ValaCCodeVariableDeclarator* _tmp15_ = NULL;
      ValaCCodeVariableDeclarator* _tmp16_;
      gboolean _tmp17_;
      gboolean _tmp18_;
      gboolean _tmp20_;
      gboolean _tmp34_ = FALSE;
      ValaDataType* _tmp35_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (f != NULL);
      g_return_if_fail (decl_space != NULL);
      _tmp0_ = vala_field_get_cname (f);
      _tmp1_ = _tmp0_;
      _tmp2_ = vala_ccode_base_module_add_symbol_declaration (self, decl_space, (ValaSymbol*) f, _tmp1_);
      _tmp3_ = _tmp2_;
      _g_free0 (_tmp1_);
      if (_tmp3_) {
            return;
      }
      _tmp4_ = vala_variable_get_variable_type ((ValaVariable*) f);
      vala_ccode_base_module_generate_type_declaration (self, _tmp4_, decl_space);
      _tmp5_ = vala_variable_get_variable_type ((ValaVariable*) f);
      _tmp6_ = vala_data_type_get_cname (_tmp5_);
      field_ctype = _tmp6_;
      _tmp7_ = vala_field_get_is_volatile (f);
      if (_tmp7_) {
            gchar* _tmp8_;
            _tmp8_ = g_strconcat ("volatile ", field_ctype, NULL);
            _g_free0 (field_ctype);
            field_ctype = _tmp8_;
      }
      _tmp9_ = vala_ccode_declaration_new (field_ctype);
      _cdecl_ = _tmp9_;
      _tmp10_ = vala_field_get_cname (f);
      _tmp11_ = _tmp10_;
      _tmp12_ = vala_variable_get_variable_type ((ValaVariable*) f);
      _tmp13_ = vala_data_type_get_cdeclarator_suffix (_tmp12_);
      _tmp14_ = _tmp13_;
      _tmp15_ = vala_ccode_variable_declarator_new (_tmp11_, NULL, _tmp14_);
      _tmp16_ = _tmp15_;
      vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp16_);
      _vala_ccode_node_unref0 (_tmp16_);
      _g_free0 (_tmp14_);
      _g_free0 (_tmp11_);
      _tmp17_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
      if (_tmp17_) {
            vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);
      } else {
            vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_EXTERN);
      }
      _tmp18_ = vala_symbol_get_deprecated ((ValaSymbol*) f);
      if (_tmp18_) {
            ValaCCodeModifiers _tmp19_;
            _tmp19_ = vala_ccode_declaration_get_modifiers (_cdecl_);
            vala_ccode_declaration_set_modifiers (_cdecl_, _tmp19_ | VALA_CCODE_MODIFIERS_DEPRECATED);
      }
      vala_ccode_file_add_type_member_declaration (decl_space, (ValaCCodeNode*) _cdecl_);
      _tmp20_ = vala_lockable_get_lock_used ((ValaLockable*) f);
      if (_tmp20_) {
            gchar* _tmp21_ = NULL;
            gchar* _tmp22_;
            ValaCCodeDeclaration* _tmp23_ = NULL;
            ValaCCodeDeclaration* _tmp24_;
            ValaCCodeDeclaration* flock;
            gchar* _tmp25_ = NULL;
            gchar* _tmp26_;
            gchar* _tmp27_ = NULL;
            gchar* _tmp28_;
            ValaCCodeConstant* _tmp29_ = NULL;
            ValaCCodeConstant* _tmp30_;
            ValaCCodeVariableDeclarator* _tmp31_ = NULL;
            ValaCCodeVariableDeclarator* _tmp32_;
            ValaCCodeVariableDeclarator* flock_decl;
            gboolean _tmp33_;
            _tmp21_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) self->mutex_type, FALSE);
            _tmp22_ = _tmp21_;
            _tmp23_ = vala_ccode_declaration_new (_tmp22_);
            _tmp24_ = _tmp23_;
            _g_free0 (_tmp22_);
            flock = _tmp24_;
            _tmp25_ = vala_field_get_cname (f);
            _tmp26_ = _tmp25_;
            _tmp27_ = vala_ccode_base_module_get_symbol_lock_name (self, _tmp26_);
            _tmp28_ = _tmp27_;
            _tmp29_ = vala_ccode_constant_new ("{0}");
            _tmp30_ = _tmp29_;
            _tmp31_ = vala_ccode_variable_declarator_new (_tmp28_, (ValaCCodeExpression*) _tmp30_, NULL);
            _tmp32_ = _tmp31_;
            _vala_ccode_node_unref0 (_tmp30_);
            _g_free0 (_tmp28_);
            _g_free0 (_tmp26_);
            flock_decl = _tmp32_;
            vala_ccode_declaration_add_declarator (flock, (ValaCCodeDeclarator*) flock_decl);
            _tmp33_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
            if (_tmp33_) {
                  vala_ccode_declaration_set_modifiers (flock, VALA_CCODE_MODIFIERS_STATIC);
            } else {
                  vala_ccode_declaration_set_modifiers (flock, VALA_CCODE_MODIFIERS_EXTERN);
            }
            vala_ccode_file_add_type_member_declaration (decl_space, (ValaCCodeNode*) flock);
            _vala_ccode_node_unref0 (flock_decl);
            _vala_ccode_node_unref0 (flock);
      }
      _tmp35_ = vala_variable_get_variable_type ((ValaVariable*) f);
      if (VALA_IS_ARRAY_TYPE (_tmp35_)) {
            gboolean _tmp36_;
            _tmp36_ = vala_variable_get_no_array_length ((ValaVariable*) f);
            _tmp34_ = !_tmp36_;
      } else {
            _tmp34_ = FALSE;
      }
      if (_tmp34_) {
            ValaDataType* _tmp37_ = NULL;
            ValaArrayType* _tmp38_;
            ValaArrayType* array_type;
            gboolean _tmp39_;
            _tmp37_ = vala_variable_get_variable_type ((ValaVariable*) f);
            _tmp38_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp37_));
            array_type = _tmp38_;
            _tmp39_ = vala_array_type_get_fixed_length (array_type);
            if (!_tmp39_) {
                  {
                        gint dim;
                        dim = 1;
                        {
                              gboolean _tmp40_;
                              _tmp40_ = TRUE;
                              while (TRUE) {
                                    gint _tmp41_;
                                    ValaDataType* _tmp42_ = NULL;
                                    ValaDataType* len_type;
                                    gchar* _tmp43_ = NULL;
                                    gchar* _tmp44_;
                                    ValaCCodeDeclaration* _tmp45_ = NULL;
                                    gchar* _tmp46_ = NULL;
                                    gchar* _tmp47_;
                                    gchar* _tmp48_ = NULL;
                                    gchar* _tmp49_;
                                    ValaCCodeVariableDeclarator* _tmp50_ = NULL;
                                    ValaCCodeVariableDeclarator* _tmp51_;
                                    gboolean _tmp52_;
                                    if (!_tmp40_) {
                                          dim++;
                                    }
                                    _tmp40_ = FALSE;
                                    _tmp41_ = vala_array_type_get_rank (array_type);
                                    if (!(dim <= _tmp41_)) {
                                          break;
                                    }
                                    _tmp42_ = vala_data_type_copy (self->int_type);
                                    len_type = _tmp42_;
                                    _tmp43_ = vala_data_type_get_cname (len_type);
                                    _tmp44_ = _tmp43_;
                                    _tmp45_ = vala_ccode_declaration_new (_tmp44_);
                                    _vala_ccode_node_unref0 (_cdecl_);
                                    _cdecl_ = _tmp45_;
                                    _g_free0 (_tmp44_);
                                    _tmp46_ = vala_field_get_cname (f);
                                    _tmp47_ = _tmp46_;
                                    _tmp48_ = vala_ccode_base_module_get_array_length_cname (self, _tmp47_, dim);
                                    _tmp49_ = _tmp48_;
                                    _tmp50_ = vala_ccode_variable_declarator_new (_tmp49_, NULL, NULL);
                                    _tmp51_ = _tmp50_;
                                    vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp51_);
                                    _vala_ccode_node_unref0 (_tmp51_);
                                    _g_free0 (_tmp49_);
                                    _g_free0 (_tmp47_);
                                    _tmp52_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
                                    if (_tmp52_) {
                                          vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);
                                    } else {
                                          vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_EXTERN);
                                    }
                                    vala_ccode_file_add_type_member_declaration (decl_space, (ValaCCodeNode*) _cdecl_);
                                    _vala_code_node_unref0 (len_type);
                              }
                        }
                  }
            }
            _vala_code_node_unref0 (array_type);
      } else {
            ValaDataType* _tmp53_ = NULL;
            _tmp53_ = vala_variable_get_variable_type ((ValaVariable*) f);
            if (VALA_IS_DELEGATE_TYPE (_tmp53_)) {
                  ValaDataType* _tmp54_ = NULL;
                  ValaDelegateType* _tmp55_;
                  ValaDelegateType* delegate_type;
                  ValaDelegate* _tmp56_ = NULL;
                  gboolean _tmp57_;
                  _tmp54_ = vala_variable_get_variable_type ((ValaVariable*) f);
                  _tmp55_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp54_));
                  delegate_type = _tmp55_;
                  _tmp56_ = vala_delegate_type_get_delegate_symbol (delegate_type);
                  _tmp57_ = vala_delegate_get_has_target (_tmp56_);
                  if (_tmp57_) {
                        ValaCCodeDeclaration* _tmp58_ = NULL;
                        gchar* _tmp59_ = NULL;
                        gchar* _tmp60_;
                        gchar* _tmp61_ = NULL;
                        gchar* _tmp62_;
                        ValaCCodeVariableDeclarator* _tmp63_ = NULL;
                        ValaCCodeVariableDeclarator* _tmp64_;
                        gboolean _tmp65_;
                        gboolean _tmp66_;
                        _tmp58_ = vala_ccode_declaration_new ("gpointer");
                        _vala_ccode_node_unref0 (_cdecl_);
                        _cdecl_ = _tmp58_;
                        _tmp59_ = vala_field_get_cname (f);
                        _tmp60_ = _tmp59_;
                        _tmp61_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp60_);
                        _tmp62_ = _tmp61_;
                        _tmp63_ = vala_ccode_variable_declarator_new (_tmp62_, NULL, NULL);
                        _tmp64_ = _tmp63_;
                        vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp64_);
                        _vala_ccode_node_unref0 (_tmp64_);
                        _g_free0 (_tmp62_);
                        _g_free0 (_tmp60_);
                        _tmp65_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
                        if (_tmp65_) {
                              vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);
                        } else {
                              vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_EXTERN);
                        }
                        vala_ccode_file_add_type_member_declaration (decl_space, (ValaCCodeNode*) _cdecl_);
                        _tmp66_ = vala_data_type_get_value_owned ((ValaDataType*) delegate_type);
                        if (_tmp66_) {
                              ValaCCodeDeclaration* _tmp67_ = NULL;
                              gchar* _tmp68_ = NULL;
                              gchar* _tmp69_;
                              gchar* _tmp70_ = NULL;
                              gchar* _tmp71_;
                              ValaCCodeVariableDeclarator* _tmp72_ = NULL;
                              ValaCCodeVariableDeclarator* _tmp73_;
                              gboolean _tmp74_;
                              _tmp67_ = vala_ccode_declaration_new ("GDestroyNotify");
                              _vala_ccode_node_unref0 (_cdecl_);
                              _cdecl_ = _tmp67_;
                              _tmp68_ = vala_field_get_cname (f);
                              _tmp69_ = _tmp68_;
                              _tmp70_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp69_);
                              _tmp71_ = _tmp70_;
                              _tmp72_ = vala_ccode_variable_declarator_new (_tmp71_, NULL, NULL);
                              _tmp73_ = _tmp72_;
                              vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp73_);
                              _vala_ccode_node_unref0 (_tmp73_);
                              _g_free0 (_tmp71_);
                              _g_free0 (_tmp69_);
                              _tmp74_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
                              if (_tmp74_) {
                                    vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);
                              } else {
                                    vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_EXTERN);
                              }
                              vala_ccode_file_add_type_member_declaration (decl_space, (ValaCCodeNode*) _cdecl_);
                        }
                  }
                  _vala_code_node_unref0 (delegate_type);
            }
      }
      _vala_ccode_node_unref0 (_cdecl_);
      _g_free0 (field_ctype);
}


static void vala_ccode_base_module_real_visit_field (ValaCodeVisitor* base, ValaField* f) {
      ValaCCodeBaseModule * self;
      ValaDataType* _tmp0_ = NULL;
      ValaSymbol* _tmp1_ = NULL;
      ValaSymbol* _tmp2_;
      ValaClass* _tmp3_;
      ValaClass* cl;
      gboolean _tmp4_ = FALSE;
      gboolean is_gtypeinstance;
      ValaCCodeExpression* lhs;
      ValaDataType* _tmp6_ = NULL;
      gchar* _tmp7_ = NULL;
      gchar* field_ctype;
      gboolean _tmp8_;
      ValaMemberBinding _tmp10_;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (f != NULL);
      vala_ccode_base_module_visit_member (self, (ValaSymbol*) f);
      _tmp0_ = vala_variable_get_variable_type ((ValaVariable*) f);
      vala_ccode_base_module_check_type (self, _tmp0_);
      _tmp1_ = vala_symbol_get_parent_symbol ((ValaSymbol*) f);
      _tmp2_ = _tmp1_;
      _tmp3_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp2_) ? ((ValaClass*) _tmp2_) : NULL);
      cl = _tmp3_;
      if (cl != NULL) {
            gboolean _tmp5_;
            _tmp5_ = vala_class_get_is_compact (cl);
            _tmp4_ = !_tmp5_;
      } else {
            _tmp4_ = FALSE;
      }
      is_gtypeinstance = _tmp4_;
      lhs = NULL;
      _tmp6_ = vala_variable_get_variable_type ((ValaVariable*) f);
      _tmp7_ = vala_data_type_get_cname (_tmp6_);
      field_ctype = _tmp7_;
      _tmp8_ = vala_field_get_is_volatile (f);
      if (_tmp8_) {
            gchar* _tmp9_;
            _tmp9_ = g_strconcat ("volatile ", field_ctype, NULL);
            _g_free0 (field_ctype);
            field_ctype = _tmp9_;
      }
      _tmp10_ = vala_field_get_binding (f);
      if (_tmp10_ == VALA_MEMBER_BINDING_INSTANCE) {
            gboolean _tmp11_ = FALSE;
            ValaExpression* _tmp25_ = NULL;
            gboolean _tmp65_ = FALSE;
            ValaDataType* _tmp66_ = NULL;
            gboolean _tmp67_;
            if (is_gtypeinstance) {
                  ValaSymbolAccessibility _tmp12_;
                  _tmp12_ = vala_symbol_get_access ((ValaSymbol*) f);
                  _tmp11_ = _tmp12_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
            } else {
                  _tmp11_ = FALSE;
            }
            if (_tmp11_) {
                  ValaCCodeIdentifier* _tmp13_ = NULL;
                  ValaCCodeIdentifier* _tmp14_;
                  ValaCCodeMemberAccess* _tmp15_ = NULL;
                  ValaCCodeMemberAccess* _tmp16_;
                  gchar* _tmp17_ = NULL;
                  gchar* _tmp18_;
                  ValaCCodeMemberAccess* _tmp19_ = NULL;
                  _tmp13_ = vala_ccode_identifier_new ("self");
                  _tmp14_ = _tmp13_;
                  _tmp15_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp14_, "priv");
                  _tmp16_ = _tmp15_;
                  _tmp17_ = vala_field_get_cname (f);
                  _tmp18_ = _tmp17_;
                  _tmp19_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp16_, _tmp18_);
                  _vala_ccode_node_unref0 (lhs);
                  lhs = (ValaCCodeExpression*) _tmp19_;
                  _g_free0 (_tmp18_);
                  _vala_ccode_node_unref0 (_tmp16_);
                  _vala_ccode_node_unref0 (_tmp14_);
            } else {
                  ValaCCodeIdentifier* _tmp20_ = NULL;
                  ValaCCodeIdentifier* _tmp21_;
                  gchar* _tmp22_ = NULL;
                  gchar* _tmp23_;
                  ValaCCodeMemberAccess* _tmp24_ = NULL;
                  _tmp20_ = vala_ccode_identifier_new ("self");
                  _tmp21_ = _tmp20_;
                  _tmp22_ = vala_field_get_cname (f);
                  _tmp23_ = _tmp22_;
                  _tmp24_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp21_, _tmp23_);
                  _vala_ccode_node_unref0 (lhs);
                  lhs = (ValaCCodeExpression*) _tmp24_;
                  _g_free0 (_tmp23_);
                  _vala_ccode_node_unref0 (_tmp21_);
            }
            _tmp25_ = vala_variable_get_initializer ((ValaVariable*) f);
            if (_tmp25_ != NULL) {
                  ValaExpression* _tmp26_ = NULL;
                  ValaExpression* _tmp27_ = NULL;
                  ValaCCodeExpression* _tmp28_ = NULL;
                  ValaCCodeExpression* rhs;
                  ValaCCodeFunction* _tmp29_ = NULL;
                  gboolean _tmp30_ = FALSE;
                  gboolean _tmp31_ = FALSE;
                  ValaDataType* _tmp32_ = NULL;
                  ValaArrayList* _tmp64_ = NULL;
                  vala_ccode_base_module_push_context (self, self->instance_init_context);
                  _tmp26_ = vala_variable_get_initializer ((ValaVariable*) f);
                  vala_code_node_emit ((ValaCodeNode*) _tmp26_, (ValaCodeGenerator*) self);
                  _tmp27_ = vala_variable_get_initializer ((ValaVariable*) f);
                  _tmp28_ = vala_ccode_base_module_get_cvalue (self, _tmp27_);
                  rhs = _tmp28_;
                  _tmp29_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_assignment (_tmp29_, lhs, rhs);
                  _tmp32_ = vala_variable_get_variable_type ((ValaVariable*) f);
                  if (VALA_IS_ARRAY_TYPE (_tmp32_)) {
                        gboolean _tmp33_;
                        _tmp33_ = vala_variable_get_no_array_length ((ValaVariable*) f);
                        _tmp31_ = !_tmp33_;
                  } else {
                        _tmp31_ = FALSE;
                  }
                  if (_tmp31_) {
                        ValaExpression* _tmp34_ = NULL;
                        _tmp34_ = vala_variable_get_initializer ((ValaVariable*) f);
                        _tmp30_ = VALA_IS_ARRAY_CREATION_EXPRESSION (_tmp34_);
                  } else {
                        _tmp30_ = FALSE;
                  }
                  if (_tmp30_) {
                        ValaDataType* _tmp35_ = NULL;
                        ValaArrayType* _tmp36_;
                        ValaArrayType* array_type;
                        ValaSymbol* _tmp37_ = NULL;
                        ValaTargetValue* _tmp38_ = NULL;
                        ValaTargetValue* _tmp39_;
                        ValaTargetValue* _tmp40_ = NULL;
                        ValaTargetValue* _tmp41_;
                        ValaTargetValue* field_value;
                        ValaExpression* _tmp42_ = NULL;
                        ValaList* _tmp43_ = NULL;
                        ValaList* sizes;
                        gboolean _tmp51_ = FALSE;
                        gint _tmp52_;
                        _tmp35_ = vala_variable_get_variable_type ((ValaVariable*) f);
                        _tmp36_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp35_));
                        array_type = _tmp36_;
                        _tmp37_ = vala_symbol_get_parent_symbol ((ValaSymbol*) f);
                        _tmp38_ = vala_ccode_base_module_load_this_parameter (self, VALA_TYPESYMBOL (_tmp37_));
                        _tmp39_ = _tmp38_;
                        _tmp40_ = vala_ccode_base_module_get_field_cvalue (self, f, _tmp39_);
                        _tmp41_ = _tmp40_;
                        _vala_target_value_unref0 (_tmp39_);
                        field_value = _tmp41_;
                        _tmp42_ = vala_variable_get_initializer ((ValaVariable*) f);
                        _tmp43_ = vala_array_creation_expression_get_sizes (VALA_ARRAY_CREATION_EXPRESSION (_tmp42_));
                        sizes = _tmp43_;
                        {
                              gint dim;
                              dim = 1;
                              {
                                    gboolean _tmp44_;
                                    _tmp44_ = TRUE;
                                    while (TRUE) {
                                          gint _tmp45_;
                                          ValaCCodeExpression* _tmp46_ = NULL;
                                          ValaCCodeExpression* array_len_lhs;
                                          gpointer _tmp47_ = NULL;
                                          ValaExpression* size;
                                          ValaCCodeFunction* _tmp48_ = NULL;
                                          ValaCCodeExpression* _tmp49_ = NULL;
                                          ValaCCodeExpression* _tmp50_;
                                          if (!_tmp44_) {
                                                dim++;
                                          }
                                          _tmp44_ = FALSE;
                                          _tmp45_ = vala_array_type_get_rank (array_type);
                                          if (!(dim <= _tmp45_)) {
                                                break;
                                          }
                                          _tmp46_ = vala_ccode_base_module_get_array_length_cvalue (self, field_value, dim);
                                          array_len_lhs = _tmp46_;
                                          _tmp47_ = vala_list_get (sizes, dim - 1);
                                          size = (ValaExpression*) _tmp47_;
                                          _tmp48_ = vala_ccode_base_module_get_ccode (self);
                                          _tmp49_ = vala_ccode_base_module_get_cvalue (self, size);
                                          _tmp50_ = _tmp49_;
                                          vala_ccode_function_add_assignment (_tmp48_, array_len_lhs, _tmp50_);
                                          _vala_ccode_node_unref0 (_tmp50_);
                                          _vala_code_node_unref0 (size);
                                          _vala_ccode_node_unref0 (array_len_lhs);
                                    }
                              }
                        }
                        _tmp52_ = vala_array_type_get_rank (array_type);
                        if (_tmp52_ == 1) {
                              gboolean _tmp53_;
                              _tmp53_ = vala_symbol_is_internal_symbol ((ValaSymbol*) f);
                              _tmp51_ = _tmp53_;
                        } else {
                              _tmp51_ = FALSE;
                        }
                        if (_tmp51_) {
                              ValaCCodeExpression* _tmp54_ = NULL;
                              ValaCCodeExpression* lhs_array_size;
                              ValaCCodeExpression* _tmp55_ = NULL;
                              ValaCCodeExpression* rhs_array_len;
                              ValaCCodeFunction* _tmp56_ = NULL;
                              _tmp54_ = vala_ccode_base_module_get_array_size_cvalue (self, field_value);
                              lhs_array_size = _tmp54_;
                              _tmp55_ = vala_ccode_base_module_get_array_length_cvalue (self, field_value, 1);
                              rhs_array_len = _tmp55_;
                              _tmp56_ = vala_ccode_base_module_get_ccode (self);
                              vala_ccode_function_add_assignment (_tmp56_, lhs_array_size, rhs_array_len);
                              _vala_ccode_node_unref0 (rhs_array_len);
                              _vala_ccode_node_unref0 (lhs_array_size);
                        }
                        _vala_iterable_unref0 (sizes);
                        _vala_target_value_unref0 (field_value);
                        _vala_code_node_unref0 (array_type);
                  }
                  {
                        ValaArrayList* _tmp57_ = NULL;
                        ValaArrayList* _tmp58_;
                        ValaArrayList* _local_list;
                        gint _tmp59_;
                        gint _local_size;
                        gint _local_index;
                        _tmp57_ = vala_ccode_base_module_get_temp_ref_vars (self);
                        _tmp58_ = _vala_iterable_ref0 (_tmp57_);
                        _local_list = _tmp58_;
                        _tmp59_ = vala_collection_get_size ((ValaCollection*) _local_list);
                        _local_size = _tmp59_;
                        _local_index = -1;
                        while (TRUE) {
                              gpointer _tmp60_ = NULL;
                              ValaLocalVariable* local;
                              ValaCCodeFunction* _tmp61_ = NULL;
                              ValaCCodeExpression* _tmp62_ = NULL;
                              ValaCCodeExpression* _tmp63_;
                              _local_index = _local_index + 1;
                              if (!(_local_index < _local_size)) {
                                    break;
                              }
                              _tmp60_ = vala_list_get ((ValaList*) _local_list, _local_index);
                              local = (ValaLocalVariable*) _tmp60_;
                              _tmp61_ = vala_ccode_base_module_get_ccode (self);
                              _tmp62_ = vala_ccode_base_module_destroy_local (self, local);
                              _tmp63_ = _tmp62_;
                              vala_ccode_function_add_expression (_tmp61_, _tmp63_);
                              _vala_ccode_node_unref0 (_tmp63_);
                              _vala_code_node_unref0 (local);
                        }
                        _vala_iterable_unref0 (_local_list);
                  }
                  _tmp64_ = vala_ccode_base_module_get_temp_ref_vars (self);
                  vala_collection_clear ((ValaCollection*) _tmp64_);
                  vala_ccode_base_module_pop_context (self);
                  _vala_ccode_node_unref0 (rhs);
            }
            _tmp66_ = vala_variable_get_variable_type ((ValaVariable*) f);
            _tmp67_ = vala_ccode_base_module_requires_destroy (self, _tmp66_);
            if (_tmp67_) {
                  _tmp65_ = self->instance_finalize_context != NULL;
            } else {
                  _tmp65_ = FALSE;
            }
            if (_tmp65_) {
                  ValaCCodeFunction* _tmp68_ = NULL;
                  ValaSymbol* _tmp69_ = NULL;
                  ValaTargetValue* _tmp70_ = NULL;
                  ValaTargetValue* _tmp71_;
                  ValaCCodeExpression* _tmp72_ = NULL;
                  ValaCCodeExpression* _tmp73_;
                  vala_ccode_base_module_push_context (self, self->instance_finalize_context);
                  _tmp68_ = vala_ccode_base_module_get_ccode (self);
                  _tmp69_ = vala_symbol_get_parent_symbol ((ValaSymbol*) f);
                  _tmp70_ = vala_ccode_base_module_load_this_parameter (self, VALA_TYPESYMBOL (_tmp69_));
                  _tmp71_ = _tmp70_;
                  _tmp72_ = vala_ccode_base_module_destroy_field (self, f, _tmp71_);
                  _tmp73_ = _tmp72_;
                  vala_ccode_function_add_expression (_tmp68_, _tmp73_);
                  _vala_ccode_node_unref0 (_tmp73_);
                  _vala_target_value_unref0 (_tmp71_);
                  vala_ccode_base_module_pop_context (self);
            }
      } else {
            ValaMemberBinding _tmp74_;
            _tmp74_ = vala_field_get_binding (f);
            if (_tmp74_ == VALA_MEMBER_BINDING_CLASS) {
                  ValaSymbolAccessibility _tmp76_;
                  ValaExpression* _tmp95_ = NULL;
                  if (!is_gtypeinstance) {
                        ValaSourceReference* _tmp75_ = NULL;
                        _tmp75_ = vala_code_node_get_source_reference ((ValaCodeNode*) f);
                        vala_report_error (_tmp75_, "class fields are not supported in compact classes");
                        vala_code_node_set_error ((ValaCodeNode*) f, TRUE);
                        _g_free0 (field_ctype);
                        _vala_ccode_node_unref0 (lhs);
                        _vala_code_node_unref0 (cl);
                        return;
                  }
                  _tmp76_ = vala_symbol_get_access ((ValaSymbol*) f);
                  if (_tmp76_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) {
                        gchar* _tmp77_ = NULL;
                        gchar* _tmp78_;
                        gchar* _tmp79_ = NULL;
                        gchar* _tmp80_;
                        ValaCCodeIdentifier* _tmp81_ = NULL;
                        ValaCCodeIdentifier* _tmp82_;
                        ValaCCodeFunctionCall* _tmp83_ = NULL;
                        ValaCCodeFunctionCall* _tmp84_;
                        ValaCCodeFunctionCall* ccall;
                        ValaCCodeIdentifier* _tmp85_ = NULL;
                        ValaCCodeIdentifier* _tmp86_;
                        gchar* _tmp87_ = NULL;
                        gchar* _tmp88_;
                        ValaCCodeMemberAccess* _tmp89_ = NULL;
                        _tmp77_ = vala_typesymbol_get_upper_case_cname ((ValaTypeSymbol*) cl, NULL);
                        _tmp78_ = _tmp77_;
                        _tmp79_ = g_strdup_printf ("%s_GET_CLASS_PRIVATE", _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_);
                        _g_free0 (_tmp78_);
                        ccall = _tmp84_;
                        _tmp85_ = vala_ccode_identifier_new ("klass");
                        _tmp86_ = _tmp85_;
                        vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp86_);
                        _vala_ccode_node_unref0 (_tmp86_);
                        _tmp87_ = vala_field_get_cname (f);
                        _tmp88_ = _tmp87_;
                        _tmp89_ = vala_ccode_member_access_new ((ValaCCodeExpression*) ccall, _tmp88_, TRUE);
                        _vala_ccode_node_unref0 (lhs);
                        lhs = (ValaCCodeExpression*) _tmp89_;
                        _g_free0 (_tmp88_);
                        _vala_ccode_node_unref0 (ccall);
                  } else {
                        ValaCCodeIdentifier* _tmp90_ = NULL;
                        ValaCCodeIdentifier* _tmp91_;
                        gchar* _tmp92_ = NULL;
                        gchar* _tmp93_;
                        ValaCCodeMemberAccess* _tmp94_ = NULL;
                        _tmp90_ = vala_ccode_identifier_new ("klass");
                        _tmp91_ = _tmp90_;
                        _tmp92_ = vala_field_get_cname (f);
                        _tmp93_ = _tmp92_;
                        _tmp94_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp91_, _tmp93_, TRUE);
                        _vala_ccode_node_unref0 (lhs);
                        lhs = (ValaCCodeExpression*) _tmp94_;
                        _g_free0 (_tmp93_);
                        _vala_ccode_node_unref0 (_tmp91_);
                  }
                  _tmp95_ = vala_variable_get_initializer ((ValaVariable*) f);
                  if (_tmp95_ != NULL) {
                        ValaExpression* _tmp96_ = NULL;
                        ValaExpression* _tmp97_ = NULL;
                        ValaCCodeExpression* _tmp98_ = NULL;
                        ValaCCodeExpression* rhs;
                        ValaCCodeFunction* _tmp99_ = NULL;
                        ValaArrayList* _tmp107_ = NULL;
                        vala_ccode_base_module_push_context (self, self->class_init_context);
                        _tmp96_ = vala_variable_get_initializer ((ValaVariable*) f);
                        vala_code_node_emit ((ValaCodeNode*) _tmp96_, (ValaCodeGenerator*) self);
                        _tmp97_ = vala_variable_get_initializer ((ValaVariable*) f);
                        _tmp98_ = vala_ccode_base_module_get_cvalue (self, _tmp97_);
                        rhs = _tmp98_;
                        _tmp99_ = vala_ccode_base_module_get_ccode (self);
                        vala_ccode_function_add_assignment (_tmp99_, lhs, rhs);
                        {
                              ValaArrayList* _tmp100_ = NULL;
                              ValaArrayList* _tmp101_;
                              ValaArrayList* _local_list;
                              gint _tmp102_;
                              gint _local_size;
                              gint _local_index;
                              _tmp100_ = vala_ccode_base_module_get_temp_ref_vars (self);
                              _tmp101_ = _vala_iterable_ref0 (_tmp100_);
                              _local_list = _tmp101_;
                              _tmp102_ = vala_collection_get_size ((ValaCollection*) _local_list);
                              _local_size = _tmp102_;
                              _local_index = -1;
                              while (TRUE) {
                                    gpointer _tmp103_ = NULL;
                                    ValaLocalVariable* local;
                                    ValaCCodeFunction* _tmp104_ = NULL;
                                    ValaCCodeExpression* _tmp105_ = NULL;
                                    ValaCCodeExpression* _tmp106_;
                                    _local_index = _local_index + 1;
                                    if (!(_local_index < _local_size)) {
                                          break;
                                    }
                                    _tmp103_ = vala_list_get ((ValaList*) _local_list, _local_index);
                                    local = (ValaLocalVariable*) _tmp103_;
                                    _tmp104_ = vala_ccode_base_module_get_ccode (self);
                                    _tmp105_ = vala_ccode_base_module_destroy_local (self, local);
                                    _tmp106_ = _tmp105_;
                                    vala_ccode_function_add_expression (_tmp104_, _tmp106_);
                                    _vala_ccode_node_unref0 (_tmp106_);
                                    _vala_code_node_unref0 (local);
                              }
                              _vala_iterable_unref0 (_local_list);
                        }
                        _tmp107_ = vala_ccode_base_module_get_temp_ref_vars (self);
                        vala_collection_clear ((ValaCollection*) _tmp107_);
                        vala_ccode_base_module_pop_context (self);
                        _vala_ccode_node_unref0 (rhs);
                  }
            } else {
                  gboolean _tmp108_;
                  gboolean _tmp109_;
                  gchar* _tmp110_ = NULL;
                  gchar* _tmp111_;
                  ValaCCodeIdentifier* _tmp112_ = NULL;
                  gchar* _tmp113_ = NULL;
                  gchar* _tmp114_;
                  ValaDataType* _tmp115_ = NULL;
                  gchar* _tmp116_ = NULL;
                  gchar* _tmp117_;
                  ValaCCodeVariableDeclarator* _tmp118_ = NULL;
                  ValaCCodeVariableDeclarator* _tmp119_;
                  ValaCCodeVariableDeclarator* var_decl;
                  ValaDataType* _tmp120_ = NULL;
                  ValaCCodeExpression* _tmp121_ = NULL;
                  ValaCCodeExpression* _tmp122_;
                  ValaExpression* _tmp125_ = NULL;
                  ValaCCodeDeclaration* _tmp130_ = NULL;
                  ValaCCodeDeclaration* var_def;
                  gboolean _tmp131_;
                  gboolean _tmp132_ = FALSE;
                  ValaDataType* _tmp133_ = NULL;
                  ValaExpression* _tmp196_ = NULL;
                  vala_ccode_base_module_generate_field_declaration (self, f, self->cfile);
                  _tmp108_ = vala_symbol_is_internal_symbol ((ValaSymbol*) f);
                  if (!_tmp108_) {
                        vala_ccode_base_module_generate_field_declaration (self, f, self->header_file);
                  }
                  _tmp109_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
                  if (!_tmp109_) {
                        vala_ccode_base_module_generate_field_declaration (self, f, self->internal_header_file);
                  }
                  _tmp110_ = vala_field_get_cname (f);
                  _tmp111_ = _tmp110_;
                  _tmp112_ = vala_ccode_identifier_new (_tmp111_);
                  _vala_ccode_node_unref0 (lhs);
                  lhs = (ValaCCodeExpression*) _tmp112_;
                  _g_free0 (_tmp111_);
                  _tmp113_ = vala_field_get_cname (f);
                  _tmp114_ = _tmp113_;
                  _tmp115_ = vala_variable_get_variable_type ((ValaVariable*) f);
                  _tmp116_ = vala_data_type_get_cdeclarator_suffix (_tmp115_);
                  _tmp117_ = _tmp116_;
                  _tmp118_ = vala_ccode_variable_declarator_new (_tmp114_, NULL, _tmp117_);
                  _tmp119_ = _tmp118_;
                  _g_free0 (_tmp117_);
                  _g_free0 (_tmp114_);
                  var_decl = _tmp119_;
                  _tmp120_ = vala_variable_get_variable_type ((ValaVariable*) f);
                  _tmp121_ = vala_ccode_base_module_default_value_for_type (self, _tmp120_, TRUE);
                  _tmp122_ = _tmp121_;
                  vala_ccode_variable_declarator_set_initializer (var_decl, _tmp122_);
                  _vala_ccode_node_unref0 (_tmp122_);
                  if (self->class_init_context != NULL) {
                        vala_ccode_base_module_push_context (self, self->class_init_context);
                  } else {
                        ValaCCodeBaseModuleEmitContext* _tmp123_ = NULL;
                        ValaCCodeBaseModuleEmitContext* _tmp124_;
                        _tmp123_ = vala_ccode_base_module_emit_context_new (NULL);
                        _tmp124_ = _tmp123_;
                        vala_ccode_base_module_push_context (self, _tmp124_);
                        _vala_ccode_base_module_emit_context_unref0 (_tmp124_);
                  }
                  _tmp125_ = vala_variable_get_initializer ((ValaVariable*) f);
                  if (_tmp125_ != NULL) {
                        ValaExpression* _tmp126_ = NULL;
                        ValaExpression* _tmp127_ = NULL;
                        ValaCCodeExpression* _tmp128_ = NULL;
                        ValaCCodeExpression* init;
                        gboolean _tmp129_;
                        _tmp126_ = vala_variable_get_initializer ((ValaVariable*) f);
                        vala_code_node_emit ((ValaCodeNode*) _tmp126_, (ValaCodeGenerator*) self);
                        _tmp127_ = vala_variable_get_initializer ((ValaVariable*) f);
                        _tmp128_ = vala_ccode_base_module_get_cvalue (self, _tmp127_);
                        init = _tmp128_;
                        _tmp129_ = vala_ccode_base_module_is_constant_ccode_expression (self, init);
                        if (_tmp129_) {
                              vala_ccode_variable_declarator_set_initializer (var_decl, init);
                        }
                        _vala_ccode_node_unref0 (init);
                  }
                  _tmp130_ = vala_ccode_declaration_new (field_ctype);
                  var_def = _tmp130_;
                  vala_ccode_declaration_add_declarator (var_def, (ValaCCodeDeclarator*) var_decl);
                  _tmp131_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
                  if (!_tmp131_) {
                        vala_ccode_declaration_set_modifiers (var_def, VALA_CCODE_MODIFIERS_EXTERN);
                  } else {
                        vala_ccode_declaration_set_modifiers (var_def, VALA_CCODE_MODIFIERS_STATIC);
                  }
                  vala_ccode_file_add_type_member_declaration (self->cfile, (ValaCCodeNode*) var_def);
                  _tmp133_ = vala_variable_get_variable_type ((ValaVariable*) f);
                  if (VALA_IS_ARRAY_TYPE (_tmp133_)) {
                        gboolean _tmp134_;
                        _tmp134_ = vala_variable_get_no_array_length ((ValaVariable*) f);
                        _tmp132_ = !_tmp134_;
                  } else {
                        _tmp132_ = FALSE;
                  }
                  if (_tmp132_) {
                        ValaDataType* _tmp135_ = NULL;
                        ValaArrayType* _tmp136_;
                        ValaArrayType* array_type;
                        gboolean _tmp137_;
                        _tmp135_ = vala_variable_get_variable_type ((ValaVariable*) f);
                        _tmp136_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp135_));
                        array_type = _tmp136_;
                        _tmp137_ = vala_array_type_get_fixed_length (array_type);
                        if (!_tmp137_) {
                              gboolean _tmp154_ = FALSE;
                              gint _tmp155_;
                              {
                                    gint dim;
                                    dim = 1;
                                    {
                                          gboolean _tmp138_;
                                          _tmp138_ = TRUE;
                                          while (TRUE) {
                                                gint _tmp139_;
                                                ValaDataType* _tmp140_ = NULL;
                                                ValaDataType* len_type;
                                                gchar* _tmp141_ = NULL;
                                                gchar* _tmp142_;
                                                ValaCCodeDeclaration* _tmp143_ = NULL;
                                                ValaCCodeDeclaration* _tmp144_;
                                                ValaCCodeDeclaration* len_def;
                                                gchar* _tmp145_ = NULL;
                                                gchar* _tmp146_;
                                                gchar* _tmp147_ = NULL;
                                                gchar* _tmp148_;
                                                ValaCCodeConstant* _tmp149_ = NULL;
                                                ValaCCodeConstant* _tmp150_;
                                                ValaCCodeVariableDeclarator* _tmp151_ = NULL;
                                                ValaCCodeVariableDeclarator* _tmp152_;
                                                gboolean _tmp153_;
                                                if (!_tmp138_) {
                                                      dim++;
                                                }
                                                _tmp138_ = FALSE;
                                                _tmp139_ = vala_array_type_get_rank (array_type);
                                                if (!(dim <= _tmp139_)) {
                                                      break;
                                                }
                                                _tmp140_ = vala_data_type_copy (self->int_type);
                                                len_type = _tmp140_;
                                                _tmp141_ = vala_data_type_get_cname (len_type);
                                                _tmp142_ = _tmp141_;
                                                _tmp143_ = vala_ccode_declaration_new (_tmp142_);
                                                _tmp144_ = _tmp143_;
                                                _g_free0 (_tmp142_);
                                                len_def = _tmp144_;
                                                _tmp145_ = vala_field_get_cname (f);
                                                _tmp146_ = _tmp145_;
                                                _tmp147_ = vala_ccode_base_module_get_array_length_cname (self, _tmp146_, dim);
                                                _tmp148_ = _tmp147_;
                                                _tmp149_ = vala_ccode_constant_new ("0");
                                                _tmp150_ = _tmp149_;
                                                _tmp151_ = vala_ccode_variable_declarator_new (_tmp148_, (ValaCCodeExpression*) _tmp150_, NULL);
                                                _tmp152_ = _tmp151_;
                                                vala_ccode_declaration_add_declarator (len_def, (ValaCCodeDeclarator*) _tmp152_);
                                                _vala_ccode_node_unref0 (_tmp152_);
                                                _vala_ccode_node_unref0 (_tmp150_);
                                                _g_free0 (_tmp148_);
                                                _g_free0 (_tmp146_);
                                                _tmp153_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
                                                if (!_tmp153_) {
                                                      vala_ccode_declaration_set_modifiers (len_def, VALA_CCODE_MODIFIERS_EXTERN);
                                                } else {
                                                      vala_ccode_declaration_set_modifiers (len_def, VALA_CCODE_MODIFIERS_STATIC);
                                                }
                                                vala_ccode_file_add_type_member_declaration (self->cfile, (ValaCCodeNode*) len_def);
                                                _vala_ccode_node_unref0 (len_def);
                                                _vala_code_node_unref0 (len_type);
                                          }
                                    }
                              }
                              _tmp155_ = vala_array_type_get_rank (array_type);
                              if (_tmp155_ == 1) {
                                    gboolean _tmp156_;
                                    _tmp156_ = vala_symbol_is_internal_symbol ((ValaSymbol*) f);
                                    _tmp154_ = _tmp156_;
                              } else {
                                    _tmp154_ = FALSE;
                              }
                              if (_tmp154_) {
                                    ValaDataType* _tmp157_ = NULL;
                                    ValaDataType* len_type;
                                    gchar* _tmp158_ = NULL;
                                    gchar* _tmp159_;
                                    ValaCCodeDeclaration* _tmp160_ = NULL;
                                    ValaCCodeDeclaration* _tmp161_;
                                    ValaCCodeDeclaration* _cdecl_;
                                    gchar* _tmp162_ = NULL;
                                    gchar* _tmp163_;
                                    gchar* _tmp164_ = NULL;
                                    gchar* _tmp165_;
                                    ValaCCodeConstant* _tmp166_ = NULL;
                                    ValaCCodeConstant* _tmp167_;
                                    ValaCCodeVariableDeclarator* _tmp168_ = NULL;
                                    ValaCCodeVariableDeclarator* _tmp169_;
                                    _tmp157_ = vala_data_type_copy (self->int_type);
                                    len_type = _tmp157_;
                                    _tmp158_ = vala_data_type_get_cname (len_type);
                                    _tmp159_ = _tmp158_;
                                    _tmp160_ = vala_ccode_declaration_new (_tmp159_);
                                    _tmp161_ = _tmp160_;
                                    _g_free0 (_tmp159_);
                                    _cdecl_ = _tmp161_;
                                    _tmp162_ = vala_field_get_cname (f);
                                    _tmp163_ = _tmp162_;
                                    _tmp164_ = vala_ccode_base_module_get_array_size_cname (self, _tmp163_);
                                    _tmp165_ = _tmp164_;
                                    _tmp166_ = vala_ccode_constant_new ("0");
                                    _tmp167_ = _tmp166_;
                                    _tmp168_ = vala_ccode_variable_declarator_new (_tmp165_, (ValaCCodeExpression*) _tmp167_, NULL);
                                    _tmp169_ = _tmp168_;
                                    vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp169_);
                                    _vala_ccode_node_unref0 (_tmp169_);
                                    _vala_ccode_node_unref0 (_tmp167_);
                                    _g_free0 (_tmp165_);
                                    _g_free0 (_tmp163_);
                                    vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);
                                    vala_ccode_file_add_type_member_declaration (self->cfile, (ValaCCodeNode*) _cdecl_);
                                    _vala_ccode_node_unref0 (_cdecl_);
                                    _vala_code_node_unref0 (len_type);
                              }
                        }
                        _vala_code_node_unref0 (array_type);
                  } else {
                        ValaDataType* _tmp170_ = NULL;
                        _tmp170_ = vala_variable_get_variable_type ((ValaVariable*) f);
                        if (VALA_IS_DELEGATE_TYPE (_tmp170_)) {
                              ValaDataType* _tmp171_ = NULL;
                              ValaDelegateType* _tmp172_;
                              ValaDelegateType* delegate_type;
                              ValaDelegate* _tmp173_ = NULL;
                              gboolean _tmp174_;
                              _tmp171_ = vala_variable_get_variable_type ((ValaVariable*) f);
                              _tmp172_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp171_));
                              delegate_type = _tmp172_;
                              _tmp173_ = vala_delegate_type_get_delegate_symbol (delegate_type);
                              _tmp174_ = vala_delegate_get_has_target (_tmp173_);
                              if (_tmp174_) {
                                    ValaCCodeDeclaration* _tmp175_ = NULL;
                                    ValaCCodeDeclaration* target_def;
                                    gchar* _tmp176_ = NULL;
                                    gchar* _tmp177_;
                                    gchar* _tmp178_ = NULL;
                                    gchar* _tmp179_;
                                    ValaCCodeConstant* _tmp180_ = NULL;
                                    ValaCCodeConstant* _tmp181_;
                                    ValaCCodeVariableDeclarator* _tmp182_ = NULL;
                                    ValaCCodeVariableDeclarator* _tmp183_;
                                    gboolean _tmp184_;
                                    gboolean _tmp185_;
                                    _tmp175_ = vala_ccode_declaration_new ("gpointer");
                                    target_def = _tmp175_;
                                    _tmp176_ = vala_field_get_cname (f);
                                    _tmp177_ = _tmp176_;
                                    _tmp178_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp177_);
                                    _tmp179_ = _tmp178_;
                                    _tmp180_ = vala_ccode_constant_new ("NULL");
                                    _tmp181_ = _tmp180_;
                                    _tmp182_ = vala_ccode_variable_declarator_new (_tmp179_, (ValaCCodeExpression*) _tmp181_, NULL);
                                    _tmp183_ = _tmp182_;
                                    vala_ccode_declaration_add_declarator (target_def, (ValaCCodeDeclarator*) _tmp183_);
                                    _vala_ccode_node_unref0 (_tmp183_);
                                    _vala_ccode_node_unref0 (_tmp181_);
                                    _g_free0 (_tmp179_);
                                    _g_free0 (_tmp177_);
                                    _tmp184_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
                                    if (!_tmp184_) {
                                          vala_ccode_declaration_set_modifiers (target_def, VALA_CCODE_MODIFIERS_EXTERN);
                                    } else {
                                          vala_ccode_declaration_set_modifiers (target_def, VALA_CCODE_MODIFIERS_STATIC);
                                    }
                                    vala_ccode_file_add_type_member_declaration (self->cfile, (ValaCCodeNode*) target_def);
                                    _tmp185_ = vala_data_type_get_value_owned ((ValaDataType*) delegate_type);
                                    if (_tmp185_) {
                                          ValaCCodeDeclaration* _tmp186_ = NULL;
                                          ValaCCodeDeclaration* target_destroy_notify_def;
                                          gchar* _tmp187_ = NULL;
                                          gchar* _tmp188_;
                                          gchar* _tmp189_ = NULL;
                                          gchar* _tmp190_;
                                          ValaCCodeConstant* _tmp191_ = NULL;
                                          ValaCCodeConstant* _tmp192_;
                                          ValaCCodeVariableDeclarator* _tmp193_ = NULL;
                                          ValaCCodeVariableDeclarator* _tmp194_;
                                          gboolean _tmp195_;
                                          _tmp186_ = vala_ccode_declaration_new ("GDestroyNotify");
                                          target_destroy_notify_def = _tmp186_;
                                          _tmp187_ = vala_field_get_cname (f);
                                          _tmp188_ = _tmp187_;
                                          _tmp189_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp188_);
                                          _tmp190_ = _tmp189_;
                                          _tmp191_ = vala_ccode_constant_new ("NULL");
                                          _tmp192_ = _tmp191_;
                                          _tmp193_ = vala_ccode_variable_declarator_new (_tmp190_, (ValaCCodeExpression*) _tmp192_, NULL);
                                          _tmp194_ = _tmp193_;
                                          vala_ccode_declaration_add_declarator (target_destroy_notify_def, (ValaCCodeDeclarator*) _tmp194_);
                                          _vala_ccode_node_unref0 (_tmp194_);
                                          _vala_ccode_node_unref0 (_tmp192_);
                                          _g_free0 (_tmp190_);
                                          _g_free0 (_tmp188_);
                                          _tmp195_ = vala_symbol_is_private_symbol ((ValaSymbol*) f);
                                          if (!_tmp195_) {
                                                vala_ccode_declaration_set_modifiers (target_destroy_notify_def, VALA_CCODE_MODIFIERS_EXTERN);
                                          } else {
                                                vala_ccode_declaration_set_modifiers (target_destroy_notify_def, VALA_CCODE_MODIFIERS_STATIC);
                                          }
                                          vala_ccode_file_add_type_member_declaration (self->cfile, (ValaCCodeNode*) target_destroy_notify_def);
                                          _vala_ccode_node_unref0 (target_destroy_notify_def);
                                    }
                                    _vala_ccode_node_unref0 (target_def);
                              }
                              _vala_code_node_unref0 (delegate_type);
                        }
                  }
                  _tmp196_ = vala_variable_get_initializer ((ValaVariable*) f);
                  if (_tmp196_ != NULL) {
                        ValaExpression* _tmp197_ = NULL;
                        ValaCCodeExpression* _tmp198_ = NULL;
                        ValaCCodeExpression* rhs;
                        gboolean _tmp199_;
                        _tmp197_ = vala_variable_get_initializer ((ValaVariable*) f);
                        _tmp198_ = vala_ccode_base_module_get_cvalue (self, _tmp197_);
                        rhs = _tmp198_;
                        _tmp199_ = vala_ccode_base_module_is_constant_ccode_expression (self, rhs);
                        if (!_tmp199_) {
                              ValaSymbol* _tmp200_ = NULL;
                              _tmp200_ = vala_symbol_get_parent_symbol ((ValaSymbol*) f);
                              if (VALA_IS_CLASS (_tmp200_)) {
                                    ValaExpression* _tmp201_ = NULL;
                                    gboolean _tmp219_ = FALSE;
                                    gboolean _tmp220_ = FALSE;
                                    ValaDataType* _tmp221_ = NULL;
                                    _tmp201_ = vala_variable_get_initializer ((ValaVariable*) f);
                                    if (VALA_IS_INITIALIZER_LIST (_tmp201_)) {
                                          ValaCCodeFunction* _tmp202_ = NULL;
                                          ValaDataType* _tmp203_ = NULL;
                                          ValaLocalVariable* _tmp204_ = NULL;
                                          ValaLocalVariable* temp_decl;
                                          const gchar* _tmp205_ = NULL;
                                          ValaCCodeVariableDeclarator* _tmp206_ = NULL;
                                          ValaCCodeVariableDeclarator* vardecl;
                                          ValaCCodeFunction* _tmp207_ = NULL;
                                          ValaDataType* _tmp208_ = NULL;
                                          gchar* _tmp209_ = NULL;
                                          gchar* _tmp210_;
                                          const gchar* _tmp211_ = NULL;
                                          gchar* _tmp212_ = NULL;
                                          gchar* _tmp213_;
                                          ValaCCodeExpression* _tmp214_ = NULL;
                                          ValaCCodeExpression* _tmp215_;
                                          ValaCCodeExpression* tmp;
                                          ValaCCodeFunction* _tmp216_ = NULL;
                                          ValaCCodeFunction* _tmp217_ = NULL;
                                          _tmp202_ = vala_ccode_base_module_get_ccode (self);
                                          vala_ccode_function_open_block (_tmp202_);
                                          _tmp203_ = vala_variable_get_variable_type ((ValaVariable*) f);
                                          _tmp204_ = vala_ccode_base_module_get_temp_variable (self, _tmp203_, TRUE, NULL, TRUE);
                                          temp_decl = _tmp204_;
                                          _tmp205_ = vala_symbol_get_name ((ValaSymbol*) temp_decl);
                                          _tmp206_ = vala_ccode_variable_declarator_new_zero (_tmp205_, rhs, NULL);
                                          vardecl = _tmp206_;
                                          _tmp207_ = vala_ccode_base_module_get_ccode (self);
                                          _tmp208_ = vala_variable_get_variable_type ((ValaVariable*) temp_decl);
                                          _tmp209_ = vala_data_type_get_cname (_tmp208_);
                                          _tmp210_ = _tmp209_;
                                          vala_ccode_function_add_declaration (_tmp207_, _tmp210_, (ValaCCodeDeclarator*) vardecl, 0);
                                          _g_free0 (_tmp210_);
                                          _tmp211_ = vala_symbol_get_name ((ValaSymbol*) temp_decl);
                                          _tmp212_ = vala_ccode_base_module_get_variable_cname (self, _tmp211_);
                                          _tmp213_ = _tmp212_;
                                          _tmp214_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp213_);
                                          _tmp215_ = _tmp214_;
                                          _g_free0 (_tmp213_);
                                          tmp = _tmp215_;
                                          _tmp216_ = vala_ccode_base_module_get_ccode (self);
                                          vala_ccode_function_add_assignment (_tmp216_, lhs, tmp);
                                          _tmp217_ = vala_ccode_base_module_get_ccode (self);
                                          vala_ccode_function_close (_tmp217_);
                                          _vala_ccode_node_unref0 (tmp);
                                          _vala_ccode_node_unref0 (vardecl);
                                          _vala_code_node_unref0 (temp_decl);
                                    } else {
                                          ValaCCodeFunction* _tmp218_ = NULL;
                                          _tmp218_ = vala_ccode_base_module_get_ccode (self);
                                          vala_ccode_function_add_assignment (_tmp218_, lhs, rhs);
                                    }
                                    _tmp221_ = vala_variable_get_variable_type ((ValaVariable*) f);
                                    if (VALA_IS_ARRAY_TYPE (_tmp221_)) {
                                          gboolean _tmp222_;
                                          _tmp222_ = vala_variable_get_no_array_length ((ValaVariable*) f);
                                          _tmp220_ = !_tmp222_;
                                    } else {
                                          _tmp220_ = FALSE;
                                    }
                                    if (_tmp220_) {
                                          ValaExpression* _tmp223_ = NULL;
                                          _tmp223_ = vala_variable_get_initializer ((ValaVariable*) f);
                                          _tmp219_ = VALA_IS_ARRAY_CREATION_EXPRESSION (_tmp223_);
                                    } else {
                                          _tmp219_ = FALSE;
                                    }
                                    if (_tmp219_) {
                                          ValaDataType* _tmp224_ = NULL;
                                          ValaArrayType* _tmp225_;
                                          ValaArrayType* array_type;
                                          ValaTargetValue* _tmp226_ = NULL;
                                          ValaTargetValue* field_value;
                                          ValaExpression* _tmp227_ = NULL;
                                          ValaList* _tmp228_ = NULL;
                                          ValaList* sizes;
                                          _tmp224_ = vala_variable_get_variable_type ((ValaVariable*) f);
                                          _tmp225_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp224_));
                                          array_type = _tmp225_;
                                          _tmp226_ = vala_ccode_base_module_get_field_cvalue (self, f, NULL);
                                          field_value = _tmp226_;
                                          _tmp227_ = vala_variable_get_initializer ((ValaVariable*) f);
                                          _tmp228_ = vala_array_creation_expression_get_sizes (VALA_ARRAY_CREATION_EXPRESSION (_tmp227_));
                                          sizes = _tmp228_;
                                          {
                                                gint dim;
                                                dim = 1;
                                                {
                                                      gboolean _tmp229_;
                                                      _tmp229_ = TRUE;
                                                      while (TRUE) {
                                                            gint _tmp230_;
                                                            ValaCCodeExpression* _tmp231_ = NULL;
                                                            ValaCCodeExpression* array_len_lhs;
                                                            gpointer _tmp232_ = NULL;
                                                            ValaExpression* size;
                                                            ValaCCodeFunction* _tmp233_ = NULL;
                                                            ValaCCodeExpression* _tmp234_ = NULL;
                                                            ValaCCodeExpression* _tmp235_;
                                                            if (!_tmp229_) {
                                                                  dim++;
                                                            }
                                                            _tmp229_ = FALSE;
                                                            _tmp230_ = vala_array_type_get_rank (array_type);
                                                            if (!(dim <= _tmp230_)) {
                                                                  break;
                                                            }
                                                            _tmp231_ = vala_ccode_base_module_get_array_length_cvalue (self, field_value, dim);
                                                            array_len_lhs = _tmp231_;
                                                            _tmp232_ = vala_list_get (sizes, dim - 1);
                                                            size = (ValaExpression*) _tmp232_;
                                                            _tmp233_ = vala_ccode_base_module_get_ccode (self);
                                                            _tmp234_ = vala_ccode_base_module_get_cvalue (self, size);
                                                            _tmp235_ = _tmp234_;
                                                            vala_ccode_function_add_assignment (_tmp233_, array_len_lhs, _tmp235_);
                                                            _vala_ccode_node_unref0 (_tmp235_);
                                                            _vala_code_node_unref0 (size);
                                                            _vala_ccode_node_unref0 (array_len_lhs);
                                                      }
                                                }
                                          }
                                          _vala_iterable_unref0 (sizes);
                                          _vala_target_value_unref0 (field_value);
                                          _vala_code_node_unref0 (array_type);
                                    }
                              } else {
                                    ValaSourceReference* _tmp236_ = NULL;
                                    vala_code_node_set_error ((ValaCodeNode*) f, TRUE);
                                    _tmp236_ = vala_code_node_get_source_reference ((ValaCodeNode*) f);
                                    vala_report_error (_tmp236_, "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);
                                    _g_free0 (field_ctype);
                                    _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);
            }
      }
      _g_free0 (field_ctype);
      _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* _tmp9_;
      ValaCCodeParenthesizedExpression* _tmp10_;
      ValaCCodeParenthesizedExpression* cparenthesized;
      gboolean _tmp11_ = FALSE;
      g_return_val_if_fail (self != NULL, FALSE);
      g_return_val_if_fail (cexpr != NULL, FALSE);
      if (VALA_IS_CCODE_CONSTANT (cexpr)) {
            result = TRUE;
            return result;
      } else {
            if (VALA_IS_CCODE_CAST_EXPRESSION (cexpr)) {
                  ValaCCodeCastExpression* _tmp0_;
                  ValaCCodeCastExpression* ccast;
                  ValaCCodeExpression* _tmp1_ = NULL;
                  gboolean _tmp2_;
                  _tmp0_ = _vala_ccode_node_ref0 (VALA_CCODE_CAST_EXPRESSION (cexpr));
                  ccast = _tmp0_;
                  _tmp1_ = vala_ccode_cast_expression_get_inner (ccast);
                  _tmp2_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp1_);
                  result = _tmp2_;
                  _vala_ccode_node_unref0 (ccast);
                  return result;
            } else {
                  if (VALA_IS_CCODE_BINARY_EXPRESSION (cexpr)) {
                        ValaCCodeBinaryExpression* _tmp3_;
                        ValaCCodeBinaryExpression* cbinary;
                        gboolean _tmp4_ = FALSE;
                        ValaCCodeExpression* _tmp5_ = NULL;
                        gboolean _tmp6_;
                        _tmp3_ = _vala_ccode_node_ref0 (VALA_CCODE_BINARY_EXPRESSION (cexpr));
                        cbinary = _tmp3_;
                        _tmp5_ = vala_ccode_binary_expression_get_left (cbinary);
                        _tmp6_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp5_);
                        if (_tmp6_) {
                              ValaCCodeExpression* _tmp7_ = NULL;
                              gboolean _tmp8_;
                              _tmp7_ = vala_ccode_binary_expression_get_right (cbinary);
                              _tmp8_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp7_);
                              _tmp4_ = _tmp8_;
                        } else {
                              _tmp4_ = FALSE;
                        }
                        result = _tmp4_;
                        _vala_ccode_node_unref0 (cbinary);
                        return result;
                  }
            }
      }
      _tmp9_ = cexpr;
      _tmp10_ = _vala_ccode_node_ref0 (VALA_IS_CCODE_PARENTHESIZED_EXPRESSION (_tmp9_) ? ((ValaCCodeParenthesizedExpression*) _tmp9_) : NULL);
      cparenthesized = _tmp10_;
      if (NULL != cparenthesized) {
            ValaCCodeExpression* _tmp12_ = NULL;
            gboolean _tmp13_;
            _tmp12_ = vala_ccode_parenthesized_expression_get_inner (cparenthesized);
            _tmp13_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp12_);
            _tmp11_ = _tmp13_;
      } else {
            _tmp11_ = FALSE;
      }
      result = _tmp11_;
      _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;
      g_return_val_if_fail (self != NULL, FALSE);
      g_return_val_if_fail (cexpr != NULL, FALSE);
      if (VALA_IS_CCODE_CONSTANT (cexpr)) {
            _tmp0_ = TRUE;
      } else {
            _tmp0_ = VALA_IS_CCODE_IDENTIFIER (cexpr);
      }
      if (_tmp0_) {
            result = TRUE;
            return result;
      } else {
            if (VALA_IS_CCODE_BINARY_EXPRESSION (cexpr)) {
                  ValaCCodeBinaryExpression* _tmp1_;
                  ValaCCodeBinaryExpression* cbinary;
                  gboolean _tmp2_ = FALSE;
                  ValaCCodeExpression* _tmp3_ = NULL;
                  gboolean _tmp4_;
                  _tmp1_ = _vala_ccode_node_ref0 (VALA_CCODE_BINARY_EXPRESSION (cexpr));
                  cbinary = _tmp1_;
                  _tmp3_ = vala_ccode_binary_expression_get_left (cbinary);
                  _tmp4_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp3_);
                  if (_tmp4_) {
                        ValaCCodeExpression* _tmp5_ = NULL;
                        gboolean _tmp6_;
                        _tmp5_ = vala_ccode_binary_expression_get_right (cbinary);
                        _tmp6_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp5_);
                        _tmp2_ = _tmp6_;
                  } else {
                        _tmp2_ = FALSE;
                  }
                  result = _tmp2_;
                  _vala_ccode_node_unref0 (cbinary);
                  return result;
            } else {
                  if (VALA_IS_CCODE_UNARY_EXPRESSION (cexpr)) {
                        ValaCCodeUnaryExpression* _tmp7_;
                        ValaCCodeUnaryExpression* cunary;
                        ValaCCodeUnaryOperator _tmp8_;
                        _tmp7_ = _vala_ccode_node_ref0 (VALA_CCODE_UNARY_EXPRESSION (cexpr));
                        cunary = _tmp7_;
                        _tmp8_ = vala_ccode_unary_expression_get_operator (cunary);
                        switch (_tmp8_) {
                              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:
                              {
                                    ValaCCodeExpression* _tmp9_ = NULL;
                                    gboolean _tmp10_;
                                    _tmp9_ = vala_ccode_unary_expression_get_inner (cunary);
                                    _tmp10_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp9_);
                                    result = _tmp10_;
                                    _vala_ccode_node_unref0 (cunary);
                                    return result;
                              }
                        }
                        _vala_ccode_node_unref0 (cunary);
                  } else {
                        if (VALA_IS_CCODE_MEMBER_ACCESS (cexpr)) {
                              ValaCCodeMemberAccess* _tmp11_;
                              ValaCCodeMemberAccess* cma;
                              ValaCCodeExpression* _tmp12_ = NULL;
                              gboolean _tmp13_;
                              _tmp11_ = _vala_ccode_node_ref0 (VALA_CCODE_MEMBER_ACCESS (cexpr));
                              cma = _tmp11_;
                              _tmp12_ = vala_ccode_member_access_get_inner (cma);
                              _tmp13_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp12_);
                              result = _tmp13_;
                              _vala_ccode_node_unref0 (cma);
                              return result;
                        } else {
                              if (VALA_IS_CCODE_ELEMENT_ACCESS (cexpr)) {
                                    ValaCCodeElementAccess* _tmp14_;
                                    ValaCCodeElementAccess* cea;
                                    gboolean _tmp15_ = FALSE;
                                    ValaCCodeExpression* _tmp16_ = NULL;
                                    gboolean _tmp17_;
                                    _tmp14_ = _vala_ccode_node_ref0 (VALA_CCODE_ELEMENT_ACCESS (cexpr));
                                    cea = _tmp14_;
                                    _tmp16_ = vala_ccode_element_access_get_container (cea);
                                    _tmp17_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp16_);
                                    if (_tmp17_) {
                                          ValaCCodeExpression* _tmp18_ = NULL;
                                          gboolean _tmp19_;
                                          _tmp18_ = vala_ccode_element_access_get_index (cea);
                                          _tmp19_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp18_);
                                          _tmp15_ = _tmp19_;
                                    } else {
                                          _tmp15_ = FALSE;
                                    }
                                    result = _tmp15_;
                                    _vala_ccode_node_unref0 (cea);
                                    return result;
                              } else {
                                    if (VALA_IS_CCODE_CAST_EXPRESSION (cexpr)) {
                                          ValaCCodeCastExpression* _tmp20_;
                                          ValaCCodeCastExpression* ccast;
                                          ValaCCodeExpression* _tmp21_ = NULL;
                                          gboolean _tmp22_;
                                          _tmp20_ = _vala_ccode_node_ref0 (VALA_CCODE_CAST_EXPRESSION (cexpr));
                                          ccast = _tmp20_;
                                          _tmp21_ = vala_ccode_cast_expression_get_inner (ccast);
                                          _tmp22_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp21_);
                                          result = _tmp22_;
                                          _vala_ccode_node_unref0 (ccast);
                                          return result;
                                    } else {
                                          if (VALA_IS_CCODE_PARENTHESIZED_EXPRESSION (cexpr)) {
                                                ValaCCodeParenthesizedExpression* _tmp23_;
                                                ValaCCodeParenthesizedExpression* cparenthesized;
                                                ValaCCodeExpression* _tmp24_ = NULL;
                                                gboolean _tmp25_;
                                                _tmp23_ = _vala_ccode_node_ref0 (VALA_CCODE_PARENTHESIZED_EXPRESSION (cexpr));
                                                cparenthesized = _tmp23_;
                                                _tmp24_ = vala_ccode_parenthesized_expression_get_inner (cparenthesized);
                                                _tmp25_ = vala_ccode_base_module_is_pure_ccode_expression (self, _tmp24_);
                                                result = _tmp25_;
                                                _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;
      gboolean _tmp0_;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (p != NULL);
      _tmp0_ = vala_parameter_get_ellipsis (p);
      if (!_tmp0_) {
            ValaDataType* _tmp1_ = NULL;
            _tmp1_ = vala_variable_get_variable_type ((ValaVariable*) p);
            vala_ccode_base_module_check_type (self, _tmp1_);
      }
}


static void vala_ccode_base_module_real_visit_property (ValaCodeVisitor* base, ValaProperty* prop) {
      ValaCCodeBaseModule * self;
      ValaDataType* _tmp0_ = NULL;
      ValaPropertyAccessor* _tmp1_ = NULL;
      ValaPropertyAccessor* _tmp3_ = NULL;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (prop != NULL);
      vala_ccode_base_module_visit_member (self, (ValaSymbol*) prop);
      _tmp0_ = vala_property_get_property_type (prop);
      vala_ccode_base_module_check_type (self, _tmp0_);
      _tmp1_ = vala_property_get_get_accessor (prop);
      if (_tmp1_ != NULL) {
            ValaPropertyAccessor* _tmp2_ = NULL;
            _tmp2_ = vala_property_get_get_accessor (prop);
            vala_code_node_accept ((ValaCodeNode*) _tmp2_, (ValaCodeVisitor*) self);
      }
      _tmp3_ = vala_property_get_set_accessor (prop);
      if (_tmp3_ != NULL) {
            ValaPropertyAccessor* _tmp4_ = NULL;
            _tmp4_ = vala_property_get_set_accessor (prop);
            vala_code_node_accept ((ValaCodeNode*) _tmp4_, (ValaCodeVisitor*) self);
      }
}


void vala_ccode_base_module_generate_type_declaration (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeFile* decl_space) {
      g_return_if_fail (self != NULL);
      g_return_if_fail (type != NULL);
      g_return_if_fail (decl_space != NULL);
      if (VALA_IS_OBJECT_TYPE (type)) {
            ValaObjectType* _tmp0_;
            ValaObjectType* object_type;
            ValaObjectTypeSymbol* _tmp1_ = NULL;
            _tmp0_ = _vala_code_node_ref0 (VALA_OBJECT_TYPE (type));
            object_type = _tmp0_;
            _tmp1_ = vala_object_type_get_type_symbol (object_type);
            if (VALA_IS_CLASS (_tmp1_)) {
                  ValaObjectTypeSymbol* _tmp2_ = NULL;
                  _tmp2_ = vala_object_type_get_type_symbol (object_type);
                  vala_ccode_base_module_generate_class_declaration (self, VALA_CLASS (_tmp2_), decl_space);
            } else {
                  ValaObjectTypeSymbol* _tmp3_ = NULL;
                  _tmp3_ = vala_object_type_get_type_symbol (object_type);
                  if (VALA_IS_INTERFACE (_tmp3_)) {
                        ValaObjectTypeSymbol* _tmp4_ = NULL;
                        _tmp4_ = vala_object_type_get_type_symbol (object_type);
                        vala_ccode_base_module_generate_interface_declaration (self, VALA_INTERFACE (_tmp4_), decl_space);
                  }
            }
            _vala_code_node_unref0 (object_type);
      } else {
            if (VALA_IS_DELEGATE_TYPE (type)) {
                  ValaDelegateType* _tmp5_;
                  ValaDelegateType* deleg_type;
                  ValaDelegate* _tmp6_ = NULL;
                  ValaDelegate* _tmp7_;
                  ValaDelegate* d;
                  _tmp5_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (type));
                  deleg_type = _tmp5_;
                  _tmp6_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                  _tmp7_ = _vala_code_node_ref0 (_tmp6_);
                  d = _tmp7_;
                  vala_ccode_base_module_generate_delegate_declaration (self, d, decl_space);
                  _vala_code_node_unref0 (d);
                  _vala_code_node_unref0 (deleg_type);
            } else {
                  ValaTypeSymbol* _tmp8_ = NULL;
                  _tmp8_ = vala_data_type_get_data_type (type);
                  if (VALA_IS_ENUM (_tmp8_)) {
                        ValaTypeSymbol* _tmp9_ = NULL;
                        ValaEnum* _tmp10_;
                        ValaEnum* en;
                        _tmp9_ = vala_data_type_get_data_type (type);
                        _tmp10_ = _vala_code_node_ref0 (VALA_ENUM (_tmp9_));
                        en = _tmp10_;
                        vala_ccode_base_module_generate_enum_declaration (self, en, decl_space);
                        _vala_code_node_unref0 (en);
                  } else {
                        if (VALA_IS_VALUE_TYPE (type)) {
                              ValaValueType* _tmp11_;
                              ValaValueType* value_type;
                              ValaTypeSymbol* _tmp12_ = NULL;
                              _tmp11_ = _vala_code_node_ref0 (VALA_VALUE_TYPE (type));
                              value_type = _tmp11_;
                              _tmp12_ = vala_value_type_get_type_symbol (value_type);
                              vala_ccode_base_module_generate_struct_declaration (self, VALA_STRUCT (_tmp12_), decl_space);
                              _vala_code_node_unref0 (value_type);
                        } else {
                              if (VALA_IS_ARRAY_TYPE (type)) {
                                    ValaArrayType* _tmp13_;
                                    ValaArrayType* array_type;
                                    ValaDataType* _tmp14_ = NULL;
                                    _tmp13_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (type));
                                    array_type = _tmp13_;
                                    _tmp14_ = vala_array_type_get_element_type (array_type);
                                    vala_ccode_base_module_generate_type_declaration (self, _tmp14_, decl_space);
                                    _vala_code_node_unref0 (array_type);
                              } else {
                                    if (VALA_IS_ERROR_TYPE (type)) {
                                          ValaErrorType* _tmp15_;
                                          ValaErrorType* error_type;
                                          ValaErrorDomain* _tmp16_ = NULL;
                                          _tmp15_ = _vala_code_node_ref0 (VALA_ERROR_TYPE (type));
                                          error_type = _tmp15_;
                                          _tmp16_ = vala_error_type_get_error_domain (error_type);
                                          if (_tmp16_ != NULL) {
                                                ValaErrorDomain* _tmp17_ = NULL;
                                                _tmp17_ = vala_error_type_get_error_domain (error_type);
                                                vala_ccode_base_module_generate_error_domain_declaration (self, _tmp17_, decl_space);
                                          }
                                          _vala_code_node_unref0 (error_type);
                                    } else {
                                          if (VALA_IS_POINTER_TYPE (type)) {
                                                ValaPointerType* _tmp18_;
                                                ValaPointerType* pointer_type;
                                                ValaDataType* _tmp19_ = NULL;
                                                _tmp18_ = _vala_code_node_ref0 (VALA_POINTER_TYPE (type));
                                                pointer_type = _tmp18_;
                                                _tmp19_ = vala_pointer_type_get_base_type (pointer_type);
                                                vala_ccode_base_module_generate_type_declaration (self, _tmp19_, decl_space);
                                                _vala_code_node_unref0 (pointer_type);
                                          }
                                    }
                              }
                        }
                  }
            }
      }
      {
            ValaList* _tmp20_ = NULL;
            ValaList* _type_arg_list;
            gint _tmp21_;
            gint _type_arg_size;
            gint _type_arg_index;
            _tmp20_ = vala_data_type_get_type_arguments (type);
            _type_arg_list = _tmp20_;
            _tmp21_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
            _type_arg_size = _tmp21_;
            _type_arg_index = -1;
            while (TRUE) {
                  gpointer _tmp22_ = NULL;
                  ValaDataType* type_arg;
                  _type_arg_index = _type_arg_index + 1;
                  if (!(_type_arg_index < _type_arg_size)) {
                        break;
                  }
                  _tmp22_ = vala_list_get (_type_arg_list, _type_arg_index);
                  type_arg = (ValaDataType*) _tmp22_;
                  vala_ccode_base_module_generate_type_declaration (self, type_arg, decl_space);
                  _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 (self != NULL);
      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) {
      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 (self != NULL);
      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) {
      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 (self != NULL);
      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) {
      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 (self != NULL);
      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) {
      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) {
      gchar* _tmp0_ = NULL;
      gchar* _tmp1_;
      gboolean _tmp2_;
      gboolean _tmp3_;
      ValaProperty* _tmp4_ = NULL;
      ValaProperty* _tmp5_;
      ValaProperty* prop;
      gboolean _tmp6_ = FALSE;
      gboolean _tmp7_;
      gboolean returns_real_struct;
      ValaCCodeParameter* cvalueparam = NULL;
      ValaDataType* _tmp30_ = NULL;
      ValaCCodeFunction* function = NULL;
      gboolean _tmp31_ = FALSE;
      gboolean _tmp32_;
      ValaMemberBinding _tmp42_;
      gboolean _tmp53_ = FALSE;
      gboolean _tmp54_ = FALSE;
      gboolean _tmp55_;
      ValaDataType* _tmp57_ = NULL;
      gboolean _tmp92_ = FALSE;
      gboolean _tmp93_ = FALSE;
      gboolean _tmp94_;
      g_return_if_fail (self != NULL);
      g_return_if_fail (acc != NULL);
      g_return_if_fail (decl_space != NULL);
      _tmp0_ = vala_property_accessor_get_cname (acc);
      _tmp1_ = _tmp0_;
      _tmp2_ = vala_ccode_base_module_add_symbol_declaration (self, decl_space, (ValaSymbol*) acc, _tmp1_);
      _tmp3_ = _tmp2_;
      _g_free0 (_tmp1_);
      if (_tmp3_) {
            return;
      }
      _tmp4_ = vala_property_accessor_get_prop (acc);
      _tmp5_ = _vala_code_node_ref0 (VALA_PROPERTY (_tmp4_));
      prop = _tmp5_;
      _tmp7_ = vala_property_accessor_get_readable (acc);
      if (_tmp7_) {
            ValaDataType* _tmp8_ = NULL;
            gboolean _tmp9_;
            _tmp8_ = vala_property_get_property_type (prop);
            _tmp9_ = vala_data_type_is_real_non_null_struct_type (_tmp8_);
            _tmp6_ = _tmp9_;
      } else {
            _tmp6_ = FALSE;
      }
      returns_real_struct = _tmp6_;
      if (returns_real_struct) {
            ValaDataType* _tmp10_ = NULL;
            gchar* _tmp11_ = NULL;
            gchar* _tmp12_;
            gchar* _tmp13_;
            gchar* _tmp14_;
            ValaCCodeParameter* _tmp15_ = NULL;
            _tmp10_ = vala_property_accessor_get_value_type (acc);
            _tmp11_ = vala_data_type_get_cname (_tmp10_);
            _tmp12_ = _tmp11_;
            _tmp13_ = g_strconcat (_tmp12_, "*", NULL);
            _tmp14_ = _tmp13_;
            _tmp15_ = vala_ccode_parameter_new ("result", _tmp14_);
            _vala_ccode_node_unref0 (cvalueparam);
            cvalueparam = _tmp15_;
            _g_free0 (_tmp14_);
            _g_free0 (_tmp12_);
      } else {
            gboolean _tmp16_ = FALSE;
            gboolean _tmp17_;
            _tmp17_ = vala_property_accessor_get_readable (acc);
            if (!_tmp17_) {
                  ValaDataType* _tmp18_ = NULL;
                  gboolean _tmp19_;
                  _tmp18_ = vala_property_get_property_type (prop);
                  _tmp19_ = vala_data_type_is_real_non_null_struct_type (_tmp18_);
                  _tmp16_ = _tmp19_;
            } else {
                  _tmp16_ = FALSE;
            }
            if (_tmp16_) {
                  ValaDataType* _tmp20_ = NULL;
                  gchar* _tmp21_ = NULL;
                  gchar* _tmp22_;
                  gchar* _tmp23_;
                  gchar* _tmp24_;
                  ValaCCodeParameter* _tmp25_ = NULL;
                  _tmp20_ = vala_property_accessor_get_value_type (acc);
                  _tmp21_ = vala_data_type_get_cname (_tmp20_);
                  _tmp22_ = _tmp21_;
                  _tmp23_ = g_strconcat (_tmp22_, "*", NULL);
                  _tmp24_ = _tmp23_;
                  _tmp25_ = vala_ccode_parameter_new ("value", _tmp24_);
                  _vala_ccode_node_unref0 (cvalueparam);
                  cvalueparam = _tmp25_;
                  _g_free0 (_tmp24_);
                  _g_free0 (_tmp22_);
            } else {
                  ValaDataType* _tmp26_ = NULL;
                  gchar* _tmp27_ = NULL;
                  gchar* _tmp28_;
                  ValaCCodeParameter* _tmp29_ = NULL;
                  _tmp26_ = vala_property_accessor_get_value_type (acc);
                  _tmp27_ = vala_data_type_get_cname (_tmp26_);
                  _tmp28_ = _tmp27_;
                  _tmp29_ = vala_ccode_parameter_new ("value", _tmp28_);
                  _vala_ccode_node_unref0 (cvalueparam);
                  cvalueparam = _tmp29_;
                  _g_free0 (_tmp28_);
            }
      }
      _tmp30_ = vala_property_accessor_get_value_type (acc);
      vala_ccode_base_module_generate_type_declaration (self, _tmp30_, decl_space);
      _tmp32_ = vala_property_accessor_get_readable (acc);
      if (_tmp32_) {
            _tmp31_ = !returns_real_struct;
      } else {
            _tmp31_ = FALSE;
      }
      if (_tmp31_) {
            gchar* _tmp33_ = NULL;
            gchar* _tmp34_;
            ValaDataType* _tmp35_ = NULL;
            gchar* _tmp36_ = NULL;
            gchar* _tmp37_;
            ValaCCodeFunction* _tmp38_ = NULL;
            _tmp33_ = vala_property_accessor_get_cname (acc);
            _tmp34_ = _tmp33_;
            _tmp35_ = vala_property_accessor_get_value_type (acc);
            _tmp36_ = vala_data_type_get_cname (_tmp35_);
            _tmp37_ = _tmp36_;
            _tmp38_ = vala_ccode_function_new (_tmp34_, _tmp37_);
            _vala_ccode_node_unref0 (function);
            function = _tmp38_;
            _g_free0 (_tmp37_);
            _g_free0 (_tmp34_);
      } else {
            gchar* _tmp39_ = NULL;
            gchar* _tmp40_;
            ValaCCodeFunction* _tmp41_ = NULL;
            _tmp39_ = vala_property_accessor_get_cname (acc);
            _tmp40_ = _tmp39_;
            _tmp41_ = vala_ccode_function_new (_tmp40_, "void");
            _vala_ccode_node_unref0 (function);
            function = _tmp41_;
            _g_free0 (_tmp40_);
      }
      _tmp42_ = vala_property_get_binding (prop);
      if (_tmp42_ == VALA_MEMBER_BINDING_INSTANCE) {
            ValaSymbol* _tmp43_ = NULL;
            ValaTypeSymbol* _tmp44_;
            ValaTypeSymbol* t;
            ValaDataType* _tmp45_ = NULL;
            ValaDataType* this_type;
            gchar* _tmp46_ = NULL;
            gchar* _tmp47_;
            ValaCCodeParameter* _tmp48_ = NULL;
            ValaCCodeParameter* _tmp49_;
            ValaCCodeParameter* cselfparam;
            _tmp43_ = vala_symbol_get_parent_symbol ((ValaSymbol*) prop);
            _tmp44_ = _vala_code_node_ref0 (VALA_TYPESYMBOL (_tmp43_));
            t = _tmp44_;
            _tmp45_ = vala_ccode_base_module_get_data_type_for_symbol (t);
            this_type = _tmp45_;
            vala_ccode_base_module_generate_type_declaration (self, this_type, decl_space);
            _tmp46_ = vala_data_type_get_cname (this_type);
            _tmp47_ = _tmp46_;
            _tmp48_ = vala_ccode_parameter_new ("self", _tmp47_);
            _tmp49_ = _tmp48_;
            _g_free0 (_tmp47_);
            cselfparam = _tmp49_;
            if (VALA_IS_STRUCT (t)) {
                  const gchar* _tmp50_ = NULL;
                  gchar* _tmp51_;
                  gchar* _tmp52_;
                  _tmp50_ = vala_ccode_parameter_get_type_name (cselfparam);
                  _tmp51_ = g_strconcat (_tmp50_, "*", NULL);
                  _tmp52_ = _tmp51_;
                  vala_ccode_parameter_set_type_name (cselfparam, _tmp52_);
                  _g_free0 (_tmp52_);
            }
            vala_ccode_function_add_parameter (function, cselfparam);
            _vala_ccode_node_unref0 (cselfparam);
            _vala_code_node_unref0 (this_type);
            _vala_code_node_unref0 (t);
      }
      _tmp55_ = vala_property_accessor_get_writable (acc);
      if (_tmp55_) {
            _tmp54_ = TRUE;
      } else {
            gboolean _tmp56_;
            _tmp56_ = vala_property_accessor_get_construction (acc);
            _tmp54_ = _tmp56_;
      }
      if (_tmp54_) {
            _tmp53_ = TRUE;
      } else {
            _tmp53_ = returns_real_struct;
      }
      if (_tmp53_) {
            vala_ccode_function_add_parameter (function, cvalueparam);
      }
      _tmp57_ = vala_property_accessor_get_value_type (acc);
      if (VALA_IS_ARRAY_TYPE (_tmp57_)) {
            ValaDataType* _tmp58_ = NULL;
            ValaArrayType* _tmp59_;
            ValaArrayType* array_type;
            gchar* _tmp60_;
            gchar* length_ctype;
            gboolean _tmp61_;
            _tmp58_ = vala_property_accessor_get_value_type (acc);
            _tmp59_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp58_));
            array_type = _tmp59_;
            _tmp60_ = g_strdup ("int");
            length_ctype = _tmp60_;
            _tmp61_ = vala_property_accessor_get_readable (acc);
            if (_tmp61_) {
                  gchar* _tmp62_;
                  _tmp62_ = g_strdup ("int*");
                  _g_free0 (length_ctype);
                  length_ctype = _tmp62_;
            }
            {
                  gint dim;
                  dim = 1;
                  {
                        gboolean _tmp63_;
                        _tmp63_ = TRUE;
                        while (TRUE) {
                              gint _tmp64_;
                              const gchar* _tmp65_ = NULL;
                              gboolean _tmp66_;
                              gchar* _tmp67_ = NULL;
                              gchar* _tmp68_;
                              ValaCCodeParameter* _tmp69_ = NULL;
                              ValaCCodeParameter* _tmp70_;
                              if (!_tmp63_) {
                                    dim++;
                              }
                              _tmp63_ = FALSE;
                              _tmp64_ = vala_array_type_get_rank (array_type);
                              if (!(dim <= _tmp64_)) {
                                    break;
                              }
                              _tmp66_ = vala_property_accessor_get_readable (acc);
                              if (_tmp66_) {
                                    _tmp65_ = "result";
                              } else {
                                    _tmp65_ = "value";
                              }
                              _tmp67_ = vala_ccode_base_module_get_array_length_cname (self, _tmp65_, dim);
                              _tmp68_ = _tmp67_;
                              _tmp69_ = vala_ccode_parameter_new (_tmp68_, length_ctype);
                              _tmp70_ = _tmp69_;
                              vala_ccode_function_add_parameter (function, _tmp70_);
                              _vala_ccode_node_unref0 (_tmp70_);
                              _g_free0 (_tmp68_);
                        }
                  }
            }
            _g_free0 (length_ctype);
            _vala_code_node_unref0 (array_type);
      } else {
            gboolean _tmp71_ = FALSE;
            ValaDataType* _tmp72_ = NULL;
            _tmp72_ = vala_property_accessor_get_value_type (acc);
            if (VALA_IS_DELEGATE_TYPE (_tmp72_)) {
                  ValaDataType* _tmp73_ = NULL;
                  ValaDelegate* _tmp74_ = NULL;
                  gboolean _tmp75_;
                  _tmp73_ = vala_property_accessor_get_value_type (acc);
                  _tmp74_ = vala_delegate_type_get_delegate_symbol (VALA_DELEGATE_TYPE (_tmp73_));
                  _tmp75_ = vala_delegate_get_has_target (_tmp74_);
                  _tmp71_ = _tmp75_;
            } else {
                  _tmp71_ = FALSE;
            }
            if (_tmp71_) {
                  const gchar* _tmp76_ = NULL;
                  gboolean _tmp77_;
                  const gchar* _tmp78_ = NULL;
                  gboolean _tmp79_;
                  gchar* _tmp80_ = NULL;
                  gchar* _tmp81_;
                  ValaCCodeParameter* _tmp82_ = NULL;
                  ValaCCodeParameter* _tmp83_;
                  gboolean _tmp84_ = FALSE;
                  gboolean _tmp85_;
                  _tmp77_ = vala_property_accessor_get_readable (acc);
                  if (_tmp77_) {
                        _tmp76_ = "result";
                  } else {
                        _tmp76_ = "value";
                  }
                  _tmp79_ = vala_property_accessor_get_readable (acc);
                  if (_tmp79_) {
                        _tmp78_ = "gpointer*";
                  } else {
                        _tmp78_ = "gpointer";
                  }
                  _tmp80_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp76_);
                  _tmp81_ = _tmp80_;
                  _tmp82_ = vala_ccode_parameter_new (_tmp81_, _tmp78_);
                  _tmp83_ = _tmp82_;
                  vala_ccode_function_add_parameter (function, _tmp83_);
                  _vala_ccode_node_unref0 (_tmp83_);
                  _g_free0 (_tmp81_);
                  _tmp85_ = vala_property_accessor_get_readable (acc);
                  if (!_tmp85_) {
                        ValaDataType* _tmp86_ = NULL;
                        gboolean _tmp87_;
                        _tmp86_ = vala_property_accessor_get_value_type (acc);
                        _tmp87_ = vala_data_type_get_value_owned (_tmp86_);
                        _tmp84_ = _tmp87_;
                  } else {
                        _tmp84_ = FALSE;
                  }
                  if (_tmp84_) {
                        gchar* _tmp88_ = NULL;
                        gchar* _tmp89_;
                        ValaCCodeParameter* _tmp90_ = NULL;
                        ValaCCodeParameter* _tmp91_;
                        _tmp88_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, "value");
                        _tmp89_ = _tmp88_;
                        _tmp90_ = vala_ccode_parameter_new (_tmp89_, "GDestroyNotify");
                        _tmp91_ = _tmp90_;
                        vala_ccode_function_add_parameter (function, _tmp91_);
                        _vala_ccode_node_unref0 (_tmp91_);
                        _g_free0 (_tmp89_);
                  }
            }
      }
      _tmp94_ = vala_symbol_is_private_symbol ((ValaSymbol*) prop);
      if (_tmp94_) {
            _tmp93_ = TRUE;
      } else {
            gboolean _tmp95_ = FALSE;
            gboolean _tmp96_;
            _tmp96_ = vala_property_accessor_get_readable (acc);
            if (!_tmp96_) {
                  gboolean _tmp97_;
                  _tmp97_ = vala_property_accessor_get_writable (acc);
                  _tmp95_ = !_tmp97_;
            } else {
                  _tmp95_ = FALSE;
            }
            _tmp93_ = _tmp95_;
      }
      if (_tmp93_) {
            _tmp92_ = TRUE;
      } else {
            ValaSymbolAccessibility _tmp98_;
            _tmp98_ = vala_symbol_get_access ((ValaSymbol*) acc);
            _tmp92_ = _tmp98_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
      }
      if (_tmp92_) {
            ValaCCodeModifiers _tmp99_;
            _tmp99_ = vala_ccode_function_get_modifiers (function);
            vala_ccode_function_set_modifiers (function, _tmp99_ | VALA_CCODE_MODIFIERS_STATIC);
      }
      vala_ccode_file_add_function_declaration (decl_space, function);
      _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;
      ValaCCodeBaseModuleEmitContext* _tmp0_ = NULL;
      ValaCCodeBaseModuleEmitContext* _tmp1_;
      ValaProperty* _tmp2_ = NULL;
      ValaProperty* _tmp3_;
      ValaProperty* prop;
      ValaComment* _tmp4_ = NULL;
      gboolean _tmp9_ = FALSE;
      gboolean _tmp10_;
      gboolean returns_real_struct;
      ValaLocalVariable* _tmp13_ = NULL;
      ValaSymbol* _tmp15_ = NULL;
      ValaTypeSymbol* _tmp16_;
      ValaTypeSymbol* t;
      gboolean _tmp17_ = FALSE;
      gboolean _tmp18_;
      gboolean _tmp25_ = FALSE;
      gboolean _tmp26_ = FALSE;
      gboolean _tmp27_;
      ValaSourceFileType _tmp43_;
      ValaDataType* _tmp44_ = NULL;
      ValaDataType* this_type;
      gchar* _tmp45_ = NULL;
      gchar* _tmp46_;
      ValaCCodeParameter* _tmp47_ = NULL;
      ValaCCodeParameter* _tmp48_;
      ValaCCodeParameter* cselfparam;
      ValaCCodeParameter* cvalueparam = NULL;
      gboolean _tmp72_ = FALSE;
      gboolean _tmp73_;
      gboolean _tmp224_;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (acc != NULL);
      _tmp0_ = vala_ccode_base_module_emit_context_new ((ValaSymbol*) acc);
      _tmp1_ = _tmp0_;
      vala_ccode_base_module_push_context (self, _tmp1_);
      _vala_ccode_base_module_emit_context_unref0 (_tmp1_);
      _tmp2_ = vala_property_accessor_get_prop (acc);
      _tmp3_ = _vala_code_node_ref0 (VALA_PROPERTY (_tmp2_));
      prop = _tmp3_;
      _tmp4_ = vala_symbol_get_comment ((ValaSymbol*) acc);
      if (_tmp4_ != NULL) {
            ValaComment* _tmp5_ = NULL;
            const gchar* _tmp6_ = NULL;
            ValaCCodeComment* _tmp7_ = NULL;
            ValaCCodeComment* _tmp8_;
            _tmp5_ = vala_symbol_get_comment ((ValaSymbol*) acc);
            _tmp6_ = vala_comment_get_content (_tmp5_);
            _tmp7_ = vala_ccode_comment_new (_tmp6_);
            _tmp8_ = _tmp7_;
            vala_ccode_file_add_type_member_definition (self->cfile, (ValaCCodeNode*) _tmp8_);
            _vala_ccode_node_unref0 (_tmp8_);
      }
      _tmp10_ = vala_property_accessor_get_readable (acc);
      if (_tmp10_) {
            ValaDataType* _tmp11_ = NULL;
            gboolean _tmp12_;
            _tmp11_ = vala_property_get_property_type (prop);
            _tmp12_ = vala_data_type_is_real_non_null_struct_type (_tmp11_);
            _tmp9_ = _tmp12_;
      } else {
            _tmp9_ = FALSE;
      }
      returns_real_struct = _tmp9_;
      _tmp13_ = vala_subroutine_get_result_var ((ValaSubroutine*) acc);
      if (_tmp13_ != NULL) {
            ValaLocalVariable* _tmp14_ = NULL;
            _tmp14_ = vala_subroutine_get_result_var ((ValaSubroutine*) acc);
            vala_code_node_accept ((ValaCodeNode*) _tmp14_, (ValaCodeVisitor*) self);
      }
      _tmp15_ = vala_symbol_get_parent_symbol ((ValaSymbol*) prop);
      _tmp16_ = _vala_code_node_ref0 (VALA_TYPESYMBOL (_tmp15_));
      t = _tmp16_;
      _tmp18_ = vala_property_accessor_get_construction (acc);
      if (_tmp18_) {
            gboolean _tmp19_;
            _tmp19_ = vala_typesymbol_is_subtype_of (t, self->gobject_type);
            _tmp17_ = !_tmp19_;
      } else {
            _tmp17_ = FALSE;
      }
      if (_tmp17_) {
            ValaSourceReference* _tmp20_ = NULL;
            _tmp20_ = vala_code_node_get_source_reference ((ValaCodeNode*) acc);
            vala_report_error (_tmp20_, "construct properties require GLib.Object");
            vala_code_node_set_error ((ValaCodeNode*) acc, TRUE);
            _vala_code_node_unref0 (t);
            _vala_code_node_unref0 (prop);
            return;
      } else {
            gboolean _tmp21_ = FALSE;
            gboolean _tmp22_;
            _tmp22_ = vala_property_accessor_get_construction (acc);
            if (_tmp22_) {
                  gboolean _tmp23_;
                  _tmp23_ = vala_ccode_base_module_is_gobject_property (self, prop);
                  _tmp21_ = !_tmp23_;
            } else {
                  _tmp21_ = FALSE;
            }
            if (_tmp21_) {
                  ValaSourceReference* _tmp24_ = NULL;
                  _tmp24_ = vala_code_node_get_source_reference ((ValaCodeNode*) acc);
                  vala_report_error (_tmp24_, "construct properties not supported for specified property type");
                  vala_code_node_set_error ((ValaCodeNode*) acc, TRUE);
                  _vala_code_node_unref0 (t);
                  _vala_code_node_unref0 (prop);
                  return;
            }
      }
      _tmp27_ = vala_property_get_is_abstract (prop);
      if (_tmp27_) {
            _tmp26_ = TRUE;
      } else {
            gboolean _tmp28_;
            _tmp28_ = vala_property_get_is_virtual (prop);
            _tmp26_ = _tmp28_;
      }
      if (_tmp26_) {
            _tmp25_ = TRUE;
      } else {
            gboolean _tmp29_ = FALSE;
            ValaProperty* _tmp30_ = NULL;
            _tmp30_ = vala_property_get_base_property (prop);
            if (_tmp30_ == NULL) {
                  ValaProperty* _tmp31_ = NULL;
                  _tmp31_ = vala_property_get_base_interface_property (prop);
                  _tmp29_ = _tmp31_ == NULL;
            } else {
                  _tmp29_ = FALSE;
            }
            _tmp25_ = _tmp29_;
      }
      if (_tmp25_) {
            gboolean _tmp32_ = FALSE;
            gboolean _tmp33_;
            vala_ccode_base_module_generate_property_accessor_declaration (self, acc, self->cfile);
            _tmp33_ = vala_property_accessor_get_readable (acc);
            if (_tmp33_) {
                  _tmp32_ = TRUE;
            } else {
                  gboolean _tmp34_;
                  _tmp34_ = vala_property_accessor_get_writable (acc);
                  _tmp32_ = _tmp34_;
            }
            if (_tmp32_) {
                  gboolean _tmp35_ = FALSE;
                  gboolean _tmp36_;
                  gboolean _tmp40_ = FALSE;
                  gboolean _tmp41_;
                  _tmp36_ = vala_symbol_is_internal_symbol ((ValaSymbol*) prop);
                  if (!_tmp36_) {
                        gboolean _tmp37_ = FALSE;
                        ValaSymbolAccessibility _tmp38_;
                        _tmp38_ = vala_symbol_get_access ((ValaSymbol*) acc);
                        if (_tmp38_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {
                              _tmp37_ = TRUE;
                        } else {
                              ValaSymbolAccessibility _tmp39_;
                              _tmp39_ = vala_symbol_get_access ((ValaSymbol*) acc);
                              _tmp37_ = _tmp39_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED;
                        }
                        _tmp35_ = _tmp37_;
                  } else {
                        _tmp35_ = FALSE;
                  }
                  if (_tmp35_) {
                        vala_ccode_base_module_generate_property_accessor_declaration (self, acc, self->header_file);
                  }
                  _tmp41_ = vala_symbol_is_private_symbol ((ValaSymbol*) prop);
                  if (!_tmp41_) {
                        ValaSymbolAccessibility _tmp42_;
                        _tmp42_ = vala_symbol_get_access ((ValaSymbol*) acc);
                        _tmp40_ = _tmp42_ != VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
                  } else {
                        _tmp40_ = FALSE;
                  }
                  if (_tmp40_) {
                        vala_ccode_base_module_generate_property_accessor_declaration (self, acc, self->internal_header_file);
                  }
            }
      }
      _tmp43_ = vala_symbol_get_source_type ((ValaSymbol*) acc);
      if (_tmp43_ == VALA_SOURCE_FILE_TYPE_FAST) {
            _vala_code_node_unref0 (t);
            _vala_code_node_unref0 (prop);
            return;
      }
      _tmp44_ = vala_ccode_base_module_get_data_type_for_symbol (t);
      this_type = _tmp44_;
      _tmp45_ = vala_data_type_get_cname (this_type);
      _tmp46_ = _tmp45_;
      _tmp47_ = vala_ccode_parameter_new ("self", _tmp46_);
      _tmp48_ = _tmp47_;
      _g_free0 (_tmp46_);
      cselfparam = _tmp48_;
      if (VALA_IS_STRUCT (t)) {
            const gchar* _tmp49_ = NULL;
            gchar* _tmp50_;
            gchar* _tmp51_;
            _tmp49_ = vala_ccode_parameter_get_type_name (cselfparam);
            _tmp50_ = g_strconcat (_tmp49_, "*", NULL);
            _tmp51_ = _tmp50_;
            vala_ccode_parameter_set_type_name (cselfparam, _tmp51_);
            _g_free0 (_tmp51_);
      }
      if (returns_real_struct) {
            ValaDataType* _tmp52_ = NULL;
            gchar* _tmp53_ = NULL;
            gchar* _tmp54_;
            gchar* _tmp55_;
            gchar* _tmp56_;
            ValaCCodeParameter* _tmp57_ = NULL;
            _tmp52_ = vala_property_accessor_get_value_type (acc);
            _tmp53_ = vala_data_type_get_cname (_tmp52_);
            _tmp54_ = _tmp53_;
            _tmp55_ = g_strconcat (_tmp54_, "*", NULL);
            _tmp56_ = _tmp55_;
            _tmp57_ = vala_ccode_parameter_new ("result", _tmp56_);
            _vala_ccode_node_unref0 (cvalueparam);
            cvalueparam = _tmp57_;
            _g_free0 (_tmp56_);
            _g_free0 (_tmp54_);
      } else {
            gboolean _tmp58_ = FALSE;
            gboolean _tmp59_;
            _tmp59_ = vala_property_accessor_get_readable (acc);
            if (!_tmp59_) {
                  ValaDataType* _tmp60_ = NULL;
                  gboolean _tmp61_;
                  _tmp60_ = vala_property_get_property_type (prop);
                  _tmp61_ = vala_data_type_is_real_non_null_struct_type (_tmp60_);
                  _tmp58_ = _tmp61_;
            } else {
                  _tmp58_ = FALSE;
            }
            if (_tmp58_) {
                  ValaDataType* _tmp62_ = NULL;
                  gchar* _tmp63_ = NULL;
                  gchar* _tmp64_;
                  gchar* _tmp65_;
                  gchar* _tmp66_;
                  ValaCCodeParameter* _tmp67_ = NULL;
                  _tmp62_ = vala_property_accessor_get_value_type (acc);
                  _tmp63_ = vala_data_type_get_cname (_tmp62_);
                  _tmp64_ = _tmp63_;
                  _tmp65_ = g_strconcat (_tmp64_, "*", NULL);
                  _tmp66_ = _tmp65_;
                  _tmp67_ = vala_ccode_parameter_new ("value", _tmp66_);
                  _vala_ccode_node_unref0 (cvalueparam);
                  cvalueparam = _tmp67_;
                  _g_free0 (_tmp66_);
                  _g_free0 (_tmp64_);
            } else {
                  ValaDataType* _tmp68_ = NULL;
                  gchar* _tmp69_ = NULL;
                  gchar* _tmp70_;
                  ValaCCodeParameter* _tmp71_ = NULL;
                  _tmp68_ = vala_property_accessor_get_value_type (acc);
                  _tmp69_ = vala_data_type_get_cname (_tmp68_);
                  _tmp70_ = _tmp69_;
                  _tmp71_ = vala_ccode_parameter_new ("value", _tmp70_);
                  _vala_ccode_node_unref0 (cvalueparam);
                  cvalueparam = _tmp71_;
                  _g_free0 (_tmp70_);
            }
      }
      _tmp73_ = vala_property_get_is_abstract (prop);
      if (_tmp73_) {
            _tmp72_ = TRUE;
      } else {
            gboolean _tmp74_;
            _tmp74_ = vala_property_get_is_virtual (prop);
            _tmp72_ = _tmp74_;
      }
      if (_tmp72_) {
            ValaCCodeFunction* function = NULL;
            gboolean _tmp75_ = FALSE;
            gboolean _tmp76_;
            gboolean _tmp86_ = FALSE;
            gboolean _tmp87_ = FALSE;
            gboolean _tmp88_;
            ValaDataType* _tmp90_ = NULL;
            gboolean _tmp125_ = FALSE;
            gboolean _tmp126_ = FALSE;
            gboolean _tmp127_;
            ValaCCodeFunctionCall* vcast;
            ValaSymbol* _tmp133_ = NULL;
            ValaCCodeIdentifier* _tmp152_ = NULL;
            ValaCCodeIdentifier* _tmp153_;
            gboolean _tmp154_;
            _tmp76_ = vala_property_accessor_get_readable (acc);
            if (_tmp76_) {
                  _tmp75_ = !returns_real_struct;
            } else {
                  _tmp75_ = FALSE;
            }
            if (_tmp75_) {
                  gchar* _tmp77_ = NULL;
                  gchar* _tmp78_;
                  ValaDataType* _tmp79_ = NULL;
                  gchar* _tmp80_ = NULL;
                  gchar* _tmp81_;
                  ValaCCodeFunction* _tmp82_ = NULL;
                  _tmp77_ = vala_property_accessor_get_cname (acc);
                  _tmp78_ = _tmp77_;
                  _tmp79_ = vala_ccode_base_module_get_current_return_type (self);
                  _tmp80_ = vala_data_type_get_cname (_tmp79_);
                  _tmp81_ = _tmp80_;
                  _tmp82_ = vala_ccode_function_new (_tmp78_, _tmp81_);
                  _vala_ccode_node_unref0 (function);
                  function = _tmp82_;
                  _g_free0 (_tmp81_);
                  _g_free0 (_tmp78_);
            } else {
                  gchar* _tmp83_ = NULL;
                  gchar* _tmp84_;
                  ValaCCodeFunction* _tmp85_ = NULL;
                  _tmp83_ = vala_property_accessor_get_cname (acc);
                  _tmp84_ = _tmp83_;
                  _tmp85_ = vala_ccode_function_new (_tmp84_, "void");
                  _vala_ccode_node_unref0 (function);
                  function = _tmp85_;
                  _g_free0 (_tmp84_);
            }
            vala_ccode_function_add_parameter (function, cselfparam);
            _tmp88_ = vala_property_accessor_get_writable (acc);
            if (_tmp88_) {
                  _tmp87_ = TRUE;
            } else {
                  gboolean _tmp89_;
                  _tmp89_ = vala_property_accessor_get_construction (acc);
                  _tmp87_ = _tmp89_;
            }
            if (_tmp87_) {
                  _tmp86_ = TRUE;
            } else {
                  _tmp86_ = returns_real_struct;
            }
            if (_tmp86_) {
                  vala_ccode_function_add_parameter (function, cvalueparam);
            }
            _tmp90_ = vala_property_accessor_get_value_type (acc);
            if (VALA_IS_ARRAY_TYPE (_tmp90_)) {
                  ValaDataType* _tmp91_ = NULL;
                  ValaArrayType* _tmp92_;
                  ValaArrayType* array_type;
                  gchar* _tmp93_;
                  gchar* length_ctype;
                  gboolean _tmp94_;
                  _tmp91_ = vala_property_accessor_get_value_type (acc);
                  _tmp92_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp91_));
                  array_type = _tmp92_;
                  _tmp93_ = g_strdup ("int");
                  length_ctype = _tmp93_;
                  _tmp94_ = vala_property_accessor_get_readable (acc);
                  if (_tmp94_) {
                        gchar* _tmp95_;
                        _tmp95_ = g_strdup ("int*");
                        _g_free0 (length_ctype);
                        length_ctype = _tmp95_;
                  }
                  {
                        gint dim;
                        dim = 1;
                        {
                              gboolean _tmp96_;
                              _tmp96_ = TRUE;
                              while (TRUE) {
                                    gint _tmp97_;
                                    const gchar* _tmp98_ = NULL;
                                    gboolean _tmp99_;
                                    gchar* _tmp100_ = NULL;
                                    gchar* _tmp101_;
                                    ValaCCodeParameter* _tmp102_ = NULL;
                                    ValaCCodeParameter* _tmp103_;
                                    if (!_tmp96_) {
                                          dim++;
                                    }
                                    _tmp96_ = FALSE;
                                    _tmp97_ = vala_array_type_get_rank (array_type);
                                    if (!(dim <= _tmp97_)) {
                                          break;
                                    }
                                    _tmp99_ = vala_property_accessor_get_readable (acc);
                                    if (_tmp99_) {
                                          _tmp98_ = "result";
                                    } else {
                                          _tmp98_ = "value";
                                    }
                                    _tmp100_ = vala_ccode_base_module_get_array_length_cname (self, _tmp98_, dim);
                                    _tmp101_ = _tmp100_;
                                    _tmp102_ = vala_ccode_parameter_new (_tmp101_, length_ctype);
                                    _tmp103_ = _tmp102_;
                                    vala_ccode_function_add_parameter (function, _tmp103_);
                                    _vala_ccode_node_unref0 (_tmp103_);
                                    _g_free0 (_tmp101_);
                              }
                        }
                  }
                  _g_free0 (length_ctype);
                  _vala_code_node_unref0 (array_type);
            } else {
                  gboolean _tmp104_ = FALSE;
                  ValaDataType* _tmp105_ = NULL;
                  _tmp105_ = vala_property_accessor_get_value_type (acc);
                  if (VALA_IS_DELEGATE_TYPE (_tmp105_)) {
                        ValaDataType* _tmp106_ = NULL;
                        ValaDelegate* _tmp107_ = NULL;
                        gboolean _tmp108_;
                        _tmp106_ = vala_property_accessor_get_value_type (acc);
                        _tmp107_ = vala_delegate_type_get_delegate_symbol (VALA_DELEGATE_TYPE (_tmp106_));
                        _tmp108_ = vala_delegate_get_has_target (_tmp107_);
                        _tmp104_ = _tmp108_;
                  } else {
                        _tmp104_ = FALSE;
                  }
                  if (_tmp104_) {
                        const gchar* _tmp109_ = NULL;
                        gboolean _tmp110_;
                        const gchar* _tmp111_ = NULL;
                        gboolean _tmp112_;
                        gchar* _tmp113_ = NULL;
                        gchar* _tmp114_;
                        ValaCCodeParameter* _tmp115_ = NULL;
                        ValaCCodeParameter* _tmp116_;
                        gboolean _tmp117_ = FALSE;
                        gboolean _tmp118_;
                        _tmp110_ = vala_property_accessor_get_readable (acc);
                        if (_tmp110_) {
                              _tmp109_ = "result";
                        } else {
                              _tmp109_ = "value";
                        }
                        _tmp112_ = vala_property_accessor_get_readable (acc);
                        if (_tmp112_) {
                              _tmp111_ = "gpointer*";
                        } else {
                              _tmp111_ = "gpointer";
                        }
                        _tmp113_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp109_);
                        _tmp114_ = _tmp113_;
                        _tmp115_ = vala_ccode_parameter_new (_tmp114_, _tmp111_);
                        _tmp116_ = _tmp115_;
                        vala_ccode_function_add_parameter (function, _tmp116_);
                        _vala_ccode_node_unref0 (_tmp116_);
                        _g_free0 (_tmp114_);
                        _tmp118_ = vala_property_accessor_get_readable (acc);
                        if (!_tmp118_) {
                              ValaDataType* _tmp119_ = NULL;
                              gboolean _tmp120_;
                              _tmp119_ = vala_property_accessor_get_value_type (acc);
                              _tmp120_ = vala_data_type_get_value_owned (_tmp119_);
                              _tmp117_ = _tmp120_;
                        } else {
                              _tmp117_ = FALSE;
                        }
                        if (_tmp117_) {
                              gchar* _tmp121_ = NULL;
                              gchar* _tmp122_;
                              ValaCCodeParameter* _tmp123_ = NULL;
                              ValaCCodeParameter* _tmp124_;
                              _tmp121_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, "value");
                              _tmp122_ = _tmp121_;
                              _tmp123_ = vala_ccode_parameter_new (_tmp122_, "GDestroyNotify");
                              _tmp124_ = _tmp123_;
                              vala_ccode_function_add_parameter (function, _tmp124_);
                              _vala_ccode_node_unref0 (_tmp124_);
                              _g_free0 (_tmp122_);
                        }
                  }
            }
            _tmp127_ = vala_symbol_is_private_symbol ((ValaSymbol*) prop);
            if (_tmp127_) {
                  _tmp126_ = TRUE;
            } else {
                  gboolean _tmp128_ = FALSE;
                  gboolean _tmp129_;
                  _tmp129_ = vala_property_accessor_get_readable (acc);
                  if (_tmp129_) {
                        _tmp128_ = TRUE;
                  } else {
                        gboolean _tmp130_;
                        _tmp130_ = vala_property_accessor_get_writable (acc);
                        _tmp128_ = _tmp130_;
                  }
                  _tmp126_ = !_tmp128_;
            }
            if (_tmp126_) {
                  _tmp125_ = TRUE;
            } else {
                  ValaSymbolAccessibility _tmp131_;
                  _tmp131_ = vala_symbol_get_access ((ValaSymbol*) acc);
                  _tmp125_ = _tmp131_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
            }
            if (_tmp125_) {
                  ValaCCodeModifiers _tmp132_;
                  _tmp132_ = vala_ccode_function_get_modifiers (function);
                  vala_ccode_function_set_modifiers (function, _tmp132_ | VALA_CCODE_MODIFIERS_STATIC);
            }
            vala_ccode_base_module_push_function (self, function);
            vcast = NULL;
            _tmp133_ = vala_symbol_get_parent_symbol ((ValaSymbol*) prop);
            if (VALA_IS_INTERFACE (_tmp133_)) {
                  ValaSymbol* _tmp134_ = NULL;
                  ValaInterface* _tmp135_;
                  ValaInterface* iface;
                  gchar* _tmp136_ = NULL;
                  gchar* _tmp137_;
                  gchar* _tmp138_ = NULL;
                  gchar* _tmp139_;
                  ValaCCodeIdentifier* _tmp140_ = NULL;
                  ValaCCodeIdentifier* _tmp141_;
                  ValaCCodeFunctionCall* _tmp142_ = NULL;
                  _tmp134_ = vala_symbol_get_parent_symbol ((ValaSymbol*) prop);
                  _tmp135_ = _vala_code_node_ref0 (VALA_INTERFACE (_tmp134_));
                  iface = _tmp135_;
                  _tmp136_ = vala_typesymbol_get_upper_case_cname ((ValaTypeSymbol*) iface, NULL);
                  _tmp137_ = _tmp136_;
                  _tmp138_ = g_strdup_printf ("%s_GET_INTERFACE", _tmp137_);
                  _tmp139_ = _tmp138_;
                  _tmp140_ = vala_ccode_identifier_new (_tmp139_);
                  _tmp141_ = _tmp140_;
                  _tmp142_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp141_);
                  _vala_ccode_node_unref0 (vcast);
                  vcast = _tmp142_;
                  _vala_ccode_node_unref0 (_tmp141_);
                  _g_free0 (_tmp139_);
                  _g_free0 (_tmp137_);
                  _vala_code_node_unref0 (iface);
            } else {
                  ValaSymbol* _tmp143_ = NULL;
                  ValaClass* _tmp144_;
                  ValaClass* cl;
                  gchar* _tmp145_ = NULL;
                  gchar* _tmp146_;
                  gchar* _tmp147_ = NULL;
                  gchar* _tmp148_;
                  ValaCCodeIdentifier* _tmp149_ = NULL;
                  ValaCCodeIdentifier* _tmp150_;
                  ValaCCodeFunctionCall* _tmp151_ = NULL;
                  _tmp143_ = vala_symbol_get_parent_symbol ((ValaSymbol*) prop);
                  _tmp144_ = _vala_code_node_ref0 (VALA_CLASS (_tmp143_));
                  cl = _tmp144_;
                  _tmp145_ = vala_typesymbol_get_upper_case_cname ((ValaTypeSymbol*) cl, NULL);
                  _tmp146_ = _tmp145_;
                  _tmp147_ = g_strdup_printf ("%s_GET_CLASS", _tmp146_);
                  _tmp148_ = _tmp147_;
                  _tmp149_ = vala_ccode_identifier_new (_tmp148_);
                  _tmp150_ = _tmp149_;
                  _tmp151_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp150_);
                  _vala_ccode_node_unref0 (vcast);
                  vcast = _tmp151_;
                  _vala_ccode_node_unref0 (_tmp150_);
                  _g_free0 (_tmp148_);
                  _g_free0 (_tmp146_);
                  _vala_code_node_unref0 (cl);
            }
            _tmp152_ = vala_ccode_identifier_new ("self");
            _tmp153_ = _tmp152_;
            vala_ccode_function_call_add_argument (vcast, (ValaCCodeExpression*) _tmp153_);
            _vala_ccode_node_unref0 (_tmp153_);
            _tmp154_ = vala_property_accessor_get_readable (acc);
            if (_tmp154_) {
                  const gchar* _tmp155_ = NULL;
                  gchar* _tmp156_ = NULL;
                  gchar* _tmp157_;
                  ValaCCodeMemberAccess* _tmp158_ = NULL;
                  ValaCCodeMemberAccess* _tmp159_;
                  ValaCCodeFunctionCall* _tmp160_ = NULL;
                  ValaCCodeFunctionCall* _tmp161_;
                  ValaCCodeFunctionCall* vcall;
                  ValaCCodeIdentifier* _tmp162_ = NULL;
                  ValaCCodeIdentifier* _tmp163_;
                  _tmp155_ = vala_symbol_get_name ((ValaSymbol*) prop);
                  _tmp156_ = g_strdup_printf ("get_%s", _tmp155_);
                  _tmp157_ = _tmp156_;
                  _tmp158_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) vcast, _tmp157_);
                  _tmp159_ = _tmp158_;
                  _tmp160_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp159_);
                  _tmp161_ = _tmp160_;
                  _vala_ccode_node_unref0 (_tmp159_);
                  _g_free0 (_tmp157_);
                  vcall = _tmp161_;
                  _tmp162_ = vala_ccode_identifier_new ("self");
                  _tmp163_ = _tmp162_;
                  vala_ccode_function_call_add_argument (vcall, (ValaCCodeExpression*) _tmp163_);
                  _vala_ccode_node_unref0 (_tmp163_);
                  if (returns_real_struct) {
                        ValaCCodeIdentifier* _tmp164_ = NULL;
                        ValaCCodeIdentifier* _tmp165_;
                        ValaCCodeFunction* _tmp166_ = NULL;
                        _tmp164_ = vala_ccode_identifier_new ("result");
                        _tmp165_ = _tmp164_;
                        vala_ccode_function_call_add_argument (vcall, (ValaCCodeExpression*) _tmp165_);
                        _vala_ccode_node_unref0 (_tmp165_);
                        _tmp166_ = vala_ccode_base_module_get_ccode (self);
                        vala_ccode_function_add_expression (_tmp166_, (ValaCCodeExpression*) vcall);
                  } else {
                        ValaDataType* _tmp167_ = NULL;
                        ValaCCodeFunction* _tmp185_ = NULL;
                        _tmp167_ = vala_property_accessor_get_value_type (acc);
                        if (VALA_IS_ARRAY_TYPE (_tmp167_)) {
                              ValaDataType* _tmp168_ = NULL;
                              ValaArrayType* _tmp169_;
                              ValaArrayType* array_type;
                              _tmp168_ = vala_property_accessor_get_value_type (acc);
                              _tmp169_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp168_));
                              array_type = _tmp169_;
                              {
                                    gint dim;
                                    dim = 1;
                                    {
                                          gboolean _tmp170_;
                                          _tmp170_ = TRUE;
                                          while (TRUE) {
                                                gint _tmp171_;
                                                gchar* _tmp172_ = NULL;
                                                gchar* _tmp173_;
                                                ValaCCodeIdentifier* _tmp174_ = NULL;
                                                ValaCCodeIdentifier* _tmp175_;
                                                ValaCCodeIdentifier* len_expr;
                                                if (!_tmp170_) {
                                                      dim++;
                                                }
                                                _tmp170_ = FALSE;
                                                _tmp171_ = vala_array_type_get_rank (array_type);
                                                if (!(dim <= _tmp171_)) {
                                                      break;
                                                }
                                                _tmp172_ = vala_ccode_base_module_get_array_length_cname (self, "result", dim);
                                                _tmp173_ = _tmp172_;
                                                _tmp174_ = vala_ccode_identifier_new (_tmp173_);
                                                _tmp175_ = _tmp174_;
                                                _g_free0 (_tmp173_);
                                                len_expr = _tmp175_;
                                                vala_ccode_function_call_add_argument (vcall, (ValaCCodeExpression*) len_expr);
                                                _vala_ccode_node_unref0 (len_expr);
                                          }
                                    }
                              }
                              _vala_code_node_unref0 (array_type);
                        } else {
                              gboolean _tmp176_ = FALSE;
                              ValaDataType* _tmp177_ = NULL;
                              _tmp177_ = vala_property_accessor_get_value_type (acc);
                              if (VALA_IS_DELEGATE_TYPE (_tmp177_)) {
                                    ValaDataType* _tmp178_ = NULL;
                                    ValaDelegate* _tmp179_ = NULL;
                                    gboolean _tmp180_;
                                    _tmp178_ = vala_property_accessor_get_value_type (acc);
                                    _tmp179_ = vala_delegate_type_get_delegate_symbol (VALA_DELEGATE_TYPE (_tmp178_));
                                    _tmp180_ = vala_delegate_get_has_target (_tmp179_);
                                    _tmp176_ = _tmp180_;
                              } else {
                                    _tmp176_ = FALSE;
                              }
                              if (_tmp176_) {
                                    gchar* _tmp181_ = NULL;
                                    gchar* _tmp182_;
                                    ValaCCodeIdentifier* _tmp183_ = NULL;
                                    ValaCCodeIdentifier* _tmp184_;
                                    _tmp181_ = vala_ccode_base_module_get_delegate_target_cname (self, "result");
                                    _tmp182_ = _tmp181_;
                                    _tmp183_ = vala_ccode_identifier_new (_tmp182_);
                                    _tmp184_ = _tmp183_;
                                    vala_ccode_function_call_add_argument (vcall, (ValaCCodeExpression*) _tmp184_);
                                    _vala_ccode_node_unref0 (_tmp184_);
                                    _g_free0 (_tmp182_);
                              }
                        }
                        _tmp185_ = vala_ccode_base_module_get_ccode (self);
                        vala_ccode_function_add_return (_tmp185_, (ValaCCodeExpression*) vcall);
                  }
                  _vala_ccode_node_unref0 (vcall);
            } else {
                  const gchar* _tmp186_ = NULL;
                  gchar* _tmp187_ = NULL;
                  gchar* _tmp188_;
                  ValaCCodeMemberAccess* _tmp189_ = NULL;
                  ValaCCodeMemberAccess* _tmp190_;
                  ValaCCodeFunctionCall* _tmp191_ = NULL;
                  ValaCCodeFunctionCall* _tmp192_;
                  ValaCCodeFunctionCall* vcall;
                  ValaCCodeIdentifier* _tmp193_ = NULL;
                  ValaCCodeIdentifier* _tmp194_;
                  ValaCCodeIdentifier* _tmp195_ = NULL;
                  ValaCCodeIdentifier* _tmp196_;
                  ValaDataType* _tmp197_ = NULL;
                  ValaCCodeFunction* _tmp223_ = NULL;
                  _tmp186_ = vala_symbol_get_name ((ValaSymbol*) prop);
                  _tmp187_ = g_strdup_printf ("set_%s", _tmp186_);
                  _tmp188_ = _tmp187_;
                  _tmp189_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) vcast, _tmp188_);
                  _tmp190_ = _tmp189_;
                  _tmp191_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp190_);
                  _tmp192_ = _tmp191_;
                  _vala_ccode_node_unref0 (_tmp190_);
                  _g_free0 (_tmp188_);
                  vcall = _tmp192_;
                  _tmp193_ = vala_ccode_identifier_new ("self");
                  _tmp194_ = _tmp193_;
                  vala_ccode_function_call_add_argument (vcall, (ValaCCodeExpression*) _tmp194_);
                  _vala_ccode_node_unref0 (_tmp194_);
                  _tmp195_ = vala_ccode_identifier_new ("value");
                  _tmp196_ = _tmp195_;
                  vala_ccode_function_call_add_argument (vcall, (ValaCCodeExpression*) _tmp196_);
                  _vala_ccode_node_unref0 (_tmp196_);
                  _tmp197_ = vala_property_accessor_get_value_type (acc);
                  if (VALA_IS_ARRAY_TYPE (_tmp197_)) {
                        ValaDataType* _tmp198_ = NULL;
                        ValaArrayType* _tmp199_;
                        ValaArrayType* array_type;
                        _tmp198_ = vala_property_accessor_get_value_type (acc);
                        _tmp199_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp198_));
                        array_type = _tmp199_;
                        {
                              gint dim;
                              dim = 1;
                              {
                                    gboolean _tmp200_;
                                    _tmp200_ = TRUE;
                                    while (TRUE) {
                                          gint _tmp201_;
                                          gchar* _tmp202_ = NULL;
                                          gchar* _tmp203_;
                                          ValaCCodeIdentifier* _tmp204_ = NULL;
                                          ValaCCodeIdentifier* _tmp205_;
                                          ValaCCodeIdentifier* len_expr;
                                          if (!_tmp200_) {
                                                dim++;
                                          }
                                          _tmp200_ = FALSE;
                                          _tmp201_ = vala_array_type_get_rank (array_type);
                                          if (!(dim <= _tmp201_)) {
                                                break;
                                          }
                                          _tmp202_ = vala_ccode_base_module_get_array_length_cname (self, "value", dim);
                                          _tmp203_ = _tmp202_;
                                          _tmp204_ = vala_ccode_identifier_new (_tmp203_);
                                          _tmp205_ = _tmp204_;
                                          _g_free0 (_tmp203_);
                                          len_expr = _tmp205_;
                                          vala_ccode_function_call_add_argument (vcall, (ValaCCodeExpression*) len_expr);
                                          _vala_ccode_node_unref0 (len_expr);
                                    }
                              }
                        }
                        _vala_code_node_unref0 (array_type);
                  } else {
                        gboolean _tmp206_ = FALSE;
                        ValaDataType* _tmp207_ = NULL;
                        _tmp207_ = vala_property_accessor_get_value_type (acc);
                        if (VALA_IS_DELEGATE_TYPE (_tmp207_)) {
                              ValaDataType* _tmp208_ = NULL;
                              ValaDelegate* _tmp209_ = NULL;
                              gboolean _tmp210_;
                              _tmp208_ = vala_property_accessor_get_value_type (acc);
                              _tmp209_ = vala_delegate_type_get_delegate_symbol (VALA_DELEGATE_TYPE (_tmp208_));
                              _tmp210_ = vala_delegate_get_has_target (_tmp209_);
                              _tmp206_ = _tmp210_;
                        } else {
                              _tmp206_ = FALSE;
                        }
                        if (_tmp206_) {
                              gchar* _tmp211_ = NULL;
                              gchar* _tmp212_;
                              ValaCCodeIdentifier* _tmp213_ = NULL;
                              ValaCCodeIdentifier* _tmp214_;
                              gboolean _tmp215_ = FALSE;
                              gboolean _tmp216_;
                              _tmp211_ = vala_ccode_base_module_get_delegate_target_cname (self, "value");
                              _tmp212_ = _tmp211_;
                              _tmp213_ = vala_ccode_identifier_new (_tmp212_);
                              _tmp214_ = _tmp213_;
                              vala_ccode_function_call_add_argument (vcall, (ValaCCodeExpression*) _tmp214_);
                              _vala_ccode_node_unref0 (_tmp214_);
                              _g_free0 (_tmp212_);
                              _tmp216_ = vala_property_accessor_get_readable (acc);
                              if (!_tmp216_) {
                                    ValaDataType* _tmp217_ = NULL;
                                    gboolean _tmp218_;
                                    _tmp217_ = vala_property_accessor_get_value_type (acc);
                                    _tmp218_ = vala_data_type_get_value_owned (_tmp217_);
                                    _tmp215_ = _tmp218_;
                              } else {
                                    _tmp215_ = FALSE;
                              }
                              if (_tmp215_) {
                                    gchar* _tmp219_ = NULL;
                                    gchar* _tmp220_;
                                    ValaCCodeIdentifier* _tmp221_ = NULL;
                                    ValaCCodeIdentifier* _tmp222_;
                                    _tmp219_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, "value");
                                    _tmp220_ = _tmp219_;
                                    _tmp221_ = vala_ccode_identifier_new (_tmp220_);
                                    _tmp222_ = _tmp221_;
                                    vala_ccode_function_call_add_argument (vcall, (ValaCCodeExpression*) _tmp222_);
                                    _vala_ccode_node_unref0 (_tmp222_);
                                    _g_free0 (_tmp220_);
                              }
                        }
                  }
                  _tmp223_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_expression (_tmp223_, (ValaCCodeExpression*) vcall);
                  _vala_ccode_node_unref0 (vcall);
            }
            vala_ccode_base_module_pop_function (self);
            vala_ccode_file_add_function (self->cfile, function);
            _vala_ccode_node_unref0 (vcast);
            _vala_ccode_node_unref0 (function);
      }
      _tmp224_ = vala_property_get_is_abstract (prop);
      if (!_tmp224_) {
            gboolean _tmp225_ = FALSE;
            ValaProperty* _tmp226_ = NULL;
            gboolean is_virtual;
            gchar* cname = NULL;
            ValaCCodeFunction* function = NULL;
            gboolean _tmp238_ = FALSE;
            gboolean _tmp239_ = FALSE;
            gboolean _tmp240_;
            ValaObjectType* base_type;
            ValaMemberBinding _tmp247_;
            gboolean _tmp261_ = FALSE;
            gboolean _tmp262_ = FALSE;
            gboolean _tmp263_;
            ValaDataType* _tmp265_ = NULL;
            gboolean _tmp308_ = FALSE;
            ValaMemberBinding _tmp309_;
            gboolean _tmp312_ = FALSE;
            gboolean _tmp313_;
            ValaBlock* _tmp342_ = NULL;
            gboolean _tmp343_;
            gboolean _tmp349_ = FALSE;
            gboolean _tmp350_ = FALSE;
            gboolean _tmp351_;
            _tmp226_ = vala_property_get_base_property (prop);
            if (_tmp226_ != NULL) {
                  _tmp225_ = TRUE;
            } else {
                  ValaProperty* _tmp227_ = NULL;
                  _tmp227_ = vala_property_get_base_interface_property (prop);
                  _tmp225_ = _tmp227_ != NULL;
            }
            is_virtual = _tmp225_;
            if (is_virtual) {
                  gboolean _tmp228_;
                  _tmp228_ = vala_property_accessor_get_readable (acc);
                  if (_tmp228_) {
                        gchar* _tmp229_ = NULL;
                        gchar* _tmp230_;
                        const gchar* _tmp231_ = NULL;
                        gchar* _tmp232_ = NULL;
                        _tmp229_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) t, NULL);
                        _tmp230_ = _tmp229_;
                        _tmp231_ = vala_symbol_get_name ((ValaSymbol*) prop);
                        _tmp232_ = g_strdup_printf ("%s_real_get_%s", _tmp230_, _tmp231_);
                        _g_free0 (cname);
                        cname = _tmp232_;
                        _g_free0 (_tmp230_);
                  } else {
                        gchar* _tmp233_ = NULL;
                        gchar* _tmp234_;
                        const gchar* _tmp235_ = NULL;
                        gchar* _tmp236_ = NULL;
                        _tmp233_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) t, NULL);
                        _tmp234_ = _tmp233_;
                        _tmp235_ = vala_symbol_get_name ((ValaSymbol*) prop);
                        _tmp236_ = g_strdup_printf ("%s_real_set_%s", _tmp234_, _tmp235_);
                        _g_free0 (cname);
                        cname = _tmp236_;
                        _g_free0 (_tmp234_);
                  }
            } else {
                  gchar* _tmp237_ = NULL;
                  _tmp237_ = vala_property_accessor_get_cname (acc);
                  _g_free0 (cname);
                  cname = _tmp237_;
            }
            _tmp240_ = vala_property_accessor_get_writable (acc);
            if (_tmp240_) {
                  _tmp239_ = TRUE;
            } else {
                  gboolean _tmp241_;
                  _tmp241_ = vala_property_accessor_get_construction (acc);
                  _tmp239_ = _tmp241_;
            }
            if (_tmp239_) {
                  _tmp238_ = TRUE;
            } else {
                  _tmp238_ = returns_real_struct;
            }
            if (_tmp238_) {
                  ValaCCodeFunction* _tmp242_ = NULL;
                  _tmp242_ = vala_ccode_function_new (cname, "void");
                  _vala_ccode_node_unref0 (function);
                  function = _tmp242_;
            } else {
                  ValaDataType* _tmp243_ = NULL;
                  gchar* _tmp244_ = NULL;
                  gchar* _tmp245_;
                  ValaCCodeFunction* _tmp246_ = NULL;
                  _tmp243_ = vala_property_accessor_get_value_type (acc);
                  _tmp244_ = vala_data_type_get_cname (_tmp243_);
                  _tmp245_ = _tmp244_;
                  _tmp246_ = vala_ccode_function_new (cname, _tmp245_);
                  _vala_ccode_node_unref0 (function);
                  function = _tmp246_;
                  _g_free0 (_tmp245_);
            }
            base_type = NULL;
            _tmp247_ = vala_property_get_binding (prop);
            if (_tmp247_ == VALA_MEMBER_BINDING_INSTANCE) {
                  if (is_virtual) {
                        ValaProperty* _tmp248_ = NULL;
                        ValaCCodeModifiers _tmp256_;
                        gchar* _tmp257_ = NULL;
                        gchar* _tmp258_;
                        ValaCCodeParameter* _tmp259_ = NULL;
                        ValaCCodeParameter* _tmp260_;
                        _tmp248_ = vala_property_get_base_property (prop);
                        if (_tmp248_ != NULL) {
                              ValaProperty* _tmp249_ = NULL;
                              ValaSymbol* _tmp250_ = NULL;
                              ValaObjectType* _tmp251_ = NULL;
                              _tmp249_ = vala_property_get_base_property (prop);
                              _tmp250_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp249_);
                              _tmp251_ = vala_object_type_new (VALA_OBJECT_TYPE_SYMBOL (_tmp250_));
                              _vala_code_node_unref0 (base_type);
                              base_type = _tmp251_;
                        } else {
                              ValaProperty* _tmp252_ = NULL;
                              _tmp252_ = vala_property_get_base_interface_property (prop);
                              if (_tmp252_ != NULL) {
                                    ValaProperty* _tmp253_ = NULL;
                                    ValaSymbol* _tmp254_ = NULL;
                                    ValaObjectType* _tmp255_ = NULL;
                                    _tmp253_ = vala_property_get_base_interface_property (prop);
                                    _tmp254_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp253_);
                                    _tmp255_ = vala_object_type_new (VALA_OBJECT_TYPE_SYMBOL (_tmp254_));
                                    _vala_code_node_unref0 (base_type);
                                    base_type = _tmp255_;
                              }
                        }
                        _tmp256_ = vala_ccode_function_get_modifiers (function);
                        vala_ccode_function_set_modifiers (function, _tmp256_ | VALA_CCODE_MODIFIERS_STATIC);
                        _tmp257_ = vala_data_type_get_cname ((ValaDataType*) base_type);
                        _tmp258_ = _tmp257_;
                        _tmp259_ = vala_ccode_parameter_new ("base", _tmp258_);
                        _tmp260_ = _tmp259_;
                        vala_ccode_function_add_parameter (function, _tmp260_);
                        _vala_ccode_node_unref0 (_tmp260_);
                        _g_free0 (_tmp258_);
                  } else {
                        vala_ccode_function_add_parameter (function, cselfparam);
                  }
            }
            _tmp263_ = vala_property_accessor_get_writable (acc);
            if (_tmp263_) {
                  _tmp262_ = TRUE;
            } else {
                  gboolean _tmp264_;
                  _tmp264_ = vala_property_accessor_get_construction (acc);
                  _tmp262_ = _tmp264_;
            }
            if (_tmp262_) {
                  _tmp261_ = TRUE;
            } else {
                  _tmp261_ = returns_real_struct;
            }
            if (_tmp261_) {
                  vala_ccode_function_add_parameter (function, cvalueparam);
            }
            _tmp265_ = vala_property_accessor_get_value_type (acc);
            if (VALA_IS_ARRAY_TYPE (_tmp265_)) {
                  ValaDataType* _tmp266_ = NULL;
                  ValaArrayType* _tmp267_;
                  ValaArrayType* array_type;
                  gchar* _tmp268_;
                  gchar* length_ctype;
                  gboolean _tmp269_;
                  _tmp266_ = vala_property_accessor_get_value_type (acc);
                  _tmp267_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp266_));
                  array_type = _tmp267_;
                  _tmp268_ = g_strdup ("int");
                  length_ctype = _tmp268_;
                  _tmp269_ = vala_property_accessor_get_readable (acc);
                  if (_tmp269_) {
                        gchar* _tmp270_;
                        _tmp270_ = g_strdup ("int*");
                        _g_free0 (length_ctype);
                        length_ctype = _tmp270_;
                  }
                  {
                        gint dim;
                        dim = 1;
                        {
                              gboolean _tmp271_;
                              _tmp271_ = TRUE;
                              while (TRUE) {
                                    gint _tmp272_;
                                    const gchar* _tmp273_ = NULL;
                                    gboolean _tmp274_;
                                    gchar* _tmp275_ = NULL;
                                    gchar* _tmp276_;
                                    ValaCCodeParameter* _tmp277_ = NULL;
                                    ValaCCodeParameter* _tmp278_;
                                    if (!_tmp271_) {
                                          dim++;
                                    }
                                    _tmp271_ = FALSE;
                                    _tmp272_ = vala_array_type_get_rank (array_type);
                                    if (!(dim <= _tmp272_)) {
                                          break;
                                    }
                                    _tmp274_ = vala_property_accessor_get_readable (acc);
                                    if (_tmp274_) {
                                          _tmp273_ = "result";
                                    } else {
                                          _tmp273_ = "value";
                                    }
                                    _tmp275_ = vala_ccode_base_module_get_array_length_cname (self, _tmp273_, dim);
                                    _tmp276_ = _tmp275_;
                                    _tmp277_ = vala_ccode_parameter_new (_tmp276_, length_ctype);
                                    _tmp278_ = _tmp277_;
                                    vala_ccode_function_add_parameter (function, _tmp278_);
                                    _vala_ccode_node_unref0 (_tmp278_);
                                    _g_free0 (_tmp276_);
                              }
                        }
                  }
                  _g_free0 (length_ctype);
                  _vala_code_node_unref0 (array_type);
            } else {
                  gboolean _tmp279_ = FALSE;
                  ValaDataType* _tmp280_ = NULL;
                  _tmp280_ = vala_property_accessor_get_value_type (acc);
                  if (VALA_IS_DELEGATE_TYPE (_tmp280_)) {
                        ValaDataType* _tmp281_ = NULL;
                        ValaDelegate* _tmp282_ = NULL;
                        gboolean _tmp283_;
                        _tmp281_ = vala_property_accessor_get_value_type (acc);
                        _tmp282_ = vala_delegate_type_get_delegate_symbol (VALA_DELEGATE_TYPE (_tmp281_));
                        _tmp283_ = vala_delegate_get_has_target (_tmp282_);
                        _tmp279_ = _tmp283_;
                  } else {
                        _tmp279_ = FALSE;
                  }
                  if (_tmp279_) {
                        const gchar* _tmp284_ = NULL;
                        gboolean _tmp285_;
                        const gchar* _tmp286_ = NULL;
                        gboolean _tmp287_;
                        gchar* _tmp288_ = NULL;
                        gchar* _tmp289_;
                        ValaCCodeParameter* _tmp290_ = NULL;
                        ValaCCodeParameter* _tmp291_;
                        gboolean _tmp292_ = FALSE;
                        gboolean _tmp293_;
                        _tmp285_ = vala_property_accessor_get_readable (acc);
                        if (_tmp285_) {
                              _tmp284_ = "result";
                        } else {
                              _tmp284_ = "value";
                        }
                        _tmp287_ = vala_property_accessor_get_readable (acc);
                        if (_tmp287_) {
                              _tmp286_ = "gpointer*";
                        } else {
                              _tmp286_ = "gpointer";
                        }
                        _tmp288_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp284_);
                        _tmp289_ = _tmp288_;
                        _tmp290_ = vala_ccode_parameter_new (_tmp289_, _tmp286_);
                        _tmp291_ = _tmp290_;
                        vala_ccode_function_add_parameter (function, _tmp291_);
                        _vala_ccode_node_unref0 (_tmp291_);
                        _g_free0 (_tmp289_);
                        _tmp293_ = vala_property_accessor_get_readable (acc);
                        if (!_tmp293_) {
                              ValaDataType* _tmp294_ = NULL;
                              gboolean _tmp295_;
                              _tmp294_ = vala_property_accessor_get_value_type (acc);
                              _tmp295_ = vala_data_type_get_value_owned (_tmp294_);
                              _tmp292_ = _tmp295_;
                        } else {
                              _tmp292_ = FALSE;
                        }
                        if (_tmp292_) {
                              gchar* _tmp296_ = NULL;
                              gchar* _tmp297_;
                              ValaCCodeParameter* _tmp298_ = NULL;
                              ValaCCodeParameter* _tmp299_;
                              _tmp296_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, "value");
                              _tmp297_ = _tmp296_;
                              _tmp298_ = vala_ccode_parameter_new (_tmp297_, "GDestroyNotify");
                              _tmp299_ = _tmp298_;
                              vala_ccode_function_add_parameter (function, _tmp299_);
                              _vala_ccode_node_unref0 (_tmp299_);
                              _g_free0 (_tmp297_);
                        }
                  }
            }
            if (!is_virtual) {
                  gboolean _tmp300_ = FALSE;
                  gboolean _tmp301_ = FALSE;
                  gboolean _tmp302_;
                  _tmp302_ = vala_symbol_is_private_symbol ((ValaSymbol*) prop);
                  if (_tmp302_) {
                        _tmp301_ = TRUE;
                  } else {
                        gboolean _tmp303_ = FALSE;
                        gboolean _tmp304_;
                        _tmp304_ = vala_property_accessor_get_readable (acc);
                        if (_tmp304_) {
                              _tmp303_ = TRUE;
                        } else {
                              gboolean _tmp305_;
                              _tmp305_ = vala_property_accessor_get_writable (acc);
                              _tmp303_ = _tmp305_;
                        }
                        _tmp301_ = !_tmp303_;
                  }
                  if (_tmp301_) {
                        _tmp300_ = TRUE;
                  } else {
                        ValaSymbolAccessibility _tmp306_;
                        _tmp306_ = vala_symbol_get_access ((ValaSymbol*) acc);
                        _tmp300_ = _tmp306_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;
                  }
                  if (_tmp300_) {
                        ValaCCodeModifiers _tmp307_;
                        _tmp307_ = vala_ccode_function_get_modifiers (function);
                        vala_ccode_function_set_modifiers (function, _tmp307_ | VALA_CCODE_MODIFIERS_STATIC);
                  }
            }
            vala_ccode_base_module_push_function (self, function);
            _tmp309_ = vala_property_get_binding (prop);
            if (_tmp309_ == VALA_MEMBER_BINDING_INSTANCE) {
                  _tmp308_ = !is_virtual;
            } else {
                  _tmp308_ = FALSE;
            }
            if (_tmp308_) {
                  gboolean _tmp310_ = FALSE;
                  gboolean _tmp311_;
                  _tmp311_ = vala_property_accessor_get_readable (acc);
                  if (!_tmp311_) {
                        _tmp310_ = TRUE;
                  } else {
                        _tmp310_ = returns_real_struct;
                  }
                  if (_tmp310_) {
                        vala_ccode_base_module_create_property_type_check_statement (self, prop, FALSE, t, TRUE, "self");
                  } else {
                        vala_ccode_base_module_create_property_type_check_statement (self, prop, TRUE, t, TRUE, "self");
                  }
            }
            _tmp313_ = vala_property_accessor_get_readable (acc);
            if (_tmp313_) {
                  _tmp312_ = !returns_real_struct;
            } else {
                  _tmp312_ = FALSE;
            }
            if (_tmp312_) {
                  gboolean _tmp314_ = FALSE;
                  ValaBasicBlock* _tmp315_ = NULL;
                  _tmp315_ = vala_subroutine_get_return_block ((ValaSubroutine*) acc);
                  if (_tmp315_ == NULL) {
                        _tmp314_ = TRUE;
                  } else {
                        ValaBasicBlock* _tmp316_ = NULL;
                        ValaList* _tmp317_ = NULL;
                        ValaList* _tmp318_;
                        gint _tmp319_;
                        _tmp316_ = vala_subroutine_get_return_block ((ValaSubroutine*) acc);
                        _tmp317_ = vala_basic_block_get_predecessors (_tmp316_);
                        _tmp318_ = _tmp317_;
                        _tmp319_ = vala_collection_get_size ((ValaCollection*) _tmp318_);
                        _tmp314_ = _tmp319_ > 0;
                        _vala_iterable_unref0 (_tmp318_);
                  }
                  if (_tmp314_) {
                        ValaCCodeFunction* _tmp320_ = NULL;
                        ValaDataType* _tmp321_ = NULL;
                        gchar* _tmp322_ = NULL;
                        gchar* _tmp323_;
                        ValaCCodeVariableDeclarator* _tmp324_ = NULL;
                        ValaCCodeVariableDeclarator* _tmp325_;
                        _tmp320_ = vala_ccode_base_module_get_ccode (self);
                        _tmp321_ = vala_property_accessor_get_value_type (acc);
                        _tmp322_ = vala_data_type_get_cname (_tmp321_);
                        _tmp323_ = _tmp322_;
                        _tmp324_ = vala_ccode_variable_declarator_new ("result", NULL, NULL);
                        _tmp325_ = _tmp324_;
                        vala_ccode_function_add_declaration (_tmp320_, _tmp323_, (ValaCCodeDeclarator*) _tmp325_, 0);
                        _vala_ccode_node_unref0 (_tmp325_);
                        _g_free0 (_tmp323_);
                  }
            }
            if (is_virtual) {
                  ValaCCodeFunction* _tmp326_ = NULL;
                  gchar* _tmp327_ = NULL;
                  gchar* _tmp328_;
                  ValaCCodeVariableDeclarator* _tmp329_ = NULL;
                  ValaCCodeVariableDeclarator* _tmp330_;
                  ValaCCodeFunction* _tmp331_ = NULL;
                  ValaCCodeIdentifier* _tmp332_ = NULL;
                  ValaCCodeIdentifier* _tmp333_;
                  ValaCCodeIdentifier* _tmp334_ = NULL;
                  ValaCCodeIdentifier* _tmp335_;
                  ValaGLibValue* _tmp336_ = NULL;
                  ValaGLibValue* _tmp337_;
                  ValaTargetValue* _tmp338_ = NULL;
                  ValaTargetValue* _tmp339_;
                  ValaCCodeExpression* _tmp340_ = NULL;
                  ValaCCodeExpression* _tmp341_;
                  _tmp326_ = vala_ccode_base_module_get_ccode (self);
                  _tmp327_ = vala_data_type_get_cname (this_type);
                  _tmp328_ = _tmp327_;
                  _tmp329_ = vala_ccode_variable_declarator_new ("self", NULL, NULL);
                  _tmp330_ = _tmp329_;
                  vala_ccode_function_add_declaration (_tmp326_, _tmp328_, (ValaCCodeDeclarator*) _tmp330_, 0);
                  _vala_ccode_node_unref0 (_tmp330_);
                  _g_free0 (_tmp328_);
                  _tmp331_ = vala_ccode_base_module_get_ccode (self);
                  _tmp332_ = vala_ccode_identifier_new ("self");
                  _tmp333_ = _tmp332_;
                  _tmp334_ = vala_ccode_identifier_new ("base");
                  _tmp335_ = _tmp334_;
                  _tmp336_ = vala_glib_value_new ((ValaDataType*) base_type, (ValaCCodeExpression*) _tmp335_);
                  _tmp337_ = _tmp336_;
                  _tmp338_ = vala_ccode_base_module_transform_value (self, (ValaTargetValue*) _tmp337_, this_type, (ValaCodeNode*) acc);
                  _tmp339_ = _tmp338_;
                  _tmp340_ = vala_ccode_base_module_get_cvalue_ (self, _tmp339_);
                  _tmp341_ = _tmp340_;
                  vala_ccode_function_add_assignment (_tmp331_, (ValaCCodeExpression*) _tmp333_, _tmp341_);
                  _vala_ccode_node_unref0 (_tmp341_);
                  _vala_target_value_unref0 (_tmp339_);
                  _vala_target_value_unref0 (_tmp337_);
                  _vala_ccode_node_unref0 (_tmp335_);
                  _vala_ccode_node_unref0 (_tmp333_);
            }
            _tmp342_ = vala_subroutine_get_body ((ValaSubroutine*) acc);
            vala_code_node_emit ((ValaCodeNode*) _tmp342_, (ValaCodeGenerator*) self);
            _tmp343_ = vala_ccode_base_module_get_current_method_inner_error (self);
            if (_tmp343_) {
                  ValaCCodeFunction* _tmp344_ = NULL;
                  ValaCCodeConstant* _tmp345_ = NULL;
                  ValaCCodeConstant* _tmp346_;
                  ValaCCodeVariableDeclarator* _tmp347_ = NULL;
                  ValaCCodeVariableDeclarator* _tmp348_;
                  _tmp344_ = vala_ccode_base_module_get_ccode (self);
                  _tmp345_ = vala_ccode_constant_new ("NULL");
                  _tmp346_ = _tmp345_;
                  _tmp347_ = vala_ccode_variable_declarator_new_zero ("_inner_error_", (ValaCCodeExpression*) _tmp346_, NULL);
                  _tmp348_ = _tmp347_;
                  vala_ccode_function_add_declaration (_tmp344_, "GError *", (ValaCCodeDeclarator*) _tmp348_, 0);
                  _vala_ccode_node_unref0 (_tmp348_);
                  _vala_ccode_node_unref0 (_tmp346_);
            }
            _tmp351_ = vala_ccode_base_module_is_gobject_property (self, prop);
            if (_tmp351_) {
                  gboolean _tmp352_;
                  _tmp352_ = vala_property_get_notify (prop);
                  _tmp350_ = _tmp352_;
            } else {
                  _tmp350_ = FALSE;
            }
            if (_tmp350_) {
                  gboolean _tmp353_ = FALSE;
                  gboolean _tmp354_;
                  _tmp354_ = vala_property_accessor_get_writable (acc);
                  if (_tmp354_) {
                        _tmp353_ = TRUE;
                  } else {
                        gboolean _tmp355_;
                        _tmp355_ = vala_property_accessor_get_construction (acc);
                        _tmp353_ = _tmp355_;
                  }
                  _tmp349_ = _tmp353_;
            } else {
                  _tmp349_ = FALSE;
            }
            if (_tmp349_) {
                  ValaCCodeIdentifier* _tmp356_ = NULL;
                  ValaCCodeIdentifier* _tmp357_;
                  ValaCCodeFunctionCall* _tmp358_ = NULL;
                  ValaCCodeFunctionCall* _tmp359_;
                  ValaCCodeFunctionCall* notify_call;
                  ValaCCodeIdentifier* _tmp360_ = NULL;
                  ValaCCodeIdentifier* _tmp361_;
                  ValaCCodeCastExpression* _tmp362_ = NULL;
                  ValaCCodeCastExpression* _tmp363_;
                  ValaCCodeConstant* _tmp364_ = NULL;
                  ValaCCodeConstant* _tmp365_;
                  ValaCCodeFunction* _tmp366_ = NULL;
                  _tmp356_ = vala_ccode_identifier_new ("g_object_notify");
                  _tmp357_ = _tmp356_;
                  _tmp358_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp357_);
                  _tmp359_ = _tmp358_;
                  _vala_ccode_node_unref0 (_tmp357_);
                  notify_call = _tmp359_;
                  _tmp360_ = vala_ccode_identifier_new ("self");
                  _tmp361_ = _tmp360_;
                  _tmp362_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp361_, "GObject *");
                  _tmp363_ = _tmp362_;
                  vala_ccode_function_call_add_argument (notify_call, (ValaCCodeExpression*) _tmp363_);
                  _vala_ccode_node_unref0 (_tmp363_);
                  _vala_ccode_node_unref0 (_tmp361_);
                  _tmp364_ = vala_property_get_canonical_cconstant (prop);
                  _tmp365_ = _tmp364_;
                  vala_ccode_function_call_add_argument (notify_call, (ValaCCodeExpression*) _tmp365_);
                  _vala_ccode_node_unref0 (_tmp365_);
                  _tmp366_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_expression (_tmp366_, (ValaCCodeExpression*) notify_call);
                  _vala_ccode_node_unref0 (notify_call);
            }
            vala_ccode_file_add_function (self->cfile, function);
            _vala_code_node_unref0 (base_type);
            _vala_ccode_node_unref0 (function);
            _g_free0 (cname);
      }
      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;
      ValaMemberBinding _tmp1_;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (d != NULL);
      _tmp1_ = vala_destructor_get_binding (d);
      if (_tmp1_ == VALA_MEMBER_BINDING_STATIC) {
            _tmp0_ = !self->in_plugin;
      } else {
            _tmp0_ = FALSE;
      }
      if (_tmp0_) {
            ValaSourceReference* _tmp2_ = NULL;
            _tmp2_ = vala_code_node_get_source_reference ((ValaCodeNode*) d);
            vala_report_error (_tmp2_, "static destructors are only supported for dynamic types");
            vala_code_node_set_error ((ValaCodeNode*) d, TRUE);
            return;
      }
}


gint vala_ccode_base_module_get_block_id (ValaCCodeBaseModule* self, ValaBlock* b) {
      gint result = 0;
      gpointer _tmp0_ = NULL;
      gint _result_;
      g_return_val_if_fail (self != NULL, 0);
      g_return_val_if_fail (b != NULL, 0);
      _tmp0_ = vala_map_get (self->priv->block_map, b);
      _result_ = GPOINTER_TO_INT (_tmp0_);
      if (_result_ == 0) {
            self->priv->next_block_id = self->priv->next_block_id + 1;
            _result_ = self->priv->next_block_id;
            vala_map_set (self->priv->block_map, b, GINT_TO_POINTER (_result_));
      }
      result = _result_;
      return result;
}


static void vala_ccode_base_module_capture_parameter (ValaCCodeBaseModule* self, ValaParameter* param, ValaCCodeStruct* data, gint block_id) {
      ValaDataType* _tmp0_ = NULL;
      ValaDataType* _tmp1_ = NULL;
      ValaDataType* _tmp2_ = NULL;
      ValaDataType* param_type;
      gchar* _tmp3_ = NULL;
      gchar* _tmp4_;
      const gchar* _tmp5_ = NULL;
      gchar* _tmp6_ = NULL;
      gchar* _tmp7_;
      gboolean _tmp8_ = FALSE;
      ValaDataType* _tmp9_ = NULL;
      gboolean is_unowned_delegate;
      ValaTargetValue* _tmp12_ = NULL;
      ValaTargetValue* value;
      gboolean _tmp13_ = FALSE;
      gboolean _tmp14_ = FALSE;
      gboolean _tmp15_;
      ValaDataType* _tmp19_ = NULL;
      ValaDataType* _tmp20_;
      ValaArrayType* _tmp21_;
      ValaArrayType* array_type;
      ValaDataType* _tmp22_ = NULL;
      ValaDataType* _tmp23_;
      ValaDelegateType* _tmp24_;
      ValaDelegateType* deleg_type;
      gboolean _tmp25_ = FALSE;
      g_return_if_fail (self != NULL);
      g_return_if_fail (param != NULL);
      g_return_if_fail (data != NULL);
      _tmp0_ = vala_variable_get_variable_type ((ValaVariable*) param);
      vala_ccode_base_module_generate_type_declaration (self, _tmp0_, self->cfile);
      _tmp1_ = vala_variable_get_variable_type ((ValaVariable*) param);
      _tmp2_ = vala_data_type_copy (_tmp1_);
      param_type = _tmp2_;
      vala_data_type_set_value_owned (param_type, TRUE);
      _tmp3_ = vala_data_type_get_cname (param_type);
      _tmp4_ = _tmp3_;
      _tmp5_ = vala_symbol_get_name ((ValaSymbol*) param);
      _tmp6_ = vala_ccode_base_module_get_variable_cname (self, _tmp5_);
      _tmp7_ = _tmp6_;
      vala_ccode_struct_add_field (data, _tmp4_, _tmp7_, NULL);
      _g_free0 (_tmp7_);
      _g_free0 (_tmp4_);
      _tmp9_ = vala_variable_get_variable_type ((ValaVariable*) param);
      if (VALA_IS_DELEGATE_TYPE (_tmp9_)) {
            ValaDataType* _tmp10_ = NULL;
            gboolean _tmp11_;
            _tmp10_ = vala_variable_get_variable_type ((ValaVariable*) param);
            _tmp11_ = vala_data_type_get_value_owned (_tmp10_);
            _tmp8_ = !_tmp11_;
      } else {
            _tmp8_ = FALSE;
      }
      is_unowned_delegate = _tmp8_;
      vala_parameter_set_captured (param, FALSE);
      _tmp12_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, param);
      value = _tmp12_;
      _tmp15_ = vala_ccode_base_module_requires_copy (self, param_type);
      if (_tmp15_) {
            ValaDataType* _tmp16_ = NULL;
            gboolean _tmp17_;
            _tmp16_ = vala_variable_get_variable_type ((ValaVariable*) param);
            _tmp17_ = vala_data_type_get_value_owned (_tmp16_);
            _tmp14_ = !_tmp17_;
      } else {
            _tmp14_ = FALSE;
      }
      if (_tmp14_) {
            _tmp13_ = !is_unowned_delegate;
      } else {
            _tmp13_ = FALSE;
      }
      if (_tmp13_) {
            ValaTargetValue* _tmp18_ = NULL;
            _tmp18_ = vala_ccode_base_module_copy_value (self, value, (ValaCodeNode*) param);
            _vala_target_value_unref0 (value);
            value = _tmp18_;
      }
      _tmp19_ = vala_variable_get_variable_type ((ValaVariable*) param);
      _tmp20_ = _tmp19_;
      _tmp21_ = _vala_code_node_ref0 (VALA_IS_ARRAY_TYPE (_tmp20_) ? ((ValaArrayType*) _tmp20_) : NULL);
      array_type = _tmp21_;
      _tmp22_ = vala_variable_get_variable_type ((ValaVariable*) param);
      _tmp23_ = _tmp22_;
      _tmp24_ = _vala_code_node_ref0 (VALA_IS_DELEGATE_TYPE (_tmp23_) ? ((ValaDelegateType*) _tmp23_) : NULL);
      deleg_type = _tmp24_;
      if (array_type != NULL) {
            gboolean _tmp26_;
            _tmp26_ = vala_variable_get_no_array_length ((ValaVariable*) param);
            _tmp25_ = !_tmp26_;
      } else {
            _tmp25_ = FALSE;
      }
      if (_tmp25_) {
            {
                  gint dim;
                  dim = 1;
                  {
                        gboolean _tmp27_;
                        _tmp27_ = TRUE;
                        while (TRUE) {
                              gint _tmp28_;
                              gchar* _tmp29_ = NULL;
                              gchar* _tmp30_;
                              if (!_tmp27_) {
                                    dim++;
                              }
                              _tmp27_ = FALSE;
                              _tmp28_ = vala_array_type_get_rank (array_type);
                              if (!(dim <= _tmp28_)) {
                                    break;
                              }
                              _tmp29_ = vala_ccode_base_module_get_parameter_array_length_cname (self, param, dim);
                              _tmp30_ = _tmp29_;
                              vala_ccode_struct_add_field (data, "gint", _tmp30_, NULL);
                              _g_free0 (_tmp30_);
                        }
                  }
            }
      } else {
            gboolean _tmp31_ = FALSE;
            if (deleg_type != NULL) {
                  ValaDelegate* _tmp32_ = NULL;
                  gboolean _tmp33_;
                  _tmp32_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                  _tmp33_ = vala_delegate_get_has_target (_tmp32_);
                  _tmp31_ = _tmp33_;
            } else {
                  _tmp31_ = FALSE;
            }
            if (_tmp31_) {
                  const gchar* _tmp34_ = NULL;
                  gchar* _tmp35_ = NULL;
                  gchar* _tmp36_;
                  gchar* _tmp37_ = NULL;
                  gchar* _tmp38_;
                  ValaDataType* _tmp39_ = NULL;
                  gboolean _tmp40_;
                  _tmp34_ = vala_symbol_get_name ((ValaSymbol*) param);
                  _tmp35_ = vala_ccode_base_module_get_variable_cname (self, _tmp34_);
                  _tmp36_ = _tmp35_;
                  _tmp37_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp36_);
                  _tmp38_ = _tmp37_;
                  vala_ccode_struct_add_field (data, "gpointer", _tmp38_, NULL);
                  _g_free0 (_tmp38_);
                  _g_free0 (_tmp36_);
                  _tmp39_ = vala_variable_get_variable_type ((ValaVariable*) param);
                  _tmp40_ = vala_data_type_get_value_owned (_tmp39_);
                  if (_tmp40_) {
                        const gchar* _tmp41_ = NULL;
                        gchar* _tmp42_ = NULL;
                        gchar* _tmp43_;
                        gchar* _tmp44_ = NULL;
                        gchar* _tmp45_;
                        ValaTargetValue* _tmp46_ = NULL;
                        ValaTargetValue* lvalue;
                        ValaCCodeExpression* _tmp47_ = NULL;
                        _tmp41_ = vala_symbol_get_name ((ValaSymbol*) param);
                        _tmp42_ = vala_ccode_base_module_get_variable_cname (self, _tmp41_);
                        _tmp43_ = _tmp42_;
                        _tmp44_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp43_);
                        _tmp45_ = _tmp44_;
                        vala_ccode_struct_add_field (data, "GDestroyNotify", _tmp45_, NULL);
                        _g_free0 (_tmp45_);
                        _g_free0 (_tmp43_);
                        _tmp46_ = vala_ccode_base_module_get_parameter_cvalue (self, param);
                        lvalue = _tmp46_;
                        _tmp47_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, lvalue);
                        _vala_ccode_node_unref0 (VALA_GLIB_VALUE (value)->delegate_target_destroy_notify_cvalue);
                        VALA_GLIB_VALUE (value)->delegate_target_destroy_notify_cvalue = _tmp47_;
                        _vala_target_value_unref0 (lvalue);
                  }
            }
      }
      vala_parameter_set_captured (param, TRUE);
      vala_code_generator_store_parameter ((ValaCodeGenerator*) self, param, value);
      _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;
      ValaList* _tmp0_ = NULL;
      ValaList* local_vars;
      gboolean _tmp1_ = FALSE;
      gboolean _tmp2_ = FALSE;
      ValaCodeNode* _tmp3_ = NULL;
      gboolean _tmp7_;
      ValaSymbol* _tmp452_ = NULL;
      gboolean _tmp487_;
      gboolean _tmp507_ = FALSE;
      gboolean _tmp508_ = FALSE;
      ValaCodeNode* _tmp509_ = NULL;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (b != NULL);
      vala_ccode_base_module_emit_context_push_symbol (self->emit_context, (ValaSymbol*) b);
      _tmp0_ = vala_block_get_local_variables (b);
      local_vars = _tmp0_;
      _tmp3_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
      if (VALA_IS_BLOCK (_tmp3_)) {
            _tmp2_ = TRUE;
      } else {
            ValaCodeNode* _tmp4_ = NULL;
            _tmp4_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
            _tmp2_ = VALA_IS_SWITCH_STATEMENT (_tmp4_);
      }
      if (_tmp2_) {
            _tmp1_ = TRUE;
      } else {
            ValaCodeNode* _tmp5_ = NULL;
            _tmp5_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
            _tmp1_ = VALA_IS_TRY_STATEMENT (_tmp5_);
      }
      if (_tmp1_) {
            ValaCCodeFunction* _tmp6_ = NULL;
            _tmp6_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_open_block (_tmp6_);
      }
      _tmp7_ = vala_block_get_captured (b);
      if (_tmp7_) {
            ValaSymbol* _tmp8_ = NULL;
            ValaBlock* _tmp9_ = NULL;
            ValaBlock* _tmp10_;
            ValaBlock* parent_block;
            gint _tmp11_;
            gint block_id;
            gchar* _tmp12_ = NULL;
            gchar* struct_name;
            gchar* _tmp13_;
            gchar* _tmp14_;
            ValaCCodeStruct* _tmp15_ = NULL;
            ValaCCodeStruct* _tmp16_;
            ValaCCodeStruct* data;
            ValaCCodeIdentifier* _tmp99_ = NULL;
            ValaCCodeIdentifier* _tmp100_;
            ValaCCodeFunctionCall* _tmp101_ = NULL;
            ValaCCodeFunctionCall* _tmp102_;
            ValaCCodeFunctionCall* data_alloc;
            ValaCCodeIdentifier* _tmp103_ = NULL;
            ValaCCodeIdentifier* _tmp104_;
            gboolean _tmp105_;
            ValaCCodeFunction* _tmp117_ = NULL;
            gchar* _tmp118_ = NULL;
            gchar* _tmp119_;
            ValaCCodeExpression* _tmp120_ = NULL;
            ValaCCodeExpression* _tmp121_;
            ValaCCodeFunction* _tmp122_ = NULL;
            gchar* _tmp123_ = NULL;
            gchar* _tmp124_;
            ValaCCodeExpression* _tmp125_ = NULL;
            ValaCCodeExpression* _tmp126_;
            ValaCCodeMemberAccess* _tmp127_ = NULL;
            ValaCCodeMemberAccess* _tmp128_;
            ValaCCodeIdentifier* _tmp129_ = NULL;
            ValaCCodeIdentifier* _tmp130_;
            ValaSymbol* _tmp233_ = NULL;
            gchar* _tmp258_;
            gchar* _tmp259_;
            ValaCCodeVariableDeclarator* _tmp260_ = NULL;
            ValaCCodeVariableDeclarator* _tmp261_;
            ValaCCodeTypeDefinition* _tmp262_ = NULL;
            ValaCCodeTypeDefinition* _tmp263_;
            ValaCCodeTypeDefinition* _typedef_;
            gchar* _tmp264_ = NULL;
            gchar* _tmp265_;
            gchar* _tmp266_;
            gchar* _tmp267_;
            ValaCCodeFunction* _tmp268_ = NULL;
            ValaCCodeFunction* _tmp269_;
            ValaCCodeFunction* ref_fun;
            gchar* _tmp270_ = NULL;
            gchar* _tmp271_;
            gchar* _tmp272_;
            gchar* _tmp273_;
            ValaCCodeParameter* _tmp274_ = NULL;
            ValaCCodeParameter* _tmp275_;
            ValaCCodeIdentifier* _tmp276_ = NULL;
            ValaCCodeIdentifier* _tmp277_;
            ValaCCodeFunctionCall* _tmp278_ = NULL;
            ValaCCodeFunctionCall* _tmp279_;
            ValaCCodeFunctionCall* ccall;
            gchar* _tmp280_ = NULL;
            gchar* _tmp281_;
            ValaCCodeIdentifier* _tmp282_ = NULL;
            ValaCCodeIdentifier* _tmp283_;
            ValaCCodeMemberAccess* _tmp284_ = NULL;
            ValaCCodeMemberAccess* _tmp285_;
            ValaCCodeUnaryExpression* _tmp286_ = NULL;
            ValaCCodeUnaryExpression* _tmp287_;
            ValaCCodeFunction* _tmp288_ = NULL;
            ValaCCodeFunction* _tmp289_ = NULL;
            gchar* _tmp290_ = NULL;
            gchar* _tmp291_;
            ValaCCodeIdentifier* _tmp292_ = NULL;
            ValaCCodeIdentifier* _tmp293_;
            gchar* _tmp294_ = NULL;
            gchar* _tmp295_;
            ValaCCodeFunction* _tmp296_ = NULL;
            ValaCCodeFunction* _tmp297_;
            ValaCCodeFunction* unref_fun;
            gchar* _tmp298_ = NULL;
            gchar* _tmp299_;
            gchar* _tmp300_;
            gchar* _tmp301_;
            ValaCCodeParameter* _tmp302_ = NULL;
            ValaCCodeParameter* _tmp303_;
            ValaCCodeIdentifier* _tmp304_ = NULL;
            ValaCCodeIdentifier* _tmp305_;
            ValaCCodeFunctionCall* _tmp306_ = NULL;
            gchar* _tmp307_ = NULL;
            gchar* _tmp308_;
            ValaCCodeIdentifier* _tmp309_ = NULL;
            ValaCCodeIdentifier* _tmp310_;
            ValaCCodeMemberAccess* _tmp311_ = NULL;
            ValaCCodeMemberAccess* _tmp312_;
            ValaCCodeUnaryExpression* _tmp313_ = NULL;
            ValaCCodeUnaryExpression* _tmp314_;
            ValaCCodeFunction* _tmp315_ = NULL;
            ValaSymbol* _tmp382_ = NULL;
            ValaCCodeIdentifier* _tmp423_ = NULL;
            ValaCCodeIdentifier* _tmp424_;
            ValaCCodeFunctionCall* _tmp425_ = NULL;
            ValaCCodeFunctionCall* _tmp426_;
            ValaCCodeFunctionCall* data_free;
            ValaCCodeIdentifier* _tmp427_ = NULL;
            ValaCCodeIdentifier* _tmp428_;
            gchar* _tmp429_ = NULL;
            gchar* _tmp430_;
            ValaCCodeIdentifier* _tmp431_ = NULL;
            ValaCCodeIdentifier* _tmp432_;
            ValaCCodeFunction* _tmp433_ = NULL;
            ValaCCodeFunction* _tmp434_ = NULL;
            _tmp8_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
            _tmp9_ = vala_ccode_base_module_next_closure_block (self, _tmp8_);
            _tmp10_ = _vala_code_node_ref0 (_tmp9_);
            parent_block = _tmp10_;
            _tmp11_ = vala_ccode_base_module_get_block_id (self, b);
            block_id = _tmp11_;
            _tmp12_ = g_strdup_printf ("Block%dData", block_id);
            struct_name = _tmp12_;
            _tmp13_ = g_strconcat ("_", struct_name, NULL);
            _tmp14_ = _tmp13_;
            _tmp15_ = vala_ccode_struct_new (_tmp14_);
            _tmp16_ = _tmp15_;
            _g_free0 (_tmp14_);
            data = _tmp16_;
            vala_ccode_struct_add_field (data, "int", "_ref_count_", NULL);
            if (parent_block != NULL) {
                  gint _tmp17_;
                  gint parent_block_id;
                  gchar* _tmp18_ = NULL;
                  gchar* _tmp19_;
                  gchar* _tmp20_ = NULL;
                  gchar* _tmp21_;
                  _tmp17_ = vala_ccode_base_module_get_block_id (self, parent_block);
                  parent_block_id = _tmp17_;
                  _tmp18_ = g_strdup_printf ("Block%dData *", parent_block_id);
                  _tmp19_ = _tmp18_;
                  _tmp20_ = g_strdup_printf ("_data%d_", parent_block_id);
                  _tmp21_ = _tmp20_;
                  vala_ccode_struct_add_field (data, _tmp19_, _tmp21_, NULL);
                  _g_free0 (_tmp21_);
                  _g_free0 (_tmp19_);
            } else {
                  gboolean _tmp22_ = FALSE;
                  gboolean _tmp23_ = FALSE;
                  ValaMethod* _tmp38_ = NULL;
                  if (self->in_constructor) {
                        _tmp23_ = TRUE;
                  } else {
                        gboolean _tmp24_ = FALSE;
                        ValaMethod* _tmp25_ = NULL;
                        _tmp25_ = vala_ccode_base_module_get_current_method (self);
                        if (_tmp25_ != NULL) {
                              ValaMethod* _tmp26_ = NULL;
                              ValaMemberBinding _tmp27_;
                              _tmp26_ = vala_ccode_base_module_get_current_method (self);
                              _tmp27_ = vala_method_get_binding (_tmp26_);
                              _tmp24_ = _tmp27_ == VALA_MEMBER_BINDING_INSTANCE;
                        } else {
                              _tmp24_ = FALSE;
                        }
                        _tmp23_ = _tmp24_;
                  }
                  if (_tmp23_) {
                        _tmp22_ = TRUE;
                  } else {
                        gboolean _tmp28_ = FALSE;
                        ValaPropertyAccessor* _tmp29_ = NULL;
                        _tmp29_ = vala_ccode_base_module_get_current_property_accessor (self);
                        if (_tmp29_ != NULL) {
                              ValaPropertyAccessor* _tmp30_ = NULL;
                              ValaProperty* _tmp31_ = NULL;
                              ValaMemberBinding _tmp32_;
                              _tmp30_ = vala_ccode_base_module_get_current_property_accessor (self);
                              _tmp31_ = vala_property_accessor_get_prop (_tmp30_);
                              _tmp32_ = vala_property_get_binding (_tmp31_);
                              _tmp28_ = _tmp32_ == VALA_MEMBER_BINDING_INSTANCE;
                        } else {
                              _tmp28_ = FALSE;
                        }
                        _tmp22_ = _tmp28_;
                  }
                  if (_tmp22_) {
                        ValaTypeSymbol* _tmp33_ = NULL;
                        gchar* _tmp34_ = NULL;
                        gchar* _tmp35_;
                        gchar* _tmp36_ = NULL;
                        gchar* _tmp37_;
                        _tmp33_ = vala_ccode_base_module_get_current_type_symbol (self);
                        _tmp34_ = vala_typesymbol_get_cname (_tmp33_, FALSE);
                        _tmp35_ = _tmp34_;
                        _tmp36_ = g_strdup_printf ("%s *", _tmp35_);
                        _tmp37_ = _tmp36_;
                        vala_ccode_struct_add_field (data, _tmp37_, "self", NULL);
                        _g_free0 (_tmp37_);
                        _g_free0 (_tmp35_);
                  }
                  _tmp38_ = vala_ccode_base_module_get_current_method (self);
                  if (_tmp38_ != NULL) {
                        {
                              ValaMethod* _tmp39_ = NULL;
                              ValaList* _tmp40_ = NULL;
                              ValaList* _type_param_list;
                              gint _tmp41_;
                              gint _type_param_size;
                              gint _type_param_index;
                              _tmp39_ = vala_ccode_base_module_get_current_method (self);
                              _tmp40_ = vala_method_get_type_parameters (_tmp39_);
                              _type_param_list = _tmp40_;
                              _tmp41_ = vala_collection_get_size ((ValaCollection*) _type_param_list);
                              _type_param_size = _tmp41_;
                              _type_param_index = -1;
                              while (TRUE) {
                                    gpointer _tmp42_ = NULL;
                                    ValaTypeParameter* type_param;
                                    gchar* func_name = NULL;
                                    const gchar* _tmp43_ = NULL;
                                    gchar* _tmp44_ = NULL;
                                    gchar* _tmp45_;
                                    gchar* _tmp46_ = NULL;
                                    const gchar* _tmp47_ = NULL;
                                    gchar* _tmp48_ = NULL;
                                    gchar* _tmp49_;
                                    gchar* _tmp50_ = NULL;
                                    const gchar* _tmp51_ = NULL;
                                    gchar* _tmp52_ = NULL;
                                    gchar* _tmp53_;
                                    gchar* _tmp54_ = NULL;
                                    _type_param_index = _type_param_index + 1;
                                    if (!(_type_param_index < _type_param_size)) {
                                          break;
                                    }
                                    _tmp42_ = vala_list_get (_type_param_list, _type_param_index);
                                    type_param = (ValaTypeParameter*) _tmp42_;
                                    _tmp43_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                    _tmp44_ = g_utf8_strdown (_tmp43_, (gssize) (-1));
                                    _tmp45_ = _tmp44_;
                                    _tmp46_ = g_strdup_printf ("%s_type", _tmp45_);
                                    _g_free0 (func_name);
                                    func_name = _tmp46_;
                                    _g_free0 (_tmp45_);
                                    vala_ccode_struct_add_field (data, "GType", func_name, NULL);
                                    _tmp47_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                    _tmp48_ = g_utf8_strdown (_tmp47_, (gssize) (-1));
                                    _tmp49_ = _tmp48_;
                                    _tmp50_ = g_strdup_printf ("%s_dup_func", _tmp49_);
                                    _g_free0 (func_name);
                                    func_name = _tmp50_;
                                    _g_free0 (_tmp49_);
                                    vala_ccode_struct_add_field (data, "GBoxedCopyFunc", func_name, NULL);
                                    _tmp51_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                    _tmp52_ = g_utf8_strdown (_tmp51_, (gssize) (-1));
                                    _tmp53_ = _tmp52_;
                                    _tmp54_ = g_strdup_printf ("%s_destroy_func", _tmp53_);
                                    _g_free0 (func_name);
                                    func_name = _tmp54_;
                                    _g_free0 (_tmp53_);
                                    vala_ccode_struct_add_field (data, "GDestroyNotify", func_name, NULL);
                                    _g_free0 (func_name);
                                    _vala_code_node_unref0 (type_param);
                              }
                              _vala_iterable_unref0 (_type_param_list);
                        }
                  }
            }
            {
                  ValaList* _tmp55_;
                  ValaList* _local_list;
                  gint _tmp56_;
                  gint _local_size;
                  gint _local_index;
                  _tmp55_ = _vala_iterable_ref0 (local_vars);
                  _local_list = _tmp55_;
                  _tmp56_ = vala_collection_get_size ((ValaCollection*) _local_list);
                  _local_size = _tmp56_;
                  _local_index = -1;
                  while (TRUE) {
                        gpointer _tmp57_ = NULL;
                        ValaLocalVariable* local;
                        gboolean _tmp58_;
                        _local_index = _local_index + 1;
                        if (!(_local_index < _local_size)) {
                              break;
                        }
                        _tmp57_ = vala_list_get (_local_list, _local_index);
                        local = (ValaLocalVariable*) _tmp57_;
                        _tmp58_ = vala_local_variable_get_captured (local);
                        if (_tmp58_) {
                              ValaDataType* _tmp59_ = NULL;
                              ValaDataType* _tmp60_ = NULL;
                              gchar* _tmp61_ = NULL;
                              gchar* _tmp62_;
                              const gchar* _tmp63_ = NULL;
                              gchar* _tmp64_ = NULL;
                              gchar* _tmp65_;
                              ValaDataType* _tmp66_ = NULL;
                              gchar* _tmp67_ = NULL;
                              gchar* _tmp68_;
                              gchar* _tmp69_;
                              gchar* _tmp70_;
                              ValaDataType* _tmp71_ = NULL;
                              _tmp59_ = vala_variable_get_variable_type ((ValaVariable*) local);
                              vala_ccode_base_module_generate_type_declaration (self, _tmp59_, self->cfile);
                              _tmp60_ = vala_variable_get_variable_type ((ValaVariable*) local);
                              _tmp61_ = vala_data_type_get_cname (_tmp60_);
                              _tmp62_ = _tmp61_;
                              _tmp63_ = vala_symbol_get_name ((ValaSymbol*) local);
                              _tmp64_ = vala_ccode_base_module_get_variable_cname (self, _tmp63_);
                              _tmp65_ = _tmp64_;
                              _tmp66_ = vala_variable_get_variable_type ((ValaVariable*) local);
                              _tmp67_ = vala_data_type_get_cdeclarator_suffix (_tmp66_);
                              _tmp68_ = _tmp67_;
                              _tmp69_ = g_strconcat (_tmp65_, _tmp68_, NULL);
                              _tmp70_ = _tmp69_;
                              vala_ccode_struct_add_field (data, _tmp62_, _tmp70_, NULL);
                              _g_free0 (_tmp70_);
                              _g_free0 (_tmp68_);
                              _g_free0 (_tmp65_);
                              _g_free0 (_tmp62_);
                              _tmp71_ = vala_variable_get_variable_type ((ValaVariable*) local);
                              if (VALA_IS_ARRAY_TYPE (_tmp71_)) {
                                    ValaDataType* _tmp72_ = NULL;
                                    ValaArrayType* _tmp73_;
                                    ValaArrayType* array_type;
                                    const gchar* _tmp81_ = NULL;
                                    gchar* _tmp82_ = NULL;
                                    gchar* _tmp83_;
                                    gchar* _tmp84_ = NULL;
                                    gchar* _tmp85_;
                                    _tmp72_ = vala_variable_get_variable_type ((ValaVariable*) local);
                                    _tmp73_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp72_));
                                    array_type = _tmp73_;
                                    {
                                          gint dim;
                                          dim = 1;
                                          {
                                                gboolean _tmp74_;
                                                _tmp74_ = TRUE;
                                                while (TRUE) {
                                                      gint _tmp75_;
                                                      const gchar* _tmp76_ = NULL;
                                                      gchar* _tmp77_ = NULL;
                                                      gchar* _tmp78_;
                                                      gchar* _tmp79_ = NULL;
                                                      gchar* _tmp80_;
                                                      if (!_tmp74_) {
                                                            dim++;
                                                      }
                                                      _tmp74_ = FALSE;
                                                      _tmp75_ = vala_array_type_get_rank (array_type);
                                                      if (!(dim <= _tmp75_)) {
                                                            break;
                                                      }
                                                      _tmp76_ = vala_symbol_get_name ((ValaSymbol*) local);
                                                      _tmp77_ = vala_ccode_base_module_get_variable_cname (self, _tmp76_);
                                                      _tmp78_ = _tmp77_;
                                                      _tmp79_ = vala_ccode_base_module_get_array_length_cname (self, _tmp78_, dim);
                                                      _tmp80_ = _tmp79_;
                                                      vala_ccode_struct_add_field (data, "gint", _tmp80_, NULL);
                                                      _g_free0 (_tmp80_);
                                                      _g_free0 (_tmp78_);
                                                }
                                          }
                                    }
                                    _tmp81_ = vala_symbol_get_name ((ValaSymbol*) local);
                                    _tmp82_ = vala_ccode_base_module_get_variable_cname (self, _tmp81_);
                                    _tmp83_ = _tmp82_;
                                    _tmp84_ = vala_ccode_base_module_get_array_size_cname (self, _tmp83_);
                                    _tmp85_ = _tmp84_;
                                    vala_ccode_struct_add_field (data, "gint", _tmp85_, NULL);
                                    _g_free0 (_tmp85_);
                                    _g_free0 (_tmp83_);
                                    _vala_code_node_unref0 (array_type);
                              } else {
                                    ValaDataType* _tmp86_ = NULL;
                                    _tmp86_ = vala_variable_get_variable_type ((ValaVariable*) local);
                                    if (VALA_IS_DELEGATE_TYPE (_tmp86_)) {
                                          const gchar* _tmp87_ = NULL;
                                          gchar* _tmp88_ = NULL;
                                          gchar* _tmp89_;
                                          gchar* _tmp90_ = NULL;
                                          gchar* _tmp91_;
                                          ValaDataType* _tmp92_ = NULL;
                                          gboolean _tmp93_;
                                          _tmp87_ = vala_symbol_get_name ((ValaSymbol*) local);
                                          _tmp88_ = vala_ccode_base_module_get_variable_cname (self, _tmp87_);
                                          _tmp89_ = _tmp88_;
                                          _tmp90_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp89_);
                                          _tmp91_ = _tmp90_;
                                          vala_ccode_struct_add_field (data, "gpointer", _tmp91_, NULL);
                                          _g_free0 (_tmp91_);
                                          _g_free0 (_tmp89_);
                                          _tmp92_ = vala_variable_get_variable_type ((ValaVariable*) local);
                                          _tmp93_ = vala_data_type_get_value_owned (_tmp92_);
                                          if (_tmp93_) {
                                                const gchar* _tmp94_ = NULL;
                                                gchar* _tmp95_ = NULL;
                                                gchar* _tmp96_;
                                                gchar* _tmp97_ = NULL;
                                                gchar* _tmp98_;
                                                _tmp94_ = vala_symbol_get_name ((ValaSymbol*) local);
                                                _tmp95_ = vala_ccode_base_module_get_variable_cname (self, _tmp94_);
                                                _tmp96_ = _tmp95_;
                                                _tmp97_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp96_);
                                                _tmp98_ = _tmp97_;
                                                vala_ccode_struct_add_field (data, "GDestroyNotify", _tmp98_, NULL);
                                                _g_free0 (_tmp98_);
                                                _g_free0 (_tmp96_);
                                          }
                                    }
                              }
                        }
                        _vala_code_node_unref0 (local);
                  }
                  _vala_iterable_unref0 (_local_list);
            }
            _tmp99_ = vala_ccode_identifier_new ("g_slice_new0");
            _tmp100_ = _tmp99_;
            _tmp101_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp100_);
            _tmp102_ = _tmp101_;
            _vala_ccode_node_unref0 (_tmp100_);
            data_alloc = _tmp102_;
            _tmp103_ = vala_ccode_identifier_new (struct_name);
            _tmp104_ = _tmp103_;
            vala_ccode_function_call_add_argument (data_alloc, (ValaCCodeExpression*) _tmp104_);
            _vala_ccode_node_unref0 (_tmp104_);
            _tmp105_ = vala_ccode_base_module_is_in_coroutine (self);
            if (_tmp105_) {
                  gchar* _tmp106_;
                  gchar* _tmp107_;
                  gchar* _tmp108_ = NULL;
                  gchar* _tmp109_;
                  _tmp106_ = g_strconcat (struct_name, "*", NULL);
                  _tmp107_ = _tmp106_;
                  _tmp108_ = g_strdup_printf ("_data%d_", block_id);
                  _tmp109_ = _tmp108_;
                  vala_ccode_struct_add_field (self->closure_struct, _tmp107_, _tmp109_, NULL);
                  _g_free0 (_tmp109_);
                  _g_free0 (_tmp107_);
            } else {
                  ValaCCodeFunction* _tmp110_ = NULL;
                  gchar* _tmp111_;
                  gchar* _tmp112_;
                  gchar* _tmp113_ = NULL;
                  gchar* _tmp114_;
                  ValaCCodeVariableDeclarator* _tmp115_ = NULL;
                  ValaCCodeVariableDeclarator* _tmp116_;
                  _tmp110_ = vala_ccode_base_module_get_ccode (self);
                  _tmp111_ = g_strconcat (struct_name, "*", NULL);
                  _tmp112_ = _tmp111_;
                  _tmp113_ = g_strdup_printf ("_data%d_", block_id);
                  _tmp114_ = _tmp113_;
                  _tmp115_ = vala_ccode_variable_declarator_new (_tmp114_, NULL, NULL);
                  _tmp116_ = _tmp115_;
                  vala_ccode_function_add_declaration (_tmp110_, _tmp112_, (ValaCCodeDeclarator*) _tmp116_, 0);
                  _vala_ccode_node_unref0 (_tmp116_);
                  _g_free0 (_tmp114_);
                  _g_free0 (_tmp112_);
            }
            _tmp117_ = vala_ccode_base_module_get_ccode (self);
            _tmp118_ = g_strdup_printf ("_data%d_", block_id);
            _tmp119_ = _tmp118_;
            _tmp120_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp119_);
            _tmp121_ = _tmp120_;
            vala_ccode_function_add_assignment (_tmp117_, _tmp121_, (ValaCCodeExpression*) data_alloc);
            _vala_ccode_node_unref0 (_tmp121_);
            _g_free0 (_tmp119_);
            _tmp122_ = vala_ccode_base_module_get_ccode (self);
            _tmp123_ = g_strdup_printf ("_data%d_", block_id);
            _tmp124_ = _tmp123_;
            _tmp125_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp124_);
            _tmp126_ = _tmp125_;
            _tmp127_ = vala_ccode_member_access_new_pointer (_tmp126_, "_ref_count_");
            _tmp128_ = _tmp127_;
            _tmp129_ = vala_ccode_identifier_new ("1");
            _tmp130_ = _tmp129_;
            vala_ccode_function_add_assignment (_tmp122_, (ValaCCodeExpression*) _tmp128_, (ValaCCodeExpression*) _tmp130_);
            _vala_ccode_node_unref0 (_tmp130_);
            _vala_ccode_node_unref0 (_tmp128_);
            _vala_ccode_node_unref0 (_tmp126_);
            _g_free0 (_tmp124_);
            if (parent_block != NULL) {
                  gint _tmp131_;
                  gint parent_block_id;
                  gchar* _tmp132_ = NULL;
                  gchar* _tmp133_;
                  ValaCCodeIdentifier* _tmp134_ = NULL;
                  ValaCCodeIdentifier* _tmp135_;
                  ValaCCodeFunctionCall* _tmp136_ = NULL;
                  ValaCCodeFunctionCall* _tmp137_;
                  ValaCCodeFunctionCall* ref_call;
                  gchar* _tmp138_ = NULL;
                  gchar* _tmp139_;
                  ValaCCodeExpression* _tmp140_ = NULL;
                  ValaCCodeExpression* _tmp141_;
                  ValaCCodeFunction* _tmp142_ = NULL;
                  gchar* _tmp143_ = NULL;
                  gchar* _tmp144_;
                  ValaCCodeExpression* _tmp145_ = NULL;
                  ValaCCodeExpression* _tmp146_;
                  gchar* _tmp147_ = NULL;
                  gchar* _tmp148_;
                  ValaCCodeMemberAccess* _tmp149_ = NULL;
                  ValaCCodeMemberAccess* _tmp150_;
                  _tmp131_ = vala_ccode_base_module_get_block_id (self, parent_block);
                  parent_block_id = _tmp131_;
                  _tmp132_ = g_strdup_printf ("block%d_data_ref", parent_block_id);
                  _tmp133_ = _tmp132_;
                  _tmp134_ = vala_ccode_identifier_new (_tmp133_);
                  _tmp135_ = _tmp134_;
                  _tmp136_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp135_);
                  _tmp137_ = _tmp136_;
                  _vala_ccode_node_unref0 (_tmp135_);
                  _g_free0 (_tmp133_);
                  ref_call = _tmp137_;
                  _tmp138_ = g_strdup_printf ("_data%d_", parent_block_id);
                  _tmp139_ = _tmp138_;
                  _tmp140_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp139_);
                  _tmp141_ = _tmp140_;
                  vala_ccode_function_call_add_argument (ref_call, _tmp141_);
                  _vala_ccode_node_unref0 (_tmp141_);
                  _g_free0 (_tmp139_);
                  _tmp142_ = vala_ccode_base_module_get_ccode (self);
                  _tmp143_ = g_strdup_printf ("_data%d_", block_id);
                  _tmp144_ = _tmp143_;
                  _tmp145_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp144_);
                  _tmp146_ = _tmp145_;
                  _tmp147_ = g_strdup_printf ("_data%d_", parent_block_id);
                  _tmp148_ = _tmp147_;
                  _tmp149_ = vala_ccode_member_access_new_pointer (_tmp146_, _tmp148_);
                  _tmp150_ = _tmp149_;
                  vala_ccode_function_add_assignment (_tmp142_, (ValaCCodeExpression*) _tmp150_, (ValaCCodeExpression*) ref_call);
                  _vala_ccode_node_unref0 (_tmp150_);
                  _g_free0 (_tmp148_);
                  _vala_ccode_node_unref0 (_tmp146_);
                  _g_free0 (_tmp144_);
                  _vala_ccode_node_unref0 (ref_call);
            } else {
                  gboolean _tmp151_ = FALSE;
                  ValaMethod* _tmp152_ = NULL;
                  gboolean in_instance_method;
                  gboolean _tmp155_ = FALSE;
                  ValaPropertyAccessor* _tmp156_ = NULL;
                  gboolean in_instance_property;
                  gboolean _tmp160_ = FALSE;
                  gboolean _tmp161_ = FALSE;
                  ValaMethod* _tmp162_ = NULL;
                  gboolean in_creation_method_with_chainup;
                  gboolean _tmp166_ = FALSE;
                  gboolean _tmp167_ = FALSE;
                  ValaMethod* _tmp189_ = NULL;
                  _tmp152_ = vala_ccode_base_module_get_current_method (self);
                  if (_tmp152_ != NULL) {
                        ValaMethod* _tmp153_ = NULL;
                        ValaMemberBinding _tmp154_;
                        _tmp153_ = vala_ccode_base_module_get_current_method (self);
                        _tmp154_ = vala_method_get_binding (_tmp153_);
                        _tmp151_ = _tmp154_ == VALA_MEMBER_BINDING_INSTANCE;
                  } else {
                        _tmp151_ = FALSE;
                  }
                  in_instance_method = _tmp151_;
                  _tmp156_ = vala_ccode_base_module_get_current_property_accessor (self);
                  if (_tmp156_ != NULL) {
                        ValaPropertyAccessor* _tmp157_ = NULL;
                        ValaProperty* _tmp158_ = NULL;
                        ValaMemberBinding _tmp159_;
                        _tmp157_ = vala_ccode_base_module_get_current_property_accessor (self);
                        _tmp158_ = vala_property_accessor_get_prop (_tmp157_);
                        _tmp159_ = vala_property_get_binding (_tmp158_);
                        _tmp155_ = _tmp159_ == VALA_MEMBER_BINDING_INSTANCE;
                  } else {
                        _tmp155_ = FALSE;
                  }
                  in_instance_property = _tmp155_;
                  _tmp162_ = vala_ccode_base_module_get_current_method (self);
                  if (VALA_IS_CREATION_METHOD (_tmp162_)) {
                        ValaClass* _tmp163_ = NULL;
                        _tmp163_ = vala_ccode_base_module_get_current_class (self);
                        _tmp161_ = _tmp163_ != NULL;
                  } else {
                        _tmp161_ = FALSE;
                  }
                  if (_tmp161_) {
                        ValaClass* _tmp164_ = NULL;
                        ValaClass* _tmp165_ = NULL;
                        _tmp164_ = vala_ccode_base_module_get_current_class (self);
                        _tmp165_ = vala_class_get_base_class (_tmp164_);
                        _tmp160_ = _tmp165_ != NULL;
                  } else {
                        _tmp160_ = FALSE;
                  }
                  in_creation_method_with_chainup = _tmp160_;
                  if (self->in_constructor) {
                        _tmp167_ = TRUE;
                  } else {
                        gboolean _tmp168_ = FALSE;
                        if (in_instance_method) {
                              gboolean _tmp169_ = FALSE;
                              if (!in_creation_method_with_chainup) {
                                    _tmp169_ = TRUE;
                              } else {
                                    ValaMethod* _tmp170_ = NULL;
                                    ValaBlock* _tmp171_ = NULL;
                                    _tmp170_ = vala_ccode_base_module_get_current_method (self);
                                    _tmp171_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp170_);
                                    _tmp169_ = _tmp171_ != b;
                              }
                              _tmp168_ = _tmp169_;
                        } else {
                              _tmp168_ = FALSE;
                        }
                        _tmp167_ = _tmp168_;
                  }
                  if (_tmp167_) {
                        _tmp166_ = TRUE;
                  } else {
                        _tmp166_ = in_instance_property;
                  }
                  if (_tmp166_) {
                        ValaTypeSymbol* _tmp172_ = NULL;
                        ValaDataType* _tmp173_ = NULL;
                        ValaDataType* _tmp174_;
                        ValaSourceReference* _tmp175_ = NULL;
                        ValaCCodeExpression* _tmp176_ = NULL;
                        ValaCCodeExpression* _tmp177_;
                        ValaCCodeFunctionCall* _tmp178_ = NULL;
                        ValaCCodeFunctionCall* _tmp179_;
                        ValaCCodeFunctionCall* ref_call;
                        ValaCCodeExpression* _tmp180_ = NULL;
                        ValaCCodeExpression* _tmp181_;
                        ValaCCodeFunction* _tmp182_ = NULL;
                        gchar* _tmp183_ = NULL;
                        gchar* _tmp184_;
                        ValaCCodeExpression* _tmp185_ = NULL;
                        ValaCCodeExpression* _tmp186_;
                        ValaCCodeMemberAccess* _tmp187_ = NULL;
                        ValaCCodeMemberAccess* _tmp188_;
                        _tmp172_ = vala_ccode_base_module_get_current_type_symbol (self);
                        _tmp173_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp172_);
                        _tmp174_ = _tmp173_;
                        _tmp175_ = vala_code_node_get_source_reference ((ValaCodeNode*) b);
                        _tmp176_ = vala_ccode_base_module_get_dup_func_expression (self, _tmp174_, _tmp175_, FALSE);
                        _tmp177_ = _tmp176_;
                        _tmp178_ = vala_ccode_function_call_new (_tmp177_);
                        _tmp179_ = _tmp178_;
                        _vala_ccode_node_unref0 (_tmp177_);
                        _vala_code_node_unref0 (_tmp174_);
                        ref_call = _tmp179_;
                        _tmp180_ = vala_ccode_base_module_get_result_cexpression (self, "self");
                        _tmp181_ = _tmp180_;
                        vala_ccode_function_call_add_argument (ref_call, _tmp181_);
                        _vala_ccode_node_unref0 (_tmp181_);
                        _tmp182_ = vala_ccode_base_module_get_ccode (self);
                        _tmp183_ = g_strdup_printf ("_data%d_", block_id);
                        _tmp184_ = _tmp183_;
                        _tmp185_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp184_);
                        _tmp186_ = _tmp185_;
                        _tmp187_ = vala_ccode_member_access_new_pointer (_tmp186_, "self");
                        _tmp188_ = _tmp187_;
                        vala_ccode_function_add_assignment (_tmp182_, (ValaCCodeExpression*) _tmp188_, (ValaCCodeExpression*) ref_call);
                        _vala_ccode_node_unref0 (_tmp188_);
                        _vala_ccode_node_unref0 (_tmp186_);
                        _g_free0 (_tmp184_);
                        _vala_ccode_node_unref0 (ref_call);
                  }
                  _tmp189_ = vala_ccode_base_module_get_current_method (self);
                  if (_tmp189_ != NULL) {
                        {
                              ValaMethod* _tmp190_ = NULL;
                              ValaList* _tmp191_ = NULL;
                              ValaList* _type_param_list;
                              gint _tmp192_;
                              gint _type_param_size;
                              gint _type_param_index;
                              _tmp190_ = vala_ccode_base_module_get_current_method (self);
                              _tmp191_ = vala_method_get_type_parameters (_tmp190_);
                              _type_param_list = _tmp191_;
                              _tmp192_ = vala_collection_get_size ((ValaCollection*) _type_param_list);
                              _type_param_size = _tmp192_;
                              _type_param_index = -1;
                              while (TRUE) {
                                    gpointer _tmp193_ = NULL;
                                    ValaTypeParameter* type_param;
                                    gchar* func_name = NULL;
                                    const gchar* _tmp194_ = NULL;
                                    gchar* _tmp195_ = NULL;
                                    gchar* _tmp196_;
                                    gchar* _tmp197_ = NULL;
                                    ValaCCodeFunction* _tmp198_ = NULL;
                                    gchar* _tmp199_ = NULL;
                                    gchar* _tmp200_;
                                    ValaCCodeExpression* _tmp201_ = NULL;
                                    ValaCCodeExpression* _tmp202_;
                                    ValaCCodeMemberAccess* _tmp203_ = NULL;
                                    ValaCCodeMemberAccess* _tmp204_;
                                    ValaCCodeIdentifier* _tmp205_ = NULL;
                                    ValaCCodeIdentifier* _tmp206_;
                                    const gchar* _tmp207_ = NULL;
                                    gchar* _tmp208_ = NULL;
                                    gchar* _tmp209_;
                                    gchar* _tmp210_ = NULL;
                                    ValaCCodeFunction* _tmp211_ = NULL;
                                    gchar* _tmp212_ = NULL;
                                    gchar* _tmp213_;
                                    ValaCCodeExpression* _tmp214_ = NULL;
                                    ValaCCodeExpression* _tmp215_;
                                    ValaCCodeMemberAccess* _tmp216_ = NULL;
                                    ValaCCodeMemberAccess* _tmp217_;
                                    ValaCCodeIdentifier* _tmp218_ = NULL;
                                    ValaCCodeIdentifier* _tmp219_;
                                    const gchar* _tmp220_ = NULL;
                                    gchar* _tmp221_ = NULL;
                                    gchar* _tmp222_;
                                    gchar* _tmp223_ = NULL;
                                    ValaCCodeFunction* _tmp224_ = NULL;
                                    gchar* _tmp225_ = NULL;
                                    gchar* _tmp226_;
                                    ValaCCodeExpression* _tmp227_ = NULL;
                                    ValaCCodeExpression* _tmp228_;
                                    ValaCCodeMemberAccess* _tmp229_ = NULL;
                                    ValaCCodeMemberAccess* _tmp230_;
                                    ValaCCodeIdentifier* _tmp231_ = NULL;
                                    ValaCCodeIdentifier* _tmp232_;
                                    _type_param_index = _type_param_index + 1;
                                    if (!(_type_param_index < _type_param_size)) {
                                          break;
                                    }
                                    _tmp193_ = vala_list_get (_type_param_list, _type_param_index);
                                    type_param = (ValaTypeParameter*) _tmp193_;
                                    _tmp194_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                    _tmp195_ = g_utf8_strdown (_tmp194_, (gssize) (-1));
                                    _tmp196_ = _tmp195_;
                                    _tmp197_ = g_strdup_printf ("%s_type", _tmp196_);
                                    _g_free0 (func_name);
                                    func_name = _tmp197_;
                                    _g_free0 (_tmp196_);
                                    _tmp198_ = vala_ccode_base_module_get_ccode (self);
                                    _tmp199_ = g_strdup_printf ("_data%d_", block_id);
                                    _tmp200_ = _tmp199_;
                                    _tmp201_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp200_);
                                    _tmp202_ = _tmp201_;
                                    _tmp203_ = vala_ccode_member_access_new_pointer (_tmp202_, func_name);
                                    _tmp204_ = _tmp203_;
                                    _tmp205_ = vala_ccode_identifier_new (func_name);
                                    _tmp206_ = _tmp205_;
                                    vala_ccode_function_add_assignment (_tmp198_, (ValaCCodeExpression*) _tmp204_, (ValaCCodeExpression*) _tmp206_);
                                    _vala_ccode_node_unref0 (_tmp206_);
                                    _vala_ccode_node_unref0 (_tmp204_);
                                    _vala_ccode_node_unref0 (_tmp202_);
                                    _g_free0 (_tmp200_);
                                    _tmp207_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                    _tmp208_ = g_utf8_strdown (_tmp207_, (gssize) (-1));
                                    _tmp209_ = _tmp208_;
                                    _tmp210_ = g_strdup_printf ("%s_dup_func", _tmp209_);
                                    _g_free0 (func_name);
                                    func_name = _tmp210_;
                                    _g_free0 (_tmp209_);
                                    _tmp211_ = vala_ccode_base_module_get_ccode (self);
                                    _tmp212_ = g_strdup_printf ("_data%d_", block_id);
                                    _tmp213_ = _tmp212_;
                                    _tmp214_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp213_);
                                    _tmp215_ = _tmp214_;
                                    _tmp216_ = vala_ccode_member_access_new_pointer (_tmp215_, func_name);
                                    _tmp217_ = _tmp216_;
                                    _tmp218_ = vala_ccode_identifier_new (func_name);
                                    _tmp219_ = _tmp218_;
                                    vala_ccode_function_add_assignment (_tmp211_, (ValaCCodeExpression*) _tmp217_, (ValaCCodeExpression*) _tmp219_);
                                    _vala_ccode_node_unref0 (_tmp219_);
                                    _vala_ccode_node_unref0 (_tmp217_);
                                    _vala_ccode_node_unref0 (_tmp215_);
                                    _g_free0 (_tmp213_);
                                    _tmp220_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                    _tmp221_ = g_utf8_strdown (_tmp220_, (gssize) (-1));
                                    _tmp222_ = _tmp221_;
                                    _tmp223_ = g_strdup_printf ("%s_destroy_func", _tmp222_);
                                    _g_free0 (func_name);
                                    func_name = _tmp223_;
                                    _g_free0 (_tmp222_);
                                    _tmp224_ = vala_ccode_base_module_get_ccode (self);
                                    _tmp225_ = g_strdup_printf ("_data%d_", block_id);
                                    _tmp226_ = _tmp225_;
                                    _tmp227_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp226_);
                                    _tmp228_ = _tmp227_;
                                    _tmp229_ = vala_ccode_member_access_new_pointer (_tmp228_, func_name);
                                    _tmp230_ = _tmp229_;
                                    _tmp231_ = vala_ccode_identifier_new (func_name);
                                    _tmp232_ = _tmp231_;
                                    vala_ccode_function_add_assignment (_tmp224_, (ValaCCodeExpression*) _tmp230_, (ValaCCodeExpression*) _tmp232_);
                                    _vala_ccode_node_unref0 (_tmp232_);
                                    _vala_ccode_node_unref0 (_tmp230_);
                                    _vala_ccode_node_unref0 (_tmp228_);
                                    _g_free0 (_tmp226_);
                                    _g_free0 (func_name);
                                    _vala_code_node_unref0 (type_param);
                              }
                              _vala_iterable_unref0 (_type_param_list);
                        }
                  }
            }
            _tmp233_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
            if (VALA_IS_METHOD (_tmp233_)) {
                  ValaSymbol* _tmp234_ = NULL;
                  ValaMethod* _tmp235_;
                  ValaMethod* m;
                  gboolean _tmp240_;
                  _tmp234_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
                  _tmp235_ = _vala_code_node_ref0 (VALA_METHOD (_tmp234_));
                  m = _tmp235_;
                  {
                        ValaList* _tmp236_ = NULL;
                        ValaList* _param_list;
                        gint _tmp237_;
                        gint _param_size;
                        gint _param_index;
                        _tmp236_ = vala_method_get_parameters (m);
                        _param_list = _tmp236_;
                        _tmp237_ = vala_collection_get_size ((ValaCollection*) _param_list);
                        _param_size = _tmp237_;
                        _param_index = -1;
                        while (TRUE) {
                              gpointer _tmp238_ = NULL;
                              ValaParameter* param;
                              gboolean _tmp239_;
                              _param_index = _param_index + 1;
                              if (!(_param_index < _param_size)) {
                                    break;
                              }
                              _tmp238_ = vala_list_get (_param_list, _param_index);
                              param = (ValaParameter*) _tmp238_;
                              _tmp239_ = vala_parameter_get_captured (param);
                              if (_tmp239_) {
                                    vala_ccode_base_module_capture_parameter (self, param, data, block_id);
                              }
                              _vala_code_node_unref0 (param);
                        }
                        _vala_iterable_unref0 (_param_list);
                  }
                  _tmp240_ = vala_method_get_coroutine (m);
                  if (_tmp240_) {
                        ValaCCodeFunction* _tmp241_ = NULL;
                        gchar* _tmp242_ = NULL;
                        gchar* _tmp243_;
                        ValaCCodeExpression* _tmp244_ = NULL;
                        ValaCCodeExpression* _tmp245_;
                        ValaCCodeMemberAccess* _tmp246_ = NULL;
                        ValaCCodeMemberAccess* _tmp247_;
                        ValaCCodeIdentifier* _tmp248_ = NULL;
                        ValaCCodeIdentifier* _tmp249_;
                        vala_ccode_struct_add_field (data, "gpointer", "_async_data_", NULL);
                        _tmp241_ = vala_ccode_base_module_get_ccode (self);
                        _tmp242_ = g_strdup_printf ("_data%d_", block_id);
                        _tmp243_ = _tmp242_;
                        _tmp244_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp243_);
                        _tmp245_ = _tmp244_;
                        _tmp246_ = vala_ccode_member_access_new_pointer (_tmp245_, "_async_data_");
                        _tmp247_ = _tmp246_;
                        _tmp248_ = vala_ccode_identifier_new ("_data_");
                        _tmp249_ = _tmp248_;
                        vala_ccode_function_add_assignment (_tmp241_, (ValaCCodeExpression*) _tmp247_, (ValaCCodeExpression*) _tmp249_);
                        _vala_ccode_node_unref0 (_tmp249_);
                        _vala_ccode_node_unref0 (_tmp247_);
                        _vala_ccode_node_unref0 (_tmp245_);
                        _g_free0 (_tmp243_);
                  }
                  _vala_code_node_unref0 (m);
            } else {
                  ValaSymbol* _tmp250_ = NULL;
                  _tmp250_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
                  if (VALA_IS_PROPERTY_ACCESSOR (_tmp250_)) {
                        ValaSymbol* _tmp251_ = NULL;
                        ValaPropertyAccessor* _tmp252_;
                        ValaPropertyAccessor* acc;
                        gboolean _tmp253_ = FALSE;
                        gboolean _tmp254_;
                        _tmp251_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
                        _tmp252_ = _vala_code_node_ref0 (VALA_PROPERTY_ACCESSOR (_tmp251_));
                        acc = _tmp252_;
                        _tmp254_ = vala_property_accessor_get_readable (acc);
                        if (!_tmp254_) {
                              ValaParameter* _tmp255_ = NULL;
                              gboolean _tmp256_;
                              _tmp255_ = vala_property_accessor_get_value_parameter (acc);
                              _tmp256_ = vala_parameter_get_captured (_tmp255_);
                              _tmp253_ = _tmp256_;
                        } else {
                              _tmp253_ = FALSE;
                        }
                        if (_tmp253_) {
                              ValaParameter* _tmp257_ = NULL;
                              _tmp257_ = vala_property_accessor_get_value_parameter (acc);
                              vala_ccode_base_module_capture_parameter (self, _tmp257_, data, block_id);
                        }
                        _vala_code_node_unref0 (acc);
                  }
            }
            _tmp258_ = g_strconcat ("struct _", struct_name, NULL);
            _tmp259_ = _tmp258_;
            _tmp260_ = vala_ccode_variable_declarator_new (struct_name, NULL, NULL);
            _tmp261_ = _tmp260_;
            _tmp262_ = vala_ccode_type_definition_new (_tmp259_, (ValaCCodeDeclarator*) _tmp261_);
            _tmp263_ = _tmp262_;
            _vala_ccode_node_unref0 (_tmp261_);
            _g_free0 (_tmp259_);
            _typedef_ = _tmp263_;
            vala_ccode_file_add_type_declaration (self->cfile, (ValaCCodeNode*) _typedef_);
            vala_ccode_file_add_type_definition (self->cfile, (ValaCCodeNode*) data);
            _tmp264_ = g_strdup_printf ("block%d_data_ref", block_id);
            _tmp265_ = _tmp264_;
            _tmp266_ = g_strconcat (struct_name, "*", NULL);
            _tmp267_ = _tmp266_;
            _tmp268_ = vala_ccode_function_new (_tmp265_, _tmp267_);
            _tmp269_ = _tmp268_;
            _g_free0 (_tmp267_);
            _g_free0 (_tmp265_);
            ref_fun = _tmp269_;
            _tmp270_ = g_strdup_printf ("_data%d_", block_id);
            _tmp271_ = _tmp270_;
            _tmp272_ = g_strconcat (struct_name, "*", NULL);
            _tmp273_ = _tmp272_;
            _tmp274_ = vala_ccode_parameter_new (_tmp271_, _tmp273_);
            _tmp275_ = _tmp274_;
            vala_ccode_function_add_parameter (ref_fun, _tmp275_);
            _vala_ccode_node_unref0 (_tmp275_);
            _g_free0 (_tmp273_);
            _g_free0 (_tmp271_);
            vala_ccode_function_set_modifiers (ref_fun, VALA_CCODE_MODIFIERS_STATIC);
            vala_ccode_base_module_push_function (self, ref_fun);
            _tmp276_ = vala_ccode_identifier_new ("g_atomic_int_inc");
            _tmp277_ = _tmp276_;
            _tmp278_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp277_);
            _tmp279_ = _tmp278_;
            _vala_ccode_node_unref0 (_tmp277_);
            ccall = _tmp279_;
            _tmp280_ = g_strdup_printf ("_data%d_", block_id);
            _tmp281_ = _tmp280_;
            _tmp282_ = vala_ccode_identifier_new (_tmp281_);
            _tmp283_ = _tmp282_;
            _tmp284_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp283_, "_ref_count_");
            _tmp285_ = _tmp284_;
            _tmp286_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp285_);
            _tmp287_ = _tmp286_;
            vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp287_);
            _vala_ccode_node_unref0 (_tmp287_);
            _vala_ccode_node_unref0 (_tmp285_);
            _vala_ccode_node_unref0 (_tmp283_);
            _g_free0 (_tmp281_);
            _tmp288_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_expression (_tmp288_, (ValaCCodeExpression*) ccall);
            _tmp289_ = vala_ccode_base_module_get_ccode (self);
            _tmp290_ = g_strdup_printf ("_data%d_", block_id);
            _tmp291_ = _tmp290_;
            _tmp292_ = vala_ccode_identifier_new (_tmp291_);
            _tmp293_ = _tmp292_;
            vala_ccode_function_add_return (_tmp289_, (ValaCCodeExpression*) _tmp293_);
            _vala_ccode_node_unref0 (_tmp293_);
            _g_free0 (_tmp291_);
            vala_ccode_base_module_pop_function (self);
            vala_ccode_file_add_function_declaration (self->cfile, ref_fun);
            vala_ccode_file_add_function (self->cfile, ref_fun);
            _tmp294_ = g_strdup_printf ("block%d_data_unref", block_id);
            _tmp295_ = _tmp294_;
            _tmp296_ = vala_ccode_function_new (_tmp295_, "void");
            _tmp297_ = _tmp296_;
            _g_free0 (_tmp295_);
            unref_fun = _tmp297_;
            _tmp298_ = g_strdup_printf ("_data%d_", block_id);
            _tmp299_ = _tmp298_;
            _tmp300_ = g_strconcat (struct_name, "*", NULL);
            _tmp301_ = _tmp300_;
            _tmp302_ = vala_ccode_parameter_new (_tmp299_, _tmp301_);
            _tmp303_ = _tmp302_;
            vala_ccode_function_add_parameter (unref_fun, _tmp303_);
            _vala_ccode_node_unref0 (_tmp303_);
            _g_free0 (_tmp301_);
            _g_free0 (_tmp299_);
            vala_ccode_function_set_modifiers (unref_fun, VALA_CCODE_MODIFIERS_STATIC);
            vala_ccode_base_module_push_function (self, unref_fun);
            _tmp304_ = vala_ccode_identifier_new ("g_atomic_int_dec_and_test");
            _tmp305_ = _tmp304_;
            _tmp306_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp305_);
            _vala_ccode_node_unref0 (ccall);
            ccall = _tmp306_;
            _vala_ccode_node_unref0 (_tmp305_);
            _tmp307_ = g_strdup_printf ("_data%d_", block_id);
            _tmp308_ = _tmp307_;
            _tmp309_ = vala_ccode_identifier_new (_tmp308_);
            _tmp310_ = _tmp309_;
            _tmp311_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp310_, "_ref_count_");
            _tmp312_ = _tmp311_;
            _tmp313_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp312_);
            _tmp314_ = _tmp313_;
            vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp314_);
            _vala_ccode_node_unref0 (_tmp314_);
            _vala_ccode_node_unref0 (_tmp312_);
            _vala_ccode_node_unref0 (_tmp310_);
            _g_free0 (_tmp308_);
            _tmp315_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_open_if (_tmp315_, (ValaCCodeExpression*) ccall);
            if (parent_block != NULL) {
                  gint _tmp316_;
                  gint parent_block_id;
                  gchar* _tmp317_ = NULL;
                  gchar* _tmp318_;
                  ValaCCodeIdentifier* _tmp319_ = NULL;
                  ValaCCodeIdentifier* _tmp320_;
                  ValaCCodeFunctionCall* _tmp321_ = NULL;
                  ValaCCodeFunctionCall* _tmp322_;
                  ValaCCodeFunctionCall* unref_call;
                  gchar* _tmp323_ = NULL;
                  gchar* _tmp324_;
                  ValaCCodeIdentifier* _tmp325_ = NULL;
                  ValaCCodeIdentifier* _tmp326_;
                  gchar* _tmp327_ = NULL;
                  gchar* _tmp328_;
                  ValaCCodeMemberAccess* _tmp329_ = NULL;
                  ValaCCodeMemberAccess* _tmp330_;
                  ValaCCodeFunction* _tmp331_ = NULL;
                  ValaCCodeFunction* _tmp332_ = NULL;
                  gchar* _tmp333_ = NULL;
                  gchar* _tmp334_;
                  ValaCCodeIdentifier* _tmp335_ = NULL;
                  ValaCCodeIdentifier* _tmp336_;
                  gchar* _tmp337_ = NULL;
                  gchar* _tmp338_;
                  ValaCCodeMemberAccess* _tmp339_ = NULL;
                  ValaCCodeMemberAccess* _tmp340_;
                  ValaCCodeConstant* _tmp341_ = NULL;
                  ValaCCodeConstant* _tmp342_;
                  _tmp316_ = vala_ccode_base_module_get_block_id (self, parent_block);
                  parent_block_id = _tmp316_;
                  _tmp317_ = g_strdup_printf ("block%d_data_unref", parent_block_id);
                  _tmp318_ = _tmp317_;
                  _tmp319_ = vala_ccode_identifier_new (_tmp318_);
                  _tmp320_ = _tmp319_;
                  _tmp321_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp320_);
                  _tmp322_ = _tmp321_;
                  _vala_ccode_node_unref0 (_tmp320_);
                  _g_free0 (_tmp318_);
                  unref_call = _tmp322_;
                  _tmp323_ = g_strdup_printf ("_data%d_", block_id);
                  _tmp324_ = _tmp323_;
                  _tmp325_ = vala_ccode_identifier_new (_tmp324_);
                  _tmp326_ = _tmp325_;
                  _tmp327_ = g_strdup_printf ("_data%d_", parent_block_id);
                  _tmp328_ = _tmp327_;
                  _tmp329_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp326_, _tmp328_);
                  _tmp330_ = _tmp329_;
                  vala_ccode_function_call_add_argument (unref_call, (ValaCCodeExpression*) _tmp330_);
                  _vala_ccode_node_unref0 (_tmp330_);
                  _g_free0 (_tmp328_);
                  _vala_ccode_node_unref0 (_tmp326_);
                  _g_free0 (_tmp324_);
                  _tmp331_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_expression (_tmp331_, (ValaCCodeExpression*) unref_call);
                  _tmp332_ = vala_ccode_base_module_get_ccode (self);
                  _tmp333_ = g_strdup_printf ("_data%d_", block_id);
                  _tmp334_ = _tmp333_;
                  _tmp335_ = vala_ccode_identifier_new (_tmp334_);
                  _tmp336_ = _tmp335_;
                  _tmp337_ = g_strdup_printf ("_data%d_", parent_block_id);
                  _tmp338_ = _tmp337_;
                  _tmp339_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp336_, _tmp338_);
                  _tmp340_ = _tmp339_;
                  _tmp341_ = vala_ccode_constant_new ("NULL");
                  _tmp342_ = _tmp341_;
                  vala_ccode_function_add_assignment (_tmp332_, (ValaCCodeExpression*) _tmp340_, (ValaCCodeExpression*) _tmp342_);
                  _vala_ccode_node_unref0 (_tmp342_);
                  _vala_ccode_node_unref0 (_tmp340_);
                  _g_free0 (_tmp338_);
                  _vala_ccode_node_unref0 (_tmp336_);
                  _g_free0 (_tmp334_);
                  _vala_ccode_node_unref0 (unref_call);
            } else {
                  gboolean _tmp343_ = FALSE;
                  gboolean _tmp344_ = FALSE;
                  if (self->in_constructor) {
                        _tmp344_ = TRUE;
                  } else {
                        gboolean _tmp345_ = FALSE;
                        ValaMethod* _tmp346_ = NULL;
                        _tmp346_ = vala_ccode_base_module_get_current_method (self);
                        if (_tmp346_ != NULL) {
                              ValaMethod* _tmp347_ = NULL;
                              ValaMemberBinding _tmp348_;
                              _tmp347_ = vala_ccode_base_module_get_current_method (self);
                              _tmp348_ = vala_method_get_binding (_tmp347_);
                              _tmp345_ = _tmp348_ == VALA_MEMBER_BINDING_INSTANCE;
                        } else {
                              _tmp345_ = FALSE;
                        }
                        _tmp344_ = _tmp345_;
                  }
                  if (_tmp344_) {
                        _tmp343_ = TRUE;
                  } else {
                        gboolean _tmp349_ = FALSE;
                        ValaPropertyAccessor* _tmp350_ = NULL;
                        _tmp350_ = vala_ccode_base_module_get_current_property_accessor (self);
                        if (_tmp350_ != NULL) {
                              ValaPropertyAccessor* _tmp351_ = NULL;
                              ValaProperty* _tmp352_ = NULL;
                              ValaMemberBinding _tmp353_;
                              _tmp351_ = vala_ccode_base_module_get_current_property_accessor (self);
                              _tmp352_ = vala_property_accessor_get_prop (_tmp351_);
                              _tmp353_ = vala_property_get_binding (_tmp352_);
                              _tmp349_ = _tmp353_ == VALA_MEMBER_BINDING_INSTANCE;
                        } else {
                              _tmp349_ = FALSE;
                        }
                        _tmp343_ = _tmp349_;
                  }
                  if (_tmp343_) {
                        ValaTypeSymbol* _tmp354_ = NULL;
                        ValaDataType* _tmp355_ = NULL;
                        ValaDataType* _tmp356_;
                        gchar* _tmp357_ = NULL;
                        gchar* _tmp358_;
                        ValaCCodeIdentifier* _tmp359_ = NULL;
                        ValaCCodeIdentifier* _tmp360_;
                        ValaCCodeMemberAccess* _tmp361_ = NULL;
                        ValaCCodeMemberAccess* _tmp362_;
                        ValaGLibValue* _tmp363_ = NULL;
                        ValaGLibValue* _tmp364_;
                        ValaGLibValue* this_value;
                        ValaCCodeFunction* _tmp365_ = NULL;
                        ValaCCodeExpression* _tmp366_ = NULL;
                        ValaCCodeExpression* _tmp367_;
                        _tmp354_ = vala_ccode_base_module_get_current_type_symbol (self);
                        _tmp355_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp354_);
                        _tmp356_ = _tmp355_;
                        _tmp357_ = g_strdup_printf ("_data%d_", block_id);
                        _tmp358_ = _tmp357_;
                        _tmp359_ = vala_ccode_identifier_new (_tmp358_);
                        _tmp360_ = _tmp359_;
                        _tmp361_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp360_, "self");
                        _tmp362_ = _tmp361_;
                        _tmp363_ = vala_glib_value_new (_tmp356_, (ValaCCodeExpression*) _tmp362_);
                        _tmp364_ = _tmp363_;
                        _vala_ccode_node_unref0 (_tmp362_);
                        _vala_ccode_node_unref0 (_tmp360_);
                        _g_free0 (_tmp358_);
                        _vala_code_node_unref0 (_tmp356_);
                        this_value = _tmp364_;
                        _tmp365_ = vala_ccode_base_module_get_ccode (self);
                        _tmp366_ = vala_ccode_base_module_destroy_value (self, (ValaTargetValue*) this_value, FALSE);
                        _tmp367_ = _tmp366_;
                        vala_ccode_function_add_expression (_tmp365_, _tmp367_);
                        _vala_ccode_node_unref0 (_tmp367_);
                        _vala_target_value_unref0 (this_value);
                  }
            }
            {
                  gint _tmp368_;
                  gint i;
                  _tmp368_ = vala_collection_get_size ((ValaCollection*) local_vars);
                  i = _tmp368_ - 1;
                  {
                        gboolean _tmp369_;
                        _tmp369_ = TRUE;
                        while (TRUE) {
                              gpointer _tmp370_ = NULL;
                              ValaLocalVariable* local;
                              gboolean _tmp371_;
                              if (!_tmp369_) {
                                    i--;
                              }
                              _tmp369_ = FALSE;
                              if (!(i >= 0)) {
                                    break;
                              }
                              _tmp370_ = vala_list_get (local_vars, i);
                              local = (ValaLocalVariable*) _tmp370_;
                              _tmp371_ = vala_local_variable_get_captured (local);
                              if (_tmp371_) {
                                    ValaDataType* _tmp372_ = NULL;
                                    gboolean _tmp373_;
                                    _tmp372_ = vala_variable_get_variable_type ((ValaVariable*) local);
                                    _tmp373_ = vala_ccode_base_module_requires_destroy (self, _tmp372_);
                                    if (_tmp373_) {
                                          gboolean old_coroutine;
                                          ValaMethod* _tmp374_ = NULL;
                                          ValaCCodeFunction* _tmp378_ = NULL;
                                          ValaCCodeExpression* _tmp379_ = NULL;
                                          ValaCCodeExpression* _tmp380_;
                                          old_coroutine = FALSE;
                                          _tmp374_ = vala_ccode_base_module_get_current_method (self);
                                          if (_tmp374_ != NULL) {
                                                ValaMethod* _tmp375_ = NULL;
                                                gboolean _tmp376_;
                                                ValaMethod* _tmp377_ = NULL;
                                                _tmp375_ = vala_ccode_base_module_get_current_method (self);
                                                _tmp376_ = vala_method_get_coroutine (_tmp375_);
                                                old_coroutine = _tmp376_;
                                                _tmp377_ = vala_ccode_base_module_get_current_method (self);
                                                vala_method_set_coroutine (_tmp377_, FALSE);
                                          }
                                          _tmp378_ = vala_ccode_base_module_get_ccode (self);
                                          _tmp379_ = vala_ccode_base_module_destroy_local (self, local);
                                          _tmp380_ = _tmp379_;
                                          vala_ccode_function_add_expression (_tmp378_, _tmp380_);
                                          _vala_ccode_node_unref0 (_tmp380_);
                                          if (old_coroutine) {
                                                ValaMethod* _tmp381_ = NULL;
                                                _tmp381_ = vala_ccode_base_module_get_current_method (self);
                                                vala_method_set_coroutine (_tmp381_, TRUE);
                                          }
                                    }
                              }
                              _vala_code_node_unref0 (local);
                        }
                  }
            }
            _tmp382_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
            if (VALA_IS_METHOD (_tmp382_)) {
                  ValaSymbol* _tmp383_ = NULL;
                  ValaMethod* _tmp384_;
                  ValaMethod* m;
                  _tmp383_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
                  _tmp384_ = _vala_code_node_ref0 (VALA_METHOD (_tmp383_));
                  m = _tmp384_;
                  {
                        ValaList* _tmp385_ = NULL;
                        ValaList* _param_list;
                        gint _tmp386_;
                        gint _param_size;
                        gint _param_index;
                        _tmp385_ = vala_method_get_parameters (m);
                        _param_list = _tmp385_;
                        _tmp386_ = vala_collection_get_size ((ValaCollection*) _param_list);
                        _param_size = _tmp386_;
                        _param_index = -1;
                        while (TRUE) {
                              gpointer _tmp387_ = NULL;
                              ValaParameter* param;
                              gboolean _tmp388_;
                              _param_index = _param_index + 1;
                              if (!(_param_index < _param_size)) {
                                    break;
                              }
                              _tmp387_ = vala_list_get (_param_list, _param_index);
                              param = (ValaParameter*) _tmp387_;
                              _tmp388_ = vala_parameter_get_captured (param);
                              if (_tmp388_) {
                                    ValaDataType* _tmp389_ = NULL;
                                    ValaDataType* _tmp390_ = NULL;
                                    ValaDataType* param_type;
                                    gboolean _tmp391_ = FALSE;
                                    ValaDataType* _tmp392_ = NULL;
                                    gboolean is_unowned_delegate;
                                    gboolean _tmp395_ = FALSE;
                                    gboolean _tmp396_;
                                    _tmp389_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                    _tmp390_ = vala_data_type_copy (_tmp389_);
                                    param_type = _tmp390_;
                                    vala_data_type_set_value_owned (param_type, TRUE);
                                    _tmp392_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                    if (VALA_IS_DELEGATE_TYPE (_tmp392_)) {
                                          ValaDataType* _tmp393_ = NULL;
                                          gboolean _tmp394_;
                                          _tmp393_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          _tmp394_ = vala_data_type_get_value_owned (_tmp393_);
                                          _tmp391_ = !_tmp394_;
                                    } else {
                                          _tmp391_ = FALSE;
                                    }
                                    is_unowned_delegate = _tmp391_;
                                    _tmp396_ = vala_ccode_base_module_requires_destroy (self, param_type);
                                    if (_tmp396_) {
                                          _tmp395_ = !is_unowned_delegate;
                                    } else {
                                          _tmp395_ = FALSE;
                                    }
                                    if (_tmp395_) {
                                          gboolean old_coroutine;
                                          ValaCCodeFunction* _tmp398_ = NULL;
                                          ValaCCodeExpression* _tmp399_ = NULL;
                                          ValaCCodeExpression* _tmp400_;
                                          old_coroutine = FALSE;
                                          if (m != NULL) {
                                                gboolean _tmp397_;
                                                _tmp397_ = vala_method_get_coroutine (m);
                                                old_coroutine = _tmp397_;
                                                vala_method_set_coroutine (m, FALSE);
                                          }
                                          _tmp398_ = vala_ccode_base_module_get_ccode (self);
                                          _tmp399_ = vala_ccode_base_module_destroy_parameter (self, param);
                                          _tmp400_ = _tmp399_;
                                          vala_ccode_function_add_expression (_tmp398_, _tmp400_);
                                          _vala_ccode_node_unref0 (_tmp400_);
                                          if (old_coroutine) {
                                                vala_method_set_coroutine (m, TRUE);
                                          }
                                    }
                                    _vala_code_node_unref0 (param_type);
                              }
                              _vala_code_node_unref0 (param);
                        }
                        _vala_iterable_unref0 (_param_list);
                  }
                  _vala_code_node_unref0 (m);
            } else {
                  ValaSymbol* _tmp401_ = NULL;
                  _tmp401_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
                  if (VALA_IS_PROPERTY_ACCESSOR (_tmp401_)) {
                        ValaSymbol* _tmp402_ = NULL;
                        ValaPropertyAccessor* _tmp403_;
                        ValaPropertyAccessor* acc;
                        gboolean _tmp404_ = FALSE;
                        gboolean _tmp405_;
                        _tmp402_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
                        _tmp403_ = _vala_code_node_ref0 (VALA_PROPERTY_ACCESSOR (_tmp402_));
                        acc = _tmp403_;
                        _tmp405_ = vala_property_accessor_get_readable (acc);
                        if (!_tmp405_) {
                              ValaParameter* _tmp406_ = NULL;
                              gboolean _tmp407_;
                              _tmp406_ = vala_property_accessor_get_value_parameter (acc);
                              _tmp407_ = vala_parameter_get_captured (_tmp406_);
                              _tmp404_ = _tmp407_;
                        } else {
                              _tmp404_ = FALSE;
                        }
                        if (_tmp404_) {
                              ValaParameter* _tmp408_ = NULL;
                              ValaDataType* _tmp409_ = NULL;
                              ValaDataType* _tmp410_ = NULL;
                              ValaDataType* param_type;
                              gboolean _tmp411_ = FALSE;
                              ValaParameter* _tmp412_ = NULL;
                              ValaDataType* _tmp413_ = NULL;
                              gboolean is_unowned_delegate;
                              gboolean _tmp417_ = FALSE;
                              gboolean _tmp418_;
                              _tmp408_ = vala_property_accessor_get_value_parameter (acc);
                              _tmp409_ = vala_variable_get_variable_type ((ValaVariable*) _tmp408_);
                              _tmp410_ = vala_data_type_copy (_tmp409_);
                              param_type = _tmp410_;
                              vala_data_type_set_value_owned (param_type, TRUE);
                              _tmp412_ = vala_property_accessor_get_value_parameter (acc);
                              _tmp413_ = vala_variable_get_variable_type ((ValaVariable*) _tmp412_);
                              if (VALA_IS_DELEGATE_TYPE (_tmp413_)) {
                                    ValaParameter* _tmp414_ = NULL;
                                    ValaDataType* _tmp415_ = NULL;
                                    gboolean _tmp416_;
                                    _tmp414_ = vala_property_accessor_get_value_parameter (acc);
                                    _tmp415_ = vala_variable_get_variable_type ((ValaVariable*) _tmp414_);
                                    _tmp416_ = vala_data_type_get_value_owned (_tmp415_);
                                    _tmp411_ = !_tmp416_;
                              } else {
                                    _tmp411_ = FALSE;
                              }
                              is_unowned_delegate = _tmp411_;
                              _tmp418_ = vala_ccode_base_module_requires_destroy (self, param_type);
                              if (_tmp418_) {
                                    _tmp417_ = !is_unowned_delegate;
                              } else {
                                    _tmp417_ = FALSE;
                              }
                              if (_tmp417_) {
                                    ValaCCodeFunction* _tmp419_ = NULL;
                                    ValaParameter* _tmp420_ = NULL;
                                    ValaCCodeExpression* _tmp421_ = NULL;
                                    ValaCCodeExpression* _tmp422_;
                                    _tmp419_ = vala_ccode_base_module_get_ccode (self);
                                    _tmp420_ = vala_property_accessor_get_value_parameter (acc);
                                    _tmp421_ = vala_ccode_base_module_destroy_parameter (self, _tmp420_);
                                    _tmp422_ = _tmp421_;
                                    vala_ccode_function_add_expression (_tmp419_, _tmp422_);
                                    _vala_ccode_node_unref0 (_tmp422_);
                              }
                              _vala_code_node_unref0 (param_type);
                        }
                        _vala_code_node_unref0 (acc);
                  }
            }
            _tmp423_ = vala_ccode_identifier_new ("g_slice_free");
            _tmp424_ = _tmp423_;
            _tmp425_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp424_);
            _tmp426_ = _tmp425_;
            _vala_ccode_node_unref0 (_tmp424_);
            data_free = _tmp426_;
            _tmp427_ = vala_ccode_identifier_new (struct_name);
            _tmp428_ = _tmp427_;
            vala_ccode_function_call_add_argument (data_free, (ValaCCodeExpression*) _tmp428_);
            _vala_ccode_node_unref0 (_tmp428_);
            _tmp429_ = g_strdup_printf ("_data%d_", block_id);
            _tmp430_ = _tmp429_;
            _tmp431_ = vala_ccode_identifier_new (_tmp430_);
            _tmp432_ = _tmp431_;
            vala_ccode_function_call_add_argument (data_free, (ValaCCodeExpression*) _tmp432_);
            _vala_ccode_node_unref0 (_tmp432_);
            _g_free0 (_tmp430_);
            _tmp433_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_expression (_tmp433_, (ValaCCodeExpression*) data_free);
            _tmp434_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_close (_tmp434_);
            vala_ccode_base_module_pop_function (self);
            vala_ccode_file_add_function_declaration (self->cfile, unref_fun);
            vala_ccode_file_add_function (self->cfile, unref_fun);
            _vala_ccode_node_unref0 (data_free);
            _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* _tmp435_ = NULL;
            ValaList* _stmt_list;
            gint _tmp436_;
            gint _stmt_size;
            gint _stmt_index;
            _tmp435_ = vala_block_get_statements (b);
            _stmt_list = _tmp435_;
            _tmp436_ = vala_collection_get_size ((ValaCollection*) _stmt_list);
            _stmt_size = _tmp436_;
            _stmt_index = -1;
            while (TRUE) {
                  gpointer _tmp437_ = NULL;
                  ValaStatement* stmt;
                  _stmt_index = _stmt_index + 1;
                  if (!(_stmt_index < _stmt_size)) {
                        break;
                  }
                  _tmp437_ = vala_list_get (_stmt_list, _stmt_index);
                  stmt = (ValaStatement*) _tmp437_;
                  vala_code_node_emit ((ValaCodeNode*) stmt, (ValaCodeGenerator*) self);
                  _vala_code_node_unref0 (stmt);
            }
            _vala_iterable_unref0 (_stmt_list);
      }
      {
            gint _tmp438_;
            gint i;
            _tmp438_ = vala_collection_get_size ((ValaCollection*) local_vars);
            i = _tmp438_ - 1;
            {
                  gboolean _tmp439_;
                  _tmp439_ = TRUE;
                  while (TRUE) {
                        gpointer _tmp440_ = NULL;
                        ValaLocalVariable* local;
                        gboolean _tmp441_ = FALSE;
                        gboolean _tmp442_ = FALSE;
                        gboolean _tmp443_ = FALSE;
                        gboolean _tmp444_;
                        if (!_tmp439_) {
                              i--;
                        }
                        _tmp439_ = FALSE;
                        if (!(i >= 0)) {
                              break;
                        }
                        _tmp440_ = vala_list_get (local_vars, i);
                        local = (ValaLocalVariable*) _tmp440_;
                        vala_symbol_set_active ((ValaSymbol*) local, FALSE);
                        _tmp444_ = vala_code_node_get_unreachable ((ValaCodeNode*) local);
                        if (!_tmp444_) {
                              gboolean _tmp445_;
                              _tmp445_ = vala_local_variable_get_floating (local);
                              _tmp443_ = !_tmp445_;
                        } else {
                              _tmp443_ = FALSE;
                        }
                        if (_tmp443_) {
                              gboolean _tmp446_;
                              _tmp446_ = vala_local_variable_get_captured (local);
                              _tmp442_ = !_tmp446_;
                        } else {
                              _tmp442_ = FALSE;
                        }
                        if (_tmp442_) {
                              ValaDataType* _tmp447_ = NULL;
                              gboolean _tmp448_;
                              _tmp447_ = vala_variable_get_variable_type ((ValaVariable*) local);
                              _tmp448_ = vala_ccode_base_module_requires_destroy (self, _tmp447_);
                              _tmp441_ = _tmp448_;
                        } else {
                              _tmp441_ = FALSE;
                        }
                        if (_tmp441_) {
                              ValaCCodeFunction* _tmp449_ = NULL;
                              ValaCCodeExpression* _tmp450_ = NULL;
                              ValaCCodeExpression* _tmp451_;
                              _tmp449_ = vala_ccode_base_module_get_ccode (self);
                              _tmp450_ = vala_ccode_base_module_destroy_local (self, local);
                              _tmp451_ = _tmp450_;
                              vala_ccode_function_add_expression (_tmp449_, _tmp451_);
                              _vala_ccode_node_unref0 (_tmp451_);
                        }
                        _vala_code_node_unref0 (local);
                  }
            }
      }
      _tmp452_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
      if (VALA_IS_METHOD (_tmp452_)) {
            ValaSymbol* _tmp453_ = NULL;
            ValaMethod* _tmp454_;
            ValaMethod* m;
            _tmp453_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
            _tmp454_ = _vala_code_node_ref0 (VALA_METHOD (_tmp453_));
            m = _tmp454_;
            {
                  ValaList* _tmp455_ = NULL;
                  ValaList* _param_list;
                  gint _tmp456_;
                  gint _param_size;
                  gint _param_index;
                  _tmp455_ = vala_method_get_parameters (m);
                  _param_list = _tmp455_;
                  _tmp456_ = vala_collection_get_size ((ValaCollection*) _param_list);
                  _param_size = _tmp456_;
                  _param_index = -1;
                  while (TRUE) {
                        gpointer _tmp457_ = NULL;
                        ValaParameter* param;
                        gboolean _tmp458_ = FALSE;
                        gboolean _tmp459_ = FALSE;
                        gboolean _tmp460_ = FALSE;
                        gboolean _tmp461_;
                        _param_index = _param_index + 1;
                        if (!(_param_index < _param_size)) {
                              break;
                        }
                        _tmp457_ = vala_list_get (_param_list, _param_index);
                        param = (ValaParameter*) _tmp457_;
                        _tmp461_ = vala_parameter_get_captured (param);
                        if (!_tmp461_) {
                              gboolean _tmp462_;
                              _tmp462_ = vala_parameter_get_ellipsis (param);
                              _tmp460_ = !_tmp462_;
                        } else {
                              _tmp460_ = FALSE;
                        }
                        if (_tmp460_) {
                              ValaDataType* _tmp463_ = NULL;
                              gboolean _tmp464_;
                              _tmp463_ = vala_variable_get_variable_type ((ValaVariable*) param);
                              _tmp464_ = vala_ccode_base_module_requires_destroy (self, _tmp463_);
                              _tmp459_ = _tmp464_;
                        } else {
                              _tmp459_ = FALSE;
                        }
                        if (_tmp459_) {
                              ValaParameterDirection _tmp465_;
                              _tmp465_ = vala_parameter_get_direction (param);
                              _tmp458_ = _tmp465_ == VALA_PARAMETER_DIRECTION_IN;
                        } else {
                              _tmp458_ = FALSE;
                        }
                        if (_tmp458_) {
                              ValaCCodeFunction* _tmp466_ = NULL;
                              ValaCCodeExpression* _tmp467_ = NULL;
                              ValaCCodeExpression* _tmp468_;
                              _tmp466_ = vala_ccode_base_module_get_ccode (self);
                              _tmp467_ = vala_ccode_base_module_destroy_parameter (self, param);
                              _tmp468_ = _tmp467_;
                              vala_ccode_function_add_expression (_tmp466_, _tmp468_);
                              _vala_ccode_node_unref0 (_tmp468_);
                        } else {
                              gboolean _tmp469_ = FALSE;
                              ValaParameterDirection _tmp470_;
                              _tmp470_ = vala_parameter_get_direction (param);
                              if (_tmp470_ == VALA_PARAMETER_DIRECTION_OUT) {
                                    gboolean _tmp471_;
                                    _tmp471_ = vala_method_get_coroutine (m);
                                    _tmp469_ = !_tmp471_;
                              } else {
                                    _tmp469_ = FALSE;
                              }
                              if (_tmp469_) {
                                    vala_ccode_base_module_return_out_parameter (self, param);
                              }
                        }
                        _vala_code_node_unref0 (param);
                  }
                  _vala_iterable_unref0 (_param_list);
            }
            _vala_code_node_unref0 (m);
      } else {
            ValaSymbol* _tmp472_ = NULL;
            _tmp472_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
            if (VALA_IS_PROPERTY_ACCESSOR (_tmp472_)) {
                  ValaSymbol* _tmp473_ = NULL;
                  ValaPropertyAccessor* _tmp474_;
                  ValaPropertyAccessor* acc;
                  gboolean _tmp475_ = FALSE;
                  gboolean _tmp476_ = FALSE;
                  ValaParameter* _tmp477_ = NULL;
                  _tmp473_ = vala_symbol_get_parent_symbol ((ValaSymbol*) b);
                  _tmp474_ = _vala_code_node_ref0 (VALA_PROPERTY_ACCESSOR (_tmp473_));
                  acc = _tmp474_;
                  _tmp477_ = vala_property_accessor_get_value_parameter (acc);
                  if (_tmp477_ != NULL) {
                        ValaParameter* _tmp478_ = NULL;
                        gboolean _tmp479_;
                        _tmp478_ = vala_property_accessor_get_value_parameter (acc);
                        _tmp479_ = vala_parameter_get_captured (_tmp478_);
                        _tmp476_ = !_tmp479_;
                  } else {
                        _tmp476_ = FALSE;
                  }
                  if (_tmp476_) {
                        ValaParameter* _tmp480_ = NULL;
                        ValaDataType* _tmp481_ = NULL;
                        gboolean _tmp482_;
                        _tmp480_ = vala_property_accessor_get_value_parameter (acc);
                        _tmp481_ = vala_variable_get_variable_type ((ValaVariable*) _tmp480_);
                        _tmp482_ = vala_ccode_base_module_requires_destroy (self, _tmp481_);
                        _tmp475_ = _tmp482_;
                  } else {
                        _tmp475_ = FALSE;
                  }
                  if (_tmp475_) {
                        ValaCCodeFunction* _tmp483_ = NULL;
                        ValaParameter* _tmp484_ = NULL;
                        ValaCCodeExpression* _tmp485_ = NULL;
                        ValaCCodeExpression* _tmp486_;
                        _tmp483_ = vala_ccode_base_module_get_ccode (self);
                        _tmp484_ = vala_property_accessor_get_value_parameter (acc);
                        _tmp485_ = vala_ccode_base_module_destroy_parameter (self, _tmp484_);
                        _tmp486_ = _tmp485_;
                        vala_ccode_function_add_expression (_tmp483_, _tmp486_);
                        _vala_ccode_node_unref0 (_tmp486_);
                  }
                  _vala_code_node_unref0 (acc);
            }
      }
      _tmp487_ = vala_block_get_captured (b);
      if (_tmp487_) {
            gint _tmp488_;
            gint block_id;
            gchar* _tmp489_ = NULL;
            gchar* _tmp490_;
            ValaCCodeIdentifier* _tmp491_ = NULL;
            ValaCCodeIdentifier* _tmp492_;
            ValaCCodeFunctionCall* _tmp493_ = NULL;
            ValaCCodeFunctionCall* _tmp494_;
            ValaCCodeFunctionCall* data_unref;
            gchar* _tmp495_ = NULL;
            gchar* _tmp496_;
            ValaCCodeExpression* _tmp497_ = NULL;
            ValaCCodeExpression* _tmp498_;
            ValaCCodeFunction* _tmp499_ = NULL;
            ValaCCodeFunction* _tmp500_ = NULL;
            gchar* _tmp501_ = NULL;
            gchar* _tmp502_;
            ValaCCodeExpression* _tmp503_ = NULL;
            ValaCCodeExpression* _tmp504_;
            ValaCCodeConstant* _tmp505_ = NULL;
            ValaCCodeConstant* _tmp506_;
            _tmp488_ = vala_ccode_base_module_get_block_id (self, b);
            block_id = _tmp488_;
            _tmp489_ = g_strdup_printf ("block%d_data_unref", block_id);
            _tmp490_ = _tmp489_;
            _tmp491_ = vala_ccode_identifier_new (_tmp490_);
            _tmp492_ = _tmp491_;
            _tmp493_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp492_);
            _tmp494_ = _tmp493_;
            _vala_ccode_node_unref0 (_tmp492_);
            _g_free0 (_tmp490_);
            data_unref = _tmp494_;
            _tmp495_ = g_strdup_printf ("_data%d_", block_id);
            _tmp496_ = _tmp495_;
            _tmp497_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp496_);
            _tmp498_ = _tmp497_;
            vala_ccode_function_call_add_argument (data_unref, _tmp498_);
            _vala_ccode_node_unref0 (_tmp498_);
            _g_free0 (_tmp496_);
            _tmp499_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_expression (_tmp499_, (ValaCCodeExpression*) data_unref);
            _tmp500_ = vala_ccode_base_module_get_ccode (self);
            _tmp501_ = g_strdup_printf ("_data%d_", block_id);
            _tmp502_ = _tmp501_;
            _tmp503_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp502_);
            _tmp504_ = _tmp503_;
            _tmp505_ = vala_ccode_constant_new ("NULL");
            _tmp506_ = _tmp505_;
            vala_ccode_function_add_assignment (_tmp500_, _tmp504_, (ValaCCodeExpression*) _tmp506_);
            _vala_ccode_node_unref0 (_tmp506_);
            _vala_ccode_node_unref0 (_tmp504_);
            _g_free0 (_tmp502_);
            _vala_ccode_node_unref0 (data_unref);
      }
      _tmp509_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
      if (VALA_IS_BLOCK (_tmp509_)) {
            _tmp508_ = TRUE;
      } else {
            ValaCodeNode* _tmp510_ = NULL;
            _tmp510_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
            _tmp508_ = VALA_IS_SWITCH_STATEMENT (_tmp510_);
      }
      if (_tmp508_) {
            _tmp507_ = TRUE;
      } else {
            ValaCodeNode* _tmp511_ = NULL;
            _tmp511_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
            _tmp507_ = VALA_IS_TRY_STATEMENT (_tmp511_);
      }
      if (_tmp507_) {
            ValaCCodeFunction* _tmp512_ = NULL;
            _tmp512_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_close (_tmp512_);
      }
      vala_ccode_base_module_emit_context_pop_symbol (self->emit_context);
      _vala_iterable_unref0 (local_vars);
}


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


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_ = NULL;
            ValaCCodeIdentifier* _tmp2_;
            gchar* _tmp3_ = NULL;
            gchar* _tmp4_;
            ValaCCodeMemberAccess* _tmp5_ = NULL;
            ValaCCodeExpression* _tmp6_;
            _tmp1_ = vala_ccode_identifier_new ("_data_");
            _tmp2_ = _tmp1_;
            _tmp3_ = vala_ccode_base_module_get_variable_cname (self, name);
            _tmp4_ = _tmp3_;
            _tmp5_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp2_, _tmp4_);
            _tmp6_ = (ValaCCodeExpression*) _tmp5_;
            _g_free0 (_tmp4_);
            _vala_ccode_node_unref0 (_tmp2_);
            result = _tmp6_;
            return result;
      } else {
            gchar* _tmp7_ = NULL;
            gchar* _tmp8_;
            ValaCCodeIdentifier* _tmp9_ = NULL;
            ValaCCodeExpression* _tmp10_;
            _tmp7_ = vala_ccode_base_module_get_variable_cname (self, name);
            _tmp8_ = _tmp7_;
            _tmp9_ = vala_ccode_identifier_new (_tmp8_);
            _tmp10_ = (ValaCCodeExpression*) _tmp9_;
            _g_free0 (_tmp8_);
            result = _tmp10_;
            return result;
      }
}


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


gchar* vala_ccode_base_module_get_variable_cname (ValaCCodeBaseModule* self, const gchar* name) {
      gchar* result = NULL;
      gchar _tmp0_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (name != NULL, NULL);
      _tmp0_ = string_get (name, (glong) 0);
      if (_tmp0_ == '.') {
            ValaMap* _tmp2_ = NULL;
            gboolean _tmp3_;
            ValaMap* _tmp10_ = NULL;
            gpointer _tmp11_ = NULL;
            if (g_strcmp0 (name, ".result") == 0) {
                  gchar* _tmp1_;
                  _tmp1_ = g_strdup ("result");
                  result = _tmp1_;
                  return result;
            }
            _tmp2_ = vala_ccode_base_module_get_variable_name_map (self);
            _tmp3_ = vala_map_contains (_tmp2_, name);
            if (!_tmp3_) {
                  ValaMap* _tmp4_ = NULL;
                  gint _tmp5_;
                  gchar* _tmp6_ = NULL;
                  gchar* _tmp7_;
                  gint _tmp8_;
                  gint _tmp9_;
                  _tmp4_ = vala_ccode_base_module_get_variable_name_map (self);
                  _tmp5_ = vala_ccode_base_module_get_next_temp_var_id (self);
                  _tmp6_ = g_strdup_printf ("_tmp%d_", _tmp5_);
                  _tmp7_ = _tmp6_;
                  vala_map_set (_tmp4_, name, _tmp7_);
                  _g_free0 (_tmp7_);
                  _tmp8_ = vala_ccode_base_module_get_next_temp_var_id (self);
                  _tmp9_ = _tmp8_;
                  vala_ccode_base_module_set_next_temp_var_id (self, _tmp9_ + 1);
            }
            _tmp10_ = vala_ccode_base_module_get_variable_name_map (self);
            _tmp11_ = vala_map_get (_tmp10_, name);
            result = (gchar*) _tmp11_;
            return result;
      } else {
            gboolean _tmp12_;
            _tmp12_ = vala_collection_contains ((ValaCollection*) self->priv->reserved_identifiers, name);
            if (_tmp12_) {
                  gchar* _tmp13_ = NULL;
                  _tmp13_ = g_strdup_printf ("_%s_", name);
                  result = _tmp13_;
                  return result;
            } else {
                  gchar* _tmp14_;
                  _tmp14_ = g_strdup (name);
                  result = _tmp14_;
                  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_ = NULL;
            ValaCCodeIdentifier* _tmp2_;
            ValaCCodeMemberAccess* _tmp3_ = NULL;
            ValaCCodeExpression* _tmp4_;
            _tmp1_ = vala_ccode_identifier_new ("_data_");
            _tmp2_ = _tmp1_;
            _tmp3_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp2_, cname);
            _tmp4_ = (ValaCCodeExpression*) _tmp3_;
            _vala_ccode_node_unref0 (_tmp2_);
            result = _tmp4_;
            return result;
      } else {
            ValaCCodeIdentifier* _tmp5_ = NULL;
            _tmp5_ = vala_ccode_identifier_new (cname);
            result = (ValaCCodeExpression*) _tmp5_;
            return result;
      }
}


static gboolean vala_ccode_base_module_has_simple_struct_initializer (ValaCCodeBaseModule* self, ValaLocalVariable* local) {
      gboolean result = FALSE;
      ValaDataType* _tmp0_ = NULL;
      ValaTypeSymbol* _tmp1_ = NULL;
      ValaTypeSymbol* _tmp2_;
      ValaStruct* _tmp3_;
      ValaStruct* st;
      ValaExpression* _tmp4_ = NULL;
      ValaExpression* _tmp5_;
      ValaObjectCreationExpression* _tmp6_;
      ValaObjectCreationExpression* initializer;
      gboolean _tmp7_ = FALSE;
      gboolean _tmp8_ = FALSE;
      gboolean _tmp9_ = FALSE;
      gboolean _tmp10_ = FALSE;
      gboolean _tmp11_ = FALSE;
      g_return_val_if_fail (self != NULL, FALSE);
      g_return_val_if_fail (local != NULL, FALSE);
      _tmp0_ = vala_variable_get_variable_type ((ValaVariable*) local);
      _tmp1_ = vala_data_type_get_data_type (_tmp0_);
      _tmp2_ = _tmp1_;
      _tmp3_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp2_) ? ((ValaStruct*) _tmp2_) : NULL);
      st = _tmp3_;
      _tmp4_ = vala_variable_get_initializer ((ValaVariable*) local);
      _tmp5_ = _tmp4_;
      _tmp6_ = _vala_code_node_ref0 (VALA_IS_OBJECT_CREATION_EXPRESSION (_tmp5_) ? ((ValaObjectCreationExpression*) _tmp5_) : NULL);
      initializer = _tmp6_;
      if (st != NULL) {
            gboolean _tmp12_ = FALSE;
            gboolean _tmp13_;
            _tmp13_ = vala_struct_is_simple_type (st);
            if (!_tmp13_) {
                  _tmp12_ = TRUE;
            } else {
                  gchar* _tmp14_ = NULL;
                  gchar* _tmp15_;
                  _tmp14_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) st, FALSE);
                  _tmp15_ = _tmp14_;
                  _tmp12_ = g_strcmp0 (_tmp15_, "va_list") == 0;
                  _g_free0 (_tmp15_);
            }
            _tmp11_ = _tmp12_;
      } else {
            _tmp11_ = FALSE;
      }
      if (_tmp11_) {
            ValaDataType* _tmp16_ = NULL;
            gboolean _tmp17_;
            _tmp16_ = vala_variable_get_variable_type ((ValaVariable*) local);
            _tmp17_ = vala_data_type_get_nullable (_tmp16_);
            _tmp10_ = !_tmp17_;
      } else {
            _tmp10_ = FALSE;
      }
      if (_tmp10_) {
            ValaDataType* _tmp18_ = NULL;
            ValaTypeSymbol* _tmp19_ = NULL;
            _tmp18_ = vala_variable_get_variable_type ((ValaVariable*) local);
            _tmp19_ = vala_data_type_get_data_type (_tmp18_);
            _tmp9_ = _tmp19_ != VALA_TYPESYMBOL (self->gvalue_type);
      } else {
            _tmp9_ = FALSE;
      }
      if (_tmp9_) {
            _tmp8_ = initializer != NULL;
      } else {
            _tmp8_ = FALSE;
      }
      if (_tmp8_) {
            ValaList* _tmp20_ = NULL;
            ValaList* _tmp21_;
            gint _tmp22_;
            _tmp20_ = vala_object_creation_expression_get_object_initializer (initializer);
            _tmp21_ = _tmp20_;
            _tmp22_ = vala_collection_get_size ((ValaCollection*) _tmp21_);
            _tmp7_ = _tmp22_ == 0;
            _vala_iterable_unref0 (_tmp21_);
      } else {
            _tmp7_ = FALSE;
      }
      if (_tmp7_) {
            result = TRUE;
            _vala_code_node_unref0 (initializer);
            _vala_code_node_unref0 (st);
            return result;
      } else {
            result = FALSE;
            _vala_code_node_unref0 (initializer);
            _vala_code_node_unref0 (st);
            return result;
      }
      _vala_code_node_unref0 (initializer);
      _vala_code_node_unref0 (st);
}


static void vala_ccode_base_module_real_visit_local_variable (ValaCodeVisitor* base, ValaLocalVariable* local) {
      ValaCCodeBaseModule * self;
      ValaDataType* _tmp0_ = NULL;
      ValaExpression* _tmp1_ = NULL;
      ValaDataType* _tmp4_ = NULL;
      ValaCCodeExpression* rhs;
      gboolean _tmp5_ = FALSE;
      ValaExpression* _tmp6_ = NULL;
      gboolean _tmp12_;
      gboolean _tmp102_ = FALSE;
      ValaExpression* _tmp103_ = NULL;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (local != NULL);
      _tmp0_ = vala_variable_get_variable_type ((ValaVariable*) local);
      vala_ccode_base_module_check_type (self, _tmp0_);
      _tmp1_ = vala_variable_get_initializer ((ValaVariable*) local);
      if (_tmp1_ != NULL) {
            ValaExpression* _tmp2_ = NULL;
            ValaExpression* _tmp3_ = NULL;
            _tmp2_ = vala_variable_get_initializer ((ValaVariable*) local);
            vala_code_node_emit ((ValaCodeNode*) _tmp2_, (ValaCodeGenerator*) self);
            _tmp3_ = vala_variable_get_initializer ((ValaVariable*) local);
            vala_code_visitor_visit_end_full_expression ((ValaCodeVisitor*) self, _tmp3_);
      }
      _tmp4_ = vala_variable_get_variable_type ((ValaVariable*) local);
      vala_ccode_base_module_generate_type_declaration (self, _tmp4_, self->cfile);
      rhs = NULL;
      _tmp6_ = vala_variable_get_initializer ((ValaVariable*) local);
      if (_tmp6_ != NULL) {
            ValaExpression* _tmp7_ = NULL;
            ValaCCodeExpression* _tmp8_ = NULL;
            ValaCCodeExpression* _tmp9_;
            _tmp7_ = vala_variable_get_initializer ((ValaVariable*) local);
            _tmp8_ = vala_ccode_base_module_get_cvalue (self, _tmp7_);
            _tmp9_ = _tmp8_;
            _tmp5_ = _tmp9_ != NULL;
            _vala_ccode_node_unref0 (_tmp9_);
      } else {
            _tmp5_ = FALSE;
      }
      if (_tmp5_) {
            ValaExpression* _tmp10_ = NULL;
            ValaCCodeExpression* _tmp11_ = NULL;
            _tmp10_ = vala_variable_get_initializer ((ValaVariable*) local);
            _tmp11_ = vala_ccode_base_module_get_cvalue (self, _tmp10_);
            _vala_ccode_node_unref0 (rhs);
            rhs = _tmp11_;
      }
      _tmp12_ = vala_local_variable_get_captured (local);
      if (!_tmp12_) {
            gboolean _tmp13_ = FALSE;
            ValaMethod* _tmp14_ = NULL;
            ValaDataType* _tmp45_ = NULL;
            _tmp14_ = vala_ccode_base_module_get_current_method (self);
            if (_tmp14_ != NULL) {
                  ValaMethod* _tmp15_ = NULL;
                  gboolean _tmp16_;
                  _tmp15_ = vala_ccode_base_module_get_current_method (self);
                  _tmp16_ = vala_method_get_coroutine (_tmp15_);
                  _tmp13_ = _tmp16_;
            } else {
                  _tmp13_ = FALSE;
            }
            if (_tmp13_) {
                  ValaDataType* _tmp17_ = NULL;
                  gchar* _tmp18_ = NULL;
                  gchar* _tmp19_;
                  const gchar* _tmp20_ = NULL;
                  gchar* _tmp21_ = NULL;
                  gchar* _tmp22_;
                  ValaDataType* _tmp23_ = NULL;
                  gchar* _tmp24_ = NULL;
                  gchar* _tmp25_;
                  gchar* _tmp26_;
                  gchar* _tmp27_;
                  _tmp17_ = vala_variable_get_variable_type ((ValaVariable*) local);
                  _tmp18_ = vala_data_type_get_cname (_tmp17_);
                  _tmp19_ = _tmp18_;
                  _tmp20_ = vala_symbol_get_name ((ValaSymbol*) local);
                  _tmp21_ = vala_ccode_base_module_get_variable_cname (self, _tmp20_);
                  _tmp22_ = _tmp21_;
                  _tmp23_ = vala_variable_get_variable_type ((ValaVariable*) local);
                  _tmp24_ = vala_data_type_get_cdeclarator_suffix (_tmp23_);
                  _tmp25_ = _tmp24_;
                  _tmp26_ = g_strconcat (_tmp22_, _tmp25_, NULL);
                  _tmp27_ = _tmp26_;
                  vala_ccode_struct_add_field (self->closure_struct, _tmp19_, _tmp27_, NULL);
                  _g_free0 (_tmp27_);
                  _g_free0 (_tmp25_);
                  _g_free0 (_tmp22_);
                  _g_free0 (_tmp19_);
            } else {
                  const gchar* _tmp28_ = NULL;
                  gchar* _tmp29_ = NULL;
                  gchar* _tmp30_;
                  ValaDataType* _tmp31_ = NULL;
                  gchar* _tmp32_ = NULL;
                  gchar* _tmp33_;
                  ValaCCodeVariableDeclarator* _tmp34_ = NULL;
                  ValaCCodeVariableDeclarator* _tmp35_;
                  ValaCCodeVariableDeclarator* cvar;
                  gboolean _tmp36_ = FALSE;
                  ValaCCodeFunction* _tmp41_ = NULL;
                  ValaDataType* _tmp42_ = NULL;
                  gchar* _tmp43_ = NULL;
                  gchar* _tmp44_;
                  _tmp28_ = vala_symbol_get_name ((ValaSymbol*) local);
                  _tmp29_ = vala_ccode_base_module_get_variable_cname (self, _tmp28_);
                  _tmp30_ = _tmp29_;
                  _tmp31_ = vala_variable_get_variable_type ((ValaVariable*) local);
                  _tmp32_ = vala_data_type_get_cdeclarator_suffix (_tmp31_);
                  _tmp33_ = _tmp32_;
                  _tmp34_ = vala_ccode_variable_declarator_new (_tmp30_, NULL, _tmp33_);
                  _tmp35_ = _tmp34_;
                  _g_free0 (_tmp33_);
                  _g_free0 (_tmp30_);
                  cvar = _tmp35_;
                  if (rhs == NULL) {
                        _tmp36_ = TRUE;
                  } else {
                        gboolean _tmp37_;
                        _tmp37_ = vala_ccode_base_module_has_simple_struct_initializer (self, local);
                        _tmp36_ = _tmp37_;
                  }
                  if (_tmp36_) {
                        ValaDataType* _tmp38_ = NULL;
                        ValaCCodeExpression* _tmp39_ = NULL;
                        ValaCCodeExpression* _tmp40_;
                        _tmp38_ = vala_variable_get_variable_type ((ValaVariable*) local);
                        _tmp39_ = vala_ccode_base_module_default_value_for_type (self, _tmp38_, TRUE);
                        _tmp40_ = _tmp39_;
                        vala_ccode_variable_declarator_set_initializer (cvar, _tmp40_);
                        _vala_ccode_node_unref0 (_tmp40_);
                        vala_ccode_variable_declarator_set_init0 (cvar, TRUE);
                  }
                  _tmp41_ = vala_ccode_base_module_get_ccode (self);
                  _tmp42_ = vala_variable_get_variable_type ((ValaVariable*) local);
                  _tmp43_ = vala_data_type_get_cname (_tmp42_);
                  _tmp44_ = _tmp43_;
                  vala_ccode_function_add_declaration (_tmp41_, _tmp44_, (ValaCCodeDeclarator*) cvar, 0);
                  _g_free0 (_tmp44_);
                  _vala_ccode_node_unref0 (cvar);
            }
            _tmp45_ = vala_variable_get_variable_type ((ValaVariable*) local);
            if (VALA_IS_ARRAY_TYPE (_tmp45_)) {
                  ValaDataType* _tmp46_ = NULL;
                  ValaArrayType* _tmp47_;
                  ValaArrayType* array_type;
                  gboolean _tmp48_;
                  _tmp46_ = vala_variable_get_variable_type ((ValaVariable*) local);
                  _tmp47_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp46_));
                  array_type = _tmp47_;
                  _tmp48_ = vala_array_type_get_fixed_length (array_type);
                  if (!_tmp48_) {
                        gint _tmp61_;
                        {
                              gint dim;
                              dim = 1;
                              {
                                    gboolean _tmp49_;
                                    _tmp49_ = TRUE;
                                    while (TRUE) {
                                          gint _tmp50_;
                                          ValaDataType* _tmp51_ = NULL;
                                          ValaDataType* _tmp52_;
                                          const gchar* _tmp53_ = NULL;
                                          gchar* _tmp54_ = NULL;
                                          gchar* _tmp55_;
                                          gchar* _tmp56_ = NULL;
                                          gchar* _tmp57_;
                                          ValaLocalVariable* _tmp58_ = NULL;
                                          ValaLocalVariable* _tmp59_;
                                          ValaLocalVariable* len_var;
                                          ValaExpression* _tmp60_ = NULL;
                                          if (!_tmp49_) {
                                                dim++;
                                          }
                                          _tmp49_ = FALSE;
                                          _tmp50_ = vala_array_type_get_rank (array_type);
                                          if (!(dim <= _tmp50_)) {
                                                break;
                                          }
                                          _tmp51_ = vala_data_type_copy (self->int_type);
                                          _tmp52_ = _tmp51_;
                                          _tmp53_ = vala_symbol_get_name ((ValaSymbol*) local);
                                          _tmp54_ = vala_ccode_base_module_get_variable_cname (self, _tmp53_);
                                          _tmp55_ = _tmp54_;
                                          _tmp56_ = vala_ccode_base_module_get_array_length_cname (self, _tmp55_, dim);
                                          _tmp57_ = _tmp56_;
                                          _tmp58_ = vala_local_variable_new (_tmp52_, _tmp57_, NULL, NULL);
                                          _tmp59_ = _tmp58_;
                                          _g_free0 (_tmp57_);
                                          _g_free0 (_tmp55_);
                                          _vala_code_node_unref0 (_tmp52_);
                                          len_var = _tmp59_;
                                          _tmp60_ = vala_variable_get_initializer ((ValaVariable*) local);
                                          vala_ccode_base_module_emit_temp_var (self, len_var, _tmp60_ == NULL);
                                          _vala_code_node_unref0 (len_var);
                                    }
                              }
                        }
                        _tmp61_ = vala_array_type_get_rank (array_type);
                        if (_tmp61_ == 1) {
                              ValaDataType* _tmp62_ = NULL;
                              ValaDataType* _tmp63_;
                              const gchar* _tmp64_ = NULL;
                              gchar* _tmp65_ = NULL;
                              gchar* _tmp66_;
                              gchar* _tmp67_ = NULL;
                              gchar* _tmp68_;
                              ValaLocalVariable* _tmp69_ = NULL;
                              ValaLocalVariable* _tmp70_;
                              ValaLocalVariable* size_var;
                              ValaExpression* _tmp71_ = NULL;
                              _tmp62_ = vala_data_type_copy (self->int_type);
                              _tmp63_ = _tmp62_;
                              _tmp64_ = vala_symbol_get_name ((ValaSymbol*) local);
                              _tmp65_ = vala_ccode_base_module_get_variable_cname (self, _tmp64_);
                              _tmp66_ = _tmp65_;
                              _tmp67_ = vala_ccode_base_module_get_array_size_cname (self, _tmp66_);
                              _tmp68_ = _tmp67_;
                              _tmp69_ = vala_local_variable_new (_tmp63_, _tmp68_, NULL, NULL);
                              _tmp70_ = _tmp69_;
                              _g_free0 (_tmp68_);
                              _g_free0 (_tmp66_);
                              _vala_code_node_unref0 (_tmp63_);
                              size_var = _tmp70_;
                              _tmp71_ = vala_variable_get_initializer ((ValaVariable*) local);
                              vala_ccode_base_module_emit_temp_var (self, size_var, _tmp71_ == NULL);
                              _vala_code_node_unref0 (size_var);
                        }
                  }
                  _vala_code_node_unref0 (array_type);
            } else {
                  ValaDataType* _tmp72_ = NULL;
                  _tmp72_ = vala_variable_get_variable_type ((ValaVariable*) local);
                  if (VALA_IS_DELEGATE_TYPE (_tmp72_)) {
                        ValaDataType* _tmp73_ = NULL;
                        ValaDelegateType* _tmp74_;
                        ValaDelegateType* deleg_type;
                        ValaDelegate* _tmp75_ = NULL;
                        ValaDelegate* _tmp76_;
                        ValaDelegate* d;
                        gboolean _tmp77_;
                        _tmp73_ = vala_variable_get_variable_type ((ValaVariable*) local);
                        _tmp74_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp73_));
                        deleg_type = _tmp74_;
                        _tmp75_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                        _tmp76_ = _vala_code_node_ref0 (_tmp75_);
                        d = _tmp76_;
                        _tmp77_ = vala_delegate_get_has_target (d);
                        if (_tmp77_) {
                              ValaVoidType* _tmp78_ = NULL;
                              ValaVoidType* _tmp79_;
                              ValaPointerType* _tmp80_ = NULL;
                              ValaPointerType* _tmp81_;
                              const gchar* _tmp82_ = NULL;
                              gchar* _tmp83_ = NULL;
                              gchar* _tmp84_;
                              gchar* _tmp85_ = NULL;
                              gchar* _tmp86_;
                              ValaLocalVariable* _tmp87_ = NULL;
                              ValaLocalVariable* _tmp88_;
                              ValaLocalVariable* target_var;
                              ValaExpression* _tmp89_ = NULL;
                              gboolean _tmp90_;
                              _tmp78_ = vala_void_type_new (NULL);
                              _tmp79_ = _tmp78_;
                              _tmp80_ = vala_pointer_type_new ((ValaDataType*) _tmp79_, NULL);
                              _tmp81_ = _tmp80_;
                              _tmp82_ = vala_symbol_get_name ((ValaSymbol*) local);
                              _tmp83_ = vala_ccode_base_module_get_variable_cname (self, _tmp82_);
                              _tmp84_ = _tmp83_;
                              _tmp85_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp84_);
                              _tmp86_ = _tmp85_;
                              _tmp87_ = vala_local_variable_new ((ValaDataType*) _tmp81_, _tmp86_, NULL, NULL);
                              _tmp88_ = _tmp87_;
                              _g_free0 (_tmp86_);
                              _g_free0 (_tmp84_);
                              _vala_code_node_unref0 (_tmp81_);
                              _vala_code_node_unref0 (_tmp79_);
                              target_var = _tmp88_;
                              _tmp89_ = vala_variable_get_initializer ((ValaVariable*) local);
                              vala_ccode_base_module_emit_temp_var (self, target_var, _tmp89_ == NULL);
                              _tmp90_ = vala_data_type_get_value_owned ((ValaDataType*) deleg_type);
                              if (_tmp90_) {
                                    const gchar* _tmp91_ = NULL;
                                    gchar* _tmp92_ = NULL;
                                    gchar* _tmp93_;
                                    gchar* _tmp94_ = NULL;
                                    gchar* _tmp95_;
                                    ValaLocalVariable* _tmp96_ = NULL;
                                    ValaLocalVariable* _tmp97_;
                                    ValaLocalVariable* target_destroy_notify_var;
                                    ValaExpression* _tmp98_ = NULL;
                                    _tmp91_ = vala_symbol_get_name ((ValaSymbol*) local);
                                    _tmp92_ = vala_ccode_base_module_get_variable_cname (self, _tmp91_);
                                    _tmp93_ = _tmp92_;
                                    _tmp94_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp93_);
                                    _tmp95_ = _tmp94_;
                                    _tmp96_ = vala_local_variable_new (self->gdestroynotify_type, _tmp95_, NULL, NULL);
                                    _tmp97_ = _tmp96_;
                                    _g_free0 (_tmp95_);
                                    _g_free0 (_tmp93_);
                                    target_destroy_notify_var = _tmp97_;
                                    _tmp98_ = vala_variable_get_initializer ((ValaVariable*) local);
                                    vala_ccode_base_module_emit_temp_var (self, target_destroy_notify_var, _tmp98_ == NULL);
                                    _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);
                  }
            }
      }
      if (rhs != NULL) {
            gboolean _tmp99_;
            _tmp99_ = vala_ccode_base_module_has_simple_struct_initializer (self, local);
            if (!_tmp99_) {
                  ValaExpression* _tmp100_ = NULL;
                  ValaTargetValue* _tmp101_ = NULL;
                  _tmp100_ = vala_variable_get_initializer ((ValaVariable*) local);
                  _tmp101_ = vala_expression_get_target_value (_tmp100_);
                  vala_code_generator_store_local ((ValaCodeGenerator*) self, local, _tmp101_, TRUE);
            }
      }
      _tmp103_ = vala_variable_get_initializer ((ValaVariable*) local);
      if (_tmp103_ != NULL) {
            ValaExpression* _tmp104_ = NULL;
            gboolean _tmp105_;
            _tmp104_ = vala_variable_get_initializer ((ValaVariable*) local);
            _tmp105_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp104_);
            _tmp102_ = _tmp105_;
      } else {
            _tmp102_ = FALSE;
      }
      if (_tmp102_) {
            ValaExpression* _tmp106_ = NULL;
            _tmp106_ = vala_variable_get_initializer ((ValaVariable*) local);
            vala_ccode_base_module_add_simple_check (self, (ValaCodeNode*) _tmp106_, FALSE);
      }
      vala_symbol_set_active ((ValaSymbol*) local, TRUE);
      _vala_ccode_node_unref0 (rhs);
}


static void vala_ccode_base_module_real_visit_initializer_list (ValaCodeVisitor* base, ValaInitializerList* list) {
      ValaCCodeBaseModule * self;
      ValaDataType* _tmp0_ = NULL;
      ValaTypeSymbol* _tmp1_ = NULL;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (list != NULL);
      _tmp0_ = vala_expression_get_target_type ((ValaExpression*) list);
      _tmp1_ = vala_data_type_get_data_type (_tmp0_);
      if (VALA_IS_STRUCT (_tmp1_)) {
            ValaDataType* _tmp2_ = NULL;
            ValaTypeSymbol* _tmp3_ = NULL;
            ValaStruct* _tmp4_;
            ValaStruct* st;
            gboolean _tmp5_ = FALSE;
            gboolean _tmp6_ = FALSE;
            ValaCodeNode* _tmp7_ = NULL;
            _tmp2_ = vala_expression_get_target_type ((ValaExpression*) list);
            _tmp3_ = vala_data_type_get_data_type (_tmp2_);
            _tmp4_ = _vala_code_node_ref0 (VALA_STRUCT (_tmp3_));
            st = _tmp4_;
            _tmp7_ = vala_code_node_get_parent_node ((ValaCodeNode*) list);
            if (VALA_IS_CONSTANT (_tmp7_)) {
                  _tmp6_ = TRUE;
            } else {
                  ValaCodeNode* _tmp8_ = NULL;
                  _tmp8_ = vala_code_node_get_parent_node ((ValaCodeNode*) list);
                  _tmp6_ = VALA_IS_FIELD (_tmp8_);
            }
            if (_tmp6_) {
                  _tmp5_ = TRUE;
            } else {
                  ValaCodeNode* _tmp9_ = NULL;
                  _tmp9_ = vala_code_node_get_parent_node ((ValaCodeNode*) list);
                  _tmp5_ = VALA_IS_INITIALIZER_LIST (_tmp9_);
            }
            if (_tmp5_) {
                  ValaCCodeInitializerList* _tmp10_ = NULL;
                  ValaCCodeInitializerList* clist;
                  ValaList* _tmp11_ = NULL;
                  ValaList* _tmp12_;
                  ValaIterator* _tmp13_ = NULL;
                  ValaIterator* _tmp14_;
                  ValaIterator* field_it;
                  _tmp10_ = vala_ccode_initializer_list_new ();
                  clist = _tmp10_;
                  _tmp11_ = vala_struct_get_fields (st);
                  _tmp12_ = _tmp11_;
                  _tmp13_ = vala_iterable_iterator ((ValaIterable*) _tmp12_);
                  _tmp14_ = _tmp13_;
                  _vala_iterable_unref0 (_tmp12_);
                  field_it = _tmp14_;
                  {
                        ValaList* _tmp15_ = NULL;
                        ValaList* _expr_list;
                        gint _tmp16_;
                        gint _expr_size;
                        gint _expr_index;
                        _tmp15_ = vala_initializer_list_get_initializers (list);
                        _expr_list = _tmp15_;
                        _tmp16_ = vala_collection_get_size ((ValaCollection*) _expr_list);
                        _expr_size = _tmp16_;
                        _expr_index = -1;
                        while (TRUE) {
                              gpointer _tmp17_ = NULL;
                              ValaExpression* expr;
                              ValaField* field;
                              ValaCCodeExpression* _tmp20_ = NULL;
                              ValaCCodeExpression* cexpr;
                              gchar* _tmp21_ = NULL;
                              gchar* ctype;
                              ValaDataType* _tmp23_ = NULL;
                              ValaDataType* _tmp24_;
                              ValaArrayType* _tmp25_;
                              ValaArrayType* array_type;
                              gboolean _tmp26_ = FALSE;
                              gboolean _tmp27_ = FALSE;
                              _expr_index = _expr_index + 1;
                              if (!(_expr_index < _expr_size)) {
                                    break;
                              }
                              _tmp17_ = vala_list_get (_expr_list, _expr_index);
                              expr = (ValaExpression*) _tmp17_;
                              field = NULL;
                              while (TRUE) {
                                    gpointer _tmp18_ = NULL;
                                    ValaMemberBinding _tmp19_;
                                    if (!(field == NULL)) {
                                          break;
                                    }
                                    vala_iterator_next (field_it);
                                    _tmp18_ = vala_iterator_get (field_it);
                                    _vala_code_node_unref0 (field);
                                    field = (ValaField*) _tmp18_;
                                    _tmp19_ = vala_field_get_binding (field);
                                    if (_tmp19_ != VALA_MEMBER_BINDING_INSTANCE) {
                                          _vala_code_node_unref0 (field);
                                          field = NULL;
                                    }
                              }
                              _tmp20_ = vala_ccode_base_module_get_cvalue (self, expr);
                              cexpr = _tmp20_;
                              _tmp21_ = vala_field_get_ctype (field);
                              ctype = _tmp21_;
                              if (ctype != NULL) {
                                    ValaCCodeCastExpression* _tmp22_ = NULL;
                                    _tmp22_ = vala_ccode_cast_expression_new (cexpr, ctype);
                                    _vala_ccode_node_unref0 (cexpr);
                                    cexpr = (ValaCCodeExpression*) _tmp22_;
                              }
                              vala_ccode_initializer_list_append (clist, cexpr);
                              _tmp23_ = vala_variable_get_variable_type ((ValaVariable*) field);
                              _tmp24_ = _tmp23_;
                              _tmp25_ = _vala_code_node_ref0 (VALA_IS_ARRAY_TYPE (_tmp24_) ? ((ValaArrayType*) _tmp24_) : NULL);
                              array_type = _tmp25_;
                              if (array_type != NULL) {
                                    gboolean _tmp28_;
                                    _tmp28_ = vala_variable_get_no_array_length ((ValaVariable*) field);
                                    _tmp27_ = !_tmp28_;
                              } else {
                                    _tmp27_ = FALSE;
                              }
                              if (_tmp27_) {
                                    gboolean _tmp29_;
                                    _tmp29_ = vala_variable_get_array_null_terminated ((ValaVariable*) field);
                                    _tmp26_ = !_tmp29_;
                              } else {
                                    _tmp26_ = FALSE;
                              }
                              if (_tmp26_) {
                                    {
                                          gint dim;
                                          dim = 1;
                                          {
                                                gboolean _tmp30_;
                                                _tmp30_ = TRUE;
                                                while (TRUE) {
                                                      gint _tmp31_;
                                                      ValaTargetValue* _tmp32_ = NULL;
                                                      ValaCCodeExpression* _tmp33_ = NULL;
                                                      ValaCCodeExpression* _tmp34_;
                                                      if (!_tmp30_) {
                                                            dim++;
                                                      }
                                                      _tmp30_ = FALSE;
                                                      _tmp31_ = vala_array_type_get_rank (array_type);
                                                      if (!(dim <= _tmp31_)) {
                                                            break;
                                                      }
                                                      _tmp32_ = vala_expression_get_target_value (expr);
                                                      _tmp33_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp32_, dim);
                                                      _tmp34_ = _tmp33_;
                                                      vala_ccode_initializer_list_append (clist, _tmp34_);
                                                      _vala_ccode_node_unref0 (_tmp34_);
                                                }
                                          }
                                    }
                              }
                              _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);
                  }
                  vala_ccode_base_module_set_cvalue (self, (ValaExpression*) list, (ValaCCodeExpression*) clist);
                  _vala_iterator_unref0 (field_it);
                  _vala_ccode_node_unref0 (clist);
            } else {
                  ValaDataType* _tmp35_ = NULL;
                  ValaLocalVariable* _tmp36_ = NULL;
                  ValaLocalVariable* temp_decl;
                  ValaTargetValue* _tmp37_ = NULL;
                  ValaTargetValue* instance;
                  ValaList* _tmp38_ = NULL;
                  ValaList* _tmp39_;
                  ValaIterator* _tmp40_ = NULL;
                  ValaIterator* _tmp41_;
                  ValaIterator* field_it;
                  _tmp35_ = vala_expression_get_target_type ((ValaExpression*) list);
                  _tmp36_ = vala_ccode_base_module_get_temp_variable (self, _tmp35_, FALSE, (ValaCodeNode*) list, TRUE);
                  temp_decl = _tmp36_;
                  vala_ccode_base_module_emit_temp_var (self, temp_decl, FALSE);
                  _tmp37_ = vala_ccode_base_module_get_local_cvalue (self, temp_decl);
                  instance = _tmp37_;
                  _tmp38_ = vala_struct_get_fields (st);
                  _tmp39_ = _tmp38_;
                  _tmp40_ = vala_iterable_iterator ((ValaIterable*) _tmp39_);
                  _tmp41_ = _tmp40_;
                  _vala_iterable_unref0 (_tmp39_);
                  field_it = _tmp41_;
                  {
                        ValaList* _tmp42_ = NULL;
                        ValaList* _expr_list;
                        gint _tmp43_;
                        gint _expr_size;
                        gint _expr_index;
                        _tmp42_ = vala_initializer_list_get_initializers (list);
                        _expr_list = _tmp42_;
                        _tmp43_ = vala_collection_get_size ((ValaCollection*) _expr_list);
                        _expr_size = _tmp43_;
                        _expr_index = -1;
                        while (TRUE) {
                              gpointer _tmp44_ = NULL;
                              ValaExpression* expr;
                              ValaField* field;
                              ValaTargetValue* _tmp47_ = NULL;
                              _expr_index = _expr_index + 1;
                              if (!(_expr_index < _expr_size)) {
                                    break;
                              }
                              _tmp44_ = vala_list_get (_expr_list, _expr_index);
                              expr = (ValaExpression*) _tmp44_;
                              field = NULL;
                              while (TRUE) {
                                    gpointer _tmp45_ = NULL;
                                    ValaMemberBinding _tmp46_;
                                    if (!(field == NULL)) {
                                          break;
                                    }
                                    vala_iterator_next (field_it);
                                    _tmp45_ = vala_iterator_get (field_it);
                                    _vala_code_node_unref0 (field);
                                    field = (ValaField*) _tmp45_;
                                    _tmp46_ = vala_field_get_binding (field);
                                    if (_tmp46_ != VALA_MEMBER_BINDING_INSTANCE) {
                                          _vala_code_node_unref0 (field);
                                          field = NULL;
                                    }
                              }
                              _tmp47_ = vala_expression_get_target_value (expr);
                              vala_code_generator_store_field ((ValaCodeGenerator*) self, field, instance, _tmp47_);
                              _vala_code_node_unref0 (field);
                              _vala_code_node_unref0 (expr);
                        }
                        _vala_iterable_unref0 (_expr_list);
                  }
                  vala_expression_set_target_value ((ValaExpression*) list, instance);
                  _vala_iterator_unref0 (field_it);
                  _vala_target_value_unref0 (instance);
                  _vala_code_node_unref0 (temp_decl);
            }
            _vala_code_node_unref0 (st);
      } else {
            ValaCCodeInitializerList* _tmp48_ = NULL;
            ValaCCodeInitializerList* clist;
            _tmp48_ = vala_ccode_initializer_list_new ();
            clist = _tmp48_;
            {
                  ValaList* _tmp49_ = NULL;
                  ValaList* _expr_list;
                  gint _tmp50_;
                  gint _expr_size;
                  gint _expr_index;
                  _tmp49_ = vala_initializer_list_get_initializers (list);
                  _expr_list = _tmp49_;
                  _tmp50_ = vala_collection_get_size ((ValaCollection*) _expr_list);
                  _expr_size = _tmp50_;
                  _expr_index = -1;
                  while (TRUE) {
                        gpointer _tmp51_ = NULL;
                        ValaExpression* expr;
                        ValaCCodeExpression* _tmp52_ = NULL;
                        ValaCCodeExpression* _tmp53_;
                        _expr_index = _expr_index + 1;
                        if (!(_expr_index < _expr_size)) {
                              break;
                        }
                        _tmp51_ = vala_list_get (_expr_list, _expr_index);
                        expr = (ValaExpression*) _tmp51_;
                        _tmp52_ = vala_ccode_base_module_get_cvalue (self, expr);
                        _tmp53_ = _tmp52_;
                        vala_ccode_initializer_list_append (clist, _tmp53_);
                        _vala_ccode_node_unref0 (_tmp53_);
                        _vala_code_node_unref0 (expr);
                  }
                  _vala_iterable_unref0 (_expr_list);
            }
            vala_ccode_base_module_set_cvalue (self, (ValaExpression*) list, (ValaCCodeExpression*) clist);
            _vala_ccode_node_unref0 (clist);
      }
}


static ValaLocalVariable* vala_ccode_base_module_real_create_local (ValaCodeGenerator* base, ValaDataType* type) {
      ValaCCodeBaseModule * self;
      ValaLocalVariable* result = NULL;
      gboolean _tmp0_;
      ValaLocalVariable* _tmp1_ = NULL;
      ValaLocalVariable* _result_;
      self = (ValaCCodeBaseModule*) base;
      g_return_val_if_fail (type != NULL, NULL);
      _tmp0_ = vala_data_type_get_value_owned (type);
      _tmp1_ = vala_ccode_base_module_get_temp_variable (self, type, _tmp0_, NULL, TRUE);
      _result_ = _tmp1_;
      vala_ccode_base_module_emit_temp_var (self, _result_, FALSE);
      result = _result_;
      return result;
}


ValaLocalVariable* vala_ccode_base_module_get_temp_variable (ValaCCodeBaseModule* self, ValaDataType* type, gboolean value_owned, ValaCodeNode* node_reference, gboolean init) {
      ValaLocalVariable* result = NULL;
      ValaDataType* _tmp0_ = NULL;
      ValaDataType* var_type;
      gint _tmp1_;
      gchar* _tmp2_ = NULL;
      gchar* _tmp3_;
      ValaLocalVariable* _tmp4_ = NULL;
      ValaLocalVariable* _tmp5_;
      ValaLocalVariable* local;
      gint _tmp7_;
      gint _tmp8_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (type != NULL, NULL);
      _tmp0_ = vala_data_type_copy (type);
      var_type = _tmp0_;
      vala_data_type_set_value_owned (var_type, value_owned);
      _tmp1_ = vala_ccode_base_module_get_next_temp_var_id (self);
      _tmp2_ = g_strdup_printf ("_tmp%d_", _tmp1_);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_local_variable_new (var_type, _tmp3_, NULL, NULL);
      _tmp5_ = _tmp4_;
      _g_free0 (_tmp3_);
      local = _tmp5_;
      vala_local_variable_set_no_init (local, !init);
      if (node_reference != NULL) {
            ValaSourceReference* _tmp6_ = NULL;
            _tmp6_ = vala_code_node_get_source_reference (node_reference);
            vala_code_node_set_source_reference ((ValaCodeNode*) local, _tmp6_);
      }
      _tmp7_ = vala_ccode_base_module_get_next_temp_var_id (self);
      _tmp8_ = _tmp7_;
      vala_ccode_base_module_set_next_temp_var_id (self, _tmp8_ + 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_ = NULL;
      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);
      if (_tmp2_ != NULL) {
            ValaTypeParameter* _tmp3_ = NULL;
            ValaSymbol* _tmp4_ = NULL;
            _tmp3_ = vala_data_type_get_type_parameter (type);
            _tmp4_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp3_);
            _tmp1_ = VALA_IS_TYPESYMBOL (_tmp4_);
      } else {
            _tmp1_ = FALSE;
      }
      if (_tmp1_) {
            gboolean _tmp5_ = FALSE;
            ValaMethod* _tmp6_ = NULL;
            _tmp6_ = vala_ccode_base_module_get_current_method (self);
            if (_tmp6_ == NULL) {
                  _tmp5_ = TRUE;
            } else {
                  ValaMethod* _tmp7_ = NULL;
                  ValaMemberBinding _tmp8_;
                  _tmp7_ = vala_ccode_base_module_get_current_method (self);
                  _tmp8_ = vala_method_get_binding (_tmp7_);
                  _tmp5_ = _tmp8_ == VALA_MEMBER_BINDING_INSTANCE;
            }
            _tmp0_ = _tmp5_;
      } else {
            _tmp0_ = FALSE;
      }
      if (_tmp0_) {
            result = TRUE;
            return result;
      } else {
            result = FALSE;
            return result;
      }
}


ValaCCodeExpression* vala_ccode_base_module_get_type_id_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup) {
      ValaCCodeExpression* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (type != NULL, NULL);
      if (VALA_IS_GENERIC_TYPE (type)) {
            ValaTypeParameter* _tmp0_ = NULL;
            const gchar* _tmp1_ = NULL;
            gchar* _tmp2_ = NULL;
            gchar* _tmp3_;
            gchar* _tmp4_ = NULL;
            gchar* _tmp5_;
            gchar* var_name;
            gboolean _tmp6_ = FALSE;
            gboolean _tmp7_ = FALSE;
            gboolean _tmp8_;
            _tmp0_ = vala_data_type_get_type_parameter (type);
            _tmp1_ = vala_symbol_get_name ((ValaSymbol*) _tmp0_);
            _tmp2_ = g_utf8_strdown (_tmp1_, (gssize) (-1));
            _tmp3_ = _tmp2_;
            _tmp4_ = g_strdup_printf ("%s_type", _tmp3_);
            _tmp5_ = _tmp4_;
            _g_free0 (_tmp3_);
            var_name = _tmp5_;
            _tmp8_ = vala_ccode_base_module_is_in_generic_type (self, type);
            if (_tmp8_) {
                  _tmp7_ = !is_chainup;
            } else {
                  _tmp7_ = FALSE;
            }
            if (_tmp7_) {
                  gboolean _tmp9_;
                  _tmp9_ = vala_ccode_base_module_get_in_creation_method (self);
                  _tmp6_ = !_tmp9_;
            } else {
                  _tmp6_ = FALSE;
            }
            if (_tmp6_) {
                  ValaCCodeExpression* _tmp10_ = NULL;
                  ValaCCodeExpression* _tmp11_;
                  ValaCCodeMemberAccess* _tmp12_ = NULL;
                  ValaCCodeMemberAccess* _tmp13_;
                  ValaCCodeMemberAccess* _tmp14_ = NULL;
                  ValaCCodeExpression* _tmp15_;
                  _tmp10_ = vala_ccode_base_module_get_result_cexpression (self, "self");
                  _tmp11_ = _tmp10_;
                  _tmp12_ = vala_ccode_member_access_new_pointer (_tmp11_, "priv");
                  _tmp13_ = _tmp12_;
                  _tmp14_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp13_, var_name);
                  _tmp15_ = (ValaCCodeExpression*) _tmp14_;
                  _vala_ccode_node_unref0 (_tmp13_);
                  _vala_ccode_node_unref0 (_tmp11_);
                  result = _tmp15_;
                  _g_free0 (var_name);
                  return result;
            } else {
                  ValaCCodeIdentifier* _tmp16_ = NULL;
                  _tmp16_ = vala_ccode_identifier_new (var_name);
                  result = (ValaCCodeExpression*) _tmp16_;
                  _g_free0 (var_name);
                  return result;
            }
            _g_free0 (var_name);
      } else {
            gchar* _tmp17_ = NULL;
            gchar* type_id;
            ValaCCodeIdentifier* _tmp19_ = NULL;
            _tmp17_ = vala_data_type_get_type_id (type);
            type_id = _tmp17_;
            if (type_id == NULL) {
                  gchar* _tmp18_;
                  _tmp18_ = g_strdup ("G_TYPE_INVALID");
                  _g_free0 (type_id);
                  type_id = _tmp18_;
            } else {
                  vala_ccode_base_module_generate_type_declaration (self, type, self->cfile);
            }
            _tmp19_ = vala_ccode_identifier_new (type_id);
            result = (ValaCCodeExpression*) _tmp19_;
            _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;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (type != NULL, NULL);
      if (VALA_IS_ERROR_TYPE (type)) {
            ValaCCodeIdentifier* _tmp0_ = NULL;
            _tmp0_ = vala_ccode_identifier_new ("g_error_copy");
            result = (ValaCCodeExpression*) _tmp0_;
            return result;
      } else {
            ValaTypeSymbol* _tmp1_ = NULL;
            _tmp1_ = vala_data_type_get_data_type (type);
            if (_tmp1_ != NULL) {
                  gchar* dup_function = NULL;
                  ValaTypeSymbol* _tmp2_ = NULL;
                  ValaTypeSymbol* _tmp3_;
                  ValaClass* _tmp4_;
                  ValaClass* cl;
                  ValaTypeSymbol* _tmp5_ = NULL;
                  gboolean _tmp6_;
                  ValaCCodeIdentifier* _tmp35_ = NULL;
                  _tmp2_ = vala_data_type_get_data_type (type);
                  _tmp3_ = _tmp2_;
                  _tmp4_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp3_) ? ((ValaClass*) _tmp3_) : NULL);
                  cl = _tmp4_;
                  _tmp5_ = vala_data_type_get_data_type (type);
                  _tmp6_ = vala_typesymbol_is_reference_counting (_tmp5_);
                  if (_tmp6_) {
                        ValaTypeSymbol* _tmp7_ = NULL;
                        gchar* _tmp8_ = NULL;
                        gboolean _tmp9_ = FALSE;
                        ValaTypeSymbol* _tmp10_ = NULL;
                        _tmp7_ = vala_data_type_get_data_type (type);
                        _tmp8_ = vala_typesymbol_get_ref_function (_tmp7_);
                        _g_free0 (dup_function);
                        dup_function = _tmp8_;
                        _tmp10_ = vala_data_type_get_data_type (type);
                        if (VALA_IS_INTERFACE (_tmp10_)) {
                              _tmp9_ = dup_function == NULL;
                        } else {
                              _tmp9_ = FALSE;
                        }
                        if (_tmp9_) {
                              ValaTypeSymbol* _tmp11_ = NULL;
                              gchar* _tmp12_ = NULL;
                              gchar* _tmp13_;
                              gchar* _tmp14_ = NULL;
                              gchar* _tmp15_;
                              _tmp11_ = vala_data_type_get_data_type (type);
                              _tmp12_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp11_);
                              _tmp13_ = _tmp12_;
                              _tmp14_ = g_strdup_printf ("missing class prerequisite for interface `%s', add GLib.Object to inte" \
"rface declaration if unsure", _tmp13_);
                              _tmp15_ = _tmp14_;
                              vala_report_error (source_reference, _tmp15_);
                              _g_free0 (_tmp15_);
                              _g_free0 (_tmp13_);
                              result = NULL;
                              _vala_code_node_unref0 (cl);
                              _g_free0 (dup_function);
                              return result;
                        }
                  } else {
                        gboolean _tmp16_ = FALSE;
                        if (cl != NULL) {
                              gboolean _tmp17_;
                              _tmp17_ = vala_class_get_is_immutable (cl);
                              _tmp16_ = _tmp17_;
                        } else {
                              _tmp16_ = FALSE;
                        }
                        if (_tmp16_) {
                              ValaTypeSymbol* _tmp18_ = NULL;
                              gchar* _tmp19_ = NULL;
                              _tmp18_ = vala_data_type_get_data_type (type);
                              _tmp19_ = vala_typesymbol_get_dup_function (_tmp18_);
                              _g_free0 (dup_function);
                              dup_function = _tmp19_;
                              if (dup_function == NULL) {
                                    gchar* _tmp20_;
                                    _tmp20_ = g_strdup ("");
                                    _g_free0 (dup_function);
                                    dup_function = _tmp20_;
                              }
                        } else {
                              gboolean _tmp21_ = FALSE;
                              if (cl != NULL) {
                                    gboolean _tmp22_;
                                    _tmp22_ = vala_class_get_is_gboxed (cl);
                                    _tmp21_ = _tmp22_;
                              } else {
                                    _tmp21_ = FALSE;
                              }
                              if (_tmp21_) {
                                    gchar* _tmp23_ = NULL;
                                    _tmp23_ = vala_ccode_base_module_generate_dup_func_wrapper (self, type);
                                    _g_free0 (dup_function);
                                    dup_function = _tmp23_;
                                    if (dup_function == NULL) {
                                          gchar* _tmp24_;
                                          _tmp24_ = g_strdup ("");
                                          _g_free0 (dup_function);
                                          dup_function = _tmp24_;
                                    }
                              } else {
                                    if (VALA_IS_VALUE_TYPE (type)) {
                                          ValaTypeSymbol* _tmp25_ = NULL;
                                          gchar* _tmp26_ = NULL;
                                          gboolean _tmp27_ = FALSE;
                                          _tmp25_ = vala_data_type_get_data_type (type);
                                          _tmp26_ = vala_typesymbol_get_dup_function (_tmp25_);
                                          _g_free0 (dup_function);
                                          dup_function = _tmp26_;
                                          if (dup_function == NULL) {
                                                gboolean _tmp28_;
                                                _tmp28_ = vala_data_type_get_nullable (type);
                                                _tmp27_ = _tmp28_;
                                          } else {
                                                _tmp27_ = FALSE;
                                          }
                                          if (_tmp27_) {
                                                gchar* _tmp29_ = NULL;
                                                _tmp29_ = vala_ccode_base_module_generate_struct_dup_wrapper (self, VALA_VALUE_TYPE (type));
                                                _g_free0 (dup_function);
                                                dup_function = _tmp29_;
                                          } else {
                                                if (dup_function == NULL) {
                                                      gchar* _tmp30_;
                                                      _tmp30_ = g_strdup ("");
                                                      _g_free0 (dup_function);
                                                      dup_function = _tmp30_;
                                                }
                                          }
                                    } else {
                                          ValaTypeSymbol* _tmp31_ = NULL;
                                          const gchar* _tmp32_ = NULL;
                                          gchar* _tmp33_ = NULL;
                                          gchar* _tmp34_;
                                          _tmp31_ = vala_data_type_get_data_type (type);
                                          _tmp32_ = vala_symbol_get_name ((ValaSymbol*) _tmp31_);
                                          _tmp33_ = g_strdup_printf ("duplicating %s instance, use unowned variable or explicitly invoke cop" \
"y method", _tmp32_);
                                          _tmp34_ = _tmp33_;
                                          vala_report_error (source_reference, _tmp34_);
                                          _g_free0 (_tmp34_);
                                          result = NULL;
                                          _vala_code_node_unref0 (cl);
                                          _g_free0 (dup_function);
                                          return result;
                                    }
                              }
                        }
                  }
                  _tmp35_ = vala_ccode_identifier_new (dup_function);
                  result = (ValaCCodeExpression*) _tmp35_;
                  _vala_code_node_unref0 (cl);
                  _g_free0 (dup_function);
                  return result;
            } else {
                  ValaTypeParameter* _tmp36_ = NULL;
                  _tmp36_ = vala_data_type_get_type_parameter (type);
                  if (_tmp36_ != NULL) {
                        ValaTypeParameter* _tmp37_ = NULL;
                        const gchar* _tmp38_ = NULL;
                        gchar* _tmp39_ = NULL;
                        gchar* _tmp40_;
                        gchar* _tmp41_ = NULL;
                        gchar* _tmp42_;
                        gchar* func_name;
                        gboolean _tmp43_ = FALSE;
                        gboolean _tmp44_ = FALSE;
                        gboolean _tmp45_;
                        _tmp37_ = vala_data_type_get_type_parameter (type);
                        _tmp38_ = vala_symbol_get_name ((ValaSymbol*) _tmp37_);
                        _tmp39_ = g_utf8_strdown (_tmp38_, (gssize) (-1));
                        _tmp40_ = _tmp39_;
                        _tmp41_ = g_strdup_printf ("%s_dup_func", _tmp40_);
                        _tmp42_ = _tmp41_;
                        _g_free0 (_tmp40_);
                        func_name = _tmp42_;
                        _tmp45_ = vala_ccode_base_module_is_in_generic_type (self, type);
                        if (_tmp45_) {
                              _tmp44_ = !is_chainup;
                        } else {
                              _tmp44_ = FALSE;
                        }
                        if (_tmp44_) {
                              gboolean _tmp46_;
                              _tmp46_ = vala_ccode_base_module_get_in_creation_method (self);
                              _tmp43_ = !_tmp46_;
                        } else {
                              _tmp43_ = FALSE;
                        }
                        if (_tmp43_) {
                              ValaCCodeExpression* _tmp47_ = NULL;
                              ValaCCodeExpression* _tmp48_;
                              ValaCCodeMemberAccess* _tmp49_ = NULL;
                              ValaCCodeMemberAccess* _tmp50_;
                              ValaCCodeMemberAccess* _tmp51_ = NULL;
                              ValaCCodeExpression* _tmp52_;
                              _tmp47_ = vala_ccode_base_module_get_result_cexpression (self, "self");
                              _tmp48_ = _tmp47_;
                              _tmp49_ = vala_ccode_member_access_new_pointer (_tmp48_, "priv");
                              _tmp50_ = _tmp49_;
                              _tmp51_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp50_, func_name);
                              _tmp52_ = (ValaCCodeExpression*) _tmp51_;
                              _vala_ccode_node_unref0 (_tmp50_);
                              _vala_ccode_node_unref0 (_tmp48_);
                              result = _tmp52_;
                              _g_free0 (func_name);
                              return result;
                        } else {
                              ValaCCodeIdentifier* _tmp53_ = NULL;
                              _tmp53_ = vala_ccode_identifier_new (func_name);
                              result = (ValaCCodeExpression*) _tmp53_;
                              _g_free0 (func_name);
                              return result;
                        }
                        _g_free0 (func_name);
                  } else {
                        if (VALA_IS_POINTER_TYPE (type)) {
                              ValaPointerType* _tmp54_;
                              ValaPointerType* pointer_type;
                              ValaDataType* _tmp55_ = NULL;
                              ValaCCodeExpression* _tmp56_ = NULL;
                              _tmp54_ = _vala_code_node_ref0 (VALA_POINTER_TYPE (type));
                              pointer_type = _tmp54_;
                              _tmp55_ = vala_pointer_type_get_base_type (pointer_type);
                              _tmp56_ = vala_ccode_base_module_get_dup_func_expression (self, _tmp55_, source_reference, FALSE);
                              result = _tmp56_;
                              _vala_code_node_unref0 (pointer_type);
                              return result;
                        } else {
                              ValaCCodeConstant* _tmp57_ = NULL;
                              _tmp57_ = vala_ccode_constant_new ("NULL");
                              result = (ValaCCodeExpression*) _tmp57_;
                              return result;
                        }
                  }
            }
      }
}


ValaCCodeExpression* vala_ccode_base_module_get_dup_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup) {
      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) {
      ValaTypeSymbol* _tmp0_ = NULL;
      ValaTypeSymbol* _tmp1_;
      ValaStruct* _tmp2_;
      ValaStruct* left_type_as_struct;
      ValaTypeSymbol* _tmp3_ = NULL;
      ValaTypeSymbol* _tmp4_;
      ValaStruct* _tmp5_;
      ValaStruct* right_type_as_struct;
      ValaCCodeExpression* _tmp6_ = NULL;
      ValaCCodeExpression* valuecast;
      ValaCCodeExpression* _tmp9_ = NULL;
      gboolean _tmp12_ = FALSE;
      gboolean _tmp13_ = FALSE;
      gboolean _tmp14_ = FALSE;
      ValaTypeSymbol* _tmp15_ = NULL;
      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_ = vala_data_type_get_data_type (*left_type);
      _tmp1_ = _tmp0_;
      _tmp2_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp1_) ? ((ValaStruct*) _tmp1_) : NULL);
      left_type_as_struct = _tmp2_;
      _tmp3_ = vala_data_type_get_data_type (*right_type);
      _tmp4_ = _tmp3_;
      _tmp5_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp4_) ? ((ValaStruct*) _tmp4_) : NULL);
      right_type_as_struct = _tmp5_;
      _tmp6_ = vala_ccode_base_module_try_cast_value_to_type (self, *cleft, *left_type, *right_type, NULL);
      valuecast = _tmp6_;
      if (valuecast != NULL) {
            ValaCCodeExpression* _tmp7_;
            ValaDataType* _tmp8_;
            _tmp7_ = _vala_ccode_node_ref0 (valuecast);
            _vala_ccode_node_unref0 (*cleft);
            *cleft = _tmp7_;
            _tmp8_ = _vala_code_node_ref0 (*right_type);
            _vala_code_node_unref0 (*left_type);
            *left_type = _tmp8_;
            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;
      }
      _tmp9_ = vala_ccode_base_module_try_cast_value_to_type (self, *cright, *right_type, *left_type, NULL);
      _vala_ccode_node_unref0 (valuecast);
      valuecast = _tmp9_;
      if (valuecast != NULL) {
            ValaCCodeExpression* _tmp10_;
            ValaDataType* _tmp11_;
            _tmp10_ = _vala_ccode_node_ref0 (valuecast);
            _vala_ccode_node_unref0 (*cright);
            *cright = _tmp10_;
            _tmp11_ = _vala_code_node_ref0 (*left_type);
            _vala_code_node_unref0 (*right_type);
            *right_type = _tmp11_;
            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;
      }
      _tmp15_ = vala_data_type_get_data_type (*left_type);
      if (VALA_IS_CLASS (_tmp15_)) {
            ValaTypeSymbol* _tmp16_ = NULL;
            gboolean _tmp17_;
            _tmp16_ = vala_data_type_get_data_type (*left_type);
            _tmp17_ = vala_class_get_is_compact (VALA_CLASS (_tmp16_));
            _tmp14_ = !_tmp17_;
      } else {
            _tmp14_ = FALSE;
      }
      if (_tmp14_) {
            ValaTypeSymbol* _tmp18_ = NULL;
            _tmp18_ = vala_data_type_get_data_type (*right_type);
            _tmp13_ = VALA_IS_CLASS (_tmp18_);
      } else {
            _tmp13_ = FALSE;
      }
      if (_tmp13_) {
            ValaTypeSymbol* _tmp19_ = NULL;
            gboolean _tmp20_;
            _tmp19_ = vala_data_type_get_data_type (*right_type);
            _tmp20_ = vala_class_get_is_compact (VALA_CLASS (_tmp19_));
            _tmp12_ = !_tmp20_;
      } else {
            _tmp12_ = FALSE;
      }
      if (_tmp12_) {
            ValaTypeSymbol* _tmp21_ = NULL;
            ValaClass* _tmp22_;
            ValaClass* left_cl;
            ValaTypeSymbol* _tmp23_ = NULL;
            ValaClass* _tmp24_;
            ValaClass* right_cl;
            _tmp21_ = vala_data_type_get_data_type (*left_type);
            _tmp22_ = _vala_code_node_ref0 (VALA_CLASS (_tmp21_));
            left_cl = _tmp22_;
            _tmp23_ = vala_data_type_get_data_type (*right_type);
            _tmp24_ = _vala_code_node_ref0 (VALA_CLASS (_tmp23_));
            right_cl = _tmp24_;
            if (left_cl != right_cl) {
                  gboolean _tmp25_;
                  _tmp25_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) left_cl, (ValaTypeSymbol*) right_cl);
                  if (_tmp25_) {
                        ValaCCodeFunctionCall* _tmp26_ = NULL;
                        _tmp26_ = vala_ccode_base_module_generate_instance_cast (self, *cleft, (ValaTypeSymbol*) right_cl);
                        _vala_ccode_node_unref0 (*cleft);
                        *cleft = (ValaCCodeExpression*) _tmp26_;
                  } else {
                        gboolean _tmp27_;
                        _tmp27_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) right_cl, (ValaTypeSymbol*) left_cl);
                        if (_tmp27_) {
                              ValaCCodeFunctionCall* _tmp28_ = NULL;
                              _tmp28_ = vala_ccode_base_module_generate_instance_cast (self, *cright, (ValaTypeSymbol*) left_cl);
                              _vala_ccode_node_unref0 (*cright);
                              *cright = (ValaCCodeExpression*) _tmp28_;
                        }
                  }
            }
            _vala_code_node_unref0 (right_cl);
            _vala_code_node_unref0 (left_cl);
      } else {
            gboolean _tmp29_ = FALSE;
            if (left_type_as_struct != NULL) {
                  _tmp29_ = right_type_as_struct != NULL;
            } else {
                  _tmp29_ = FALSE;
            }
            if (_tmp29_) {
                  if (VALA_IS_STRUCT_VALUE_TYPE (*left_type)) {
                        gboolean _tmp30_;
                        gboolean _tmp32_;
                        _tmp30_ = vala_data_type_get_nullable (*left_type);
                        if (!_tmp30_) {
                              ValaCCodeUnaryExpression* _tmp31_ = NULL;
                              _tmp31_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, *cleft);
                              _vala_ccode_node_unref0 (*cleft);
                              *cleft = (ValaCCodeExpression*) _tmp31_;
                        }
                        _tmp32_ = vala_data_type_get_nullable (*right_type);
                        if (!_tmp32_) {
                              ValaCCodeUnaryExpression* _tmp33_ = NULL;
                              _tmp33_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, *cright);
                              _vala_ccode_node_unref0 (*cright);
                              *cright = (ValaCCodeExpression*) _tmp33_;
                        }
                  } else {
                        gboolean _tmp34_ = FALSE;
                        gboolean _tmp35_;
                        _tmp35_ = vala_data_type_get_nullable (*left_type);
                        if (_tmp35_) {
                              gboolean _tmp36_;
                              _tmp36_ = vala_data_type_get_nullable (*right_type);
                              _tmp34_ = _tmp36_;
                        } else {
                              _tmp34_ = FALSE;
                        }
                        if (_tmp34_) {
                        } else {
                              gboolean _tmp37_;
                              _tmp37_ = vala_data_type_get_nullable (*left_type);
                              if (_tmp37_) {
                                    ValaCCodeUnaryExpression* _tmp38_ = NULL;
                                    _tmp38_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, *cleft);
                                    _vala_ccode_node_unref0 (*cleft);
                                    *cleft = (ValaCCodeExpression*) _tmp38_;
                              } else {
                                    gboolean _tmp39_;
                                    _tmp39_ = vala_data_type_get_nullable (*right_type);
                                    if (_tmp39_) {
                                          ValaCCodeUnaryExpression* _tmp40_ = NULL;
                                          _tmp40_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, *cright);
                                          _vala_ccode_node_unref0 (*cright);
                                          *cright = (ValaCCodeExpression*) _tmp40_;
                                    }
                              }
                        }
                  }
            }
      }
      _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;
      gchar* _tmp0_ = NULL;
      gchar* _tmp1_;
      gchar* _tmp2_ = NULL;
      gchar* _tmp3_;
      gchar* equal_func;
      gboolean _tmp4_;
      ValaCCodeFunction* _tmp5_ = NULL;
      ValaCCodeFunction* function;
      gchar* _tmp6_ = NULL;
      gchar* _tmp7_;
      gchar* _tmp8_;
      gchar* _tmp9_;
      gchar* _tmp10_;
      gchar* _tmp11_;
      ValaCCodeParameter* _tmp12_ = NULL;
      ValaCCodeParameter* _tmp13_;
      gchar* _tmp14_ = NULL;
      gchar* _tmp15_;
      gchar* _tmp16_;
      gchar* _tmp17_;
      gchar* _tmp18_;
      gchar* _tmp19_;
      ValaCCodeParameter* _tmp20_ = NULL;
      ValaCCodeParameter* _tmp21_;
      ValaList* _tmp95_ = NULL;
      ValaList* _tmp96_;
      gint _tmp97_;
      gboolean _tmp98_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (st != NULL, NULL);
      _tmp0_ = vala_symbol_get_lower_case_cprefix ((ValaSymbol*) st);
      _tmp1_ = _tmp0_;
      _tmp2_ = g_strdup_printf ("_%sequal", _tmp1_);
      _tmp3_ = _tmp2_;
      _g_free0 (_tmp1_);
      equal_func = _tmp3_;
      _tmp4_ = vala_ccode_base_module_add_wrapper (self, equal_func);
      if (!_tmp4_) {
            result = equal_func;
            return result;
      }
      _tmp5_ = vala_ccode_function_new (equal_func, "gboolean");
      function = _tmp5_;
      vala_ccode_function_set_modifiers (function, VALA_CCODE_MODIFIERS_STATIC);
      _tmp6_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) st, FALSE);
      _tmp7_ = _tmp6_;
      _tmp8_ = g_strconcat ("const ", _tmp7_, NULL);
      _tmp9_ = _tmp8_;
      _tmp10_ = g_strconcat (_tmp9_, "*", NULL);
      _tmp11_ = _tmp10_;
      _tmp12_ = vala_ccode_parameter_new ("s1", _tmp11_);
      _tmp13_ = _tmp12_;
      vala_ccode_function_add_parameter (function, _tmp13_);
      _vala_ccode_node_unref0 (_tmp13_);
      _g_free0 (_tmp11_);
      _g_free0 (_tmp9_);
      _g_free0 (_tmp7_);
      _tmp14_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) st, FALSE);
      _tmp15_ = _tmp14_;
      _tmp16_ = g_strconcat ("const ", _tmp15_, NULL);
      _tmp17_ = _tmp16_;
      _tmp18_ = g_strconcat (_tmp17_, "*", NULL);
      _tmp19_ = _tmp18_;
      _tmp20_ = vala_ccode_parameter_new ("s2", _tmp19_);
      _tmp21_ = _tmp20_;
      vala_ccode_function_add_parameter (function, _tmp21_);
      _vala_ccode_node_unref0 (_tmp21_);
      _g_free0 (_tmp19_);
      _g_free0 (_tmp17_);
      _g_free0 (_tmp15_);
      vala_ccode_base_module_push_function (self, function);
      {
            ValaCCodeIdentifier* _tmp22_ = NULL;
            ValaCCodeIdentifier* _tmp23_;
            ValaCCodeIdentifier* _tmp24_ = NULL;
            ValaCCodeIdentifier* _tmp25_;
            ValaCCodeBinaryExpression* _tmp26_ = NULL;
            ValaCCodeBinaryExpression* _tmp27_;
            ValaCCodeBinaryExpression* cexp;
            ValaCCodeFunction* _tmp28_ = NULL;
            ValaCCodeFunction* _tmp29_ = NULL;
            ValaCCodeConstant* _tmp30_ = NULL;
            ValaCCodeConstant* _tmp31_;
            ValaCCodeFunction* _tmp32_ = NULL;
            _tmp22_ = vala_ccode_identifier_new ("s1");
            _tmp23_ = _tmp22_;
            _tmp24_ = vala_ccode_identifier_new ("s2");
            _tmp25_ = _tmp24_;
            _tmp26_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp23_, (ValaCCodeExpression*) _tmp25_);
            _tmp27_ = _tmp26_;
            _vala_ccode_node_unref0 (_tmp25_);
            _vala_ccode_node_unref0 (_tmp23_);
            cexp = _tmp27_;
            _tmp28_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_open_if (_tmp28_, (ValaCCodeExpression*) cexp);
            _tmp29_ = vala_ccode_base_module_get_ccode (self);
            _tmp30_ = vala_ccode_constant_new ("TRUE");
            _tmp31_ = _tmp30_;
            vala_ccode_function_add_return (_tmp29_, (ValaCCodeExpression*) _tmp31_);
            _vala_ccode_node_unref0 (_tmp31_);
            _tmp32_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_close (_tmp32_);
            _vala_ccode_node_unref0 (cexp);
      }
      {
            ValaCCodeIdentifier* _tmp33_ = NULL;
            ValaCCodeIdentifier* _tmp34_;
            ValaCCodeConstant* _tmp35_ = NULL;
            ValaCCodeConstant* _tmp36_;
            ValaCCodeBinaryExpression* _tmp37_ = NULL;
            ValaCCodeBinaryExpression* _tmp38_;
            ValaCCodeBinaryExpression* cexp;
            ValaCCodeFunction* _tmp39_ = NULL;
            ValaCCodeFunction* _tmp40_ = NULL;
            ValaCCodeConstant* _tmp41_ = NULL;
            ValaCCodeConstant* _tmp42_;
            ValaCCodeFunction* _tmp43_ = NULL;
            ValaCCodeIdentifier* _tmp44_ = NULL;
            ValaCCodeIdentifier* _tmp45_;
            ValaCCodeConstant* _tmp46_ = NULL;
            ValaCCodeConstant* _tmp47_;
            ValaCCodeBinaryExpression* _tmp48_ = NULL;
            ValaCCodeFunction* _tmp49_ = NULL;
            ValaCCodeFunction* _tmp50_ = NULL;
            ValaCCodeConstant* _tmp51_ = NULL;
            ValaCCodeConstant* _tmp52_;
            ValaCCodeFunction* _tmp53_ = NULL;
            _tmp33_ = vala_ccode_identifier_new ("s1");
            _tmp34_ = _tmp33_;
            _tmp35_ = vala_ccode_constant_new ("NULL");
            _tmp36_ = _tmp35_;
            _tmp37_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp34_, (ValaCCodeExpression*) _tmp36_);
            _tmp38_ = _tmp37_;
            _vala_ccode_node_unref0 (_tmp36_);
            _vala_ccode_node_unref0 (_tmp34_);
            cexp = _tmp38_;
            _tmp39_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_open_if (_tmp39_, (ValaCCodeExpression*) cexp);
            _tmp40_ = vala_ccode_base_module_get_ccode (self);
            _tmp41_ = vala_ccode_constant_new ("FALSE");
            _tmp42_ = _tmp41_;
            vala_ccode_function_add_return (_tmp40_, (ValaCCodeExpression*) _tmp42_);
            _vala_ccode_node_unref0 (_tmp42_);
            _tmp43_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_close (_tmp43_);
            _tmp44_ = vala_ccode_identifier_new ("s2");
            _tmp45_ = _tmp44_;
            _tmp46_ = vala_ccode_constant_new ("NULL");
            _tmp47_ = _tmp46_;
            _tmp48_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp45_, (ValaCCodeExpression*) _tmp47_);
            _vala_ccode_node_unref0 (cexp);
            cexp = _tmp48_;
            _vala_ccode_node_unref0 (_tmp47_);
            _vala_ccode_node_unref0 (_tmp45_);
            _tmp49_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_open_if (_tmp49_, (ValaCCodeExpression*) cexp);
            _tmp50_ = vala_ccode_base_module_get_ccode (self);
            _tmp51_ = vala_ccode_constant_new ("FALSE");
            _tmp52_ = _tmp51_;
            vala_ccode_function_add_return (_tmp50_, (ValaCCodeExpression*) _tmp52_);
            _vala_ccode_node_unref0 (_tmp52_);
            _tmp53_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_close (_tmp53_);
            _vala_ccode_node_unref0 (cexp);
      }
      {
            ValaList* _tmp54_ = NULL;
            ValaList* _f_list;
            gint _tmp55_;
            gint _f_size;
            gint _f_index;
            _tmp54_ = vala_struct_get_fields (st);
            _f_list = _tmp54_;
            _tmp55_ = vala_collection_get_size ((ValaCollection*) _f_list);
            _f_size = _tmp55_;
            _f_index = -1;
            while (TRUE) {
                  gpointer _tmp56_ = NULL;
                  ValaField* f;
                  ValaMemberBinding _tmp57_;
                  ValaCCodeExpression* cexp = NULL;
                  ValaCCodeIdentifier* _tmp58_ = NULL;
                  ValaCCodeIdentifier* _tmp59_;
                  const gchar* _tmp60_ = NULL;
                  ValaCCodeMemberAccess* _tmp61_ = NULL;
                  ValaCCodeExpression* _tmp62_;
                  ValaCCodeExpression* s1;
                  ValaCCodeIdentifier* _tmp63_ = NULL;
                  ValaCCodeIdentifier* _tmp64_;
                  const gchar* _tmp65_ = NULL;
                  ValaCCodeMemberAccess* _tmp66_ = NULL;
                  ValaCCodeExpression* _tmp67_;
                  ValaCCodeExpression* s2;
                  ValaDataType* _tmp68_ = NULL;
                  ValaDataType* _tmp69_ = NULL;
                  ValaDataType* variable_type;
                  gboolean _tmp70_ = FALSE;
                  ValaDataType* _tmp71_ = NULL;
                  ValaCCodeFunction* _tmp90_ = NULL;
                  ValaCCodeFunction* _tmp91_ = NULL;
                  ValaCCodeConstant* _tmp92_ = NULL;
                  ValaCCodeConstant* _tmp93_;
                  ValaCCodeFunction* _tmp94_ = NULL;
                  _f_index = _f_index + 1;
                  if (!(_f_index < _f_size)) {
                        break;
                  }
                  _tmp56_ = vala_list_get (_f_list, _f_index);
                  f = (ValaField*) _tmp56_;
                  _tmp57_ = vala_field_get_binding (f);
                  if (_tmp57_ != VALA_MEMBER_BINDING_INSTANCE) {
                        _vala_code_node_unref0 (f);
                        continue;
                  }
                  _tmp58_ = vala_ccode_identifier_new ("s1");
                  _tmp59_ = _tmp58_;
                  _tmp60_ = vala_symbol_get_name ((ValaSymbol*) f);
                  _tmp61_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp59_, _tmp60_);
                  _tmp62_ = VALA_CCODE_EXPRESSION (_tmp61_);
                  _vala_ccode_node_unref0 (_tmp59_);
                  s1 = _tmp62_;
                  _tmp63_ = vala_ccode_identifier_new ("s2");
                  _tmp64_ = _tmp63_;
                  _tmp65_ = vala_symbol_get_name ((ValaSymbol*) f);
                  _tmp66_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp64_, _tmp65_);
                  _tmp67_ = VALA_CCODE_EXPRESSION (_tmp66_);
                  _vala_ccode_node_unref0 (_tmp64_);
                  s2 = _tmp67_;
                  _tmp68_ = vala_variable_get_variable_type ((ValaVariable*) f);
                  _tmp69_ = vala_data_type_copy (_tmp68_);
                  variable_type = _tmp69_;
                  vala_ccode_base_module_make_comparable_cexpression (self, &variable_type, &s1, &variable_type, &s2);
                  _tmp71_ = vala_variable_get_variable_type ((ValaVariable*) f);
                  if (!VALA_IS_NULL_TYPE (_tmp71_)) {
                        ValaDataType* _tmp72_ = NULL;
                        gboolean _tmp73_;
                        _tmp72_ = vala_variable_get_variable_type ((ValaVariable*) f);
                        _tmp73_ = vala_data_type_compatible (_tmp72_, self->string_type);
                        _tmp70_ = _tmp73_;
                  } else {
                        _tmp70_ = FALSE;
                  }
                  if (_tmp70_) {
                        ValaCCodeIdentifier* _tmp74_ = NULL;
                        ValaCCodeIdentifier* _tmp75_;
                        ValaCCodeFunctionCall* _tmp76_ = NULL;
                        ValaCCodeFunctionCall* _tmp77_;
                        ValaCCodeFunctionCall* ccall;
                        ValaCCodeExpression* _tmp78_;
                        _tmp74_ = vala_ccode_identifier_new ("g_strcmp0");
                        _tmp75_ = _tmp74_;
                        _tmp76_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp75_);
                        _tmp77_ = _tmp76_;
                        _vala_ccode_node_unref0 (_tmp75_);
                        ccall = _tmp77_;
                        vala_ccode_function_call_add_argument (ccall, s1);
                        vala_ccode_function_call_add_argument (ccall, s2);
                        _tmp78_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) ccall);
                        _vala_ccode_node_unref0 (cexp);
                        cexp = _tmp78_;
                        _vala_ccode_node_unref0 (ccall);
                  } else {
                        ValaDataType* _tmp79_ = NULL;
                        _tmp79_ = vala_variable_get_variable_type ((ValaVariable*) f);
                        if (VALA_IS_STRUCT_VALUE_TYPE (_tmp79_)) {
                              ValaDataType* _tmp80_ = NULL;
                              ValaTypeSymbol* _tmp81_ = NULL;
                              ValaTypeSymbol* _tmp82_;
                              gchar* _tmp83_ = NULL;
                              gchar* equalfunc;
                              ValaCCodeIdentifier* _tmp84_ = NULL;
                              ValaCCodeIdentifier* _tmp85_;
                              ValaCCodeFunctionCall* _tmp86_ = NULL;
                              ValaCCodeFunctionCall* _tmp87_;
                              ValaCCodeFunctionCall* ccall;
                              ValaCCodeUnaryExpression* _tmp88_ = NULL;
                              _tmp80_ = vala_variable_get_variable_type ((ValaVariable*) f);
                              _tmp81_ = vala_data_type_get_data_type (_tmp80_);
                              _tmp82_ = _tmp81_;
                              _tmp83_ = vala_ccode_base_module_generate_struct_equal_function (self, VALA_IS_STRUCT (_tmp82_) ? ((ValaStruct*) _tmp82_) : NULL);
                              equalfunc = _tmp83_;
                              _tmp84_ = vala_ccode_identifier_new (equalfunc);
                              _tmp85_ = _tmp84_;
                              _tmp86_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp85_);
                              _tmp87_ = _tmp86_;
                              _vala_ccode_node_unref0 (_tmp85_);
                              ccall = _tmp87_;
                              vala_ccode_function_call_add_argument (ccall, s1);
                              vala_ccode_function_call_add_argument (ccall, s2);
                              _tmp88_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) ccall);
                              _vala_ccode_node_unref0 (cexp);
                              cexp = (ValaCCodeExpression*) _tmp88_;
                              _vala_ccode_node_unref0 (ccall);
                              _g_free0 (equalfunc);
                        } else {
                              ValaCCodeBinaryExpression* _tmp89_ = NULL;
                              _tmp89_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, s1, s2);
                              _vala_ccode_node_unref0 (cexp);
                              cexp = (ValaCCodeExpression*) _tmp89_;
                        }
                  }
                  _tmp90_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_open_if (_tmp90_, cexp);
                  _tmp91_ = vala_ccode_base_module_get_ccode (self);
                  _tmp92_ = vala_ccode_constant_new ("FALSE");
                  _tmp93_ = _tmp92_;
                  vala_ccode_function_add_return (_tmp91_, (ValaCCodeExpression*) _tmp93_);
                  _vala_ccode_node_unref0 (_tmp93_);
                  _tmp94_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_close (_tmp94_);
                  _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);
      }
      _tmp95_ = vala_struct_get_fields (st);
      _tmp96_ = _tmp95_;
      _tmp97_ = vala_collection_get_size ((ValaCollection*) _tmp96_);
      _tmp98_ = _tmp97_ == 0;
      _vala_iterable_unref0 (_tmp96_);
      if (_tmp98_) {
            gboolean _tmp99_;
            _tmp99_ = vala_struct_is_simple_type (st);
            if (_tmp99_) {
                  ValaCCodeIdentifier* _tmp100_ = NULL;
                  ValaCCodeIdentifier* _tmp101_;
                  ValaCCodeUnaryExpression* _tmp102_ = NULL;
                  ValaCCodeUnaryExpression* _tmp103_;
                  ValaCCodeIdentifier* _tmp104_ = NULL;
                  ValaCCodeIdentifier* _tmp105_;
                  ValaCCodeUnaryExpression* _tmp106_ = NULL;
                  ValaCCodeUnaryExpression* _tmp107_;
                  ValaCCodeBinaryExpression* _tmp108_ = NULL;
                  ValaCCodeBinaryExpression* _tmp109_;
                  ValaCCodeBinaryExpression* cexp;
                  ValaCCodeFunction* _tmp110_ = NULL;
                  _tmp100_ = vala_ccode_identifier_new ("s1");
                  _tmp101_ = _tmp100_;
                  _tmp102_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp101_);
                  _tmp103_ = _tmp102_;
                  _tmp104_ = vala_ccode_identifier_new ("s2");
                  _tmp105_ = _tmp104_;
                  _tmp106_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp105_);
                  _tmp107_ = _tmp106_;
                  _tmp108_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp103_, (ValaCCodeExpression*) _tmp107_);
                  _tmp109_ = _tmp108_;
                  _vala_ccode_node_unref0 (_tmp107_);
                  _vala_ccode_node_unref0 (_tmp105_);
                  _vala_ccode_node_unref0 (_tmp103_);
                  _vala_ccode_node_unref0 (_tmp101_);
                  cexp = _tmp109_;
                  _tmp110_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_return (_tmp110_, (ValaCCodeExpression*) cexp);
                  _vala_ccode_node_unref0 (cexp);
            } else {
                  ValaCCodeFunction* _tmp111_ = NULL;
                  ValaCCodeConstant* _tmp112_ = NULL;
                  ValaCCodeConstant* _tmp113_;
                  _tmp111_ = vala_ccode_base_module_get_ccode (self);
                  _tmp112_ = vala_ccode_constant_new ("FALSE");
                  _tmp113_ = _tmp112_;
                  vala_ccode_function_add_return (_tmp111_, (ValaCCodeExpression*) _tmp113_);
                  _vala_ccode_node_unref0 (_tmp113_);
            }
      } else {
            ValaCCodeFunction* _tmp114_ = NULL;
            ValaCCodeConstant* _tmp115_ = NULL;
            ValaCCodeConstant* _tmp116_;
            _tmp114_ = vala_ccode_base_module_get_ccode (self);
            _tmp115_ = vala_ccode_constant_new ("TRUE");
            _tmp116_ = _tmp115_;
            vala_ccode_function_add_return (_tmp114_, (ValaCCodeExpression*) _tmp116_);
            _vala_ccode_node_unref0 (_tmp116_);
      }
      vala_ccode_base_module_pop_function (self);
      vala_ccode_file_add_function_declaration (self->cfile, function);
      vala_ccode_file_add_function (self->cfile, function);
      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* _tmp0_ = NULL;
      gchar* _tmp1_;
      gchar* _tmp2_ = NULL;
      gchar* _tmp3_;
      gchar* equal_func;
      gboolean _tmp4_;
      ValaCCodeFunction* _tmp5_ = NULL;
      ValaCCodeFunction* function;
      gchar* _tmp6_ = NULL;
      gchar* _tmp7_;
      gchar* _tmp8_;
      gchar* _tmp9_;
      gchar* _tmp10_;
      gchar* _tmp11_;
      ValaCCodeParameter* _tmp12_ = NULL;
      ValaCCodeParameter* _tmp13_;
      gchar* _tmp14_ = NULL;
      gchar* _tmp15_;
      gchar* _tmp16_;
      gchar* _tmp17_;
      gchar* _tmp18_;
      gchar* _tmp19_;
      ValaCCodeParameter* _tmp20_ = NULL;
      ValaCCodeParameter* _tmp21_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (sym != NULL, NULL);
      _tmp0_ = vala_symbol_get_lower_case_cprefix ((ValaSymbol*) sym);
      _tmp1_ = _tmp0_;
      _tmp2_ = g_strdup_printf ("_%sequal", _tmp1_);
      _tmp3_ = _tmp2_;
      _g_free0 (_tmp1_);
      equal_func = _tmp3_;
      _tmp4_ = vala_ccode_base_module_add_wrapper (self, equal_func);
      if (!_tmp4_) {
            result = equal_func;
            return result;
      }
      _tmp5_ = vala_ccode_function_new (equal_func, "gboolean");
      function = _tmp5_;
      vala_ccode_function_set_modifiers (function, VALA_CCODE_MODIFIERS_STATIC);
      _tmp6_ = vala_typesymbol_get_cname (sym, FALSE);
      _tmp7_ = _tmp6_;
      _tmp8_ = g_strconcat ("const ", _tmp7_, NULL);
      _tmp9_ = _tmp8_;
      _tmp10_ = g_strconcat (_tmp9_, "*", NULL);
      _tmp11_ = _tmp10_;
      _tmp12_ = vala_ccode_parameter_new ("s1", _tmp11_);
      _tmp13_ = _tmp12_;
      vala_ccode_function_add_parameter (function, _tmp13_);
      _vala_ccode_node_unref0 (_tmp13_);
      _g_free0 (_tmp11_);
      _g_free0 (_tmp9_);
      _g_free0 (_tmp7_);
      _tmp14_ = vala_typesymbol_get_cname (sym, FALSE);
      _tmp15_ = _tmp14_;
      _tmp16_ = g_strconcat ("const ", _tmp15_, NULL);
      _tmp17_ = _tmp16_;
      _tmp18_ = g_strconcat (_tmp17_, "*", NULL);
      _tmp19_ = _tmp18_;
      _tmp20_ = vala_ccode_parameter_new ("s2", _tmp19_);
      _tmp21_ = _tmp20_;
      vala_ccode_function_add_parameter (function, _tmp21_);
      _vala_ccode_node_unref0 (_tmp21_);
      _g_free0 (_tmp19_);
      _g_free0 (_tmp17_);
      _g_free0 (_tmp15_);
      vala_ccode_base_module_push_function (self, function);
      {
            ValaCCodeIdentifier* _tmp22_ = NULL;
            ValaCCodeIdentifier* _tmp23_;
            ValaCCodeIdentifier* _tmp24_ = NULL;
            ValaCCodeIdentifier* _tmp25_;
            ValaCCodeBinaryExpression* _tmp26_ = NULL;
            ValaCCodeBinaryExpression* _tmp27_;
            ValaCCodeBinaryExpression* cexp;
            ValaCCodeFunction* _tmp28_ = NULL;
            ValaCCodeFunction* _tmp29_ = NULL;
            ValaCCodeConstant* _tmp30_ = NULL;
            ValaCCodeConstant* _tmp31_;
            ValaCCodeFunction* _tmp32_ = NULL;
            _tmp22_ = vala_ccode_identifier_new ("s1");
            _tmp23_ = _tmp22_;
            _tmp24_ = vala_ccode_identifier_new ("s2");
            _tmp25_ = _tmp24_;
            _tmp26_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp23_, (ValaCCodeExpression*) _tmp25_);
            _tmp27_ = _tmp26_;
            _vala_ccode_node_unref0 (_tmp25_);
            _vala_ccode_node_unref0 (_tmp23_);
            cexp = _tmp27_;
            _tmp28_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_open_if (_tmp28_, (ValaCCodeExpression*) cexp);
            _tmp29_ = vala_ccode_base_module_get_ccode (self);
            _tmp30_ = vala_ccode_constant_new ("TRUE");
            _tmp31_ = _tmp30_;
            vala_ccode_function_add_return (_tmp29_, (ValaCCodeExpression*) _tmp31_);
            _vala_ccode_node_unref0 (_tmp31_);
            _tmp32_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_close (_tmp32_);
            _vala_ccode_node_unref0 (cexp);
      }
      {
            ValaCCodeIdentifier* _tmp33_ = NULL;
            ValaCCodeIdentifier* _tmp34_;
            ValaCCodeConstant* _tmp35_ = NULL;
            ValaCCodeConstant* _tmp36_;
            ValaCCodeBinaryExpression* _tmp37_ = NULL;
            ValaCCodeBinaryExpression* _tmp38_;
            ValaCCodeBinaryExpression* cexp;
            ValaCCodeFunction* _tmp39_ = NULL;
            ValaCCodeFunction* _tmp40_ = NULL;
            ValaCCodeConstant* _tmp41_ = NULL;
            ValaCCodeConstant* _tmp42_;
            ValaCCodeFunction* _tmp43_ = NULL;
            ValaCCodeIdentifier* _tmp44_ = NULL;
            ValaCCodeIdentifier* _tmp45_;
            ValaCCodeConstant* _tmp46_ = NULL;
            ValaCCodeConstant* _tmp47_;
            ValaCCodeBinaryExpression* _tmp48_ = NULL;
            ValaCCodeFunction* _tmp49_ = NULL;
            ValaCCodeFunction* _tmp50_ = NULL;
            ValaCCodeConstant* _tmp51_ = NULL;
            ValaCCodeConstant* _tmp52_;
            ValaCCodeFunction* _tmp53_ = NULL;
            _tmp33_ = vala_ccode_identifier_new ("s1");
            _tmp34_ = _tmp33_;
            _tmp35_ = vala_ccode_constant_new ("NULL");
            _tmp36_ = _tmp35_;
            _tmp37_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp34_, (ValaCCodeExpression*) _tmp36_);
            _tmp38_ = _tmp37_;
            _vala_ccode_node_unref0 (_tmp36_);
            _vala_ccode_node_unref0 (_tmp34_);
            cexp = _tmp38_;
            _tmp39_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_open_if (_tmp39_, (ValaCCodeExpression*) cexp);
            _tmp40_ = vala_ccode_base_module_get_ccode (self);
            _tmp41_ = vala_ccode_constant_new ("FALSE");
            _tmp42_ = _tmp41_;
            vala_ccode_function_add_return (_tmp40_, (ValaCCodeExpression*) _tmp42_);
            _vala_ccode_node_unref0 (_tmp42_);
            _tmp43_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_close (_tmp43_);
            _tmp44_ = vala_ccode_identifier_new ("s2");
            _tmp45_ = _tmp44_;
            _tmp46_ = vala_ccode_constant_new ("NULL");
            _tmp47_ = _tmp46_;
            _tmp48_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp45_, (ValaCCodeExpression*) _tmp47_);
            _vala_ccode_node_unref0 (cexp);
            cexp = _tmp48_;
            _vala_ccode_node_unref0 (_tmp47_);
            _vala_ccode_node_unref0 (_tmp45_);
            _tmp49_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_open_if (_tmp49_, (ValaCCodeExpression*) cexp);
            _tmp50_ = vala_ccode_base_module_get_ccode (self);
            _tmp51_ = vala_ccode_constant_new ("FALSE");
            _tmp52_ = _tmp51_;
            vala_ccode_function_add_return (_tmp50_, (ValaCCodeExpression*) _tmp52_);
            _vala_ccode_node_unref0 (_tmp52_);
            _tmp53_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_close (_tmp53_);
            _vala_ccode_node_unref0 (cexp);
      }
      {
            ValaCCodeIdentifier* _tmp54_ = NULL;
            ValaCCodeIdentifier* _tmp55_;
            ValaCCodeUnaryExpression* _tmp56_ = NULL;
            ValaCCodeUnaryExpression* _tmp57_;
            ValaCCodeIdentifier* _tmp58_ = NULL;
            ValaCCodeIdentifier* _tmp59_;
            ValaCCodeUnaryExpression* _tmp60_ = NULL;
            ValaCCodeUnaryExpression* _tmp61_;
            ValaCCodeBinaryExpression* _tmp62_ = NULL;
            ValaCCodeBinaryExpression* _tmp63_;
            ValaCCodeBinaryExpression* cexp;
            ValaCCodeFunction* _tmp64_ = NULL;
            _tmp54_ = vala_ccode_identifier_new ("s1");
            _tmp55_ = _tmp54_;
            _tmp56_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp55_);
            _tmp57_ = _tmp56_;
            _tmp58_ = vala_ccode_identifier_new ("s2");
            _tmp59_ = _tmp58_;
            _tmp60_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp59_);
            _tmp61_ = _tmp60_;
            _tmp62_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp57_, (ValaCCodeExpression*) _tmp61_);
            _tmp63_ = _tmp62_;
            _vala_ccode_node_unref0 (_tmp61_);
            _vala_ccode_node_unref0 (_tmp59_);
            _vala_ccode_node_unref0 (_tmp57_);
            _vala_ccode_node_unref0 (_tmp55_);
            cexp = _tmp63_;
            _tmp64_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_return (_tmp64_, (ValaCCodeExpression*) cexp);
            _vala_ccode_node_unref0 (cexp);
      }
      vala_ccode_base_module_pop_function (self);
      vala_ccode_file_add_function_declaration (self->cfile, function);
      vala_ccode_file_add_function (self->cfile, function);
      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;
      ValaTypeSymbol* _tmp0_ = NULL;
      gchar* _tmp1_ = NULL;
      gchar* _tmp2_;
      gchar* _tmp3_ = NULL;
      gchar* _tmp4_;
      gchar* dup_func;
      gboolean _tmp5_;
      gchar* _tmp6_ = NULL;
      gchar* _tmp7_;
      ValaCCodeFunction* _tmp8_ = NULL;
      ValaCCodeFunction* _tmp9_;
      ValaCCodeFunction* function;
      gchar* _tmp10_ = NULL;
      gchar* _tmp11_;
      ValaCCodeParameter* _tmp12_ = NULL;
      ValaCCodeParameter* _tmp13_;
      ValaTypeSymbol* _tmp14_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (value_type != NULL, NULL);
      _tmp0_ = vala_value_type_get_type_symbol (value_type);
      _tmp1_ = vala_symbol_get_lower_case_cprefix ((ValaSymbol*) _tmp0_);
      _tmp2_ = _tmp1_;
      _tmp3_ = g_strdup_printf ("_%sdup", _tmp2_);
      _tmp4_ = _tmp3_;
      _g_free0 (_tmp2_);
      dup_func = _tmp4_;
      _tmp5_ = vala_ccode_base_module_add_wrapper (self, dup_func);
      if (!_tmp5_) {
            result = dup_func;
            return result;
      }
      _tmp6_ = vala_data_type_get_cname ((ValaDataType*) value_type);
      _tmp7_ = _tmp6_;
      _tmp8_ = vala_ccode_function_new (dup_func, _tmp7_);
      _tmp9_ = _tmp8_;
      _g_free0 (_tmp7_);
      function = _tmp9_;
      vala_ccode_function_set_modifiers (function, VALA_CCODE_MODIFIERS_STATIC);
      _tmp10_ = vala_data_type_get_cname ((ValaDataType*) value_type);
      _tmp11_ = _tmp10_;
      _tmp12_ = vala_ccode_parameter_new ("self", _tmp11_);
      _tmp13_ = _tmp12_;
      vala_ccode_function_add_parameter (function, _tmp13_);
      _vala_ccode_node_unref0 (_tmp13_);
      _g_free0 (_tmp11_);
      vala_ccode_base_module_push_function (self, function);
      _tmp14_ = vala_value_type_get_type_symbol (value_type);
      if (_tmp14_ == VALA_TYPESYMBOL (self->gvalue_type)) {
            ValaCCodeIdentifier* _tmp15_ = NULL;
            ValaCCodeIdentifier* _tmp16_;
            ValaCCodeFunctionCall* _tmp17_ = NULL;
            ValaCCodeFunctionCall* _tmp18_;
            ValaCCodeFunctionCall* dup_call;
            ValaCCodeIdentifier* _tmp19_ = NULL;
            ValaCCodeIdentifier* _tmp20_;
            ValaCCodeIdentifier* _tmp21_ = NULL;
            ValaCCodeIdentifier* _tmp22_;
            ValaCCodeFunction* _tmp23_ = NULL;
            _tmp15_ = vala_ccode_identifier_new ("g_boxed_copy");
            _tmp16_ = _tmp15_;
            _tmp17_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp16_);
            _tmp18_ = _tmp17_;
            _vala_ccode_node_unref0 (_tmp16_);
            dup_call = _tmp18_;
            _tmp19_ = vala_ccode_identifier_new ("G_TYPE_VALUE");
            _tmp20_ = _tmp19_;
            vala_ccode_function_call_add_argument (dup_call, (ValaCCodeExpression*) _tmp20_);
            _vala_ccode_node_unref0 (_tmp20_);
            _tmp21_ = vala_ccode_identifier_new ("self");
            _tmp22_ = _tmp21_;
            vala_ccode_function_call_add_argument (dup_call, (ValaCCodeExpression*) _tmp22_);
            _vala_ccode_node_unref0 (_tmp22_);
            _tmp23_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_return (_tmp23_, (ValaCCodeExpression*) dup_call);
            _vala_ccode_node_unref0 (dup_call);
      } else {
            ValaCCodeFunction* _tmp24_ = NULL;
            gchar* _tmp25_ = NULL;
            gchar* _tmp26_;
            ValaCCodeVariableDeclarator* _tmp27_ = NULL;
            ValaCCodeVariableDeclarator* _tmp28_;
            ValaCCodeIdentifier* _tmp29_ = NULL;
            ValaCCodeIdentifier* _tmp30_;
            ValaCCodeFunctionCall* _tmp31_ = NULL;
            ValaCCodeFunctionCall* _tmp32_;
            ValaCCodeFunctionCall* creation_call;
            ValaTypeSymbol* _tmp33_ = NULL;
            gchar* _tmp34_ = NULL;
            gchar* _tmp35_;
            ValaCCodeConstant* _tmp36_ = NULL;
            ValaCCodeConstant* _tmp37_;
            ValaCCodeConstant* _tmp38_ = NULL;
            ValaCCodeConstant* _tmp39_;
            ValaCCodeFunction* _tmp40_ = NULL;
            ValaCCodeIdentifier* _tmp41_ = NULL;
            ValaCCodeIdentifier* _tmp42_;
            ValaTypeSymbol* _tmp43_ = NULL;
            ValaTypeSymbol* _tmp44_;
            ValaStruct* _tmp45_;
            ValaStruct* st;
            gboolean _tmp46_ = FALSE;
            ValaCCodeFunction* _tmp78_ = NULL;
            ValaCCodeIdentifier* _tmp79_ = NULL;
            ValaCCodeIdentifier* _tmp80_;
            _tmp24_ = vala_ccode_base_module_get_ccode (self);
            _tmp25_ = vala_data_type_get_cname ((ValaDataType*) value_type);
            _tmp26_ = _tmp25_;
            _tmp27_ = vala_ccode_variable_declarator_new ("dup", NULL, NULL);
            _tmp28_ = _tmp27_;
            vala_ccode_function_add_declaration (_tmp24_, _tmp26_, (ValaCCodeDeclarator*) _tmp28_, 0);
            _vala_ccode_node_unref0 (_tmp28_);
            _g_free0 (_tmp26_);
            _tmp29_ = vala_ccode_identifier_new ("g_new0");
            _tmp30_ = _tmp29_;
            _tmp31_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp30_);
            _tmp32_ = _tmp31_;
            _vala_ccode_node_unref0 (_tmp30_);
            creation_call = _tmp32_;
            _tmp33_ = vala_data_type_get_data_type ((ValaDataType*) value_type);
            _tmp34_ = vala_typesymbol_get_cname (_tmp33_, FALSE);
            _tmp35_ = _tmp34_;
            _tmp36_ = vala_ccode_constant_new (_tmp35_);
            _tmp37_ = _tmp36_;
            vala_ccode_function_call_add_argument (creation_call, (ValaCCodeExpression*) _tmp37_);
            _vala_ccode_node_unref0 (_tmp37_);
            _g_free0 (_tmp35_);
            _tmp38_ = vala_ccode_constant_new ("1");
            _tmp39_ = _tmp38_;
            vala_ccode_function_call_add_argument (creation_call, (ValaCCodeExpression*) _tmp39_);
            _vala_ccode_node_unref0 (_tmp39_);
            _tmp40_ = vala_ccode_base_module_get_ccode (self);
            _tmp41_ = vala_ccode_identifier_new ("dup");
            _tmp42_ = _tmp41_;
            vala_ccode_function_add_assignment (_tmp40_, (ValaCCodeExpression*) _tmp42_, (ValaCCodeExpression*) creation_call);
            _vala_ccode_node_unref0 (_tmp42_);
            _tmp43_ = vala_data_type_get_data_type ((ValaDataType*) value_type);
            _tmp44_ = _tmp43_;
            _tmp45_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp44_) ? ((ValaStruct*) _tmp44_) : NULL);
            st = _tmp45_;
            if (st != NULL) {
                  gboolean _tmp47_;
                  _tmp47_ = vala_struct_is_disposable (st);
                  _tmp46_ = _tmp47_;
            } else {
                  _tmp46_ = FALSE;
            }
            if (_tmp46_) {
                  gboolean _tmp48_;
                  gchar* _tmp49_ = NULL;
                  gchar* _tmp50_;
                  ValaCCodeIdentifier* _tmp51_ = NULL;
                  ValaCCodeIdentifier* _tmp52_;
                  ValaCCodeFunctionCall* _tmp53_ = NULL;
                  ValaCCodeFunctionCall* _tmp54_;
                  ValaCCodeFunctionCall* copy_call;
                  ValaCCodeIdentifier* _tmp55_ = NULL;
                  ValaCCodeIdentifier* _tmp56_;
                  ValaCCodeIdentifier* _tmp57_ = NULL;
                  ValaCCodeIdentifier* _tmp58_;
                  ValaCCodeFunction* _tmp59_ = NULL;
                  _tmp48_ = vala_struct_get_has_copy_function (st);
                  if (!_tmp48_) {
                        vala_ccode_base_module_generate_struct_copy_function (self, st);
                  }
                  _tmp49_ = vala_typesymbol_get_copy_function ((ValaTypeSymbol*) st);
                  _tmp50_ = _tmp49_;
                  _tmp51_ = vala_ccode_identifier_new (_tmp50_);
                  _tmp52_ = _tmp51_;
                  _tmp53_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp52_);
                  _tmp54_ = _tmp53_;
                  _vala_ccode_node_unref0 (_tmp52_);
                  _g_free0 (_tmp50_);
                  copy_call = _tmp54_;
                  _tmp55_ = vala_ccode_identifier_new ("self");
                  _tmp56_ = _tmp55_;
                  vala_ccode_function_call_add_argument (copy_call, (ValaCCodeExpression*) _tmp56_);
                  _vala_ccode_node_unref0 (_tmp56_);
                  _tmp57_ = vala_ccode_identifier_new ("dup");
                  _tmp58_ = _tmp57_;
                  vala_ccode_function_call_add_argument (copy_call, (ValaCCodeExpression*) _tmp58_);
                  _vala_ccode_node_unref0 (_tmp58_);
                  _tmp59_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_expression (_tmp59_, (ValaCCodeExpression*) copy_call);
                  _vala_ccode_node_unref0 (copy_call);
            } else {
                  ValaCCodeIdentifier* _tmp60_ = NULL;
                  ValaCCodeIdentifier* _tmp61_;
                  ValaCCodeFunctionCall* _tmp62_ = NULL;
                  ValaCCodeFunctionCall* _tmp63_;
                  ValaCCodeFunctionCall* sizeof_call;
                  ValaTypeSymbol* _tmp64_ = NULL;
                  gchar* _tmp65_ = NULL;
                  gchar* _tmp66_;
                  ValaCCodeConstant* _tmp67_ = NULL;
                  ValaCCodeConstant* _tmp68_;
                  ValaCCodeIdentifier* _tmp69_ = NULL;
                  ValaCCodeIdentifier* _tmp70_;
                  ValaCCodeFunctionCall* _tmp71_ = NULL;
                  ValaCCodeFunctionCall* _tmp72_;
                  ValaCCodeFunctionCall* copy_call;
                  ValaCCodeIdentifier* _tmp73_ = NULL;
                  ValaCCodeIdentifier* _tmp74_;
                  ValaCCodeIdentifier* _tmp75_ = NULL;
                  ValaCCodeIdentifier* _tmp76_;
                  ValaCCodeFunction* _tmp77_ = NULL;
                  vala_ccode_file_add_include (self->cfile, "string.h", FALSE);
                  _tmp60_ = vala_ccode_identifier_new ("sizeof");
                  _tmp61_ = _tmp60_;
                  _tmp62_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp61_);
                  _tmp63_ = _tmp62_;
                  _vala_ccode_node_unref0 (_tmp61_);
                  sizeof_call = _tmp63_;
                  _tmp64_ = vala_data_type_get_data_type ((ValaDataType*) value_type);
                  _tmp65_ = vala_typesymbol_get_cname (_tmp64_, FALSE);
                  _tmp66_ = _tmp65_;
                  _tmp67_ = vala_ccode_constant_new (_tmp66_);
                  _tmp68_ = _tmp67_;
                  vala_ccode_function_call_add_argument (sizeof_call, (ValaCCodeExpression*) _tmp68_);
                  _vala_ccode_node_unref0 (_tmp68_);
                  _g_free0 (_tmp66_);
                  _tmp69_ = vala_ccode_identifier_new ("memcpy");
                  _tmp70_ = _tmp69_;
                  _tmp71_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp70_);
                  _tmp72_ = _tmp71_;
                  _vala_ccode_node_unref0 (_tmp70_);
                  copy_call = _tmp72_;
                  _tmp73_ = vala_ccode_identifier_new ("dup");
                  _tmp74_ = _tmp73_;
                  vala_ccode_function_call_add_argument (copy_call, (ValaCCodeExpression*) _tmp74_);
                  _vala_ccode_node_unref0 (_tmp74_);
                  _tmp75_ = vala_ccode_identifier_new ("self");
                  _tmp76_ = _tmp75_;
                  vala_ccode_function_call_add_argument (copy_call, (ValaCCodeExpression*) _tmp76_);
                  _vala_ccode_node_unref0 (_tmp76_);
                  vala_ccode_function_call_add_argument (copy_call, (ValaCCodeExpression*) sizeof_call);
                  _tmp77_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_expression (_tmp77_, (ValaCCodeExpression*) copy_call);
                  _vala_ccode_node_unref0 (copy_call);
                  _vala_ccode_node_unref0 (sizeof_call);
            }
            _tmp78_ = vala_ccode_base_module_get_ccode (self);
            _tmp79_ = vala_ccode_identifier_new ("dup");
            _tmp80_ = _tmp79_;
            vala_ccode_function_add_return (_tmp78_, (ValaCCodeExpression*) _tmp80_);
            _vala_ccode_node_unref0 (_tmp80_);
            _vala_code_node_unref0 (st);
            _vala_ccode_node_unref0 (creation_call);
      }
      vala_ccode_base_module_pop_function (self);
      vala_ccode_file_add_function_declaration (self->cfile, function);
      vala_ccode_file_add_function (self->cfile, function);
      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;
      ValaTypeSymbol* _tmp0_ = NULL;
      gchar* _tmp1_ = NULL;
      gchar* _tmp2_;
      gchar* _tmp3_ = NULL;
      gchar* _tmp4_;
      gchar* destroy_func;
      gboolean _tmp5_;
      gchar* _tmp6_ = NULL;
      gchar* _tmp7_;
      ValaCCodeFunction* _tmp8_ = NULL;
      ValaCCodeFunction* _tmp9_;
      ValaCCodeFunction* function;
      gchar* _tmp10_ = NULL;
      gchar* _tmp11_;
      ValaCCodeParameter* _tmp12_ = NULL;
      ValaCCodeParameter* _tmp13_;
      ValaTypeSymbol* _tmp14_ = NULL;
      ValaTypeSymbol* _tmp15_;
      ValaClass* _tmp16_;
      ValaClass* cl;
      gboolean _tmp17_ = FALSE;
      ValaCCodeIdentifier* _tmp19_ = NULL;
      ValaCCodeIdentifier* _tmp20_;
      ValaCCodeFunctionCall* _tmp21_ = NULL;
      ValaCCodeFunctionCall* _tmp22_;
      ValaCCodeFunctionCall* free_call;
      gchar* _tmp23_ = NULL;
      gchar* _tmp24_;
      ValaCCodeIdentifier* _tmp25_ = NULL;
      ValaCCodeIdentifier* _tmp26_;
      ValaCCodeIdentifier* _tmp27_ = NULL;
      ValaCCodeIdentifier* _tmp28_;
      ValaCCodeFunction* _tmp29_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (type != NULL, NULL);
      _tmp0_ = vala_data_type_get_data_type (type);
      _tmp1_ = vala_typesymbol_get_cname (_tmp0_, FALSE);
      _tmp2_ = _tmp1_;
      _tmp3_ = g_strdup_printf ("_vala_%s_copy", _tmp2_);
      _tmp4_ = _tmp3_;
      _g_free0 (_tmp2_);
      destroy_func = _tmp4_;
      _tmp5_ = vala_ccode_base_module_add_wrapper (self, destroy_func);
      if (!_tmp5_) {
            result = destroy_func;
            return result;
      }
      _tmp6_ = vala_data_type_get_cname (type);
      _tmp7_ = _tmp6_;
      _tmp8_ = vala_ccode_function_new (destroy_func, _tmp7_);
      _tmp9_ = _tmp8_;
      _g_free0 (_tmp7_);
      function = _tmp9_;
      vala_ccode_function_set_modifiers (function, VALA_CCODE_MODIFIERS_STATIC);
      _tmp10_ = vala_data_type_get_cname (type);
      _tmp11_ = _tmp10_;
      _tmp12_ = vala_ccode_parameter_new ("self", _tmp11_);
      _tmp13_ = _tmp12_;
      vala_ccode_function_add_parameter (function, _tmp13_);
      _vala_ccode_node_unref0 (_tmp13_);
      _g_free0 (_tmp11_);
      vala_ccode_base_module_push_function (self, function);
      _tmp14_ = vala_data_type_get_data_type (type);
      _tmp15_ = _tmp14_;
      _tmp16_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp15_) ? ((ValaClass*) _tmp15_) : NULL);
      cl = _tmp16_;
      if (cl != NULL) {
            gboolean _tmp18_;
            _tmp18_ = vala_class_get_is_gboxed (cl);
            _tmp17_ = _tmp18_;
      } else {
            _tmp17_ = FALSE;
      }
      g_assert (_tmp17_);
      _tmp19_ = vala_ccode_identifier_new ("g_boxed_copy");
      _tmp20_ = _tmp19_;
      _tmp21_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp20_);
      _tmp22_ = _tmp21_;
      _vala_ccode_node_unref0 (_tmp20_);
      free_call = _tmp22_;
      _tmp23_ = vala_typesymbol_get_type_id ((ValaTypeSymbol*) cl);
      _tmp24_ = _tmp23_;
      _tmp25_ = vala_ccode_identifier_new (_tmp24_);
      _tmp26_ = _tmp25_;
      vala_ccode_function_call_add_argument (free_call, (ValaCCodeExpression*) _tmp26_);
      _vala_ccode_node_unref0 (_tmp26_);
      _g_free0 (_tmp24_);
      _tmp27_ = vala_ccode_identifier_new ("self");
      _tmp28_ = _tmp27_;
      vala_ccode_function_call_add_argument (free_call, (ValaCCodeExpression*) _tmp28_);
      _vala_ccode_node_unref0 (_tmp28_);
      _tmp29_ = vala_ccode_base_module_get_ccode (self);
      vala_ccode_function_add_return (_tmp29_, (ValaCCodeExpression*) free_call);
      vala_ccode_base_module_pop_function (self);
      vala_ccode_file_add_function_declaration (self->cfile, function);
      vala_ccode_file_add_function (self->cfile, function);
      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;
      ValaTypeSymbol* _tmp0_ = NULL;
      gchar* _tmp1_ = NULL;
      gchar* _tmp2_;
      gchar* _tmp3_ = NULL;
      gchar* _tmp4_;
      gchar* destroy_func;
      gboolean _tmp5_;
      ValaCCodeFunction* _tmp6_ = NULL;
      ValaCCodeFunction* function;
      gchar* _tmp7_ = NULL;
      gchar* _tmp8_;
      ValaCCodeParameter* _tmp9_ = NULL;
      ValaCCodeParameter* _tmp10_;
      ValaTypeSymbol* _tmp11_ = NULL;
      ValaTypeSymbol* _tmp12_;
      ValaClass* _tmp13_;
      ValaClass* cl;
      gboolean _tmp14_ = FALSE;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (type != NULL, NULL);
      _tmp0_ = vala_data_type_get_data_type (type);
      _tmp1_ = vala_typesymbol_get_cname (_tmp0_, FALSE);
      _tmp2_ = _tmp1_;
      _tmp3_ = g_strdup_printf ("_vala_%s_free", _tmp2_);
      _tmp4_ = _tmp3_;
      _g_free0 (_tmp2_);
      destroy_func = _tmp4_;
      _tmp5_ = vala_ccode_base_module_add_wrapper (self, destroy_func);
      if (!_tmp5_) {
            result = destroy_func;
            return result;
      }
      _tmp6_ = vala_ccode_function_new (destroy_func, "void");
      function = _tmp6_;
      vala_ccode_function_set_modifiers (function, VALA_CCODE_MODIFIERS_STATIC);
      _tmp7_ = vala_data_type_get_cname (type);
      _tmp8_ = _tmp7_;
      _tmp9_ = vala_ccode_parameter_new ("self", _tmp8_);
      _tmp10_ = _tmp9_;
      vala_ccode_function_add_parameter (function, _tmp10_);
      _vala_ccode_node_unref0 (_tmp10_);
      _g_free0 (_tmp8_);
      vala_ccode_base_module_push_function (self, function);
      _tmp11_ = vala_data_type_get_data_type (type);
      _tmp12_ = _tmp11_;
      _tmp13_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp12_) ? ((ValaClass*) _tmp12_) : NULL);
      cl = _tmp13_;
      if (cl != NULL) {
            gboolean _tmp15_;
            _tmp15_ = vala_class_get_is_gboxed (cl);
            _tmp14_ = _tmp15_;
      } else {
            _tmp14_ = FALSE;
      }
      if (_tmp14_) {
            ValaCCodeIdentifier* _tmp16_ = NULL;
            ValaCCodeIdentifier* _tmp17_;
            ValaCCodeFunctionCall* _tmp18_ = NULL;
            ValaCCodeFunctionCall* _tmp19_;
            ValaCCodeFunctionCall* free_call;
            gchar* _tmp20_ = NULL;
            gchar* _tmp21_;
            ValaCCodeIdentifier* _tmp22_ = NULL;
            ValaCCodeIdentifier* _tmp23_;
            ValaCCodeIdentifier* _tmp24_ = NULL;
            ValaCCodeIdentifier* _tmp25_;
            ValaCCodeFunction* _tmp26_ = NULL;
            _tmp16_ = vala_ccode_identifier_new ("g_boxed_free");
            _tmp17_ = _tmp16_;
            _tmp18_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp17_);
            _tmp19_ = _tmp18_;
            _vala_ccode_node_unref0 (_tmp17_);
            free_call = _tmp19_;
            _tmp20_ = vala_typesymbol_get_type_id ((ValaTypeSymbol*) cl);
            _tmp21_ = _tmp20_;
            _tmp22_ = vala_ccode_identifier_new (_tmp21_);
            _tmp23_ = _tmp22_;
            vala_ccode_function_call_add_argument (free_call, (ValaCCodeExpression*) _tmp23_);
            _vala_ccode_node_unref0 (_tmp23_);
            _g_free0 (_tmp21_);
            _tmp24_ = vala_ccode_identifier_new ("self");
            _tmp25_ = _tmp24_;
            vala_ccode_function_call_add_argument (free_call, (ValaCCodeExpression*) _tmp25_);
            _vala_ccode_node_unref0 (_tmp25_);
            _tmp26_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_expression (_tmp26_, (ValaCCodeExpression*) free_call);
            _vala_ccode_node_unref0 (free_call);
      } else {
            if (cl != NULL) {
                  gboolean _tmp27_;
                  ValaTypeSymbol* _tmp28_ = NULL;
                  gchar* _tmp29_ = NULL;
                  gchar* _tmp30_;
                  ValaCCodeIdentifier* _tmp31_ = NULL;
                  ValaCCodeIdentifier* _tmp32_;
                  ValaCCodeFunctionCall* _tmp33_ = NULL;
                  ValaCCodeFunctionCall* _tmp34_;
                  ValaCCodeFunctionCall* free_call;
                  ValaCCodeIdentifier* _tmp35_ = NULL;
                  ValaCCodeIdentifier* _tmp36_;
                  ValaCCodeUnaryExpression* _tmp37_ = NULL;
                  ValaCCodeUnaryExpression* _tmp38_;
                  ValaCCodeFunction* _tmp39_ = NULL;
                  _tmp27_ = vala_class_get_free_function_address_of (cl);
                  g_assert (_tmp27_);
                  _tmp28_ = vala_data_type_get_data_type (type);
                  _tmp29_ = vala_typesymbol_get_free_function (_tmp28_);
                  _tmp30_ = _tmp29_;
                  _tmp31_ = vala_ccode_identifier_new (_tmp30_);
                  _tmp32_ = _tmp31_;
                  _tmp33_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp32_);
                  _tmp34_ = _tmp33_;
                  _vala_ccode_node_unref0 (_tmp32_);
                  _g_free0 (_tmp30_);
                  free_call = _tmp34_;
                  _tmp35_ = vala_ccode_identifier_new ("self");
                  _tmp36_ = _tmp35_;
                  _tmp37_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp36_);
                  _tmp38_ = _tmp37_;
                  vala_ccode_function_call_add_argument (free_call, (ValaCCodeExpression*) _tmp38_);
                  _vala_ccode_node_unref0 (_tmp38_);
                  _vala_ccode_node_unref0 (_tmp36_);
                  _tmp39_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_expression (_tmp39_, (ValaCCodeExpression*) free_call);
                  _vala_ccode_node_unref0 (free_call);
            } else {
                  ValaTypeSymbol* _tmp40_ = NULL;
                  ValaTypeSymbol* _tmp41_;
                  ValaStruct* _tmp42_;
                  ValaStruct* st;
                  gboolean _tmp43_ = FALSE;
                  ValaCCodeIdentifier* _tmp55_ = NULL;
                  ValaCCodeIdentifier* _tmp56_;
                  ValaCCodeFunctionCall* _tmp57_ = NULL;
                  ValaCCodeFunctionCall* _tmp58_;
                  ValaCCodeFunctionCall* free_call;
                  ValaCCodeIdentifier* _tmp59_ = NULL;
                  ValaCCodeIdentifier* _tmp60_;
                  ValaCCodeFunction* _tmp61_ = NULL;
                  _tmp40_ = vala_data_type_get_data_type (type);
                  _tmp41_ = _tmp40_;
                  _tmp42_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp41_) ? ((ValaStruct*) _tmp41_) : NULL);
                  st = _tmp42_;
                  if (st != NULL) {
                        gboolean _tmp44_;
                        _tmp44_ = vala_struct_is_disposable (st);
                        _tmp43_ = _tmp44_;
                  } else {
                        _tmp43_ = FALSE;
                  }
                  if (_tmp43_) {
                        gboolean _tmp45_;
                        gchar* _tmp46_ = NULL;
                        gchar* _tmp47_;
                        ValaCCodeIdentifier* _tmp48_ = NULL;
                        ValaCCodeIdentifier* _tmp49_;
                        ValaCCodeFunctionCall* _tmp50_ = NULL;
                        ValaCCodeFunctionCall* _tmp51_;
                        ValaCCodeFunctionCall* destroy_call;
                        ValaCCodeIdentifier* _tmp52_ = NULL;
                        ValaCCodeIdentifier* _tmp53_;
                        ValaCCodeFunction* _tmp54_ = NULL;
                        _tmp45_ = vala_struct_get_has_destroy_function (st);
                        if (!_tmp45_) {
                              vala_ccode_base_module_generate_struct_destroy_function (self, st);
                        }
                        _tmp46_ = vala_typesymbol_get_destroy_function ((ValaTypeSymbol*) st);
                        _tmp47_ = _tmp46_;
                        _tmp48_ = vala_ccode_identifier_new (_tmp47_);
                        _tmp49_ = _tmp48_;
                        _tmp50_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp49_);
                        _tmp51_ = _tmp50_;
                        _vala_ccode_node_unref0 (_tmp49_);
                        _g_free0 (_tmp47_);
                        destroy_call = _tmp51_;
                        _tmp52_ = vala_ccode_identifier_new ("self");
                        _tmp53_ = _tmp52_;
                        vala_ccode_function_call_add_argument (destroy_call, (ValaCCodeExpression*) _tmp53_);
                        _vala_ccode_node_unref0 (_tmp53_);
                        _tmp54_ = vala_ccode_base_module_get_ccode (self);
                        vala_ccode_function_add_expression (_tmp54_, (ValaCCodeExpression*) destroy_call);
                        _vala_ccode_node_unref0 (destroy_call);
                  }
                  _tmp55_ = vala_ccode_identifier_new ("g_free");
                  _tmp56_ = _tmp55_;
                  _tmp57_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp56_);
                  _tmp58_ = _tmp57_;
                  _vala_ccode_node_unref0 (_tmp56_);
                  free_call = _tmp58_;
                  _tmp59_ = vala_ccode_identifier_new ("self");
                  _tmp60_ = _tmp59_;
                  vala_ccode_function_call_add_argument (free_call, (ValaCCodeExpression*) _tmp60_);
                  _vala_ccode_node_unref0 (_tmp60_);
                  _tmp61_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_expression (_tmp61_, (ValaCCodeExpression*) free_call);
                  _vala_ccode_node_unref0 (free_call);
                  _vala_code_node_unref0 (st);
            }
      }
      vala_ccode_base_module_pop_function (self);
      vala_ccode_file_add_function_declaration (self->cfile, function);
      vala_ccode_file_add_function (self->cfile, function);
      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* _tmp0_ = NULL;
      ValaCCodeExpression* element_destroy_func_expression;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (type != NULL, NULL);
      _tmp0_ = vala_ccode_base_module_get_destroy_func_expression (self, type, is_chainup);
      element_destroy_func_expression = _tmp0_;
      if (VALA_IS_CCODE_IDENTIFIER (element_destroy_func_expression)) {
            ValaCCodeIdentifier* _tmp1_;
            ValaCCodeIdentifier* freeid;
            const gchar* _tmp2_ = NULL;
            gchar* _tmp3_ = NULL;
            gchar* free0_func;
            gboolean _tmp4_;
            ValaCCodeIdentifier* _tmp15_ = NULL;
            _tmp1_ = _vala_ccode_node_ref0 (VALA_CCODE_IDENTIFIER (element_destroy_func_expression));
            freeid = _tmp1_;
            _tmp2_ = vala_ccode_identifier_get_name (freeid);
            _tmp3_ = g_strdup_printf ("_%s0_", _tmp2_);
            free0_func = _tmp3_;
            _tmp4_ = vala_ccode_base_module_add_wrapper (self, free0_func);
            if (_tmp4_) {
                  ValaCCodeFunction* _tmp5_ = NULL;
                  ValaCCodeFunction* function;
                  ValaCCodeParameter* _tmp6_ = NULL;
                  ValaCCodeParameter* _tmp7_;
                  ValaCCodeFunction* _tmp8_ = NULL;
                  ValaCCodeIdentifier* _tmp9_ = NULL;
                  ValaCCodeIdentifier* _tmp10_;
                  ValaGLibValue* _tmp11_ = NULL;
                  ValaGLibValue* _tmp12_;
                  ValaCCodeExpression* _tmp13_ = NULL;
                  ValaCCodeExpression* _tmp14_;
                  _tmp5_ = vala_ccode_function_new (free0_func, "void");
                  function = _tmp5_;
                  vala_ccode_function_set_modifiers (function, VALA_CCODE_MODIFIERS_STATIC);
                  _tmp6_ = vala_ccode_parameter_new ("var", "gpointer");
                  _tmp7_ = _tmp6_;
                  vala_ccode_function_add_parameter (function, _tmp7_);
                  _vala_ccode_node_unref0 (_tmp7_);
                  vala_ccode_base_module_push_function (self, function);
                  _tmp8_ = vala_ccode_base_module_get_ccode (self);
                  _tmp9_ = vala_ccode_identifier_new ("var");
                  _tmp10_ = _tmp9_;
                  _tmp11_ = vala_glib_value_new (type, (ValaCCodeExpression*) _tmp10_);
                  _tmp12_ = _tmp11_;
                  _tmp13_ = vala_ccode_base_module_destroy_value (self, (ValaTargetValue*) _tmp12_, TRUE);
                  _tmp14_ = _tmp13_;
                  vala_ccode_function_add_expression (_tmp8_, _tmp14_);
                  _vala_ccode_node_unref0 (_tmp14_);
                  _vala_target_value_unref0 (_tmp12_);
                  _vala_ccode_node_unref0 (_tmp10_);
                  vala_ccode_base_module_pop_function (self);
                  vala_ccode_file_add_function_declaration (self->cfile, function);
                  vala_ccode_file_add_function (self->cfile, function);
                  _vala_ccode_node_unref0 (function);
            }
            _tmp15_ = vala_ccode_identifier_new (free0_func);
            _vala_ccode_node_unref0 (element_destroy_func_expression);
            element_destroy_func_expression = (ValaCCodeExpression*) _tmp15_;
            _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;
      ValaProfile _tmp1_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (type != NULL, NULL);
      _tmp1_ = vala_code_context_get_profile (self->priv->_context);
      if (_tmp1_ == VALA_PROFILE_GOBJECT) {
            gboolean _tmp2_ = FALSE;
            gboolean _tmp3_ = FALSE;
            ValaTypeSymbol* _tmp4_ = NULL;
            _tmp4_ = vala_data_type_get_data_type (type);
            if (_tmp4_ == VALA_TYPESYMBOL (self->glist_type)) {
                  _tmp3_ = TRUE;
            } else {
                  ValaTypeSymbol* _tmp5_ = NULL;
                  _tmp5_ = vala_data_type_get_data_type (type);
                  _tmp3_ = _tmp5_ == VALA_TYPESYMBOL (self->gslist_type);
            }
            if (_tmp3_) {
                  _tmp2_ = TRUE;
            } else {
                  ValaTypeSymbol* _tmp6_ = NULL;
                  _tmp6_ = vala_data_type_get_data_type (type);
                  _tmp2_ = _tmp6_ == VALA_TYPESYMBOL (self->gnode_type);
            }
            _tmp0_ = _tmp2_;
      } else {
            _tmp0_ = FALSE;
      }
      if (_tmp0_) {
            gboolean elements_require_free;
            ValaCCodeExpression* element_destroy_func_expression;
            gboolean _tmp12_ = FALSE;
            elements_require_free = FALSE;
            element_destroy_func_expression = NULL;
            {
                  ValaList* _tmp7_ = NULL;
                  ValaList* _type_arg_list;
                  gint _tmp8_;
                  gint _type_arg_size;
                  gint _type_arg_index;
                  _tmp7_ = vala_data_type_get_type_arguments (type);
                  _type_arg_list = _tmp7_;
                  _tmp8_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
                  _type_arg_size = _tmp8_;
                  _type_arg_index = -1;
                  while (TRUE) {
                        gpointer _tmp9_ = NULL;
                        ValaDataType* type_arg;
                        gboolean _tmp10_;
                        _type_arg_index = _type_arg_index + 1;
                        if (!(_type_arg_index < _type_arg_size)) {
                              break;
                        }
                        _tmp9_ = vala_list_get (_type_arg_list, _type_arg_index);
                        type_arg = (ValaDataType*) _tmp9_;
                        _tmp10_ = vala_ccode_base_module_requires_destroy (self, type_arg);
                        elements_require_free = _tmp10_;
                        if (elements_require_free) {
                              ValaCCodeExpression* _tmp11_ = NULL;
                              _tmp11_ = vala_ccode_base_module_get_destroy0_func_expression (self, type_arg, FALSE);
                              _vala_ccode_node_unref0 (element_destroy_func_expression);
                              element_destroy_func_expression = _tmp11_;
                        }
                        _vala_code_node_unref0 (type_arg);
                  }
                  _vala_iterable_unref0 (_type_arg_list);
            }
            if (elements_require_free) {
                  _tmp12_ = VALA_IS_CCODE_IDENTIFIER (element_destroy_func_expression);
            } else {
                  _tmp12_ = FALSE;
            }
            if (_tmp12_) {
                  gchar* _tmp13_ = NULL;
                  gchar* _tmp14_;
                  ValaCCodeIdentifier* _tmp15_ = NULL;
                  ValaCCodeExpression* _tmp16_;
                  _tmp13_ = vala_ccode_base_module_generate_collection_free_wrapper (self, type, VALA_CCODE_IDENTIFIER (element_destroy_func_expression));
                  _tmp14_ = _tmp13_;
                  _tmp15_ = vala_ccode_identifier_new (_tmp14_);
                  _tmp16_ = (ValaCCodeExpression*) _tmp15_;
                  _g_free0 (_tmp14_);
                  result = _tmp16_;
                  _vala_ccode_node_unref0 (element_destroy_func_expression);
                  return result;
            } else {
                  ValaTypeSymbol* _tmp17_ = NULL;
                  gchar* _tmp18_ = NULL;
                  gchar* _tmp19_;
                  ValaCCodeIdentifier* _tmp20_ = NULL;
                  ValaCCodeExpression* _tmp21_;
                  _tmp17_ = vala_data_type_get_data_type (type);
                  _tmp18_ = vala_typesymbol_get_free_function (_tmp17_);
                  _tmp19_ = _tmp18_;
                  _tmp20_ = vala_ccode_identifier_new (_tmp19_);
                  _tmp21_ = (ValaCCodeExpression*) _tmp20_;
                  _g_free0 (_tmp19_);
                  result = _tmp21_;
                  _vala_ccode_node_unref0 (element_destroy_func_expression);
                  return result;
            }
            _vala_ccode_node_unref0 (element_destroy_func_expression);
      } else {
            if (VALA_IS_ERROR_TYPE (type)) {
                  ValaCCodeIdentifier* _tmp22_ = NULL;
                  _tmp22_ = vala_ccode_identifier_new ("g_error_free");
                  result = (ValaCCodeExpression*) _tmp22_;
                  return result;
            } else {
                  ValaTypeSymbol* _tmp23_ = NULL;
                  _tmp23_ = vala_data_type_get_data_type (type);
                  if (_tmp23_ != NULL) {
                        gchar* unref_function = NULL;
                        ValaCCodeIdentifier* _tmp60_ = NULL;
                        if (VALA_IS_REFERENCE_TYPE (type)) {
                              ValaTypeSymbol* _tmp24_ = NULL;
                              gboolean _tmp25_;
                              _tmp24_ = vala_data_type_get_data_type (type);
                              _tmp25_ = vala_typesymbol_is_reference_counting (_tmp24_);
                              if (_tmp25_) {
                                    ValaTypeSymbol* _tmp26_ = NULL;
                                    gchar* _tmp27_ = NULL;
                                    gboolean _tmp28_ = FALSE;
                                    ValaTypeSymbol* _tmp29_ = NULL;
                                    _tmp26_ = vala_data_type_get_data_type (type);
                                    _tmp27_ = vala_typesymbol_get_unref_function (_tmp26_);
                                    _g_free0 (unref_function);
                                    unref_function = _tmp27_;
                                    _tmp29_ = vala_data_type_get_data_type (type);
                                    if (VALA_IS_INTERFACE (_tmp29_)) {
                                          _tmp28_ = unref_function == NULL;
                                    } else {
                                          _tmp28_ = FALSE;
                                    }
                                    if (_tmp28_) {
                                          ValaSourceReference* _tmp30_ = NULL;
                                          ValaTypeSymbol* _tmp31_ = NULL;
                                          gchar* _tmp32_ = NULL;
                                          gchar* _tmp33_;
                                          gchar* _tmp34_ = NULL;
                                          gchar* _tmp35_;
                                          _tmp30_ = vala_code_node_get_source_reference ((ValaCodeNode*) type);
                                          _tmp31_ = vala_data_type_get_data_type (type);
                                          _tmp32_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp31_);
                                          _tmp33_ = _tmp32_;
                                          _tmp34_ = g_strdup_printf ("missing class prerequisite for interface `%s', add GLib.Object to inte" \
"rface declaration if unsure", _tmp33_);
                                          _tmp35_ = _tmp34_;
                                          vala_report_error (_tmp30_, _tmp35_);
                                          _g_free0 (_tmp35_);
                                          _g_free0 (_tmp33_);
                                          result = NULL;
                                          _g_free0 (unref_function);
                                          return result;
                                    }
                              } else {
                                    ValaTypeSymbol* _tmp36_ = NULL;
                                    ValaTypeSymbol* _tmp37_;
                                    ValaClass* _tmp38_;
                                    ValaClass* cl;
                                    gboolean _tmp39_ = FALSE;
                                    _tmp36_ = vala_data_type_get_data_type (type);
                                    _tmp37_ = _tmp36_;
                                    _tmp38_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp37_) ? ((ValaClass*) _tmp37_) : NULL);
                                    cl = _tmp38_;
                                    if (cl != NULL) {
                                          gboolean _tmp40_ = FALSE;
                                          gboolean _tmp41_;
                                          _tmp41_ = vala_class_get_free_function_address_of (cl);
                                          if (_tmp41_) {
                                                _tmp40_ = TRUE;
                                          } else {
                                                gboolean _tmp42_;
                                                _tmp42_ = vala_class_get_is_gboxed (cl);
                                                _tmp40_ = _tmp42_;
                                          }
                                          _tmp39_ = _tmp40_;
                                    } else {
                                          _tmp39_ = FALSE;
                                    }
                                    if (_tmp39_) {
                                          gchar* _tmp43_ = NULL;
                                          _tmp43_ = vala_ccode_base_module_generate_free_func_wrapper (self, type);
                                          _g_free0 (unref_function);
                                          unref_function = _tmp43_;
                                    } else {
                                          ValaTypeSymbol* _tmp44_ = NULL;
                                          gchar* _tmp45_ = NULL;
                                          _tmp44_ = vala_data_type_get_data_type (type);
                                          _tmp45_ = vala_typesymbol_get_free_function (_tmp44_);
                                          _g_free0 (unref_function);
                                          unref_function = _tmp45_;
                                    }
                                    _vala_code_node_unref0 (cl);
                              }
                        } else {
                              gboolean _tmp46_;
                              _tmp46_ = vala_data_type_get_nullable (type);
                              if (_tmp46_) {
                                    ValaTypeSymbol* _tmp47_ = NULL;
                                    gchar* _tmp48_ = NULL;
                                    _tmp47_ = vala_data_type_get_data_type (type);
                                    _tmp48_ = vala_typesymbol_get_free_function (_tmp47_);
                                    _g_free0 (unref_function);
                                    unref_function = _tmp48_;
                                    if (unref_function == NULL) {
                                          gboolean _tmp49_ = FALSE;
                                          ValaTypeSymbol* _tmp50_ = NULL;
                                          _tmp50_ = vala_data_type_get_data_type (type);
                                          if (VALA_IS_STRUCT (_tmp50_)) {
                                                ValaTypeSymbol* _tmp51_ = NULL;
                                                gboolean _tmp52_;
                                                _tmp51_ = vala_data_type_get_data_type (type);
                                                _tmp52_ = vala_struct_is_disposable (VALA_STRUCT (_tmp51_));
                                                _tmp49_ = _tmp52_;
                                          } else {
                                                _tmp49_ = FALSE;
                                          }
                                          if (_tmp49_) {
                                                gchar* _tmp53_ = NULL;
                                                _tmp53_ = vala_ccode_base_module_generate_free_func_wrapper (self, type);
                                                _g_free0 (unref_function);
                                                unref_function = _tmp53_;
                                          } else {
                                                gchar* _tmp54_;
                                                _tmp54_ = g_strdup ("g_free");
                                                _g_free0 (unref_function);
                                                unref_function = _tmp54_;
                                          }
                                    }
                              } else {
                                    ValaTypeSymbol* _tmp55_ = NULL;
                                    ValaStruct* _tmp56_;
                                    ValaStruct* st;
                                    gboolean _tmp57_;
                                    gchar* _tmp58_ = NULL;
                                    _tmp55_ = vala_data_type_get_data_type (type);
                                    _tmp56_ = _vala_code_node_ref0 (VALA_STRUCT (_tmp55_));
                                    st = _tmp56_;
                                    _tmp57_ = vala_struct_get_has_destroy_function (st);
                                    if (!_tmp57_) {
                                          vala_ccode_base_module_generate_struct_destroy_function (self, st);
                                    }
                                    _tmp58_ = vala_typesymbol_get_destroy_function ((ValaTypeSymbol*) st);
                                    _g_free0 (unref_function);
                                    unref_function = _tmp58_;
                                    _vala_code_node_unref0 (st);
                              }
                        }
                        if (unref_function == NULL) {
                              ValaCCodeConstant* _tmp59_ = NULL;
                              _tmp59_ = vala_ccode_constant_new ("NULL");
                              result = (ValaCCodeExpression*) _tmp59_;
                              _g_free0 (unref_function);
                              return result;
                        }
                        _tmp60_ = vala_ccode_identifier_new (unref_function);
                        result = (ValaCCodeExpression*) _tmp60_;
                        _g_free0 (unref_function);
                        return result;
                  } else {
                        ValaTypeParameter* _tmp61_ = NULL;
                        _tmp61_ = vala_data_type_get_type_parameter (type);
                        if (_tmp61_ != NULL) {
                              ValaTypeParameter* _tmp62_ = NULL;
                              const gchar* _tmp63_ = NULL;
                              gchar* _tmp64_ = NULL;
                              gchar* _tmp65_;
                              gchar* _tmp66_ = NULL;
                              gchar* _tmp67_;
                              gchar* func_name;
                              gboolean _tmp68_ = FALSE;
                              gboolean _tmp69_ = FALSE;
                              gboolean _tmp70_;
                              _tmp62_ = vala_data_type_get_type_parameter (type);
                              _tmp63_ = vala_symbol_get_name ((ValaSymbol*) _tmp62_);
                              _tmp64_ = g_utf8_strdown (_tmp63_, (gssize) (-1));
                              _tmp65_ = _tmp64_;
                              _tmp66_ = g_strdup_printf ("%s_destroy_func", _tmp65_);
                              _tmp67_ = _tmp66_;
                              _g_free0 (_tmp65_);
                              func_name = _tmp67_;
                              _tmp70_ = vala_ccode_base_module_is_in_generic_type (self, type);
                              if (_tmp70_) {
                                    _tmp69_ = !is_chainup;
                              } else {
                                    _tmp69_ = FALSE;
                              }
                              if (_tmp69_) {
                                    gboolean _tmp71_;
                                    _tmp71_ = vala_ccode_base_module_get_in_creation_method (self);
                                    _tmp68_ = !_tmp71_;
                              } else {
                                    _tmp68_ = FALSE;
                              }
                              if (_tmp68_) {
                                    ValaCCodeExpression* _tmp72_ = NULL;
                                    ValaCCodeExpression* _tmp73_;
                                    ValaCCodeMemberAccess* _tmp74_ = NULL;
                                    ValaCCodeMemberAccess* _tmp75_;
                                    ValaCCodeMemberAccess* _tmp76_ = NULL;
                                    ValaCCodeExpression* _tmp77_;
                                    _tmp72_ = vala_ccode_base_module_get_result_cexpression (self, "self");
                                    _tmp73_ = _tmp72_;
                                    _tmp74_ = vala_ccode_member_access_new_pointer (_tmp73_, "priv");
                                    _tmp75_ = _tmp74_;
                                    _tmp76_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp75_, func_name);
                                    _tmp77_ = (ValaCCodeExpression*) _tmp76_;
                                    _vala_ccode_node_unref0 (_tmp75_);
                                    _vala_ccode_node_unref0 (_tmp73_);
                                    result = _tmp77_;
                                    _g_free0 (func_name);
                                    return result;
                              } else {
                                    ValaCCodeIdentifier* _tmp78_ = NULL;
                                    _tmp78_ = vala_ccode_identifier_new (func_name);
                                    result = (ValaCCodeExpression*) _tmp78_;
                                    _g_free0 (func_name);
                                    return result;
                              }
                              _g_free0 (func_name);
                        } else {
                              if (VALA_IS_ARRAY_TYPE (type)) {
                                    ValaProfile _tmp79_;
                                    _tmp79_ = vala_code_context_get_profile (self->priv->_context);
                                    if (_tmp79_ == VALA_PROFILE_POSIX) {
                                          ValaCCodeIdentifier* _tmp80_ = NULL;
                                          _tmp80_ = vala_ccode_identifier_new ("free");
                                          result = (ValaCCodeExpression*) _tmp80_;
                                          return result;
                                    } else {
                                          ValaCCodeIdentifier* _tmp81_ = NULL;
                                          _tmp81_ = vala_ccode_identifier_new ("g_free");
                                          result = (ValaCCodeExpression*) _tmp81_;
                                          return result;
                                    }
                              } else {
                                    if (VALA_IS_POINTER_TYPE (type)) {
                                          ValaProfile _tmp82_;
                                          _tmp82_ = vala_code_context_get_profile (self->priv->_context);
                                          if (_tmp82_ == VALA_PROFILE_POSIX) {
                                                ValaCCodeIdentifier* _tmp83_ = NULL;
                                                _tmp83_ = vala_ccode_identifier_new ("free");
                                                result = (ValaCCodeExpression*) _tmp83_;
                                                return result;
                                          } else {
                                                ValaCCodeIdentifier* _tmp84_ = NULL;
                                                _tmp84_ = vala_ccode_identifier_new ("g_free");
                                                result = (ValaCCodeExpression*) _tmp84_;
                                                return result;
                                          }
                                    } else {
                                          ValaCCodeConstant* _tmp85_ = NULL;
                                          _tmp85_ = vala_ccode_constant_new ("NULL");
                                          result = (ValaCCodeExpression*) _tmp85_;
                                          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;
      ValaTypeSymbol* _tmp0_ = NULL;
      gchar* _tmp1_ = NULL;
      gchar* _tmp2_;
      const gchar* _tmp3_ = NULL;
      gchar* _tmp4_ = NULL;
      gchar* _tmp5_;
      gchar* destroy_func;
      gboolean _tmp6_;
      ValaCCodeFunction* _tmp7_ = NULL;
      ValaCCodeFunction* function;
      gchar* _tmp8_ = NULL;
      gchar* _tmp9_;
      ValaCCodeParameter* _tmp10_ = NULL;
      ValaCCodeParameter* _tmp11_;
      ValaCCodeFunctionCall* element_free_call = NULL;
      ValaTypeSymbol* _tmp12_ = NULL;
      ValaCCodeFunction* _tmp58_ = NULL;
      ValaTypeSymbol* _tmp59_ = NULL;
      gchar* _tmp60_ = NULL;
      gchar* _tmp61_;
      ValaCCodeIdentifier* _tmp62_ = NULL;
      ValaCCodeIdentifier* _tmp63_;
      ValaCCodeFunctionCall* _tmp64_ = NULL;
      ValaCCodeFunctionCall* _tmp65_;
      ValaCCodeFunctionCall* cfreecall;
      ValaCCodeIdentifier* _tmp66_ = NULL;
      ValaCCodeIdentifier* _tmp67_;
      ValaCCodeFunction* _tmp68_ = NULL;
      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_ = vala_data_type_get_data_type (collection_type);
      _tmp1_ = vala_typesymbol_get_free_function (_tmp0_);
      _tmp2_ = _tmp1_;
      _tmp3_ = vala_ccode_identifier_get_name (element_destroy_func_expression);
      _tmp4_ = g_strdup_printf ("_%s_%s", _tmp2_, _tmp3_);
      _tmp5_ = _tmp4_;
      _g_free0 (_tmp2_);
      destroy_func = _tmp5_;
      _tmp6_ = vala_ccode_base_module_add_wrapper (self, destroy_func);
      if (!_tmp6_) {
            result = destroy_func;
            return result;
      }
      _tmp7_ = vala_ccode_function_new (destroy_func, "void");
      function = _tmp7_;
      vala_ccode_function_set_modifiers (function, VALA_CCODE_MODIFIERS_STATIC);
      _tmp8_ = vala_data_type_get_cname (collection_type);
      _tmp9_ = _tmp8_;
      _tmp10_ = vala_ccode_parameter_new ("self", _tmp9_);
      _tmp11_ = _tmp10_;
      vala_ccode_function_add_parameter (function, _tmp11_);
      _vala_ccode_node_unref0 (_tmp11_);
      _g_free0 (_tmp9_);
      vala_ccode_base_module_push_function (self, function);
      _tmp12_ = vala_data_type_get_data_type (collection_type);
      if (_tmp12_ == VALA_TYPESYMBOL (self->gnode_type)) {
            gchar* _tmp13_ = NULL;
            gchar* destroy_node_func;
            ValaCCodeFunction* _tmp14_ = NULL;
            ValaCCodeFunction* wrapper;
            gchar* _tmp15_ = NULL;
            gchar* _tmp16_;
            ValaCCodeParameter* _tmp17_ = NULL;
            ValaCCodeParameter* _tmp18_;
            ValaCCodeParameter* _tmp19_ = NULL;
            ValaCCodeParameter* _tmp20_;
            ValaCCodeFunctionCall* _tmp21_ = NULL;
            ValaCCodeFunctionCall* free_call;
            ValaCCodeIdentifier* _tmp22_ = NULL;
            ValaCCodeIdentifier* _tmp23_;
            ValaCCodeMemberAccess* _tmp24_ = NULL;
            ValaCCodeMemberAccess* _tmp25_;
            ValaCCodeFunction* _tmp26_ = NULL;
            ValaCCodeFunction* _tmp27_ = NULL;
            ValaCCodeConstant* _tmp28_ = NULL;
            ValaCCodeConstant* _tmp29_;
            ValaCCodeIdentifier* _tmp30_ = NULL;
            ValaCCodeIdentifier* _tmp31_;
            ValaCCodeFunctionCall* _tmp32_ = NULL;
            ValaCCodeIdentifier* _tmp33_ = NULL;
            ValaCCodeIdentifier* _tmp34_;
            ValaCCodeConstant* _tmp35_ = NULL;
            ValaCCodeConstant* _tmp36_;
            ValaCCodeConstant* _tmp37_ = NULL;
            ValaCCodeConstant* _tmp38_;
            ValaCCodeConstant* _tmp39_ = NULL;
            ValaCCodeConstant* _tmp40_;
            ValaCCodeIdentifier* _tmp41_ = NULL;
            ValaCCodeIdentifier* _tmp42_;
            ValaCCodeConstant* _tmp43_ = NULL;
            ValaCCodeConstant* _tmp44_;
            _tmp13_ = g_strdup_printf ("%s_node", destroy_func);
            destroy_node_func = _tmp13_;
            _tmp14_ = vala_ccode_function_new (destroy_node_func, "gboolean");
            wrapper = _tmp14_;
            vala_ccode_function_set_modifiers (wrapper, VALA_CCODE_MODIFIERS_STATIC);
            _tmp15_ = vala_data_type_get_cname (collection_type);
            _tmp16_ = _tmp15_;
            _tmp17_ = vala_ccode_parameter_new ("node", _tmp16_);
            _tmp18_ = _tmp17_;
            vala_ccode_function_add_parameter (wrapper, _tmp18_);
            _vala_ccode_node_unref0 (_tmp18_);
            _g_free0 (_tmp16_);
            _tmp19_ = vala_ccode_parameter_new ("unused", "gpointer");
            _tmp20_ = _tmp19_;
            vala_ccode_function_add_parameter (wrapper, _tmp20_);
            _vala_ccode_node_unref0 (_tmp20_);
            vala_ccode_base_module_push_function (self, wrapper);
            _tmp21_ = vala_ccode_function_call_new ((ValaCCodeExpression*) element_destroy_func_expression);
            free_call = _tmp21_;
            _tmp22_ = vala_ccode_identifier_new ("node");
            _tmp23_ = _tmp22_;
            _tmp24_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp23_, "data");
            _tmp25_ = _tmp24_;
            vala_ccode_function_call_add_argument (free_call, (ValaCCodeExpression*) _tmp25_);
            _vala_ccode_node_unref0 (_tmp25_);
            _vala_ccode_node_unref0 (_tmp23_);
            _tmp26_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_expression (_tmp26_, (ValaCCodeExpression*) free_call);
            _tmp27_ = vala_ccode_base_module_get_ccode (self);
            _tmp28_ = vala_ccode_constant_new ("FALSE");
            _tmp29_ = _tmp28_;
            vala_ccode_function_add_return (_tmp27_, (ValaCCodeExpression*) _tmp29_);
            _vala_ccode_node_unref0 (_tmp29_);
            vala_ccode_base_module_pop_function (self);
            vala_ccode_file_add_function_declaration (self->cfile, function);
            vala_ccode_file_add_function (self->cfile, wrapper);
            _tmp30_ = vala_ccode_identifier_new ("g_node_traverse");
            _tmp31_ = _tmp30_;
            _tmp32_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp31_);
            _vala_ccode_node_unref0 (element_free_call);
            element_free_call = _tmp32_;
            _vala_ccode_node_unref0 (_tmp31_);
            _tmp33_ = vala_ccode_identifier_new ("self");
            _tmp34_ = _tmp33_;
            vala_ccode_function_call_add_argument (element_free_call, (ValaCCodeExpression*) _tmp34_);
            _vala_ccode_node_unref0 (_tmp34_);
            _tmp35_ = vala_ccode_constant_new ("G_POST_ORDER");
            _tmp36_ = _tmp35_;
            vala_ccode_function_call_add_argument (element_free_call, (ValaCCodeExpression*) _tmp36_);
            _vala_ccode_node_unref0 (_tmp36_);
            _tmp37_ = vala_ccode_constant_new ("G_TRAVERSE_ALL");
            _tmp38_ = _tmp37_;
            vala_ccode_function_call_add_argument (element_free_call, (ValaCCodeExpression*) _tmp38_);
            _vala_ccode_node_unref0 (_tmp38_);
            _tmp39_ = vala_ccode_constant_new ("-1");
            _tmp40_ = _tmp39_;
            vala_ccode_function_call_add_argument (element_free_call, (ValaCCodeExpression*) _tmp40_);
            _vala_ccode_node_unref0 (_tmp40_);
            _tmp41_ = vala_ccode_identifier_new (destroy_node_func);
            _tmp42_ = _tmp41_;
            vala_ccode_function_call_add_argument (element_free_call, (ValaCCodeExpression*) _tmp42_);
            _vala_ccode_node_unref0 (_tmp42_);
            _tmp43_ = vala_ccode_constant_new ("NULL");
            _tmp44_ = _tmp43_;
            vala_ccode_function_call_add_argument (element_free_call, (ValaCCodeExpression*) _tmp44_);
            _vala_ccode_node_unref0 (_tmp44_);
            _vala_ccode_node_unref0 (free_call);
            _vala_ccode_node_unref0 (wrapper);
            _g_free0 (destroy_node_func);
      } else {
            ValaTypeSymbol* _tmp45_ = NULL;
            ValaCCodeIdentifier* _tmp52_ = NULL;
            ValaCCodeIdentifier* _tmp53_;
            ValaCCodeCastExpression* _tmp54_ = NULL;
            ValaCCodeCastExpression* _tmp55_;
            ValaCCodeConstant* _tmp56_ = NULL;
            ValaCCodeConstant* _tmp57_;
            _tmp45_ = vala_data_type_get_data_type (collection_type);
            if (_tmp45_ == VALA_TYPESYMBOL (self->glist_type)) {
                  ValaCCodeIdentifier* _tmp46_ = NULL;
                  ValaCCodeIdentifier* _tmp47_;
                  ValaCCodeFunctionCall* _tmp48_ = NULL;
                  _tmp46_ = vala_ccode_identifier_new ("g_list_foreach");
                  _tmp47_ = _tmp46_;
                  _tmp48_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp47_);
                  _vala_ccode_node_unref0 (element_free_call);
                  element_free_call = _tmp48_;
                  _vala_ccode_node_unref0 (_tmp47_);
            } else {
                  ValaCCodeIdentifier* _tmp49_ = NULL;
                  ValaCCodeIdentifier* _tmp50_;
                  ValaCCodeFunctionCall* _tmp51_ = NULL;
                  _tmp49_ = vala_ccode_identifier_new ("g_slist_foreach");
                  _tmp50_ = _tmp49_;
                  _tmp51_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp50_);
                  _vala_ccode_node_unref0 (element_free_call);
                  element_free_call = _tmp51_;
                  _vala_ccode_node_unref0 (_tmp50_);
            }
            _tmp52_ = vala_ccode_identifier_new ("self");
            _tmp53_ = _tmp52_;
            vala_ccode_function_call_add_argument (element_free_call, (ValaCCodeExpression*) _tmp53_);
            _vala_ccode_node_unref0 (_tmp53_);
            _tmp54_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) element_destroy_func_expression, "GFunc");
            _tmp55_ = _tmp54_;
            vala_ccode_function_call_add_argument (element_free_call, (ValaCCodeExpression*) _tmp55_);
            _vala_ccode_node_unref0 (_tmp55_);
            _tmp56_ = vala_ccode_constant_new ("NULL");
            _tmp57_ = _tmp56_;
            vala_ccode_function_call_add_argument (element_free_call, (ValaCCodeExpression*) _tmp57_);
            _vala_ccode_node_unref0 (_tmp57_);
      }
      _tmp58_ = vala_ccode_base_module_get_ccode (self);
      vala_ccode_function_add_expression (_tmp58_, (ValaCCodeExpression*) element_free_call);
      _tmp59_ = vala_data_type_get_data_type (collection_type);
      _tmp60_ = vala_typesymbol_get_free_function (_tmp59_);
      _tmp61_ = _tmp60_;
      _tmp62_ = vala_ccode_identifier_new (_tmp61_);
      _tmp63_ = _tmp62_;
      _tmp64_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp63_);
      _tmp65_ = _tmp64_;
      _vala_ccode_node_unref0 (_tmp63_);
      _g_free0 (_tmp61_);
      cfreecall = _tmp65_;
      _tmp66_ = vala_ccode_identifier_new ("self");
      _tmp67_ = _tmp66_;
      vala_ccode_function_call_add_argument (cfreecall, (ValaCCodeExpression*) _tmp67_);
      _vala_ccode_node_unref0 (_tmp67_);
      _tmp68_ = vala_ccode_base_module_get_ccode (self);
      vala_ccode_function_add_expression (_tmp68_, (ValaCCodeExpression*) cfreecall);
      vala_ccode_base_module_pop_function (self);
      vala_ccode_file_add_function_declaration (self->cfile, function);
      vala_ccode_file_add_function (self->cfile, function);
      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 (self != NULL, 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) {
      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;
      ValaTargetValue* _tmp0_ = NULL;
      ValaTargetValue* _tmp1_;
      ValaCCodeExpression* _tmp2_ = NULL;
      ValaCCodeExpression* _tmp3_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (local != NULL, NULL);
      _tmp0_ = vala_ccode_base_module_get_local_cvalue (self, local);
      _tmp1_ = _tmp0_;
      _tmp2_ = vala_ccode_base_module_destroy_value (self, _tmp1_, FALSE);
      _tmp3_ = _tmp2_;
      _vala_target_value_unref0 (_tmp1_);
      result = _tmp3_;
      return result;
}


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


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


static ValaCCodeExpression* vala_ccode_base_module_real_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition) {
      ValaCCodeExpression* result = NULL;
      ValaDataType* _tmp0_ = NULL;
      ValaDataType* _tmp1_;
      ValaDataType* type;
      ValaCCodeExpression* _tmp2_ = NULL;
      ValaCCodeExpression* cvar;
      ValaCCodeExpression* _tmp30_ = NULL;
      ValaCCodeExpression* _tmp31_;
      ValaCCodeFunctionCall* _tmp32_ = NULL;
      ValaCCodeFunctionCall* _tmp33_;
      ValaCCodeFunctionCall* ccall;
      gboolean _tmp34_ = FALSE;
      gboolean _tmp58_ = FALSE;
      gboolean _tmp59_ = FALSE;
      ValaCCodeExpression* _tmp60_ = NULL;
      ValaCCodeConstant* _tmp79_ = NULL;
      ValaCCodeConstant* _tmp80_;
      ValaCCodeBinaryExpression* _tmp81_ = NULL;
      ValaCCodeBinaryExpression* _tmp82_;
      ValaCCodeBinaryExpression* cisnull;
      ValaTypeParameter* _tmp83_ = NULL;
      ValaCCodeCommaExpression* _tmp96_ = NULL;
      ValaCCodeCommaExpression* ccomma;
      ValaProfile _tmp97_;
      ValaCCodeConstant* _tmp146_ = NULL;
      ValaCCodeConstant* _tmp147_;
      ValaCCodeAssignment* _tmp148_ = NULL;
      ValaCCodeAssignment* cassign;
      gboolean _tmp149_ = FALSE;
      gboolean _tmp150_ = FALSE;
      ValaTypeSymbol* _tmp151_ = NULL;
      gboolean uses_gfree;
      gboolean _tmp157_ = FALSE;
      ValaCCodeConstant* _tmp158_ = NULL;
      ValaCCodeConstant* _tmp159_;
      ValaCCodeConditionalExpression* _tmp160_ = NULL;
      ValaCCodeExpression* _tmp161_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (value != NULL, NULL);
      _tmp0_ = vala_target_value_get_value_type (value);
      _tmp1_ = _vala_code_node_ref0 (_tmp0_);
      type = _tmp1_;
      _tmp2_ = vala_ccode_base_module_get_cvalue_ (self, value);
      cvar = _tmp2_;
      if (VALA_IS_DELEGATE_TYPE (type)) {
            ValaCCodeExpression* _tmp3_ = NULL;
            ValaCCodeExpression* delegate_target;
            ValaCCodeExpression* _tmp4_ = NULL;
            ValaCCodeExpression* delegate_target_destroy_notify;
            ValaCCodeFunctionCall* _tmp5_ = NULL;
            ValaCCodeFunctionCall* ccall;
            ValaCCodeCommaExpression* _tmp6_ = NULL;
            ValaCCodeCommaExpression* destroy_call;
            ValaCCodeConstant* _tmp7_ = NULL;
            ValaCCodeConstant* _tmp8_;
            ValaCCodeConstant* _tmp9_ = NULL;
            ValaCCodeConstant* _tmp10_;
            ValaCCodeBinaryExpression* _tmp11_ = NULL;
            ValaCCodeBinaryExpression* _tmp12_;
            ValaCCodeBinaryExpression* cisnull;
            ValaCCodeCommaExpression* _tmp13_ = NULL;
            ValaCCodeCommaExpression* ccomma;
            ValaCCodeConstant* _tmp14_ = NULL;
            ValaCCodeConstant* _tmp15_;
            ValaCCodeConditionalExpression* _tmp16_ = NULL;
            ValaCCodeConditionalExpression* _tmp17_;
            ValaCCodeConstant* _tmp18_ = NULL;
            ValaCCodeConstant* _tmp19_;
            ValaCCodeAssignment* _tmp20_ = NULL;
            ValaCCodeAssignment* _tmp21_;
            ValaCCodeConstant* _tmp22_ = NULL;
            ValaCCodeConstant* _tmp23_;
            ValaCCodeAssignment* _tmp24_ = NULL;
            ValaCCodeAssignment* _tmp25_;
            ValaCCodeConstant* _tmp26_ = NULL;
            ValaCCodeConstant* _tmp27_;
            ValaCCodeAssignment* _tmp28_ = NULL;
            ValaCCodeAssignment* _tmp29_;
            _tmp3_ = vala_ccode_base_module_get_delegate_target_cvalue (self, value);
            delegate_target = _tmp3_;
            _tmp4_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, value);
            delegate_target_destroy_notify = _tmp4_;
            _tmp5_ = vala_ccode_function_call_new (delegate_target_destroy_notify);
            ccall = _tmp5_;
            vala_ccode_function_call_add_argument (ccall, delegate_target);
            _tmp6_ = vala_ccode_comma_expression_new ();
            destroy_call = _tmp6_;
            vala_ccode_comma_expression_append_expression (destroy_call, (ValaCCodeExpression*) ccall);
            _tmp7_ = vala_ccode_constant_new ("NULL");
            _tmp8_ = _tmp7_;
            vala_ccode_comma_expression_append_expression (destroy_call, (ValaCCodeExpression*) _tmp8_);
            _vala_ccode_node_unref0 (_tmp8_);
            _tmp9_ = vala_ccode_constant_new ("NULL");
            _tmp10_ = _tmp9_;
            _tmp11_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, delegate_target_destroy_notify, (ValaCCodeExpression*) _tmp10_);
            _tmp12_ = _tmp11_;
            _vala_ccode_node_unref0 (_tmp10_);
            cisnull = _tmp12_;
            _tmp13_ = vala_ccode_comma_expression_new ();
            ccomma = _tmp13_;
            _tmp14_ = vala_ccode_constant_new ("NULL");
            _tmp15_ = _tmp14_;
            _tmp16_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) cisnull, (ValaCCodeExpression*) _tmp15_, (ValaCCodeExpression*) destroy_call);
            _tmp17_ = _tmp16_;
            vala_ccode_comma_expression_append_expression (ccomma, (ValaCCodeExpression*) _tmp17_);
            _vala_ccode_node_unref0 (_tmp17_);
            _vala_ccode_node_unref0 (_tmp15_);
            _tmp18_ = vala_ccode_constant_new ("NULL");
            _tmp19_ = _tmp18_;
            _tmp20_ = vala_ccode_assignment_new (cvar, (ValaCCodeExpression*) _tmp19_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
            _tmp21_ = _tmp20_;
            vala_ccode_comma_expression_append_expression (ccomma, (ValaCCodeExpression*) _tmp21_);
            _vala_ccode_node_unref0 (_tmp21_);
            _vala_ccode_node_unref0 (_tmp19_);
            _tmp22_ = vala_ccode_constant_new ("NULL");
            _tmp23_ = _tmp22_;
            _tmp24_ = vala_ccode_assignment_new (delegate_target, (ValaCCodeExpression*) _tmp23_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
            _tmp25_ = _tmp24_;
            vala_ccode_comma_expression_append_expression (ccomma, (ValaCCodeExpression*) _tmp25_);
            _vala_ccode_node_unref0 (_tmp25_);
            _vala_ccode_node_unref0 (_tmp23_);
            _tmp26_ = vala_ccode_constant_new ("NULL");
            _tmp27_ = _tmp26_;
            _tmp28_ = vala_ccode_assignment_new (delegate_target_destroy_notify, (ValaCCodeExpression*) _tmp27_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
            _tmp29_ = _tmp28_;
            vala_ccode_comma_expression_append_expression (ccomma, (ValaCCodeExpression*) _tmp29_);
            _vala_ccode_node_unref0 (_tmp29_);
            _vala_ccode_node_unref0 (_tmp27_);
            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;
      }
      _tmp30_ = vala_ccode_base_module_get_destroy_func_expression (self, type, FALSE);
      _tmp31_ = _tmp30_;
      _tmp32_ = vala_ccode_function_call_new (_tmp31_);
      _tmp33_ = _tmp32_;
      _vala_ccode_node_unref0 (_tmp31_);
      ccall = _tmp33_;
      if (VALA_IS_VALUE_TYPE (type)) {
            gboolean _tmp35_;
            _tmp35_ = vala_data_type_get_nullable (type);
            _tmp34_ = !_tmp35_;
      } else {
            _tmp34_ = FALSE;
      }
      if (_tmp34_) {
            ValaTypeSymbol* _tmp36_ = NULL;
            ValaTypeSymbol* _tmp37_;
            ValaStruct* _tmp38_;
            ValaStruct* st;
            gboolean _tmp39_ = FALSE;
            gboolean _tmp43_ = FALSE;
            _tmp36_ = vala_data_type_get_data_type (type);
            _tmp37_ = _tmp36_;
            _tmp38_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp37_) ? ((ValaStruct*) _tmp37_) : NULL);
            st = _tmp38_;
            if (st != NULL) {
                  gboolean _tmp40_;
                  _tmp40_ = vala_struct_is_simple_type (st);
                  _tmp39_ = _tmp40_;
            } else {
                  _tmp39_ = FALSE;
            }
            if (_tmp39_) {
                  vala_ccode_function_call_add_argument (ccall, cvar);
            } else {
                  ValaCCodeUnaryExpression* _tmp41_ = NULL;
                  ValaCCodeUnaryExpression* _tmp42_;
                  _tmp41_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, cvar);
                  _tmp42_ = _tmp41_;
                  vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp42_);
                  _vala_ccode_node_unref0 (_tmp42_);
            }
            if (self->gvalue_type != NULL) {
                  ValaTypeSymbol* _tmp44_ = NULL;
                  _tmp44_ = vala_data_type_get_data_type (type);
                  _tmp43_ = _tmp44_ == VALA_TYPESYMBOL (self->gvalue_type);
            } else {
                  _tmp43_ = FALSE;
            }
            if (_tmp43_) {
                  ValaCCodeIdentifier* _tmp45_ = NULL;
                  ValaCCodeIdentifier* _tmp46_;
                  ValaCCodeFunctionCall* _tmp47_ = NULL;
                  ValaCCodeFunctionCall* _tmp48_;
                  ValaCCodeFunctionCall* cisvalid;
                  ValaCCodeUnaryExpression* _tmp49_ = NULL;
                  ValaCCodeUnaryExpression* _tmp50_;
                  ValaCCodeCommaExpression* _tmp51_ = NULL;
                  ValaCCodeCommaExpression* ccomma;
                  ValaCCodeConstant* _tmp52_ = NULL;
                  ValaCCodeConstant* _tmp53_;
                  ValaCCodeConstant* _tmp54_ = NULL;
                  ValaCCodeConstant* _tmp55_;
                  ValaCCodeConditionalExpression* _tmp56_ = NULL;
                  ValaCCodeExpression* _tmp57_;
                  _tmp45_ = vala_ccode_identifier_new ("G_IS_VALUE");
                  _tmp46_ = _tmp45_;
                  _tmp47_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp46_);
                  _tmp48_ = _tmp47_;
                  _vala_ccode_node_unref0 (_tmp46_);
                  cisvalid = _tmp48_;
                  _tmp49_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, cvar);
                  _tmp50_ = _tmp49_;
                  vala_ccode_function_call_add_argument (cisvalid, (ValaCCodeExpression*) _tmp50_);
                  _vala_ccode_node_unref0 (_tmp50_);
                  _tmp51_ = vala_ccode_comma_expression_new ();
                  ccomma = _tmp51_;
                  vala_ccode_comma_expression_append_expression (ccomma, (ValaCCodeExpression*) ccall);
                  _tmp52_ = vala_ccode_constant_new ("NULL");
                  _tmp53_ = _tmp52_;
                  vala_ccode_comma_expression_append_expression (ccomma, (ValaCCodeExpression*) _tmp53_);
                  _vala_ccode_node_unref0 (_tmp53_);
                  _tmp54_ = vala_ccode_constant_new ("NULL");
                  _tmp55_ = _tmp54_;
                  _tmp56_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) cisvalid, (ValaCCodeExpression*) ccomma, (ValaCCodeExpression*) _tmp55_);
                  _tmp57_ = (ValaCCodeExpression*) _tmp56_;
                  _vala_ccode_node_unref0 (_tmp55_);
                  result = _tmp57_;
                  _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 {
                  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);
      }
      _tmp60_ = vala_ccode_function_call_get_call (ccall);
      if (VALA_IS_CCODE_IDENTIFIER (_tmp60_)) {
            _tmp59_ = !VALA_IS_ARRAY_TYPE (type);
      } else {
            _tmp59_ = FALSE;
      }
      if (_tmp59_) {
            _tmp58_ = !is_macro_definition;
      } else {
            _tmp58_ = FALSE;
      }
      if (_tmp58_) {
            ValaCCodeExpression* _tmp61_ = NULL;
            ValaCCodeIdentifier* _tmp62_;
            ValaCCodeIdentifier* freeid;
            const gchar* _tmp63_ = NULL;
            gchar* _tmp64_ = NULL;
            gchar* free0_func;
            gboolean _tmp65_;
            ValaCCodeIdentifier* _tmp76_ = NULL;
            ValaCCodeIdentifier* _tmp77_;
            ValaCCodeFunctionCall* _tmp78_ = NULL;
            _tmp61_ = vala_ccode_function_call_get_call (ccall);
            _tmp62_ = _vala_ccode_node_ref0 (VALA_CCODE_IDENTIFIER (_tmp61_));
            freeid = _tmp62_;
            _tmp63_ = vala_ccode_identifier_get_name (freeid);
            _tmp64_ = g_strdup_printf ("_%s0", _tmp63_);
            free0_func = _tmp64_;
            _tmp65_ = vala_ccode_base_module_add_wrapper (self, free0_func);
            if (_tmp65_) {
                  ValaCCodeIdentifier* _tmp66_ = NULL;
                  ValaCCodeIdentifier* _tmp67_;
                  ValaGLibValue* _tmp68_ = NULL;
                  ValaGLibValue* _tmp69_;
                  ValaCCodeExpression* _tmp70_ = NULL;
                  ValaCCodeExpression* _tmp71_;
                  ValaCCodeExpression* macro;
                  gchar* _tmp72_ = NULL;
                  gchar* _tmp73_;
                  ValaCCodeMacroReplacement* _tmp74_ = NULL;
                  ValaCCodeMacroReplacement* _tmp75_;
                  _tmp66_ = vala_ccode_identifier_new ("var");
                  _tmp67_ = _tmp66_;
                  _tmp68_ = vala_glib_value_new (type, (ValaCCodeExpression*) _tmp67_);
                  _tmp69_ = _tmp68_;
                  _tmp70_ = vala_ccode_base_module_destroy_value (self, (ValaTargetValue*) _tmp69_, TRUE);
                  _tmp71_ = _tmp70_;
                  _vala_target_value_unref0 (_tmp69_);
                  _vala_ccode_node_unref0 (_tmp67_);
                  macro = _tmp71_;
                  _tmp72_ = g_strdup_printf ("%s(var)", free0_func);
                  _tmp73_ = _tmp72_;
                  _tmp74_ = vala_ccode_macro_replacement_new_with_expression (_tmp73_, macro);
                  _tmp75_ = _tmp74_;
                  vala_ccode_file_add_type_declaration (self->cfile, (ValaCCodeNode*) _tmp75_);
                  _vala_ccode_node_unref0 (_tmp75_);
                  _g_free0 (_tmp73_);
                  _vala_ccode_node_unref0 (macro);
            }
            _tmp76_ = vala_ccode_identifier_new (free0_func);
            _tmp77_ = _tmp76_;
            _tmp78_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp77_);
            _vala_ccode_node_unref0 (ccall);
            ccall = _tmp78_;
            _vala_ccode_node_unref0 (_tmp77_);
            vala_ccode_function_call_add_argument (ccall, cvar);
            result = (ValaCCodeExpression*) ccall;
            _g_free0 (free0_func);
            _vala_ccode_node_unref0 (freeid);
            _vala_ccode_node_unref0 (cvar);
            _vala_code_node_unref0 (type);
            return result;
      }
      _tmp79_ = vala_ccode_constant_new ("NULL");
      _tmp80_ = _tmp79_;
      _tmp81_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, cvar, (ValaCCodeExpression*) _tmp80_);
      _tmp82_ = _tmp81_;
      _vala_ccode_node_unref0 (_tmp80_);
      cisnull = _tmp82_;
      _tmp83_ = vala_data_type_get_type_parameter (type);
      if (_tmp83_ != NULL) {
            gboolean _tmp84_ = FALSE;
            ValaTypeSymbol* _tmp85_ = NULL;
            ValaCCodeExpression* _tmp89_ = NULL;
            ValaCCodeExpression* _tmp90_;
            ValaCCodeConstant* _tmp91_ = NULL;
            ValaCCodeConstant* _tmp92_;
            ValaCCodeBinaryExpression* _tmp93_ = NULL;
            ValaCCodeBinaryExpression* _tmp94_;
            ValaCCodeBinaryExpression* cunrefisnull;
            ValaCCodeBinaryExpression* _tmp95_ = NULL;
            _tmp85_ = vala_ccode_base_module_get_current_type_symbol (self);
            if (!VALA_IS_CLASS (_tmp85_)) {
                  _tmp84_ = TRUE;
            } else {
                  ValaClass* _tmp86_ = NULL;
                  gboolean _tmp87_;
                  _tmp86_ = vala_ccode_base_module_get_current_class (self);
                  _tmp87_ = vala_class_get_is_compact (_tmp86_);
                  _tmp84_ = _tmp87_;
            }
            if (_tmp84_) {
                  ValaCCodeConstant* _tmp88_ = NULL;
                  _tmp88_ = vala_ccode_constant_new ("NULL");
                  result = (ValaCCodeExpression*) _tmp88_;
                  _vala_ccode_node_unref0 (cisnull);
                  _vala_ccode_node_unref0 (ccall);
                  _vala_ccode_node_unref0 (cvar);
                  _vala_code_node_unref0 (type);
                  return result;
            }
            _tmp89_ = vala_ccode_base_module_get_destroy_func_expression (self, type, FALSE);
            _tmp90_ = _tmp89_;
            _tmp91_ = vala_ccode_constant_new ("NULL");
            _tmp92_ = _tmp91_;
            _tmp93_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, _tmp90_, (ValaCCodeExpression*) _tmp92_);
            _tmp94_ = _tmp93_;
            _vala_ccode_node_unref0 (_tmp92_);
            _vala_ccode_node_unref0 (_tmp90_);
            cunrefisnull = _tmp94_;
            _tmp95_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_OR, (ValaCCodeExpression*) cisnull, (ValaCCodeExpression*) cunrefisnull);
            _vala_ccode_node_unref0 (cisnull);
            cisnull = _tmp95_;
            _vala_ccode_node_unref0 (cunrefisnull);
      }
      vala_ccode_function_call_add_argument (ccall, cvar);
      _tmp96_ = vala_ccode_comma_expression_new ();
      ccomma = _tmp96_;
      _tmp97_ = vala_code_context_get_profile (self->priv->_context);
      if (_tmp97_ == VALA_PROFILE_GOBJECT) {
            gboolean _tmp98_ = FALSE;
            gboolean _tmp99_ = FALSE;
            ValaTypeSymbol* _tmp100_ = NULL;
            _tmp100_ = vala_data_type_get_data_type (type);
            if (_tmp100_ != NULL) {
                  ValaTypeSymbol* _tmp101_ = NULL;
                  gboolean _tmp102_;
                  _tmp101_ = vala_data_type_get_data_type (type);
                  _tmp102_ = vala_typesymbol_is_reference_counting (_tmp101_);
                  _tmp99_ = !_tmp102_;
            } else {
                  _tmp99_ = FALSE;
            }
            if (_tmp99_) {
                  gboolean _tmp103_ = FALSE;
                  gboolean _tmp104_ = FALSE;
                  gboolean _tmp105_ = FALSE;
                  ValaTypeSymbol* _tmp106_ = NULL;
                  _tmp106_ = vala_data_type_get_data_type (type);
                  if (_tmp106_ == self->gstringbuilder_type) {
                        _tmp105_ = TRUE;
                  } else {
                        ValaTypeSymbol* _tmp107_ = NULL;
                        _tmp107_ = vala_data_type_get_data_type (type);
                        _tmp105_ = _tmp107_ == self->garray_type;
                  }
                  if (_tmp105_) {
                        _tmp104_ = TRUE;
                  } else {
                        ValaTypeSymbol* _tmp108_ = NULL;
                        _tmp108_ = vala_data_type_get_data_type (type);
                        _tmp104_ = _tmp108_ == self->gbytearray_type;
                  }
                  if (_tmp104_) {
                        _tmp103_ = TRUE;
                  } else {
                        ValaTypeSymbol* _tmp109_ = NULL;
                        _tmp109_ = vala_data_type_get_data_type (type);
                        _tmp103_ = _tmp109_ == self->gptrarray_type;
                  }
                  _tmp98_ = _tmp103_;
            } else {
                  _tmp98_ = FALSE;
            }
            if (_tmp98_) {
                  ValaCCodeConstant* _tmp110_ = NULL;
                  ValaCCodeConstant* _tmp111_;
                  _tmp110_ = vala_ccode_constant_new ("TRUE");
                  _tmp111_ = _tmp110_;
                  vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp111_);
                  _vala_ccode_node_unref0 (_tmp111_);
            } else {
                  ValaTypeSymbol* _tmp112_ = NULL;
                  _tmp112_ = vala_data_type_get_data_type (type);
                  if (_tmp112_ == self->gthreadpool_type) {
                        ValaCCodeConstant* _tmp113_ = NULL;
                        ValaCCodeConstant* _tmp114_;
                        ValaCCodeConstant* _tmp115_ = NULL;
                        ValaCCodeConstant* _tmp116_;
                        _tmp113_ = vala_ccode_constant_new ("FALSE");
                        _tmp114_ = _tmp113_;
                        vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp114_);
                        _vala_ccode_node_unref0 (_tmp114_);
                        _tmp115_ = vala_ccode_constant_new ("TRUE");
                        _tmp116_ = _tmp115_;
                        vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp116_);
                        _vala_ccode_node_unref0 (_tmp116_);
                  } else {
                        if (VALA_IS_ARRAY_TYPE (type)) {
                              ValaArrayType* _tmp117_;
                              ValaArrayType* array_type;
                              ValaDataType* _tmp118_ = NULL;
                              gboolean _tmp119_;
                              _tmp117_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (type));
                              array_type = _tmp117_;
                              _tmp118_ = vala_array_type_get_element_type (array_type);
                              _tmp119_ = vala_ccode_base_module_requires_destroy (self, _tmp118_);
                              if (_tmp119_) {
                                    ValaCCodeExpression* csizeexpr;
                                    csizeexpr = NULL;
                                    if (VALA_GLIB_VALUE (value)->array_length_cvalues != NULL) {
                                          ValaCCodeExpression* _tmp120_ = NULL;
                                          _tmp120_ = vala_ccode_base_module_get_array_length_cvalue (self, value, -1);
                                          _vala_ccode_node_unref0 (csizeexpr);
                                          csizeexpr = _tmp120_;
                                    } else {
                                          gboolean _tmp121_;
                                          _tmp121_ = vala_ccode_base_module_get_array_null_terminated (self, value);
                                          if (_tmp121_) {
                                                ValaCCodeIdentifier* _tmp122_ = NULL;
                                                ValaCCodeIdentifier* _tmp123_;
                                                ValaCCodeFunctionCall* _tmp124_ = NULL;
                                                ValaCCodeFunctionCall* _tmp125_;
                                                ValaCCodeFunctionCall* len_call;
                                                ValaCCodeExpression* _tmp126_;
                                                self->requires_array_length = TRUE;
                                                _tmp122_ = vala_ccode_identifier_new ("_vala_array_length");
                                                _tmp123_ = _tmp122_;
                                                _tmp124_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp123_);
                                                _tmp125_ = _tmp124_;
                                                _vala_ccode_node_unref0 (_tmp123_);
                                                len_call = _tmp125_;
                                                vala_ccode_function_call_add_argument (len_call, cvar);
                                                _tmp126_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) len_call);
                                                _vala_ccode_node_unref0 (csizeexpr);
                                                csizeexpr = _tmp126_;
                                                _vala_ccode_node_unref0 (len_call);
                                          } else {
                                                ValaCCodeExpression* _tmp127_ = NULL;
                                                _tmp127_ = vala_ccode_base_module_get_array_length_cexpr (self, value);
                                                _vala_ccode_node_unref0 (csizeexpr);
                                                csizeexpr = _tmp127_;
                                          }
                                    }
                                    if (csizeexpr != NULL) {
                                          ValaDataType* _tmp128_ = NULL;
                                          ValaTypeSymbol* _tmp129_ = NULL;
                                          ValaTypeSymbol* _tmp130_;
                                          ValaStruct* _tmp131_;
                                          ValaStruct* st;
                                          gboolean _tmp132_ = FALSE;
                                          _tmp128_ = vala_array_type_get_element_type (array_type);
                                          _tmp129_ = vala_data_type_get_data_type (_tmp128_);
                                          _tmp130_ = _tmp129_;
                                          _tmp131_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp130_) ? ((ValaStruct*) _tmp130_) : NULL);
                                          st = _tmp131_;
                                          if (st != NULL) {
                                                ValaDataType* _tmp133_ = NULL;
                                                gboolean _tmp134_;
                                                _tmp133_ = vala_array_type_get_element_type (array_type);
                                                _tmp134_ = vala_data_type_get_nullable (_tmp133_);
                                                _tmp132_ = !_tmp134_;
                                          } else {
                                                _tmp132_ = FALSE;
                                          }
                                          if (_tmp132_) {
                                                gchar* _tmp135_ = NULL;
                                                gchar* _tmp136_;
                                                ValaCCodeIdentifier* _tmp137_ = NULL;
                                                ValaCCodeIdentifier* _tmp138_;
                                                _tmp135_ = vala_ccode_base_module_append_struct_array_free (self, st);
                                                _tmp136_ = _tmp135_;
                                                _tmp137_ = vala_ccode_identifier_new (_tmp136_);
                                                _tmp138_ = _tmp137_;
                                                vala_ccode_function_call_set_call (ccall, (ValaCCodeExpression*) _tmp138_);
                                                _vala_ccode_node_unref0 (_tmp138_);
                                                _g_free0 (_tmp136_);
                                                vala_ccode_function_call_add_argument (ccall, csizeexpr);
                                          } else {
                                                ValaCCodeIdentifier* _tmp139_ = NULL;
                                                ValaCCodeIdentifier* _tmp140_;
                                                ValaDataType* _tmp141_ = NULL;
                                                ValaCCodeExpression* _tmp142_ = NULL;
                                                ValaCCodeExpression* _tmp143_;
                                                ValaCCodeCastExpression* _tmp144_ = NULL;
                                                ValaCCodeCastExpression* _tmp145_;
                                                self->requires_array_free = TRUE;
                                                _tmp139_ = vala_ccode_identifier_new ("_vala_array_free");
                                                _tmp140_ = _tmp139_;
                                                vala_ccode_function_call_set_call (ccall, (ValaCCodeExpression*) _tmp140_);
                                                _vala_ccode_node_unref0 (_tmp140_);
                                                vala_ccode_function_call_add_argument (ccall, csizeexpr);
                                                _tmp141_ = vala_array_type_get_element_type (array_type);
                                                _tmp142_ = vala_ccode_base_module_get_destroy_func_expression (self, _tmp141_, FALSE);
                                                _tmp143_ = _tmp142_;
                                                _tmp144_ = vala_ccode_cast_expression_new (_tmp143_, "GDestroyNotify");
                                                _tmp145_ = _tmp144_;
                                                vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp145_);
                                                _vala_ccode_node_unref0 (_tmp145_);
                                                _vala_ccode_node_unref0 (_tmp143_);
                                          }
                                          _vala_code_node_unref0 (st);
                                    }
                                    _vala_ccode_node_unref0 (csizeexpr);
                              }
                              _vala_code_node_unref0 (array_type);
                        }
                  }
            }
      }
      vala_ccode_comma_expression_append_expression (ccomma, (ValaCCodeExpression*) ccall);
      _tmp146_ = vala_ccode_constant_new ("NULL");
      _tmp147_ = _tmp146_;
      vala_ccode_comma_expression_append_expression (ccomma, (ValaCCodeExpression*) _tmp147_);
      _vala_ccode_node_unref0 (_tmp147_);
      _tmp148_ = vala_ccode_assignment_new (cvar, (ValaCCodeExpression*) ccomma, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
      cassign = _tmp148_;
      _tmp151_ = vala_data_type_get_data_type (type);
      if (_tmp151_ != NULL) {
            ValaTypeSymbol* _tmp152_ = NULL;
            gboolean _tmp153_;
            _tmp152_ = vala_data_type_get_data_type (type);
            _tmp153_ = vala_typesymbol_is_reference_counting (_tmp152_);
            _tmp150_ = !_tmp153_;
      } else {
            _tmp150_ = FALSE;
      }
      if (_tmp150_) {
            ValaTypeSymbol* _tmp154_ = NULL;
            gchar* _tmp155_ = NULL;
            gchar* _tmp156_;
            _tmp154_ = vala_data_type_get_data_type (type);
            _tmp155_ = vala_typesymbol_get_free_function (_tmp154_);
            _tmp156_ = _tmp155_;
            _tmp149_ = g_strcmp0 (_tmp156_, "g_free") == 0;
            _g_free0 (_tmp156_);
      } else {
            _tmp149_ = FALSE;
      }
      uses_gfree = _tmp149_;
      if (uses_gfree) {
            _tmp157_ = TRUE;
      } else {
            _tmp157_ = VALA_IS_ARRAY_TYPE (type);
      }
      uses_gfree = _tmp157_;
      if (uses_gfree) {
            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;
      }
      _tmp158_ = vala_ccode_constant_new ("NULL");
      _tmp159_ = _tmp158_;
      _tmp160_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) cisnull, (ValaCCodeExpression*) _tmp159_, (ValaCCodeExpression*) cassign);
      _tmp161_ = (ValaCCodeExpression*) _tmp160_;
      _vala_ccode_node_unref0 (_tmp159_);
      result = _tmp161_;
      _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) {
      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_ = NULL;
      gint _tmp1_;
      ValaLocalVariable* full_expr_var;
      ValaCodeNode* _tmp2_ = NULL;
      ValaCodeNode* _tmp3_;
      ValaLocalVariable* _tmp4_;
      ValaLocalVariable* local_decl;
      gboolean _tmp5_ = FALSE;
      ValaArrayList* _tmp29_ = NULL;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (expr != NULL);
      _tmp0_ = vala_ccode_base_module_get_temp_ref_vars (self);
      _tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
      if (_tmp1_ == 0) {
            return;
      }
      full_expr_var = NULL;
      _tmp2_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr);
      _tmp3_ = _tmp2_;
      _tmp4_ = _vala_code_node_ref0 (VALA_IS_LOCAL_VARIABLE (_tmp3_) ? ((ValaLocalVariable*) _tmp3_) : NULL);
      local_decl = _tmp4_;
      if (local_decl != NULL) {
            gboolean _tmp6_;
            _tmp6_ = vala_ccode_base_module_has_simple_struct_initializer (self, local_decl);
            _tmp5_ = _tmp6_;
      } else {
            _tmp5_ = FALSE;
      }
      if (!_tmp5_) {
            ValaDataType* _tmp7_ = NULL;
            ValaDataType* _tmp8_;
            ValaDataType* expr_type;
            ValaDataType* _tmp9_ = NULL;
            ValaLocalVariable* _tmp12_ = NULL;
            ValaCCodeFunction* _tmp13_ = NULL;
            const gchar* _tmp14_ = NULL;
            ValaCCodeExpression* _tmp15_ = NULL;
            ValaCCodeExpression* _tmp16_;
            ValaCCodeExpression* _tmp17_ = NULL;
            ValaCCodeExpression* _tmp18_;
            _tmp7_ = vala_expression_get_value_type (expr);
            _tmp8_ = _vala_code_node_ref0 (_tmp7_);
            expr_type = _tmp8_;
            _tmp9_ = vala_expression_get_target_type (expr);
            if (_tmp9_ != NULL) {
                  ValaDataType* _tmp10_ = NULL;
                  ValaDataType* _tmp11_;
                  _tmp10_ = vala_expression_get_target_type (expr);
                  _tmp11_ = _vala_code_node_ref0 (_tmp10_);
                  _vala_code_node_unref0 (expr_type);
                  expr_type = _tmp11_;
            }
            _tmp12_ = vala_ccode_base_module_get_temp_variable (self, expr_type, TRUE, (ValaCodeNode*) expr, FALSE);
            _vala_code_node_unref0 (full_expr_var);
            full_expr_var = _tmp12_;
            vala_ccode_base_module_emit_temp_var (self, full_expr_var, FALSE);
            _tmp13_ = vala_ccode_base_module_get_ccode (self);
            _tmp14_ = vala_symbol_get_name ((ValaSymbol*) full_expr_var);
            _tmp15_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp14_);
            _tmp16_ = _tmp15_;
            _tmp17_ = vala_ccode_base_module_get_cvalue (self, expr);
            _tmp18_ = _tmp17_;
            vala_ccode_function_add_assignment (_tmp13_, _tmp16_, _tmp18_);
            _vala_ccode_node_unref0 (_tmp18_);
            _vala_ccode_node_unref0 (_tmp16_);
            _vala_code_node_unref0 (expr_type);
      }
      {
            ValaArrayList* _tmp19_ = NULL;
            ValaArrayList* _tmp20_;
            ValaArrayList* _local_list;
            gint _tmp21_;
            gint _local_size;
            gint _local_index;
            _tmp19_ = vala_ccode_base_module_get_temp_ref_vars (self);
            _tmp20_ = _vala_iterable_ref0 (_tmp19_);
            _local_list = _tmp20_;
            _tmp21_ = vala_collection_get_size ((ValaCollection*) _local_list);
            _local_size = _tmp21_;
            _local_index = -1;
            while (TRUE) {
                  gpointer _tmp22_ = NULL;
                  ValaLocalVariable* local;
                  ValaCCodeFunction* _tmp23_ = NULL;
                  ValaCCodeExpression* _tmp24_ = NULL;
                  ValaCCodeExpression* _tmp25_;
                  _local_index = _local_index + 1;
                  if (!(_local_index < _local_size)) {
                        break;
                  }
                  _tmp22_ = vala_list_get ((ValaList*) _local_list, _local_index);
                  local = (ValaLocalVariable*) _tmp22_;
                  _tmp23_ = vala_ccode_base_module_get_ccode (self);
                  _tmp24_ = vala_ccode_base_module_destroy_local (self, local);
                  _tmp25_ = _tmp24_;
                  vala_ccode_function_add_expression (_tmp23_, _tmp25_);
                  _vala_ccode_node_unref0 (_tmp25_);
                  _vala_code_node_unref0 (local);
            }
            _vala_iterable_unref0 (_local_list);
      }
      if (full_expr_var != NULL) {
            const gchar* _tmp26_ = NULL;
            ValaCCodeExpression* _tmp27_ = NULL;
            ValaCCodeExpression* _tmp28_;
            _tmp26_ = vala_symbol_get_name ((ValaSymbol*) full_expr_var);
            _tmp27_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp26_);
            _tmp28_ = _tmp27_;
            vala_ccode_base_module_set_cvalue (self, expr, _tmp28_);
            _vala_ccode_node_unref0 (_tmp28_);
      }
      _tmp29_ = vala_ccode_base_module_get_temp_ref_vars (self);
      vala_collection_clear ((ValaCollection*) _tmp29_);
      _vala_code_node_unref0 (local_decl);
      _vala_code_node_unref0 (full_expr_var);
}


void vala_ccode_base_module_emit_temp_var (ValaCCodeBaseModule* self, ValaLocalVariable* local, gboolean always_init) {
      const gchar* _tmp0_ = NULL;
      ValaDataType* _tmp1_ = NULL;
      gchar* _tmp2_ = NULL;
      gchar* _tmp3_;
      ValaCCodeVariableDeclarator* _tmp4_ = NULL;
      ValaCCodeVariableDeclarator* _tmp5_;
      ValaCCodeVariableDeclarator* vardecl;
      ValaDataType* _tmp6_ = NULL;
      ValaTypeSymbol* _tmp7_ = NULL;
      ValaTypeSymbol* _tmp8_;
      ValaStruct* _tmp9_;
      ValaStruct* st;
      ValaDataType* _tmp10_ = NULL;
      ValaDataType* _tmp11_;
      ValaArrayType* _tmp12_;
      ValaArrayType* array_type;
      const gchar* _tmp13_ = NULL;
      gboolean _tmp14_;
      gboolean _tmp39_;
      g_return_if_fail (self != NULL);
      g_return_if_fail (local != NULL);
      _tmp0_ = vala_symbol_get_name ((ValaSymbol*) local);
      _tmp1_ = vala_variable_get_variable_type ((ValaVariable*) local);
      _tmp2_ = vala_data_type_get_cdeclarator_suffix (_tmp1_);
      _tmp3_ = _tmp2_;
      _tmp4_ = vala_ccode_variable_declarator_new (_tmp0_, NULL, _tmp3_);
      _tmp5_ = _tmp4_;
      _g_free0 (_tmp3_);
      vardecl = _tmp5_;
      _tmp6_ = vala_variable_get_variable_type ((ValaVariable*) local);
      _tmp7_ = vala_data_type_get_data_type (_tmp6_);
      _tmp8_ = _tmp7_;
      _tmp9_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp8_) ? ((ValaStruct*) _tmp8_) : NULL);
      st = _tmp9_;
      _tmp10_ = vala_variable_get_variable_type ((ValaVariable*) local);
      _tmp11_ = _tmp10_;
      _tmp12_ = _vala_code_node_ref0 (VALA_IS_ARRAY_TYPE (_tmp11_) ? ((ValaArrayType*) _tmp11_) : NULL);
      array_type = _tmp12_;
      _tmp13_ = vala_symbol_get_name ((ValaSymbol*) local);
      _tmp14_ = g_str_has_prefix (_tmp13_, "*");
      if (_tmp14_) {
      } else {
            gboolean _tmp15_;
            _tmp15_ = vala_local_variable_get_no_init (local);
            if (_tmp15_) {
            } else {
                  gboolean _tmp16_ = FALSE;
                  gboolean _tmp17_ = FALSE;
                  ValaDataType* _tmp18_ = NULL;
                  gboolean _tmp19_;
                  _tmp18_ = vala_variable_get_variable_type ((ValaVariable*) local);
                  _tmp19_ = vala_data_type_get_nullable (_tmp18_);
                  if (!_tmp19_) {
                        gboolean _tmp20_ = FALSE;
                        if (st != NULL) {
                              gboolean _tmp21_;
                              _tmp21_ = vala_struct_is_simple_type (st);
                              _tmp20_ = !_tmp21_;
                        } else {
                              _tmp20_ = FALSE;
                        }
                        _tmp17_ = _tmp20_;
                  } else {
                        _tmp17_ = FALSE;
                  }
                  if (_tmp17_) {
                        _tmp16_ = TRUE;
                  } else {
                        gboolean _tmp22_ = FALSE;
                        if (array_type != NULL) {
                              gboolean _tmp23_;
                              _tmp23_ = vala_array_type_get_fixed_length (array_type);
                              _tmp22_ = _tmp23_;
                        } else {
                              _tmp22_ = FALSE;
                        }
                        _tmp16_ = _tmp22_;
                  }
                  if (_tmp16_) {
                        ValaCCodeInitializerList* _tmp24_ = NULL;
                        ValaCCodeInitializerList* clist;
                        ValaCCodeConstant* _tmp25_ = NULL;
                        ValaCCodeConstant* _tmp26_;
                        _tmp24_ = vala_ccode_initializer_list_new ();
                        clist = _tmp24_;
                        _tmp25_ = vala_ccode_constant_new ("0");
                        _tmp26_ = _tmp25_;
                        vala_ccode_initializer_list_append (clist, (ValaCCodeExpression*) _tmp26_);
                        _vala_ccode_node_unref0 (_tmp26_);
                        vala_ccode_variable_declarator_set_initializer (vardecl, (ValaCCodeExpression*) clist);
                        vala_ccode_variable_declarator_set_init0 (vardecl, TRUE);
                        _vala_ccode_node_unref0 (clist);
                  } else {
                        gboolean _tmp27_ = FALSE;
                        gboolean _tmp28_ = FALSE;
                        ValaDataType* _tmp29_ = NULL;
                        gboolean _tmp30_;
                        _tmp29_ = vala_variable_get_variable_type ((ValaVariable*) local);
                        _tmp30_ = vala_data_type_is_reference_type_or_type_parameter (_tmp29_);
                        if (_tmp30_) {
                              _tmp28_ = TRUE;
                        } else {
                              ValaDataType* _tmp31_ = NULL;
                              gboolean _tmp32_;
                              _tmp31_ = vala_variable_get_variable_type ((ValaVariable*) local);
                              _tmp32_ = vala_data_type_get_nullable (_tmp31_);
                              _tmp28_ = _tmp32_;
                        }
                        if (_tmp28_) {
                              _tmp27_ = TRUE;
                        } else {
                              ValaDataType* _tmp33_ = NULL;
                              _tmp33_ = vala_variable_get_variable_type ((ValaVariable*) local);
                              _tmp27_ = VALA_IS_DELEGATE_TYPE (_tmp33_);
                        }
                        if (_tmp27_) {
                              ValaCCodeConstant* _tmp34_ = NULL;
                              ValaCCodeConstant* _tmp35_;
                              _tmp34_ = vala_ccode_constant_new ("NULL");
                              _tmp35_ = _tmp34_;
                              vala_ccode_variable_declarator_set_initializer (vardecl, (ValaCCodeExpression*) _tmp35_);
                              _vala_ccode_node_unref0 (_tmp35_);
                              vala_ccode_variable_declarator_set_init0 (vardecl, TRUE);
                        } else {
                              if (always_init) {
                                    ValaDataType* _tmp36_ = NULL;
                                    ValaCCodeExpression* _tmp37_ = NULL;
                                    ValaCCodeExpression* _tmp38_;
                                    _tmp36_ = vala_variable_get_variable_type ((ValaVariable*) local);
                                    _tmp37_ = vala_ccode_base_module_default_value_for_type (self, _tmp36_, TRUE);
                                    _tmp38_ = _tmp37_;
                                    vala_ccode_variable_declarator_set_initializer (vardecl, _tmp38_);
                                    _vala_ccode_node_unref0 (_tmp38_);
                                    vala_ccode_variable_declarator_set_init0 (vardecl, TRUE);
                              }
                        }
                  }
            }
      }
      _tmp39_ = vala_ccode_base_module_is_in_coroutine (self);
      if (_tmp39_) {
            ValaDataType* _tmp40_ = NULL;
            gchar* _tmp41_ = NULL;
            gchar* _tmp42_;
            const gchar* _tmp43_ = NULL;
            ValaCCodeExpression* _tmp44_ = NULL;
            _tmp40_ = vala_variable_get_variable_type ((ValaVariable*) local);
            _tmp41_ = vala_data_type_get_cname (_tmp40_);
            _tmp42_ = _tmp41_;
            _tmp43_ = vala_symbol_get_name ((ValaSymbol*) local);
            vala_ccode_struct_add_field (self->closure_struct, _tmp42_, _tmp43_, NULL);
            _g_free0 (_tmp42_);
            _tmp44_ = vala_ccode_variable_declarator_get_initializer (vardecl);
            if (VALA_IS_CCODE_INITIALIZER_LIST (_tmp44_)) {
                  ValaCCodeIdentifier* _tmp45_ = NULL;
                  ValaCCodeIdentifier* _tmp46_;
                  ValaCCodeFunctionCall* _tmp47_ = NULL;
                  ValaCCodeFunctionCall* _tmp48_;
                  ValaCCodeFunctionCall* memset_call;
                  const gchar* _tmp49_ = NULL;
                  ValaCCodeExpression* _tmp50_ = NULL;
                  ValaCCodeExpression* _tmp51_;
                  ValaCCodeUnaryExpression* _tmp52_ = NULL;
                  ValaCCodeUnaryExpression* _tmp53_;
                  ValaCCodeConstant* _tmp54_ = NULL;
                  ValaCCodeConstant* _tmp55_;
                  ValaDataType* _tmp56_ = NULL;
                  gchar* _tmp57_ = NULL;
                  gchar* _tmp58_;
                  gchar* _tmp59_ = NULL;
                  gchar* _tmp60_;
                  ValaCCodeIdentifier* _tmp61_ = NULL;
                  ValaCCodeIdentifier* _tmp62_;
                  ValaCCodeFunction* _tmp63_ = NULL;
                  vala_ccode_file_add_include (self->cfile, "string.h", FALSE);
                  _tmp45_ = vala_ccode_identifier_new ("memset");
                  _tmp46_ = _tmp45_;
                  _tmp47_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp46_);
                  _tmp48_ = _tmp47_;
                  _vala_ccode_node_unref0 (_tmp46_);
                  memset_call = _tmp48_;
                  _tmp49_ = vala_symbol_get_name ((ValaSymbol*) local);
                  _tmp50_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp49_);
                  _tmp51_ = _tmp50_;
                  _tmp52_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp51_);
                  _tmp53_ = _tmp52_;
                  vala_ccode_function_call_add_argument (memset_call, (ValaCCodeExpression*) _tmp53_);
                  _vala_ccode_node_unref0 (_tmp53_);
                  _vala_ccode_node_unref0 (_tmp51_);
                  _tmp54_ = vala_ccode_constant_new ("0");
                  _tmp55_ = _tmp54_;
                  vala_ccode_function_call_add_argument (memset_call, (ValaCCodeExpression*) _tmp55_);
                  _vala_ccode_node_unref0 (_tmp55_);
                  _tmp56_ = vala_variable_get_variable_type ((ValaVariable*) local);
                  _tmp57_ = vala_data_type_get_cname (_tmp56_);
                  _tmp58_ = _tmp57_;
                  _tmp59_ = g_strdup_printf ("sizeof (%s)", _tmp58_);
                  _tmp60_ = _tmp59_;
                  _tmp61_ = vala_ccode_identifier_new (_tmp60_);
                  _tmp62_ = _tmp61_;
                  vala_ccode_function_call_add_argument (memset_call, (ValaCCodeExpression*) _tmp62_);
                  _vala_ccode_node_unref0 (_tmp62_);
                  _g_free0 (_tmp60_);
                  _g_free0 (_tmp58_);
                  _tmp63_ = vala_ccode_base_module_get_ccode (self);
                  vala_ccode_function_add_expression (_tmp63_, (ValaCCodeExpression*) memset_call);
                  _vala_ccode_node_unref0 (memset_call);
            } else {
                  ValaCCodeExpression* _tmp64_ = NULL;
                  _tmp64_ = vala_ccode_variable_declarator_get_initializer (vardecl);
                  if (_tmp64_ != NULL) {
                        ValaCCodeFunction* _tmp65_ = NULL;
                        const gchar* _tmp66_ = NULL;
                        ValaCCodeExpression* _tmp67_ = NULL;
                        ValaCCodeExpression* _tmp68_;
                        ValaCCodeExpression* _tmp69_ = NULL;
                        _tmp65_ = vala_ccode_base_module_get_ccode (self);
                        _tmp66_ = vala_symbol_get_name ((ValaSymbol*) local);
                        _tmp67_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp66_);
                        _tmp68_ = _tmp67_;
                        _tmp69_ = vala_ccode_variable_declarator_get_initializer (vardecl);
                        vala_ccode_function_add_assignment (_tmp65_, _tmp68_, _tmp69_);
                        _vala_ccode_node_unref0 (_tmp68_);
                  }
            }
      } else {
            ValaCCodeFunction* _tmp70_ = NULL;
            ValaDataType* _tmp71_ = NULL;
            gchar* _tmp72_ = NULL;
            gchar* _tmp73_;
            _tmp70_ = vala_ccode_base_module_get_ccode (self);
            _tmp71_ = vala_variable_get_variable_type ((ValaVariable*) local);
            _tmp72_ = vala_data_type_get_cname (_tmp71_);
            _tmp73_ = _tmp72_;
            vala_ccode_function_add_declaration (_tmp70_, _tmp73_, (ValaCCodeDeclarator*) vardecl, 0);
            _g_free0 (_tmp73_);
      }
      _vala_code_node_unref0 (array_type);
      _vala_code_node_unref0 (st);
      _vala_ccode_node_unref0 (vardecl);
}


static void vala_ccode_base_module_real_visit_expression_statement (ValaCodeVisitor* base, ValaExpressionStatement* stmt) {
      ValaCCodeBaseModule * self;
      ValaExpression* _tmp0_ = NULL;
      gboolean _tmp1_;
      gboolean _tmp9_ = FALSE;
      gboolean _tmp10_;
      ValaArrayList* _tmp14_ = NULL;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (stmt != NULL);
      _tmp0_ = vala_expression_statement_get_expression (stmt);
      _tmp1_ = vala_code_node_get_error ((ValaCodeNode*) _tmp0_);
      if (_tmp1_) {
            vala_code_node_set_error ((ValaCodeNode*) stmt, TRUE);
            return;
      }
      {
            ValaArrayList* _tmp2_ = NULL;
            ValaArrayList* _tmp3_;
            ValaArrayList* _local_list;
            gint _tmp4_;
            gint _local_size;
            gint _local_index;
            _tmp2_ = vala_ccode_base_module_get_temp_ref_vars (self);
            _tmp3_ = _vala_iterable_ref0 (_tmp2_);
            _local_list = _tmp3_;
            _tmp4_ = vala_collection_get_size ((ValaCollection*) _local_list);
            _local_size = _tmp4_;
            _local_index = -1;
            while (TRUE) {
                  gpointer _tmp5_ = NULL;
                  ValaLocalVariable* local;
                  ValaCCodeFunction* _tmp6_ = NULL;
                  ValaCCodeExpression* _tmp7_ = NULL;
                  ValaCCodeExpression* _tmp8_;
                  _local_index = _local_index + 1;
                  if (!(_local_index < _local_size)) {
                        break;
                  }
                  _tmp5_ = vala_list_get ((ValaList*) _local_list, _local_index);
                  local = (ValaLocalVariable*) _tmp5_;
                  _tmp6_ = vala_ccode_base_module_get_ccode (self);
                  _tmp7_ = vala_ccode_base_module_destroy_local (self, local);
                  _tmp8_ = _tmp7_;
                  vala_ccode_function_add_expression (_tmp6_, _tmp8_);
                  _vala_ccode_node_unref0 (_tmp8_);
                  _vala_code_node_unref0 (local);
            }
            _vala_iterable_unref0 (_local_list);
      }
      _tmp10_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) stmt);
      if (_tmp10_) {
            ValaExpression* _tmp11_ = NULL;
            gboolean _tmp12_;
            _tmp11_ = vala_expression_statement_get_expression (stmt);
            _tmp12_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp11_);
            _tmp9_ = _tmp12_;
      } else {
            _tmp9_ = FALSE;
      }
      if (_tmp9_) {
            ValaExpression* _tmp13_ = NULL;
            _tmp13_ = vala_expression_statement_get_expression (stmt);
            vala_ccode_base_module_add_simple_check (self, (ValaCodeNode*) _tmp13_, FALSE);
      }
      _tmp14_ = vala_ccode_base_module_get_temp_ref_vars (self);
      vala_collection_clear ((ValaCollection*) _tmp14_);
}


static void vala_ccode_base_module_real_append_scope_free (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at) {
      ValaBlock* _tmp0_;
      ValaBlock* b;
      ValaList* _tmp1_ = NULL;
      ValaList* local_vars;
      gboolean _tmp18_;
      g_return_if_fail (self != NULL);
      g_return_if_fail (sym != NULL);
      _tmp0_ = _vala_code_node_ref0 (VALA_BLOCK (sym));
      b = _tmp0_;
      _tmp1_ = vala_block_get_local_variables (b);
      local_vars = _tmp1_;
      {
            gint _tmp2_;
            gint i;
            _tmp2_ = vala_collection_get_size ((ValaCollection*) local_vars);
            i = _tmp2_ - 1;
            {
                  gboolean _tmp3_;
                  _tmp3_ = TRUE;
                  while (TRUE) {
                        gpointer _tmp4_ = NULL;
                        ValaLocalVariable* local;
                        gboolean _tmp5_ = FALSE;
                        gboolean _tmp6_ = FALSE;
                        gboolean _tmp7_ = FALSE;
                        gboolean _tmp8_ = FALSE;
                        gboolean _tmp9_;
                        if (!_tmp3_) {
                              i--;
                        }
                        _tmp3_ = FALSE;
                        if (!(i >= 0)) {
                              break;
                        }
                        _tmp4_ = vala_list_get (local_vars, i);
                        local = (ValaLocalVariable*) _tmp4_;
                        _tmp9_ = vala_code_node_get_unreachable ((ValaCodeNode*) local);
                        if (!_tmp9_) {
                              gboolean _tmp10_;
                              _tmp10_ = vala_symbol_get_active ((ValaSymbol*) local);
                              _tmp8_ = _tmp10_;
                        } else {
                              _tmp8_ = FALSE;
                        }
                        if (_tmp8_) {
                              gboolean _tmp11_;
                              _tmp11_ = vala_local_variable_get_floating (local);
                              _tmp7_ = !_tmp11_;
                        } else {
                              _tmp7_ = FALSE;
                        }
                        if (_tmp7_) {
                              gboolean _tmp12_;
                              _tmp12_ = vala_local_variable_get_captured (local);
                              _tmp6_ = !_tmp12_;
                        } else {
                              _tmp6_ = FALSE;
                        }
                        if (_tmp6_) {
                              ValaDataType* _tmp13_ = NULL;
                              gboolean _tmp14_;
                              _tmp13_ = vala_variable_get_variable_type ((ValaVariable*) local);
                              _tmp14_ = vala_ccode_base_module_requires_destroy (self, _tmp13_);
                              _tmp5_ = _tmp14_;
                        } else {
                              _tmp5_ = FALSE;
                        }
                        if (_tmp5_) {
                              ValaCCodeFunction* _tmp15_ = NULL;
                              ValaCCodeExpression* _tmp16_ = NULL;
                              ValaCCodeExpression* _tmp17_;
                              _tmp15_ = vala_ccode_base_module_get_ccode (self);
                              _tmp16_ = vala_ccode_base_module_destroy_local (self, local);
                              _tmp17_ = _tmp16_;
                              vala_ccode_function_add_expression (_tmp15_, _tmp17_);
                              _vala_ccode_node_unref0 (_tmp17_);
                        }
                        _vala_code_node_unref0 (local);
                  }
            }
      }
      _tmp18_ = vala_block_get_captured (b);
      if (_tmp18_) {
            gint _tmp19_;
            gint block_id;
            gchar* _tmp20_ = NULL;
            gchar* _tmp21_;
            ValaCCodeIdentifier* _tmp22_ = NULL;
            ValaCCodeIdentifier* _tmp23_;
            ValaCCodeFunctionCall* _tmp24_ = NULL;
            ValaCCodeFunctionCall* _tmp25_;
            ValaCCodeFunctionCall* data_unref;
            gchar* _tmp26_ = NULL;
            gchar* _tmp27_;
            ValaCCodeExpression* _tmp28_ = NULL;
            ValaCCodeExpression* _tmp29_;
            ValaCCodeFunction* _tmp30_ = NULL;
            ValaCCodeFunction* _tmp31_ = NULL;
            gchar* _tmp32_ = NULL;
            gchar* _tmp33_;
            ValaCCodeExpression* _tmp34_ = NULL;
            ValaCCodeExpression* _tmp35_;
            ValaCCodeConstant* _tmp36_ = NULL;
            ValaCCodeConstant* _tmp37_;
            _tmp19_ = vala_ccode_base_module_get_block_id (self, b);
            block_id = _tmp19_;
            _tmp20_ = g_strdup_printf ("block%d_data_unref", block_id);
            _tmp21_ = _tmp20_;
            _tmp22_ = vala_ccode_identifier_new (_tmp21_);
            _tmp23_ = _tmp22_;
            _tmp24_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp23_);
            _tmp25_ = _tmp24_;
            _vala_ccode_node_unref0 (_tmp23_);
            _g_free0 (_tmp21_);
            data_unref = _tmp25_;
            _tmp26_ = g_strdup_printf ("_data%d_", block_id);
            _tmp27_ = _tmp26_;
            _tmp28_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp27_);
            _tmp29_ = _tmp28_;
            vala_ccode_function_call_add_argument (data_unref, _tmp29_);
            _vala_ccode_node_unref0 (_tmp29_);
            _g_free0 (_tmp27_);
            _tmp30_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_expression (_tmp30_, (ValaCCodeExpression*) data_unref);
            _tmp31_ = vala_ccode_base_module_get_ccode (self);
            _tmp32_ = g_strdup_printf ("_data%d_", block_id);
            _tmp33_ = _tmp32_;
            _tmp34_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp33_);
            _tmp35_ = _tmp34_;
            _tmp36_ = vala_ccode_constant_new ("NULL");
            _tmp37_ = _tmp36_;
            vala_ccode_function_add_assignment (_tmp31_, _tmp35_, (ValaCCodeExpression*) _tmp37_);
            _vala_ccode_node_unref0 (_tmp37_);
            _vala_ccode_node_unref0 (_tmp35_);
            _g_free0 (_tmp33_);
            _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) {
      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* _tmp0_;
      ValaBlock* b;
      gboolean _tmp6_ = FALSE;
      ValaSymbol* _tmp8_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (sym != NULL);
      _tmp0_ = _vala_code_node_ref0 (VALA_BLOCK (sym));
      b = _tmp0_;
      vala_ccode_base_module_append_scope_free (self, sym, stop_at);
      if (stop_at_loop) {
            gboolean _tmp1_ = FALSE;
            gboolean _tmp2_ = FALSE;
            ValaCodeNode* _tmp3_ = NULL;
            _tmp3_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
            if (VALA_IS_LOOP (_tmp3_)) {
                  _tmp2_ = TRUE;
            } else {
                  ValaCodeNode* _tmp4_ = NULL;
                  _tmp4_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
                  _tmp2_ = VALA_IS_FOREACH_STATEMENT (_tmp4_);
            }
            if (_tmp2_) {
                  _tmp1_ = TRUE;
            } else {
                  ValaCodeNode* _tmp5_ = NULL;
                  _tmp5_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
                  _tmp1_ = VALA_IS_SWITCH_STATEMENT (_tmp5_);
            }
            if (_tmp1_) {
                  _vala_code_node_unref0 (b);
                  return;
            }
      }
      if (stop_at != NULL) {
            ValaCodeNode* _tmp7_ = NULL;
            _tmp7_ = vala_code_node_get_parent_node ((ValaCodeNode*) b);
            _tmp6_ = _tmp7_ == stop_at;
      } else {
            _tmp6_ = FALSE;
      }
      if (_tmp6_) {
            _vala_code_node_unref0 (b);
            return;
      }
      _tmp8_ = vala_symbol_get_parent_symbol (sym);
      if (VALA_IS_BLOCK (_tmp8_)) {
            ValaSymbol* _tmp9_ = NULL;
            _tmp9_ = vala_symbol_get_parent_symbol (sym);
            vala_ccode_base_module_append_local_free (self, _tmp9_, stop_at_loop, stop_at);
      } else {
            ValaSymbol* _tmp10_ = NULL;
            _tmp10_ = vala_symbol_get_parent_symbol (sym);
            if (VALA_IS_METHOD (_tmp10_)) {
                  ValaSymbol* _tmp11_ = NULL;
                  _tmp11_ = vala_symbol_get_parent_symbol (sym);
                  vala_ccode_base_module_append_param_free (self, VALA_METHOD (_tmp11_));
            } else {
                  ValaSymbol* _tmp12_ = NULL;
                  _tmp12_ = vala_symbol_get_parent_symbol (sym);
                  if (VALA_IS_PROPERTY_ACCESSOR (_tmp12_)) {
                        ValaSymbol* _tmp13_ = NULL;
                        ValaPropertyAccessor* _tmp14_;
                        ValaPropertyAccessor* acc;
                        gboolean _tmp15_ = FALSE;
                        ValaParameter* _tmp16_ = NULL;
                        _tmp13_ = vala_symbol_get_parent_symbol (sym);
                        _tmp14_ = _vala_code_node_ref0 (VALA_PROPERTY_ACCESSOR (_tmp13_));
                        acc = _tmp14_;
                        _tmp16_ = vala_property_accessor_get_value_parameter (acc);
                        if (_tmp16_ != NULL) {
                              ValaParameter* _tmp17_ = NULL;
                              ValaDataType* _tmp18_ = NULL;
                              gboolean _tmp19_;
                              _tmp17_ = vala_property_accessor_get_value_parameter (acc);
                              _tmp18_ = vala_variable_get_variable_type ((ValaVariable*) _tmp17_);
                              _tmp19_ = vala_ccode_base_module_requires_destroy (self, _tmp18_);
                              _tmp15_ = _tmp19_;
                        } else {
                              _tmp15_ = FALSE;
                        }
                        if (_tmp15_) {
                              ValaCCodeFunction* _tmp20_ = NULL;
                              ValaParameter* _tmp21_ = NULL;
                              ValaCCodeExpression* _tmp22_ = NULL;
                              ValaCCodeExpression* _tmp23_;
                              _tmp20_ = vala_ccode_base_module_get_ccode (self);
                              _tmp21_ = vala_property_accessor_get_value_parameter (acc);
                              _tmp22_ = vala_ccode_base_module_destroy_parameter (self, _tmp21_);
                              _tmp23_ = _tmp22_;
                              vala_ccode_function_add_expression (_tmp20_, _tmp23_);
                              _vala_ccode_node_unref0 (_tmp23_);
                        }
                        _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* _tmp0_ = NULL;
            ValaList* _param_list;
            gint _tmp1_;
            gint _param_size;
            gint _param_index;
            _tmp0_ = vala_method_get_parameters (m);
            _param_list = _tmp0_;
            _tmp1_ = vala_collection_get_size ((ValaCollection*) _param_list);
            _param_size = _tmp1_;
            _param_index = -1;
            while (TRUE) {
                  gpointer _tmp2_ = NULL;
                  ValaParameter* param;
                  gboolean _tmp3_ = FALSE;
                  gboolean _tmp4_ = FALSE;
                  gboolean _tmp5_ = FALSE;
                  gboolean _tmp6_;
                  _param_index = _param_index + 1;
                  if (!(_param_index < _param_size)) {
                        break;
                  }
                  _tmp2_ = vala_list_get (_param_list, _param_index);
                  param = (ValaParameter*) _tmp2_;
                  _tmp6_ = vala_parameter_get_captured (param);
                  if (!_tmp6_) {
                        gboolean _tmp7_;
                        _tmp7_ = vala_parameter_get_ellipsis (param);
                        _tmp5_ = !_tmp7_;
                  } else {
                        _tmp5_ = FALSE;
                  }
                  if (_tmp5_) {
                        ValaDataType* _tmp8_ = NULL;
                        gboolean _tmp9_;
                        _tmp8_ = vala_variable_get_variable_type ((ValaVariable*) param);
                        _tmp9_ = vala_ccode_base_module_requires_destroy (self, _tmp8_);
                        _tmp4_ = _tmp9_;
                  } else {
                        _tmp4_ = FALSE;
                  }
                  if (_tmp4_) {
                        ValaParameterDirection _tmp10_;
                        _tmp10_ = vala_parameter_get_direction (param);
                        _tmp3_ = _tmp10_ == VALA_PARAMETER_DIRECTION_IN;
                  } else {
                        _tmp3_ = FALSE;
                  }
                  if (_tmp3_) {
                        ValaCCodeFunction* _tmp11_ = NULL;
                        ValaCCodeExpression* _tmp12_ = NULL;
                        ValaCCodeExpression* _tmp13_;
                        _tmp11_ = vala_ccode_base_module_get_ccode (self);
                        _tmp12_ = vala_ccode_base_module_destroy_parameter (self, param);
                        _tmp13_ = _tmp12_;
                        vala_ccode_function_add_expression (_tmp11_, _tmp13_);
                        _vala_ccode_node_unref0 (_tmp13_);
                  }
                  _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_ = NULL;
      ValaSymbol* _tmp1_ = NULL;
      ValaSymbol* _tmp2_;
      ValaSymbol* sym;
      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);
      if (_tmp0_ == NULL) {
            result = FALSE;
            return result;
      }
      _tmp1_ = vala_ccode_base_module_get_current_symbol (self);
      _tmp2_ = _vala_code_node_ref0 (_tmp1_);
      sym = _tmp2_;
      while (TRUE) {
            gboolean _tmp3_ = FALSE;
            gboolean _tmp4_ = FALSE;
            gboolean _tmp9_ = FALSE;
            gboolean _tmp10_ = FALSE;
            ValaCodeNode* _tmp11_ = NULL;
            ValaSymbol* _tmp19_ = NULL;
            ValaSymbol* _tmp20_;
            if (VALA_IS_METHOD (sym)) {
                  _tmp4_ = TRUE;
            } else {
                  _tmp4_ = VALA_IS_PROPERTY_ACCESSOR (sym);
            }
            if (!_tmp4_) {
                  ValaScope* _tmp5_ = NULL;
                  const gchar* _tmp6_ = NULL;
                  ValaSymbol* _tmp7_ = NULL;
                  ValaSymbol* _tmp8_;
                  _tmp5_ = vala_symbol_get_scope (sym);
                  _tmp6_ = vala_symbol_get_name ((ValaSymbol*) local);
                  _tmp7_ = vala_scope_lookup (_tmp5_, _tmp6_);
                  _tmp8_ = _tmp7_;
                  _tmp3_ = _tmp8_ == NULL;
                  _vala_code_node_unref0 (_tmp8_);
            } else {
                  _tmp3_ = FALSE;
            }
            if (!_tmp3_) {
                  break;
            }
            _tmp11_ = vala_code_node_get_parent_node ((ValaCodeNode*) sym);
            if (VALA_IS_TRY_STATEMENT (_tmp11_)) {
                  ValaCodeNode* _tmp12_ = NULL;
                  ValaBlock* _tmp13_ = NULL;
                  _tmp12_ = vala_code_node_get_parent_node ((ValaCodeNode*) sym);
                  _tmp13_ = vala_try_statement_get_finally_body (VALA_TRY_STATEMENT (_tmp12_));
                  _tmp10_ = _tmp13_ != NULL;
            } else {
                  _tmp10_ = FALSE;
            }
            if (_tmp10_) {
                  _tmp9_ = TRUE;
            } else {
                  gboolean _tmp14_ = FALSE;
                  ValaCodeNode* _tmp15_ = NULL;
                  _tmp15_ = vala_code_node_get_parent_node ((ValaCodeNode*) sym);
                  if (VALA_IS_CATCH_CLAUSE (_tmp15_)) {
                        ValaCodeNode* _tmp16_ = NULL;
                        ValaCodeNode* _tmp17_ = NULL;
                        ValaBlock* _tmp18_ = NULL;
                        _tmp16_ = vala_code_node_get_parent_node ((ValaCodeNode*) sym);
                        _tmp17_ = vala_code_node_get_parent_node (_tmp16_);
                        _tmp18_ = vala_try_statement_get_finally_body (VALA_TRY_STATEMENT (_tmp17_));
                        _tmp14_ = _tmp18_ != NULL;
                  } else {
                        _tmp14_ = FALSE;
                  }
                  _tmp9_ = _tmp14_;
            }
            if (_tmp9_) {
                  result = TRUE;
                  _vala_code_node_unref0 (sym);
                  return result;
            }
            _tmp19_ = vala_symbol_get_parent_symbol (sym);
            _tmp20_ = _vala_code_node_ref0 (_tmp19_);
            _vala_code_node_unref0 (sym);
            sym = _tmp20_;
      }
      result = FALSE;
      _vala_code_node_unref0 (sym);
      return result;
}


void vala_ccode_base_module_return_out_parameter (ValaCCodeBaseModule* self, ValaParameter* param) {
      ValaDataType* _tmp0_ = NULL;
      ValaDataType* _tmp1_;
      ValaDelegateType* _tmp2_;
      ValaDelegateType* delegate_type;
      ValaTargetValue* _tmp3_ = NULL;
      ValaTargetValue* value;
      gboolean _tmp4_;
      gboolean old_coroutine;
      ValaMethod* _tmp5_ = NULL;
      ValaCCodeFunction* _tmp6_ = NULL;
      const gchar* _tmp7_ = NULL;
      ValaCCodeExpression* _tmp8_ = NULL;
      ValaCCodeExpression* _tmp9_;
      ValaCCodeFunction* _tmp10_ = NULL;
      const gchar* _tmp11_ = NULL;
      ValaCCodeExpression* _tmp12_ = NULL;
      ValaCCodeExpression* _tmp13_;
      ValaCCodeUnaryExpression* _tmp14_ = NULL;
      ValaCCodeUnaryExpression* _tmp15_;
      ValaCCodeExpression* _tmp16_ = NULL;
      ValaCCodeExpression* _tmp17_;
      gboolean _tmp18_ = FALSE;
      ValaDataType* _tmp44_ = NULL;
      gboolean _tmp45_;
      ValaCCodeFunction* _tmp52_ = NULL;
      ValaDataType* _tmp53_ = NULL;
      ValaDataType* _tmp54_;
      ValaArrayType* _tmp55_;
      ValaArrayType* array_type;
      gboolean _tmp56_ = FALSE;
      gboolean _tmp57_ = FALSE;
      ValaMethod* _tmp77_ = NULL;
      g_return_if_fail (self != NULL);
      g_return_if_fail (param != NULL);
      _tmp0_ = vala_variable_get_variable_type ((ValaVariable*) param);
      _tmp1_ = _tmp0_;
      _tmp2_ = _vala_code_node_ref0 (VALA_IS_DELEGATE_TYPE (_tmp1_) ? ((ValaDelegateType*) _tmp1_) : NULL);
      delegate_type = _tmp2_;
      _tmp3_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, param);
      value = _tmp3_;
      _tmp4_ = vala_ccode_base_module_is_in_coroutine (self);
      old_coroutine = _tmp4_;
      _tmp5_ = vala_ccode_base_module_get_current_method (self);
      vala_method_set_coroutine (_tmp5_, FALSE);
      _tmp6_ = vala_ccode_base_module_get_ccode (self);
      _tmp7_ = vala_symbol_get_name ((ValaSymbol*) param);
      _tmp8_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp7_);
      _tmp9_ = _tmp8_;
      vala_ccode_function_open_if (_tmp6_, _tmp9_);
      _vala_ccode_node_unref0 (_tmp9_);
      _tmp10_ = vala_ccode_base_module_get_ccode (self);
      _tmp11_ = vala_symbol_get_name ((ValaSymbol*) param);
      _tmp12_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp11_);
      _tmp13_ = _tmp12_;
      _tmp14_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp13_);
      _tmp15_ = _tmp14_;
      _tmp16_ = vala_ccode_base_module_get_cvalue_ (self, value);
      _tmp17_ = _tmp16_;
      vala_ccode_function_add_assignment (_tmp10_, (ValaCCodeExpression*) _tmp15_, _tmp17_);
      _vala_ccode_node_unref0 (_tmp17_);
      _vala_ccode_node_unref0 (_tmp15_);
      _vala_ccode_node_unref0 (_tmp13_);
      if (delegate_type != NULL) {
            ValaDelegate* _tmp19_ = NULL;
            gboolean _tmp20_;
            _tmp19_ = vala_delegate_type_get_delegate_symbol (delegate_type);
            _tmp20_ = vala_delegate_get_has_target (_tmp19_);
            _tmp18_ = _tmp20_;
      } else {
            _tmp18_ = FALSE;
      }
      if (_tmp18_) {
            ValaCCodeFunction* _tmp21_ = NULL;
            const gchar* _tmp22_ = NULL;
            gchar* _tmp23_ = NULL;
            gchar* _tmp24_;
            ValaCCodeExpression* _tmp25_ = NULL;
            ValaCCodeExpression* _tmp26_;
            ValaCCodeUnaryExpression* _tmp27_ = NULL;
            ValaCCodeUnaryExpression* _tmp28_;
            ValaCCodeExpression* _tmp29_ = NULL;
            ValaCCodeExpression* _tmp30_;
            gboolean _tmp31_;
            _tmp21_ = vala_ccode_base_module_get_ccode (self);
            _tmp22_ = vala_symbol_get_name ((ValaSymbol*) param);
            _tmp23_ = vala_ccode_base_module_get_delegate_target_cname (self, _tmp22_);
            _tmp24_ = _tmp23_;
            _tmp25_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp24_);
            _tmp26_ = _tmp25_;
            _tmp27_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp26_);
            _tmp28_ = _tmp27_;
            _tmp29_ = vala_ccode_base_module_get_delegate_target_cvalue (self, value);
            _tmp30_ = _tmp29_;
            vala_ccode_function_add_assignment (_tmp21_, (ValaCCodeExpression*) _tmp28_, _tmp30_);
            _vala_ccode_node_unref0 (_tmp30_);
            _vala_ccode_node_unref0 (_tmp28_);
            _vala_ccode_node_unref0 (_tmp26_);
            _g_free0 (_tmp24_);
            _tmp31_ = vala_data_type_get_value_owned ((ValaDataType*) delegate_type);
            if (_tmp31_) {
                  ValaCCodeFunction* _tmp32_ = NULL;
                  const gchar* _tmp33_ = NULL;
                  gchar* _tmp34_ = NULL;
                  gchar* _tmp35_;
                  ValaCCodeExpression* _tmp36_ = NULL;
                  ValaCCodeExpression* _tmp37_;
                  ValaCCodeUnaryExpression* _tmp38_ = NULL;
                  ValaCCodeUnaryExpression* _tmp39_;
                  ValaTargetValue* _tmp40_ = NULL;
                  ValaTargetValue* _tmp41_;
                  ValaCCodeExpression* _tmp42_ = NULL;
                  ValaCCodeExpression* _tmp43_;
                  _tmp32_ = vala_ccode_base_module_get_ccode (self);
                  _tmp33_ = vala_symbol_get_name ((ValaSymbol*) param);
                  _tmp34_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp33_);
                  _tmp35_ = _tmp34_;
                  _tmp36_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp35_);
                  _tmp37_ = _tmp36_;
                  _tmp38_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp37_);
                  _tmp39_ = _tmp38_;
                  _tmp40_ = vala_ccode_base_module_get_parameter_cvalue (self, param);
                  _tmp41_ = _tmp40_;
                  _tmp42_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp41_);
                  _tmp43_ = _tmp42_;
                  vala_ccode_function_add_assignment (_tmp32_, (ValaCCodeExpression*) _tmp39_, _tmp43_);
                  _vala_ccode_node_unref0 (_tmp43_);
                  _vala_target_value_unref0 (_tmp41_);
                  _vala_ccode_node_unref0 (_tmp39_);
                  _vala_ccode_node_unref0 (_tmp37_);
                  _g_free0 (_tmp35_);
            }
      }
      _tmp44_ = vala_variable_get_variable_type ((ValaVariable*) param);
      _tmp45_ = vala_data_type_is_disposable (_tmp44_);
      if (_tmp45_) {
            ValaCCodeFunction* _tmp46_ = NULL;
            ValaMethod* _tmp47_ = NULL;
            ValaCCodeFunction* _tmp48_ = NULL;
            ValaCCodeExpression* _tmp49_ = NULL;
            ValaCCodeExpression* _tmp50_;
            ValaMethod* _tmp51_ = NULL;
            _tmp46_ = vala_ccode_base_module_get_ccode (self);
            vala_ccode_function_add_else (_tmp46_);
            _tmp47_ = vala_ccode_base_module_get_current_method (self);
            vala_method_set_coroutine (_tmp47_, old_coroutine);
            _tmp48_ = vala_ccode_base_module_get_ccode (self);
            _tmp49_ = vala_ccode_base_module_destroy_parameter (self, param);
            _tmp50_ = _tmp49_;
            vala_ccode_function_add_expression (_tmp48_, _tmp50_);
            _vala_ccode_node_unref0 (_tmp50_);
            _tmp51_ = vala_ccode_base_module_get_current_method (self);
            vala_method_set_coroutine (_tmp51_, FALSE);
      }
      _tmp52_ = vala_ccode_base_module_get_ccode (self);
      vala_ccode_function_close (_tmp52_);
      _tmp53_ = vala_variable_get_variable_type ((ValaVariable*) param);
      _tmp54_ = _tmp53_;
      _tmp55_ = _vala_code_node_ref0 (VALA_IS_ARRAY_TYPE (_tmp54_) ? ((ValaArrayType*) _tmp54_) : NULL);
      array_type = _tmp55_;
      if (array_type != NULL) {
            gboolean _tmp58_;
            _tmp58_ = vala_array_type_get_fixed_length (array_type);
            _tmp57_ = !_tmp58_;
      } else {
            _tmp57_ = FALSE;
      }
      if (_tmp57_) {
            gboolean _tmp59_;
            _tmp59_ = vala_variable_get_no_array_length ((ValaVariable*) param);
            _tmp56_ = !_tmp59_;
      } else {
            _tmp56_ = FALSE;
      }
      if (_tmp56_) {
            {
                  gint dim;
                  dim = 1;
                  {
                        gboolean _tmp60_;
                        _tmp60_ = TRUE;
                        while (TRUE) {
                              gint _tmp61_;
                              ValaCCodeFunction* _tmp62_ = NULL;
                              gchar* _tmp63_ = NULL;
                              gchar* _tmp64_;
                              ValaCCodeExpression* _tmp65_ = NULL;
                              ValaCCodeExpression* _tmp66_;
                              ValaCCodeFunction* _tmp67_ = NULL;
                              gchar* _tmp68_ = NULL;
                              gchar* _tmp69_;
                              ValaCCodeExpression* _tmp70_ = NULL;
                              ValaCCodeExpression* _tmp71_;
                              ValaCCodeUnaryExpression* _tmp72_ = NULL;
                              ValaCCodeUnaryExpression* _tmp73_;
                              ValaCCodeExpression* _tmp74_ = NULL;
                              ValaCCodeExpression* _tmp75_;
                              ValaCCodeFunction* _tmp76_ = NULL;
                              if (!_tmp60_) {
                                    dim++;
                              }
                              _tmp60_ = FALSE;
                              _tmp61_ = vala_array_type_get_rank (array_type);
                              if (!(dim <= _tmp61_)) {
                                    break;
                              }
                              _tmp62_ = vala_ccode_base_module_get_ccode (self);
                              _tmp63_ = vala_ccode_base_module_get_parameter_array_length_cname (self, param, dim);
                              _tmp64_ = _tmp63_;
                              _tmp65_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp64_);
                              _tmp66_ = _tmp65_;
                              vala_ccode_function_open_if (_tmp62_, _tmp66_);
                              _vala_ccode_node_unref0 (_tmp66_);
                              _g_free0 (_tmp64_);
                              _tmp67_ = vala_ccode_base_module_get_ccode (self);
                              _tmp68_ = vala_ccode_base_module_get_parameter_array_length_cname (self, param, dim);
                              _tmp69_ = _tmp68_;
                              _tmp70_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp69_);
                              _tmp71_ = _tmp70_;
                              _tmp72_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp71_);
                              _tmp73_ = _tmp72_;
                              _tmp74_ = vala_ccode_base_module_get_array_length_cvalue (self, value, -1);
                              _tmp75_ = _tmp74_;
                              vala_ccode_function_add_assignment (_tmp67_, (ValaCCodeExpression*) _tmp73_, _tmp75_);
                              _vala_ccode_node_unref0 (_tmp75_);
                              _vala_ccode_node_unref0 (_tmp73_);
                              _vala_ccode_node_unref0 (_tmp71_);
                              _g_free0 (_tmp69_);
                              _tmp76_ = vala_ccode_base_module_get_ccode (self);
                              vala_ccode_function_close (_tmp76_);
                        }
                  }
            }
      }
      _tmp77_ = vala_ccode_base_module_get_current_method (self);
      vala_method_set_coroutine (_tmp77_, old_coroutine);
      _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;
      ValaExpression* _tmp0_ = NULL;
      gboolean _tmp8_ = FALSE;
      gboolean _tmp9_ = FALSE;
      gboolean _tmp10_ = FALSE;
      ValaMethod* _tmp11_ = NULL;
      ValaExpression* _tmp86_ = NULL;
      ValaSymbol* _tmp97_ = NULL;
      ValaMethod* _tmp98_ = NULL;
      gboolean _tmp103_ = FALSE;
      ValaMethod* _tmp104_ = NULL;
      gboolean _tmp112_;
      self = (ValaCCodeBaseModule*) base;
      g_return_if_fail (stmt != NULL);
      return_expression_symbol = NULL;
      _tmp0_ = vala_return_statement_get_return_expression (stmt);
      if (_tmp0_ != NULL) {
            ValaExpression* _tmp1_ = NULL;
            ValaSymbol* _tmp2_ = NULL;
            ValaSymbol* _tmp3_;
            ValaLocalVariable* _tmp4_;
            ValaLocalVariable* local;
            gboolean _tmp5_ = FALSE;
            _tmp1_ = vala_return_statement_get_return_expression (stmt);
            _tmp2_ = vala_expression_get_symbol_reference (_tmp1_);
            _tmp3_ = _tmp2_;
            _tmp4_ = _vala_code_node_ref0 (VALA_IS_LOCAL_VARIABLE (_tmp3_) ? ((ValaLocalVariable*) _tmp3_) : NULL);
            local = _tmp4_;
            if (local != NULL) {
                  gboolean _tmp6_;
                  _tmp6_ = vala_symbol_get_active ((ValaSymbol*) local);
                  _tmp5_ = !_tmp6_;
            } else {
                  _tmp5_ = FALSE;
            }
            if (_tmp5_) {
                  ValaSymbol* _tmp7_;
                  _tmp7_ = _vala_code_node_ref0 ((ValaSymbol*) local);
                  _vala_code_node_unref0 (return_expression_symbol);
                  return_expression_symbol = _tmp7_;
            }
            _vala_code_node_unref0 (local);
      }
      _tmp11_ = vala_ccode_base_module_get_current_method (self);
      if (_tmp11_ != NULL) {
            ValaMethod* _tmp12_ = NULL;
            gboolean _tmp13_;
            _tmp12_ = vala_ccode_base_module_get_current_method (self);
            _tmp13_ = vala_method_get_no_array_length (_tmp12_);
            _tmp10_ = !_tmp13_;
      } else {
            _tmp10_ = FALSE;
      }
      if (_tmp10_) {
            _tmp9_ = TRUE;
      } else {
            ValaPropertyAccessor* _tmp14_ = NULL;
            _tmp14_ = vala_ccode_base_module_get_current_property_accessor (self);
            _tmp9_ = _tmp14_ != NULL;
      }
      if (_tmp9_) {
            ValaDataType* _tmp15_ = NULL;
            _tmp15_ = vala_ccode_base_module_get_current_return_type (self);
            _tmp8_ = VALA_IS_ARRAY_TYPE (_tmp15_);
      } else {
            _tmp8_ = FALSE;
      }
      if (_tmp8_) {
            ValaDataType* _tmp16_ = NULL;
            ValaLocalVariable* _tmp17_ = NULL;
            ValaLocalVariable* return_expr_decl;
            ValaCCodeFunction* _tmp18_ = NULL;
            const gchar* _tmp19_ = NULL;
            ValaCCodeExpression* _tmp20_ = NULL;
            ValaCCodeExpression* _tmp21_;
            ValaExpression* _tmp22_ = NULL;
            ValaCCodeExpression* _tmp23_ = NULL;
            ValaCCodeExpression* _tmp24_;
            ValaDataType* _tmp25_ = NULL;
            ValaArrayType* _tmp26_;
            ValaArrayType* array_type;
            ValaExpression* _tmp41_ = NULL;
            const gchar* _tmp42_ = NULL;
            ValaCCodeExpression* _tmp43_ = NULL;
            ValaCCodeExpression* _tmp44_;
            _tmp16_ = vala_ccode_base_module_get_current_return_type (self);
            _tmp17_ = vala_ccode_base_module_get_temp_variable (self, _tmp16_, TRUE, (ValaCodeNode*) stmt, FALSE);
            return_expr_decl = _tmp17_;
            _tmp18_ = vala_ccode_base_module_get_ccode (self);
            _tmp19_ = vala_symbol_get_name ((ValaSymbol*) return_expr_decl);
            _tmp20_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp19_);
            _tmp21_ = _tmp20_;
            _tmp22_ = vala_return_statement_get_return_expression (stmt);
            _tmp23_ = vala_ccode_base_module_get_cvalue (self, _tmp22_);
            _tmp24_ = _tmp23_;
            vala_ccode_function_add_assignment (_tmp18_, _tmp21_, _tmp24_);
            _vala_ccode_node_unref0 (_tmp24_);
            _vala_ccode_node_unref0 (_tmp21_);
            _tmp25_ = vala_ccode_base_module_get_current_return_type (self);
            _tmp26_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp25_));
            array_type = _tmp26_;
            {
                  gint dim;
                  dim = 1;
                  {
                        gboolean _tmp27_;
                        _tmp27_ = TRUE;
                        while (TRUE) {
                              gint _tmp28_;
                              gchar* _tmp29_ = NULL;
                              gchar* _tmp30_;
                              ValaCCodeExpression* _tmp31_ = NULL;
                              ValaCCodeExpression* _tmp32_;
                              ValaCCodeExpression* len_l;
                              ValaExpression* _tmp33_ = NULL;
                              ValaCCodeExpression* _tmp34_ = NULL;
                              ValaCCodeExpression* len_r;
                              gboolean _tmp35_;
                              if (!_tmp27_) {
                                    dim++;
                              }
                              _tmp27_ = FALSE;
                              _tmp28_ = vala_array_type_get_rank (array_type);
                              if (!(dim <= _tmp28_)) {
                                    break;
                              }
                              _tmp29_ = vala_ccode_base_module_get_array_length_cname (self, "result", dim);
                              _tmp30_ = _tmp29_;
                              _tmp31_ = vala_ccode_base_module_get_result_cexpression (self, _tmp30_);
                              _tmp32_ = _tmp31_;
                              _g_free0 (_tmp30_);
                              len_l = _tmp32_;
                              _tmp33_ = vala_return_statement_get_return_expression (stmt);
                              _tmp34_ = vala_ccode_base_m