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

#include <glib-object.h>
#include <glib.h>

#if !defined(VALA_EXTERN)
#if defined(_WIN32) || defined(__CYGWIN__)
#define VALA_EXTERN __declspec(dllexport) extern
#elif __GNUC__ >= 4
#define VALA_EXTERN __attribute__((visibility("default"))) extern
#else
#define VALA_EXTERN extern
#endif
#endif

#define TYPE_FOO (foo_get_type ())
#define FOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FOO, Foo))
#define FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FOO, FooClass))
#define IS_FOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FOO))
#define IS_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FOO))
#define FOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FOO, FooClass))

typedef struct _Foo Foo;
typedef struct _FooClass FooClass;
typedef struct _FooPrivate FooPrivate;
enum  {
	FOO_0_PROPERTY,
	FOO_NUM_PROPERTIES
};
static GParamSpec* foo_properties[FOO_NUM_PROPERTIES];
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
typedef struct _Block1Data Block1Data;
#define _g_ptr_array_unref0(var) ((var == NULL) ? NULL : (var = (g_ptr_array_unref (var), NULL)))
typedef struct _Block2Data Block2Data;
#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 _Foo {
	GObject parent_instance;
	FooPrivate * priv;
	gint i;
};

struct _FooClass {
	GObjectClass parent_class;
};

struct _Block1Data {
	int _ref_count_;
	GPtrArray* self;
	GCompareFunc compare_func;
};

struct _Block2Data {
	int _ref_count_;
	GPtrArray* self;
	GCompareDataFunc compare_func;
	gpointer compare_func_target;
};

static gpointer foo_parent_class = NULL;

VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, g_object_unref)
VALA_EXTERN Foo* foo_new (gint i);
VALA_EXTERN Foo* foo_construct (GType object_type,
                    gint i);
static void foo_finalize (GObject * obj);
static GType foo_get_type_once (void);
VALA_EXTERN gint compare_foo (Foo* a,
                  Foo* b);
static void _vala_main (void);
static void _g_object_unref0_ (gpointer var);
static Block1Data* block1_data_ref (Block1Data* _data1_);
static void block1_data_unref (void * _userdata_);
static gint __vala_lambda0__gcompare_data_func (gconstpointer a,
                                         gconstpointer b,
                                         gpointer self);
static gint _compare_foo_gcompare_func (gconstpointer a,
                                 gconstpointer b);
static Block2Data* block2_data_ref (Block2Data* _data2_);
static void block2_data_unref (void * _userdata_);
static gint __vala_lambda1__gcompare_data_func (gconstpointer a,
                                         gconstpointer b,
                                         gpointer self);
static gint _compare_foo_gcompare_data_func (gconstpointer a,
                                      gconstpointer b,
                                      gpointer self);

Foo*
foo_construct (GType object_type,
               gint i)
{
	Foo * self = NULL;
	self = (Foo*) g_object_new (object_type, NULL);
	self->i = i;
	return self;
}

Foo*
foo_new (gint i)
{
	return foo_construct (TYPE_FOO, i);
}

static void
foo_class_init (FooClass * klass,
                gpointer klass_data)
{
	foo_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = foo_finalize;
}

static void
foo_instance_init (Foo * self,
                   gpointer klass)
{
}

static void
foo_finalize (GObject * obj)
{
	Foo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FOO, Foo);
	G_OBJECT_CLASS (foo_parent_class)->finalize (obj);
}

static GType
foo_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (FooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) foo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Foo), 0, (GInstanceInitFunc) foo_instance_init, NULL };
	GType foo_type_id;
	foo_type_id = g_type_register_static (G_TYPE_OBJECT, "Foo", &g_define_type_info, 0);
	return foo_type_id;
}

GType
foo_get_type (void)
{
	static volatile gsize foo_type_id__once = 0;
	if (g_once_init_enter (&foo_type_id__once)) {
		GType foo_type_id;
		foo_type_id = foo_get_type_once ();
		g_once_init_leave (&foo_type_id__once, foo_type_id);
	}
	return foo_type_id__once;
}

gint
compare_foo (Foo* a,
             Foo* b)
{
	gint result;
	g_return_val_if_fail (IS_FOO (a), 0);
	g_return_val_if_fail (IS_FOO (b), 0);
	result = b->i - a->i;
	return result;
}

