/* 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)))
typedef struct _ValaCCodeBaseModuleEmitContextPrivate ValaCCodeBaseModuleEmitContextPrivate;
#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);
#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

struct _ValaCCodeBaseModule {
	ValaCodeGenerator parent_instance;
	ValaCCodeBaseModulePrivate * priv;
	ValaSymbol* root_symbol;
	ValaCCodeBaseModuleEmitContext* emit_context;
	ValaCCodeLineDirective* current_line;
	ValaCCodeFile* header_file;
	ValaCCodeFile* internal_header_file;
	ValaCCodeFile* cfile;
	ValaCCodeBaseModuleEmitContext* class_init_context;
	ValaCCodeBaseModuleEmitContext* base_init_context;
	ValaCCodeBaseModuleEmitContext* class_finalize_context;
	ValaCCodeBaseModuleEmitContext* base_finalize_context;
	ValaCCodeBaseModuleEmitContext* instance_init_context;
	ValaCCodeBaseModuleEmitContext* instance_finalize_context;
	ValaCCodeStruct* param_spec_struct;
	ValaCCodeStruct* closure_struct;
	ValaCCodeEnum* prop_enum;
	ValaCCodeEnum* signal_enum;
	ValaSet* user_marshal_set;
	ValaSet* predefined_marshal_set;
	gint next_regex_id;
	gint next_coroutine_state G_GNUC_DEPRECATED;
	ValaDataType* void_type;
	ValaDataType* bool_type;
	ValaDataType* char_type;
	ValaDataType* uchar_type;
	ValaDataType* unichar_type;
	ValaDataType* short_type;
	ValaDataType* ushort_type;
	ValaDataType* int_type;
	ValaDataType* uint_type;
	ValaDataType* long_type;
	ValaDataType* ulong_type;
	ValaDataType* int8_type;
	ValaDataType* uint8_type;
	ValaDataType* int16_type;
	ValaDataType* uint16_type;
	ValaDataType* int32_type;
	ValaDataType* uint32_type;
	ValaDataType* int64_type;
	ValaDataType* uint64_type;
	ValaDataType* string_type;
	ValaDataType* regex_type;
	ValaDataType* float_type;
	ValaDataType* double_type;
	ValaTypeSymbol* gtype_type;
	ValaTypeSymbol* gobject_type;
	ValaErrorType* gerror_type;
	ValaClass* glist_type;
	ValaClass* gslist_type;
	ValaClass* gnode_type;
	ValaClass* gqueue_type;
	ValaClass* gvaluearray_type;
	ValaTypeSymbol* gstringbuilder_type;
	ValaTypeSymbol* garray_type;
	ValaTypeSymbol* gbytearray_type;
	ValaTypeSymbol* gptrarray_type;
	ValaTypeSymbol* gthreadpool_type;
	ValaDataType* gdestroynotify_type;
	ValaDataType* gquark_type;
	ValaStruct* gvalue_type;
	ValaClass* gvariant_type;
	ValaStruct* mutex_type;
	ValaStruct* gmutex_type;
	ValaStruct* grecmutex_type;
	ValaStruct* grwlock_type;
	ValaStruct* gcond_type;
	ValaClass* gsource_type;
	ValaTypeSymbol* type_module_type;
	ValaTypeSymbol* dbus_proxy_type;
	ValaClass* gtk_widget_type;
	gboolean in_plugin;
	gchar* module_init_param_name;
	gboolean gvaluecollector_h_needed;
	gboolean requires_assert;
	gboolean requires_array_free;
	gboolean requires_array_move;
	gboolean requires_array_length;
	gboolean requires_clear_mutex;
	ValaSet* wrappers;
};

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

struct _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 _ValaCCodeBaseModuleEmitContext {
	GTypeInstance parent_instance;
	volatile int ref_count;
	ValaCCodeBaseModuleEmitContextPrivate * priv;
	ValaSymbol* current_symbol;
	ValaArrayList* symbol_stack;
	ValaTryStatement* current_try;
	ValaCatchClause* current_catch;
	ValaCCodeFunction* ccode;
	ValaArrayList* ccode_stack;
	ValaArrayList* temp_ref_values;
	gint next_temp_var_id;
	gboolean current_method_inner_error;
	gboolean current_method_return;
	ValaMap* variable_name_map;
	ValaMap* closure_variable_count_map;
	ValaMap* closure_variable_clash_map;
	gint next_coroutine_state;
};

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

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

struct _ValaGLibValueClass {
	ValaTargetValueClass parent_class;
};


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);
gboolean vala_ccode_base_module_get_ccode_simple_generics (ValaMethod* m);
void vala_ccode_base_module_check_type_arguments (ValaCCodeBaseModule* self, ValaMemberAccess* access);
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);
ValaTargetValue* vala_ccode_base_module_copy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
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);
gboolean vala_ccode_base_module_get_ccode_finish_instance (ValaCodeNode* node);
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);
G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
G_GNUC_INTERNAL ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
G_GNUC_INTERNAL GType vala_glib_value_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
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);
ValaCCodeExpression* vala_ccode_base_module_get_array_length_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim);
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_;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp2_ = FALSE;
	gchar** _tmp3_;
	gint _tmp3__length1;
	_tmp0_ = separator;
	if (_tmp0_ == NULL) {
		separator = "";
	}
	_tmp3_ = str_array;
	_tmp3__length1 = str_array_length1;
	if (_tmp3_ != NULL) {
		_tmp2_ = TRUE;
	} else {
		gchar** _tmp4_;
		gint _tmp4__length1;
		_tmp4_ = str_array;
		_tmp4__length1 = str_array_length1;
		_tmp2_ = _tmp4__length1 > 0;
	}
	if (_tmp2_) {
		_tmp1_ = TRUE;
	} else {
		gboolean _tmp5_ = FALSE;
		gchar** _tmp6_;
		gint _tmp6__length1;
		_tmp6_ = str_array;
		_tmp6__length1 = str_array_length1;
		if (_tmp6__length1 == -1) {
			gchar** _tmp7_;
			gint _tmp7__length1;
			const gchar* _tmp8_;
			_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_;
		gint _tmp33_;
		gint _tmp34_;
		gsize _tmp35_;
		const gchar* _tmp36_;
		gint _tmp37_;
		gint _tmp38_;
		gint _tmp39_;
		const gchar* res = NULL;
		gsize _tmp40_;
		void* _tmp41_;
		void* ptr = NULL;
		const gchar* _tmp42_;
		gchar** _tmp43_;
		gint _tmp43__length1;
		const gchar* _tmp44_;
		void* _tmp45_;
		const gchar* _tmp62_;
		len = (gsize) 1;
		{
			gboolean _tmp9_ = FALSE;
			i = 0;
			_tmp9_ = TRUE;
			while (TRUE) {
				gboolean _tmp11_ = FALSE;
				gboolean _tmp12_ = FALSE;
				gchar** _tmp13_;
				gint _tmp13__length1;
				gint _tmp21_ = 0;
				gchar** _tmp22_;
				gint _tmp22__length1;
				gint _tmp23_;
				const gchar* _tmp24_;
				gsize _tmp30_;
				if (!_tmp9_) {
					gint _tmp10_;
					_tmp10_ = i;
					i = _tmp10_ + 1;
				}
				_tmp9_ = FALSE;
				_tmp13_ = str_array;
				_tmp13__length1 = str_array_length1;
				if (_tmp13__length1 != -1) {
					gint _tmp14_;
					gchar** _tmp15_;
					gint _tmp15__length1;
					_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_;
					gint _tmp17__length1;
					_tmp17_ = str_array;
					_tmp17__length1 = str_array_length1;
					if (_tmp17__length1 == -1) {
						gchar** _tmp18_;
						gint _tmp18__length1;
						gint _tmp19_;
						const gchar* _tmp20_;
						_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_;
					gint _tmp25__length1;
					gint _tmp26_;
					const gchar* _tmp27_;
					gint _tmp28_;
					gint _tmp29_;
					_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_;
			_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_;
				gchar** _tmp49_;
				gint _tmp49__length1;
				void* _tmp50_;
				const gchar* _tmp51_;
				void* _tmp52_;
				const gchar* _tmp53_ = NULL;
				gchar** _tmp54_;
				gint _tmp54__length1;
				gint _tmp55_;
				const gchar* _tmp56_;
				void* _tmp60_;
				void* _tmp61_;
				if (!_tmp46_) {
					gint _tmp47_;
					_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_;
					gint _tmp57__length1;
					gint _tmp58_;
					const gchar* _tmp59_;
					_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_;
		_tmp63_ = g_strdup ("");
		result = _tmp63_;
		return result;
	}
}


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


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


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



