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

/* valaccodemethodcallmodule.vala
 *
 * Copyright (C) 2006-2010  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 <float.h>
#include <math.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_TYPE_CCODE_STRUCT_MODULE (vala_ccode_struct_module_get_type ())
#define VALA_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModule))
#define VALA_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass))
#define VALA_IS_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_STRUCT_MODULE))
#define VALA_IS_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_STRUCT_MODULE))
#define VALA_CCODE_STRUCT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass))

typedef struct _ValaCCodeStructModule ValaCCodeStructModule;
typedef struct _ValaCCodeStructModuleClass ValaCCodeStructModuleClass;
typedef struct _ValaCCodeStructModulePrivate ValaCCodeStructModulePrivate;

#define VALA_TYPE_CCODE_METHOD_MODULE (vala_ccode_method_module_get_type ())
#define VALA_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModule))
#define VALA_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass))
#define VALA_IS_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_MODULE))
#define VALA_IS_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_MODULE))
#define VALA_CCODE_METHOD_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass))

typedef struct _ValaCCodeMethodModule ValaCCodeMethodModule;
typedef struct _ValaCCodeMethodModuleClass ValaCCodeMethodModuleClass;
typedef struct _ValaCCodeMethodModulePrivate ValaCCodeMethodModulePrivate;

#define VALA_TYPE_CCODE_CONTROL_FLOW_MODULE (vala_ccode_control_flow_module_get_type ())
#define VALA_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModule))
#define VALA_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass))
#define VALA_IS_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE))
#define VALA_IS_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE))
#define VALA_CCODE_CONTROL_FLOW_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass))

typedef struct _ValaCCodeControlFlowModule ValaCCodeControlFlowModule;
typedef struct _ValaCCodeControlFlowModuleClass ValaCCodeControlFlowModuleClass;
typedef struct _ValaCCodeControlFlowModulePrivate ValaCCodeControlFlowModulePrivate;

#define VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE (vala_ccode_member_access_module_get_type ())
#define VALA_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModule))
#define VALA_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass))
#define VALA_IS_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE))
#define VALA_IS_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE))
#define VALA_CCODE_MEMBER_ACCESS_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass))

typedef struct _ValaCCodeMemberAccessModule ValaCCodeMemberAccessModule;
typedef struct _ValaCCodeMemberAccessModuleClass ValaCCodeMemberAccessModuleClass;
typedef struct _ValaCCodeMemberAccessModulePrivate ValaCCodeMemberAccessModulePrivate;

#define VALA_TYPE_CCODE_ASSIGNMENT_MODULE (vala_ccode_assignment_module_get_type ())
#define VALA_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModule))
#define VALA_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass))
#define VALA_IS_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE))
#define VALA_IS_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE))
#define VALA_CCODE_ASSIGNMENT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass))

typedef struct _ValaCCodeAssignmentModule ValaCCodeAssignmentModule;
typedef struct _ValaCCodeAssignmentModuleClass ValaCCodeAssignmentModuleClass;
typedef struct _ValaCCodeAssignmentModulePrivate ValaCCodeAssignmentModulePrivate;

#define VALA_TYPE_CCODE_METHOD_CALL_MODULE (vala_ccode_method_call_module_get_type ())
#define VALA_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModule))
#define VALA_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass))
#define VALA_IS_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE))
#define VALA_IS_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE))
#define VALA_CCODE_METHOD_CALL_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass))

typedef struct _ValaCCodeMethodCallModule ValaCCodeMethodCallModule;
typedef struct _ValaCCodeMethodCallModuleClass ValaCCodeMethodCallModuleClass;
typedef struct _ValaCCodeMethodCallModulePrivate ValaCCodeMethodCallModulePrivate;
#define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_unref (var), NULL)))
#define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL)))

#define VALA_TYPE_CTYPE (vala_ctype_get_type ())
#define VALA_CTYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CTYPE, ValaCType))
#define VALA_CTYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CTYPE, ValaCTypeClass))
#define VALA_IS_CTYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CTYPE))
#define VALA_IS_CTYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CTYPE))
#define VALA_CTYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CTYPE, ValaCTypeClass))

typedef struct _ValaCType ValaCType;
typedef struct _ValaCTypeClass ValaCTypeClass;
#define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

#define VALA_TYPE_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_ccode_base_module_emit_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_base_module_emit_context_unref (var), NULL)))
#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

struct _ValaCCodeBaseModule {
	ValaCodeGenerator parent_instance;
	ValaCCodeBaseModulePrivate * priv;
	ValaSymbol* root_symbol;
	ValaCCodeBaseModuleEmitContext* emit_context;
	ValaCCodeLineDirective* current_line;
	ValaCCodeFile* header_file;
	ValaCCodeFile* internal_header_file;
	ValaCCodeFile* cfile;
	ValaCCodeBaseModuleEmitContext* class_init_context;
	ValaCCodeBaseModuleEmitContext* base_init_context;
	ValaCCodeBaseModuleEmitContext* class_finalize_context;
	ValaCCodeBaseModuleEmitContext* base_finalize_context;
	ValaCCodeBaseModuleEmitContext* instance_init_context;
	ValaCCodeBaseModuleEmitContext* instance_finalize_context;
	ValaCCodeStruct* param_spec_struct;
	ValaCCodeStruct* closure_struct;
	ValaCCodeEnum* prop_enum;
	ValaSet* user_marshal_set;
	ValaSet* predefined_marshal_set;
	gint next_regex_id;
	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* gqueue_type;
	ValaClass* gvaluearray_type;
	ValaTypeSymbol* gstringbuilder_type;
	ValaTypeSymbol* garray_type;
	ValaTypeSymbol* gbytearray_type;
	ValaTypeSymbol* gptrarray_type;
	ValaTypeSymbol* gthreadpool_type;
	ValaDataType* gdestroynotify_type;
	ValaDataType* gquark_type;
	ValaStruct* gvalue_type;
	ValaClass* gvariant_type;
	ValaStruct* mutex_type;
	ValaStruct* gmutex_type;
	ValaStruct* grecmutex_type;
	ValaStruct* grwlock_type;
	ValaStruct* gcond_type;
	ValaClass* gsource_type;
	ValaTypeSymbol* type_module_type;
	ValaTypeSymbol* dbus_proxy_type;
	ValaClass* gtk_widget_type;
	gboolean in_plugin;
	gchar* module_init_param_name;
	gboolean gvaluecollector_h_needed;
	gboolean requires_assert;
	gboolean requires_array_free;
	gboolean requires_array_move;
	gboolean requires_array_length;
	gboolean requires_clear_mutex;
	ValaSet* wrappers;
};

struct _ValaCCodeBaseModuleClass {
	ValaCodeGeneratorClass parent_class;
	void (*append_vala_array_free) (ValaCCodeBaseModule* self);
	void (*append_vala_array_move) (ValaCCodeBaseModule* self);
	void (*append_vala_array_length) (ValaCCodeBaseModule* self);
	gboolean (*generate_enum_declaration) (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space);
	void (*generate_class_struct_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
	void (*generate_struct_declaration) (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space);
	void (*generate_delegate_declaration) (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space);
	void (*generate_cparameters) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);
	ValaCCodeExpression* (*get_dup_func_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);
	gchar* (*append_struct_array_free) (ValaCCodeBaseModule* self, ValaStruct* st);
	ValaCCodeExpression* (*destroy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
	void (*append_scope_free) (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);
	ValaTargetValue* (*get_local_cvalue) (ValaCCodeBaseModule* self, ValaLocalVariable* local);
	ValaTargetValue* (*get_parameter_cvalue) (ValaCCodeBaseModule* self, ValaParameter* param);
	ValaTargetValue* (*get_field_cvalue) (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance);
	ValaTargetValue* (*load_variable) (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value);
	ValaTargetValue* (*load_this_parameter) (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
	void (*store_value) (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
	gchar* (*get_delegate_target_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
	ValaCCodeExpression* (*get_delegate_target_cexpression) (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify);
	ValaCCodeExpression* (*get_delegate_target_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
	ValaCCodeExpression* (*get_delegate_target_destroy_notify_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
	gchar* (*get_delegate_target_destroy_notify_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
	ValaTargetValue* (*copy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
	void (*generate_class_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
	void (*generate_interface_declaration) (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space);
	void (*generate_method_declaration) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
	void (*generate_error_domain_declaration) (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);
	ValaCCodeExpression* (*deserialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail);
	ValaCCodeExpression* (*serialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr);
	ValaCCodeExpression* (*get_implicit_cast_expression) (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node);
	void (*create_type_check_statement) (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);
	gboolean (*is_gobject_property) (ValaCCodeBaseModule* self, ValaProperty* prop);
	void (*generate_dynamic_method_wrapper) (ValaCCodeBaseModule* self, ValaDynamicMethod* method);
	gboolean (*method_has_wrapper) (ValaCCodeBaseModule* self, ValaMethod* method);
	ValaCCodeFunctionCall* (*get_param_spec) (ValaCCodeBaseModule* self, ValaProperty* prop);
	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);
};

struct _ValaCCodeStructModule {
	ValaCCodeBaseModule parent_instance;
	ValaCCodeStructModulePrivate * priv;
};

struct _ValaCCodeStructModuleClass {
	ValaCCodeBaseModuleClass parent_class;
};

struct _ValaCCodeMethodModule {
	ValaCCodeStructModule parent_instance;
	ValaCCodeMethodModulePrivate * priv;
};

struct _ValaCCodeMethodModuleClass {
	ValaCCodeStructModuleClass parent_class;
	void (*generate_method_result_declaration) (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map);
	ValaCCodeParameter* (*generate_parameter) (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map);
};

struct _ValaCCodeControlFlowModule {
	ValaCCodeMethodModule parent_instance;
	ValaCCodeControlFlowModulePrivate * priv;
};

struct _ValaCCodeControlFlowModuleClass {
	ValaCCodeMethodModuleClass parent_class;
};

struct _ValaCCodeMemberAccessModule {
	ValaCCodeControlFlowModule parent_instance;
	ValaCCodeMemberAccessModulePrivate * priv;
};

struct _ValaCCodeMemberAccessModuleClass {
	ValaCCodeControlFlowModuleClass parent_class;
};

struct _ValaCCodeAssignmentModule {
	ValaCCodeMemberAccessModule parent_instance;
	ValaCCodeAssignmentModulePrivate * priv;
};

struct _ValaCCodeAssignmentModuleClass {
	ValaCCodeMemberAccessModuleClass parent_class;
};

struct _ValaCCodeMethodCallModule {
	ValaCCodeAssignmentModule parent_instance;
	ValaCCodeMethodCallModulePrivate * priv;
};

struct _ValaCCodeMethodCallModuleClass {
	ValaCCodeAssignmentModuleClass parent_class;
};

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

struct _ValaGLibValueClass {
	ValaTargetValueClass parent_class;
};


static gpointer vala_ccode_method_call_module_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;
GType vala_ccode_struct_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_method_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_control_flow_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_member_access_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_assignment_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_method_call_module_get_type (void) G_GNUC_CONST;
enum  {
	VALA_CCODE_METHOD_CALL_MODULE_DUMMY_PROPERTY
};
static void vala_ccode_method_call_module_real_visit_method_call (ValaCodeVisitor* base, ValaMethodCall* expr);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr);
static gchar* vala_ccode_method_call_module_generate_enum_tostring_function (ValaCCodeMethodCallModule* self, ValaEnum* en);
gchar* vala_ccode_base_module_get_ccode_constructv_name (ValaCreationMethod* m);
void vala_ccode_base_module_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
gchar* vala_ccode_base_module_get_ccode_real_name (ValaSymbol* sym);
gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);
gchar* vala_ccode_base_module_get_ccode_finish_name (ValaMethod* m);
gchar* vala_ccode_base_module_get_ccode_upper_case_name (ValaSymbol* sym, const gchar* infix);
gchar* vala_ccode_base_module_get_ccode_lower_case_name (ValaCodeNode* node, const gchar* infix);
ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self);
gchar* vala_ccode_base_module_get_ccode_vfunc_name (ValaMethod* m);
gchar* vala_ccode_base_module_get_ccode_finish_vfunc_name (ValaMethod* m);
gint vala_ccode_base_module_get_param_pos (ValaCCodeBaseModule* self, gdouble param_pos, gboolean ellipsis);
ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name);
void vala_ccode_base_module_add_generic_type_arguments (ValaCCodeBaseModule* self, ValaMap* arg_map, ValaList* type_args, ValaCodeNode* expr, gboolean is_chainup, ValaList* type_parameters);
ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);
ValaCCodeExpression* vala_ccode_base_module_get_this_cexpression (ValaCCodeBaseModule* self);
gboolean vala_ccode_base_module_get_ccode_has_generic_type_parameter (ValaMethod* m);
gboolean vala_ccode_base_module_get_ccode_simple_generics (ValaMethod* m);
ValaMethod* vala_ccode_base_module_get_current_method (ValaCCodeBaseModule* self);
gint vala_ccode_base_module_get_block_id (ValaCCodeBaseModule* self, ValaBlock* b);
gdouble vala_ccode_base_module_get_ccode_instance_pos (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value);
gboolean vala_ccode_base_module_get_lvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
ValaTargetValue* vala_ccode_base_module_store_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* initializer, ValaCodeNode* node_reference, gboolean* value_owned);
ValaDataType* vala_ccode_base_module_get_this_type (ValaCCodeBaseModule* self);
gdouble vala_ccode_base_module_get_ccode_generic_type_pos (ValaMethod* m);
void vala_ccode_base_module_generate_dynamic_method_wrapper (ValaCCodeBaseModule* self, ValaDynamicMethod* method);
ValaCCodeExpression* vala_ccode_base_module_get_dup_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);
gboolean vala_ccode_base_module_get_ccode_array_length (ValaCodeNode* node);
gchar* vala_ccode_base_module_get_ccode_array_length_type (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_get_array_length_cexpression (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim);
gdouble vala_ccode_base_module_get_ccode_array_length_pos (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cexpression (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify);
gchar* vala_ccode_base_module_get_ccode_type (ValaCodeNode* node);
gdouble vala_ccode_base_module_get_ccode_delegate_target_pos (ValaCodeNode* node);
gboolean vala_ccode_base_module_requires_copy (ValaCCodeBaseModule* self, ValaDataType* type);
gdouble vala_ccode_base_module_get_ccode_destroy_notify_pos (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_get_destroy_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup);
ValaCCodeExpression* vala_ccode_base_module_handle_struct_argument (ValaCCodeBaseModule* self, ValaParameter* param, ValaExpression* arg, ValaCCodeExpression* cexpr);
ValaLocalVariable* vala_ccode_base_module_get_temp_variable (ValaCCodeBaseModule* self, ValaDataType* type, gboolean value_owned, ValaCodeNode* node_reference, gboolean init);
void vala_ccode_base_module_emit_temp_var (ValaCCodeBaseModule* self, ValaLocalVariable* local);
void vala_ccode_base_module_set_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* cvalue);
ValaCType* vala_ctype_new (const gchar* ctype_name);
ValaCType* vala_ctype_construct (GType object_type, const gchar* ctype_name);
GType vala_ctype_get_type (void) G_GNUC_CONST;
void vala_ccode_base_module_append_array_length (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* size);
ValaList* vala_ccode_base_module_get_array_lengths (ValaCCodeBaseModule* self, ValaExpression* expr);
void vala_ccode_base_module_set_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* delegate_target);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr);
void vala_ccode_base_module_set_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* destroy_notify);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr);
gdouble vala_ccode_base_module_get_ccode_pos (ValaParameter* param);
gboolean vala_ccode_base_module_get_ccode_array_null_terminated (ValaCodeNode* node);
gchar* vala_ccode_base_module_generate_ready_function (ValaCCodeBaseModule* self, ValaMethod* m);
void vala_ccode_base_module_set_current_method_inner_error (ValaCCodeBaseModule* self, gboolean value);
gchar* vala_ccode_base_module_get_ccode_sentinel (ValaMethod* m);
gboolean vala_ccode_base_module_get_signal_has_emitter (ValaCCodeBaseModule* self, ValaSignal* sig);
void vala_ccode_base_module_store_property (ValaCCodeBaseModule* self, ValaProperty* prop, ValaExpression* instance, ValaTargetValue* value);
ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
GType vala_glib_value_get_type (void) G_GNUC_CONST;
ValaCCodeExpression* vala_ccode_base_module_get_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
gboolean vala_ccode_base_module_requires_destroy (ValaCCodeBaseModule* self, ValaDataType* type);
ValaCCodeExpression* vala_ccode_base_module_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
void vala_ccode_base_module_store_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
ValaTargetValue* vala_ccode_base_module_transform_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* target_type, ValaCodeNode* node);
gboolean vala_ccode_base_module_add_wrapper (ValaCCodeBaseModule* self, const gchar* wrapper_name);
void vala_ccode_base_module_push_context (ValaCCodeBaseModule* self, ValaCCodeBaseModuleEmitContext* emit_context);
ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_new (ValaSymbol* symbol);
ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_construct (GType object_type, ValaSymbol* symbol);
void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func);
void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self);
ValaCCodeMethodCallModule* vala_ccode_method_call_module_new (void);
ValaCCodeMethodCallModule* vala_ccode_method_call_module_construct (GType object_type);
ValaCCodeAssignmentModule* vala_ccode_assignment_module_new (void);
ValaCCodeAssignmentModule* vala_ccode_assignment_module_construct (GType object_type);
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);


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


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


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


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


static gchar* _vala_g_strjoinv (const gchar* separator, gchar** str_array, int str_array_length1) {
	gchar* result = NULL;
	const gchar* _tmp0_ = NULL;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp2_ = FALSE;
	gchar** _tmp3_ = NULL;
	gint _tmp3__length1 = 0;
	_tmp0_ = separator;
	if (_tmp0_ == NULL) {
		separator = "";
	}
	_tmp3_ = str_array;
	_tmp3__length1 = str_array_length1;
	if (_tmp3_ != NULL) {
		_tmp2_ = TRUE;
	} else {
		gchar** _tmp4_ = NULL;
		gint _tmp4__length1 = 0;
		_tmp4_ = str_array;
		_tmp4__length1 = str_array_length1;
		_tmp2_ = _tmp4__length1 > 0;
	}
	if (_tmp2_) {
		_tmp1_ = TRUE;
	} else {
		gboolean _tmp5_ = FALSE;
		gchar** _tmp6_ = NULL;
		gint _tmp6__length1 = 0;
		_tmp6_ = str_array;
		_tmp6__length1 = str_array_length1;
		if (_tmp6__length1 == (-1)) {
			gchar** _tmp7_ = NULL;
			gint _tmp7__length1 = 0;
			const gchar* _tmp8_ = NULL;
			_tmp7_ = str_array;
			_tmp7__length1 = str_array_length1;
			_tmp8_ = _tmp7_[0];
			_tmp5_ = _tmp8_ != NULL;
		} else {
			_tmp5_ = FALSE;
		}
		_tmp1_ = _tmp5_;
	}
	if (_tmp1_) {
		gint i = 0;
		gsize len = 0UL;
		gint _tmp31_ = 0;
		gint _tmp33_ = 0;
		gint _tmp34_ = 0;
		gsize _tmp35_ = 0UL;
		const gchar* _tmp36_ = NULL;
		gint _tmp37_ = 0;
		gint _tmp38_ = 0;
		gint _tmp39_ = 0;
		const gchar* res = NULL;
		gsize _tmp40_ = 0UL;
		void* _tmp41_ = NULL;
		void* ptr = NULL;
		const gchar* _tmp42_ = NULL;
		gchar** _tmp43_ = NULL;
		gint _tmp43__length1 = 0;
		const gchar* _tmp44_ = NULL;
		void* _tmp45_ = NULL;
		const gchar* _tmp62_ = NULL;
		len = (gsize) 1;
		{
			gboolean _tmp9_ = FALSE;
			i = 0;
			_tmp9_ = TRUE;
			while (TRUE) {
				gboolean _tmp11_ = FALSE;
				gboolean _tmp12_ = FALSE;
				gchar** _tmp13_ = NULL;
				gint _tmp13__length1 = 0;
				gint _tmp21_ = 0;
				gchar** _tmp22_ = NULL;
				gint _tmp22__length1 = 0;
				gint _tmp23_ = 0;
				const gchar* _tmp24_ = NULL;
				gsize _tmp30_ = 0UL;
				if (!_tmp9_) {
					gint _tmp10_ = 0;
					_tmp10_ = i;
					i = _tmp10_ + 1;
				}
				_tmp9_ = FALSE;
				_tmp13_ = str_array;
				_tmp13__length1 = str_array_length1;
				if (_tmp13__length1 != (-1)) {
					gint _tmp14_ = 0;
					gchar** _tmp15_ = NULL;
					gint _tmp15__length1 = 0;
					_tmp14_ = i;
					_tmp15_ = str_array;
					_tmp15__length1 = str_array_length1;
					_tmp12_ = _tmp14_ < _tmp15__length1;
				} else {
					_tmp12_ = FALSE;
				}
				if (_tmp12_) {
					_tmp11_ = TRUE;
				} else {
					gboolean _tmp16_ = FALSE;
					gchar** _tmp17_ = NULL;
					gint _tmp17__length1 = 0;
					_tmp17_ = str_array;
					_tmp17__length1 = str_array_length1;
					if (_tmp17__length1 == (-1)) {
						gchar** _tmp18_ = NULL;
						gint _tmp18__length1 = 0;
						gint _tmp19_ = 0;
						const gchar* _tmp20_ = NULL;
						_tmp18_ = str_array;
						_tmp18__length1 = str_array_length1;
						_tmp19_ = i;
						_tmp20_ = _tmp18_[_tmp19_];
						_tmp16_ = _tmp20_ != NULL;
					} else {
						_tmp16_ = FALSE;
					}
					_tmp11_ = _tmp16_;
				}
				if (!_tmp11_) {
					break;
				}
				_tmp22_ = str_array;
				_tmp22__length1 = str_array_length1;
				_tmp23_ = i;
				_tmp24_ = _tmp22_[_tmp23_];
				if (_tmp24_ != NULL) {
					gchar** _tmp25_ = NULL;
					gint _tmp25__length1 = 0;
					gint _tmp26_ = 0;
					const gchar* _tmp27_ = NULL;
					gint _tmp28_ = 0;
					gint _tmp29_ = 0;
					_tmp25_ = str_array;
					_tmp25__length1 = str_array_length1;
					_tmp26_ = i;
					_tmp27_ = _tmp25_[_tmp26_];
					_tmp28_ = strlen ((const gchar*) _tmp27_);
					_tmp29_ = _tmp28_;
					_tmp21_ = _tmp29_;
				} else {
					_tmp21_ = 0;
				}
				_tmp30_ = len;
				len = _tmp30_ + _tmp21_;
			}
		}
		_tmp31_ = i;
		if (_tmp31_ == 0) {
			gchar* _tmp32_ = NULL;
			_tmp32_ = g_strdup ("");
			result = _tmp32_;
			return result;
		}
		_tmp33_ = i;
		str_array_length1 = _tmp33_;
		_tmp34_ = str_array_length1;
		_tmp35_ = len;
		_tmp36_ = separator;
		_tmp37_ = strlen ((const gchar*) _tmp36_);
		_tmp38_ = _tmp37_;
		_tmp39_ = i;
		len = _tmp35_ + (_tmp38_ * (_tmp39_ - 1));
		_tmp40_ = len;
		_tmp41_ = g_malloc (_tmp40_);
		res = _tmp41_;
		_tmp42_ = res;
		_tmp43_ = str_array;
		_tmp43__length1 = str_array_length1;
		_tmp44_ = _tmp43_[0];
		_tmp45_ = g_stpcpy ((void*) _tmp42_, (const gchar*) _tmp44_);
		ptr = _tmp45_;
		{
			gboolean _tmp46_ = FALSE;
			i = 1;
			_tmp46_ = TRUE;
			while (TRUE) {
				gint _tmp48_ = 0;
				gchar** _tmp49_ = NULL;
				gint _tmp49__length1 = 0;
				void* _tmp50_ = NULL;
				const gchar* _tmp51_ = NULL;
				void* _tmp52_ = NULL;
				const gchar* _tmp53_ = NULL;
				gchar** _tmp54_ = NULL;
				gint _tmp54__length1 = 0;
				gint _tmp55_ = 0;
				const gchar* _tmp56_ = NULL;
				void* _tmp60_ = NULL;
				void* _tmp61_ = NULL;
				if (!_tmp46_) {
					gint _tmp47_ = 0;
					_tmp47_ = i;
					i = _tmp47_ + 1;
				}
				_tmp46_ = FALSE;
				_tmp48_ = i;
				_tmp49_ = str_array;
				_tmp49__length1 = str_array_length1;
				if (!(_tmp48_ < _tmp49__length1)) {
					break;
				}
				_tmp50_ = ptr;
				_tmp51_ = separator;
				_tmp52_ = g_stpcpy (_tmp50_, (const gchar*) _tmp51_);
				ptr = _tmp52_;
				_tmp54_ = str_array;
				_tmp54__length1 = str_array_length1;
				_tmp55_ = i;
				_tmp56_ = _tmp54_[_tmp55_];
				if (_tmp56_ != NULL) {
					gchar** _tmp57_ = NULL;
					gint _tmp57__length1 = 0;
					gint _tmp58_ = 0;
					const gchar* _tmp59_ = NULL;
					_tmp57_ = str_array;
					_tmp57__length1 = str_array_length1;
					_tmp58_ = i;
					_tmp59_ = _tmp57_[_tmp58_];
					_tmp53_ = (const gchar*) _tmp59_;
				} else {
					_tmp53_ = "";
				}
				_tmp60_ = ptr;
				_tmp61_ = g_stpcpy (_tmp60_, _tmp53_);
				ptr = _tmp61_;
			}
		}
		_tmp62_ = res;
		res = NULL;
		result = (gchar*) _tmp62_;
		return result;
	} else {
		gchar* _tmp63_ = NULL;
		_tmp63_ = g_strdup ("");
		result = _tmp63_;
		return result;
	}
}


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


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


static gchar* string_replace (const gchar* self, const gchar* old, const gchar* replacement) {
	gchar* result = NULL;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (old != NULL, NULL);
	g_return_val_if_fail (replacement != NULL, NULL);
	{
		GRegex* regex = NULL;
		const gchar* _tmp0_ = NULL;
		gchar* _tmp1_ = NULL;
		gchar* _tmp2_ = NULL;
		GRegex* _tmp3_ = NULL;
		GRegex* _tmp4_ = NULL;
		gchar* _tmp5_ = NULL;
		GRegex* _tmp6_ = NULL;
		const gchar* _tmp7_ = NULL;
		gchar* _tmp8_ = NULL;
		gchar* _tmp9_ = NULL;
		_tmp0_ = old;
		_tmp1_ = g_regex_escape_string (_tmp0_, -1);
		_tmp2_ = _tmp1_;
		_tmp3_ = g_regex_new (_tmp2_, 0, 0, &_inner_error_);
		_tmp4_ = _tmp3_;
		_g_free0 (_tmp2_);
		regex = _tmp4_;
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			if (_inner_error_->domain == G_REGEX_ERROR) {
				goto __catch4_g_regex_error;
			}
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
		_tmp6_ = regex;
		_tmp7_ = replacement;
		_tmp8_ = g_regex_replace_literal (_tmp6_, self, (gssize) (-1), 0, _tmp7_, 0, &_inner_error_);
		_tmp5_ = _tmp8_;
		if (G_UNLIKELY (_inner_error_ != NULL)) {
			_g_regex_unref0 (regex);
			if (_inner_error_->domain == G_REGEX_ERROR) {
				goto __catch4_g_regex_error;
			}
			_g_regex_unref0 (regex);
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return NULL;
		}
		_tmp9_ = _tmp5_;
		_tmp5_ = NULL;
		result = _tmp9_;
		_g_free0 (_tmp5_);
		_g_regex_unref0 (regex);
		return result;
	}
	goto __finally4;
	__catch4_g_regex_error:
	{
		GError* e = NULL;
		e = _inner_error_;
		_inner_error_ = NULL;
		g_assert_not_reached ();
		_g_error_free0 (e);
	}
	__finally4:
	if (G_UNLIKELY (_inner_error_ != NULL)) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
}


static void vala_ccode_method_call_module_real_visit_method_call (ValaCodeVisitor* base, ValaMethodCall* expr) {
	ValaCCodeMethodCallModule * self;
	ValaCCodeFunctionCall* ccall = NULL;
	ValaMethodCall* _tmp0_ = NULL;
	ValaExpression* _tmp1_ = NULL;
	ValaExpression* _tmp2_ = NULL;
	ValaCCodeExpression* _tmp3_ = NULL;
	ValaCCodeExpression* _tmp4_ = NULL;
	ValaCCodeFunctionCall* _tmp5_ = NULL;
	ValaCCodeFunctionCall* _tmp6_ = NULL;
	ValaCCodeFunctionCall* async_call = NULL;
	ValaCCodeFunctionCall* finish_call = NULL;
	ValaMethod* m = NULL;
	ValaDelegate* deleg = NULL;
	ValaList* params = NULL;
	ValaMemberAccess* ma = NULL;
	ValaMethodCall* _tmp7_ = NULL;
	ValaExpression* _tmp8_ = NULL;
	ValaExpression* _tmp9_ = NULL;
	ValaMemberAccess* _tmp10_ = NULL;
	ValaDataType* itype = NULL;
	ValaMethodCall* _tmp11_ = NULL;
	ValaExpression* _tmp12_ = NULL;
	ValaExpression* _tmp13_ = NULL;
	ValaDataType* _tmp14_ = NULL;
	ValaDataType* _tmp15_ = NULL;
	ValaDataType* _tmp16_ = NULL;
	ValaDataType* _tmp17_ = NULL;
	ValaList* _tmp18_ = NULL;
	ValaDataType* _tmp19_ = NULL;
	ValaHashMap* in_arg_map = NULL;
	GHashFunc _tmp134_ = NULL;
	GEqualFunc _tmp135_ = NULL;
	GEqualFunc _tmp136_ = NULL;
	ValaHashMap* _tmp137_ = NULL;
	ValaHashMap* out_arg_map = NULL;
	ValaHashMap* _tmp138_ = NULL;
	ValaHashMap* _tmp139_ = NULL;
	gboolean _tmp140_ = FALSE;
	ValaMethod* _tmp141_ = NULL;
	gboolean _tmp288_ = FALSE;
	ValaMethod* _tmp289_ = NULL;
	ValaCCodeExpression* ccall_expr = NULL;
	ValaCCodeFunctionCall* _tmp466_ = NULL;
	ValaCCodeExpression* _tmp467_ = NULL;
	ValaMethod* _tmp468_ = NULL;
	ValaCCodeExpression* instance = NULL;
	gboolean _tmp485_ = FALSE;
	ValaMethod* _tmp486_ = NULL;
	gboolean _tmp644_ = FALSE;
	ValaMethod* _tmp645_ = NULL;
	ValaMethod* _tmp702_ = NULL;
	gboolean ellipsis = FALSE;
	gint i = 0;
	gint arg_pos = 0;
	ValaIterator* params_it = NULL;
	ValaList* _tmp902_ = NULL;
	ValaIterator* _tmp903_ = NULL;
	ValaIterator* _tmp1273_ = NULL;
	gboolean _tmp1274_ = FALSE;
	gboolean _tmp1284_ = FALSE;
	gboolean _tmp1285_ = FALSE;
	ValaMethod* _tmp1286_ = NULL;
	gboolean _tmp1420_ = FALSE;
	ValaDelegate* _tmp1421_ = NULL;
	gboolean _tmp1516_ = FALSE;
	ValaMethod* _tmp1517_ = NULL;
	ValaMethodCall* _tmp1536_ = NULL;
	gboolean _tmp1537_ = FALSE;
	gboolean _tmp1538_ = FALSE;
	gboolean _tmp1545_ = FALSE;
	ValaDataType* _tmp1573_ = NULL;
	gboolean return_result_via_out_param = FALSE;
	ValaDataType* _tmp1603_ = NULL;
	ValaDataType* _tmp1604_ = NULL;
	ValaDataType* _tmp1605_ = NULL;
	gboolean _tmp1606_ = FALSE;
	gboolean _tmp1607_ = FALSE;
	gboolean _tmp1608_ = FALSE;
	ValaDataType* _tmp1609_ = NULL;
	ValaCCodeFunctionCall* _tmp1628_ = NULL;
	ValaCCodeFunctionCall* _tmp1629_ = NULL;
	ValaCCodeExpression* out_param_ref = NULL;
	gboolean _tmp1630_ = FALSE;
	gint last_pos = 0;
	gint min_pos = 0;
	ValaCCodeFunctionCall* _tmp1646_ = NULL;
	ValaCCodeFunctionCall* _tmp1647_ = NULL;
	ValaCCodeFunctionCall* _tmp1672_ = NULL;
	ValaMethodCall* _tmp1697_ = NULL;
	gboolean _tmp1698_ = FALSE;
	gboolean _tmp1699_ = FALSE;
	ValaMethodCall* _tmp1724_ = NULL;
	gboolean _tmp1725_ = FALSE;
	gboolean _tmp1726_ = FALSE;
	gboolean _tmp1759_ = FALSE;
	gboolean _tmp1765_ = FALSE;
	gboolean _tmp1766_ = FALSE;
	ValaMethod* _tmp1767_ = NULL;
	gboolean _tmp1806_ = FALSE;
	gboolean _tmp1807_ = FALSE;
	ValaMethod* _tmp1808_ = NULL;
	ValaMethod* _tmp1827_ = NULL;
	gboolean _tmp1946_ = FALSE;
	ValaMethodCall* _tmp1947_ = NULL;
	ValaCodeNode* _tmp1948_ = NULL;
	ValaCodeNode* _tmp1949_ = NULL;
	ValaList* _tmp2019_ = NULL;
	ValaIterator* _tmp2020_ = NULL;
	gboolean _tmp2081_ = FALSE;
	gboolean _tmp2082_ = FALSE;
	ValaMethod* _tmp2083_ = NULL;
	self = (ValaCCodeMethodCallModule*) base;
	g_return_if_fail (expr != NULL);
	_tmp0_ = expr;
	_tmp1_ = vala_method_call_get_call (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_ccode_function_call_new (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_ccode_node_unref0 (_tmp4_);
	ccall = _tmp6_;
	async_call = NULL;
	finish_call = NULL;
	m = NULL;
	deleg = NULL;
	_tmp7_ = expr;
	_tmp8_ = vala_method_call_get_call (_tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_MEMBER_ACCESS) ? ((ValaMemberAccess*) _tmp9_) : NULL);
	ma = _tmp10_;
	_tmp11_ = expr;
	_tmp12_ = vala_method_call_get_call (_tmp11_);
	_tmp13_ = _tmp12_;
	_tmp14_ = vala_expression_get_value_type (_tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = _vala_code_node_ref0 (_tmp15_);
	itype = _tmp16_;
	_tmp17_ = itype;
	_tmp18_ = vala_data_type_get_parameters (_tmp17_);
	_vala_iterable_unref0 (params);
	params = _tmp18_;
	_tmp19_ = itype;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp19_, VALA_TYPE_METHOD_TYPE)) {
		ValaMemberAccess* _tmp20_ = NULL;
		ValaDataType* _tmp21_ = NULL;
		ValaMethod* _tmp22_ = NULL;
		ValaMethod* _tmp23_ = NULL;
		ValaMethod* _tmp24_ = NULL;
		gboolean _tmp25_ = FALSE;
		gboolean _tmp26_ = FALSE;
		ValaMemberAccess* _tmp27_ = NULL;
		ValaExpression* _tmp28_ = NULL;
		ValaExpression* _tmp29_ = NULL;
		_tmp20_ = ma;
		_vala_assert (_tmp20_ != NULL, "ma != null");
		_tmp21_ = itype;
		_tmp22_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp21_, VALA_TYPE_METHOD_TYPE, ValaMethodType));
		_tmp23_ = _tmp22_;
		_tmp24_ = _vala_code_node_ref0 (_tmp23_);
		_vala_code_node_unref0 (m);
		m = _tmp24_;
		_tmp27_ = ma;
		_tmp28_ = vala_member_access_get_inner (_tmp27_);
		_tmp29_ = _tmp28_;
		if (_tmp29_ != NULL) {
			ValaMemberAccess* _tmp30_ = NULL;
			ValaExpression* _tmp31_ = NULL;
			ValaExpression* _tmp32_ = NULL;
			ValaDataType* _tmp33_ = NULL;
			ValaDataType* _tmp34_ = NULL;
			_tmp30_ = ma;
			_tmp31_ = vala_member_access_get_inner (_tmp30_);
			_tmp32_ = _tmp31_;
			_tmp33_ = vala_expression_get_value_type (_tmp32_);
			_tmp34_ = _tmp33_;
			_tmp26_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp34_, VALA_TYPE_ENUM_VALUE_TYPE);
		} else {
			_tmp26_ = FALSE;
		}
		if (_tmp26_) {
			ValaMemberAccess* _tmp35_ = NULL;
			ValaExpression* _tmp36_ = NULL;
			ValaExpression* _tmp37_ = NULL;
			ValaDataType* _tmp38_ = NULL;
			ValaDataType* _tmp39_ = NULL;
			ValaMethod* _tmp40_ = NULL;
			ValaMethod* _tmp41_ = NULL;
			ValaMethod* _tmp42_ = NULL;
			_tmp35_ = ma;
			_tmp36_ = vala_member_access_get_inner (_tmp35_);
			_tmp37_ = _tmp36_;
			_tmp38_ = vala_expression_get_value_type (_tmp37_);
			_tmp39_ = _tmp38_;
			_tmp40_ = vala_enum_value_type_get_to_string_method (G_TYPE_CHECK_INSTANCE_CAST (_tmp39_, VALA_TYPE_ENUM_VALUE_TYPE, ValaEnumValueType));
			_tmp41_ = _tmp40_;
			_tmp42_ = m;
			_tmp25_ = _tmp41_ == _tmp42_;
			_vala_code_node_unref0 (_tmp41_);
		} else {
			_tmp25_ = FALSE;
		}
		if (_tmp25_) {
			ValaEnum* en = NULL;
			ValaMemberAccess* _tmp43_ = NULL;
			ValaExpression* _tmp44_ = NULL;
			ValaExpression* _tmp45_ = NULL;
			ValaDataType* _tmp46_ = NULL;
			ValaDataType* _tmp47_ = NULL;
			ValaTypeSymbol* _tmp48_ = NULL;
			ValaTypeSymbol* _tmp49_ = NULL;
			ValaEnum* _tmp50_ = NULL;
			ValaCCodeFunctionCall* _tmp51_ = NULL;
			ValaEnum* _tmp52_ = NULL;
			gchar* _tmp53_ = NULL;
			gchar* _tmp54_ = NULL;
			ValaCCodeIdentifier* _tmp55_ = NULL;
			ValaCCodeIdentifier* _tmp56_ = NULL;
			_tmp43_ = ma;
			_tmp44_ = vala_member_access_get_inner (_tmp43_);
			_tmp45_ = _tmp44_;
			_tmp46_ = vala_expression_get_value_type (_tmp45_);
			_tmp47_ = _tmp46_;
			_tmp48_ = vala_data_type_get_data_type (_tmp47_);
			_tmp49_ = _tmp48_;
			_tmp50_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp49_, VALA_TYPE_ENUM, ValaEnum));
			en = _tmp50_;
			_tmp51_ = ccall;
			_tmp52_ = en;
			_tmp53_ = vala_ccode_method_call_module_generate_enum_tostring_function (self, _tmp52_);
			_tmp54_ = _tmp53_;
			_tmp55_ = vala_ccode_identifier_new (_tmp54_);
			_tmp56_ = _tmp55_;
			vala_ccode_function_call_set_call (_tmp51_, (ValaCCodeExpression*) _tmp56_);
			_vala_ccode_node_unref0 (_tmp56_);
			_g_free0 (_tmp54_);
			_vala_code_node_unref0 (en);
		} else {
			ValaMethodCall* _tmp57_ = NULL;
			gboolean _tmp58_ = FALSE;
			gboolean _tmp59_ = FALSE;
			_tmp57_ = expr;
			_tmp58_ = vala_method_call_get_is_constructv_chainup (_tmp57_);
			_tmp59_ = _tmp58_;
			if (_tmp59_) {
				ValaCCodeFunctionCall* _tmp60_ = NULL;
				ValaMethod* _tmp61_ = NULL;
				gchar* _tmp62_ = NULL;
				gchar* _tmp63_ = NULL;
				ValaCCodeIdentifier* _tmp64_ = NULL;
				ValaCCodeIdentifier* _tmp65_ = NULL;
				_tmp60_ = ccall;
				_tmp61_ = m;
				_tmp62_ = vala_ccode_base_module_get_ccode_constructv_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp61_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
				_tmp63_ = _tmp62_;
				_tmp64_ = vala_ccode_identifier_new (_tmp63_);
				_tmp65_ = _tmp64_;
				vala_ccode_function_call_set_call (_tmp60_, (ValaCCodeExpression*) _tmp65_);
				_vala_ccode_node_unref0 (_tmp65_);
				_g_free0 (_tmp63_);
			}
		}
	} else {
		ValaDataType* _tmp66_ = NULL;
		_tmp66_ = itype;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp66_, VALA_TYPE_SIGNAL_TYPE)) {
			ValaSignalType* sig_type = NULL;
			ValaDataType* _tmp67_ = NULL;
			ValaSignalType* _tmp68_ = NULL;
			gboolean _tmp69_ = FALSE;
			gboolean _tmp70_ = FALSE;
			ValaMemberAccess* _tmp71_ = NULL;
			_tmp67_ = itype;
			_tmp68_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp67_, VALA_TYPE_SIGNAL_TYPE, ValaSignalType));
			sig_type = _tmp68_;
			_tmp71_ = ma;
			if (_tmp71_ != NULL) {
				ValaMemberAccess* _tmp72_ = NULL;
				ValaExpression* _tmp73_ = NULL;
				ValaExpression* _tmp74_ = NULL;
				_tmp72_ = ma;
				_tmp73_ = vala_member_access_get_inner (_tmp72_);
				_tmp74_ = _tmp73_;
				_tmp70_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp74_, VALA_TYPE_BASE_ACCESS);
			} else {
				_tmp70_ = FALSE;
			}
			if (_tmp70_) {
				ValaSignalType* _tmp75_ = NULL;
				ValaSignal* _tmp76_ = NULL;
				ValaSignal* _tmp77_ = NULL;
				gboolean _tmp78_ = FALSE;
				gboolean _tmp79_ = FALSE;
				_tmp75_ = sig_type;
				_tmp76_ = vala_signal_type_get_signal_symbol (_tmp75_);
				_tmp77_ = _tmp76_;
				_tmp78_ = vala_signal_get_is_virtual (_tmp77_);
				_tmp79_ = _tmp78_;
				_tmp69_ = _tmp79_;
			} else {
				_tmp69_ = FALSE;
			}
			if (_tmp69_) {
				ValaSignalType* _tmp80_ = NULL;
				ValaSignal* _tmp81_ = NULL;
				ValaSignal* _tmp82_ = NULL;
				ValaMethod* _tmp83_ = NULL;
				ValaMethod* _tmp84_ = NULL;
				ValaMethod* _tmp85_ = NULL;
				_tmp80_ = sig_type;
				_tmp81_ = vala_signal_type_get_signal_symbol (_tmp80_);
				_tmp82_ = _tmp81_;
				_tmp83_ = vala_signal_get_default_handler (_tmp82_);
				_tmp84_ = _tmp83_;
				_tmp85_ = _vala_code_node_ref0 (_tmp84_);
				_vala_code_node_unref0 (m);
				m = _tmp85_;
			} else {
				ValaMethodCall* _tmp86_ = NULL;
				ValaExpression* _tmp87_ = NULL;
				ValaExpression* _tmp88_ = NULL;
				ValaCCodeExpression* _tmp89_ = NULL;
				_tmp86_ = expr;
				_tmp87_ = vala_method_call_get_call (_tmp86_);
				_tmp88_ = _tmp87_;
				_tmp89_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp88_);
				_vala_ccode_node_unref0 (ccall);
				ccall = G_TYPE_CHECK_INSTANCE_CAST (_tmp89_, VALA_TYPE_CCODE_FUNCTION_CALL, ValaCCodeFunctionCall);
			}
			_vala_code_node_unref0 (sig_type);
		} else {
			ValaDataType* _tmp90_ = NULL;
			_tmp90_ = itype;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp90_, VALA_TYPE_OBJECT_TYPE)) {
				ValaClass* cl = NULL;
				ValaDataType* _tmp91_ = NULL;
				ValaObjectTypeSymbol* _tmp92_ = NULL;
				ValaObjectTypeSymbol* _tmp93_ = NULL;
				ValaClass* _tmp94_ = NULL;
				ValaClass* _tmp95_ = NULL;
				ValaCreationMethod* _tmp96_ = NULL;
				ValaCreationMethod* _tmp97_ = NULL;
				ValaMethod* _tmp98_ = NULL;
				ValaMethod* _tmp99_ = NULL;
				ValaCCodeFile* _tmp100_ = NULL;
				gchar* real_name = NULL;
				ValaMethod* _tmp101_ = NULL;
				gchar* _tmp102_ = NULL;
				ValaMethodCall* _tmp103_ = NULL;
				gboolean _tmp104_ = FALSE;
				gboolean _tmp105_ = FALSE;
				const gchar* _tmp108_ = NULL;
				ValaCCodeIdentifier* _tmp109_ = NULL;
				ValaCCodeIdentifier* _tmp110_ = NULL;
				ValaCCodeFunctionCall* _tmp111_ = NULL;
				_tmp91_ = itype;
				_tmp92_ = vala_object_type_get_type_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp91_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));
				_tmp93_ = _tmp92_;
				_tmp94_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp93_, VALA_TYPE_CLASS, ValaClass));
				cl = _tmp94_;
				_tmp95_ = cl;
				_tmp96_ = vala_class_get_default_construction_method (_tmp95_);
				_tmp97_ = _tmp96_;
				_tmp98_ = _vala_code_node_ref0 ((ValaMethod*) _tmp97_);
				_vala_code_node_unref0 (m);
				m = _tmp98_;
				_tmp99_ = m;
				_tmp100_ = ((ValaCCodeBaseModule*) self)->cfile;
				vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp99_, _tmp100_);
				_tmp101_ = m;
				_tmp102_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp101_);
				real_name = _tmp102_;
				_tmp103_ = expr;
				_tmp104_ = vala_method_call_get_is_constructv_chainup (_tmp103_);
				_tmp105_ = _tmp104_;
				if (_tmp105_) {
					ValaMethod* _tmp106_ = NULL;
					gchar* _tmp107_ = NULL;
					_tmp106_ = m;
					_tmp107_ = vala_ccode_base_module_get_ccode_constructv_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp106_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
					_g_free0 (real_name);
					real_name = _tmp107_;
				}
				_tmp108_ = real_name;
				_tmp109_ = vala_ccode_identifier_new (_tmp108_);
				_tmp110_ = _tmp109_;
				_tmp111_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp110_);
				_vala_ccode_node_unref0 (ccall);
				ccall = _tmp111_;
				_vala_ccode_node_unref0 (_tmp110_);
				_g_free0 (real_name);
				_vala_code_node_unref0 (cl);
			} else {
				ValaDataType* _tmp112_ = NULL;
				_tmp112_ = itype;
				if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp112_, VALA_TYPE_STRUCT_VALUE_TYPE)) {
					ValaStruct* st = NULL;
					ValaDataType* _tmp113_ = NULL;
					ValaTypeSymbol* _tmp114_ = NULL;
					ValaTypeSymbol* _tmp115_ = NULL;
					ValaStruct* _tmp116_ = NULL;
					ValaStruct* _tmp117_ = NULL;
					ValaMethod* _tmp118_ = NULL;
					ValaMethod* _tmp119_ = NULL;
					ValaMethod* _tmp120_ = NULL;
					ValaMethod* _tmp121_ = NULL;
					ValaCCodeFile* _tmp122_ = NULL;
					ValaMethod* _tmp123_ = NULL;
					gchar* _tmp124_ = NULL;
					gchar* _tmp125_ = NULL;
					ValaCCodeIdentifier* _tmp126_ = NULL;
					ValaCCodeIdentifier* _tmp127_ = NULL;
					ValaCCodeFunctionCall* _tmp128_ = NULL;
					_tmp113_ = itype;
					_tmp114_ = vala_value_type_get_type_symbol ((ValaValueType*) G_TYPE_CHECK_INSTANCE_CAST (_tmp113_, VALA_TYPE_STRUCT_VALUE_TYPE, ValaStructValueType));
					_tmp115_ = _tmp114_;
					_tmp116_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp115_, VALA_TYPE_STRUCT, ValaStruct));
					st = _tmp116_;
					_tmp117_ = st;
					_tmp118_ = vala_struct_get_default_construction_method (_tmp117_);
					_tmp119_ = _tmp118_;
					_tmp120_ = _vala_code_node_ref0 (_tmp119_);
					_vala_code_node_unref0 (m);
					m = _tmp120_;
					_tmp121_ = m;
					_tmp122_ = ((ValaCCodeBaseModule*) self)->cfile;
					vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp121_, _tmp122_);
					_tmp123_ = m;
					_tmp124_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp123_);
					_tmp125_ = _tmp124_;
					_tmp126_ = vala_ccode_identifier_new (_tmp125_);
					_tmp127_ = _tmp126_;
					_tmp128_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp127_);
					_vala_ccode_node_unref0 (ccall);
					ccall = _tmp128_;
					_vala_ccode_node_unref0 (_tmp127_);
					_g_free0 (_tmp125_);
					_vala_code_node_unref0 (st);
				} else {
					ValaDataType* _tmp129_ = NULL;
					_tmp129_ = itype;
					if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp129_, VALA_TYPE_DELEGATE_TYPE)) {
						ValaDataType* _tmp130_ = NULL;
						ValaDelegate* _tmp131_ = NULL;
						ValaDelegate* _tmp132_ = NULL;
						ValaDelegate* _tmp133_ = NULL;
						_tmp130_ = itype;
						_tmp131_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp130_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
						_tmp132_ = _tmp131_;
						_tmp133_ = _vala_code_node_ref0 (_tmp132_);
						_vala_code_node_unref0 (deleg);
						deleg = _tmp133_;
					}
				}
			}
		}
	}
	_tmp134_ = g_direct_hash;
	_tmp135_ = g_direct_equal;
	_tmp136_ = g_direct_equal;
	_tmp137_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp134_, _tmp135_, _tmp136_);
	in_arg_map = _tmp137_;
	_tmp138_ = in_arg_map;
	_tmp139_ = _vala_map_ref0 (_tmp138_);
	out_arg_map = _tmp139_;
	_tmp141_ = m;
	if (_tmp141_ != NULL) {
		ValaMethod* _tmp142_ = NULL;
		gboolean _tmp143_ = FALSE;
		gboolean _tmp144_ = FALSE;
		_tmp142_ = m;
		_tmp143_ = vala_method_get_coroutine (_tmp142_);
		_tmp144_ = _tmp143_;
		_tmp140_ = _tmp144_;
	} else {
		_tmp140_ = FALSE;
	}
	if (_tmp140_) {
		ValaMethod* _tmp145_ = NULL;
		gchar* _tmp146_ = NULL;
		gchar* _tmp147_ = NULL;
		ValaCCodeIdentifier* _tmp148_ = NULL;
		ValaCCodeIdentifier* _tmp149_ = NULL;
		ValaCCodeFunctionCall* _tmp150_ = NULL;
		ValaMethod* _tmp151_ = NULL;
		gchar* _tmp152_ = NULL;
		gchar* _tmp153_ = NULL;
		ValaCCodeIdentifier* _tmp154_ = NULL;
		ValaCCodeIdentifier* _tmp155_ = NULL;
		ValaCCodeFunctionCall* _tmp156_ = NULL;
		ValaMemberAccess* _tmp157_ = NULL;
		ValaExpression* _tmp158_ = NULL;
		ValaExpression* _tmp159_ = NULL;
		gboolean _tmp237_ = FALSE;
		ValaMemberAccess* _tmp238_ = NULL;
		const gchar* _tmp239_ = NULL;
		const gchar* _tmp240_ = NULL;
		_tmp145_ = m;
		_tmp146_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp145_);
		_tmp147_ = _tmp146_;
		_tmp148_ = vala_ccode_identifier_new (_tmp147_);
		_tmp149_ = _tmp148_;
		_tmp150_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp149_);
		_vala_ccode_node_unref0 (async_call);
		async_call = _tmp150_;
		_vala_ccode_node_unref0 (_tmp149_);
		_g_free0 (_tmp147_);
		_tmp151_ = m;
		_tmp152_ = vala_ccode_base_module_get_ccode_finish_name (_tmp151_);
		_tmp153_ = _tmp152_;
		_tmp154_ = vala_ccode_identifier_new (_tmp153_);
		_tmp155_ = _tmp154_;
		_tmp156_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp155_);
		_vala_ccode_node_unref0 (finish_call);
		finish_call = _tmp156_;
		_vala_ccode_node_unref0 (_tmp155_);
		_g_free0 (_tmp153_);
		_tmp157_ = ma;
		_tmp158_ = vala_member_access_get_inner (_tmp157_);
		_tmp159_ = _tmp158_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp159_, VALA_TYPE_BASE_ACCESS)) {
			ValaMethod* _tmp160_ = NULL;
			ValaMethod* _tmp161_ = NULL;
			ValaMethod* _tmp162_ = NULL;
			_tmp160_ = m;
			_tmp161_ = vala_method_get_base_method (_tmp160_);
			_tmp162_ = _tmp161_;
			if (_tmp162_ != NULL) {
				ValaClass* base_class = NULL;
				ValaMethod* _tmp163_ = NULL;
				ValaMethod* _tmp164_ = NULL;
				ValaMethod* _tmp165_ = NULL;
				ValaSymbol* _tmp166_ = NULL;
				ValaSymbol* _tmp167_ = NULL;
				ValaClass* _tmp168_ = NULL;
				ValaCCodeFunctionCall* vcast = NULL;
				ValaClass* _tmp169_ = NULL;
				gchar* _tmp170_ = NULL;
				gchar* _tmp171_ = NULL;
				gchar* _tmp172_ = NULL;
				gchar* _tmp173_ = NULL;
				ValaCCodeIdentifier* _tmp174_ = NULL;
				ValaCCodeIdentifier* _tmp175_ = NULL;
				ValaCCodeFunctionCall* _tmp176_ = NULL;
				ValaCCodeFunctionCall* _tmp177_ = NULL;
				ValaCCodeFunctionCall* _tmp178_ = NULL;
				ValaClass* _tmp179_ = NULL;
				ValaClass* _tmp180_ = NULL;
				gchar* _tmp181_ = NULL;
				gchar* _tmp182_ = NULL;
				gchar* _tmp183_ = NULL;
				gchar* _tmp184_ = NULL;
				ValaCCodeIdentifier* _tmp185_ = NULL;
				ValaCCodeIdentifier* _tmp186_ = NULL;
				ValaCCodeFunctionCall* _tmp187_ = NULL;
				ValaCCodeFunctionCall* _tmp188_ = NULL;
				ValaMethod* _tmp189_ = NULL;
				gchar* _tmp190_ = NULL;
				gchar* _tmp191_ = NULL;
				ValaCCodeMemberAccess* _tmp192_ = NULL;
				ValaCCodeMemberAccess* _tmp193_ = NULL;
				ValaCCodeFunctionCall* _tmp194_ = NULL;
				ValaCCodeFunctionCall* _tmp195_ = NULL;
				ValaMethod* _tmp196_ = NULL;
				gchar* _tmp197_ = NULL;
				gchar* _tmp198_ = NULL;
				ValaCCodeMemberAccess* _tmp199_ = NULL;
				ValaCCodeMemberAccess* _tmp200_ = NULL;
				_tmp163_ = m;
				_tmp164_ = vala_method_get_base_method (_tmp163_);
				_tmp165_ = _tmp164_;
				_tmp166_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp165_);
				_tmp167_ = _tmp166_;
				_tmp168_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp167_, VALA_TYPE_CLASS, ValaClass));
				base_class = _tmp168_;
				_tmp169_ = base_class;
				_tmp170_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp169_, NULL);
				_tmp171_ = _tmp170_;
				_tmp172_ = g_strdup_printf ("%s_CLASS", _tmp171_);
				_tmp173_ = _tmp172_;
				_tmp174_ = vala_ccode_identifier_new (_tmp173_);
				_tmp175_ = _tmp174_;
				_tmp176_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp175_);
				_tmp177_ = _tmp176_;
				_vala_ccode_node_unref0 (_tmp175_);
				_g_free0 (_tmp173_);
				_g_free0 (_tmp171_);
				vcast = _tmp177_;
				_tmp178_ = vcast;
				_tmp179_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
				_tmp180_ = _tmp179_;
				_tmp181_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp180_, NULL);
				_tmp182_ = _tmp181_;
				_tmp183_ = g_strdup_printf ("%s_parent_class", _tmp182_);
				_tmp184_ = _tmp183_;
				_tmp185_ = vala_ccode_identifier_new (_tmp184_);
				_tmp186_ = _tmp185_;
				vala_ccode_function_call_add_argument (_tmp178_, (ValaCCodeExpression*) _tmp186_);
				_vala_ccode_node_unref0 (_tmp186_);
				_g_free0 (_tmp184_);
				_g_free0 (_tmp182_);
				_tmp187_ = async_call;
				_tmp188_ = vcast;
				_tmp189_ = m;
				_tmp190_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp189_);
				_tmp191_ = _tmp190_;
				_tmp192_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp188_, _tmp191_);
				_tmp193_ = _tmp192_;
				vala_ccode_function_call_set_call (_tmp187_, (ValaCCodeExpression*) _tmp193_);
				_vala_ccode_node_unref0 (_tmp193_);
				_g_free0 (_tmp191_);
				_tmp194_ = finish_call;
				_tmp195_ = vcast;
				_tmp196_ = m;
				_tmp197_ = vala_ccode_base_module_get_ccode_finish_vfunc_name (_tmp196_);
				_tmp198_ = _tmp197_;
				_tmp199_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp195_, _tmp198_);
				_tmp200_ = _tmp199_;
				vala_ccode_function_call_set_call (_tmp194_, (ValaCCodeExpression*) _tmp200_);
				_vala_ccode_node_unref0 (_tmp200_);
				_g_free0 (_tmp198_);
				_vala_ccode_node_unref0 (vcast);
				_vala_code_node_unref0 (base_class);
			} else {
				ValaMethod* _tmp201_ = NULL;
				ValaMethod* _tmp202_ = NULL;
				ValaMethod* _tmp203_ = NULL;
				_tmp201_ = m;
				_tmp202_ = vala_method_get_base_interface_method (_tmp201_);
				_tmp203_ = _tmp202_;
				if (_tmp203_ != NULL) {
					ValaInterface* base_iface = NULL;
					ValaMethod* _tmp204_ = NULL;
					ValaMethod* _tmp205_ = NULL;
					ValaMethod* _tmp206_ = NULL;
					ValaSymbol* _tmp207_ = NULL;
					ValaSymbol* _tmp208_ = NULL;
					ValaInterface* _tmp209_ = NULL;
					gchar* parent_iface_var = NULL;
					ValaClass* _tmp210_ = NULL;
					ValaClass* _tmp211_ = NULL;
					gchar* _tmp212_ = NULL;
					gchar* _tmp213_ = NULL;
					ValaInterface* _tmp214_ = NULL;
					gchar* _tmp215_ = NULL;
					gchar* _tmp216_ = NULL;
					gchar* _tmp217_ = NULL;
					gchar* _tmp218_ = NULL;
					ValaCCodeFunctionCall* _tmp219_ = NULL;
					const gchar* _tmp220_ = NULL;
					ValaCCodeIdentifier* _tmp221_ = NULL;
					ValaCCodeIdentifier* _tmp222_ = NULL;
					ValaMethod* _tmp223_ = NULL;
					gchar* _tmp224_ = NULL;
					gchar* _tmp225_ = NULL;
					ValaCCodeMemberAccess* _tmp226_ = NULL;
					ValaCCodeMemberAccess* _tmp227_ = NULL;
					ValaCCodeFunctionCall* _tmp228_ = NULL;
					const gchar* _tmp229_ = NULL;
					ValaCCodeIdentifier* _tmp230_ = NULL;
					ValaCCodeIdentifier* _tmp231_ = NULL;
					ValaMethod* _tmp232_ = NULL;
					gchar* _tmp233_ = NULL;
					gchar* _tmp234_ = NULL;
					ValaCCodeMemberAccess* _tmp235_ = NULL;
					ValaCCodeMemberAccess* _tmp236_ = NULL;
					_tmp204_ = m;
					_tmp205_ = vala_method_get_base_interface_method (_tmp204_);
					_tmp206_ = _tmp205_;
					_tmp207_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp206_);
					_tmp208_ = _tmp207_;
					_tmp209_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp208_, VALA_TYPE_INTERFACE, ValaInterface));
					base_iface = _tmp209_;
					_tmp210_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
					_tmp211_ = _tmp210_;
					_tmp212_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp211_, NULL);
					_tmp213_ = _tmp212_;
					_tmp214_ = base_iface;
					_tmp215_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp214_, NULL);
					_tmp216_ = _tmp215_;
					_tmp217_ = g_strdup_printf ("%s_%s_parent_iface", _tmp213_, _tmp216_);
					_tmp218_ = _tmp217_;
					_g_free0 (_tmp216_);
					_g_free0 (_tmp213_);
					parent_iface_var = _tmp218_;
					_tmp219_ = async_call;
					_tmp220_ = parent_iface_var;
					_tmp221_ = vala_ccode_identifier_new (_tmp220_);
					_tmp222_ = _tmp221_;
					_tmp223_ = m;
					_tmp224_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp223_);
					_tmp225_ = _tmp224_;
					_tmp226_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp222_, _tmp225_);
					_tmp227_ = _tmp226_;
					vala_ccode_function_call_set_call (_tmp219_, (ValaCCodeExpression*) _tmp227_);
					_vala_ccode_node_unref0 (_tmp227_);
					_g_free0 (_tmp225_);
					_vala_ccode_node_unref0 (_tmp222_);
					_tmp228_ = finish_call;
					_tmp229_ = parent_iface_var;
					_tmp230_ = vala_ccode_identifier_new (_tmp229_);
					_tmp231_ = _tmp230_;
					_tmp232_ = m;
					_tmp233_ = vala_ccode_base_module_get_ccode_finish_vfunc_name (_tmp232_);
					_tmp234_ = _tmp233_;
					_tmp235_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp231_, _tmp234_);
					_tmp236_ = _tmp235_;
					vala_ccode_function_call_set_call (_tmp228_, (ValaCCodeExpression*) _tmp236_);
					_vala_ccode_node_unref0 (_tmp236_);
					_g_free0 (_tmp234_);
					_vala_ccode_node_unref0 (_tmp231_);
					_g_free0 (parent_iface_var);
					_vala_code_node_unref0 (base_iface);
				}
			}
		}
		_tmp238_ = ma;
		_tmp239_ = vala_member_access_get_member_name (_tmp238_);
		_tmp240_ = _tmp239_;
		if (g_strcmp0 (_tmp240_, "begin") == 0) {
			ValaMemberAccess* _tmp241_ = NULL;
			ValaExpression* _tmp242_ = NULL;
			ValaExpression* _tmp243_ = NULL;
			ValaSymbol* _tmp244_ = NULL;
			ValaSymbol* _tmp245_ = NULL;
			ValaMemberAccess* _tmp246_ = NULL;
			ValaSymbol* _tmp247_ = NULL;
			ValaSymbol* _tmp248_ = NULL;
			_tmp241_ = ma;
			_tmp242_ = vala_member_access_get_inner (_tmp241_);
			_tmp243_ = _tmp242_;
			_tmp244_ = vala_expression_get_symbol_reference (_tmp243_);
			_tmp245_ = _tmp244_;
			_tmp246_ = ma;
			_tmp247_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp246_);
			_tmp248_ = _tmp247_;
			_tmp237_ = _tmp245_ == _tmp248_;
		} else {
			_tmp237_ = FALSE;
		}
		if (_tmp237_) {
			ValaCCodeFunctionCall* _tmp249_ = NULL;
			ValaCCodeFunctionCall* _tmp250_ = NULL;
			ValaMethod* _tmp251_ = NULL;
			ValaList* _tmp252_ = NULL;
			_tmp249_ = async_call;
			_tmp250_ = _vala_ccode_node_ref0 (_tmp249_);
			_vala_ccode_node_unref0 (ccall);
			ccall = _tmp250_;
			_tmp251_ = m;
			_tmp252_ = vala_method_get_async_begin_parameters (_tmp251_);
			_vala_iterable_unref0 (params);
			params = _tmp252_;
		} else {
			gboolean _tmp253_ = FALSE;
			ValaMemberAccess* _tmp254_ = NULL;
			const gchar* _tmp255_ = NULL;
			const gchar* _tmp256_ = NULL;
			_tmp254_ = ma;
			_tmp255_ = vala_member_access_get_member_name (_tmp254_);
			_tmp256_ = _tmp255_;
			if (g_strcmp0 (_tmp256_, "end") == 0) {
				ValaMemberAccess* _tmp257_ = NULL;
				ValaExpression* _tmp258_ = NULL;
				ValaExpression* _tmp259_ = NULL;
				ValaSymbol* _tmp260_ = NULL;
				ValaSymbol* _tmp261_ = NULL;
				ValaMemberAccess* _tmp262_ = NULL;
				ValaSymbol* _tmp263_ = NULL;
				ValaSymbol* _tmp264_ = NULL;
				_tmp257_ = ma;
				_tmp258_ = vala_member_access_get_inner (_tmp257_);
				_tmp259_ = _tmp258_;
				_tmp260_ = vala_expression_get_symbol_reference (_tmp259_);
				_tmp261_ = _tmp260_;
				_tmp262_ = ma;
				_tmp263_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp262_);
				_tmp264_ = _tmp263_;
				_tmp253_ = _tmp261_ == _tmp264_;
			} else {
				_tmp253_ = FALSE;
			}
			if (_tmp253_) {
				ValaCCodeFunctionCall* _tmp265_ = NULL;
				ValaCCodeFunctionCall* _tmp266_ = NULL;
				ValaMethod* _tmp267_ = NULL;
				ValaList* _tmp268_ = NULL;
				_tmp265_ = finish_call;
				_tmp266_ = _vala_ccode_node_ref0 (_tmp265_);
				_vala_ccode_node_unref0 (ccall);
				ccall = _tmp266_;
				_tmp267_ = m;
				_tmp268_ = vala_method_get_async_end_parameters (_tmp267_);
				_vala_iterable_unref0 (params);
				params = _tmp268_;
			} else {
				ValaMethodCall* _tmp269_ = NULL;
				gboolean _tmp270_ = FALSE;
				gboolean _tmp271_ = FALSE;
				_tmp269_ = expr;
				_tmp270_ = vala_method_call_get_is_yield_expression (_tmp269_);
				_tmp271_ = _tmp270_;
				if (!_tmp271_) {
					ValaCCodeFunctionCall* _tmp272_ = NULL;
					ValaCCodeFunctionCall* _tmp273_ = NULL;
					ValaMethod* _tmp274_ = NULL;
					ValaList* _tmp275_ = NULL;
					_tmp272_ = async_call;
					_tmp273_ = _vala_ccode_node_ref0 (_tmp272_);
					_vala_ccode_node_unref0 (ccall);
					ccall = _tmp273_;
					_tmp274_ = m;
					_tmp275_ = vala_method_get_async_begin_parameters (_tmp274_);
					_vala_iterable_unref0 (params);
					params = _tmp275_;
				} else {
					ValaCCodeFunctionCall* _tmp276_ = NULL;
					ValaCCodeFunctionCall* _tmp277_ = NULL;
					GHashFunc _tmp278_ = NULL;
					GEqualFunc _tmp279_ = NULL;
					GEqualFunc _tmp280_ = NULL;
					ValaHashMap* _tmp281_ = NULL;
					ValaHashMap* _tmp282_ = NULL;
					gint _tmp283_ = 0;
					ValaCCodeIdentifier* _tmp284_ = NULL;
					ValaCCodeIdentifier* _tmp285_ = NULL;
					ValaCCodeMemberAccess* _tmp286_ = NULL;
					ValaCCodeMemberAccess* _tmp287_ = NULL;
					_tmp276_ = finish_call;
					_tmp277_ = _vala_ccode_node_ref0 (_tmp276_);
					_vala_ccode_node_unref0 (ccall);
					ccall = _tmp277_;
					_tmp278_ = g_direct_hash;
					_tmp279_ = g_direct_equal;
					_tmp280_ = g_direct_equal;
					_tmp281_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp278_, _tmp279_, _tmp280_);
					_vala_map_unref0 (out_arg_map);
					out_arg_map = _tmp281_;
					_tmp282_ = out_arg_map;
					_tmp283_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, 0.1, FALSE);
					_tmp284_ = vala_ccode_identifier_new ("_data_");
					_tmp285_ = _tmp284_;
					_tmp286_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp285_, "_res_");
					_tmp287_ = _tmp286_;
					vala_map_set ((ValaMap*) _tmp282_, (gpointer) ((gintptr) _tmp283_), (ValaCCodeExpression*) _tmp287_);
					_vala_ccode_node_unref0 (_tmp287_);
					_vala_ccode_node_unref0 (_tmp285_);
				}
			}
		}
	}
	_tmp289_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp289_, VALA_TYPE_CREATION_METHOD)) {
		ValaMethod* _tmp290_ = NULL;
		ValaSymbol* _tmp291_ = NULL;
		ValaSymbol* _tmp292_ = NULL;
		_tmp290_ = m;
		_tmp291_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp290_);
		_tmp292_ = _tmp291_;
		_tmp288_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp292_, VALA_TYPE_CLASS);
	} else {
		_tmp288_ = FALSE;
	}
	if (_tmp288_) {
		ValaMethod* _tmp293_ = NULL;
		ValaSymbol* _tmp294_ = NULL;
		ValaSymbol* _tmp295_ = NULL;
		gboolean _tmp296_ = FALSE;
		gboolean _tmp297_ = FALSE;
		ValaClass* _tmp301_ = NULL;
		ValaClass* _tmp302_ = NULL;
		gboolean _tmp303_ = FALSE;
		gboolean _tmp304_ = FALSE;
		_tmp293_ = m;
		_tmp294_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp293_);
		_tmp295_ = _tmp294_;
		_tmp296_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp295_, VALA_TYPE_CLASS, ValaClass));
		_tmp297_ = _tmp296_;
		if (!_tmp297_) {
			ValaCCodeFunctionCall* _tmp298_ = NULL;
			ValaCCodeExpression* _tmp299_ = NULL;
			ValaCCodeExpression* _tmp300_ = NULL;
			_tmp298_ = ccall;
			_tmp299_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "object_type");
			_tmp300_ = _tmp299_;
			vala_ccode_function_call_add_argument (_tmp298_, _tmp300_);
			_vala_ccode_node_unref0 (_tmp300_);
		}
		_tmp301_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp302_ = _tmp301_;
		_tmp303_ = vala_class_get_is_compact (_tmp302_);
		_tmp304_ = _tmp303_;
		if (!_tmp304_) {
			ValaClass* _tmp305_ = NULL;
			ValaClass* _tmp306_ = NULL;
			ValaMethod* _tmp307_ = NULL;
			ValaSymbol* _tmp308_ = NULL;
			ValaSymbol* _tmp309_ = NULL;
			_tmp305_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
			_tmp306_ = _tmp305_;
			_tmp307_ = m;
			_tmp308_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp307_);
			_tmp309_ = _tmp308_;
			if (G_TYPE_CHECK_INSTANCE_CAST (_tmp306_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp309_) {
				{
					ValaList* _base_type_list = NULL;
					ValaClass* _tmp310_ = NULL;
					ValaClass* _tmp311_ = NULL;
					ValaList* _tmp312_ = NULL;
					gint _base_type_size = 0;
					ValaList* _tmp313_ = NULL;
					gint _tmp314_ = 0;
					gint _tmp315_ = 0;
					gint _base_type_index = 0;
					_tmp310_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
					_tmp311_ = _tmp310_;
					_tmp312_ = vala_class_get_base_types (_tmp311_);
					_base_type_list = _tmp312_;
					_tmp313_ = _base_type_list;
					_tmp314_ = vala_collection_get_size ((ValaCollection*) _tmp313_);
					_tmp315_ = _tmp314_;
					_base_type_size = _tmp315_;
					_base_type_index = -1;
					while (TRUE) {
						gint _tmp316_ = 0;
						gint _tmp317_ = 0;
						gint _tmp318_ = 0;
						ValaDataType* base_type = NULL;
						ValaList* _tmp319_ = NULL;
						gint _tmp320_ = 0;
						gpointer _tmp321_ = NULL;
						ValaDataType* _tmp322_ = NULL;
						ValaTypeSymbol* _tmp323_ = NULL;
						ValaTypeSymbol* _tmp324_ = NULL;
						_tmp316_ = _base_type_index;
						_base_type_index = _tmp316_ + 1;
						_tmp317_ = _base_type_index;
						_tmp318_ = _base_type_size;
						if (!(_tmp317_ < _tmp318_)) {
							break;
						}
						_tmp319_ = _base_type_list;
						_tmp320_ = _base_type_index;
						_tmp321_ = vala_list_get (_tmp319_, _tmp320_);
						base_type = (ValaDataType*) _tmp321_;
						_tmp322_ = base_type;
						_tmp323_ = vala_data_type_get_data_type (_tmp322_);
						_tmp324_ = _tmp323_;
						if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp324_, VALA_TYPE_CLASS)) {
							ValaList* type_parameters = NULL;
							ValaMethod* _tmp325_ = NULL;
							gchar* _tmp326_ = NULL;
							gchar* _tmp327_ = NULL;
							gboolean _tmp328_ = FALSE;
							ValaHashMap* _tmp333_ = NULL;
							ValaDataType* _tmp334_ = NULL;
							ValaList* _tmp335_ = NULL;
							ValaList* _tmp336_ = NULL;
							ValaMethodCall* _tmp337_ = NULL;
							ValaList* _tmp338_ = NULL;
							type_parameters = NULL;
							_tmp325_ = m;
							_tmp326_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp325_);
							_tmp327_ = _tmp326_;
							_tmp328_ = g_strcmp0 (_tmp327_, "g_object_new") == 0;
							_g_free0 (_tmp327_);
							if (_tmp328_) {
								ValaDataType* _tmp329_ = NULL;
								ValaTypeSymbol* _tmp330_ = NULL;
								ValaTypeSymbol* _tmp331_ = NULL;
								ValaList* _tmp332_ = NULL;
								_tmp329_ = base_type;
								_tmp330_ = vala_data_type_get_data_type (_tmp329_);
								_tmp331_ = _tmp330_;
								_tmp332_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp331_, VALA_TYPE_CLASS, ValaClass));
								_vala_iterable_unref0 (type_parameters);
								type_parameters = _tmp332_;
							}
							_tmp333_ = in_arg_map;
							_tmp334_ = base_type;
							_tmp335_ = vala_data_type_get_type_arguments (_tmp334_);
							_tmp336_ = _tmp335_;
							_tmp337_ = expr;
							_tmp338_ = type_parameters;
							vala_ccode_base_module_add_generic_type_arguments ((ValaCCodeBaseModule*) self, (ValaMap*) _tmp333_, _tmp336_, (ValaCodeNode*) _tmp337_, TRUE, _tmp338_);
							_vala_iterable_unref0 (_tmp336_);
							_vala_iterable_unref0 (type_parameters);
							_vala_code_node_unref0 (base_type);
							break;
						}
						_vala_code_node_unref0 (base_type);
					}
					_vala_iterable_unref0 (_base_type_list);
				}
			} else {
				gint type_param_index = 0;
				ValaClass* cl = NULL;
				ValaMethod* _tmp339_ = NULL;
				ValaSymbol* _tmp340_ = NULL;
				ValaSymbol* _tmp341_ = NULL;
				ValaClass* _tmp342_ = NULL;
				type_param_index = 0;
				_tmp339_ = m;
				_tmp340_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp339_);
				_tmp341_ = _tmp340_;
				_tmp342_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp341_, VALA_TYPE_CLASS, ValaClass));
				cl = _tmp342_;
				{
					ValaList* _type_param_list = NULL;
					ValaClass* _tmp343_ = NULL;
					ValaList* _tmp344_ = NULL;
					gint _type_param_size = 0;
					ValaList* _tmp345_ = NULL;
					gint _tmp346_ = 0;
					gint _tmp347_ = 0;
					gint _type_param_index = 0;
					_tmp343_ = cl;
					_tmp344_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp343_);
					_type_param_list = _tmp344_;
					_tmp345_ = _type_param_list;
					_tmp346_ = vala_collection_get_size ((ValaCollection*) _tmp345_);
					_tmp347_ = _tmp346_;
					_type_param_size = _tmp347_;
					_type_param_index = -1;
					while (TRUE) {
						gint _tmp348_ = 0;
						gint _tmp349_ = 0;
						gint _tmp350_ = 0;
						ValaTypeParameter* type_param = NULL;
						ValaList* _tmp351_ = NULL;
						gint _tmp352_ = 0;
						gpointer _tmp353_ = NULL;
						ValaHashMap* _tmp354_ = NULL;
						gint _tmp355_ = 0;
						gint _tmp356_ = 0;
						ValaTypeParameter* _tmp357_ = NULL;
						const gchar* _tmp358_ = NULL;
						const gchar* _tmp359_ = NULL;
						gchar* _tmp360_ = NULL;
						gchar* _tmp361_ = NULL;
						gchar* _tmp362_ = NULL;
						gchar* _tmp363_ = NULL;
						ValaCCodeIdentifier* _tmp364_ = NULL;
						ValaCCodeIdentifier* _tmp365_ = NULL;
						ValaHashMap* _tmp366_ = NULL;
						gint _tmp367_ = 0;
						gint _tmp368_ = 0;
						ValaTypeParameter* _tmp369_ = NULL;
						const gchar* _tmp370_ = NULL;
						const gchar* _tmp371_ = NULL;
						gchar* _tmp372_ = NULL;
						gchar* _tmp373_ = NULL;
						gchar* _tmp374_ = NULL;
						gchar* _tmp375_ = NULL;
						ValaCCodeIdentifier* _tmp376_ = NULL;
						ValaCCodeIdentifier* _tmp377_ = NULL;
						ValaHashMap* _tmp378_ = NULL;
						gint _tmp379_ = 0;
						gint _tmp380_ = 0;
						ValaTypeParameter* _tmp381_ = NULL;
						const gchar* _tmp382_ = NULL;
						const gchar* _tmp383_ = NULL;
						gchar* _tmp384_ = NULL;
						gchar* _tmp385_ = NULL;
						gchar* _tmp386_ = NULL;
						gchar* _tmp387_ = NULL;
						ValaCCodeIdentifier* _tmp388_ = NULL;
						ValaCCodeIdentifier* _tmp389_ = NULL;
						gint _tmp390_ = 0;
						_tmp348_ = _type_param_index;
						_type_param_index = _tmp348_ + 1;
						_tmp349_ = _type_param_index;
						_tmp350_ = _type_param_size;
						if (!(_tmp349_ < _tmp350_)) {
							break;
						}
						_tmp351_ = _type_param_list;
						_tmp352_ = _type_param_index;
						_tmp353_ = vala_list_get (_tmp351_, _tmp352_);
						type_param = (ValaTypeParameter*) _tmp353_;
						_tmp354_ = in_arg_map;
						_tmp355_ = type_param_index;
						_tmp356_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp355_) + 0.01, FALSE);
						_tmp357_ = type_param;
						_tmp358_ = vala_symbol_get_name ((ValaSymbol*) _tmp357_);
						_tmp359_ = _tmp358_;
						_tmp360_ = g_utf8_strdown (_tmp359_, (gssize) (-1));
						_tmp361_ = _tmp360_;
						_tmp362_ = g_strdup_printf ("%s_type", _tmp361_);
						_tmp363_ = _tmp362_;
						_tmp364_ = vala_ccode_identifier_new (_tmp363_);
						_tmp365_ = _tmp364_;
						vala_map_set ((ValaMap*) _tmp354_, (gpointer) ((gintptr) _tmp356_), (ValaCCodeExpression*) _tmp365_);
						_vala_ccode_node_unref0 (_tmp365_);
						_g_free0 (_tmp363_);
						_g_free0 (_tmp361_);
						_tmp366_ = in_arg_map;
						_tmp367_ = type_param_index;
						_tmp368_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp367_) + 0.02, FALSE);
						_tmp369_ = type_param;
						_tmp370_ = vala_symbol_get_name ((ValaSymbol*) _tmp369_);
						_tmp371_ = _tmp370_;
						_tmp372_ = g_utf8_strdown (_tmp371_, (gssize) (-1));
						_tmp373_ = _tmp372_;
						_tmp374_ = g_strdup_printf ("%s_dup_func", _tmp373_);
						_tmp375_ = _tmp374_;
						_tmp376_ = vala_ccode_identifier_new (_tmp375_);
						_tmp377_ = _tmp376_;
						vala_map_set ((ValaMap*) _tmp366_, (gpointer) ((gintptr) _tmp368_), (ValaCCodeExpression*) _tmp377_);
						_vala_ccode_node_unref0 (_tmp377_);
						_g_free0 (_tmp375_);
						_g_free0 (_tmp373_);
						_tmp378_ = in_arg_map;
						_tmp379_ = type_param_index;
						_tmp380_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp379_) + 0.03, FALSE);
						_tmp381_ = type_param;
						_tmp382_ = vala_symbol_get_name ((ValaSymbol*) _tmp381_);
						_tmp383_ = _tmp382_;
						_tmp384_ = g_utf8_strdown (_tmp383_, (gssize) (-1));
						_tmp385_ = _tmp384_;
						_tmp386_ = g_strdup_printf ("%s_destroy_func", _tmp385_);
						_tmp387_ = _tmp386_;
						_tmp388_ = vala_ccode_identifier_new (_tmp387_);
						_tmp389_ = _tmp388_;
						vala_map_set ((ValaMap*) _tmp378_, (gpointer) ((gintptr) _tmp380_), (ValaCCodeExpression*) _tmp389_);
						_vala_ccode_node_unref0 (_tmp389_);
						_g_free0 (_tmp387_);
						_g_free0 (_tmp385_);
						_tmp390_ = type_param_index;
						type_param_index = _tmp390_ + 1;
						_vala_code_node_unref0 (type_param);
					}
					_vala_iterable_unref0 (_type_param_list);
				}
				_vala_code_node_unref0 (cl);
			}
		} else {
			ValaClass* _tmp391_ = NULL;
			ValaClass* _tmp392_ = NULL;
			ValaClass* _tmp393_ = NULL;
			ValaClass* _tmp394_ = NULL;
			ValaClass* _tmp395_ = NULL;
			_tmp391_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
			_tmp392_ = _tmp391_;
			_tmp393_ = vala_class_get_base_class (_tmp392_);
			_tmp394_ = _tmp393_;
			_tmp395_ = ((ValaCCodeBaseModule*) self)->gsource_type;
			if (_tmp394_ == _tmp395_) {
				gchar* class_prefix = NULL;
				ValaClass* _tmp396_ = NULL;
				ValaClass* _tmp397_ = NULL;
				gchar* _tmp398_ = NULL;
				ValaCCodeDeclaration* funcs = NULL;
				ValaCCodeDeclaration* _tmp399_ = NULL;
				ValaCCodeDeclaration* _tmp400_ = NULL;
				ValaCCodeDeclaration* _tmp401_ = NULL;
				const gchar* _tmp402_ = NULL;
				const gchar* _tmp403_ = NULL;
				const gchar* _tmp404_ = NULL;
				const gchar* _tmp405_ = NULL;
				gchar* _tmp406_ = NULL;
				gchar* _tmp407_ = NULL;
				ValaCCodeConstant* _tmp408_ = NULL;
				ValaCCodeConstant* _tmp409_ = NULL;
				ValaCCodeVariableDeclarator* _tmp410_ = NULL;
				ValaCCodeVariableDeclarator* _tmp411_ = NULL;
				ValaCCodeFunction* _tmp412_ = NULL;
				ValaCCodeFunction* _tmp413_ = NULL;
				ValaCCodeDeclaration* _tmp414_ = NULL;
				ValaCCodeFunctionCall* _tmp415_ = NULL;
				ValaCCodeIdentifier* _tmp416_ = NULL;
				ValaCCodeIdentifier* _tmp417_ = NULL;
				ValaCCodeUnaryExpression* _tmp418_ = NULL;
				ValaCCodeUnaryExpression* _tmp419_ = NULL;
				ValaCCodeFunctionCall* csizeof = NULL;
				ValaCCodeIdentifier* _tmp420_ = NULL;
				ValaCCodeIdentifier* _tmp421_ = NULL;
				ValaCCodeFunctionCall* _tmp422_ = NULL;
				ValaCCodeFunctionCall* _tmp423_ = NULL;
				ValaCCodeFunctionCall* _tmp424_ = NULL;
				ValaClass* _tmp425_ = NULL;
				ValaClass* _tmp426_ = NULL;
				gchar* _tmp427_ = NULL;
				gchar* _tmp428_ = NULL;
				ValaCCodeIdentifier* _tmp429_ = NULL;
				ValaCCodeIdentifier* _tmp430_ = NULL;
				ValaCCodeFunctionCall* _tmp431_ = NULL;
				ValaCCodeFunctionCall* _tmp432_ = NULL;
				_tmp396_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
				_tmp397_ = _tmp396_;
				_tmp398_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp397_, NULL);
				class_prefix = _tmp398_;
				_tmp399_ = vala_ccode_declaration_new ("const GSourceFuncs");
				funcs = _tmp399_;
				_tmp400_ = funcs;
				vala_ccode_declaration_set_modifiers (_tmp400_, VALA_CCODE_MODIFIERS_STATIC);
				_tmp401_ = funcs;
				_tmp402_ = class_prefix;
				_tmp403_ = class_prefix;
				_tmp404_ = class_prefix;
				_tmp405_ = class_prefix;
				_tmp406_ = g_strdup_printf ("{ %s_real_prepare, %s_real_check, %s_real_dispatch, %s_finalize}", _tmp402_, _tmp403_, _tmp404_, _tmp405_);
				_tmp407_ = _tmp406_;
				_tmp408_ = vala_ccode_constant_new (_tmp407_);
				_tmp409_ = _tmp408_;
				_tmp410_ = vala_ccode_variable_declarator_new ("_source_funcs", (ValaCCodeExpression*) _tmp409_, NULL);
				_tmp411_ = _tmp410_;
				vala_ccode_declaration_add_declarator (_tmp401_, (ValaCCodeDeclarator*) _tmp411_);
				_vala_ccode_node_unref0 (_tmp411_);
				_vala_ccode_node_unref0 (_tmp409_);
				_g_free0 (_tmp407_);
				_tmp412_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp413_ = _tmp412_;
				_tmp414_ = funcs;
				vala_ccode_function_add_statement (_tmp413_, (ValaCCodeNode*) _tmp414_);
				_tmp415_ = ccall;
				_tmp416_ = vala_ccode_identifier_new ("_source_funcs");
				_tmp417_ = _tmp416_;
				_tmp418_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp417_);
				_tmp419_ = _tmp418_;
				vala_ccode_function_call_add_argument (_tmp415_, (ValaCCodeExpression*) _tmp419_);
				_vala_ccode_node_unref0 (_tmp419_);
				_vala_ccode_node_unref0 (_tmp417_);
				_tmp420_ = vala_ccode_identifier_new ("sizeof");
				_tmp421_ = _tmp420_;
				_tmp422_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp421_);
				_tmp423_ = _tmp422_;
				_vala_ccode_node_unref0 (_tmp421_);
				csizeof = _tmp423_;
				_tmp424_ = csizeof;
				_tmp425_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
				_tmp426_ = _tmp425_;
				_tmp427_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp426_);
				_tmp428_ = _tmp427_;
				_tmp429_ = vala_ccode_identifier_new (_tmp428_);
				_tmp430_ = _tmp429_;
				vala_ccode_function_call_add_argument (_tmp424_, (ValaCCodeExpression*) _tmp430_);
				_vala_ccode_node_unref0 (_tmp430_);
				_g_free0 (_tmp428_);
				_tmp431_ = ccall;
				_tmp432_ = csizeof;
				vala_ccode_function_call_add_argument (_tmp431_, (ValaCCodeExpression*) _tmp432_);
				_vala_ccode_node_unref0 (csizeof);
				_vala_ccode_node_unref0 (funcs);
				_g_free0 (class_prefix);
			}
		}
	} else {
		gboolean _tmp433_ = FALSE;
		ValaMethod* _tmp434_ = NULL;
		_tmp434_ = m;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp434_, VALA_TYPE_CREATION_METHOD)) {
			ValaMethod* _tmp435_ = NULL;
			ValaSymbol* _tmp436_ = NULL;
			ValaSymbol* _tmp437_ = NULL;
			_tmp435_ = m;
			_tmp436_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp435_);
			_tmp437_ = _tmp436_;
			_tmp433_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp437_, VALA_TYPE_STRUCT);
		} else {
			_tmp433_ = FALSE;
		}
		if (_tmp433_) {
			ValaCCodeFunctionCall* _tmp438_ = NULL;
			ValaCCodeExpression* _tmp439_ = NULL;
			ValaCCodeExpression* _tmp440_ = NULL;
			_tmp438_ = ccall;
			_tmp439_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self);
			_tmp440_ = _tmp439_;
			vala_ccode_function_call_add_argument (_tmp438_, _tmp440_);
			_vala_ccode_node_unref0 (_tmp440_);
		} else {
			gboolean _tmp441_ = FALSE;
			gboolean _tmp442_ = FALSE;
			gboolean _tmp443_ = FALSE;
			gboolean _tmp444_ = FALSE;
			ValaMethod* _tmp445_ = NULL;
			_tmp445_ = m;
			if (_tmp445_ != NULL) {
				ValaMethod* _tmp446_ = NULL;
				ValaList* _tmp447_ = NULL;
				ValaList* _tmp448_ = NULL;
				gint _tmp449_ = 0;
				gint _tmp450_ = 0;
				_tmp446_ = m;
				_tmp447_ = vala_method_get_type_parameters (_tmp446_);
				_tmp448_ = _tmp447_;
				_tmp449_ = vala_collection_get_size ((ValaCollection*) _tmp448_);
				_tmp450_ = _tmp449_;
				_tmp444_ = _tmp450_ > 0;
				_vala_iterable_unref0 (_tmp448_);
			} else {
				_tmp444_ = FALSE;
			}
			if (_tmp444_) {
				ValaMethod* _tmp451_ = NULL;
				gboolean _tmp452_ = FALSE;
				_tmp451_ = m;
				_tmp452_ = vala_ccode_base_module_get_ccode_has_generic_type_parameter (_tmp451_);
				_tmp443_ = !_tmp452_;
			} else {
				_tmp443_ = FALSE;
			}
			if (_tmp443_) {
				ValaMethod* _tmp453_ = NULL;
				gboolean _tmp454_ = FALSE;
				_tmp453_ = m;
				_tmp454_ = vala_ccode_base_module_get_ccode_simple_generics (_tmp453_);
				_tmp442_ = !_tmp454_;
			} else {
				_tmp442_ = FALSE;
			}
			if (_tmp442_) {
				gboolean _tmp455_ = FALSE;
				ValaCCodeFunctionCall* _tmp456_ = NULL;
				ValaCCodeFunctionCall* _tmp457_ = NULL;
				_tmp456_ = ccall;
				_tmp457_ = finish_call;
				if (_tmp456_ != _tmp457_) {
					_tmp455_ = TRUE;
				} else {
					ValaMethodCall* _tmp458_ = NULL;
					gboolean _tmp459_ = FALSE;
					gboolean _tmp460_ = FALSE;
					_tmp458_ = expr;
					_tmp459_ = vala_method_call_get_is_yield_expression (_tmp458_);
					_tmp460_ = _tmp459_;
					_tmp455_ = _tmp460_;
				}
				_tmp441_ = _tmp455_;
			} else {
				_tmp441_ = FALSE;
			}
			if (_tmp441_) {
				ValaHashMap* _tmp461_ = NULL;
				ValaMemberAccess* _tmp462_ = NULL;
				ValaList* _tmp463_ = NULL;
				ValaList* _tmp464_ = NULL;
				ValaMethodCall* _tmp465_ = NULL;
				_tmp461_ = in_arg_map;
				_tmp462_ = ma;
				_tmp463_ = vala_member_access_get_type_arguments (_tmp462_);
				_tmp464_ = _tmp463_;
				_tmp465_ = expr;
				vala_ccode_base_module_add_generic_type_arguments ((ValaCCodeBaseModule*) self, (ValaMap*) _tmp461_, _tmp464_, (ValaCodeNode*) _tmp465_, FALSE, NULL);
				_vala_iterable_unref0 (_tmp464_);
			}
		}
	}
	_tmp466_ = ccall;
	_tmp467_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp466_);
	ccall_expr = _tmp467_;
	_tmp468_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp468_, VALA_TYPE_ARRAY_RESIZE_METHOD)) {
		ValaArrayType* array_type = NULL;
		ValaMemberAccess* _tmp469_ = NULL;
		ValaExpression* _tmp470_ = NULL;
		ValaExpression* _tmp471_ = NULL;
		ValaDataType* _tmp472_ = NULL;
		ValaDataType* _tmp473_ = NULL;
		ValaArrayType* _tmp474_ = NULL;
		ValaHashMap* _tmp475_ = NULL;
		gint _tmp476_ = 0;
		ValaArrayType* _tmp477_ = NULL;
		ValaDataType* _tmp478_ = NULL;
		ValaDataType* _tmp479_ = NULL;
		gchar* _tmp480_ = NULL;
		gchar* _tmp481_ = NULL;
		ValaCCodeIdentifier* _tmp482_ = NULL;
		ValaCCodeIdentifier* _tmp483_ = NULL;
		_tmp469_ = ma;
		_tmp470_ = vala_member_access_get_inner (_tmp469_);
		_tmp471_ = _tmp470_;
		_tmp472_ = vala_expression_get_value_type (_tmp471_);
		_tmp473_ = _tmp472_;
		_tmp474_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp473_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		array_type = _tmp474_;
		_tmp475_ = in_arg_map;
		_tmp476_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) 0, FALSE);
		_tmp477_ = array_type;
		_tmp478_ = vala_array_type_get_element_type (_tmp477_);
		_tmp479_ = _tmp478_;
		_tmp480_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp479_);
		_tmp481_ = _tmp480_;
		_tmp482_ = vala_ccode_identifier_new (_tmp481_);
		_tmp483_ = _tmp482_;
		vala_map_set ((ValaMap*) _tmp475_, (gpointer) ((gintptr) _tmp476_), (ValaCCodeExpression*) _tmp483_);
		_vala_ccode_node_unref0 (_tmp483_);
		_g_free0 (_tmp481_);
		_vala_code_node_unref0 (array_type);
	} else {
		ValaMethod* _tmp484_ = NULL;
		_tmp484_ = m;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp484_, VALA_TYPE_ARRAY_MOVE_METHOD)) {
			((ValaCCodeBaseModule*) self)->requires_array_move = TRUE;
		}
	}
	instance = NULL;
	_tmp486_ = m;
	if (_tmp486_ != NULL) {
		ValaMethod* _tmp487_ = NULL;
		gboolean _tmp488_ = FALSE;
		gboolean _tmp489_ = FALSE;
		_tmp487_ = m;
		_tmp488_ = vala_method_get_is_async_callback (_tmp487_);
		_tmp489_ = _tmp488_;
		_tmp485_ = _tmp489_;
	} else {
		_tmp485_ = FALSE;
	}
	if (_tmp485_) {
		ValaMethod* _tmp490_ = NULL;
		ValaMethod* _tmp491_ = NULL;
		gboolean _tmp492_ = FALSE;
		gboolean _tmp493_ = FALSE;
		ValaHashMap* _tmp508_ = NULL;
		ValaMethod* _tmp509_ = NULL;
		gdouble _tmp510_ = 0.0;
		gint _tmp511_ = 0;
		ValaCCodeExpression* _tmp512_ = NULL;
		ValaHashMap* _tmp513_ = NULL;
		ValaMethod* _tmp514_ = NULL;
		gdouble _tmp515_ = 0.0;
		gint _tmp516_ = 0;
		ValaCCodeExpression* _tmp517_ = NULL;
		_tmp490_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
		_tmp491_ = _tmp490_;
		_tmp492_ = vala_method_get_closure (_tmp491_);
		_tmp493_ = _tmp492_;
		if (_tmp493_) {
			ValaBlock* block = NULL;
			ValaMethod* _tmp494_ = NULL;
			ValaSymbol* _tmp495_ = NULL;
			ValaSymbol* _tmp496_ = NULL;
			ValaBlock* _tmp497_ = NULL;
			ValaBlock* _tmp498_ = NULL;
			ValaBlock* _tmp499_ = NULL;
			ValaBlock* _tmp500_ = NULL;
			gint _tmp501_ = 0;
			gchar* _tmp502_ = NULL;
			gchar* _tmp503_ = NULL;
			ValaCCodeExpression* _tmp504_ = NULL;
			ValaCCodeExpression* _tmp505_ = NULL;
			ValaCCodeMemberAccess* _tmp506_ = NULL;
			_tmp494_ = m;
			_tmp495_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp494_);
			_tmp496_ = _tmp495_;
			_tmp497_ = vala_subroutine_get_body ((ValaSubroutine*) G_TYPE_CHECK_INSTANCE_CAST (_tmp496_, VALA_TYPE_METHOD, ValaMethod));
			_tmp498_ = _tmp497_;
			_tmp499_ = _vala_code_node_ref0 (_tmp498_);
			block = _tmp499_;
			_tmp500_ = block;
			_tmp501_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp500_);
			_tmp502_ = g_strdup_printf ("_data%d_", _tmp501_);
			_tmp503_ = _tmp502_;
			_tmp504_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp503_);
			_tmp505_ = _tmp504_;
			_tmp506_ = vala_ccode_member_access_new_pointer (_tmp505_, "_async_data_");
			_vala_ccode_node_unref0 (instance);
			instance = (ValaCCodeExpression*) _tmp506_;
			_vala_ccode_node_unref0 (_tmp505_);
			_g_free0 (_tmp503_);
			_vala_code_node_unref0 (block);
		} else {
			ValaCCodeIdentifier* _tmp507_ = NULL;
			_tmp507_ = vala_ccode_identifier_new ("_data_");
			_vala_ccode_node_unref0 (instance);
			instance = (ValaCCodeExpression*) _tmp507_;
		}
		_tmp508_ = in_arg_map;
		_tmp509_ = m;
		_tmp510_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp509_);
		_tmp511_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp510_, FALSE);
		_tmp512_ = instance;
		vala_map_set ((ValaMap*) _tmp508_, (gpointer) ((gintptr) _tmp511_), _tmp512_);
		_tmp513_ = out_arg_map;
		_tmp514_ = m;
		_tmp515_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp514_);
		_tmp516_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp515_, FALSE);
		_tmp517_ = instance;
		vala_map_set ((ValaMap*) _tmp513_, (gpointer) ((gintptr) _tmp516_), _tmp517_);
	} else {
		gboolean _tmp518_ = FALSE;
		gboolean _tmp519_ = FALSE;
		ValaMethod* _tmp520_ = NULL;
		_tmp520_ = m;
		if (_tmp520_ != NULL) {
			ValaMethod* _tmp521_ = NULL;
			ValaMemberBinding _tmp522_ = 0;
			ValaMemberBinding _tmp523_ = 0;
			_tmp521_ = m;
			_tmp522_ = vala_method_get_binding (_tmp521_);
			_tmp523_ = _tmp522_;
			_tmp519_ = _tmp523_ == VALA_MEMBER_BINDING_INSTANCE;
		} else {
			_tmp519_ = FALSE;
		}
		if (_tmp519_) {
			ValaMethod* _tmp524_ = NULL;
			_tmp524_ = m;
			_tmp518_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp524_, VALA_TYPE_CREATION_METHOD);
		} else {
			_tmp518_ = FALSE;
		}
		if (_tmp518_) {
			ValaTargetValue* instance_value = NULL;
			ValaMemberAccess* _tmp525_ = NULL;
			ValaExpression* _tmp526_ = NULL;
			ValaExpression* _tmp527_ = NULL;
			ValaTargetValue* _tmp528_ = NULL;
			ValaTargetValue* _tmp529_ = NULL;
			ValaTargetValue* _tmp530_ = NULL;
			gboolean _tmp531_ = FALSE;
			gboolean _tmp532_ = FALSE;
			ValaMemberAccess* _tmp533_ = NULL;
			const gchar* _tmp534_ = NULL;
			const gchar* _tmp535_ = NULL;
			ValaTargetValue* _tmp557_ = NULL;
			ValaCCodeExpression* _tmp558_ = NULL;
			ValaStruct* st = NULL;
			ValaMethod* _tmp559_ = NULL;
			ValaSymbol* _tmp560_ = NULL;
			ValaSymbol* _tmp561_ = NULL;
			ValaStruct* _tmp562_ = NULL;
			gboolean _tmp563_ = FALSE;
			ValaStruct* _tmp564_ = NULL;
			ValaHashMap* _tmp576_ = NULL;
			ValaMethod* _tmp577_ = NULL;
			gdouble _tmp578_ = 0.0;
			gint _tmp579_ = 0;
			ValaCCodeExpression* _tmp580_ = NULL;
			ValaHashMap* _tmp581_ = NULL;
			ValaMethod* _tmp582_ = NULL;
			gdouble _tmp583_ = 0.0;
			gint _tmp584_ = 0;
			ValaCCodeExpression* _tmp585_ = NULL;
			_tmp525_ = ma;
			_tmp526_ = vala_member_access_get_inner (_tmp525_);
			_tmp527_ = _tmp526_;
			_tmp528_ = vala_expression_get_target_value (_tmp527_);
			_tmp529_ = _tmp528_;
			_tmp530_ = _vala_target_value_ref0 (_tmp529_);
			instance_value = _tmp530_;
			_tmp533_ = ma;
			_tmp534_ = vala_member_access_get_member_name (_tmp533_);
			_tmp535_ = _tmp534_;
			if (g_strcmp0 (_tmp535_, "begin") == 0) {
				_tmp532_ = TRUE;
			} else {
				ValaMemberAccess* _tmp536_ = NULL;
				const gchar* _tmp537_ = NULL;
				const gchar* _tmp538_ = NULL;
				_tmp536_ = ma;
				_tmp537_ = vala_member_access_get_member_name (_tmp536_);
				_tmp538_ = _tmp537_;
				_tmp532_ = g_strcmp0 (_tmp538_, "end") == 0;
			}
			if (_tmp532_) {
				ValaMemberAccess* _tmp539_ = NULL;
				ValaExpression* _tmp540_ = NULL;
				ValaExpression* _tmp541_ = NULL;
				ValaSymbol* _tmp542_ = NULL;
				ValaSymbol* _tmp543_ = NULL;
				ValaMemberAccess* _tmp544_ = NULL;
				ValaSymbol* _tmp545_ = NULL;
				ValaSymbol* _tmp546_ = NULL;
				_tmp539_ = ma;
				_tmp540_ = vala_member_access_get_inner (_tmp539_);
				_tmp541_ = _tmp540_;
				_tmp542_ = vala_expression_get_symbol_reference (_tmp541_);
				_tmp543_ = _tmp542_;
				_tmp544_ = ma;
				_tmp545_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp544_);
				_tmp546_ = _tmp545_;
				_tmp531_ = _tmp543_ == _tmp546_;
			} else {
				_tmp531_ = FALSE;
			}
			if (_tmp531_) {
				ValaMemberAccess* inner_ma = NULL;
				ValaMemberAccess* _tmp547_ = NULL;
				ValaExpression* _tmp548_ = NULL;
				ValaExpression* _tmp549_ = NULL;
				ValaMemberAccess* _tmp550_ = NULL;
				ValaMemberAccess* _tmp551_ = NULL;
				ValaExpression* _tmp552_ = NULL;
				ValaExpression* _tmp553_ = NULL;
				ValaTargetValue* _tmp554_ = NULL;
				ValaTargetValue* _tmp555_ = NULL;
				ValaTargetValue* _tmp556_ = NULL;
				_tmp547_ = ma;
				_tmp548_ = vala_member_access_get_inner (_tmp547_);
				_tmp549_ = _tmp548_;
				_tmp550_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp549_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
				inner_ma = _tmp550_;
				_tmp551_ = inner_ma;
				_tmp552_ = vala_member_access_get_inner (_tmp551_);
				_tmp553_ = _tmp552_;
				_tmp554_ = vala_expression_get_target_value (_tmp553_);
				_tmp555_ = _tmp554_;
				_tmp556_ = _vala_target_value_ref0 (_tmp555_);
				_vala_target_value_unref0 (instance_value);
				instance_value = _tmp556_;
				_vala_code_node_unref0 (inner_ma);
			}
			_tmp557_ = instance_value;
			_tmp558_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp557_);
			_vala_ccode_node_unref0 (instance);
			instance = _tmp558_;
			_tmp559_ = m;
			_tmp560_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp559_);
			_tmp561_ = _tmp560_;
			_tmp562_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp561_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp561_) : NULL);
			st = _tmp562_;
			_tmp564_ = st;
			if (_tmp564_ != NULL) {
				ValaStruct* _tmp565_ = NULL;
				gboolean _tmp566_ = FALSE;
				_tmp565_ = st;
				_tmp566_ = vala_struct_is_simple_type (_tmp565_);
				_tmp563_ = !_tmp566_;
			} else {
				_tmp563_ = FALSE;
			}
			if (_tmp563_) {
				ValaTargetValue* _tmp567_ = NULL;
				gboolean _tmp568_ = FALSE;
				ValaTargetValue* _tmp572_ = NULL;
				ValaCCodeExpression* _tmp573_ = NULL;
				ValaCCodeExpression* _tmp574_ = NULL;
				ValaCCodeUnaryExpression* _tmp575_ = NULL;
				_tmp567_ = instance_value;
				_tmp568_ = vala_ccode_base_module_get_lvalue ((ValaCCodeBaseModule*) self, _tmp567_);
				if (!_tmp568_) {
					ValaTargetValue* _tmp569_ = NULL;
					ValaMethodCall* _tmp570_ = NULL;
					ValaTargetValue* _tmp571_ = NULL;
					_tmp569_ = instance_value;
					_tmp570_ = expr;
					_tmp571_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, _tmp569_, (ValaCodeNode*) _tmp570_, NULL);
					_vala_target_value_unref0 (instance_value);
					instance_value = _tmp571_;
				}
				_tmp572_ = instance_value;
				_tmp573_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp572_);
				_tmp574_ = _tmp573_;
				_tmp575_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp574_);
				_vala_ccode_node_unref0 (instance);
				instance = (ValaCCodeExpression*) _tmp575_;
				_vala_ccode_node_unref0 (_tmp574_);
			}
			_tmp576_ = in_arg_map;
			_tmp577_ = m;
			_tmp578_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp577_);
			_tmp579_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp578_, FALSE);
			_tmp580_ = instance;
			vala_map_set ((ValaMap*) _tmp576_, (gpointer) ((gintptr) _tmp579_), _tmp580_);
			_tmp581_ = out_arg_map;
			_tmp582_ = m;
			_tmp583_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp582_);
			_tmp584_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp583_, FALSE);
			_tmp585_ = instance;
			vala_map_set ((ValaMap*) _tmp581_, (gpointer) ((gintptr) _tmp584_), _tmp585_);
			_vala_code_node_unref0 (st);
			_vala_target_value_unref0 (instance_value);
		} else {
			gboolean _tmp586_ = FALSE;
			ValaMethod* _tmp587_ = NULL;
			_tmp587_ = m;
			if (_tmp587_ != NULL) {
				ValaMethod* _tmp588_ = NULL;
				ValaMemberBinding _tmp589_ = 0;
				ValaMemberBinding _tmp590_ = 0;
				_tmp588_ = m;
				_tmp589_ = vala_method_get_binding (_tmp588_);
				_tmp590_ = _tmp589_;
				_tmp586_ = _tmp590_ == VALA_MEMBER_BINDING_CLASS;
			} else {
				_tmp586_ = FALSE;
			}
			if (_tmp586_) {
				ValaClass* cl = NULL;
				ValaMethod* _tmp591_ = NULL;
				ValaSymbol* _tmp592_ = NULL;
				ValaSymbol* _tmp593_ = NULL;
				ValaClass* _tmp594_ = NULL;
				ValaCCodeFunctionCall* cast = NULL;
				ValaClass* _tmp595_ = NULL;
				gchar* _tmp596_ = NULL;
				gchar* _tmp597_ = NULL;
				gchar* _tmp598_ = NULL;
				gchar* _tmp599_ = NULL;
				ValaCCodeIdentifier* _tmp600_ = NULL;
				ValaCCodeIdentifier* _tmp601_ = NULL;
				ValaCCodeFunctionCall* _tmp602_ = NULL;
				ValaCCodeFunctionCall* _tmp603_ = NULL;
				ValaCCodeExpression* klass = NULL;
				ValaMemberAccess* _tmp604_ = NULL;
				ValaExpression* _tmp605_ = NULL;
				ValaExpression* _tmp606_ = NULL;
				ValaCCodeFunctionCall* _tmp632_ = NULL;
				ValaCCodeExpression* _tmp633_ = NULL;
				ValaHashMap* _tmp634_ = NULL;
				ValaMethod* _tmp635_ = NULL;
				gdouble _tmp636_ = 0.0;
				gint _tmp637_ = 0;
				ValaCCodeFunctionCall* _tmp638_ = NULL;
				ValaHashMap* _tmp639_ = NULL;
				ValaMethod* _tmp640_ = NULL;
				gdouble _tmp641_ = 0.0;
				gint _tmp642_ = 0;
				ValaCCodeFunctionCall* _tmp643_ = NULL;
				_tmp591_ = m;
				_tmp592_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp591_);
				_tmp593_ = _tmp592_;
				_tmp594_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp593_, VALA_TYPE_CLASS, ValaClass));
				cl = _tmp594_;
				_tmp595_ = cl;
				_tmp596_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp595_, NULL);
				_tmp597_ = _tmp596_;
				_tmp598_ = g_strconcat (_tmp597_, "_CLASS", NULL);
				_tmp599_ = _tmp598_;
				_tmp600_ = vala_ccode_identifier_new (_tmp599_);
				_tmp601_ = _tmp600_;
				_tmp602_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp601_);
				_tmp603_ = _tmp602_;
				_vala_ccode_node_unref0 (_tmp601_);
				_g_free0 (_tmp599_);
				_g_free0 (_tmp597_);
				cast = _tmp603_;
				_tmp604_ = ma;
				_tmp605_ = vala_member_access_get_inner (_tmp604_);
				_tmp606_ = _tmp605_;
				if (_tmp606_ == NULL) {
					ValaDataType* _tmp607_ = NULL;
					ValaDataType* _tmp608_ = NULL;
					gboolean _tmp609_ = FALSE;
					_tmp607_ = vala_ccode_base_module_get_this_type ((ValaCCodeBaseModule*) self);
					_tmp608_ = _tmp607_;
					_tmp609_ = _tmp608_ == NULL;
					_vala_code_node_unref0 (_tmp608_);
					if (_tmp609_) {
						ValaCCodeIdentifier* _tmp610_ = NULL;
						_tmp610_ = vala_ccode_identifier_new ("klass");
						_vala_ccode_node_unref0 (klass);
						klass = (ValaCCodeExpression*) _tmp610_;
					} else {
						ValaCCodeFunctionCall* k = NULL;
						ValaCCodeIdentifier* _tmp611_ = NULL;
						ValaCCodeIdentifier* _tmp612_ = NULL;
						ValaCCodeFunctionCall* _tmp613_ = NULL;
						ValaCCodeFunctionCall* _tmp614_ = NULL;
						ValaCCodeFunctionCall* _tmp615_ = NULL;
						ValaCCodeExpression* _tmp616_ = NULL;
						ValaCCodeExpression* _tmp617_ = NULL;
						ValaCCodeFunctionCall* _tmp618_ = NULL;
						ValaCCodeExpression* _tmp619_ = NULL;
						_tmp611_ = vala_ccode_identifier_new ("G_OBJECT_GET_CLASS");
						_tmp612_ = _tmp611_;
						_tmp613_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp612_);
						_tmp614_ = _tmp613_;
						_vala_ccode_node_unref0 (_tmp612_);
						k = _tmp614_;
						_tmp615_ = k;
						_tmp616_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self);
						_tmp617_ = _tmp616_;
						vala_ccode_function_call_add_argument (_tmp615_, _tmp617_);
						_vala_ccode_node_unref0 (_tmp617_);
						_tmp618_ = k;
						_tmp619_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp618_);
						_vala_ccode_node_unref0 (klass);
						klass = _tmp619_;
						_vala_ccode_node_unref0 (k);
					}
				} else {
					ValaCCodeFunctionCall* k = NULL;
					ValaCCodeIdentifier* _tmp620_ = NULL;
					ValaCCodeIdentifier* _tmp621_ = NULL;
					ValaCCodeFunctionCall* _tmp622_ = NULL;
					ValaCCodeFunctionCall* _tmp623_ = NULL;
					ValaCCodeFunctionCall* _tmp624_ = NULL;
					ValaMemberAccess* _tmp625_ = NULL;
					ValaExpression* _tmp626_ = NULL;
					ValaExpression* _tmp627_ = NULL;
					ValaCCodeExpression* _tmp628_ = NULL;
					ValaCCodeExpression* _tmp629_ = NULL;
					ValaCCodeFunctionCall* _tmp630_ = NULL;
					ValaCCodeExpression* _tmp631_ = NULL;
					_tmp620_ = vala_ccode_identifier_new ("G_OBJECT_GET_CLASS");
					_tmp621_ = _tmp620_;
					_tmp622_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp621_);
					_tmp623_ = _tmp622_;
					_vala_ccode_node_unref0 (_tmp621_);
					k = _tmp623_;
					_tmp624_ = k;
					_tmp625_ = ma;
					_tmp626_ = vala_member_access_get_inner (_tmp625_);
					_tmp627_ = _tmp626_;
					_tmp628_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp627_);
					_tmp629_ = _tmp628_;
					vala_ccode_function_call_add_argument (_tmp624_, _tmp629_);
					_vala_ccode_node_unref0 (_tmp629_);
					_tmp630_ = k;
					_tmp631_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp630_);
					_vala_ccode_node_unref0 (klass);
					klass = _tmp631_;
					_vala_ccode_node_unref0 (k);
				}
				_tmp632_ = cast;
				_tmp633_ = klass;
				vala_ccode_function_call_add_argument (_tmp632_, _tmp633_);
				_tmp634_ = in_arg_map;
				_tmp635_ = m;
				_tmp636_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp635_);
				_tmp637_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp636_, FALSE);
				_tmp638_ = cast;
				vala_map_set ((ValaMap*) _tmp634_, (gpointer) ((gintptr) _tmp637_), (ValaCCodeExpression*) _tmp638_);
				_tmp639_ = out_arg_map;
				_tmp640_ = m;
				_tmp641_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp640_);
				_tmp642_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp641_, FALSE);
				_tmp643_ = cast;
				vala_map_set ((ValaMap*) _tmp639_, (gpointer) ((gintptr) _tmp642_), (ValaCCodeExpression*) _tmp643_);
				_vala_ccode_node_unref0 (klass);
				_vala_ccode_node_unref0 (cast);
				_vala_code_node_unref0 (cl);
			}
		}
	}
	_tmp645_ = m;
	if (_tmp645_ != NULL) {
		ValaMethod* _tmp646_ = NULL;
		gboolean _tmp647_ = FALSE;
		_tmp646_ = m;
		_tmp647_ = vala_ccode_base_module_get_ccode_has_generic_type_parameter (_tmp646_);
		_tmp644_ = _tmp647_;
	} else {
		_tmp644_ = FALSE;
	}
	if (_tmp644_) {
		ValaMethod* _tmp648_ = NULL;
		ValaList* _tmp649_ = NULL;
		ValaList* _tmp650_ = NULL;
		gint _tmp651_ = 0;
		gint _tmp652_ = 0;
		gboolean _tmp653_ = FALSE;
		_tmp648_ = m;
		_tmp649_ = vala_method_get_type_parameters (_tmp648_);
		_tmp650_ = _tmp649_;
		_tmp651_ = vala_collection_get_size ((ValaCollection*) _tmp650_);
		_tmp652_ = _tmp651_;
		_tmp653_ = _tmp652_ > 0;
		_vala_iterable_unref0 (_tmp650_);
		if (_tmp653_) {
			gint type_param_index = 0;
			type_param_index = 0;
			{
				ValaList* _type_arg_list = NULL;
				ValaMemberAccess* _tmp654_ = NULL;
				ValaList* _tmp655_ = NULL;
				gint _type_arg_size = 0;
				ValaList* _tmp656_ = NULL;
				gint _tmp657_ = 0;
				gint _tmp658_ = 0;
				gint _type_arg_index = 0;
				_tmp654_ = ma;
				_tmp655_ = vala_member_access_get_type_arguments (_tmp654_);
				_type_arg_list = _tmp655_;
				_tmp656_ = _type_arg_list;
				_tmp657_ = vala_collection_get_size ((ValaCollection*) _tmp656_);
				_tmp658_ = _tmp657_;
				_type_arg_size = _tmp658_;
				_type_arg_index = -1;
				while (TRUE) {
					gint _tmp659_ = 0;
					gint _tmp660_ = 0;
					gint _tmp661_ = 0;
					ValaDataType* type_arg = NULL;
					ValaList* _tmp662_ = NULL;
					gint _tmp663_ = 0;
					gpointer _tmp664_ = NULL;
					ValaHashMap* _tmp665_ = NULL;
					ValaMethod* _tmp666_ = NULL;
					gdouble _tmp667_ = 0.0;
					gint _tmp668_ = 0;
					gint _tmp669_ = 0;
					ValaDataType* _tmp670_ = NULL;
					gchar* _tmp671_ = NULL;
					gchar* _tmp672_ = NULL;
					ValaCCodeIdentifier* _tmp673_ = NULL;
					ValaCCodeIdentifier* _tmp674_ = NULL;
					gint _tmp675_ = 0;
					_tmp659_ = _type_arg_index;
					_type_arg_index = _tmp659_ + 1;
					_tmp660_ = _type_arg_index;
					_tmp661_ = _type_arg_size;
					if (!(_tmp660_ < _tmp661_)) {
						break;
					}
					_tmp662_ = _type_arg_list;
					_tmp663_ = _type_arg_index;
					_tmp664_ = vala_list_get (_tmp662_, _tmp663_);
					type_arg = (ValaDataType*) _tmp664_;
					_tmp665_ = in_arg_map;
					_tmp666_ = m;
					_tmp667_ = vala_ccode_base_module_get_ccode_generic_type_pos (_tmp666_);
					_tmp668_ = type_param_index;
					_tmp669_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp667_ + (0.01 * _tmp668_), FALSE);
					_tmp670_ = type_arg;
					_tmp671_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp670_);
					_tmp672_ = _tmp671_;
					_tmp673_ = vala_ccode_identifier_new (_tmp672_);
					_tmp674_ = _tmp673_;
					vala_map_set ((ValaMap*) _tmp665_, (gpointer) ((gintptr) _tmp669_), (ValaCCodeExpression*) _tmp674_);
					_vala_ccode_node_unref0 (_tmp674_);
					_g_free0 (_tmp672_);
					_tmp675_ = type_param_index;
					type_param_index = _tmp675_ + 1;
					_vala_code_node_unref0 (type_arg);
				}
				_vala_iterable_unref0 (_type_arg_list);
			}
		} else {
			gint type_param_index = 0;
			type_param_index = 0;
			{
				ValaList* _type_arg_list = NULL;
				ValaMemberAccess* _tmp676_ = NULL;
				ValaExpression* _tmp677_ = NULL;
				ValaExpression* _tmp678_ = NULL;
				ValaDataType* _tmp679_ = NULL;
				ValaDataType* _tmp680_ = NULL;
				ValaList* _tmp681_ = NULL;
				gint _type_arg_size = 0;
				ValaList* _tmp682_ = NULL;
				gint _tmp683_ = 0;
				gint _tmp684_ = 0;
				gint _type_arg_index = 0;
				_tmp676_ = ma;
				_tmp677_ = vala_member_access_get_inner (_tmp676_);
				_tmp678_ = _tmp677_;
				_tmp679_ = vala_expression_get_value_type (_tmp678_);
				_tmp680_ = _tmp679_;
				_tmp681_ = vala_data_type_get_type_arguments (_tmp680_);
				_type_arg_list = _tmp681_;
				_tmp682_ = _type_arg_list;
				_tmp683_ = vala_collection_get_size ((ValaCollection*) _tmp682_);
				_tmp684_ = _tmp683_;
				_type_arg_size = _tmp684_;
				_type_arg_index = -1;
				while (TRUE) {
					gint _tmp685_ = 0;
					gint _tmp686_ = 0;
					gint _tmp687_ = 0;
					ValaDataType* type_arg = NULL;
					ValaList* _tmp688_ = NULL;
					gint _tmp689_ = 0;
					gpointer _tmp690_ = NULL;
					ValaHashMap* _tmp691_ = NULL;
					ValaMethod* _tmp692_ = NULL;
					gdouble _tmp693_ = 0.0;
					gint _tmp694_ = 0;
					gint _tmp695_ = 0;
					ValaDataType* _tmp696_ = NULL;
					gchar* _tmp697_ = NULL;
					gchar* _tmp698_ = NULL;
					ValaCCodeIdentifier* _tmp699_ = NULL;
					ValaCCodeIdentifier* _tmp700_ = NULL;
					gint _tmp701_ = 0;
					_tmp685_ = _type_arg_index;
					_type_arg_index = _tmp685_ + 1;
					_tmp686_ = _type_arg_index;
					_tmp687_ = _type_arg_size;
					if (!(_tmp686_ < _tmp687_)) {
						break;
					}
					_tmp688_ = _type_arg_list;
					_tmp689_ = _type_arg_index;
					_tmp690_ = vala_list_get (_tmp688_, _tmp689_);
					type_arg = (ValaDataType*) _tmp690_;
					_tmp691_ = in_arg_map;
					_tmp692_ = m;
					_tmp693_ = vala_ccode_base_module_get_ccode_generic_type_pos (_tmp692_);
					_tmp694_ = type_param_index;
					_tmp695_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp693_ + (0.01 * _tmp694_), FALSE);
					_tmp696_ = type_arg;
					_tmp697_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp696_);
					_tmp698_ = _tmp697_;
					_tmp699_ = vala_ccode_identifier_new (_tmp698_);
					_tmp700_ = _tmp699_;
					vala_map_set ((ValaMap*) _tmp691_, (gpointer) ((gintptr) _tmp695_), (ValaCCodeExpression*) _tmp700_);
					_vala_ccode_node_unref0 (_tmp700_);
					_g_free0 (_tmp698_);
					_tmp701_ = type_param_index;
					type_param_index = _tmp701_ + 1;
					_vala_code_node_unref0 (type_arg);
				}
				_vala_iterable_unref0 (_type_arg_list);
			}
		}
	}
	_tmp702_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp702_, VALA_TYPE_ARRAY_MOVE_METHOD)) {
		ValaArrayType* array_type = NULL;
		ValaMemberAccess* _tmp703_ = NULL;
		ValaExpression* _tmp704_ = NULL;
		ValaExpression* _tmp705_ = NULL;
		ValaDataType* _tmp706_ = NULL;
		ValaDataType* _tmp707_ = NULL;
		ValaArrayType* _tmp708_ = NULL;
		ValaCCodeFunctionCall* csizeof = NULL;
		ValaCCodeIdentifier* _tmp709_ = NULL;
		ValaCCodeIdentifier* _tmp710_ = NULL;
		ValaCCodeFunctionCall* _tmp711_ = NULL;
		ValaCCodeFunctionCall* _tmp712_ = NULL;
		ValaCCodeFunctionCall* _tmp713_ = NULL;
		ValaArrayType* _tmp714_ = NULL;
		ValaDataType* _tmp715_ = NULL;
		ValaDataType* _tmp716_ = NULL;
		gchar* _tmp717_ = NULL;
		gchar* _tmp718_ = NULL;
		ValaCCodeIdentifier* _tmp719_ = NULL;
		ValaCCodeIdentifier* _tmp720_ = NULL;
		ValaHashMap* _tmp721_ = NULL;
		gint _tmp722_ = 0;
		ValaCCodeFunctionCall* _tmp723_ = NULL;
		_tmp703_ = ma;
		_tmp704_ = vala_member_access_get_inner (_tmp703_);
		_tmp705_ = _tmp704_;
		_tmp706_ = vala_expression_get_value_type (_tmp705_);
		_tmp707_ = _tmp706_;
		_tmp708_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp707_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		array_type = _tmp708_;
		_tmp709_ = vala_ccode_identifier_new ("sizeof");
		_tmp710_ = _tmp709_;
		_tmp711_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp710_);
		_tmp712_ = _tmp711_;
		_vala_ccode_node_unref0 (_tmp710_);
		csizeof = _tmp712_;
		_tmp713_ = csizeof;
		_tmp714_ = array_type;
		_tmp715_ = vala_array_type_get_element_type (_tmp714_);
		_tmp716_ = _tmp715_;
		_tmp717_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp716_);
		_tmp718_ = _tmp717_;
		_tmp719_ = vala_ccode_identifier_new (_tmp718_);
		_tmp720_ = _tmp719_;
		vala_ccode_function_call_add_argument (_tmp713_, (ValaCCodeExpression*) _tmp720_);
		_vala_ccode_node_unref0 (_tmp720_);
		_g_free0 (_tmp718_);
		_tmp721_ = in_arg_map;
		_tmp722_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, 0.1, FALSE);
		_tmp723_ = csizeof;
		vala_map_set ((ValaMap*) _tmp721_, (gpointer) ((gintptr) _tmp722_), (ValaCCodeExpression*) _tmp723_);
		_vala_ccode_node_unref0 (csizeof);
		_vala_code_node_unref0 (array_type);
	} else {
		ValaMethod* _tmp724_ = NULL;
		_tmp724_ = m;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp724_, VALA_TYPE_DYNAMIC_METHOD)) {
			ValaMethod* _tmp725_ = NULL;
			gint param_nr = 0;
			ValaMethod* _tmp797_ = NULL;
			_tmp725_ = m;
			vala_method_clear_parameters (_tmp725_);
			param_nr = 1;
			{
				ValaList* _arg_list = NULL;
				ValaMethodCall* _tmp726_ = NULL;
				ValaList* _tmp727_ = NULL;
				gint _arg_size = 0;
				ValaList* _tmp728_ = NULL;
				gint _tmp729_ = 0;
				gint _tmp730_ = 0;
				gint _arg_index = 0;
				_tmp726_ = expr;
				_tmp727_ = vala_method_call_get_argument_list (_tmp726_);
				_arg_list = _tmp727_;
				_tmp728_ = _arg_list;
				_tmp729_ = vala_collection_get_size ((ValaCollection*) _tmp728_);
				_tmp730_ = _tmp729_;
				_arg_size = _tmp730_;
				_arg_index = -1;
				while (TRUE) {
					gint _tmp731_ = 0;
					gint _tmp732_ = 0;
					gint _tmp733_ = 0;
					ValaExpression* arg = NULL;
					ValaList* _tmp734_ = NULL;
					gint _tmp735_ = 0;
					gpointer _tmp736_ = NULL;
					ValaUnaryExpression* unary = NULL;
					ValaExpression* _tmp737_ = NULL;
					ValaUnaryExpression* _tmp738_ = NULL;
					gboolean _tmp739_ = FALSE;
					ValaUnaryExpression* _tmp740_ = NULL;
					gint _tmp784_ = 0;
					_tmp731_ = _arg_index;
					_arg_index = _tmp731_ + 1;
					_tmp732_ = _arg_index;
					_tmp733_ = _arg_size;
					if (!(_tmp732_ < _tmp733_)) {
						break;
					}
					_tmp734_ = _arg_list;
					_tmp735_ = _arg_index;
					_tmp736_ = vala_list_get (_tmp734_, _tmp735_);
					arg = (ValaExpression*) _tmp736_;
					_tmp737_ = arg;
					_tmp738_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp737_, VALA_TYPE_UNARY_EXPRESSION) ? ((ValaUnaryExpression*) _tmp737_) : NULL);
					unary = _tmp738_;
					_tmp740_ = unary;
					if (_tmp740_ != NULL) {
						ValaUnaryExpression* _tmp741_ = NULL;
						ValaUnaryOperator _tmp742_ = 0;
						ValaUnaryOperator _tmp743_ = 0;
						_tmp741_ = unary;
						_tmp742_ = vala_unary_expression_get_operator (_tmp741_);
						_tmp743_ = _tmp742_;
						_tmp739_ = _tmp743_ == VALA_UNARY_OPERATOR_OUT;
					} else {
						_tmp739_ = FALSE;
					}
					if (_tmp739_) {
						ValaParameter* param = NULL;
						gint _tmp744_ = 0;
						gchar* _tmp745_ = NULL;
						gchar* _tmp746_ = NULL;
						ValaUnaryExpression* _tmp747_ = NULL;
						ValaExpression* _tmp748_ = NULL;
						ValaExpression* _tmp749_ = NULL;
						ValaDataType* _tmp750_ = NULL;
						ValaDataType* _tmp751_ = NULL;
						ValaParameter* _tmp752_ = NULL;
						ValaParameter* _tmp753_ = NULL;
						ValaParameter* _tmp754_ = NULL;
						ValaMethod* _tmp755_ = NULL;
						ValaParameter* _tmp756_ = NULL;
						_tmp744_ = param_nr;
						_tmp745_ = g_strdup_printf ("param%d", _tmp744_);
						_tmp746_ = _tmp745_;
						_tmp747_ = unary;
						_tmp748_ = vala_unary_expression_get_inner (_tmp747_);
						_tmp749_ = _tmp748_;
						_tmp750_ = vala_expression_get_value_type (_tmp749_);
						_tmp751_ = _tmp750_;
						_tmp752_ = vala_parameter_new (_tmp746_, _tmp751_, NULL);
						_tmp753_ = _tmp752_;
						_g_free0 (_tmp746_);
						param = _tmp753_;
						_tmp754_ = param;
						vala_parameter_set_direction (_tmp754_, VALA_PARAMETER_DIRECTION_OUT);
						_tmp755_ = m;
						_tmp756_ = param;
						vala_method_add_parameter (_tmp755_, _tmp756_);
						_vala_code_node_unref0 (param);
					} else {
						gboolean _tmp757_ = FALSE;
						ValaUnaryExpression* _tmp758_ = NULL;
						_tmp758_ = unary;
						if (_tmp758_ != NULL) {
							ValaUnaryExpression* _tmp759_ = NULL;
							ValaUnaryOperator _tmp760_ = 0;
							ValaUnaryOperator _tmp761_ = 0;
							_tmp759_ = unary;
							_tmp760_ = vala_unary_expression_get_operator (_tmp759_);
							_tmp761_ = _tmp760_;
							_tmp757_ = _tmp761_ == VALA_UNARY_OPERATOR_REF;
						} else {
							_tmp757_ = FALSE;
						}
						if (_tmp757_) {
							ValaParameter* param = NULL;
							gint _tmp762_ = 0;
							gchar* _tmp763_ = NULL;
							gchar* _tmp764_ = NULL;
							ValaUnaryExpression* _tmp765_ = NULL;
							ValaExpression* _tmp766_ = NULL;
							ValaExpression* _tmp767_ = NULL;
							ValaDataType* _tmp768_ = NULL;
							ValaDataType* _tmp769_ = NULL;
							ValaParameter* _tmp770_ = NULL;
							ValaParameter* _tmp771_ = NULL;
							ValaParameter* _tmp772_ = NULL;
							ValaMethod* _tmp773_ = NULL;
							ValaParameter* _tmp774_ = NULL;
							_tmp762_ = param_nr;
							_tmp763_ = g_strdup_printf ("param%d", _tmp762_);
							_tmp764_ = _tmp763_;
							_tmp765_ = unary;
							_tmp766_ = vala_unary_expression_get_inner (_tmp765_);
							_tmp767_ = _tmp766_;
							_tmp768_ = vala_expression_get_value_type (_tmp767_);
							_tmp769_ = _tmp768_;
							_tmp770_ = vala_parameter_new (_tmp764_, _tmp769_, NULL);
							_tmp771_ = _tmp770_;
							_g_free0 (_tmp764_);
							param = _tmp771_;
							_tmp772_ = param;
							vala_parameter_set_direction (_tmp772_, VALA_PARAMETER_DIRECTION_REF);
							_tmp773_ = m;
							_tmp774_ = param;
							vala_method_add_parameter (_tmp773_, _tmp774_);
							_vala_code_node_unref0 (param);
						} else {
							ValaMethod* _tmp775_ = NULL;
							gint _tmp776_ = 0;
							gchar* _tmp777_ = NULL;
							gchar* _tmp778_ = NULL;
							ValaExpression* _tmp779_ = NULL;
							ValaDataType* _tmp780_ = NULL;
							ValaDataType* _tmp781_ = NULL;
							ValaParameter* _tmp782_ = NULL;
							ValaParameter* _tmp783_ = NULL;
							_tmp775_ = m;
							_tmp776_ = param_nr;
							_tmp777_ = g_strdup_printf ("param%d", _tmp776_);
							_tmp778_ = _tmp777_;
							_tmp779_ = arg;
							_tmp780_ = vala_expression_get_value_type (_tmp779_);
							_tmp781_ = _tmp780_;
							_tmp782_ = vala_parameter_new (_tmp778_, _tmp781_, NULL);
							_tmp783_ = _tmp782_;
							vala_method_add_parameter (_tmp775_, _tmp783_);
							_vala_code_node_unref0 (_tmp783_);
							_g_free0 (_tmp778_);
						}
					}
					_tmp784_ = param_nr;
					param_nr = _tmp784_ + 1;
					_vala_code_node_unref0 (unary);
					_vala_code_node_unref0 (arg);
				}
				_vala_iterable_unref0 (_arg_list);
			}
			{
				ValaList* _param_list = NULL;
				ValaMethod* _tmp785_ = NULL;
				ValaList* _tmp786_ = NULL;
				gint _param_size = 0;
				ValaList* _tmp787_ = NULL;
				gint _tmp788_ = 0;
				gint _tmp789_ = 0;
				gint _param_index = 0;
				_tmp785_ = m;
				_tmp786_ = vala_method_get_parameters (_tmp785_);
				_param_list = _tmp786_;
				_tmp787_ = _param_list;
				_tmp788_ = vala_collection_get_size ((ValaCollection*) _tmp787_);
				_tmp789_ = _tmp788_;
				_param_size = _tmp789_;
				_param_index = -1;
				while (TRUE) {
					gint _tmp790_ = 0;
					gint _tmp791_ = 0;
					gint _tmp792_ = 0;
					ValaParameter* param = NULL;
					ValaList* _tmp793_ = NULL;
					gint _tmp794_ = 0;
					gpointer _tmp795_ = NULL;
					ValaParameter* _tmp796_ = NULL;
					_tmp790_ = _param_index;
					_param_index = _tmp790_ + 1;
					_tmp791_ = _param_index;
					_tmp792_ = _param_size;
					if (!(_tmp791_ < _tmp792_)) {
						break;
					}
					_tmp793_ = _param_list;
					_tmp794_ = _param_index;
					_tmp795_ = vala_list_get (_tmp793_, _tmp794_);
					param = (ValaParameter*) _tmp795_;
					_tmp796_ = param;
					vala_code_node_accept ((ValaCodeNode*) _tmp796_, (ValaCodeVisitor*) self);
					_vala_code_node_unref0 (param);
				}
				_vala_iterable_unref0 (_param_list);
			}
			_tmp797_ = m;
			vala_ccode_base_module_generate_dynamic_method_wrapper ((ValaCCodeBaseModule*) self, G_TYPE_CHECK_INSTANCE_CAST (_tmp797_, VALA_TYPE_DYNAMIC_METHOD, ValaDynamicMethod));
		} else {
			gboolean _tmp798_ = FALSE;
			ValaMethod* _tmp799_ = NULL;
			_tmp799_ = m;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp799_, VALA_TYPE_CREATION_METHOD)) {
				ValaMethod* _tmp800_ = NULL;
				ValaSymbol* _tmp801_ = NULL;
				ValaSymbol* _tmp802_ = NULL;
				_tmp800_ = m;
				_tmp801_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp800_);
				_tmp802_ = _tmp801_;
				_tmp798_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp802_, VALA_TYPE_CLASS);
			} else {
				_tmp798_ = FALSE;
			}
			if (_tmp798_) {
				ValaCCodeFunction* _tmp803_ = NULL;
				ValaCCodeFunction* _tmp804_ = NULL;
				ValaCCodeExpression* _tmp805_ = NULL;
				ValaCCodeExpression* _tmp806_ = NULL;
				ValaCCodeFunctionCall* _tmp807_ = NULL;
				ValaClass* _tmp808_ = NULL;
				ValaClass* _tmp809_ = NULL;
				gchar* _tmp810_ = NULL;
				gchar* _tmp811_ = NULL;
				gchar* _tmp812_ = NULL;
				gchar* _tmp813_ = NULL;
				ValaCCodeCastExpression* _tmp814_ = NULL;
				ValaCCodeCastExpression* _tmp815_ = NULL;
				ValaMethod* _tmp816_ = NULL;
				ValaMethod* _tmp817_ = NULL;
				ValaBlock* _tmp818_ = NULL;
				ValaBlock* _tmp819_ = NULL;
				gboolean _tmp820_ = FALSE;
				gboolean _tmp821_ = FALSE;
				gboolean _tmp850_ = FALSE;
				ValaClass* _tmp851_ = NULL;
				ValaClass* _tmp852_ = NULL;
				gboolean _tmp853_ = FALSE;
				gboolean _tmp854_ = FALSE;
				_tmp803_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp804_ = _tmp803_;
				_tmp805_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self);
				_tmp806_ = _tmp805_;
				_tmp807_ = ccall;
				_tmp808_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
				_tmp809_ = _tmp808_;
				_tmp810_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp809_);
				_tmp811_ = _tmp810_;
				_tmp812_ = g_strconcat (_tmp811_, "*", NULL);
				_tmp813_ = _tmp812_;
				_tmp814_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp807_, _tmp813_);
				_tmp815_ = _tmp814_;
				vala_ccode_function_add_assignment (_tmp804_, _tmp806_, (ValaCCodeExpression*) _tmp815_);
				_vala_ccode_node_unref0 (_tmp815_);
				_g_free0 (_tmp813_);
				_g_free0 (_tmp811_);
				_vala_ccode_node_unref0 (_tmp806_);
				_tmp816_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
				_tmp817_ = _tmp816_;
				_tmp818_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp817_);
				_tmp819_ = _tmp818_;
				_tmp820_ = vala_block_get_captured (_tmp819_);
				_tmp821_ = _tmp820_;
				if (_tmp821_) {
					ValaCCodeFunctionCall* ref_call = NULL;
					ValaClass* _tmp822_ = NULL;
					ValaClass* _tmp823_ = NULL;
					ValaObjectType* _tmp824_ = NULL;
					ValaObjectType* _tmp825_ = NULL;
					ValaMethodCall* _tmp826_ = NULL;
					ValaSourceReference* _tmp827_ = NULL;
					ValaSourceReference* _tmp828_ = NULL;
					ValaCCodeExpression* _tmp829_ = NULL;
					ValaCCodeExpression* _tmp830_ = NULL;
					ValaCCodeFunctionCall* _tmp831_ = NULL;
					ValaCCodeFunctionCall* _tmp832_ = NULL;
					ValaCCodeFunctionCall* _tmp833_ = NULL;
					ValaCCodeExpression* _tmp834_ = NULL;
					ValaCCodeExpression* _tmp835_ = NULL;
					ValaCCodeFunction* _tmp836_ = NULL;
					ValaCCodeFunction* _tmp837_ = NULL;
					ValaMethod* _tmp838_ = NULL;
					ValaMethod* _tmp839_ = NULL;
					ValaBlock* _tmp840_ = NULL;
					ValaBlock* _tmp841_ = NULL;
					gint _tmp842_ = 0;
					gchar* _tmp843_ = NULL;
					gchar* _tmp844_ = NULL;
					ValaCCodeExpression* _tmp845_ = NULL;
					ValaCCodeExpression* _tmp846_ = NULL;
					ValaCCodeMemberAccess* _tmp847_ = NULL;
					ValaCCodeMemberAccess* _tmp848_ = NULL;
					ValaCCodeFunctionCall* _tmp849_ = NULL;
					_tmp822_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
					_tmp823_ = _tmp822_;
					_tmp824_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp823_);
					_tmp825_ = _tmp824_;
					_tmp826_ = expr;
					_tmp827_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp826_);
					_tmp828_ = _tmp827_;
					_tmp829_ = vala_ccode_base_module_get_dup_func_expression ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp825_, _tmp828_, FALSE);
					_tmp830_ = _tmp829_;
					_tmp831_ = vala_ccode_function_call_new (_tmp830_);
					_tmp832_ = _tmp831_;
					_vala_ccode_node_unref0 (_tmp830_);
					_vala_code_node_unref0 (_tmp825_);
					ref_call = _tmp832_;
					_tmp833_ = ref_call;
					_tmp834_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self);
					_tmp835_ = _tmp834_;
					vala_ccode_function_call_add_argument (_tmp833_, _tmp835_);
					_vala_ccode_node_unref0 (_tmp835_);
					_tmp836_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
					_tmp837_ = _tmp836_;
					_tmp838_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
					_tmp839_ = _tmp838_;
					_tmp840_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp839_);
					_tmp841_ = _tmp840_;
					_tmp842_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp841_);
					_tmp843_ = g_strdup_printf ("_data%d_", _tmp842_);
					_tmp844_ = _tmp843_;
					_tmp845_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp844_);
					_tmp846_ = _tmp845_;
					_tmp847_ = vala_ccode_member_access_new_pointer (_tmp846_, "self");
					_tmp848_ = _tmp847_;
					_tmp849_ = ref_call;
					vala_ccode_function_add_assignment (_tmp837_, (ValaCCodeExpression*) _tmp848_, (ValaCCodeExpression*) _tmp849_);
					_vala_ccode_node_unref0 (_tmp848_);
					_vala_ccode_node_unref0 (_tmp846_);
					_g_free0 (_tmp844_);
					_vala_ccode_node_unref0 (ref_call);
				}
				_tmp851_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
				_tmp852_ = _tmp851_;
				_tmp853_ = vala_class_get_is_compact (_tmp852_);
				_tmp854_ = _tmp853_;
				if (!_tmp854_) {
					ValaClass* _tmp855_ = NULL;
					ValaClass* _tmp856_ = NULL;
					ValaList* _tmp857_ = NULL;
					ValaList* _tmp858_ = NULL;
					gint _tmp859_ = 0;
					gint _tmp860_ = 0;
					_tmp855_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
					_tmp856_ = _tmp855_;
					_tmp857_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp856_);
					_tmp858_ = _tmp857_;
					_tmp859_ = vala_collection_get_size ((ValaCollection*) _tmp858_);
					_tmp860_ = _tmp859_;
					_tmp850_ = _tmp860_ > 0;
					_vala_iterable_unref0 (_tmp858_);
				} else {
					_tmp850_ = FALSE;
				}
				if (_tmp850_) {
					gchar** suffices = NULL;
					gchar* _tmp861_ = NULL;
					gchar* _tmp862_ = NULL;
					gchar* _tmp863_ = NULL;
					gchar** _tmp864_ = NULL;
					gint suffices_length1 = 0;
					gint _suffices_size_ = 0;
					_tmp861_ = g_strdup ("type");
					_tmp862_ = g_strdup ("dup_func");
					_tmp863_ = g_strdup ("destroy_func");
					_tmp864_ = g_new0 (gchar*, 3 + 1);
					_tmp864_[0] = _tmp861_;
					_tmp864_[1] = _tmp862_;
					_tmp864_[2] = _tmp863_;
					suffices = _tmp864_;
					suffices_length1 = 3;
					_suffices_size_ = suffices_length1;
					{
						ValaList* _type_param_list = NULL;
						ValaClass* _tmp865_ = NULL;
						ValaClass* _tmp866_ = NULL;
						ValaList* _tmp867_ = NULL;
						gint _type_param_size = 0;
						ValaList* _tmp868_ = NULL;
						gint _tmp869_ = 0;
						gint _tmp870_ = 0;
						gint _type_param_index = 0;
						_tmp865_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
						_tmp866_ = _tmp865_;
						_tmp867_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp866_);
						_type_param_list = _tmp867_;
						_tmp868_ = _type_param_list;
						_tmp869_ = vala_collection_get_size ((ValaCollection*) _tmp868_);
						_tmp870_ = _tmp869_;
						_type_param_size = _tmp870_;
						_type_param_index = -1;
						while (TRUE) {
							gint _tmp871_ = 0;
							gint _tmp872_ = 0;
							gint _tmp873_ = 0;
							ValaTypeParameter* type_param = NULL;
							ValaList* _tmp874_ = NULL;
							gint _tmp875_ = 0;
							gpointer _tmp876_ = NULL;
							ValaCCodeMemberAccess* priv_access = NULL;
							ValaCCodeIdentifier* _tmp877_ = NULL;
							ValaCCodeIdentifier* _tmp878_ = NULL;
							ValaCCodeMemberAccess* _tmp879_ = NULL;
							ValaCCodeMemberAccess* _tmp880_ = NULL;
							gchar** _tmp881_ = NULL;
							gint _tmp881__length1 = 0;
							_tmp871_ = _type_param_index;
							_type_param_index = _tmp871_ + 1;
							_tmp872_ = _type_param_index;
							_tmp873_ = _type_param_size;
							if (!(_tmp872_ < _tmp873_)) {
								break;
							}
							_tmp874_ = _type_param_list;
							_tmp875_ = _type_param_index;
							_tmp876_ = vala_list_get (_tmp874_, _tmp875_);
							type_param = (ValaTypeParameter*) _tmp876_;
							_tmp877_ = vala_ccode_identifier_new ("self");
							_tmp878_ = _tmp877_;
							_tmp879_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp878_, "priv");
							_tmp880_ = _tmp879_;
							_vala_ccode_node_unref0 (_tmp878_);
							priv_access = _tmp880_;
							_tmp881_ = suffices;
							_tmp881__length1 = suffices_length1;
							{
								gchar** suffix_collection = NULL;
								gint suffix_collection_length1 = 0;
								gint _suffix_collection_size_ = 0;
								gint suffix_it = 0;
								suffix_collection = _tmp881_;
								suffix_collection_length1 = _tmp881__length1;
								for (suffix_it = 0; suffix_it < _tmp881__length1; suffix_it = suffix_it + 1) {
									gchar* _tmp882_ = NULL;
									gchar* suffix = NULL;
									_tmp882_ = g_strdup (suffix_collection[suffix_it]);
									suffix = _tmp882_;
									{
										ValaCCodeIdentifier* param_name = NULL;
										ValaTypeParameter* _tmp883_ = NULL;
										const gchar* _tmp884_ = NULL;
										const gchar* _tmp885_ = NULL;
										gchar* _tmp886_ = NULL;
										gchar* _tmp887_ = NULL;
										const gchar* _tmp888_ = NULL;
										gchar* _tmp889_ = NULL;
										gchar* _tmp890_ = NULL;
										ValaCCodeIdentifier* _tmp891_ = NULL;
										ValaCCodeIdentifier* _tmp892_ = NULL;
										ValaCCodeFunction* _tmp893_ = NULL;
										ValaCCodeFunction* _tmp894_ = NULL;
										ValaCCodeMemberAccess* _tmp895_ = NULL;
										ValaCCodeIdentifier* _tmp896_ = NULL;
										const gchar* _tmp897_ = NULL;
										const gchar* _tmp898_ = NULL;
										ValaCCodeMemberAccess* _tmp899_ = NULL;
										ValaCCodeMemberAccess* _tmp900_ = NULL;
										ValaCCodeIdentifier* _tmp901_ = NULL;
										_tmp883_ = type_param;
										_tmp884_ = vala_symbol_get_name ((ValaSymbol*) _tmp883_);
										_tmp885_ = _tmp884_;
										_tmp886_ = g_utf8_strdown (_tmp885_, (gssize) (-1));
										_tmp887_ = _tmp886_;
										_tmp888_ = suffix;
										_tmp889_ = g_strdup_printf ("%s_%s", _tmp887_, _tmp888_);
										_tmp890_ = _tmp889_;
										_tmp891_ = vala_ccode_identifier_new (_tmp890_);
										_tmp892_ = _tmp891_;
										_g_free0 (_tmp890_);
										_g_free0 (_tmp887_);
										param_name = _tmp892_;
										_tmp893_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
										_tmp894_ = _tmp893_;
										_tmp895_ = priv_access;
										_tmp896_ = param_name;
										_tmp897_ = vala_ccode_identifier_get_name (_tmp896_);
										_tmp898_ = _tmp897_;
										_tmp899_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp895_, _tmp898_);
										_tmp900_ = _tmp899_;
										_tmp901_ = param_name;
										vala_ccode_function_add_assignment (_tmp894_, (ValaCCodeExpression*) _tmp900_, (ValaCCodeExpression*) _tmp901_);
										_vala_ccode_node_unref0 (_tmp900_);
										_vala_ccode_node_unref0 (param_name);
										_g_free0 (suffix);
									}
								}
							}
							_vala_ccode_node_unref0 (priv_access);
							_vala_code_node_unref0 (type_param);
						}
						_vala_iterable_unref0 (_type_param_list);
					}
					suffices = (_vala_array_free (suffices, suffices_length1, (GDestroyNotify) g_free), NULL);
				}
				_vala_ccode_node_unref0 (ccall_expr);
				ccall_expr = NULL;
			}
		}
	}
	ellipsis = FALSE;
	i = 1;
	_tmp902_ = params;
	_tmp903_ = vala_iterable_iterator ((ValaIterable*) _tmp902_);
	params_it = _tmp903_;
	{
		ValaList* _arg_list = NULL;
		ValaMethodCall* _tmp904_ = NULL;
		ValaList* _tmp905_ = NULL;
		gint _arg_size = 0;
		ValaList* _tmp906_ = NULL;
		gint _tmp907_ = 0;
		gint _tmp908_ = 0;
		gint _arg_index = 0;
		_tmp904_ = expr;
		_tmp905_ = vala_method_call_get_argument_list (_tmp904_);
		_arg_list = _tmp905_;
		_tmp906_ = _arg_list;
		_tmp907_ = vala_collection_get_size ((ValaCollection*) _tmp906_);
		_tmp908_ = _tmp907_;
		_arg_size = _tmp908_;
		_arg_index = -1;
		while (TRUE) {
			gint _tmp909_ = 0;
			gint _tmp910_ = 0;
			gint _tmp911_ = 0;
			ValaExpression* arg = NULL;
			ValaList* _tmp912_ = NULL;
			gint _tmp913_ = 0;
			gpointer _tmp914_ = NULL;
			ValaCCodeExpression* cexpr = NULL;
			ValaExpression* _tmp915_ = NULL;
			ValaCCodeExpression* _tmp916_ = NULL;
			ValaHashMap* carg_map = NULL;
			ValaHashMap* _tmp917_ = NULL;
			ValaHashMap* _tmp918_ = NULL;
			ValaIterator* _tmp919_ = NULL;
			gboolean _tmp920_ = FALSE;
			ValaHashMap* _tmp1247_ = NULL;
			gint _tmp1248_ = 0;
			ValaCCodeExpression* _tmp1249_ = NULL;
			gboolean _tmp1250_ = FALSE;
			ValaExpression* _tmp1251_ = NULL;
			gint _tmp1272_ = 0;
			_tmp909_ = _arg_index;
			_arg_index = _tmp909_ + 1;
			_tmp910_ = _arg_index;
			_tmp911_ = _arg_size;
			if (!(_tmp910_ < _tmp911_)) {
				break;
			}
			_tmp912_ = _arg_list;
			_tmp913_ = _arg_index;
			_tmp914_ = vala_list_get (_tmp912_, _tmp913_);
			arg = (ValaExpression*) _tmp914_;
			_tmp915_ = arg;
			_tmp916_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp915_);
			cexpr = _tmp916_;
			_tmp917_ = in_arg_map;
			_tmp918_ = _vala_map_ref0 (_tmp917_);
			carg_map = _tmp918_;
			_tmp919_ = params_it;
			_tmp920_ = vala_iterator_next (_tmp919_);
			if (_tmp920_) {
				ValaParameter* param = NULL;
				ValaIterator* _tmp921_ = NULL;
				gpointer _tmp922_ = NULL;
				gboolean _tmp923_ = FALSE;
				ValaParameter* _tmp924_ = NULL;
				gboolean _tmp925_ = FALSE;
				gboolean _tmp926_ = FALSE;
				gboolean _tmp930_ = FALSE;
				ValaParameter* _tmp1237_ = NULL;
				gdouble _tmp1238_ = 0.0;
				gboolean _tmp1239_ = FALSE;
				gint _tmp1240_ = 0;
				_tmp921_ = params_it;
				_tmp922_ = vala_iterator_get (_tmp921_);
				param = (ValaParameter*) _tmp922_;
				_tmp924_ = param;
				_tmp925_ = vala_parameter_get_params_array (_tmp924_);
				_tmp926_ = _tmp925_;
				if (_tmp926_) {
					_tmp923_ = TRUE;
				} else {
					ValaParameter* _tmp927_ = NULL;
					gboolean _tmp928_ = FALSE;
					gboolean _tmp929_ = FALSE;
					_tmp927_ = param;
					_tmp928_ = vala_parameter_get_ellipsis (_tmp927_);
					_tmp929_ = _tmp928_;
					_tmp923_ = _tmp929_;
				}
				ellipsis = _tmp923_;
				_tmp930_ = ellipsis;
				if (!_tmp930_) {
					ValaParameter* _tmp931_ = NULL;
					ValaParameterDirection _tmp932_ = 0;
					ValaParameterDirection _tmp933_ = 0;
					ValaUnaryExpression* unary = NULL;
					ValaExpression* _tmp936_ = NULL;
					ValaUnaryExpression* _tmp937_ = NULL;
					gboolean _tmp938_ = FALSE;
					ValaUnaryExpression* _tmp939_ = NULL;
					ValaParameter* _tmp1225_ = NULL;
					gchar* _tmp1226_ = NULL;
					gchar* _tmp1227_ = NULL;
					gboolean _tmp1228_ = FALSE;
					_tmp931_ = param;
					_tmp932_ = vala_parameter_get_direction (_tmp931_);
					_tmp933_ = _tmp932_;
					if (_tmp933_ == VALA_PARAMETER_DIRECTION_OUT) {
						ValaHashMap* _tmp934_ = NULL;
						ValaHashMap* _tmp935_ = NULL;
						_tmp934_ = out_arg_map;
						_tmp935_ = _vala_map_ref0 (_tmp934_);
						_vala_map_unref0 (carg_map);
						carg_map = _tmp935_;
					}
					_tmp936_ = arg;
					_tmp937_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp936_, VALA_TYPE_UNARY_EXPRESSION) ? ((ValaUnaryExpression*) _tmp936_) : NULL);
					unary = _tmp937_;
					_tmp939_ = unary;
					if (_tmp939_ == NULL) {
						_tmp938_ = TRUE;
					} else {
						ValaUnaryExpression* _tmp940_ = NULL;
						ValaUnaryOperator _tmp941_ = 0;
						ValaUnaryOperator _tmp942_ = 0;
						_tmp940_ = unary;
						_tmp941_ = vala_unary_expression_get_operator (_tmp940_);
						_tmp942_ = _tmp941_;
						_tmp938_ = _tmp942_ != VALA_UNARY_OPERATOR_OUT;
					}
					if (_tmp938_) {
						gboolean _tmp943_ = FALSE;
						ValaParameter* _tmp944_ = NULL;
						gboolean _tmp945_ = FALSE;
						ValaParameter* _tmp1091_ = NULL;
						ValaExpression* _tmp1092_ = NULL;
						ValaCCodeExpression* _tmp1093_ = NULL;
						ValaCCodeExpression* _tmp1094_ = NULL;
						_tmp944_ = param;
						_tmp945_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp944_);
						if (_tmp945_) {
							ValaParameter* _tmp946_ = NULL;
							ValaDataType* _tmp947_ = NULL;
							ValaDataType* _tmp948_ = NULL;
							_tmp946_ = param;
							_tmp947_ = vala_variable_get_variable_type ((ValaVariable*) _tmp946_);
							_tmp948_ = _tmp947_;
							_tmp943_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp948_, VALA_TYPE_ARRAY_TYPE);
						} else {
							_tmp943_ = FALSE;
						}
						if (_tmp943_) {
							ValaArrayType* array_type = NULL;
							ValaParameter* _tmp949_ = NULL;
							ValaDataType* _tmp950_ = NULL;
							ValaDataType* _tmp951_ = NULL;
							ValaArrayType* _tmp952_ = NULL;
							_tmp949_ = param;
							_tmp950_ = vala_variable_get_variable_type ((ValaVariable*) _tmp949_);
							_tmp951_ = _tmp950_;
							_tmp952_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp951_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
							array_type = _tmp952_;
							{
								gint dim = 0;
								dim = 1;
								{
									gboolean _tmp953_ = FALSE;
									_tmp953_ = TRUE;
									while (TRUE) {
										gint _tmp955_ = 0;
										ValaArrayType* _tmp956_ = NULL;
										gint _tmp957_ = 0;
										gint _tmp958_ = 0;
										ValaCCodeExpression* array_length_expr = NULL;
										ValaParameter* _tmp959_ = NULL;
										gchar* _tmp960_ = NULL;
										gchar* _tmp961_ = NULL;
										gboolean _tmp962_ = FALSE;
										ValaHashMap* _tmp974_ = NULL;
										ValaParameter* _tmp975_ = NULL;
										gdouble _tmp976_ = 0.0;
										gint _tmp977_ = 0;
										gint _tmp978_ = 0;
										ValaCCodeExpression* _tmp979_ = NULL;
										if (!_tmp953_) {
											gint _tmp954_ = 0;
											_tmp954_ = dim;
											dim = _tmp954_ + 1;
										}
										_tmp953_ = FALSE;
										_tmp955_ = dim;
										_tmp956_ = array_type;
										_tmp957_ = vala_array_type_get_rank (_tmp956_);
										_tmp958_ = _tmp957_;
										if (!(_tmp955_ <= _tmp958_)) {
											break;
										}
										array_length_expr = NULL;
										_tmp959_ = param;
										_tmp960_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp959_);
										_tmp961_ = _tmp960_;
										_tmp962_ = _tmp961_ != NULL;
										_g_free0 (_tmp961_);
										if (_tmp962_) {
											ValaExpression* _tmp963_ = NULL;
											gint _tmp964_ = 0;
											ValaCCodeExpression* _tmp965_ = NULL;
											ValaCCodeExpression* _tmp966_ = NULL;
											ValaParameter* _tmp967_ = NULL;
											gchar* _tmp968_ = NULL;
											gchar* _tmp969_ = NULL;
											ValaCCodeCastExpression* _tmp970_ = NULL;
											_tmp963_ = arg;
											_tmp964_ = dim;
											_tmp965_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp963_, _tmp964_);
											_tmp966_ = _tmp965_;
											_tmp967_ = param;
											_tmp968_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp967_);
											_tmp969_ = _tmp968_;
											_tmp970_ = vala_ccode_cast_expression_new (_tmp966_, _tmp969_);
											_vala_ccode_node_unref0 (array_length_expr);
											array_length_expr = (ValaCCodeExpression*) _tmp970_;
											_g_free0 (_tmp969_);
											_vala_ccode_node_unref0 (_tmp966_);
										} else {
											ValaExpression* _tmp971_ = NULL;
											gint _tmp972_ = 0;
											ValaCCodeExpression* _tmp973_ = NULL;
											_tmp971_ = arg;
											_tmp972_ = dim;
											_tmp973_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp971_, _tmp972_);
											_vala_ccode_node_unref0 (array_length_expr);
											array_length_expr = _tmp973_;
										}
										_tmp974_ = carg_map;
										_tmp975_ = param;
										_tmp976_ = vala_ccode_base_module_get_ccode_array_length_pos ((ValaCodeNode*) _tmp975_);
										_tmp977_ = dim;
										_tmp978_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp976_ + (0.01 * _tmp977_), FALSE);
										_tmp979_ = array_length_expr;
										vala_map_set ((ValaMap*) _tmp974_, (gpointer) ((gintptr) _tmp978_), _tmp979_);
										_vala_ccode_node_unref0 (array_length_expr);
									}
								}
							}
							_vala_code_node_unref0 (array_type);
						} else {
							ValaParameter* _tmp980_ = NULL;
							ValaDataType* _tmp981_ = NULL;
							ValaDataType* _tmp982_ = NULL;
							_tmp980_ = param;
							_tmp981_ = vala_variable_get_variable_type ((ValaVariable*) _tmp980_);
							_tmp982_ = _tmp981_;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp982_, VALA_TYPE_DELEGATE_TYPE)) {
								ValaDelegateType* deleg_type = NULL;
								ValaParameter* _tmp983_ = NULL;
								ValaDataType* _tmp984_ = NULL;
								ValaDataType* _tmp985_ = NULL;
								ValaDelegateType* _tmp986_ = NULL;
								ValaDelegate* d = NULL;
								ValaDelegateType* _tmp987_ = NULL;
								ValaDelegate* _tmp988_ = NULL;
								ValaDelegate* _tmp989_ = NULL;
								ValaDelegate* _tmp990_ = NULL;
								ValaDelegate* _tmp991_ = NULL;
								gboolean _tmp992_ = FALSE;
								gboolean _tmp993_ = FALSE;
								_tmp983_ = param;
								_tmp984_ = vala_variable_get_variable_type ((ValaVariable*) _tmp983_);
								_tmp985_ = _tmp984_;
								_tmp986_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp985_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
								deleg_type = _tmp986_;
								_tmp987_ = deleg_type;
								_tmp988_ = vala_delegate_type_get_delegate_symbol (_tmp987_);
								_tmp989_ = _tmp988_;
								_tmp990_ = _vala_code_node_ref0 (_tmp989_);
								d = _tmp990_;
								_tmp991_ = d;
								_tmp992_ = vala_delegate_get_has_target (_tmp991_);
								_tmp993_ = _tmp992_;
								if (_tmp993_) {
									ValaCCodeExpression* delegate_target_destroy_notify = NULL;
									ValaCCodeExpression* delegate_target = NULL;
									ValaExpression* _tmp994_ = NULL;
									ValaCCodeExpression* _tmp995_ = NULL;
									ValaCCodeExpression* _tmp996_ = NULL;
									ValaCCodeExpression* _tmp997_ = NULL;
									ValaParameter* _tmp998_ = NULL;
									gchar* _tmp999_ = NULL;
									gchar* _tmp1000_ = NULL;
									gboolean _tmp1001_ = FALSE;
									_tmp994_ = arg;
									_tmp996_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp994_, &_tmp995_);
									_vala_ccode_node_unref0 (delegate_target_destroy_notify);
									delegate_target_destroy_notify = _tmp995_;
									delegate_target = _tmp996_;
									_tmp997_ = delegate_target;
									_vala_assert (_tmp997_ != NULL, "delegate_target != null");
									_tmp998_ = param;
									_tmp999_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp998_);
									_tmp1000_ = _tmp999_;
									_tmp1001_ = g_strcmp0 (_tmp1000_, "GClosure*") == 0;
									_g_free0 (_tmp1000_);
									if (_tmp1001_) {
										ValaCCodeFunctionCall* closure_new = NULL;
										ValaCCodeIdentifier* _tmp1002_ = NULL;
										ValaCCodeIdentifier* _tmp1003_ = NULL;
										ValaCCodeFunctionCall* _tmp1004_ = NULL;
										ValaCCodeFunctionCall* _tmp1005_ = NULL;
										ValaCCodeFunctionCall* _tmp1006_ = NULL;
										ValaCCodeExpression* _tmp1007_ = NULL;
										ValaCCodeCastExpression* _tmp1008_ = NULL;
										ValaCCodeCastExpression* _tmp1009_ = NULL;
										ValaCCodeFunctionCall* _tmp1010_ = NULL;
										ValaCCodeExpression* _tmp1011_ = NULL;
										ValaCCodeFunctionCall* _tmp1012_ = NULL;
										ValaCCodeExpression* _tmp1013_ = NULL;
										ValaCCodeExpression* _tmp1014_ = NULL;
										ValaCCodeIdentifier* _tmp1015_ = NULL;
										ValaCCodeIdentifier* _tmp1016_ = NULL;
										ValaCCodeBinaryExpression* _tmp1017_ = NULL;
										ValaCCodeBinaryExpression* _tmp1018_ = NULL;
										ValaCCodeIdentifier* _tmp1019_ = NULL;
										ValaCCodeIdentifier* _tmp1020_ = NULL;
										ValaCCodeFunctionCall* _tmp1021_ = NULL;
										ValaCCodeConditionalExpression* _tmp1022_ = NULL;
										_tmp1002_ = vala_ccode_identifier_new ("g_cclosure_new");
										_tmp1003_ = _tmp1002_;
										_tmp1004_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1003_);
										_tmp1005_ = _tmp1004_;
										_vala_ccode_node_unref0 (_tmp1003_);
										closure_new = _tmp1005_;
										_tmp1006_ = closure_new;
										_tmp1007_ = cexpr;
										_tmp1008_ = vala_ccode_cast_expression_new (_tmp1007_, "GCallback");
										_tmp1009_ = _tmp1008_;
										vala_ccode_function_call_add_argument (_tmp1006_, (ValaCCodeExpression*) _tmp1009_);
										_vala_ccode_node_unref0 (_tmp1009_);
										_tmp1010_ = closure_new;
										_tmp1011_ = delegate_target;
										vala_ccode_function_call_add_argument (_tmp1010_, _tmp1011_);
										_tmp1012_ = closure_new;
										_tmp1013_ = delegate_target_destroy_notify;
										vala_ccode_function_call_add_argument (_tmp1012_, _tmp1013_);
										_tmp1014_ = cexpr;
										_tmp1015_ = vala_ccode_identifier_new ("NULL");
										_tmp1016_ = _tmp1015_;
										_tmp1017_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, _tmp1014_, (ValaCCodeExpression*) _tmp1016_);
										_tmp1018_ = _tmp1017_;
										_tmp1019_ = vala_ccode_identifier_new ("NULL");
										_tmp1020_ = _tmp1019_;
										_tmp1021_ = closure_new;
										_tmp1022_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp1018_, (ValaCCodeExpression*) _tmp1020_, (ValaCCodeExpression*) _tmp1021_);
										_vala_ccode_node_unref0 (cexpr);
										cexpr = (ValaCCodeExpression*) _tmp1022_;
										_vala_ccode_node_unref0 (_tmp1020_);
										_vala_ccode_node_unref0 (_tmp1018_);
										_vala_ccode_node_unref0 (_tmp1016_);
										_vala_ccode_node_unref0 (closure_new);
									} else {
										ValaHashMap* _tmp1023_ = NULL;
										ValaParameter* _tmp1024_ = NULL;
										gdouble _tmp1025_ = 0.0;
										gint _tmp1026_ = 0;
										ValaCCodeExpression* _tmp1027_ = NULL;
										ValaDelegateType* _tmp1028_ = NULL;
										gboolean _tmp1029_ = FALSE;
										_tmp1023_ = carg_map;
										_tmp1024_ = param;
										_tmp1025_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1024_);
										_tmp1026_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1025_, FALSE);
										_tmp1027_ = delegate_target;
										vala_map_set ((ValaMap*) _tmp1023_, (gpointer) ((gintptr) _tmp1026_), _tmp1027_);
										_tmp1028_ = deleg_type;
										_tmp1029_ = vala_data_type_is_disposable ((ValaDataType*) _tmp1028_);
										if (_tmp1029_) {
											ValaCCodeExpression* _tmp1030_ = NULL;
											ValaHashMap* _tmp1031_ = NULL;
											ValaParameter* _tmp1032_ = NULL;
											gdouble _tmp1033_ = 0.0;
											gint _tmp1034_ = 0;
											ValaCCodeExpression* _tmp1035_ = NULL;
											_tmp1030_ = delegate_target_destroy_notify;
											_vala_assert (_tmp1030_ != NULL, "delegate_target_destroy_notify != null");
											_tmp1031_ = carg_map;
											_tmp1032_ = param;
											_tmp1033_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1032_);
											_tmp1034_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1033_ + 0.01, FALSE);
											_tmp1035_ = delegate_target_destroy_notify;
											vala_map_set ((ValaMap*) _tmp1031_, (gpointer) ((gintptr) _tmp1034_), _tmp1035_);
										}
									}
									_vala_ccode_node_unref0 (delegate_target);
									_vala_ccode_node_unref0 (delegate_target_destroy_notify);
								}
								_vala_code_node_unref0 (d);
								_vala_code_node_unref0 (deleg_type);
							} else {
								ValaParameter* _tmp1036_ = NULL;
								ValaDataType* _tmp1037_ = NULL;
								ValaDataType* _tmp1038_ = NULL;
								_tmp1036_ = param;
								_tmp1037_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1036_);
								_tmp1038_ = _tmp1037_;
								if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1038_, VALA_TYPE_METHOD_TYPE)) {
									ValaCCodeExpression* delegate_target_destroy_notify = NULL;
									ValaHashMap* _tmp1039_ = NULL;
									ValaParameter* _tmp1040_ = NULL;
									gdouble _tmp1041_ = 0.0;
									gint _tmp1042_ = 0;
									ValaExpression* _tmp1043_ = NULL;
									ValaCCodeExpression* _tmp1044_ = NULL;
									ValaCCodeExpression* _tmp1045_ = NULL;
									ValaCCodeExpression* _tmp1046_ = NULL;
									_tmp1039_ = carg_map;
									_tmp1040_ = param;
									_tmp1041_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1040_);
									_tmp1042_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1041_, FALSE);
									_tmp1043_ = arg;
									_tmp1045_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp1043_, &_tmp1044_);
									_vala_ccode_node_unref0 (delegate_target_destroy_notify);
									delegate_target_destroy_notify = _tmp1044_;
									_tmp1046_ = _tmp1045_;
									vala_map_set ((ValaMap*) _tmp1039_, (gpointer) ((gintptr) _tmp1042_), _tmp1046_);
									_vala_ccode_node_unref0 (_tmp1046_);
									_vala_ccode_node_unref0 (delegate_target_destroy_notify);
								} else {
									ValaParameter* _tmp1047_ = NULL;
									ValaDataType* _tmp1048_ = NULL;
									ValaDataType* _tmp1049_ = NULL;
									_tmp1047_ = param;
									_tmp1048_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1047_);
									_tmp1049_ = _tmp1048_;
									if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1049_, VALA_TYPE_GENERIC_TYPE)) {
										gboolean _tmp1050_ = FALSE;
										ValaMethod* _tmp1051_ = NULL;
										_tmp1051_ = m;
										if (_tmp1051_ != NULL) {
											ValaMethod* _tmp1052_ = NULL;
											gboolean _tmp1053_ = FALSE;
											_tmp1052_ = m;
											_tmp1053_ = vala_ccode_base_module_get_ccode_simple_generics (_tmp1052_);
											_tmp1050_ = _tmp1053_;
										} else {
											_tmp1050_ = FALSE;
										}
										if (_tmp1050_) {
											ValaGenericType* generic_type = NULL;
											ValaParameter* _tmp1054_ = NULL;
											ValaDataType* _tmp1055_ = NULL;
											ValaDataType* _tmp1056_ = NULL;
											ValaGenericType* _tmp1057_ = NULL;
											gint type_param_index = 0;
											ValaMethod* _tmp1058_ = NULL;
											ValaGenericType* _tmp1059_ = NULL;
											ValaTypeParameter* _tmp1060_ = NULL;
											ValaTypeParameter* _tmp1061_ = NULL;
											const gchar* _tmp1062_ = NULL;
											const gchar* _tmp1063_ = NULL;
											gint _tmp1064_ = 0;
											ValaDataType* type_arg = NULL;
											ValaMemberAccess* _tmp1065_ = NULL;
											ValaList* _tmp1066_ = NULL;
											ValaList* _tmp1067_ = NULL;
											gint _tmp1068_ = 0;
											gpointer _tmp1069_ = NULL;
											ValaDataType* _tmp1070_ = NULL;
											ValaParameter* _tmp1071_ = NULL;
											ValaDataType* _tmp1072_ = NULL;
											ValaDataType* _tmp1073_ = NULL;
											gboolean _tmp1074_ = FALSE;
											gboolean _tmp1075_ = FALSE;
											_tmp1054_ = param;
											_tmp1055_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1054_);
											_tmp1056_ = _tmp1055_;
											_tmp1057_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1056_, VALA_TYPE_GENERIC_TYPE, ValaGenericType));
											generic_type = _tmp1057_;
											_tmp1058_ = m;
											_tmp1059_ = generic_type;
											_tmp1060_ = vala_data_type_get_type_parameter ((ValaDataType*) _tmp1059_);
											_tmp1061_ = _tmp1060_;
											_tmp1062_ = vala_symbol_get_name ((ValaSymbol*) _tmp1061_);
											_tmp1063_ = _tmp1062_;
											_tmp1064_ = vala_method_get_type_parameter_index (_tmp1058_, _tmp1063_);
											type_param_index = _tmp1064_;
											_tmp1065_ = ma;
											_tmp1066_ = vala_member_access_get_type_arguments (_tmp1065_);
											_tmp1067_ = _tmp1066_;
											_tmp1068_ = type_param_index;
											_tmp1069_ = vala_list_get (_tmp1067_, _tmp1068_);
											_tmp1070_ = (ValaDataType*) _tmp1069_;
											_vala_iterable_unref0 (_tmp1067_);
											type_arg = _tmp1070_;
											_tmp1071_ = param;
											_tmp1072_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1071_);
											_tmp1073_ = _tmp1072_;
											_tmp1074_ = vala_data_type_get_value_owned (_tmp1073_);
											_tmp1075_ = _tmp1074_;
											if (_tmp1075_) {
												ValaDataType* _tmp1076_ = NULL;
												gboolean _tmp1077_ = FALSE;
												_tmp1076_ = type_arg;
												_tmp1077_ = vala_ccode_base_module_requires_copy ((ValaCCodeBaseModule*) self, _tmp1076_);
												if (_tmp1077_) {
													ValaHashMap* _tmp1078_ = NULL;
													ValaParameter* _tmp1079_ = NULL;
													gdouble _tmp1080_ = 0.0;
													gint _tmp1081_ = 0;
													ValaDataType* _tmp1082_ = NULL;
													ValaCCodeExpression* _tmp1083_ = NULL;
													ValaCCodeExpression* _tmp1084_ = NULL;
													_tmp1078_ = carg_map;
													_tmp1079_ = param;
													_tmp1080_ = vala_ccode_base_module_get_ccode_destroy_notify_pos ((ValaCodeNode*) _tmp1079_);
													_tmp1081_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1080_, FALSE);
													_tmp1082_ = type_arg;
													_tmp1083_ = vala_ccode_base_module_get_destroy_func_expression ((ValaCCodeBaseModule*) self, _tmp1082_, FALSE);
													_tmp1084_ = _tmp1083_;
													vala_map_set ((ValaMap*) _tmp1078_, (gpointer) ((gintptr) _tmp1081_), _tmp1084_);
													_vala_ccode_node_unref0 (_tmp1084_);
												} else {
													ValaHashMap* _tmp1085_ = NULL;
													ValaParameter* _tmp1086_ = NULL;
													gdouble _tmp1087_ = 0.0;
													gint _tmp1088_ = 0;
													ValaCCodeConstant* _tmp1089_ = NULL;
													ValaCCodeConstant* _tmp1090_ = NULL;
													_tmp1085_ = carg_map;
													_tmp1086_ = param;
													_tmp1087_ = vala_ccode_base_module_get_ccode_destroy_notify_pos ((ValaCodeNode*) _tmp1086_);
													_tmp1088_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1087_, FALSE);
													_tmp1089_ = vala_ccode_constant_new ("NULL");
													_tmp1090_ = _tmp1089_;
													vala_map_set ((ValaMap*) _tmp1085_, (gpointer) ((gintptr) _tmp1088_), (ValaCCodeExpression*) _tmp1090_);
													_vala_ccode_node_unref0 (_tmp1090_);
												}
											}
											_vala_code_node_unref0 (type_arg);
											_vala_code_node_unref0 (generic_type);
										}
									}
								}
							}
						}
						_tmp1091_ = param;
						_tmp1092_ = arg;
						_tmp1093_ = cexpr;
						_tmp1094_ = vala_ccode_base_module_handle_struct_argument ((ValaCCodeBaseModule*) self, _tmp1091_, _tmp1092_, _tmp1093_);
						_vala_ccode_node_unref0 (cexpr);
						cexpr = _tmp1094_;
					} else {
						ValaExpression* _tmp1095_ = NULL;
						ValaLocalVariable* temp_var = NULL;
						ValaParameter* _tmp1096_ = NULL;
						ValaDataType* _tmp1097_ = NULL;
						ValaDataType* _tmp1098_ = NULL;
						ValaParameter* _tmp1099_ = NULL;
						ValaDataType* _tmp1100_ = NULL;
						ValaDataType* _tmp1101_ = NULL;
						gboolean _tmp1102_ = FALSE;
						gboolean _tmp1103_ = FALSE;
						ValaLocalVariable* _tmp1104_ = NULL;
						ValaLocalVariable* _tmp1105_ = NULL;
						ValaExpression* _tmp1106_ = NULL;
						ValaLocalVariable* _tmp1107_ = NULL;
						const gchar* _tmp1108_ = NULL;
						const gchar* _tmp1109_ = NULL;
						ValaCCodeExpression* _tmp1110_ = NULL;
						ValaCCodeExpression* _tmp1111_ = NULL;
						ValaExpression* _tmp1112_ = NULL;
						ValaTargetValue* _tmp1113_ = NULL;
						ValaTargetValue* _tmp1114_ = NULL;
						ValaExpression* _tmp1115_ = NULL;
						ValaDataType* _tmp1116_ = NULL;
						ValaDataType* _tmp1117_ = NULL;
						ValaExpression* _tmp1118_ = NULL;
						ValaCCodeExpression* _tmp1119_ = NULL;
						ValaCCodeExpression* _tmp1120_ = NULL;
						ValaCCodeUnaryExpression* _tmp1121_ = NULL;
						gboolean _tmp1122_ = FALSE;
						ValaParameter* _tmp1123_ = NULL;
						gboolean _tmp1124_ = FALSE;
						_tmp1095_ = arg;
						vala_expression_set_target_value (_tmp1095_, NULL);
						_tmp1096_ = param;
						_tmp1097_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1096_);
						_tmp1098_ = _tmp1097_;
						_tmp1099_ = param;
						_tmp1100_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1099_);
						_tmp1101_ = _tmp1100_;
						_tmp1102_ = vala_data_type_get_value_owned (_tmp1101_);
						_tmp1103_ = _tmp1102_;
						_tmp1104_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1098_, _tmp1103_, NULL, TRUE);
						temp_var = _tmp1104_;
						_tmp1105_ = temp_var;
						vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1105_);
						_tmp1106_ = arg;
						_tmp1107_ = temp_var;
						_tmp1108_ = vala_symbol_get_name ((ValaSymbol*) _tmp1107_);
						_tmp1109_ = _tmp1108_;
						_tmp1110_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1109_);
						_tmp1111_ = _tmp1110_;
						vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, _tmp1106_, _tmp1111_);
						_vala_ccode_node_unref0 (_tmp1111_);
						_tmp1112_ = arg;
						_tmp1113_ = vala_expression_get_target_value (_tmp1112_);
						_tmp1114_ = _tmp1113_;
						_tmp1115_ = arg;
						_tmp1116_ = vala_expression_get_target_type (_tmp1115_);
						_tmp1117_ = _tmp1116_;
						vala_target_value_set_value_type (_tmp1114_, _tmp1117_);
						_tmp1118_ = arg;
						_tmp1119_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp1118_);
						_tmp1120_ = _tmp1119_;
						_tmp1121_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1120_);
						_vala_ccode_node_unref0 (cexpr);
						cexpr = (ValaCCodeExpression*) _tmp1121_;
						_vala_ccode_node_unref0 (_tmp1120_);
						_tmp1123_ = param;
						_tmp1124_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp1123_);
						if (_tmp1124_) {
							ValaParameter* _tmp1125_ = NULL;
							ValaDataType* _tmp1126_ = NULL;
							ValaDataType* _tmp1127_ = NULL;
							_tmp1125_ = param;
							_tmp1126_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1125_);
							_tmp1127_ = _tmp1126_;
							_tmp1122_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1127_, VALA_TYPE_ARRAY_TYPE);
						} else {
							_tmp1122_ = FALSE;
						}
						if (_tmp1122_) {
							ValaArrayType* array_type = NULL;
							ValaParameter* _tmp1128_ = NULL;
							ValaDataType* _tmp1129_ = NULL;
							ValaDataType* _tmp1130_ = NULL;
							ValaArrayType* _tmp1131_ = NULL;
							ValaDataType* array_length_type = NULL;
							ValaDataType* _tmp1132_ = NULL;
							ValaDataType* _tmp1133_ = NULL;
							ValaParameter* _tmp1134_ = NULL;
							gchar* _tmp1135_ = NULL;
							gchar* _tmp1136_ = NULL;
							gboolean _tmp1137_ = FALSE;
							_tmp1128_ = param;
							_tmp1129_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1128_);
							_tmp1130_ = _tmp1129_;
							_tmp1131_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1130_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
							array_type = _tmp1131_;
							_tmp1132_ = ((ValaCCodeBaseModule*) self)->int_type;
							_tmp1133_ = _vala_code_node_ref0 (_tmp1132_);
							array_length_type = _tmp1133_;
							_tmp1134_ = param;
							_tmp1135_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp1134_);
							_tmp1136_ = _tmp1135_;
							_tmp1137_ = _tmp1136_ != NULL;
							_g_free0 (_tmp1136_);
							if (_tmp1137_) {
								ValaParameter* _tmp1138_ = NULL;
								gchar* _tmp1139_ = NULL;
								gchar* _tmp1140_ = NULL;
								ValaCType* _tmp1141_ = NULL;
								_tmp1138_ = param;
								_tmp1139_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp1138_);
								_tmp1140_ = _tmp1139_;
								_tmp1141_ = vala_ctype_new (_tmp1140_);
								_vala_code_node_unref0 (array_length_type);
								array_length_type = (ValaDataType*) _tmp1141_;
								_g_free0 (_tmp1140_);
							}
							{
								gint dim = 0;
								dim = 1;
								{
									gboolean _tmp1142_ = FALSE;
									_tmp1142_ = TRUE;
									while (TRUE) {
										gint _tmp1144_ = 0;
										ValaArrayType* _tmp1145_ = NULL;
										gint _tmp1146_ = 0;
										gint _tmp1147_ = 0;
										ValaLocalVariable* temp_array_length = NULL;
										ValaDataType* _tmp1148_ = NULL;
										ValaLocalVariable* _tmp1149_ = NULL;
										ValaLocalVariable* _tmp1150_ = NULL;
										ValaExpression* _tmp1151_ = NULL;
										ValaLocalVariable* _tmp1152_ = NULL;
										const gchar* _tmp1153_ = NULL;
										const gchar* _tmp1154_ = NULL;
										ValaCCodeExpression* _tmp1155_ = NULL;
										ValaCCodeExpression* _tmp1156_ = NULL;
										ValaHashMap* _tmp1157_ = NULL;
										ValaParameter* _tmp1158_ = NULL;
										gdouble _tmp1159_ = 0.0;
										gint _tmp1160_ = 0;
										gint _tmp1161_ = 0;
										ValaExpression* _tmp1162_ = NULL;
										ValaList* _tmp1163_ = NULL;
										ValaList* _tmp1164_ = NULL;
										gint _tmp1165_ = 0;
										gpointer _tmp1166_ = NULL;
										ValaCCodeExpression* _tmp1167_ = NULL;
										ValaCCodeUnaryExpression* _tmp1168_ = NULL;
										ValaCCodeUnaryExpression* _tmp1169_ = NULL;
										if (!_tmp1142_) {
											gint _tmp1143_ = 0;
											_tmp1143_ = dim;
											dim = _tmp1143_ + 1;
										}
										_tmp1142_ = FALSE;
										_tmp1144_ = dim;
										_tmp1145_ = array_type;
										_tmp1146_ = vala_array_type_get_rank (_tmp1145_);
										_tmp1147_ = _tmp1146_;
										if (!(_tmp1144_ <= _tmp1147_)) {
											break;
										}
										_tmp1148_ = array_length_type;
										_tmp1149_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1148_, TRUE, NULL, TRUE);
										temp_array_length = _tmp1149_;
										_tmp1150_ = temp_array_length;
										vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1150_);
										_tmp1151_ = arg;
										_tmp1152_ = temp_array_length;
										_tmp1153_ = vala_symbol_get_name ((ValaSymbol*) _tmp1152_);
										_tmp1154_ = _tmp1153_;
										_tmp1155_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1154_);
										_tmp1156_ = _tmp1155_;
										vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, _tmp1151_, _tmp1156_);
										_vala_ccode_node_unref0 (_tmp1156_);
										_tmp1157_ = carg_map;
										_tmp1158_ = param;
										_tmp1159_ = vala_ccode_base_module_get_ccode_array_length_pos ((ValaCodeNode*) _tmp1158_);
										_tmp1160_ = dim;
										_tmp1161_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1159_ + (0.01 * _tmp1160_), FALSE);
										_tmp1162_ = arg;
										_tmp1163_ = vala_ccode_base_module_get_array_lengths ((ValaCCodeBaseModule*) self, _tmp1162_);
										_tmp1164_ = _tmp1163_;
										_tmp1165_ = dim;
										_tmp1166_ = vala_list_get (_tmp1164_, _tmp1165_ - 1);
										_tmp1167_ = (ValaCCodeExpression*) _tmp1166_;
										_tmp1168_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1167_);
										_tmp1169_ = _tmp1168_;
										vala_map_set ((ValaMap*) _tmp1157_, (gpointer) ((gintptr) _tmp1161_), (ValaCCodeExpression*) _tmp1169_);
										_vala_ccode_node_unref0 (_tmp1169_);
										_vala_ccode_node_unref0 (_tmp1167_);
										_vala_iterable_unref0 (_tmp1164_);
										_vala_code_node_unref0 (temp_array_length);
									}
								}
							}
							_vala_code_node_unref0 (array_length_type);
							_vala_code_node_unref0 (array_type);
						} else {
							ValaParameter* _tmp1170_ = NULL;
							ValaDataType* _tmp1171_ = NULL;
							ValaDataType* _tmp1172_ = NULL;
							_tmp1170_ = param;
							_tmp1171_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1170_);
							_tmp1172_ = _tmp1171_;
							if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1172_, VALA_TYPE_DELEGATE_TYPE)) {
								ValaDelegateType* deleg_type = NULL;
								ValaParameter* _tmp1173_ = NULL;
								ValaDataType* _tmp1174_ = NULL;
								ValaDataType* _tmp1175_ = NULL;
								ValaDelegateType* _tmp1176_ = NULL;
								ValaDelegate* d = NULL;
								ValaDelegateType* _tmp1177_ = NULL;
								ValaDelegate* _tmp1178_ = NULL;
								ValaDelegate* _tmp1179_ = NULL;
								ValaDelegate* _tmp1180_ = NULL;
								ValaDelegate* _tmp1181_ = NULL;
								gboolean _tmp1182_ = FALSE;
								gboolean _tmp1183_ = FALSE;
								_tmp1173_ = param;
								_tmp1174_ = vala_variable_get_variable_type ((ValaVariable*) _tmp1173_);
								_tmp1175_ = _tmp1174_;
								_tmp1176_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1175_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
								deleg_type = _tmp1176_;
								_tmp1177_ = deleg_type;
								_tmp1178_ = vala_delegate_type_get_delegate_symbol (_tmp1177_);
								_tmp1179_ = _tmp1178_;
								_tmp1180_ = _vala_code_node_ref0 (_tmp1179_);
								d = _tmp1180_;
								_tmp1181_ = d;
								_tmp1182_ = vala_delegate_get_has_target (_tmp1181_);
								_tmp1183_ = _tmp1182_;
								if (_tmp1183_) {
									ValaVoidType* _tmp1184_ = NULL;
									ValaVoidType* _tmp1185_ = NULL;
									ValaPointerType* _tmp1186_ = NULL;
									ValaPointerType* _tmp1187_ = NULL;
									ValaLocalVariable* _tmp1188_ = NULL;
									ValaLocalVariable* _tmp1189_ = NULL;
									ValaExpression* _tmp1190_ = NULL;
									ValaLocalVariable* _tmp1191_ = NULL;
									const gchar* _tmp1192_ = NULL;
									const gchar* _tmp1193_ = NULL;
									ValaCCodeExpression* _tmp1194_ = NULL;
									ValaCCodeExpression* _tmp1195_ = NULL;
									ValaHashMap* _tmp1196_ = NULL;
									ValaParameter* _tmp1197_ = NULL;
									gdouble _tmp1198_ = 0.0;
									gint _tmp1199_ = 0;
									ValaExpression* _tmp1200_ = NULL;
									ValaCCodeExpression* _tmp1201_ = NULL;
									ValaCCodeExpression* _tmp1202_ = NULL;
									ValaCCodeUnaryExpression* _tmp1203_ = NULL;
									ValaCCodeUnaryExpression* _tmp1204_ = NULL;
									ValaDelegateType* _tmp1205_ = NULL;
									gboolean _tmp1206_ = FALSE;
									_tmp1184_ = vala_void_type_new (NULL);
									_tmp1185_ = _tmp1184_;
									_tmp1186_ = vala_pointer_type_new ((ValaDataType*) _tmp1185_, NULL);
									_tmp1187_ = _tmp1186_;
									_tmp1188_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1187_, TRUE, NULL, TRUE);
									_vala_code_node_unref0 (temp_var);
									temp_var = _tmp1188_;
									_vala_code_node_unref0 (_tmp1187_);
									_vala_code_node_unref0 (_tmp1185_);
									_tmp1189_ = temp_var;
									vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1189_);
									_tmp1190_ = arg;
									_tmp1191_ = temp_var;
									_tmp1192_ = vala_symbol_get_name ((ValaSymbol*) _tmp1191_);
									_tmp1193_ = _tmp1192_;
									_tmp1194_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1193_);
									_tmp1195_ = _tmp1194_;
									vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, _tmp1190_, _tmp1195_);
									_vala_ccode_node_unref0 (_tmp1195_);
									_tmp1196_ = carg_map;
									_tmp1197_ = param;
									_tmp1198_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1197_);
									_tmp1199_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1198_, FALSE);
									_tmp1200_ = arg;
									_tmp1201_ = vala_ccode_base_module_get_delegate_target ((ValaCCodeBaseModule*) self, _tmp1200_);
									_tmp1202_ = _tmp1201_;
									_tmp1203_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1202_);
									_tmp1204_ = _tmp1203_;
									vala_map_set ((ValaMap*) _tmp1196_, (gpointer) ((gintptr) _tmp1199_), (ValaCCodeExpression*) _tmp1204_);
									_vala_ccode_node_unref0 (_tmp1204_);
									_vala_ccode_node_unref0 (_tmp1202_);
									_tmp1205_ = deleg_type;
									_tmp1206_ = vala_data_type_is_disposable ((ValaDataType*) _tmp1205_);
									if (_tmp1206_) {
										ValaDataType* _tmp1207_ = NULL;
										ValaLocalVariable* _tmp1208_ = NULL;
										ValaLocalVariable* _tmp1209_ = NULL;
										ValaExpression* _tmp1210_ = NULL;
										ValaLocalVariable* _tmp1211_ = NULL;
										const gchar* _tmp1212_ = NULL;
										const gchar* _tmp1213_ = NULL;
										ValaCCodeExpression* _tmp1214_ = NULL;
										ValaCCodeExpression* _tmp1215_ = NULL;
										ValaHashMap* _tmp1216_ = NULL;
										ValaParameter* _tmp1217_ = NULL;
										gdouble _tmp1218_ = 0.0;
										gint _tmp1219_ = 0;
										ValaExpression* _tmp1220_ = NULL;
										ValaCCodeExpression* _tmp1221_ = NULL;
										ValaCCodeExpression* _tmp1222_ = NULL;
										ValaCCodeUnaryExpression* _tmp1223_ = NULL;
										ValaCCodeUnaryExpression* _tmp1224_ = NULL;
										_tmp1207_ = ((ValaCCodeBaseModule*) self)->gdestroynotify_type;
										_tmp1208_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1207_, TRUE, NULL, TRUE);
										_vala_code_node_unref0 (temp_var);
										temp_var = _tmp1208_;
										_tmp1209_ = temp_var;
										vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1209_);
										_tmp1210_ = arg;
										_tmp1211_ = temp_var;
										_tmp1212_ = vala_symbol_get_name ((ValaSymbol*) _tmp1211_);
										_tmp1213_ = _tmp1212_;
										_tmp1214_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1213_);
										_tmp1215_ = _tmp1214_;
										vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, _tmp1210_, _tmp1215_);
										_vala_ccode_node_unref0 (_tmp1215_);
										_tmp1216_ = carg_map;
										_tmp1217_ = param;
										_tmp1218_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1217_);
										_tmp1219_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1218_ + 0.01, FALSE);
										_tmp1220_ = arg;
										_tmp1221_ = vala_ccode_base_module_get_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, _tmp1220_);
										_tmp1222_ = _tmp1221_;
										_tmp1223_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1222_);
										_tmp1224_ = _tmp1223_;
										vala_map_set ((ValaMap*) _tmp1216_, (gpointer) ((gintptr) _tmp1219_), (ValaCCodeExpression*) _tmp1224_);
										_vala_ccode_node_unref0 (_tmp1224_);
										_vala_ccode_node_unref0 (_tmp1222_);
									}
								}
								_vala_code_node_unref0 (d);
								_vala_code_node_unref0 (deleg_type);
							}
						}
						_vala_code_node_unref0 (temp_var);
					}
					_tmp1225_ = param;
					_tmp1226_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1225_);
					_tmp1227_ = _tmp1226_;
					_tmp1228_ = _tmp1227_ != NULL;
					_g_free0 (_tmp1227_);
					if (_tmp1228_) {
						ValaCCodeExpression* _tmp1229_ = NULL;
						ValaParameter* _tmp1230_ = NULL;
						gchar* _tmp1231_ = NULL;
						gchar* _tmp1232_ = NULL;
						ValaCCodeCastExpression* _tmp1233_ = NULL;
						_tmp1229_ = cexpr;
						_tmp1230_ = param;
						_tmp1231_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1230_);
						_tmp1232_ = _tmp1231_;
						_tmp1233_ = vala_ccode_cast_expression_new (_tmp1229_, _tmp1232_);
						_vala_ccode_node_unref0 (cexpr);
						cexpr = (ValaCCodeExpression*) _tmp1233_;
						_g_free0 (_tmp1232_);
					}
					_vala_code_node_unref0 (unary);
				} else {
					ValaExpression* _tmp1234_ = NULL;
					ValaCCodeExpression* _tmp1235_ = NULL;
					ValaCCodeExpression* _tmp1236_ = NULL;
					_tmp1234_ = arg;
					_tmp1235_ = cexpr;
					_tmp1236_ = vala_ccode_base_module_handle_struct_argument ((ValaCCodeBaseModule*) self, NULL, _tmp1234_, _tmp1235_);
					_vala_ccode_node_unref0 (cexpr);
					cexpr = _tmp1236_;
				}
				_tmp1237_ = param;
				_tmp1238_ = vala_ccode_base_module_get_ccode_pos (_tmp1237_);
				_tmp1239_ = ellipsis;
				_tmp1240_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1238_, _tmp1239_);
				arg_pos = _tmp1240_;
				_vala_code_node_unref0 (param);
			} else {
				ValaExpression* _tmp1241_ = NULL;
				ValaCCodeExpression* _tmp1242_ = NULL;
				ValaCCodeExpression* _tmp1243_ = NULL;
				gint _tmp1244_ = 0;
				gboolean _tmp1245_ = FALSE;
				gint _tmp1246_ = 0;
				_tmp1241_ = arg;
				_tmp1242_ = cexpr;
				_tmp1243_ = vala_ccode_base_module_handle_struct_argument ((ValaCCodeBaseModule*) self, NULL, _tmp1241_, _tmp1242_);
				_vala_ccode_node_unref0 (cexpr);
				cexpr = _tmp1243_;
				_tmp1244_ = i;
				_tmp1245_ = ellipsis;
				_tmp1246_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) _tmp1244_, _tmp1245_);
				arg_pos = _tmp1246_;
			}
			_tmp1247_ = carg_map;
			_tmp1248_ = arg_pos;
			_tmp1249_ = cexpr;
			vala_map_set ((ValaMap*) _tmp1247_, (gpointer) ((gintptr) _tmp1248_), _tmp1249_);
			_tmp1251_ = arg;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1251_, VALA_TYPE_NAMED_ARGUMENT)) {
				gboolean _tmp1252_ = FALSE;
				_tmp1252_ = ellipsis;
				_tmp1250_ = _tmp1252_;
			} else {
				_tmp1250_ = FALSE;
			}
			if (_tmp1250_) {
				ValaNamedArgument* named_arg = NULL;
				ValaExpression* _tmp1253_ = NULL;
				ValaNamedArgument* _tmp1254_ = NULL;
				gchar* name = NULL;
				ValaNamedArgument* _tmp1255_ = NULL;
				const gchar* _tmp1256_ = NULL;
				const gchar* _tmp1257_ = NULL;
				gchar** _tmp1258_ = NULL;
				gchar** _tmp1259_ = NULL;
				gchar** _tmp1260_ = NULL;
				gint _tmp1260__length1 = 0;
				gchar* _tmp1261_ = NULL;
				gchar* _tmp1262_ = NULL;
				ValaHashMap* _tmp1263_ = NULL;
				gint _tmp1264_ = 0;
				gboolean _tmp1265_ = FALSE;
				gint _tmp1266_ = 0;
				const gchar* _tmp1267_ = NULL;
				gchar* _tmp1268_ = NULL;
				gchar* _tmp1269_ = NULL;
				ValaCCodeConstant* _tmp1270_ = NULL;
				ValaCCodeConstant* _tmp1271_ = NULL;
				_tmp1253_ = arg;
				_tmp1254_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1253_, VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgument));
				named_arg = _tmp1254_;
				_tmp1255_ = named_arg;
				_tmp1256_ = vala_named_argument_get_name (_tmp1255_);
				_tmp1257_ = _tmp1256_;
				_tmp1259_ = _tmp1258_ = g_strsplit (_tmp1257_, "_", 0);
				_tmp1260_ = _tmp1259_;
				_tmp1260__length1 = _vala_array_length (_tmp1258_);
				_tmp1261_ = _vala_g_strjoinv ("-", _tmp1260_, _vala_array_length (_tmp1258_));
				_tmp1262_ = _tmp1261_;
				_tmp1260_ = (_vala_array_free (_tmp1260_, _tmp1260__length1, (GDestroyNotify) g_free), NULL);
				name = _tmp1262_;
				_tmp1263_ = carg_map;
				_tmp1264_ = i;
				_tmp1265_ = ellipsis;
				_tmp1266_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1264_ - 0.1, _tmp1265_);
				_tmp1267_ = name;
				_tmp1268_ = g_strdup_printf ("\"%s\"", _tmp1267_);
				_tmp1269_ = _tmp1268_;
				_tmp1270_ = vala_ccode_constant_new (_tmp1269_);
				_tmp1271_ = _tmp1270_;
				vala_map_set ((ValaMap*) _tmp1263_, (gpointer) ((gintptr) _tmp1266_), (ValaCCodeExpression*) _tmp1271_);
				_vala_ccode_node_unref0 (_tmp1271_);
				_g_free0 (_tmp1269_);
				_g_free0 (name);
				_vala_code_node_unref0 (named_arg);
			}
			_tmp1272_ = i;
			i = _tmp1272_ + 1;
			_vala_map_unref0 (carg_map);
			_vala_ccode_node_unref0 (cexpr);
			_vala_code_node_unref0 (arg);
		}
		_vala_iterable_unref0 (_arg_list);
	}
	_tmp1273_ = params_it;
	_tmp1274_ = vala_iterator_next (_tmp1273_);
	if (_tmp1274_) {
		ValaParameter* param = NULL;
		ValaIterator* _tmp1275_ = NULL;
		gpointer _tmp1276_ = NULL;
		gboolean _tmp1277_ = FALSE;
		ValaParameter* _tmp1278_ = NULL;
		gboolean _tmp1279_ = FALSE;
		gboolean _tmp1280_ = FALSE;
		_tmp1275_ = params_it;
		_tmp1276_ = vala_iterator_get (_tmp1275_);
		param = (ValaParameter*) _tmp1276_;
		_tmp1278_ = param;
		_tmp1279_ = vala_parameter_get_params_array (_tmp1278_);
		_tmp1280_ = _tmp1279_;
		if (_tmp1280_) {
			_tmp1277_ = TRUE;
		} else {
			ValaParameter* _tmp1281_ = NULL;
			gboolean _tmp1282_ = FALSE;
			gboolean _tmp1283_ = FALSE;
			_tmp1281_ = param;
			_tmp1282_ = vala_parameter_get_ellipsis (_tmp1281_);
			_tmp1283_ = _tmp1282_;
			_tmp1277_ = _tmp1283_;
		}
		_vala_assert (_tmp1277_, "param.params_array || param.ellipsis");
		ellipsis = TRUE;
		_vala_code_node_unref0 (param);
	}
	_tmp1286_ = m;
	if (_tmp1286_ != NULL) {
		ValaMethod* _tmp1287_ = NULL;
		ValaDataType* _tmp1288_ = NULL;
		ValaDataType* _tmp1289_ = NULL;
		_tmp1287_ = m;
		_tmp1288_ = vala_method_get_return_type (_tmp1287_);
		_tmp1289_ = _tmp1288_;
		_tmp1285_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1289_, VALA_TYPE_ARRAY_TYPE);
	} else {
		_tmp1285_ = FALSE;
	}
	if (_tmp1285_) {
		ValaCCodeFunctionCall* _tmp1290_ = NULL;
		ValaCCodeFunctionCall* _tmp1291_ = NULL;
		_tmp1290_ = async_call;
		_tmp1291_ = ccall;
		_tmp1284_ = _tmp1290_ != _tmp1291_;
	} else {
		_tmp1284_ = FALSE;
	}
	if (_tmp1284_) {
		ValaArrayType* array_type = NULL;
		ValaMethod* _tmp1292_ = NULL;
		ValaDataType* _tmp1293_ = NULL;
		ValaDataType* _tmp1294_ = NULL;
		ValaArrayType* _tmp1295_ = NULL;
		_tmp1292_ = m;
		_tmp1293_ = vala_method_get_return_type (_tmp1292_);
		_tmp1294_ = _tmp1293_;
		_tmp1295_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1294_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		array_type = _tmp1295_;
		{
			gint dim = 0;
			dim = 1;
			{
				gboolean _tmp1296_ = FALSE;
				_tmp1296_ = TRUE;
				while (TRUE) {
					gint _tmp1298_ = 0;
					ValaArrayType* _tmp1299_ = NULL;
					gint _tmp1300_ = 0;
					gint _tmp1301_ = 0;
					ValaMethod* _tmp1302_ = NULL;
					gboolean _tmp1303_ = FALSE;
					if (!_tmp1296_) {
						gint _tmp1297_ = 0;
						_tmp1297_ = dim;
						dim = _tmp1297_ + 1;
					}
					_tmp1296_ = FALSE;
					_tmp1298_ = dim;
					_tmp1299_ = array_type;
					_tmp1300_ = vala_array_type_get_rank (_tmp1299_);
					_tmp1301_ = _tmp1300_;
					if (!(_tmp1298_ <= _tmp1301_)) {
						break;
					}
					_tmp1302_ = m;
					_tmp1303_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp1302_);
					if (_tmp1303_) {
						ValaLocalVariable* temp_var = NULL;
						ValaDataType* _tmp1304_ = NULL;
						ValaDataType* _tmp1305_ = NULL;
						ValaDataType* _tmp1306_ = NULL;
						ValaLocalVariable* _tmp1307_ = NULL;
						ValaLocalVariable* _tmp1308_ = NULL;
						ValaCCodeExpression* temp_ref = NULL;
						ValaLocalVariable* _tmp1309_ = NULL;
						const gchar* _tmp1310_ = NULL;
						const gchar* _tmp1311_ = NULL;
						ValaCCodeExpression* _tmp1312_ = NULL;
						ValaLocalVariable* _tmp1313_ = NULL;
						ValaCCodeExpression* _tmp1314_ = NULL;
						ValaCCodeExpression* _tmp1315_ = NULL;
						ValaCCodeAssignment* _tmp1316_ = NULL;
						ValaCCodeFunctionCall* len_call = NULL;
						ValaCCodeIdentifier* _tmp1317_ = NULL;
						ValaCCodeIdentifier* _tmp1318_ = NULL;
						ValaCCodeFunctionCall* _tmp1319_ = NULL;
						ValaCCodeFunctionCall* _tmp1320_ = NULL;
						ValaCCodeFunctionCall* _tmp1321_ = NULL;
						ValaCCodeExpression* _tmp1322_ = NULL;
						ValaMethodCall* _tmp1323_ = NULL;
						ValaCCodeFunctionCall* _tmp1324_ = NULL;
						_tmp1304_ = itype;
						_tmp1305_ = vala_data_type_get_return_type (_tmp1304_);
						_tmp1306_ = _tmp1305_;
						_tmp1307_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1306_, TRUE, NULL, FALSE);
						_tmp1308_ = _tmp1307_;
						_vala_code_node_unref0 (_tmp1306_);
						temp_var = _tmp1308_;
						_tmp1309_ = temp_var;
						_tmp1310_ = vala_symbol_get_name ((ValaSymbol*) _tmp1309_);
						_tmp1311_ = _tmp1310_;
						_tmp1312_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1311_);
						temp_ref = _tmp1312_;
						_tmp1313_ = temp_var;
						vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1313_);
						_tmp1314_ = temp_ref;
						_tmp1315_ = ccall_expr;
						_tmp1316_ = vala_ccode_assignment_new (_tmp1314_, _tmp1315_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
						_vala_ccode_node_unref0 (ccall_expr);
						ccall_expr = (ValaCCodeExpression*) _tmp1316_;
						((ValaCCodeBaseModule*) self)->requires_array_length = TRUE;
						_tmp1317_ = vala_ccode_identifier_new ("_vala_array_length");
						_tmp1318_ = _tmp1317_;
						_tmp1319_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1318_);
						_tmp1320_ = _tmp1319_;
						_vala_ccode_node_unref0 (_tmp1318_);
						len_call = _tmp1320_;
						_tmp1321_ = len_call;
						_tmp1322_ = temp_ref;
						vala_ccode_function_call_add_argument (_tmp1321_, _tmp1322_);
						_tmp1323_ = expr;
						_tmp1324_ = len_call;
						vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1323_, (ValaCCodeExpression*) _tmp1324_);
						_vala_ccode_node_unref0 (len_call);
						_vala_ccode_node_unref0 (temp_ref);
						_vala_code_node_unref0 (temp_var);
					} else {
						ValaMethod* _tmp1325_ = NULL;
						gboolean _tmp1326_ = FALSE;
						_tmp1325_ = m;
						_tmp1326_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp1325_);
						if (_tmp1326_) {
							ValaLocalVariable* temp_var = NULL;
							ValaMethod* _tmp1327_ = NULL;
							gchar* _tmp1328_ = NULL;
							gchar* _tmp1329_ = NULL;
							gboolean _tmp1330_ = FALSE;
							ValaCCodeExpression* temp_ref = NULL;
							ValaLocalVariable* _tmp1339_ = NULL;
							const gchar* _tmp1340_ = NULL;
							const gchar* _tmp1341_ = NULL;
							ValaCCodeExpression* _tmp1342_ = NULL;
							ValaLocalVariable* _tmp1343_ = NULL;
							ValaHashMap* _tmp1344_ = NULL;
							ValaMethod* _tmp1345_ = NULL;
							gdouble _tmp1346_ = 0.0;
							gint _tmp1347_ = 0;
							gint _tmp1348_ = 0;
							ValaCCodeExpression* _tmp1349_ = NULL;
							ValaCCodeUnaryExpression* _tmp1350_ = NULL;
							ValaCCodeUnaryExpression* _tmp1351_ = NULL;
							ValaMethodCall* _tmp1352_ = NULL;
							ValaCCodeExpression* _tmp1353_ = NULL;
							_tmp1327_ = m;
							_tmp1328_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp1327_);
							_tmp1329_ = _tmp1328_;
							_tmp1330_ = _tmp1329_ == NULL;
							_g_free0 (_tmp1329_);
							if (_tmp1330_) {
								ValaDataType* _tmp1331_ = NULL;
								ValaLocalVariable* _tmp1332_ = NULL;
								_tmp1331_ = ((ValaCCodeBaseModule*) self)->int_type;
								_tmp1332_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1331_, TRUE, NULL, TRUE);
								_vala_code_node_unref0 (temp_var);
								temp_var = _tmp1332_;
							} else {
								ValaMethod* _tmp1333_ = NULL;
								gchar* _tmp1334_ = NULL;
								gchar* _tmp1335_ = NULL;
								ValaCType* _tmp1336_ = NULL;
								ValaCType* _tmp1337_ = NULL;
								ValaLocalVariable* _tmp1338_ = NULL;
								_tmp1333_ = m;
								_tmp1334_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp1333_);
								_tmp1335_ = _tmp1334_;
								_tmp1336_ = vala_ctype_new (_tmp1335_);
								_tmp1337_ = _tmp1336_;
								_tmp1338_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1337_, TRUE, NULL, TRUE);
								_vala_code_node_unref0 (temp_var);
								temp_var = _tmp1338_;
								_vala_code_node_unref0 (_tmp1337_);
								_g_free0 (_tmp1335_);
							}
							_tmp1339_ = temp_var;
							_tmp1340_ = vala_symbol_get_name ((ValaSymbol*) _tmp1339_);
							_tmp1341_ = _tmp1340_;
							_tmp1342_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1341_);
							temp_ref = _tmp1342_;
							_tmp1343_ = temp_var;
							vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1343_);
							_tmp1344_ = out_arg_map;
							_tmp1345_ = m;
							_tmp1346_ = vala_ccode_base_module_get_ccode_array_length_pos ((ValaCodeNode*) _tmp1345_);
							_tmp1347_ = dim;
							_tmp1348_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1346_ + (0.01 * _tmp1347_), FALSE);
							_tmp1349_ = temp_ref;
							_tmp1350_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1349_);
							_tmp1351_ = _tmp1350_;
							vala_map_set ((ValaMap*) _tmp1344_, (gpointer) ((gintptr) _tmp1348_), (ValaCCodeExpression*) _tmp1351_);
							_vala_ccode_node_unref0 (_tmp1351_);
							_tmp1352_ = expr;
							_tmp1353_ = temp_ref;
							vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1352_, _tmp1353_);
							_vala_ccode_node_unref0 (temp_ref);
							_vala_code_node_unref0 (temp_var);
						} else {
							ValaMethodCall* _tmp1354_ = NULL;
							ValaCCodeConstant* _tmp1355_ = NULL;
							ValaCCodeConstant* _tmp1356_ = NULL;
							_tmp1354_ = expr;
							_tmp1355_ = vala_ccode_constant_new ("-1");
							_tmp1356_ = _tmp1355_;
							vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1354_, (ValaCCodeExpression*) _tmp1356_);
							_vala_ccode_node_unref0 (_tmp1356_);
						}
					}
				}
			}
		}
		_vala_code_node_unref0 (array_type);
	} else {
		gboolean _tmp1357_ = FALSE;
		gboolean _tmp1358_ = FALSE;
		ValaMethod* _tmp1359_ = NULL;
		_tmp1359_ = m;
		if (_tmp1359_ != NULL) {
			ValaMethod* _tmp1360_ = NULL;
			ValaDataType* _tmp1361_ = NULL;
			ValaDataType* _tmp1362_ = NULL;
			_tmp1360_ = m;
			_tmp1361_ = vala_method_get_return_type (_tmp1360_);
			_tmp1362_ = _tmp1361_;
			_tmp1358_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1362_, VALA_TYPE_DELEGATE_TYPE);
		} else {
			_tmp1358_ = FALSE;
		}
		if (_tmp1358_) {
			ValaCCodeFunctionCall* _tmp1363_ = NULL;
			ValaCCodeFunctionCall* _tmp1364_ = NULL;
			_tmp1363_ = async_call;
			_tmp1364_ = ccall;
			_tmp1357_ = _tmp1363_ != _tmp1364_;
		} else {
			_tmp1357_ = FALSE;
		}
		if (_tmp1357_) {
			ValaDelegateType* deleg_type = NULL;
			ValaMethod* _tmp1365_ = NULL;
			ValaDataType* _tmp1366_ = NULL;
			ValaDataType* _tmp1367_ = NULL;
			ValaDelegateType* _tmp1368_ = NULL;
			ValaDelegate* d = NULL;
			ValaDelegateType* _tmp1369_ = NULL;
			ValaDelegate* _tmp1370_ = NULL;
			ValaDelegate* _tmp1371_ = NULL;
			ValaDelegate* _tmp1372_ = NULL;
			ValaDelegate* _tmp1373_ = NULL;
			gboolean _tmp1374_ = FALSE;
			gboolean _tmp1375_ = FALSE;
			_tmp1365_ = m;
			_tmp1366_ = vala_method_get_return_type (_tmp1365_);
			_tmp1367_ = _tmp1366_;
			_tmp1368_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1367_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
			deleg_type = _tmp1368_;
			_tmp1369_ = deleg_type;
			_tmp1370_ = vala_delegate_type_get_delegate_symbol (_tmp1369_);
			_tmp1371_ = _tmp1370_;
			_tmp1372_ = _vala_code_node_ref0 (_tmp1371_);
			d = _tmp1372_;
			_tmp1373_ = d;
			_tmp1374_ = vala_delegate_get_has_target (_tmp1373_);
			_tmp1375_ = _tmp1374_;
			if (_tmp1375_) {
				ValaLocalVariable* temp_var = NULL;
				ValaVoidType* _tmp1376_ = NULL;
				ValaVoidType* _tmp1377_ = NULL;
				ValaPointerType* _tmp1378_ = NULL;
				ValaPointerType* _tmp1379_ = NULL;
				ValaLocalVariable* _tmp1380_ = NULL;
				ValaLocalVariable* _tmp1381_ = NULL;
				ValaCCodeExpression* temp_ref = NULL;
				ValaLocalVariable* _tmp1382_ = NULL;
				const gchar* _tmp1383_ = NULL;
				const gchar* _tmp1384_ = NULL;
				ValaCCodeExpression* _tmp1385_ = NULL;
				ValaLocalVariable* _tmp1386_ = NULL;
				ValaHashMap* _tmp1387_ = NULL;
				ValaMethod* _tmp1388_ = NULL;
				gdouble _tmp1389_ = 0.0;
				gint _tmp1390_ = 0;
				ValaCCodeExpression* _tmp1391_ = NULL;
				ValaCCodeUnaryExpression* _tmp1392_ = NULL;
				ValaCCodeUnaryExpression* _tmp1393_ = NULL;
				ValaMethodCall* _tmp1394_ = NULL;
				ValaCCodeExpression* _tmp1395_ = NULL;
				ValaDelegateType* _tmp1396_ = NULL;
				gboolean _tmp1397_ = FALSE;
				_tmp1376_ = vala_void_type_new (NULL);
				_tmp1377_ = _tmp1376_;
				_tmp1378_ = vala_pointer_type_new ((ValaDataType*) _tmp1377_, NULL);
				_tmp1379_ = _tmp1378_;
				_tmp1380_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1379_, TRUE, NULL, TRUE);
				_tmp1381_ = _tmp1380_;
				_vala_code_node_unref0 (_tmp1379_);
				_vala_code_node_unref0 (_tmp1377_);
				temp_var = _tmp1381_;
				_tmp1382_ = temp_var;
				_tmp1383_ = vala_symbol_get_name ((ValaSymbol*) _tmp1382_);
				_tmp1384_ = _tmp1383_;
				_tmp1385_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1384_);
				temp_ref = _tmp1385_;
				_tmp1386_ = temp_var;
				vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1386_);
				_tmp1387_ = out_arg_map;
				_tmp1388_ = m;
				_tmp1389_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1388_);
				_tmp1390_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1389_, FALSE);
				_tmp1391_ = temp_ref;
				_tmp1392_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1391_);
				_tmp1393_ = _tmp1392_;
				vala_map_set ((ValaMap*) _tmp1387_, (gpointer) ((gintptr) _tmp1390_), (ValaCCodeExpression*) _tmp1393_);
				_vala_ccode_node_unref0 (_tmp1393_);
				_tmp1394_ = expr;
				_tmp1395_ = temp_ref;
				vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1394_, _tmp1395_);
				_tmp1396_ = deleg_type;
				_tmp1397_ = vala_data_type_is_disposable ((ValaDataType*) _tmp1396_);
				if (_tmp1397_) {
					ValaDataType* _tmp1398_ = NULL;
					ValaLocalVariable* _tmp1399_ = NULL;
					ValaLocalVariable* _tmp1400_ = NULL;
					const gchar* _tmp1401_ = NULL;
					const gchar* _tmp1402_ = NULL;
					ValaCCodeExpression* _tmp1403_ = NULL;
					ValaLocalVariable* _tmp1404_ = NULL;
					ValaHashMap* _tmp1405_ = NULL;
					ValaMethod* _tmp1406_ = NULL;
					gdouble _tmp1407_ = 0.0;
					gint _tmp1408_ = 0;
					ValaCCodeExpression* _tmp1409_ = NULL;
					ValaCCodeUnaryExpression* _tmp1410_ = NULL;
					ValaCCodeUnaryExpression* _tmp1411_ = NULL;
					ValaMethodCall* _tmp1412_ = NULL;
					ValaCCodeExpression* _tmp1413_ = NULL;
					_tmp1398_ = ((ValaCCodeBaseModule*) self)->gdestroynotify_type;
					_tmp1399_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1398_, TRUE, NULL, TRUE);
					_vala_code_node_unref0 (temp_var);
					temp_var = _tmp1399_;
					_tmp1400_ = temp_var;
					_tmp1401_ = vala_symbol_get_name ((ValaSymbol*) _tmp1400_);
					_tmp1402_ = _tmp1401_;
					_tmp1403_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1402_);
					_vala_ccode_node_unref0 (temp_ref);
					temp_ref = _tmp1403_;
					_tmp1404_ = temp_var;
					vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1404_);
					_tmp1405_ = out_arg_map;
					_tmp1406_ = m;
					_tmp1407_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1406_);
					_tmp1408_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1407_ + 0.01, FALSE);
					_tmp1409_ = temp_ref;
					_tmp1410_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1409_);
					_tmp1411_ = _tmp1410_;
					vala_map_set ((ValaMap*) _tmp1405_, (gpointer) ((gintptr) _tmp1408_), (ValaCCodeExpression*) _tmp1411_);
					_vala_ccode_node_unref0 (_tmp1411_);
					_tmp1412_ = expr;
					_tmp1413_ = temp_ref;
					vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1412_, _tmp1413_);
				} else {
					ValaMethodCall* _tmp1414_ = NULL;
					ValaCCodeConstant* _tmp1415_ = NULL;
					ValaCCodeConstant* _tmp1416_ = NULL;
					_tmp1414_ = expr;
					_tmp1415_ = vala_ccode_constant_new ("NULL");
					_tmp1416_ = _tmp1415_;
					vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1414_, (ValaCCodeExpression*) _tmp1416_);
					_vala_ccode_node_unref0 (_tmp1416_);
				}
				_vala_ccode_node_unref0 (temp_ref);
				_vala_code_node_unref0 (temp_var);
			} else {
				ValaMethodCall* _tmp1417_ = NULL;
				ValaCCodeConstant* _tmp1418_ = NULL;
				ValaCCodeConstant* _tmp1419_ = NULL;
				_tmp1417_ = expr;
				_tmp1418_ = vala_ccode_constant_new ("NULL");
				_tmp1419_ = _tmp1418_;
				vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1417_, (ValaCCodeExpression*) _tmp1419_);
				_vala_ccode_node_unref0 (_tmp1419_);
			}
			_vala_code_node_unref0 (d);
			_vala_code_node_unref0 (deleg_type);
		}
	}
	_tmp1421_ = deleg;
	if (_tmp1421_ != NULL) {
		ValaDelegate* _tmp1422_ = NULL;
		ValaDataType* _tmp1423_ = NULL;
		ValaDataType* _tmp1424_ = NULL;
		_tmp1422_ = deleg;
		_tmp1423_ = vala_delegate_get_return_type (_tmp1422_);
		_tmp1424_ = _tmp1423_;
		_tmp1420_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1424_, VALA_TYPE_ARRAY_TYPE);
	} else {
		_tmp1420_ = FALSE;
	}
	if (_tmp1420_) {
		ValaArrayType* array_type = NULL;
		ValaDelegate* _tmp1425_ = NULL;
		ValaDataType* _tmp1426_ = NULL;
		ValaDataType* _tmp1427_ = NULL;
		ValaArrayType* _tmp1428_ = NULL;
		_tmp1425_ = deleg;
		_tmp1426_ = vala_delegate_get_return_type (_tmp1425_);
		_tmp1427_ = _tmp1426_;
		_tmp1428_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1427_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		array_type = _tmp1428_;
		{
			gint dim = 0;
			dim = 1;
			{
				gboolean _tmp1429_ = FALSE;
				_tmp1429_ = TRUE;
				while (TRUE) {
					gint _tmp1431_ = 0;
					ValaArrayType* _tmp1432_ = NULL;
					gint _tmp1433_ = 0;
					gint _tmp1434_ = 0;
					ValaDelegate* _tmp1435_ = NULL;
					gboolean _tmp1436_ = FALSE;
					if (!_tmp1429_) {
						gint _tmp1430_ = 0;
						_tmp1430_ = dim;
						dim = _tmp1430_ + 1;
					}
					_tmp1429_ = FALSE;
					_tmp1431_ = dim;
					_tmp1432_ = array_type;
					_tmp1433_ = vala_array_type_get_rank (_tmp1432_);
					_tmp1434_ = _tmp1433_;
					if (!(_tmp1431_ <= _tmp1434_)) {
						break;
					}
					_tmp1435_ = deleg;
					_tmp1436_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp1435_);
					if (_tmp1436_) {
						ValaLocalVariable* temp_var = NULL;
						ValaDataType* _tmp1437_ = NULL;
						ValaDataType* _tmp1438_ = NULL;
						ValaDataType* _tmp1439_ = NULL;
						ValaLocalVariable* _tmp1440_ = NULL;
						ValaLocalVariable* _tmp1441_ = NULL;
						ValaCCodeExpression* temp_ref = NULL;
						ValaLocalVariable* _tmp1442_ = NULL;
						const gchar* _tmp1443_ = NULL;
						const gchar* _tmp1444_ = NULL;
						ValaCCodeExpression* _tmp1445_ = NULL;
						ValaLocalVariable* _tmp1446_ = NULL;
						ValaCCodeExpression* _tmp1447_ = NULL;
						ValaCCodeExpression* _tmp1448_ = NULL;
						ValaCCodeAssignment* _tmp1449_ = NULL;
						ValaCCodeFunctionCall* len_call = NULL;
						ValaCCodeIdentifier* _tmp1450_ = NULL;
						ValaCCodeIdentifier* _tmp1451_ = NULL;
						ValaCCodeFunctionCall* _tmp1452_ = NULL;
						ValaCCodeFunctionCall* _tmp1453_ = NULL;
						ValaCCodeFunctionCall* _tmp1454_ = NULL;
						ValaCCodeExpression* _tmp1455_ = NULL;
						ValaMethodCall* _tmp1456_ = NULL;
						ValaCCodeFunctionCall* _tmp1457_ = NULL;
						_tmp1437_ = itype;
						_tmp1438_ = vala_data_type_get_return_type (_tmp1437_);
						_tmp1439_ = _tmp1438_;
						_tmp1440_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1439_, TRUE, NULL, FALSE);
						_tmp1441_ = _tmp1440_;
						_vala_code_node_unref0 (_tmp1439_);
						temp_var = _tmp1441_;
						_tmp1442_ = temp_var;
						_tmp1443_ = vala_symbol_get_name ((ValaSymbol*) _tmp1442_);
						_tmp1444_ = _tmp1443_;
						_tmp1445_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1444_);
						temp_ref = _tmp1445_;
						_tmp1446_ = temp_var;
						vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1446_);
						_tmp1447_ = temp_ref;
						_tmp1448_ = ccall_expr;
						_tmp1449_ = vala_ccode_assignment_new (_tmp1447_, _tmp1448_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
						_vala_ccode_node_unref0 (ccall_expr);
						ccall_expr = (ValaCCodeExpression*) _tmp1449_;
						((ValaCCodeBaseModule*) self)->requires_array_length = TRUE;
						_tmp1450_ = vala_ccode_identifier_new ("_vala_array_length");
						_tmp1451_ = _tmp1450_;
						_tmp1452_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1451_);
						_tmp1453_ = _tmp1452_;
						_vala_ccode_node_unref0 (_tmp1451_);
						len_call = _tmp1453_;
						_tmp1454_ = len_call;
						_tmp1455_ = temp_ref;
						vala_ccode_function_call_add_argument (_tmp1454_, _tmp1455_);
						_tmp1456_ = expr;
						_tmp1457_ = len_call;
						vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1456_, (ValaCCodeExpression*) _tmp1457_);
						_vala_ccode_node_unref0 (len_call);
						_vala_ccode_node_unref0 (temp_ref);
						_vala_code_node_unref0 (temp_var);
					} else {
						ValaDelegate* _tmp1458_ = NULL;
						gboolean _tmp1459_ = FALSE;
						_tmp1458_ = deleg;
						_tmp1459_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp1458_);
						if (_tmp1459_) {
							ValaLocalVariable* temp_var = NULL;
							ValaDataType* _tmp1460_ = NULL;
							ValaLocalVariable* _tmp1461_ = NULL;
							ValaCCodeExpression* temp_ref = NULL;
							ValaLocalVariable* _tmp1462_ = NULL;
							const gchar* _tmp1463_ = NULL;
							const gchar* _tmp1464_ = NULL;
							ValaCCodeExpression* _tmp1465_ = NULL;
							ValaLocalVariable* _tmp1466_ = NULL;
							ValaHashMap* _tmp1467_ = NULL;
							ValaDelegate* _tmp1468_ = NULL;
							gdouble _tmp1469_ = 0.0;
							gint _tmp1470_ = 0;
							gint _tmp1471_ = 0;
							ValaCCodeExpression* _tmp1472_ = NULL;
							ValaCCodeUnaryExpression* _tmp1473_ = NULL;
							ValaCCodeUnaryExpression* _tmp1474_ = NULL;
							ValaMethodCall* _tmp1475_ = NULL;
							ValaCCodeExpression* _tmp1476_ = NULL;
							_tmp1460_ = ((ValaCCodeBaseModule*) self)->int_type;
							_tmp1461_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1460_, TRUE, NULL, TRUE);
							temp_var = _tmp1461_;
							_tmp1462_ = temp_var;
							_tmp1463_ = vala_symbol_get_name ((ValaSymbol*) _tmp1462_);
							_tmp1464_ = _tmp1463_;
							_tmp1465_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1464_);
							temp_ref = _tmp1465_;
							_tmp1466_ = temp_var;
							vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1466_);
							_tmp1467_ = out_arg_map;
							_tmp1468_ = deleg;
							_tmp1469_ = vala_ccode_base_module_get_ccode_array_length_pos ((ValaCodeNode*) _tmp1468_);
							_tmp1470_ = dim;
							_tmp1471_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1469_ + (0.01 * _tmp1470_), FALSE);
							_tmp1472_ = temp_ref;
							_tmp1473_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1472_);
							_tmp1474_ = _tmp1473_;
							vala_map_set ((ValaMap*) _tmp1467_, (gpointer) ((gintptr) _tmp1471_), (ValaCCodeExpression*) _tmp1474_);
							_vala_ccode_node_unref0 (_tmp1474_);
							_tmp1475_ = expr;
							_tmp1476_ = temp_ref;
							vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1475_, _tmp1476_);
							_vala_ccode_node_unref0 (temp_ref);
							_vala_code_node_unref0 (temp_var);
						} else {
							ValaMethodCall* _tmp1477_ = NULL;
							ValaCCodeConstant* _tmp1478_ = NULL;
							ValaCCodeConstant* _tmp1479_ = NULL;
							_tmp1477_ = expr;
							_tmp1478_ = vala_ccode_constant_new ("-1");
							_tmp1479_ = _tmp1478_;
							vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1477_, (ValaCCodeExpression*) _tmp1479_);
							_vala_ccode_node_unref0 (_tmp1479_);
						}
					}
				}
			}
		}
		_vala_code_node_unref0 (array_type);
	} else {
		gboolean _tmp1480_ = FALSE;
		ValaDelegate* _tmp1481_ = NULL;
		_tmp1481_ = deleg;
		if (_tmp1481_ != NULL) {
			ValaDelegate* _tmp1482_ = NULL;
			ValaDataType* _tmp1483_ = NULL;
			ValaDataType* _tmp1484_ = NULL;
			_tmp1482_ = deleg;
			_tmp1483_ = vala_delegate_get_return_type (_tmp1482_);
			_tmp1484_ = _tmp1483_;
			_tmp1480_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1484_, VALA_TYPE_DELEGATE_TYPE);
		} else {
			_tmp1480_ = FALSE;
		}
		if (_tmp1480_) {
			ValaDelegateType* deleg_type = NULL;
			ValaDelegate* _tmp1485_ = NULL;
			ValaDataType* _tmp1486_ = NULL;
			ValaDataType* _tmp1487_ = NULL;
			ValaDelegateType* _tmp1488_ = NULL;
			ValaDelegate* d = NULL;
			ValaDelegateType* _tmp1489_ = NULL;
			ValaDelegate* _tmp1490_ = NULL;
			ValaDelegate* _tmp1491_ = NULL;
			ValaDelegate* _tmp1492_ = NULL;
			ValaDelegate* _tmp1493_ = NULL;
			gboolean _tmp1494_ = FALSE;
			gboolean _tmp1495_ = FALSE;
			_tmp1485_ = deleg;
			_tmp1486_ = vala_delegate_get_return_type (_tmp1485_);
			_tmp1487_ = _tmp1486_;
			_tmp1488_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1487_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
			deleg_type = _tmp1488_;
			_tmp1489_ = deleg_type;
			_tmp1490_ = vala_delegate_type_get_delegate_symbol (_tmp1489_);
			_tmp1491_ = _tmp1490_;
			_tmp1492_ = _vala_code_node_ref0 (_tmp1491_);
			d = _tmp1492_;
			_tmp1493_ = d;
			_tmp1494_ = vala_delegate_get_has_target (_tmp1493_);
			_tmp1495_ = _tmp1494_;
			if (_tmp1495_) {
				ValaLocalVariable* temp_var = NULL;
				ValaVoidType* _tmp1496_ = NULL;
				ValaVoidType* _tmp1497_ = NULL;
				ValaPointerType* _tmp1498_ = NULL;
				ValaPointerType* _tmp1499_ = NULL;
				ValaLocalVariable* _tmp1500_ = NULL;
				ValaLocalVariable* _tmp1501_ = NULL;
				ValaCCodeExpression* temp_ref = NULL;
				ValaLocalVariable* _tmp1502_ = NULL;
				const gchar* _tmp1503_ = NULL;
				const gchar* _tmp1504_ = NULL;
				ValaCCodeExpression* _tmp1505_ = NULL;
				ValaLocalVariable* _tmp1506_ = NULL;
				ValaHashMap* _tmp1507_ = NULL;
				ValaDelegate* _tmp1508_ = NULL;
				gdouble _tmp1509_ = 0.0;
				gint _tmp1510_ = 0;
				ValaCCodeExpression* _tmp1511_ = NULL;
				ValaCCodeUnaryExpression* _tmp1512_ = NULL;
				ValaCCodeUnaryExpression* _tmp1513_ = NULL;
				ValaMethodCall* _tmp1514_ = NULL;
				ValaCCodeExpression* _tmp1515_ = NULL;
				_tmp1496_ = vala_void_type_new (NULL);
				_tmp1497_ = _tmp1496_;
				_tmp1498_ = vala_pointer_type_new ((ValaDataType*) _tmp1497_, NULL);
				_tmp1499_ = _tmp1498_;
				_tmp1500_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1499_, TRUE, NULL, TRUE);
				_tmp1501_ = _tmp1500_;
				_vala_code_node_unref0 (_tmp1499_);
				_vala_code_node_unref0 (_tmp1497_);
				temp_var = _tmp1501_;
				_tmp1502_ = temp_var;
				_tmp1503_ = vala_symbol_get_name ((ValaSymbol*) _tmp1502_);
				_tmp1504_ = _tmp1503_;
				_tmp1505_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1504_);
				temp_ref = _tmp1505_;
				_tmp1506_ = temp_var;
				vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1506_);
				_tmp1507_ = out_arg_map;
				_tmp1508_ = deleg;
				_tmp1509_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1508_);
				_tmp1510_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1509_, FALSE);
				_tmp1511_ = temp_ref;
				_tmp1512_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1511_);
				_tmp1513_ = _tmp1512_;
				vala_map_set ((ValaMap*) _tmp1507_, (gpointer) ((gintptr) _tmp1510_), (ValaCCodeExpression*) _tmp1513_);
				_vala_ccode_node_unref0 (_tmp1513_);
				_tmp1514_ = expr;
				_tmp1515_ = temp_ref;
				vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp1514_, _tmp1515_);
				_vala_ccode_node_unref0 (temp_ref);
				_vala_code_node_unref0 (temp_var);
			}
			_vala_code_node_unref0 (d);
			_vala_code_node_unref0 (deleg_type);
		}
	}
	_tmp1517_ = m;
	if (_tmp1517_ != NULL) {
		ValaMethod* _tmp1518_ = NULL;
		gboolean _tmp1519_ = FALSE;
		gboolean _tmp1520_ = FALSE;
		_tmp1518_ = m;
		_tmp1519_ = vala_method_get_coroutine (_tmp1518_);
		_tmp1520_ = _tmp1519_;
		_tmp1516_ = _tmp1520_;
	} else {
		_tmp1516_ = FALSE;
	}
	if (_tmp1516_) {
		ValaMethodCall* _tmp1521_ = NULL;
		gboolean _tmp1522_ = FALSE;
		gboolean _tmp1523_ = FALSE;
		_tmp1521_ = expr;
		_tmp1522_ = vala_method_call_get_is_yield_expression (_tmp1521_);
		_tmp1523_ = _tmp1522_;
		if (_tmp1523_) {
			ValaHashMap* _tmp1524_ = NULL;
			gint _tmp1525_ = 0;
			ValaMethod* _tmp1526_ = NULL;
			ValaMethod* _tmp1527_ = NULL;
			gchar* _tmp1528_ = NULL;
			gchar* _tmp1529_ = NULL;
			ValaCCodeIdentifier* _tmp1530_ = NULL;
			ValaCCodeIdentifier* _tmp1531_ = NULL;
			ValaHashMap* _tmp1532_ = NULL;
			gint _tmp1533_ = 0;
			ValaCCodeIdentifier* _tmp1534_ = NULL;
			ValaCCodeIdentifier* _tmp1535_ = NULL;
			_tmp1524_ = in_arg_map;
			_tmp1525_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), FALSE);
			_tmp1526_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
			_tmp1527_ = _tmp1526_;
			_tmp1528_ = vala_ccode_base_module_generate_ready_function ((ValaCCodeBaseModule*) self, _tmp1527_);
			_tmp1529_ = _tmp1528_;
			_tmp1530_ = vala_ccode_identifier_new (_tmp1529_);
			_tmp1531_ = _tmp1530_;
			vala_map_set ((ValaMap*) _tmp1524_, (gpointer) ((gintptr) _tmp1525_), (ValaCCodeExpression*) _tmp1531_);
			_vala_ccode_node_unref0 (_tmp1531_);
			_g_free0 (_tmp1529_);
			_tmp1532_ = in_arg_map;
			_tmp1533_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, -0.9, FALSE);
			_tmp1534_ = vala_ccode_identifier_new ("_data_");
			_tmp1535_ = _tmp1534_;
			vala_map_set ((ValaMap*) _tmp1532_, (gpointer) ((gintptr) _tmp1533_), (ValaCCodeExpression*) _tmp1535_);
			_vala_ccode_node_unref0 (_tmp1535_);
		}
	}
	_tmp1536_ = expr;
	_tmp1537_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp1536_);
	_tmp1538_ = _tmp1537_;
	if (_tmp1538_) {
		ValaHashMap* _tmp1539_ = NULL;
		gint _tmp1540_ = 0;
		ValaCCodeExpression* _tmp1541_ = NULL;
		ValaCCodeExpression* _tmp1542_ = NULL;
		ValaCCodeUnaryExpression* _tmp1543_ = NULL;
		ValaCCodeUnaryExpression* _tmp1544_ = NULL;
		vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);
		_tmp1539_ = out_arg_map;
		_tmp1540_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), FALSE);
		_tmp1541_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");
		_tmp1542_ = _tmp1541_;
		_tmp1543_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1542_);
		_tmp1544_ = _tmp1543_;
		vala_map_set ((ValaMap*) _tmp1539_, (gpointer) ((gintptr) _tmp1540_), (ValaCCodeExpression*) _tmp1544_);
		_vala_ccode_node_unref0 (_tmp1544_);
		_vala_ccode_node_unref0 (_tmp1542_);
	}
	_tmp1545_ = ellipsis;
	if (_tmp1545_) {
		ValaMethod* _tmp1546_ = NULL;
		_tmp1546_ = m;
		if (_tmp1546_ == NULL) {
			ValaHashMap* _tmp1547_ = NULL;
			gint _tmp1548_ = 0;
			ValaCCodeConstant* _tmp1549_ = NULL;
			ValaCCodeConstant* _tmp1550_ = NULL;
			_tmp1547_ = in_arg_map;
			_tmp1548_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), TRUE);
			_tmp1549_ = vala_ccode_constant_new ("NULL");
			_tmp1550_ = _tmp1549_;
			vala_map_set ((ValaMap*) _tmp1547_, (gpointer) ((gintptr) _tmp1548_), (ValaCCodeExpression*) _tmp1550_);
			_vala_ccode_node_unref0 (_tmp1550_);
		} else {
			gboolean _tmp1551_ = FALSE;
			gboolean _tmp1552_ = FALSE;
			gboolean _tmp1553_ = FALSE;
			ValaMethod* _tmp1554_ = NULL;
			gboolean _tmp1555_ = FALSE;
			gboolean _tmp1556_ = FALSE;
			_tmp1554_ = m;
			_tmp1555_ = vala_method_get_printf_format (_tmp1554_);
			_tmp1556_ = _tmp1555_;
			if (!_tmp1556_) {
				ValaMethod* _tmp1557_ = NULL;
				gboolean _tmp1558_ = FALSE;
				gboolean _tmp1559_ = FALSE;
				_tmp1557_ = m;
				_tmp1558_ = vala_method_get_scanf_format (_tmp1557_);
				_tmp1559_ = _tmp1558_;
				_tmp1553_ = !_tmp1559_;
			} else {
				_tmp1553_ = FALSE;
			}
			if (_tmp1553_) {
				ValaMethod* _tmp1560_ = NULL;
				gchar* _tmp1561_ = NULL;
				gchar* _tmp1562_ = NULL;
				_tmp1560_ = m;
				_tmp1561_ = vala_ccode_base_module_get_ccode_sentinel (_tmp1560_);
				_tmp1562_ = _tmp1561_;
				_tmp1552_ = g_strcmp0 (_tmp1562_, "") != 0;
				_g_free0 (_tmp1562_);
			} else {
				_tmp1552_ = FALSE;
			}
			if (_tmp1552_) {
				ValaMethodCall* _tmp1563_ = NULL;
				gboolean _tmp1564_ = FALSE;
				gboolean _tmp1565_ = FALSE;
				_tmp1563_ = expr;
				_tmp1564_ = vala_method_call_get_is_constructv_chainup (_tmp1563_);
				_tmp1565_ = _tmp1564_;
				_tmp1551_ = !_tmp1565_;
			} else {
				_tmp1551_ = FALSE;
			}
			if (_tmp1551_) {
				ValaHashMap* _tmp1566_ = NULL;
				gint _tmp1567_ = 0;
				ValaMethod* _tmp1568_ = NULL;
				gchar* _tmp1569_ = NULL;
				gchar* _tmp1570_ = NULL;
				ValaCCodeConstant* _tmp1571_ = NULL;
				ValaCCodeConstant* _tmp1572_ = NULL;
				_tmp1566_ = in_arg_map;
				_tmp1567_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), TRUE);
				_tmp1568_ = m;
				_tmp1569_ = vala_ccode_base_module_get_ccode_sentinel (_tmp1568_);
				_tmp1570_ = _tmp1569_;
				_tmp1571_ = vala_ccode_constant_new (_tmp1570_);
				_tmp1572_ = _tmp1571_;
				vala_map_set ((ValaMap*) _tmp1566_, (gpointer) ((gintptr) _tmp1567_), (ValaCCodeExpression*) _tmp1572_);
				_vala_ccode_node_unref0 (_tmp1572_);
				_g_free0 (_tmp1570_);
			}
		}
	}
	_tmp1573_ = itype;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1573_, VALA_TYPE_DELEGATE_TYPE)) {
		ValaDelegateType* deleg_type = NULL;
		ValaDataType* _tmp1574_ = NULL;
		ValaDelegateType* _tmp1575_ = NULL;
		ValaDelegate* d = NULL;
		ValaDelegateType* _tmp1576_ = NULL;
		ValaDelegate* _tmp1577_ = NULL;
		ValaDelegate* _tmp1578_ = NULL;
		ValaDelegate* _tmp1579_ = NULL;
		ValaDelegate* _tmp1580_ = NULL;
		gboolean _tmp1581_ = FALSE;
		gboolean _tmp1582_ = FALSE;
		_tmp1574_ = itype;
		_tmp1575_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1574_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
		deleg_type = _tmp1575_;
		_tmp1576_ = deleg_type;
		_tmp1577_ = vala_delegate_type_get_delegate_symbol (_tmp1576_);
		_tmp1578_ = _tmp1577_;
		_tmp1579_ = _vala_code_node_ref0 (_tmp1578_);
		d = _tmp1579_;
		_tmp1580_ = d;
		_tmp1581_ = vala_delegate_get_has_target (_tmp1580_);
		_tmp1582_ = _tmp1581_;
		if (_tmp1582_) {
			ValaCCodeExpression* delegate_target_destroy_notify = NULL;
			ValaHashMap* _tmp1583_ = NULL;
			ValaDelegate* _tmp1584_ = NULL;
			gdouble _tmp1585_ = 0.0;
			gint _tmp1586_ = 0;
			ValaMethodCall* _tmp1587_ = NULL;
			ValaExpression* _tmp1588_ = NULL;
			ValaExpression* _tmp1589_ = NULL;
			ValaCCodeExpression* _tmp1590_ = NULL;
			ValaCCodeExpression* _tmp1591_ = NULL;
			ValaCCodeExpression* _tmp1592_ = NULL;
			ValaHashMap* _tmp1593_ = NULL;
			ValaDelegate* _tmp1594_ = NULL;
			gdouble _tmp1595_ = 0.0;
			gint _tmp1596_ = 0;
			ValaMethodCall* _tmp1597_ = NULL;
			ValaExpression* _tmp1598_ = NULL;
			ValaExpression* _tmp1599_ = NULL;
			ValaCCodeExpression* _tmp1600_ = NULL;
			ValaCCodeExpression* _tmp1601_ = NULL;
			ValaCCodeExpression* _tmp1602_ = NULL;
			_tmp1583_ = in_arg_map;
			_tmp1584_ = d;
			_tmp1585_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp1584_);
			_tmp1586_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1585_, FALSE);
			_tmp1587_ = expr;
			_tmp1588_ = vala_method_call_get_call (_tmp1587_);
			_tmp1589_ = _tmp1588_;
			_tmp1591_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp1589_, &_tmp1590_);
			_vala_ccode_node_unref0 (delegate_target_destroy_notify);
			delegate_target_destroy_notify = _tmp1590_;
			_tmp1592_ = _tmp1591_;
			vala_map_set ((ValaMap*) _tmp1583_, (gpointer) ((gintptr) _tmp1586_), _tmp1592_);
			_vala_ccode_node_unref0 (_tmp1592_);
			_tmp1593_ = out_arg_map;
			_tmp1594_ = d;
			_tmp1595_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp1594_);
			_tmp1596_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp1595_, FALSE);
			_tmp1597_ = expr;
			_tmp1598_ = vala_method_call_get_call (_tmp1597_);
			_tmp1599_ = _tmp1598_;
			_tmp1601_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp1599_, &_tmp1600_);
			_vala_ccode_node_unref0 (delegate_target_destroy_notify);
			delegate_target_destroy_notify = _tmp1600_;
			_tmp1602_ = _tmp1601_;
			vala_map_set ((ValaMap*) _tmp1593_, (gpointer) ((gintptr) _tmp1596_), _tmp1602_);
			_vala_ccode_node_unref0 (_tmp1602_);
			_vala_ccode_node_unref0 (delegate_target_destroy_notify);
		}
		_vala_code_node_unref0 (d);
		_vala_code_node_unref0 (deleg_type);
	}
	_tmp1603_ = itype;
	_tmp1604_ = vala_data_type_get_return_type (_tmp1603_);
	_tmp1605_ = _tmp1604_;
	_tmp1606_ = vala_data_type_is_real_non_null_struct_type (_tmp1605_);
	_tmp1607_ = _tmp1606_;
	_vala_code_node_unref0 (_tmp1605_);
	return_result_via_out_param = _tmp1607_;
	_tmp1609_ = itype;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1609_, VALA_TYPE_SIGNAL_TYPE)) {
		ValaDataType* _tmp1610_ = NULL;
		ValaDataType* _tmp1611_ = NULL;
		ValaDataType* _tmp1612_ = NULL;
		_tmp1610_ = itype;
		_tmp1611_ = vala_data_type_get_return_type (_tmp1610_);
		_tmp1612_ = _tmp1611_;
		_tmp1608_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1612_, VALA_TYPE_VOID_TYPE);
		_vala_code_node_unref0 (_tmp1612_);
	} else {
		_tmp1608_ = FALSE;
	}
	if (_tmp1608_) {
		ValaSignal* sig = NULL;
		ValaDataType* _tmp1613_ = NULL;
		ValaSignal* _tmp1614_ = NULL;
		ValaSignal* _tmp1615_ = NULL;
		ValaSignal* _tmp1616_ = NULL;
		gboolean _tmp1617_ = FALSE;
		gboolean _tmp1618_ = FALSE;
		ValaMemberAccess* _tmp1619_ = NULL;
		_tmp1613_ = itype;
		_tmp1614_ = vala_signal_type_get_signal_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp1613_, VALA_TYPE_SIGNAL_TYPE, ValaSignalType));
		_tmp1615_ = _tmp1614_;
		_tmp1616_ = _vala_code_node_ref0 (_tmp1615_);
		sig = _tmp1616_;
		_tmp1619_ = ma;
		if (_tmp1619_ != NULL) {
			ValaMemberAccess* _tmp1620_ = NULL;
			ValaExpression* _tmp1621_ = NULL;
			ValaExpression* _tmp1622_ = NULL;
			_tmp1620_ = ma;
			_tmp1621_ = vala_member_access_get_inner (_tmp1620_);
			_tmp1622_ = _tmp1621_;
			_tmp1618_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1622_, VALA_TYPE_BASE_ACCESS);
		} else {
			_tmp1618_ = FALSE;
		}
		if (_tmp1618_) {
			ValaSignal* _tmp1623_ = NULL;
			gboolean _tmp1624_ = FALSE;
			gboolean _tmp1625_ = FALSE;
			_tmp1623_ = sig;
			_tmp1624_ = vala_signal_get_is_virtual (_tmp1623_);
			_tmp1625_ = _tmp1624_;
			_tmp1617_ = _tmp1625_;
		} else {
			_tmp1617_ = FALSE;
		}
		if (_tmp1617_) {
		} else {
			ValaSignal* _tmp1626_ = NULL;
			gboolean _tmp1627_ = FALSE;
			_tmp1626_ = sig;
			_tmp1627_ = vala_ccode_base_module_get_signal_has_emitter ((ValaCCodeBaseModule*) self, _tmp1626_);
			if (!_tmp1627_) {
				return_result_via_out_param = TRUE;
			}
		}
		_vala_code_node_unref0 (sig);
	}
	_tmp1628_ = async_call;
	_tmp1629_ = ccall;
	if (_tmp1628_ == _tmp1629_) {
		return_result_via_out_param = FALSE;
	}
	out_param_ref = NULL;
	_tmp1630_ = return_result_via_out_param;
	if (_tmp1630_) {
		ValaLocalVariable* out_param_var = NULL;
		ValaDataType* _tmp1631_ = NULL;
		ValaDataType* _tmp1632_ = NULL;
		ValaDataType* _tmp1633_ = NULL;
		ValaLocalVariable* _tmp1634_ = NULL;
		ValaLocalVariable* _tmp1635_ = NULL;
		ValaLocalVariable* _tmp1636_ = NULL;
		const gchar* _tmp1637_ = NULL;
		const gchar* _tmp1638_ = NULL;
		ValaCCodeExpression* _tmp1639_ = NULL;
		ValaLocalVariable* _tmp1640_ = NULL;
		ValaHashMap* _tmp1641_ = NULL;
		gint _tmp1642_ = 0;
		ValaCCodeExpression* _tmp1643_ = NULL;
		ValaCCodeUnaryExpression* _tmp1644_ = NULL;
		ValaCCodeUnaryExpression* _tmp1645_ = NULL;
		_tmp1631_ = itype;
		_tmp1632_ = vala_data_type_get_return_type (_tmp1631_);
		_tmp1633_ = _tmp1632_;
		_tmp1634_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1633_, TRUE, NULL, TRUE);
		_tmp1635_ = _tmp1634_;
		_vala_code_node_unref0 (_tmp1633_);
		out_param_var = _tmp1635_;
		_tmp1636_ = out_param_var;
		_tmp1637_ = vala_symbol_get_name ((ValaSymbol*) _tmp1636_);
		_tmp1638_ = _tmp1637_;
		_tmp1639_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1638_);
		_vala_ccode_node_unref0 (out_param_ref);
		out_param_ref = _tmp1639_;
		_tmp1640_ = out_param_var;
		vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1640_);
		_tmp1641_ = out_arg_map;
		_tmp1642_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-3), FALSE);
		_tmp1643_ = out_param_ref;
		_tmp1644_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1643_);
		_tmp1645_ = _tmp1644_;
		vala_map_set ((ValaMap*) _tmp1641_, (gpointer) ((gintptr) _tmp1642_), (ValaCCodeExpression*) _tmp1645_);
		_vala_ccode_node_unref0 (_tmp1645_);
		_vala_code_node_unref0 (out_param_var);
	}
	_tmp1646_ = async_call;
	_tmp1647_ = ccall;
	if (_tmp1646_ != _tmp1647_) {
		last_pos = -1;
		while (TRUE) {
			gint _tmp1665_ = 0;
			ValaCCodeFunctionCall* _tmp1666_ = NULL;
			ValaHashMap* _tmp1667_ = NULL;
			gint _tmp1668_ = 0;
			gpointer _tmp1669_ = NULL;
			ValaCCodeExpression* _tmp1670_ = NULL;
			gint _tmp1671_ = 0;
			min_pos = -1;
			{
				ValaIterator* _pos_it = NULL;
				ValaHashMap* _tmp1648_ = NULL;
				ValaSet* _tmp1649_ = NULL;
				ValaSet* _tmp1650_ = NULL;
				ValaIterator* _tmp1651_ = NULL;
				ValaIterator* _tmp1652_ = NULL;
				_tmp1648_ = out_arg_map;
				_tmp1649_ = vala_map_get_keys ((ValaMap*) _tmp1648_);
				_tmp1650_ = _tmp1649_;
				_tmp1651_ = vala_iterable_iterator ((ValaIterable*) _tmp1650_);
				_tmp1652_ = _tmp1651_;
				_vala_iterable_unref0 (_tmp1650_);
				_pos_it = _tmp1652_;
				while (TRUE) {
					ValaIterator* _tmp1653_ = NULL;
					gboolean _tmp1654_ = FALSE;
					gint pos = 0;
					ValaIterator* _tmp1655_ = NULL;
					gpointer _tmp1656_ = NULL;
					gboolean _tmp1657_ = FALSE;
					gint _tmp1658_ = 0;
					gint _tmp1659_ = 0;
					_tmp1653_ = _pos_it;
					_tmp1654_ = vala_iterator_next (_tmp1653_);
					if (!_tmp1654_) {
						break;
					}
					_tmp1655_ = _pos_it;
					_tmp1656_ = vala_iterator_get (_tmp1655_);
					pos = (gint) ((gintptr) _tmp1656_);
					_tmp1658_ = pos;
					_tmp1659_ = last_pos;
					if (_tmp1658_ > _tmp1659_) {
						gboolean _tmp1660_ = FALSE;
						gint _tmp1661_ = 0;
						_tmp1661_ = min_pos;
						if (_tmp1661_ == (-1)) {
							_tmp1660_ = TRUE;
						} else {
							gint _tmp1662_ = 0;
							gint _tmp1663_ = 0;
							_tmp1662_ = pos;
							_tmp1663_ = min_pos;
							_tmp1660_ = _tmp1662_ < _tmp1663_;
						}
						_tmp1657_ = _tmp1660_;
					} else {
						_tmp1657_ = FALSE;
					}
					if (_tmp1657_) {
						gint _tmp1664_ = 0;
						_tmp1664_ = pos;
						min_pos = _tmp1664_;
					}
				}
				_vala_iterator_unref0 (_pos_it);
			}
			_tmp1665_ = min_pos;
			if (_tmp1665_ == (-1)) {
				break;
			}
			_tmp1666_ = ccall;
			_tmp1667_ = out_arg_map;
			_tmp1668_ = min_pos;
			_tmp1669_ = vala_map_get ((ValaMap*) _tmp1667_, (gpointer) ((gintptr) _tmp1668_));
			_tmp1670_ = (ValaCCodeExpression*) _tmp1669_;
			vala_ccode_function_call_add_argument (_tmp1666_, _tmp1670_);
			_vala_ccode_node_unref0 (_tmp1670_);
			_tmp1671_ = min_pos;
			last_pos = _tmp1671_;
		}
	}
	_tmp1672_ = async_call;
	if (_tmp1672_ != NULL) {
		last_pos = -1;
		while (TRUE) {
			gint _tmp1690_ = 0;
			ValaCCodeFunctionCall* _tmp1691_ = NULL;
			ValaHashMap* _tmp1692_ = NULL;
			gint _tmp1693_ = 0;
			gpointer _tmp1694_ = NULL;
			ValaCCodeExpression* _tmp1695_ = NULL;
			gint _tmp1696_ = 0;
			min_pos = -1;
			{
				ValaIterator* _pos_it = NULL;
				ValaHashMap* _tmp1673_ = NULL;
				ValaSet* _tmp1674_ = NULL;
				ValaSet* _tmp1675_ = NULL;
				ValaIterator* _tmp1676_ = NULL;
				ValaIterator* _tmp1677_ = NULL;
				_tmp1673_ = in_arg_map;
				_tmp1674_ = vala_map_get_keys ((ValaMap*) _tmp1673_);
				_tmp1675_ = _tmp1674_;
				_tmp1676_ = vala_iterable_iterator ((ValaIterable*) _tmp1675_);
				_tmp1677_ = _tmp1676_;
				_vala_iterable_unref0 (_tmp1675_);
				_pos_it = _tmp1677_;
				while (TRUE) {
					ValaIterator* _tmp1678_ = NULL;
					gboolean _tmp1679_ = FALSE;
					gint pos = 0;
					ValaIterator* _tmp1680_ = NULL;
					gpointer _tmp1681_ = NULL;
					gboolean _tmp1682_ = FALSE;
					gint _tmp1683_ = 0;
					gint _tmp1684_ = 0;
					_tmp1678_ = _pos_it;
					_tmp1679_ = vala_iterator_next (_tmp1678_);
					if (!_tmp1679_) {
						break;
					}
					_tmp1680_ = _pos_it;
					_tmp1681_ = vala_iterator_get (_tmp1680_);
					pos = (gint) ((gintptr) _tmp1681_);
					_tmp1683_ = pos;
					_tmp1684_ = last_pos;
					if (_tmp1683_ > _tmp1684_) {
						gboolean _tmp1685_ = FALSE;
						gint _tmp1686_ = 0;
						_tmp1686_ = min_pos;
						if (_tmp1686_ == (-1)) {
							_tmp1685_ = TRUE;
						} else {
							gint _tmp1687_ = 0;
							gint _tmp1688_ = 0;
							_tmp1687_ = pos;
							_tmp1688_ = min_pos;
							_tmp1685_ = _tmp1687_ < _tmp1688_;
						}
						_tmp1682_ = _tmp1685_;
					} else {
						_tmp1682_ = FALSE;
					}
					if (_tmp1682_) {
						gint _tmp1689_ = 0;
						_tmp1689_ = pos;
						min_pos = _tmp1689_;
					}
				}
				_vala_iterator_unref0 (_pos_it);
			}
			_tmp1690_ = min_pos;
			if (_tmp1690_ == (-1)) {
				break;
			}
			_tmp1691_ = async_call;
			_tmp1692_ = in_arg_map;
			_tmp1693_ = min_pos;
			_tmp1694_ = vala_map_get ((ValaMap*) _tmp1692_, (gpointer) ((gintptr) _tmp1693_));
			_tmp1695_ = (ValaCCodeExpression*) _tmp1694_;
			vala_ccode_function_call_add_argument (_tmp1691_, _tmp1695_);
			_vala_ccode_node_unref0 (_tmp1695_);
			_tmp1696_ = min_pos;
			last_pos = _tmp1696_;
		}
	}
	_tmp1697_ = expr;
	_tmp1698_ = vala_method_call_get_is_yield_expression (_tmp1697_);
	_tmp1699_ = _tmp1698_;
	if (_tmp1699_) {
		gint state = 0;
		gint _tmp1700_ = 0;
		ValaCCodeFunction* _tmp1701_ = NULL;
		ValaCCodeFunction* _tmp1702_ = NULL;
		ValaCCodeIdentifier* _tmp1703_ = NULL;
		ValaCCodeIdentifier* _tmp1704_ = NULL;
		ValaCCodeMemberAccess* _tmp1705_ = NULL;
		ValaCCodeMemberAccess* _tmp1706_ = NULL;
		gint _tmp1707_ = 0;
		gchar* _tmp1708_ = NULL;
		gchar* _tmp1709_ = NULL;
		ValaCCodeConstant* _tmp1710_ = NULL;
		ValaCCodeConstant* _tmp1711_ = NULL;
		ValaCCodeFunction* _tmp1712_ = NULL;
		ValaCCodeFunction* _tmp1713_ = NULL;
		ValaCCodeFunctionCall* _tmp1714_ = NULL;
		ValaCCodeFunction* _tmp1715_ = NULL;
		ValaCCodeFunction* _tmp1716_ = NULL;
		ValaCCodeConstant* _tmp1717_ = NULL;
		ValaCCodeConstant* _tmp1718_ = NULL;
		ValaCCodeFunction* _tmp1719_ = NULL;
		ValaCCodeFunction* _tmp1720_ = NULL;
		gint _tmp1721_ = 0;
		gchar* _tmp1722_ = NULL;
		gchar* _tmp1723_ = NULL;
		_tmp1700_ = ((ValaCCodeBaseModule*) self)->next_coroutine_state;
		((ValaCCodeBaseModule*) self)->next_coroutine_state = _tmp1700_ + 1;
		state = _tmp1700_;
		_tmp1701_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1702_ = _tmp1701_;
		_tmp1703_ = vala_ccode_identifier_new ("_data_");
		_tmp1704_ = _tmp1703_;
		_tmp1705_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp1704_, "_state_");
		_tmp1706_ = _tmp1705_;
		_tmp1707_ = state;
		_tmp1708_ = g_strdup_printf ("%i", _tmp1707_);
		_tmp1709_ = _tmp1708_;
		_tmp1710_ = vala_ccode_constant_new (_tmp1709_);
		_tmp1711_ = _tmp1710_;
		vala_ccode_function_add_assignment (_tmp1702_, (ValaCCodeExpression*) _tmp1706_, (ValaCCodeExpression*) _tmp1711_);
		_vala_ccode_node_unref0 (_tmp1711_);
		_g_free0 (_tmp1709_);
		_vala_ccode_node_unref0 (_tmp1706_);
		_vala_ccode_node_unref0 (_tmp1704_);
		_tmp1712_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1713_ = _tmp1712_;
		_tmp1714_ = async_call;
		vala_ccode_function_add_expression (_tmp1713_, (ValaCCodeExpression*) _tmp1714_);
		_tmp1715_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1716_ = _tmp1715_;
		_tmp1717_ = vala_ccode_constant_new ("FALSE");
		_tmp1718_ = _tmp1717_;
		vala_ccode_function_add_return (_tmp1716_, (ValaCCodeExpression*) _tmp1718_);
		_vala_ccode_node_unref0 (_tmp1718_);
		_tmp1719_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1720_ = _tmp1719_;
		_tmp1721_ = state;
		_tmp1722_ = g_strdup_printf ("_state_%d", _tmp1721_);
		_tmp1723_ = _tmp1722_;
		vala_ccode_function_add_label (_tmp1720_, _tmp1723_);
		_g_free0 (_tmp1723_);
	}
	_tmp1724_ = expr;
	_tmp1725_ = vala_method_call_get_is_assert (_tmp1724_);
	_tmp1726_ = _tmp1725_;
	if (_tmp1726_) {
		gchar* message = NULL;
		ValaMethodCall* _tmp1727_ = NULL;
		ValaSourceReference* _tmp1728_ = NULL;
		ValaSourceReference* _tmp1729_ = NULL;
		ValaSourceLocation _tmp1730_ = {0};
		ValaSourceLocation _tmp1731_ = {0};
		gchar* _tmp1732_ = NULL;
		ValaMethodCall* _tmp1733_ = NULL;
		ValaSourceReference* _tmp1734_ = NULL;
		ValaSourceReference* _tmp1735_ = NULL;
		ValaSourceLocation _tmp1736_ = {0};
		ValaSourceLocation _tmp1737_ = {0};
		gchar* _tmp1738_ = NULL;
		ValaMethodCall* _tmp1739_ = NULL;
		ValaSourceReference* _tmp1740_ = NULL;
		ValaSourceReference* _tmp1741_ = NULL;
		ValaSourceLocation _tmp1742_ = {0};
		ValaSourceLocation _tmp1743_ = {0};
		gchar* _tmp1744_ = NULL;
		gchar* _tmp1745_ = NULL;
		ValaCCodeFunctionCall* _tmp1746_ = NULL;
		ValaCCodeIdentifier* _tmp1747_ = NULL;
		ValaCCodeIdentifier* _tmp1748_ = NULL;
		ValaCCodeFunctionCall* _tmp1749_ = NULL;
		const gchar* _tmp1750_ = NULL;
		gchar* _tmp1751_ = NULL;
		gchar* _tmp1752_ = NULL;
		gchar* _tmp1753_ = NULL;
		gchar* _tmp1754_ = NULL;
		gchar* _tmp1755_ = NULL;
		gchar* _tmp1756_ = NULL;
		ValaCCodeConstant* _tmp1757_ = NULL;
		ValaCCodeConstant* _tmp1758_ = NULL;
		_tmp1727_ = expr;
		_tmp1728_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1727_);
		_tmp1729_ = _tmp1728_;
		vala_source_reference_get_begin (_tmp1729_, &_tmp1730_);
		_tmp1731_ = _tmp1730_;
		_tmp1732_ = _tmp1731_.pos;
		_tmp1733_ = expr;
		_tmp1734_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1733_);
		_tmp1735_ = _tmp1734_;
		vala_source_reference_get_end (_tmp1735_, &_tmp1736_);
		_tmp1737_ = _tmp1736_;
		_tmp1738_ = _tmp1737_.pos;
		_tmp1739_ = expr;
		_tmp1740_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1739_);
		_tmp1741_ = _tmp1740_;
		vala_source_reference_get_begin (_tmp1741_, &_tmp1742_);
		_tmp1743_ = _tmp1742_;
		_tmp1744_ = _tmp1743_.pos;
		_tmp1745_ = string_substring ((const gchar*) _tmp1732_, (glong) 0, (glong) ((gint) (_tmp1738_ - _tmp1744_)));
		message = _tmp1745_;
		_tmp1746_ = ccall;
		_tmp1747_ = vala_ccode_identifier_new ("_vala_assert");
		_tmp1748_ = _tmp1747_;
		vala_ccode_function_call_set_call (_tmp1746_, (ValaCCodeExpression*) _tmp1748_);
		_vala_ccode_node_unref0 (_tmp1748_);
		_tmp1749_ = ccall;
		_tmp1750_ = message;
		_tmp1751_ = string_replace (_tmp1750_, "\n", " ");
		_tmp1752_ = _tmp1751_;
		_tmp1753_ = g_strescape (_tmp1752_, "");
		_tmp1754_ = _tmp1753_;
		_tmp1755_ = g_strdup_printf ("\"%s\"", _tmp1754_);
		_tmp1756_ = _tmp1755_;
		_tmp1757_ = vala_ccode_constant_new (_tmp1756_);
		_tmp1758_ = _tmp1757_;
		vala_ccode_function_call_add_argument (_tmp1749_, (ValaCCodeExpression*) _tmp1758_);
		_vala_ccode_node_unref0 (_tmp1758_);
		_g_free0 (_tmp1756_);
		_g_free0 (_tmp1754_);
		_g_free0 (_tmp1752_);
		((ValaCCodeBaseModule*) self)->requires_assert = TRUE;
		_g_free0 (message);
	}
	_tmp1759_ = return_result_via_out_param;
	if (_tmp1759_) {
		ValaCCodeFunction* _tmp1760_ = NULL;
		ValaCCodeFunction* _tmp1761_ = NULL;
		ValaCCodeExpression* _tmp1762_ = NULL;
		ValaCCodeExpression* _tmp1763_ = NULL;
		ValaCCodeExpression* _tmp1764_ = NULL;
		_tmp1760_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1761_ = _tmp1760_;
		_tmp1762_ = ccall_expr;
		vala_ccode_function_add_expression (_tmp1761_, _tmp1762_);
		_tmp1763_ = out_param_ref;
		_tmp1764_ = _vala_ccode_node_ref0 (_tmp1763_);
		_vala_ccode_node_unref0 (ccall_expr);
		ccall_expr = _tmp1764_;
	}
	_tmp1767_ = m;
	if (_tmp1767_ != NULL) {
		ValaMethod* _tmp1768_ = NULL;
		ValaMemberBinding _tmp1769_ = 0;
		ValaMemberBinding _tmp1770_ = 0;
		_tmp1768_ = m;
		_tmp1769_ = vala_method_get_binding (_tmp1768_);
		_tmp1770_ = _tmp1769_;
		_tmp1766_ = _tmp1770_ == VALA_MEMBER_BINDING_INSTANCE;
	} else {
		_tmp1766_ = FALSE;
	}
	if (_tmp1766_) {
		ValaMethod* _tmp1771_ = NULL;
		gboolean _tmp1772_ = FALSE;
		gboolean _tmp1773_ = FALSE;
		_tmp1771_ = m;
		_tmp1772_ = vala_method_get_returns_modified_pointer (_tmp1771_);
		_tmp1773_ = _tmp1772_;
		_tmp1765_ = _tmp1773_;
	} else {
		_tmp1765_ = FALSE;
	}
	if (_tmp1765_) {
		gboolean _tmp1774_ = FALSE;
		gboolean _tmp1775_ = FALSE;
		ValaMemberAccess* _tmp1776_ = NULL;
		_tmp1776_ = ma;
		if (_tmp1776_ != NULL) {
			ValaMemberAccess* _tmp1777_ = NULL;
			ValaExpression* _tmp1778_ = NULL;
			ValaExpression* _tmp1779_ = NULL;
			ValaSymbol* _tmp1780_ = NULL;
			ValaSymbol* _tmp1781_ = NULL;
			_tmp1777_ = ma;
			_tmp1778_ = vala_member_access_get_inner (_tmp1777_);
			_tmp1779_ = _tmp1778_;
			_tmp1780_ = vala_expression_get_symbol_reference (_tmp1779_);
			_tmp1781_ = _tmp1780_;
			_tmp1775_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1781_, VALA_TYPE_PROPERTY);
		} else {
			_tmp1775_ = FALSE;
		}
		if (_tmp1775_) {
			ValaMemberAccess* _tmp1782_ = NULL;
			ValaExpression* _tmp1783_ = NULL;
			ValaExpression* _tmp1784_ = NULL;
			_tmp1782_ = ma;
			_tmp1783_ = vala_member_access_get_inner (_tmp1782_);
			_tmp1784_ = _tmp1783_;
			_tmp1774_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1784_, VALA_TYPE_MEMBER_ACCESS);
		} else {
			_tmp1774_ = FALSE;
		}
		if (_tmp1774_) {
			ValaProperty* prop = NULL;
			ValaMemberAccess* _tmp1785_ = NULL;
			ValaExpression* _tmp1786_ = NULL;
			ValaExpression* _tmp1787_ = NULL;
			ValaSymbol* _tmp1788_ = NULL;
			ValaSymbol* _tmp1789_ = NULL;
			ValaProperty* _tmp1790_ = NULL;
			ValaProperty* _tmp1791_ = NULL;
			ValaMemberAccess* _tmp1792_ = NULL;
			ValaExpression* _tmp1793_ = NULL;
			ValaExpression* _tmp1794_ = NULL;
			ValaExpression* _tmp1795_ = NULL;
			ValaExpression* _tmp1796_ = NULL;
			ValaMethodCall* _tmp1797_ = NULL;
			ValaDataType* _tmp1798_ = NULL;
			ValaDataType* _tmp1799_ = NULL;
			ValaCCodeExpression* _tmp1800_ = NULL;
			ValaGLibValue* _tmp1801_ = NULL;
			ValaGLibValue* _tmp1802_ = NULL;
			_tmp1785_ = ma;
			_tmp1786_ = vala_member_access_get_inner (_tmp1785_);
			_tmp1787_ = _tmp1786_;
			_tmp1788_ = vala_expression_get_symbol_reference (_tmp1787_);
			_tmp1789_ = _tmp1788_;
			_tmp1790_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1789_, VALA_TYPE_PROPERTY, ValaProperty));
			prop = _tmp1790_;
			_tmp1791_ = prop;
			_tmp1792_ = ma;
			_tmp1793_ = vala_member_access_get_inner (_tmp1792_);
			_tmp1794_ = _tmp1793_;
			_tmp1795_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp1794_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));
			_tmp1796_ = _tmp1795_;
			_tmp1797_ = expr;
			_tmp1798_ = vala_expression_get_value_type ((ValaExpression*) _tmp1797_);
			_tmp1799_ = _tmp1798_;
			_tmp1800_ = ccall_expr;
			_tmp1801_ = vala_glib_value_new (_tmp1799_, _tmp1800_, FALSE);
			_tmp1802_ = _tmp1801_;
			vala_ccode_base_module_store_property ((ValaCCodeBaseModule*) self, _tmp1791_, _tmp1796_, (ValaTargetValue*) _tmp1802_);
			_vala_target_value_unref0 (_tmp1802_);
			_vala_ccode_node_unref0 (ccall_expr);
			ccall_expr = NULL;
			_vala_code_node_unref0 (prop);
		} else {
			ValaCCodeExpression* _tmp1803_ = NULL;
			ValaCCodeExpression* _tmp1804_ = NULL;
			ValaCCodeAssignment* _tmp1805_ = NULL;
			_tmp1803_ = instance;
			_tmp1804_ = ccall_expr;
			_tmp1805_ = vala_ccode_assignment_new (_tmp1803_, _tmp1804_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
			_vala_ccode_node_unref0 (ccall_expr);
			ccall_expr = (ValaCCodeExpression*) _tmp1805_;
		}
	}
	_tmp1808_ = m;
	if (_tmp1808_ != NULL) {
		ValaMethod* _tmp1809_ = NULL;
		gchar* _tmp1810_ = NULL;
		gchar* _tmp1811_ = NULL;
		_tmp1809_ = m;
		_tmp1810_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1809_);
		_tmp1811_ = _tmp1810_;
		_tmp1807_ = _tmp1811_ != NULL;
		_g_free0 (_tmp1811_);
	} else {
		_tmp1807_ = FALSE;
	}
	if (_tmp1807_) {
		ValaMethod* _tmp1812_ = NULL;
		gchar* _tmp1813_ = NULL;
		gchar* _tmp1814_ = NULL;
		ValaMethod* _tmp1815_ = NULL;
		ValaDataType* _tmp1816_ = NULL;
		ValaDataType* _tmp1817_ = NULL;
		gchar* _tmp1818_ = NULL;
		gchar* _tmp1819_ = NULL;
		_tmp1812_ = m;
		_tmp1813_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1812_);
		_tmp1814_ = _tmp1813_;
		_tmp1815_ = m;
		_tmp1816_ = vala_method_get_return_type (_tmp1815_);
		_tmp1817_ = _tmp1816_;
		_tmp1818_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1817_);
		_tmp1819_ = _tmp1818_;
		_tmp1806_ = g_strcmp0 (_tmp1814_, _tmp1819_) != 0;
		_g_free0 (_tmp1819_);
		_g_free0 (_tmp1814_);
	} else {
		_tmp1806_ = FALSE;
	}
	if (_tmp1806_) {
		ValaCCodeExpression* _tmp1820_ = NULL;
		ValaMethod* _tmp1821_ = NULL;
		ValaDataType* _tmp1822_ = NULL;
		ValaDataType* _tmp1823_ = NULL;
		gchar* _tmp1824_ = NULL;
		gchar* _tmp1825_ = NULL;
		ValaCCodeCastExpression* _tmp1826_ = NULL;
		_tmp1820_ = ccall_expr;
		_tmp1821_ = m;
		_tmp1822_ = vala_method_get_return_type (_tmp1821_);
		_tmp1823_ = _tmp1822_;
		_tmp1824_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1823_);
		_tmp1825_ = _tmp1824_;
		_tmp1826_ = vala_ccode_cast_expression_new (_tmp1820_, _tmp1825_);
		_vala_ccode_node_unref0 (ccall_expr);
		ccall_expr = (ValaCCodeExpression*) _tmp1826_;
		_g_free0 (_tmp1825_);
	}
	_tmp1827_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1827_, VALA_TYPE_ARRAY_RESIZE_METHOD)) {
		ValaIterator* arg_it = NULL;
		ValaMethodCall* _tmp1828_ = NULL;
		ValaList* _tmp1829_ = NULL;
		ValaList* _tmp1830_ = NULL;
		ValaIterator* _tmp1831_ = NULL;
		ValaIterator* _tmp1832_ = NULL;
		ValaIterator* _tmp1833_ = NULL;
		ValaCCodeExpression* new_size = NULL;
		ValaIterator* _tmp1834_ = NULL;
		gpointer _tmp1835_ = NULL;
		ValaExpression* _tmp1836_ = NULL;
		ValaCCodeExpression* _tmp1837_ = NULL;
		ValaCCodeExpression* _tmp1838_ = NULL;
		ValaLocalVariable* temp_decl = NULL;
		ValaDataType* _tmp1839_ = NULL;
		ValaLocalVariable* _tmp1840_ = NULL;
		ValaCCodeExpression* temp_ref = NULL;
		ValaLocalVariable* _tmp1841_ = NULL;
		const gchar* _tmp1842_ = NULL;
		const gchar* _tmp1843_ = NULL;
		ValaCCodeExpression* _tmp1844_ = NULL;
		ValaLocalVariable* _tmp1845_ = NULL;
		ValaCCodeFile* _tmp1846_ = NULL;
		ValaCCodeExpression* clen = NULL;
		ValaMemberAccess* _tmp1847_ = NULL;
		ValaExpression* _tmp1848_ = NULL;
		ValaExpression* _tmp1849_ = NULL;
		ValaCCodeExpression* _tmp1850_ = NULL;
		ValaCCodeExpression* celems = NULL;
		ValaMemberAccess* _tmp1851_ = NULL;
		ValaExpression* _tmp1852_ = NULL;
		ValaExpression* _tmp1853_ = NULL;
		ValaCCodeExpression* _tmp1854_ = NULL;
		ValaArrayType* array_type = NULL;
		ValaMemberAccess* _tmp1855_ = NULL;
		ValaExpression* _tmp1856_ = NULL;
		ValaExpression* _tmp1857_ = NULL;
		ValaDataType* _tmp1858_ = NULL;
		ValaDataType* _tmp1859_ = NULL;
		ValaArrayType* _tmp1860_ = NULL;
		ValaCCodeIdentifier* csizeof = NULL;
		ValaArrayType* _tmp1861_ = NULL;
		ValaDataType* _tmp1862_ = NULL;
		ValaDataType* _tmp1863_ = NULL;
		gchar* _tmp1864_ = NULL;
		gchar* _tmp1865_ = NULL;
		gchar* _tmp1866_ = NULL;
		gchar* _tmp1867_ = NULL;
		ValaCCodeIdentifier* _tmp1868_ = NULL;
		ValaCCodeIdentifier* _tmp1869_ = NULL;
		ValaCCodeBinaryExpression* cdelta = NULL;
		ValaCCodeExpression* _tmp1870_ = NULL;
		ValaCCodeExpression* _tmp1871_ = NULL;
		ValaCCodeBinaryExpression* _tmp1872_ = NULL;
		ValaCCodeBinaryExpression* ccheck = NULL;
		ValaCCodeExpression* _tmp1873_ = NULL;
		ValaCCodeExpression* _tmp1874_ = NULL;
		ValaCCodeBinaryExpression* _tmp1875_ = NULL;
		ValaCCodeFunctionCall* czero = NULL;
		ValaCCodeIdentifier* _tmp1876_ = NULL;
		ValaCCodeIdentifier* _tmp1877_ = NULL;
		ValaCCodeFunctionCall* _tmp1878_ = NULL;
		ValaCCodeFunctionCall* _tmp1879_ = NULL;
		ValaCCodeFunctionCall* _tmp1880_ = NULL;
		ValaCCodeExpression* _tmp1881_ = NULL;
		ValaCCodeExpression* _tmp1882_ = NULL;
		ValaCCodeBinaryExpression* _tmp1883_ = NULL;
		ValaCCodeBinaryExpression* _tmp1884_ = NULL;
		ValaCCodeFunctionCall* _tmp1885_ = NULL;
		ValaCCodeConstant* _tmp1886_ = NULL;
		ValaCCodeConstant* _tmp1887_ = NULL;
		ValaCCodeFunctionCall* _tmp1888_ = NULL;
		ValaCCodeIdentifier* _tmp1889_ = NULL;
		ValaCCodeBinaryExpression* _tmp1890_ = NULL;
		ValaCCodeBinaryExpression* _tmp1891_ = NULL;
		ValaCCodeBinaryExpression* _tmp1892_ = NULL;
		ValaCCodeFunction* _tmp1893_ = NULL;
		ValaCCodeFunction* _tmp1894_ = NULL;
		ValaCCodeExpression* _tmp1895_ = NULL;
		ValaCCodeExpression* _tmp1896_ = NULL;
		ValaCCodeFunction* _tmp1897_ = NULL;
		ValaCCodeFunction* _tmp1898_ = NULL;
		ValaCCodeExpression* _tmp1899_ = NULL;
		ValaCCodeFunction* _tmp1900_ = NULL;
		ValaCCodeFunction* _tmp1901_ = NULL;
		ValaCCodeBinaryExpression* _tmp1902_ = NULL;
		ValaCCodeFunctionCall* _tmp1903_ = NULL;
		ValaCCodeConstant* _tmp1904_ = NULL;
		ValaCCodeConstant* _tmp1905_ = NULL;
		ValaCCodeConditionalExpression* _tmp1906_ = NULL;
		ValaCCodeConditionalExpression* _tmp1907_ = NULL;
		ValaCCodeFunction* _tmp1908_ = NULL;
		ValaCCodeFunction* _tmp1909_ = NULL;
		ValaMemberAccess* _tmp1910_ = NULL;
		ValaExpression* _tmp1911_ = NULL;
		ValaExpression* _tmp1912_ = NULL;
		ValaCCodeExpression* _tmp1913_ = NULL;
		ValaCCodeExpression* _tmp1914_ = NULL;
		ValaCCodeExpression* _tmp1915_ = NULL;
		ValaSymbol* array_var = NULL;
		ValaMemberAccess* _tmp1916_ = NULL;
		ValaExpression* _tmp1917_ = NULL;
		ValaExpression* _tmp1918_ = NULL;
		ValaSymbol* _tmp1919_ = NULL;
		ValaSymbol* _tmp1920_ = NULL;
		ValaSymbol* _tmp1921_ = NULL;
		ValaLocalVariable* array_local = NULL;
		ValaSymbol* _tmp1922_ = NULL;
		ValaLocalVariable* _tmp1923_ = NULL;
		gboolean _tmp1924_ = FALSE;
		gboolean _tmp1925_ = FALSE;
		ValaSymbol* _tmp1926_ = NULL;
		_tmp1828_ = expr;
		_tmp1829_ = vala_method_call_get_argument_list (_tmp1828_);
		_tmp1830_ = _tmp1829_;
		_tmp1831_ = vala_iterable_iterator ((ValaIterable*) _tmp1830_);
		_tmp1832_ = _tmp1831_;
		_vala_iterable_unref0 (_tmp1830_);
		arg_it = _tmp1832_;
		_tmp1833_ = arg_it;
		vala_iterator_next (_tmp1833_);
		_tmp1834_ = arg_it;
		_tmp1835_ = vala_iterator_get (_tmp1834_);
		_tmp1836_ = (ValaExpression*) _tmp1835_;
		_tmp1837_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp1836_);
		_tmp1838_ = _tmp1837_;
		_vala_code_node_unref0 (_tmp1836_);
		new_size = _tmp1838_;
		_tmp1839_ = ((ValaCCodeBaseModule*) self)->int_type;
		_tmp1840_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1839_, TRUE, NULL, TRUE);
		temp_decl = _tmp1840_;
		_tmp1841_ = temp_decl;
		_tmp1842_ = vala_symbol_get_name ((ValaSymbol*) _tmp1841_);
		_tmp1843_ = _tmp1842_;
		_tmp1844_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1843_);
		temp_ref = _tmp1844_;
		_tmp1845_ = temp_decl;
		vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1845_);
		_tmp1846_ = ((ValaCCodeBaseModule*) self)->cfile;
		vala_ccode_file_add_include (_tmp1846_, "string.h", FALSE);
		_tmp1847_ = ma;
		_tmp1848_ = vala_member_access_get_inner (_tmp1847_);
		_tmp1849_ = _tmp1848_;
		_tmp1850_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp1849_, 1);
		clen = _tmp1850_;
		_tmp1851_ = ma;
		_tmp1852_ = vala_member_access_get_inner (_tmp1851_);
		_tmp1853_ = _tmp1852_;
		_tmp1854_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp1853_);
		celems = _tmp1854_;
		_tmp1855_ = ma;
		_tmp1856_ = vala_member_access_get_inner (_tmp1855_);
		_tmp1857_ = _tmp1856_;
		_tmp1858_ = vala_expression_get_value_type (_tmp1857_);
		_tmp1859_ = _tmp1858_;
		_tmp1860_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1859_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
		array_type = _tmp1860_;
		_tmp1861_ = array_type;
		_tmp1862_ = vala_array_type_get_element_type (_tmp1861_);
		_tmp1863_ = _tmp1862_;
		_tmp1864_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1863_);
		_tmp1865_ = _tmp1864_;
		_tmp1866_ = g_strdup_printf ("sizeof (%s)", _tmp1865_);
		_tmp1867_ = _tmp1866_;
		_tmp1868_ = vala_ccode_identifier_new (_tmp1867_);
		_tmp1869_ = _tmp1868_;
		_g_free0 (_tmp1867_);
		_g_free0 (_tmp1865_);
		csizeof = _tmp1869_;
		_tmp1870_ = temp_ref;
		_tmp1871_ = clen;
		_tmp1872_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MINUS, _tmp1870_, _tmp1871_);
		cdelta = _tmp1872_;
		_tmp1873_ = temp_ref;
		_tmp1874_ = clen;
		_tmp1875_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, _tmp1873_, _tmp1874_);
		ccheck = _tmp1875_;
		_tmp1876_ = vala_ccode_identifier_new ("memset");
		_tmp1877_ = _tmp1876_;
		_tmp1878_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1877_);
		_tmp1879_ = _tmp1878_;
		_vala_ccode_node_unref0 (_tmp1877_);
		czero = _tmp1879_;
		_tmp1880_ = czero;
		_tmp1881_ = celems;
		_tmp1882_ = clen;
		_tmp1883_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, _tmp1881_, _tmp1882_);
		_tmp1884_ = _tmp1883_;
		vala_ccode_function_call_add_argument (_tmp1880_, (ValaCCodeExpression*) _tmp1884_);
		_vala_ccode_node_unref0 (_tmp1884_);
		_tmp1885_ = czero;
		_tmp1886_ = vala_ccode_constant_new ("0");
		_tmp1887_ = _tmp1886_;
		vala_ccode_function_call_add_argument (_tmp1885_, (ValaCCodeExpression*) _tmp1887_);
		_vala_ccode_node_unref0 (_tmp1887_);
		_tmp1888_ = czero;
		_tmp1889_ = csizeof;
		_tmp1890_ = cdelta;
		_tmp1891_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) _tmp1889_, (ValaCCodeExpression*) _tmp1890_);
		_tmp1892_ = _tmp1891_;
		vala_ccode_function_call_add_argument (_tmp1888_, (ValaCCodeExpression*) _tmp1892_);
		_vala_ccode_node_unref0 (_tmp1892_);
		_tmp1893_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1894_ = _tmp1893_;
		_tmp1895_ = temp_ref;
		_tmp1896_ = new_size;
		vala_ccode_function_add_assignment (_tmp1894_, _tmp1895_, _tmp1896_);
		_tmp1897_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1898_ = _tmp1897_;
		_tmp1899_ = ccall_expr;
		vala_ccode_function_add_expression (_tmp1898_, _tmp1899_);
		_tmp1900_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1901_ = _tmp1900_;
		_tmp1902_ = ccheck;
		_tmp1903_ = czero;
		_tmp1904_ = vala_ccode_constant_new ("NULL");
		_tmp1905_ = _tmp1904_;
		_tmp1906_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp1902_, (ValaCCodeExpression*) _tmp1903_, (ValaCCodeExpression*) _tmp1905_);
		_tmp1907_ = _tmp1906_;
		vala_ccode_function_add_expression (_tmp1901_, (ValaCCodeExpression*) _tmp1907_);
		_vala_ccode_node_unref0 (_tmp1907_);
		_vala_ccode_node_unref0 (_tmp1905_);
		_tmp1908_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp1909_ = _tmp1908_;
		_tmp1910_ = ma;
		_tmp1911_ = vala_member_access_get_inner (_tmp1910_);
		_tmp1912_ = _tmp1911_;
		_tmp1913_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp1912_, 1);
		_tmp1914_ = _tmp1913_;
		_tmp1915_ = temp_ref;
		vala_ccode_function_add_assignment (_tmp1909_, _tmp1914_, _tmp1915_);
		_vala_ccode_node_unref0 (_tmp1914_);
		_tmp1916_ = ma;
		_tmp1917_ = vala_member_access_get_inner (_tmp1916_);
		_tmp1918_ = _tmp1917_;
		_tmp1919_ = vala_expression_get_symbol_reference (_tmp1918_);
		_tmp1920_ = _tmp1919_;
		_tmp1921_ = _vala_code_node_ref0 (_tmp1920_);
		array_var = _tmp1921_;
		_tmp1922_ = array_var;
		_tmp1923_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1922_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp1922_) : NULL);
		array_local = _tmp1923_;
		_tmp1926_ = array_var;
		if (_tmp1926_ != NULL) {
			ValaSymbol* _tmp1927_ = NULL;
			gboolean _tmp1928_ = FALSE;
			_tmp1927_ = array_var;
			_tmp1928_ = vala_symbol_is_internal_symbol (_tmp1927_);
			_tmp1925_ = _tmp1928_;
		} else {
			_tmp1925_ = FALSE;
		}
		if (_tmp1925_) {
			gboolean _tmp1929_ = FALSE;
			gboolean _tmp1930_ = FALSE;
			ValaSymbol* _tmp1931_ = NULL;
			_tmp1931_ = array_var;
			if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1931_, VALA_TYPE_LOCAL_VARIABLE)) {
				ValaLocalVariable* _tmp1932_ = NULL;
				gboolean _tmp1933_ = FALSE;
				gboolean _tmp1934_ = FALSE;
				_tmp1932_ = array_local;
				_tmp1933_ = vala_local_variable_get_captured (_tmp1932_);
				_tmp1934_ = _tmp1933_;
				_tmp1930_ = !_tmp1934_;
			} else {
				_tmp1930_ = FALSE;
			}
			if (_tmp1930_) {
				_tmp1929_ = TRUE;
			} else {
				ValaSymbol* _tmp1935_ = NULL;
				_tmp1935_ = array_var;
				_tmp1929_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1935_, VALA_TYPE_FIELD);
			}
			_tmp1924_ = _tmp1929_;
		} else {
			_tmp1924_ = FALSE;
		}
		if (_tmp1924_) {
			ValaCCodeFunction* _tmp1936_ = NULL;
			ValaCCodeFunction* _tmp1937_ = NULL;
			ValaMemberAccess* _tmp1938_ = NULL;
			ValaExpression* _tmp1939_ = NULL;
			ValaExpression* _tmp1940_ = NULL;
			ValaTargetValue* _tmp1941_ = NULL;
			ValaTargetValue* _tmp1942_ = NULL;
			ValaCCodeExpression* _tmp1943_ = NULL;
			ValaCCodeExpression* _tmp1944_ = NULL;
			ValaCCodeExpression* _tmp1945_ = NULL;
			_tmp1936_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1937_ = _tmp1936_;
			_tmp1938_ = ma;
			_tmp1939_ = vala_member_access_get_inner (_tmp1938_);
			_tmp1940_ = _tmp1939_;
			_tmp1941_ = vala_expression_get_target_value (_tmp1940_);
			_tmp1942_ = _tmp1941_;
			_tmp1943_ = vala_ccode_base_module_get_array_size_cvalue ((ValaCCodeBaseModule*) self, _tmp1942_);
			_tmp1944_ = _tmp1943_;
			_tmp1945_ = temp_ref;
			vala_ccode_function_add_assignment (_tmp1937_, _tmp1944_, _tmp1945_);
			_vala_ccode_node_unref0 (_tmp1944_);
		}
		_vala_code_node_unref0 (array_local);
		_vala_code_node_unref0 (array_var);
		_vala_ccode_node_unref0 (czero);
		_vala_ccode_node_unref0 (ccheck);
		_vala_ccode_node_unref0 (cdelta);
		_vala_ccode_node_unref0 (csizeof);
		_vala_code_node_unref0 (array_type);
		_vala_ccode_node_unref0 (celems);
		_vala_ccode_node_unref0 (clen);
		_vala_ccode_node_unref0 (temp_ref);
		_vala_code_node_unref0 (temp_decl);
		_vala_ccode_node_unref0 (new_size);
		_vala_iterator_unref0 (arg_it);
		_vala_ccode_node_unref0 (out_param_ref);
		_vala_iterator_unref0 (params_it);
		_vala_ccode_node_unref0 (instance);
		_vala_ccode_node_unref0 (ccall_expr);
		_vala_map_unref0 (out_arg_map);
		_vala_map_unref0 (in_arg_map);
		_vala_code_node_unref0 (itype);
		_vala_code_node_unref0 (ma);
		_vala_iterable_unref0 (params);
		_vala_code_node_unref0 (deleg);
		_vala_code_node_unref0 (m);
		_vala_ccode_node_unref0 (finish_call);
		_vala_ccode_node_unref0 (async_call);
		_vala_ccode_node_unref0 (ccall);
		return;
	}
	_tmp1947_ = expr;
	_tmp1948_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp1947_);
	_tmp1949_ = _tmp1948_;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1949_, VALA_TYPE_EXPRESSION_STATEMENT)) {
		ValaMethodCall* _tmp1950_ = NULL;
		ValaDataType* _tmp1951_ = NULL;
		ValaDataType* _tmp1952_ = NULL;
		gboolean _tmp1953_ = FALSE;
		_tmp1950_ = expr;
		_tmp1951_ = vala_expression_get_value_type ((ValaExpression*) _tmp1950_);
		_tmp1952_ = _tmp1951_;
		_tmp1953_ = vala_data_type_is_disposable (_tmp1952_);
		_tmp1946_ = !_tmp1953_;
	} else {
		_tmp1946_ = FALSE;
	}
	if (_tmp1946_) {
		gboolean _tmp1954_ = FALSE;
		ValaCCodeExpression* _tmp1955_ = NULL;
		_tmp1955_ = ccall_expr;
		if (_tmp1955_ != NULL) {
			gboolean _tmp1956_ = FALSE;
			_tmp1956_ = return_result_via_out_param;
			_tmp1954_ = !_tmp1956_;
		} else {
			_tmp1954_ = FALSE;
		}
		if (_tmp1954_) {
			ValaCCodeFunction* _tmp1957_ = NULL;
			ValaCCodeFunction* _tmp1958_ = NULL;
			ValaCCodeExpression* _tmp1959_ = NULL;
			_tmp1957_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp1958_ = _tmp1957_;
			_tmp1959_ = ccall_expr;
			vala_ccode_function_add_expression (_tmp1958_, _tmp1959_);
		}
	} else {
		ValaDataType* result_type = NULL;
		ValaDataType* _tmp1960_ = NULL;
		ValaDataType* _tmp1961_ = NULL;
		gboolean _tmp1962_ = FALSE;
		ValaMethodCall* _tmp1963_ = NULL;
		ValaDataType* _tmp1964_ = NULL;
		ValaDataType* _tmp1965_ = NULL;
		gboolean _tmp1997_ = FALSE;
		ValaMethodCall* _tmp2016_ = NULL;
		ValaTargetValue* _tmp2017_ = NULL;
		ValaTargetValue* _tmp2018_ = NULL;
		_tmp1960_ = itype;
		_tmp1961_ = vala_data_type_get_return_type (_tmp1960_);
		result_type = _tmp1961_;
		_tmp1963_ = expr;
		_tmp1964_ = vala_expression_get_formal_value_type ((ValaExpression*) _tmp1963_);
		_tmp1965_ = _tmp1964_;
		if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1965_, VALA_TYPE_GENERIC_TYPE)) {
			ValaMethodCall* _tmp1966_ = NULL;
			ValaDataType* _tmp1967_ = NULL;
			ValaDataType* _tmp1968_ = NULL;
			_tmp1966_ = expr;
			_tmp1967_ = vala_expression_get_value_type ((ValaExpression*) _tmp1966_);
			_tmp1968_ = _tmp1967_;
			_tmp1962_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1968_, VALA_TYPE_GENERIC_TYPE);
		} else {
			_tmp1962_ = FALSE;
		}
		if (_tmp1962_) {
			ValaStruct* st = NULL;
			ValaMethodCall* _tmp1969_ = NULL;
			ValaDataType* _tmp1970_ = NULL;
			ValaDataType* _tmp1971_ = NULL;
			ValaTypeParameter* _tmp1972_ = NULL;
			ValaTypeParameter* _tmp1973_ = NULL;
			ValaSymbol* _tmp1974_ = NULL;
			ValaSymbol* _tmp1975_ = NULL;
			ValaSymbol* _tmp1976_ = NULL;
			ValaSymbol* _tmp1977_ = NULL;
			ValaStruct* _tmp1978_ = NULL;
			gboolean _tmp1979_ = FALSE;
			ValaMethodCall* _tmp1980_ = NULL;
			ValaDataType* _tmp1981_ = NULL;
			ValaDataType* _tmp1982_ = NULL;
			ValaTypeParameter* _tmp1983_ = NULL;
			ValaTypeParameter* _tmp1984_ = NULL;
			ValaSymbol* _tmp1985_ = NULL;
			ValaSymbol* _tmp1986_ = NULL;
			ValaTypeSymbol* _tmp1987_ = NULL;
			_tmp1969_ = expr;
			_tmp1970_ = vala_expression_get_formal_value_type ((ValaExpression*) _tmp1969_);
			_tmp1971_ = _tmp1970_;
			_tmp1972_ = vala_data_type_get_type_parameter (_tmp1971_);
			_tmp1973_ = _tmp1972_;
			_tmp1974_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1973_);
			_tmp1975_ = _tmp1974_;
			_tmp1976_ = vala_symbol_get_parent_symbol (_tmp1975_);
			_tmp1977_ = _tmp1976_;
			_tmp1978_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1977_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp1977_) : NULL);
			st = _tmp1978_;
			_tmp1980_ = expr;
			_tmp1981_ = vala_expression_get_formal_value_type ((ValaExpression*) _tmp1980_);
			_tmp1982_ = _tmp1981_;
			_tmp1983_ = vala_data_type_get_type_parameter (_tmp1982_);
			_tmp1984_ = _tmp1983_;
			_tmp1985_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1984_);
			_tmp1986_ = _tmp1985_;
			_tmp1987_ = ((ValaCCodeBaseModule*) self)->garray_type;
			if (_tmp1986_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1987_, VALA_TYPE_SYMBOL, ValaSymbol)) {
				_tmp1979_ = TRUE;
			} else {
				gboolean _tmp1988_ = FALSE;
				ValaStruct* _tmp1989_ = NULL;
				_tmp1989_ = st;
				if (_tmp1989_ != NULL) {
					ValaStruct* _tmp1990_ = NULL;
					gchar* _tmp1991_ = NULL;
					gchar* _tmp1992_ = NULL;
					_tmp1990_ = st;
					_tmp1991_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1990_);
					_tmp1992_ = _tmp1991_;
					_tmp1988_ = g_strcmp0 (_tmp1992_, "va_list") == 0;
					_g_free0 (_tmp1992_);
				} else {
					_tmp1988_ = FALSE;
				}
				_tmp1979_ = _tmp1988_;
			}
			if (_tmp1979_) {
				ValaMethodCall* _tmp1993_ = NULL;
				ValaDataType* _tmp1994_ = NULL;
				ValaDataType* _tmp1995_ = NULL;
				ValaDataType* _tmp1996_ = NULL;
				_tmp1993_ = expr;
				_tmp1994_ = vala_expression_get_value_type ((ValaExpression*) _tmp1993_);
				_tmp1995_ = _tmp1994_;
				_tmp1996_ = _vala_code_node_ref0 (_tmp1995_);
				_vala_code_node_unref0 (result_type);
				result_type = _tmp1996_;
			}
			_vala_code_node_unref0 (st);
		}
		_tmp1997_ = return_result_via_out_param;
		if (!_tmp1997_) {
			ValaLocalVariable* temp_var = NULL;
			ValaDataType* _tmp1998_ = NULL;
			ValaDataType* _tmp1999_ = NULL;
			gboolean _tmp2000_ = FALSE;
			gboolean _tmp2001_ = FALSE;
			ValaLocalVariable* _tmp2002_ = NULL;
			ValaCCodeExpression* temp_ref = NULL;
			ValaLocalVariable* _tmp2003_ = NULL;
			const gchar* _tmp2004_ = NULL;
			const gchar* _tmp2005_ = NULL;
			ValaCCodeExpression* _tmp2006_ = NULL;
			ValaLocalVariable* _tmp2007_ = NULL;
			ValaCCodeFunction* _tmp2008_ = NULL;
			ValaCCodeFunction* _tmp2009_ = NULL;
			ValaCCodeExpression* _tmp2010_ = NULL;
			ValaCCodeExpression* _tmp2011_ = NULL;
			ValaMethodCall* _tmp2012_ = NULL;
			ValaCCodeExpression* _tmp2013_ = NULL;
			_tmp1998_ = result_type;
			_tmp1999_ = result_type;
			_tmp2000_ = vala_data_type_get_value_owned (_tmp1999_);
			_tmp2001_ = _tmp2000_;
			_tmp2002_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1998_, _tmp2001_, NULL, TRUE);
			temp_var = _tmp2002_;
			_tmp2003_ = temp_var;
			_tmp2004_ = vala_symbol_get_name ((ValaSymbol*) _tmp2003_);
			_tmp2005_ = _tmp2004_;
			_tmp2006_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp2005_);
			temp_ref = _tmp2006_;
			_tmp2007_ = temp_var;
			vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp2007_);
			_tmp2008_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp2009_ = _tmp2008_;
			_tmp2010_ = temp_ref;
			_tmp2011_ = ccall_expr;
			vala_ccode_function_add_assignment (_tmp2009_, _tmp2010_, _tmp2011_);
			_tmp2012_ = expr;
			_tmp2013_ = temp_ref;
			vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp2012_, _tmp2013_);
			_vala_ccode_node_unref0 (temp_ref);
			_vala_code_node_unref0 (temp_var);
		} else {
			ValaMethodCall* _tmp2014_ = NULL;
			ValaCCodeExpression* _tmp2015_ = NULL;
			_tmp2014_ = expr;
			_tmp2015_ = ccall_expr;
			vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp2014_, _tmp2015_);
		}
		_tmp2016_ = expr;
		_tmp2017_ = vala_expression_get_target_value ((ValaExpression*) _tmp2016_);
		_tmp2018_ = _tmp2017_;
		G_TYPE_CHECK_INSTANCE_CAST (_tmp2018_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE;
		_vala_code_node_unref0 (result_type);
	}
	_tmp2019_ = params;
	_tmp2020_ = vala_iterable_iterator ((ValaIterable*) _tmp2019_);
	_vala_iterator_unref0 (params_it);
	params_it = _tmp2020_;
	{
		ValaList* _arg_list = NULL;
		ValaMethodCall* _tmp2021_ = NULL;
		ValaList* _tmp2022_ = NULL;
		gint _arg_size = 0;
		ValaList* _tmp2023_ = NULL;
		gint _tmp2024_ = 0;
		gint _tmp2025_ = 0;
		gint _arg_index = 0;
		_tmp2021_ = expr;
		_tmp2022_ = vala_method_call_get_argument_list (_tmp2021_);
		_arg_list = _tmp2022_;
		_tmp2023_ = _arg_list;
		_tmp2024_ = vala_collection_get_size ((ValaCollection*) _tmp2023_);
		_tmp2025_ = _tmp2024_;
		_arg_size = _tmp2025_;
		_arg_index = -1;
		while (TRUE) {
			gint _tmp2026_ = 0;
			gint _tmp2027_ = 0;
			gint _tmp2028_ = 0;
			ValaExpression* arg = NULL;
			ValaList* _tmp2029_ = NULL;
			gint _tmp2030_ = 0;
			gpointer _tmp2031_ = NULL;
			ValaIterator* _tmp2032_ = NULL;
			gboolean _tmp2033_ = FALSE;
			ValaUnaryExpression* unary = NULL;
			ValaExpression* _tmp2043_ = NULL;
			ValaUnaryExpression* _tmp2044_ = NULL;
			gboolean _tmp2045_ = FALSE;
			ValaUnaryExpression* _tmp2046_ = NULL;
			ValaUnaryExpression* _tmp2050_ = NULL;
			ValaExpression* _tmp2051_ = NULL;
			ValaExpression* _tmp2052_ = NULL;
			ValaDataType* _tmp2053_ = NULL;
			ValaDataType* _tmp2054_ = NULL;
			gboolean _tmp2055_ = FALSE;
			ValaUnaryExpression* _tmp2065_ = NULL;
			ValaExpression* _tmp2066_ = NULL;
			ValaExpression* _tmp2067_ = NULL;
			ValaTargetValue* _tmp2068_ = NULL;
			ValaTargetValue* _tmp2069_ = NULL;
			ValaUnaryExpression* _tmp2070_ = NULL;
			ValaTargetValue* _tmp2071_ = NULL;
			ValaTargetValue* _tmp2072_ = NULL;
			ValaUnaryExpression* _tmp2073_ = NULL;
			ValaExpression* _tmp2074_ = NULL;
			ValaExpression* _tmp2075_ = NULL;
			ValaDataType* _tmp2076_ = NULL;
			ValaDataType* _tmp2077_ = NULL;
			ValaExpression* _tmp2078_ = NULL;
			ValaTargetValue* _tmp2079_ = NULL;
			ValaTargetValue* _tmp2080_ = NULL;
			_tmp2026_ = _arg_index;
			_arg_index = _tmp2026_ + 1;
			_tmp2027_ = _arg_index;
			_tmp2028_ = _arg_size;
			if (!(_tmp2027_ < _tmp2028_)) {
				break;
			}
			_tmp2029_ = _arg_list;
			_tmp2030_ = _arg_index;
			_tmp2031_ = vala_list_get (_tmp2029_, _tmp2030_);
			arg = (ValaExpression*) _tmp2031_;
			_tmp2032_ = params_it;
			_tmp2033_ = vala_iterator_next (_tmp2032_);
			if (_tmp2033_) {
				ValaParameter* param = NULL;
				ValaIterator* _tmp2034_ = NULL;
				gpointer _tmp2035_ = NULL;
				gboolean _tmp2036_ = FALSE;
				ValaParameter* _tmp2037_ = NULL;
				gboolean _tmp2038_ = FALSE;
				gboolean _tmp2039_ = FALSE;
				_tmp2034_ = params_it;
				_tmp2035_ = vala_iterator_get (_tmp2034_);
				param = (ValaParameter*) _tmp2035_;
				_tmp2037_ = param;
				_tmp2038_ = vala_parameter_get_params_array (_tmp2037_);
				_tmp2039_ = _tmp2038_;
				if (_tmp2039_) {
					_tmp2036_ = TRUE;
				} else {
					ValaParameter* _tmp2040_ = NULL;
					gboolean _tmp2041_ = FALSE;
					gboolean _tmp2042_ = FALSE;
					_tmp2040_ = param;
					_tmp2041_ = vala_parameter_get_ellipsis (_tmp2040_);
					_tmp2042_ = _tmp2041_;
					_tmp2036_ = _tmp2042_;
				}
				if (_tmp2036_) {
					_vala_code_node_unref0 (param);
					_vala_code_node_unref0 (arg);
					break;
				}
				_vala_code_node_unref0 (param);
			}
			_tmp2043_ = arg;
			_tmp2044_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2043_, VALA_TYPE_UNARY_EXPRESSION) ? ((ValaUnaryExpression*) _tmp2043_) : NULL);
			unary = _tmp2044_;
			_tmp2046_ = unary;
			if (_tmp2046_ == NULL) {
				_tmp2045_ = TRUE;
			} else {
				ValaUnaryExpression* _tmp2047_ = NULL;
				ValaUnaryOperator _tmp2048_ = 0;
				ValaUnaryOperator _tmp2049_ = 0;
				_tmp2047_ = unary;
				_tmp2048_ = vala_unary_expression_get_operator (_tmp2047_);
				_tmp2049_ = _tmp2048_;
				_tmp2045_ = _tmp2049_ != VALA_UNARY_OPERATOR_OUT;
			}
			if (_tmp2045_) {
				_vala_code_node_unref0 (unary);
				_vala_code_node_unref0 (arg);
				continue;
			}
			_tmp2050_ = unary;
			_tmp2051_ = vala_unary_expression_get_inner (_tmp2050_);
			_tmp2052_ = _tmp2051_;
			_tmp2053_ = vala_expression_get_value_type (_tmp2052_);
			_tmp2054_ = _tmp2053_;
			_tmp2055_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp2054_);
			if (_tmp2055_) {
				ValaCCodeFunction* _tmp2056_ = NULL;
				ValaCCodeFunction* _tmp2057_ = NULL;
				ValaUnaryExpression* _tmp2058_ = NULL;
				ValaExpression* _tmp2059_ = NULL;
				ValaExpression* _tmp2060_ = NULL;
				ValaTargetValue* _tmp2061_ = NULL;
				ValaTargetValue* _tmp2062_ = NULL;
				ValaCCodeExpression* _tmp2063_ = NULL;
				ValaCCodeExpression* _tmp2064_ = NULL;
				_tmp2056_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp2057_ = _tmp2056_;
				_tmp2058_ = unary;
				_tmp2059_ = vala_unary_expression_get_inner (_tmp2058_);
				_tmp2060_ = _tmp2059_;
				_tmp2061_ = vala_expression_get_target_value (_tmp2060_);
				_tmp2062_ = _tmp2061_;
				_tmp2063_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, _tmp2062_, FALSE);
				_tmp2064_ = _tmp2063_;
				vala_ccode_function_add_expression (_tmp2057_, _tmp2064_);
				_vala_ccode_node_unref0 (_tmp2064_);
			}
			_tmp2065_ = unary;
			_tmp2066_ = vala_unary_expression_get_inner (_tmp2065_);
			_tmp2067_ = _tmp2066_;
			_tmp2068_ = vala_expression_get_target_value (_tmp2067_);
			_tmp2069_ = _tmp2068_;
			_tmp2070_ = unary;
			_tmp2071_ = vala_expression_get_target_value ((ValaExpression*) _tmp2070_);
			_tmp2072_ = _tmp2071_;
			_tmp2073_ = unary;
			_tmp2074_ = vala_unary_expression_get_inner (_tmp2073_);
			_tmp2075_ = _tmp2074_;
			_tmp2076_ = vala_expression_get_value_type (_tmp2075_);
			_tmp2077_ = _tmp2076_;
			_tmp2078_ = arg;
			_tmp2079_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, _tmp2072_, _tmp2077_, (ValaCodeNode*) _tmp2078_);
			_tmp2080_ = _tmp2079_;
			vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp2069_, _tmp2080_);
			_vala_target_value_unref0 (_tmp2080_);
			_vala_code_node_unref0 (unary);
			_vala_code_node_unref0 (arg);
		}
		_vala_iterable_unref0 (_arg_list);
	}
	_tmp2083_ = m;
	if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2083_, VALA_TYPE_CREATION_METHOD)) {
		ValaMethod* _tmp2084_ = NULL;
		ValaSymbol* _tmp2085_ = NULL;
		ValaSymbol* _tmp2086_ = NULL;
		_tmp2084_ = m;
		_tmp2085_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2084_);
		_tmp2086_ = _tmp2085_;
		_tmp2082_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2086_, VALA_TYPE_CLASS);
	} else {
		_tmp2082_ = FALSE;
	}
	if (_tmp2082_) {
		ValaClass* _tmp2087_ = NULL;
		ValaClass* _tmp2088_ = NULL;
		ValaClass* _tmp2089_ = NULL;
		ValaClass* _tmp2090_ = NULL;
		ValaClass* _tmp2091_ = NULL;
		_tmp2087_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp2088_ = _tmp2087_;
		_tmp2089_ = vala_class_get_base_class (_tmp2088_);
		_tmp2090_ = _tmp2089_;
		_tmp2091_ = ((ValaCCodeBaseModule*) self)->gsource_type;
		_tmp2081_ = _tmp2090_ == _tmp2091_;
	} else {
		_tmp2081_ = FALSE;
	}
	if (_tmp2081_) {
		ValaCCodeFunctionCall* cinitcall = NULL;
		ValaClass* _tmp2092_ = NULL;
		ValaClass* _tmp2093_ = NULL;
		gchar* _tmp2094_ = NULL;
		gchar* _tmp2095_ = NULL;
		gchar* _tmp2096_ = NULL;
		gchar* _tmp2097_ = NULL;
		ValaCCodeIdentifier* _tmp2098_ = NULL;
		ValaCCodeIdentifier* _tmp2099_ = NULL;
		ValaCCodeFunctionCall* _tmp2100_ = NULL;
		ValaCCodeFunctionCall* _tmp2101_ = NULL;
		ValaCCodeFunctionCall* _tmp2102_ = NULL;
		ValaCCodeExpression* _tmp2103_ = NULL;
		ValaCCodeExpression* _tmp2104_ = NULL;
		ValaCCodeFunction* _tmp2105_ = NULL;
		ValaCCodeFunction* _tmp2106_ = NULL;
		ValaCCodeFunctionCall* _tmp2107_ = NULL;
		_tmp2092_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
		_tmp2093_ = _tmp2092_;
		_tmp2094_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp2093_, NULL);
		_tmp2095_ = _tmp2094_;
		_tmp2096_ = g_strdup_printf ("%s_instance_init", _tmp2095_);
		_tmp2097_ = _tmp2096_;
		_tmp2098_ = vala_ccode_identifier_new (_tmp2097_);
		_tmp2099_ = _tmp2098_;
		_tmp2100_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2099_);
		_tmp2101_ = _tmp2100_;
		_vala_ccode_node_unref0 (_tmp2099_);
		_g_free0 (_tmp2097_);
		_g_free0 (_tmp2095_);
		cinitcall = _tmp2101_;
		_tmp2102_ = cinitcall;
		_tmp2103_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self);
		_tmp2104_ = _tmp2103_;
		vala_ccode_function_call_add_argument (_tmp2102_, _tmp2104_);
		_vala_ccode_node_unref0 (_tmp2104_);
		_tmp2105_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp2106_ = _tmp2105_;
		_tmp2107_ = cinitcall;
		vala_ccode_function_add_expression (_tmp2106_, (ValaCCodeExpression*) _tmp2107_);
		_vala_ccode_node_unref0 (cinitcall);
	}
	_vala_ccode_node_unref0 (out_param_ref);
	_vala_iterator_unref0 (params_it);
	_vala_ccode_node_unref0 (instance);
	_vala_ccode_node_unref0 (ccall_expr);
	_vala_map_unref0 (out_arg_map);
	_vala_map_unref0 (in_arg_map);
	_vala_code_node_unref0 (itype);
	_vala_code_node_unref0 (ma);
	_vala_iterable_unref0 (params);
	_vala_code_node_unref0 (deleg);
	_vala_code_node_unref0 (m);
	_vala_ccode_node_unref0 (finish_call);
	_vala_ccode_node_unref0 (async_call);
	_vala_ccode_node_unref0 (ccall);
}


static gchar* vala_ccode_method_call_module_generate_enum_tostring_function (ValaCCodeMethodCallModule* self, ValaEnum* en) {
	gchar* result = NULL;
	gchar* to_string_func = NULL;
	ValaEnum* _tmp0_ = NULL;
	gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	gchar* _tmp3_ = NULL;
	gchar* _tmp4_ = NULL;
	const gchar* _tmp5_ = NULL;
	gboolean _tmp6_ = FALSE;
	ValaCCodeFunction* function = NULL;
	const gchar* _tmp7_ = NULL;
	ValaCCodeFunction* _tmp8_ = NULL;
	ValaCCodeFunction* _tmp9_ = NULL;
	ValaCCodeFunction* _tmp10_ = NULL;
	ValaEnum* _tmp11_ = NULL;
	gchar* _tmp12_ = NULL;
	gchar* _tmp13_ = NULL;
	ValaCCodeParameter* _tmp14_ = NULL;
	ValaCCodeParameter* _tmp15_ = NULL;
	ValaCCodeBaseModuleEmitContext* _tmp16_ = NULL;
	ValaCCodeBaseModuleEmitContext* _tmp17_ = NULL;
	ValaCCodeFunction* _tmp18_ = NULL;
	ValaCCodeFunction* _tmp19_ = NULL;
	ValaCCodeFunction* _tmp20_ = NULL;
	ValaCCodeConstant* _tmp21_ = NULL;
	ValaCCodeConstant* _tmp22_ = NULL;
	ValaCCodeFunction* _tmp52_ = NULL;
	ValaCCodeFunction* _tmp53_ = NULL;
	ValaCCodeFunction* _tmp54_ = NULL;
	ValaCCodeFunction* _tmp55_ = NULL;
	ValaCCodeConstant* _tmp56_ = NULL;
	ValaCCodeConstant* _tmp57_ = NULL;
	ValaCCodeFile* _tmp58_ = NULL;
	ValaCCodeFunction* _tmp59_ = NULL;
	ValaCCodeFile* _tmp60_ = NULL;
	ValaCCodeFunction* _tmp61_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (en != NULL, NULL);
	_tmp0_ = en;
	_tmp1_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp0_, NULL);
	_tmp2_ = _tmp1_;
	_tmp3_ = g_strdup_printf ("_%s_to_string", _tmp2_);
	_tmp4_ = _tmp3_;
	_g_free0 (_tmp2_);
	to_string_func = _tmp4_;
	_tmp5_ = to_string_func;
	_tmp6_ = vala_ccode_base_module_add_wrapper ((ValaCCodeBaseModule*) self, _tmp5_);
	if (!_tmp6_) {
		result = to_string_func;
		return result;
	}
	_tmp7_ = to_string_func;
	_tmp8_ = vala_ccode_function_new (_tmp7_, "const char*");
	function = _tmp8_;
	_tmp9_ = function;
	vala_ccode_function_set_modifiers (_tmp9_, VALA_CCODE_MODIFIERS_STATIC);
	_tmp10_ = function;
	_tmp11_ = en;
	_tmp12_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp11_);
	_tmp13_ = _tmp12_;
	_tmp14_ = vala_ccode_parameter_new ("value", _tmp13_);
	_tmp15_ = _tmp14_;
	vala_ccode_function_add_parameter (_tmp10_, _tmp15_);
	_vala_ccode_node_unref0 (_tmp15_);
	_g_free0 (_tmp13_);
	_tmp16_ = vala_ccode_base_module_emit_context_new (NULL);
	_tmp17_ = _tmp16_;
	vala_ccode_base_module_push_context ((ValaCCodeBaseModule*) self, _tmp17_);
	_vala_ccode_base_module_emit_context_unref0 (_tmp17_);
	_tmp18_ = function;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp18_);
	_tmp19_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp20_ = _tmp19_;
	_tmp21_ = vala_ccode_constant_new ("value");
	_tmp22_ = _tmp21_;
	vala_ccode_function_open_switch (_tmp20_, (ValaCCodeExpression*) _tmp22_);
	_vala_ccode_node_unref0 (_tmp22_);
	{
		ValaList* _enum_value_list = NULL;
		ValaEnum* _tmp23_ = NULL;
		ValaList* _tmp24_ = NULL;
		gint _enum_value_size = 0;
		ValaList* _tmp25_ = NULL;
		gint _tmp26_ = 0;
		gint _tmp27_ = 0;
		gint _enum_value_index = 0;
		_tmp23_ = en;
		_tmp24_ = vala_enum_get_values (_tmp23_);
		_enum_value_list = _tmp24_;
		_tmp25_ = _enum_value_list;
		_tmp26_ = vala_collection_get_size ((ValaCollection*) _tmp25_);
		_tmp27_ = _tmp26_;
		_enum_value_size = _tmp27_;
		_enum_value_index = -1;
		while (TRUE) {
			gint _tmp28_ = 0;
			gint _tmp29_ = 0;
			gint _tmp30_ = 0;
			ValaEnumValue* enum_value = NULL;
			ValaList* _tmp31_ = NULL;
			gint _tmp32_ = 0;
			gpointer _tmp33_ = NULL;
			ValaCCodeFunction* _tmp34_ = NULL;
			ValaCCodeFunction* _tmp35_ = NULL;
			ValaEnumValue* _tmp36_ = NULL;
			gchar* _tmp37_ = NULL;
			gchar* _tmp38_ = NULL;
			ValaCCodeIdentifier* _tmp39_ = NULL;
			ValaCCodeIdentifier* _tmp40_ = NULL;
			ValaCCodeFunction* _tmp41_ = NULL;
			ValaCCodeFunction* _tmp42_ = NULL;
			ValaEnumValue* _tmp43_ = NULL;
			gchar* _tmp44_ = NULL;
			gchar* _tmp45_ = NULL;
			gchar* _tmp46_ = NULL;
			gchar* _tmp47_ = NULL;
			gchar* _tmp48_ = NULL;
			gchar* _tmp49_ = NULL;
			ValaCCodeConstant* _tmp50_ = NULL;
			ValaCCodeConstant* _tmp51_ = NULL;
			_tmp28_ = _enum_value_index;
			_enum_value_index = _tmp28_ + 1;
			_tmp29_ = _enum_value_index;
			_tmp30_ = _enum_value_size;
			if (!(_tmp29_ < _tmp30_)) {
				break;
			}
			_tmp31_ = _enum_value_list;
			_tmp32_ = _enum_value_index;
			_tmp33_ = vala_list_get (_tmp31_, _tmp32_);
			enum_value = (ValaEnumValue*) _tmp33_;
			_tmp34_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp35_ = _tmp34_;
			_tmp36_ = enum_value;
			_tmp37_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp36_);
			_tmp38_ = _tmp37_;
			_tmp39_ = vala_ccode_identifier_new (_tmp38_);
			_tmp40_ = _tmp39_;
			vala_ccode_function_add_case (_tmp35_, (ValaCCodeExpression*) _tmp40_);
			_vala_ccode_node_unref0 (_tmp40_);
			_g_free0 (_tmp38_);
			_tmp41_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp42_ = _tmp41_;
			_tmp43_ = enum_value;
			_tmp44_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp43_);
			_tmp45_ = _tmp44_;
			_tmp46_ = g_strconcat ("\"", _tmp45_, NULL);
			_tmp47_ = _tmp46_;
			_tmp48_ = g_strconcat (_tmp47_, "\"", NULL);
			_tmp49_ = _tmp48_;
			_tmp50_ = vala_ccode_constant_new (_tmp49_);
			_tmp51_ = _tmp50_;
			vala_ccode_function_add_return (_tmp42_, (ValaCCodeExpression*) _tmp51_);
			_vala_ccode_node_unref0 (_tmp51_);
			_g_free0 (_tmp49_);
			_g_free0 (_tmp47_);
			_g_free0 (_tmp45_);
			_vala_code_node_unref0 (enum_value);
		}
		_vala_iterable_unref0 (_enum_value_list);
	}
	_tmp52_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp53_ = _tmp52_;
	vala_ccode_function_close (_tmp53_);
	_tmp54_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp55_ = _tmp54_;
	_tmp56_ = vala_ccode_constant_new ("NULL");
	_tmp57_ = _tmp56_;
	vala_ccode_function_add_return (_tmp55_, (ValaCCodeExpression*) _tmp57_);
	_vala_ccode_node_unref0 (_tmp57_);
	_tmp58_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp59_ = function;
	vala_ccode_file_add_function_declaration (_tmp58_, _tmp59_);
	_tmp60_ = ((ValaCCodeBaseModule*) self)->cfile;
	_tmp61_ = function;
	vala_ccode_file_add_function (_tmp60_, _tmp61_);
	vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self);
	result = to_string_func;
	_vala_ccode_node_unref0 (function);
	return result;
}


ValaCCodeMethodCallModule* vala_ccode_method_call_module_construct (GType object_type) {
	ValaCCodeMethodCallModule* self = NULL;
	self = (ValaCCodeMethodCallModule*) vala_ccode_assignment_module_construct (object_type);
	return self;
}


ValaCCodeMethodCallModule* vala_ccode_method_call_module_new (void) {
	return vala_ccode_method_call_module_construct (VALA_TYPE_CCODE_METHOD_CALL_MODULE);
}


static void vala_ccode_method_call_module_class_init (ValaCCodeMethodCallModuleClass * klass) {
	vala_ccode_method_call_module_parent_class = g_type_class_peek_parent (klass);
	((ValaCodeVisitorClass *) klass)->visit_method_call = vala_ccode_method_call_module_real_visit_method_call;
}


static void vala_ccode_method_call_module_instance_init (ValaCCodeMethodCallModule * self) {
}


GType vala_ccode_method_call_module_get_type (void) {
	static volatile gsize vala_ccode_method_call_module_type_id__volatile = 0;
	if (g_once_init_enter (&vala_ccode_method_call_module_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeMethodCallModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_method_call_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeMethodCallModule), 0, (GInstanceInitFunc) vala_ccode_method_call_module_instance_init, NULL };
		GType vala_ccode_method_call_module_type_id;
		vala_ccode_method_call_module_type_id = g_type_register_static (VALA_TYPE_CCODE_ASSIGNMENT_MODULE, "ValaCCodeMethodCallModule", &g_define_type_info, 0);
		g_once_init_leave (&vala_ccode_method_call_module_type_id__volatile, vala_ccode_method_call_module_type_id);
	}
	return vala_ccode_method_call_module_type_id__volatile;
}


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


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


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