static void
_g_object_unref0_ (gpointer var)
{
	(var == NULL) ? NULL : (var = (g_object_unref (var), NULL));
}

static gpointer
_g_object_ref0 (gpointer self)
{
	return self ? g_object_ref (self) : NULL;
}

static gint
vala_g_ptr_array_get_length (GPtrArray* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = (gint) self->len;
	return result;
}

static void
g_ptr_array_set (GPtrArray* self,
                 guint index,
                 gpointer data)
{
	gpointer _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = data;
	data = NULL;
	g_ptr_array_add (self, _tmp0_);
	g_ptr_array_remove_index_fast (self, index);
}

static Block1Data*
block1_data_ref (Block1Data* _data1_)
{
	g_atomic_int_inc (&_data1_->_ref_count_);
	return _data1_;
}

static void
block1_data_unref (void * _userdata_)
{
	Block1Data* _data1_;
	_data1_ = (Block1Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
		GPtrArray* self;
		self = _data1_->self;
		_g_ptr_array_unref0 (self);
		g_slice_free (Block1Data, _data1_);
	}
}

static gint
_vala_lambda0_ (Block1Data* _data1_,
                gconstpointer** a,
                gconstpointer** b)
{
	GPtrArray* self;
	gint result;
	self = _data1_->self;
	result = _data1_->compare_func ((gconstpointer**) (*a), (gconstpointer**) (*b));
	return result;
}

static gint
__vala_lambda0__gcompare_data_func (gconstpointer a,
                                    gconstpointer b,
                                    gpointer self)
{
	gint result;
	result = _vala_lambda0_ (self, a, b);
	return result;
}

static void
vala_g_ptr_array_sort (GPtrArray* self,
                       GCompareFunc compare_func)
{
	Block1Data* _data1_;
	g_return_if_fail (self != NULL);
	_data1_ = g_slice_new0 (Block1Data);
	_data1_->_ref_count_ = 1;
	_data1_->self = g_ptr_array_ref (self);
	_data1_->compare_func = compare_func;
	g_ptr_array_sort_with_data (self, __vala_lambda0__gcompare_data_func, _data1_);
	block1_data_unref (_data1_);
	_data1_ = NULL;
}

static gint
_compare_foo_gcompare_func (gconstpointer a,
                            gconstpointer b)
{
	gint result;
	result = compare_foo ((Foo*) a, (Foo*) b);
	return result;
}

static Block2Data*
block2_data_ref (Block2Data* _data2_)
{
	g_atomic_int_inc (&_data2_->_ref_count_);
	return _data2_;
}

static void
block2_data_unref (void * _userdata_)
{
	Block2Data* _data2_;
	_data2_ = (Block2Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
		GPtrArray* self;
		self = _data2_->self;
		_g_ptr_array_unref0 (self);
		g_slice_free (Block2Data, _data2_);
	}
}

static gint
_vala_lambda1_ (Block2Data* _data2_,
                gconstpointer** a,
                gconstpointer** b)
{
	GPtrArray* self;
	gint result;
	self = _data2_->self;
	result = _data2_->compare_func ((gconstpointer**) (*a), (gconstpointer**) (*b), _data2_->compare_func_target);
	return result;
}

static gint
__vala_lambda1__gcompare_data_func (gconstpointer a,
                                    gconstpointer b,
                                    gpointer self)
{
	gint result;
	result = _vala_lambda1_ (self, a, b);
	return result;
}

static void
vala_g_ptr_array_sort_with_data (GPtrArray* self,
                                 GCompareDataFunc compare_func,
                                 gpointer compare_func_target)
{
	Block2Data* _data2_;
	g_return_if_fail (self != NULL);
	_data2_ = g_slice_new0 (Block2Data);
	_data2_->_ref_count_ = 1;
	_data2_->self = g_ptr_array_ref (self);
	_data2_->compare_func = compare_func;
	_data2_->compare_func_target = compare_func_target;
	g_ptr_array_sort_with_data (self, __vala_lambda1__gcompare_data_func, _data2_);
	block2_data_unref (_data2_);
	_data2_ = NULL;
}

static gint
_compare_foo_gcompare_data_func (gconstpointer a,
                                 gconstpointer b,
                                 gpointer self)
{
	gint result;
	result = compare_foo ((Foo*) a, (Foo*) b);
	return result;
}

static void
_vala_main (void)
{
	Foo* foo1 = NULL;
	Foo* _tmp0_;
	Foo* foo2 = NULL;
	Foo* _tmp1_;
	Foo* foo3 = NULL;
	Foo* _tmp2_;
	Foo* foo4 = NULL;
	Foo* _tmp3_;
	Foo* foo5 = NULL;
	Foo* _tmp4_;
	Foo* _tmp84_;
	Foo* _tmp85_;
	Foo* _tmp86_;
	Foo* _tmp87_;
	Foo* _tmp88_;
	Foo* _tmp163_;
	Foo* _tmp164_;
	Foo* _tmp165_;
	Foo* _tmp166_;
	Foo* _tmp167_;
	_tmp0_ = foo_new (5);
	foo1 = _tmp0_;
	_tmp1_ = foo_new (4);
	foo2 = _tmp1_;
	_tmp2_ = foo_new (3);
	foo3 = _tmp2_;
	_tmp3_ = foo_new (2);
	foo4 = _tmp3_;
	_tmp4_ = foo_new (1);
	foo5 = _tmp4_;
	{
		GPtrArray* array = NULL;
		GPtrArray* _tmp5_;
		GPtrArray* _tmp6_;
		Foo* _tmp7_;
		Foo* _tmp8_;
		Foo* _tmp9_;
		GPtrArray* _tmp10_;
		Foo* _tmp11_;
		Foo* _tmp12_;
		Foo* _tmp13_;
		GPtrArray* _tmp14_;
		Foo* _tmp15_;
		Foo* _tmp16_;
		Foo* _tmp17_;
		GPtrArray* _tmp18_;
		gint _tmp19_;
		gint _tmp20_;
		gint loop_size = 0;
		GPtrArray* _tmp21_;
		GPtrArray* _tmp30_;
		Foo* _tmp40_;
		GPtrArray* _tmp41_;
		gconstpointer _tmp42_;
		GPtrArray* _tmp43_;
		Foo* _tmp44_;
		Foo* _tmp45_;
		Foo* _tmp46_;
		GPtrArray* _tmp47_;
		gconstpointer _tmp48_;
		Foo* _tmp49_;
		Foo* _tmp50_;
		GPtrArray* _tmp51_;
		gint _tmp52_;
		gint _tmp53_;
		GPtrArray* _tmp54_;
		Foo* _tmp55_;
		Foo* _tmp56_;
		Foo* _tmp57_;
		GPtrArray* _tmp58_;
		gint _tmp59_;
		gint _tmp60_;
		GPtrArray* _tmp61_;
		Foo* _tmp62_;
		Foo* _tmp63_;
		GPtrArray* _tmp64_;
		gint _tmp65_;
		gint _tmp66_;
		guint index = 0U;
		GPtrArray* _tmp67_;
		Foo* _tmp68_;
		guint _tmp69_ = 0U;
		gboolean _tmp70_;
		Foo* _tmp71_;
		GPtrArray* _tmp72_;
		gint _tmp73_;
		gint _tmp74_;
		GPtrArray* _tmp75_;
		GPtrArray* _tmp76_;
		GPtrArray* _tmp77_;
		gint _tmp78_;
		gint _tmp79_;
		GPtrArray* _tmp80_;
		GPtrArray* _tmp81_;
		gint _tmp82_;
		gint _tmp83_;
		_tmp5_ = g_ptr_array_new_full ((guint) 8, _g_object_unref0_);
		array = _tmp5_;
		_tmp6_ = array;
		_tmp7_ = foo1;
		_tmp8_ = _g_object_ref0 (_tmp7_);
		g_ptr_array_add (_tmp6_, _tmp8_);
		_tmp9_ = foo1;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "foo1.ref_count == 2");
		_tmp10_ = array;
		_tmp11_ = foo2;
		_tmp12_ = _g_object_ref0 (_tmp11_);
		g_ptr_array_add (_tmp10_, _tmp12_);
		_tmp13_ = foo2;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp13_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "foo2.ref_count == 2");
		_tmp14_ = array;
		_tmp15_ = foo3;
		_tmp16_ = _g_object_ref0 (_tmp15_);
		g_ptr_array_add (_tmp14_, _tmp16_);
		_tmp17_ = foo3;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "foo3.ref_count == 2");
		_tmp18_ = array;
		_tmp19_ = vala_g_ptr_array_get_length (_tmp18_);
		_tmp20_ = _tmp19_;
		_vala_assert (_tmp20_ == 3, "array.length == 3");
		loop_size = 0;
		_tmp21_ = array;
		{
			GPtrArray* element_collection = NULL;
			guint element_index = 0U;
			element_collection = _tmp21_;
			for (element_index = 0; element_index < element_collection->len; element_index = element_index + 1) {
				Foo* element = NULL;
				element = g_ptr_array_index (element_collection, element_index);
				{
					gint _tmp22_;
					Foo* _tmp23_;
					_tmp22_ = loop_size;
					loop_size = _tmp22_ + 1;
					_tmp23_ = element;
					_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp23_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "element.ref_count == 2");
					switch (loop_size) {
						case 1:
						{
							Foo* _tmp24_;
							Foo* _tmp25_;
							_tmp24_ = element;
							_tmp25_ = foo1;
							_vala_assert (_tmp24_ == _tmp25_, "element == foo1");
							break;
						}
						case 2:
						{
							Foo* _tmp26_;
							Foo* _tmp27_;
							_tmp26_ = element;
							_tmp27_ = foo2;
							_vala_assert (_tmp26_ == _tmp27_, "element == foo2");
							break;
						}
						case 3:
						{
							Foo* _tmp28_;
							Foo* _tmp29_;
							_tmp28_ = element;
							_tmp29_ = foo3;
							_vala_assert (_tmp28_ == _tmp29_, "element == foo3");
							break;
						}
						default:
						break;
					}
				}
			}
		}
		_vala_assert (loop_size == 3, "loop_size == 3");
		loop_size = 0;
		_tmp30_ = array;
		{
			GPtrArray* element_collection = NULL;
			guint element_index = 0U;
			element_collection = _tmp30_;
			for (element_index = 0; element_index < element_collection->len; element_index = element_index + 1) {
				Foo* _tmp31_;
				Foo* element = NULL;
				_tmp31_ = _g_object_ref0 (g_ptr_array_index (element_collection, element_index));
				element = _tmp31_;
				{
					gint _tmp32_;
					Foo* _tmp33_;
					_tmp32_ = loop_size;
					loop_size = _tmp32_ + 1;
					_tmp33_ = element;
					_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 3), "element.ref_count == 3");
					switch (loop_size) {
						case 1:
						{
							Foo* _tmp34_;
							Foo* _tmp35_;
							_tmp34_ = element;
							_tmp35_ = foo1;
							_vala_assert (_tmp34_ == _tmp35_, "element == foo1");
							break;
						}
						case 2:
						{
							Foo* _tmp36_;
							Foo* _tmp37_;
							_tmp36_ = element;
							_tmp37_ = foo2;
							_vala_assert (_tmp36_ == _tmp37_, "element == foo2");
							break;
						}
						case 3:
						{
							Foo* _tmp38_;
							Foo* _tmp39_;
							_tmp38_ = element;
							_tmp39_ = foo3;
							_vala_assert (_tmp38_ == _tmp39_, "element == foo3");
							break;
						}
						default:
						break;
					}
					_g_object_unref0 (element);
				}
			}
		}
		_vala_assert (loop_size == 3, "loop_size == 3");
		_tmp40_ = foo2;
		_tmp41_ = array;
		_tmp42_ = g_ptr_array_index (_tmp41_, (guint) 1);
		_vala_assert (_tmp40_ == ((Foo*) _tmp42_), "foo2 == array.get (1)");
		_tmp43_ = array;
		_tmp44_ = foo4;
		_tmp45_ = _g_object_ref0 (_tmp44_);
		g_ptr_array_set (_tmp43_, (guint) 1, _tmp45_);
		_tmp46_ = foo4;
		_tmp47_ = array;
		_tmp48_ = g_ptr_array_index (_tmp47_, (guint) 1);
		_vala_assert (_tmp46_ == ((Foo*) _tmp48_), "foo4 == array.get (1)");
		_tmp49_ = foo2;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp49_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo2.ref_count == 1");
		_tmp50_ = foo4;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp50_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "foo4.ref_count == 2");
		_tmp51_ = array;
		_tmp52_ = vala_g_ptr_array_get_length (_tmp51_);
		_tmp53_ = _tmp52_;
		_vala_assert (_tmp53_ == 3, "array.length == 3");
		_tmp54_ = array;
		_tmp55_ = foo5;
		_tmp56_ = _g_object_ref0 (_tmp55_);
		g_ptr_array_insert (_tmp54_, 2, _tmp56_);
		_tmp57_ = foo5;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp57_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "foo5.ref_count == 2");
		_tmp58_ = array;
		_tmp59_ = vala_g_ptr_array_get_length (_tmp58_);
		_tmp60_ = _tmp59_;
		_vala_assert (_tmp60_ == 4, "array.length == 4");
		_tmp61_ = array;
		_tmp62_ = foo4;
		_vala_assert (g_ptr_array_remove (_tmp61_, _tmp62_), "array.remove (foo4)");
		_tmp63_ = foo4;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp63_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo4.ref_count == 1");
		_tmp64_ = array;
		_tmp65_ = vala_g_ptr_array_get_length (_tmp64_);
		_tmp66_ = _tmp65_;
		_vala_assert (_tmp66_ == 3, "array.length == 3");
		_tmp67_ = array;
		_tmp68_ = foo5;
		_tmp70_ = g_ptr_array_find (_tmp67_, _tmp68_, &_tmp69_);
		index = _tmp69_;
		_vala_assert (_tmp70_, "array.find (foo5, out index)");
		_tmp71_ = foo5;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp71_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "foo5.ref_count == 2");
		_vala_assert (index == ((guint) 1), "index == 1");
		_tmp72_ = array;
		_tmp73_ = vala_g_ptr_array_get_length (_tmp72_);
		_tmp74_ = _tmp73_;
		_vala_assert (_tmp74_ == 3, "array.length == 3");
		_tmp75_ = array;
		vala_g_ptr_array_sort (_tmp75_, _compare_foo_gcompare_func);
		_tmp76_ = array;
		vala_g_ptr_array_sort_with_data (_tmp76_, _compare_foo_gcompare_data_func, NULL);
		_tmp77_ = array;
		_tmp78_ = vala_g_ptr_array_get_length (_tmp77_);
		_tmp79_ = _tmp78_;
		_vala_assert (_tmp79_ == 3, "array.length == 3");
		_tmp80_ = array;
		g_ptr_array_set_size (_tmp80_, 0);
		_tmp81_ = array;
		_tmp82_ = vala_g_ptr_array_get_length (_tmp81_);
		_tmp83_ = _tmp82_;
		_vala_assert (_tmp83_ == 0, "array.length == 0");
		_g_ptr_array_unref0 (array);
	}
	_tmp84_ = foo1;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp84_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo1.ref_count == 1");
	_tmp85_ = foo2;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp85_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo2.ref_count == 1");
	_tmp86_ = foo3;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp86_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo3.ref_count == 1");
	_tmp87_ = foo4;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp87_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo4.ref_count == 1");
	_tmp88_ = foo5;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp88_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo5.ref_count == 1");
	{
		GPtrArray* array = NULL;
		GPtrArray* _tmp89_;
		GPtrArray* _tmp90_;
		Foo* _tmp91_;
		Foo* _tmp92_;
		GPtrArray* _tmp93_;
		Foo* _tmp94_;
		Foo* _tmp95_;
		GPtrArray* _tmp96_;
		Foo* _tmp97_;
		Foo* _tmp98_;
		GPtrArray* _tmp99_;
		gint _tmp100_;
		gint _tmp101_;
		gint loop_size = 0;
		GPtrArray* _tmp102_;
		GPtrArray* _tmp111_;
		Foo* _tmp121_;
		GPtrArray* _tmp122_;
		gconstpointer _tmp123_;
		GPtrArray* _tmp124_;
		Foo* _tmp125_;
		Foo* _tmp126_;
		GPtrArray* _tmp127_;
		gconstpointer _tmp128_;
		Foo* _tmp129_;
		Foo* _tmp130_;
		GPtrArray* _tmp131_;
		gint _tmp132_;
		gint _tmp133_;
		GPtrArray* _tmp134_;
		Foo* _tmp135_;
		Foo* _tmp136_;
		GPtrArray* _tmp137_;
		gint _tmp138_;
		gint _tmp139_;
		GPtrArray* _tmp140_;
		Foo* _tmp141_;
		Foo* _tmp142_;
		GPtrArray* _tmp143_;
		gint _tmp144_;
		gint _tmp145_;
		guint index = 0U;
		GPtrArray* _tmp146_;
		Foo* _tmp147_;
		guint _tmp148_ = 0U;
		gboolean _tmp149_;
		Foo* _tmp150_;
		GPtrArray* _tmp151_;
		gint _tmp152_;
		gint _tmp153_;
		GPtrArray* _tmp154_;
		GPtrArray* _tmp155_;
		GPtrArray* _tmp156_;
		gint _tmp157_;
		gint _tmp158_;
		GPtrArray* _tmp159_;
		GPtrArray* _tmp160_;
		gint _tmp161_;
		gint _tmp162_;
		_tmp89_ = g_ptr_array_new_full ((guint) 8, NULL);
		array = _tmp89_;
		_tmp90_ = array;
		_tmp91_ = foo1;
		g_ptr_array_add (_tmp90_, _tmp91_);
		_tmp92_ = foo1;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp92_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo1.ref_count == 1");
		_tmp93_ = array;
		_tmp94_ = foo2;
		g_ptr_array_add (_tmp93_, _tmp94_);
		_tmp95_ = foo2;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp95_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo2.ref_count == 1");
		_tmp96_ = array;
		_tmp97_ = foo3;
		g_ptr_array_add (_tmp96_, _tmp97_);
		_tmp98_ = foo3;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp98_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo3.ref_count == 1");
		_tmp99_ = array;
		_tmp100_ = vala_g_ptr_array_get_length (_tmp99_);
		_tmp101_ = _tmp100_;
		_vala_assert (_tmp101_ == 3, "array.length == 3");
		loop_size = 0;
		_tmp102_ = array;
		{
			GPtrArray* element_collection = NULL;
			guint element_index = 0U;
			element_collection = _tmp102_;
			for (element_index = 0; element_index < element_collection->len; element_index = element_index + 1) {
				Foo* element = NULL;
				element = g_ptr_array_index (element_collection, element_index);
				{
					gint _tmp103_;
					Foo* _tmp104_;
					_tmp103_ = loop_size;
					loop_size = _tmp103_ + 1;
					_tmp104_ = element;
					_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp104_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "element.ref_count == 1");
					switch (loop_size) {
						case 1:
						{
							Foo* _tmp105_;
							Foo* _tmp106_;
							_tmp105_ = element;
							_tmp106_ = foo1;
							_vala_assert (_tmp105_ == _tmp106_, "element == foo1");
							break;
						}
						case 2:
						{
							Foo* _tmp107_;
							Foo* _tmp108_;
							_tmp107_ = element;
							_tmp108_ = foo2;
							_vala_assert (_tmp107_ == _tmp108_, "element == foo2");
							break;
						}
						case 3:
						{
							Foo* _tmp109_;
							Foo* _tmp110_;
							_tmp109_ = element;
							_tmp110_ = foo3;
							_vala_assert (_tmp109_ == _tmp110_, "element == foo3");
							break;
						}
						default:
						break;
					}
				}
			}
		}
		_vala_assert (loop_size == 3, "loop_size == 3");
		loop_size = 0;
		_tmp111_ = array;
		{
			GPtrArray* element_collection = NULL;
			guint element_index = 0U;
			element_collection = _tmp111_;
			for (element_index = 0; element_index < element_collection->len; element_index = element_index + 1) {
				Foo* _tmp112_;
				Foo* element = NULL;
				_tmp112_ = _g_object_ref0 (g_ptr_array_index (element_collection, element_index));
				element = _tmp112_;
				{
					gint _tmp113_;
					Foo* _tmp114_;
					_tmp113_ = loop_size;
					loop_size = _tmp113_ + 1;
					_tmp114_ = element;
					_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp114_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "element.ref_count == 2");
					switch (loop_size) {
						case 1:
						{
							Foo* _tmp115_;
							Foo* _tmp116_;
							_tmp115_ = element;
							_tmp116_ = foo1;
							_vala_assert (_tmp115_ == _tmp116_, "element == foo1");
							break;
						}
						case 2:
						{
							Foo* _tmp117_;
							Foo* _tmp118_;
							_tmp117_ = element;
							_tmp118_ = foo2;
							_vala_assert (_tmp117_ == _tmp118_, "element == foo2");
							break;
						}
						case 3:
						{
							Foo* _tmp119_;
							Foo* _tmp120_;
							_tmp119_ = element;
							_tmp120_ = foo3;
							_vala_assert (_tmp119_ == _tmp120_, "element == foo3");
							break;
						}
						default:
						break;
					}
					_g_object_unref0 (element);
				}
			}
		}
		_vala_assert (loop_size == 3, "loop_size == 3");
		_tmp121_ = foo2;
		_tmp122_ = array;
		_tmp123_ = g_ptr_array_index (_tmp122_, (guint) 1);
		_vala_assert (_tmp121_ == ((Foo*) _tmp123_), "foo2 == array.get (1)");
		_tmp124_ = array;
		_tmp125_ = foo4;
		g_ptr_array_set (_tmp124_, (guint) 1, _tmp125_);
		_tmp126_ = foo4;
		_tmp127_ = array;
		_tmp128_ = g_ptr_array_index (_tmp127_, (guint) 1);
		_vala_assert (_tmp126_ == ((Foo*) _tmp128_), "foo4 == array.get (1)");
		_tmp129_ = foo2;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp129_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo2.ref_count == 1");
		_tmp130_ = foo4;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp130_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo4.ref_count == 1");
		_tmp131_ = array;
		_tmp132_ = vala_g_ptr_array_get_length (_tmp131_);
		_tmp133_ = _tmp132_;
		_vala_assert (_tmp133_ == 3, "array.length == 3");
		_tmp134_ = array;
		_tmp135_ = foo5;
		g_ptr_array_insert (_tmp134_, 2, _tmp135_);
		_tmp136_ = foo5;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp136_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo5.ref_count == 1");
		_tmp137_ = array;
		_tmp138_ = vala_g_ptr_array_get_length (_tmp137_);
		_tmp139_ = _tmp138_;
		_vala_assert (_tmp139_ == 4, "array.length == 4");
		_tmp140_ = array;
		_tmp141_ = foo4;
		_vala_assert (g_ptr_array_remove (_tmp140_, _tmp141_), "array.remove (foo4)");
		_tmp142_ = foo4;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp142_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo4.ref_count == 1");
		_tmp143_ = array;
		_tmp144_ = vala_g_ptr_array_get_length (_tmp143_);
		_tmp145_ = _tmp144_;
		_vala_assert (_tmp145_ == 3, "array.length == 3");
		_tmp146_ = array;
		_tmp147_ = foo5;
		_tmp149_ = g_ptr_array_find (_tmp146_, _tmp147_, &_tmp148_);
		index = _tmp148_;
		_vala_assert (_tmp149_, "array.find (foo5, out index)");
		_tmp150_ = foo5;
		_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp150_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo5.ref_count == 1");
		_vala_assert (index == ((guint) 1), "index == 1");
		_tmp151_ = array;
		_tmp152_ = vala_g_ptr_array_get_length (_tmp151_);
		_tmp153_ = _tmp152_;
		_vala_assert (_tmp153_ == 3, "array.length == 3");
		_tmp154_ = array;
		vala_g_ptr_array_sort (_tmp154_, _compare_foo_gcompare_func);
		_tmp155_ = array;
		vala_g_ptr_array_sort_with_data (_tmp155_, _compare_foo_gcompare_data_func, NULL);
		_tmp156_ = array;
		_tmp157_ = vala_g_ptr_array_get_length (_tmp156_);
		_tmp158_ = _tmp157_;
		_vala_assert (_tmp158_ == 3, "array.length == 3");
		_tmp159_ = array;
		g_ptr_array_set_size (_tmp159_, 0);
		_tmp160_ = array;
		_tmp161_ = vala_g_ptr_array_get_length (_tmp160_);
		_tmp162_ = _tmp161_;
		_vala_assert (_tmp162_ == 0, "array.length == 0");
		_g_ptr_array_unref0 (array);
	}
	_tmp163_ = foo1;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp163_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo1.ref_count == 1");
	_tmp164_ = foo2;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp164_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo2.ref_count == 1");
	_tmp165_ = foo3;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp165_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo3.ref_count == 1");
	_tmp166_ = foo4;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp166_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo4.ref_count == 1");
	_tmp167_ = foo5;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_tmp167_, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo5.ref_count == 1");
	_g_object_unref0 (foo5);
	_g_object_unref0 (foo4);
	_g_object_unref0 (foo3);
	_g_object_unref0 (foo2);
	_g_object_unref0 (foo1);
}

int
main (int argc,
      char ** argv)
{
	_vala_main ();
	return 0;
}