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

#include <glib.h>
#include <glib-object.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

typedef void (*FooFunc) (gpointer user_data);

#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];
typedef struct _Block1Data Block1Data;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
typedef struct _Block2Data Block2Data;
typedef struct _Block3Data Block3Data;
typedef struct _Block4Data Block4Data;
typedef struct _Block5Data Block5Data;
typedef struct _Block6Data Block6Data;
typedef struct _Block7Data Block7Data;
typedef struct _Block8Data Block8Data;
#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;
};

struct _FooClass {
	GObjectClass parent_class;
};

struct _FooPrivate {
	gint global;
};

struct _Block1Data {
	int _ref_count_;
	Foo* self;
	gint local;
};

struct _Block2Data {
	int _ref_count_;
	Foo* self;
	gint local;
};

struct _Block3Data {
	int _ref_count_;
	Foo* self;
	gint local;
};

struct _Block4Data {
	int _ref_count_;
	Foo* self;
	gint local;
};

struct _Block5Data {
	int _ref_count_;
	Foo* foo;
};

struct _Block6Data {
	int _ref_count_;
	Foo* foo;
};

struct _Block7Data {
	int _ref_count_;
	Foo* foo;
};

struct _Block8Data {
	int _ref_count_;
	Foo* foo;
};

static gint Foo_private_offset;
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)
static void foo_call (Foo* self,
               FooFunc a,
               gpointer a_target,
               FooFunc b,
               gpointer b_target);
static void foo_call_owned (Foo* self,
                     FooFunc a,
                     gpointer a_target,
                     GDestroyNotify a_target_destroy_notify,
                     FooFunc b,
                     gpointer b_target,
                     GDestroyNotify b_target_destroy_notify);
static void foo_call_shared (Foo* self,
                      FooFunc a,
                      FooFunc b,
                      gpointer user_data);
static void foo_call_shared_owned (Foo* self,
                            FooFunc a,
                            FooFunc b,
                            gpointer user_data,
                            GDestroyNotify user_data_destroy_notify);
VALA_EXTERN void foo_run_1 (Foo* self);
static Block1Data* block1_data_ref (Block1Data* _data1_);
static void block1_data_unref (void * _userdata_);
static void _vala_lambda0_ (Block1Data* _data1_);
static void __vala_lambda0__foo_func (gpointer self);
static void _vala_lambda1_ (Block1Data* _data1_);
static void __vala_lambda1__foo_func (gpointer self);
VALA_EXTERN void foo_run_2 (Foo* self);
static Block2Data* block2_data_ref (Block2Data* _data2_);
static void block2_data_unref (void * _userdata_);
static void _vala_lambda2_ (Block2Data* _data2_);
static void __vala_lambda2__foo_func (gpointer self);
static void _vala_lambda3_ (Block2Data* _data2_);
static void __vala_lambda3__foo_func (gpointer self);
VALA_EXTERN void foo_run_3 (Foo* self);
static Block3Data* block3_data_ref (Block3Data* _data3_);
static void block3_data_unref (void * _userdata_);
static void _vala_lambda4_ (Block3Data* _data3_);
static void __vala_lambda4__foo_func (gpointer self);
static void _vala_lambda5_ (Block3Data* _data3_);
static void __vala_lambda5__foo_func (gpointer self);
VALA_EXTERN void foo_run_4 (Foo* self);
static Block4Data* block4_data_ref (Block4Data* _data4_);
static void block4_data_unref (void * _userdata_);
static void _vala_lambda6_ (Block4Data* _data4_);
static void __vala_lambda6__foo_func (gpointer self);
static void _vala_lambda7_ (Block4Data* _data4_);
static void __vala_lambda7__foo_func (gpointer self);
VALA_EXTERN Foo* foo_new (void);
VALA_EXTERN Foo* foo_construct (GType object_type);
static void foo_finalize (GObject * obj);
static GType foo_get_type_once (void);
VALA_EXTERN void call_shared (FooFunc a,
                  FooFunc b,
                  gpointer user_data);
VALA_EXTERN void call_shared_owned (FooFunc a,
                        FooFunc b,
                        gpointer user_data,
                        GDestroyNotify user_data_destroy_notify);
VALA_EXTERN void run_static_1 (void);
static Block5Data* block5_data_ref (Block5Data* _data5_);
static void block5_data_unref (void * _userdata_);
static void _vala_lambda8_ (Block5Data* _data5_);
static void __vala_lambda8__foo_func (gpointer self);
static void _vala_lambda9_ (void);
static void __vala_lambda9__foo_func (gpointer self);
VALA_EXTERN void run_static_2 (void);
static Block6Data* block6_data_ref (Block6Data* _data6_);
static void block6_data_unref (void * _userdata_);
static void _vala_lambda10_ (void);
static void __vala_lambda10__foo_func (gpointer self);
static void _vala_lambda11_ (Block6Data* _data6_);
static void __vala_lambda11__foo_func (gpointer self);
VALA_EXTERN void run_static_3 (void);
static Block7Data* block7_data_ref (Block7Data* _data7_);
static void block7_data_unref (void * _userdata_);
static void _vala_lambda12_ (Block7Data* _data7_);
static void __vala_lambda12__foo_func (gpointer self);
static void _vala_lambda13_ (void);
static void __vala_lambda13__foo_func (gpointer self);
VALA_EXTERN void run_static_4 (void);
static Block8Data* block8_data_ref (Block8Data* _data8_);
static void block8_data_unref (void * _userdata_);
static void _vala_lambda14_ (void);
static void __vala_lambda14__foo_func (gpointer self);
static void _vala_lambda15_ (Block8Data* _data8_);
static void __vala_lambda15__foo_func (gpointer self);
static void _vala_main (void);

static inline gpointer
foo_get_instance_private (Foo* self)
{
	return G_STRUCT_MEMBER_P (self, Foo_private_offset);
}

static void
foo_call (Foo* self,
          FooFunc a,
          gpointer a_target,
          FooFunc b,
          gpointer b_target)
{
	g_return_if_fail (IS_FOO (self));
	a (a_target);
	b (b_target);
}

static void
foo_call_owned (Foo* self,
                FooFunc a,
                gpointer a_target,
                GDestroyNotify a_target_destroy_notify,
                FooFunc b,
                gpointer b_target,
                GDestroyNotify b_target_destroy_notify)
{
	g_return_if_fail (IS_FOO (self));
	a (a_target);
	b (b_target);
	(a_target_destroy_notify == NULL) ? NULL : (a_target_destroy_notify (a_target), NULL);
	a = NULL;
	a_target = NULL;
	a_target_destroy_notify = NULL;
	(b_target_destroy_notify == NULL) ? NULL : (b_target_destroy_notify (b_target), NULL);
	b = NULL;
	b_target = NULL;
	b_target_destroy_notify = NULL;
}

static void
foo_call_shared (Foo* self,
                 FooFunc a,
                 FooFunc b,
                 gpointer user_data)
{
	g_return_if_fail (IS_FOO (self));
	a (user_data);
	b (user_data);
}

static void
foo_call_shared_owned (Foo* self,
                       FooFunc a,
                       FooFunc b,
                       gpointer user_data,
                       GDestroyNotify user_data_destroy_notify)
{
	g_return_if_fail (IS_FOO (self));
	a (user_data);
	b (user_data);
	(user_data_destroy_notify == NULL) ? NULL : (user_data_destroy_notify (user_data), NULL);
	a = NULL;
	user_data = NULL;
	user_data_destroy_notify = NULL;
	(user_data_destroy_notify == NULL) ? NULL : (user_data_destroy_notify (user_data), NULL);
	b = NULL;
	user_data = NULL;
	user_data_destroy_notify = NULL;
}

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_)) {
		Foo* self;
		self = _data1_->self;
		_g_object_unref0 (self);
		g_slice_free (Block1Data, _data1_);
	}
}

static void
_vala_lambda0_ (Block1Data* _data1_)
{
	Foo* self;
	self = _data1_->self;
	_vala_assert (self->priv->global == 42, "global == 42");
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
}

static void
__vala_lambda0__foo_func (gpointer self)
{
	_vala_lambda0_ (self);
}

static void
_vala_lambda1_ (Block1Data* _data1_)
{
	Foo* self;
	self = _data1_->self;
	_vala_assert (_data1_->local == 23, "local == 23");
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
}

static void
__vala_lambda1__foo_func (gpointer self)
{
	_vala_lambda1_ (self);
}

void
foo_run_1 (Foo* self)
{
	Block1Data* _data1_;
	g_return_if_fail (IS_FOO (self));
	_data1_ = g_slice_new0 (Block1Data);
	_data1_->_ref_count_ = 1;
	_data1_->self = g_object_ref (self);
	_data1_->local = 23;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
	foo_call (self, __vala_lambda0__foo_func, _data1_, __vala_lambda1__foo_func, _data1_);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
	block1_data_unref (_data1_);
	_data1_ = NULL;
}

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_)) {
		Foo* self;
		self = _data2_->self;
		_g_object_unref0 (self);
		g_slice_free (Block2Data, _data2_);
	}
}

static void
_vala_lambda2_ (Block2Data* _data2_)
{
	Foo* self;
	self = _data2_->self;
	_vala_assert (self->priv->global == 42, "global == 42");
}

static void
__vala_lambda2__foo_func (gpointer self)
{
	_vala_lambda2_ (self);
}

static void
_vala_lambda3_ (Block2Data* _data2_)
{
	Foo* self;
	self = _data2_->self;
	_vala_assert (_data2_->local == 23, "local == 23");
}

static void
__vala_lambda3__foo_func (gpointer self)
{
	_vala_lambda3_ (self);
}

void
foo_run_2 (Foo* self)
{
	Block2Data* _data2_;
	g_return_if_fail (IS_FOO (self));
	_data2_ = g_slice_new0 (Block2Data);
	_data2_->_ref_count_ = 1;
	_data2_->self = g_object_ref (self);
	_data2_->local = 23;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
	foo_call_owned (self, __vala_lambda2__foo_func, block2_data_ref (_data2_), block2_data_unref, __vala_lambda3__foo_func, block2_data_ref (_data2_), block2_data_unref);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
	block2_data_unref (_data2_);
	_data2_ = NULL;
}

static Block3Data*
block3_data_ref (Block3Data* _data3_)
{
	g_atomic_int_inc (&_data3_->_ref_count_);
	return _data3_;
}

static void
block3_data_unref (void * _userdata_)
{
	Block3Data* _data3_;
	_data3_ = (Block3Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
		Foo* self;
		self = _data3_->self;
		_g_object_unref0 (self);
		g_slice_free (Block3Data, _data3_);
	}
}

static void
_vala_lambda4_ (Block3Data* _data3_)
{
	Foo* self;
	self = _data3_->self;
	_vala_assert (self->priv->global == 42, "global == 42");
}

static void
__vala_lambda4__foo_func (gpointer self)
{
	_vala_lambda4_ (self);
}

static void
_vala_lambda5_ (Block3Data* _data3_)
{
	Foo* self;
	self = _data3_->self;
	_vala_assert (_data3_->local == 23, "local == 23");
}

static void
__vala_lambda5__foo_func (gpointer self)
{
	_vala_lambda5_ (self);
}

void
foo_run_3 (Foo* self)
{
	Block3Data* _data3_;
	g_return_if_fail (IS_FOO (self));
	_data3_ = g_slice_new0 (Block3Data);
	_data3_->_ref_count_ = 1;
	_data3_->self = g_object_ref (self);
	_data3_->local = 23;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
	foo_call_shared (self, __vala_lambda4__foo_func, __vala_lambda5__foo_func, _data3_);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
	block3_data_unref (_data3_);
	_data3_ = NULL;
}

static Block4Data*
block4_data_ref (Block4Data* _data4_)
{
	g_atomic_int_inc (&_data4_->_ref_count_);
	return _data4_;
}

static void
block4_data_unref (void * _userdata_)
{
	Block4Data* _data4_;
	_data4_ = (Block4Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
		Foo* self;
		self = _data4_->self;
		_g_object_unref0 (self);
		g_slice_free (Block4Data, _data4_);
	}
}

static void
_vala_lambda6_ (Block4Data* _data4_)
{
	Foo* self;
	self = _data4_->self;
	_vala_assert (self->priv->global == 42, "global == 42");
}

static void
__vala_lambda6__foo_func (gpointer self)
{
	_vala_lambda6_ (self);
}

static void
_vala_lambda7_ (Block4Data* _data4_)
{
	Foo* self;
	self = _data4_->self;
	_vala_assert (_data4_->local == 23, "local == 23");
}

static void
__vala_lambda7__foo_func (gpointer self)
{
	_vala_lambda7_ (self);
}

void
foo_run_4 (Foo* self)
{
	Block4Data* _data4_;
	g_return_if_fail (IS_FOO (self));
	_data4_ = g_slice_new0 (Block4Data);
	_data4_->_ref_count_ = 1;
	_data4_->self = g_object_ref (self);
	_data4_->local = 23;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
	foo_call_shared_owned (self, __vala_lambda6__foo_func, __vala_lambda7__foo_func, block4_data_ref (_data4_), block4_data_unref);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (self, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 2), "this.ref_count == 2");
	block4_data_unref (_data4_);
	_data4_ = NULL;
}

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

Foo*
foo_new (void)
{
	return foo_construct (TYPE_FOO);
}

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

static void
foo_instance_init (Foo * self,
                   gpointer klass)
{
	self->priv = foo_get_instance_private (self);
	self->priv->global = 42;
}

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);
	Foo_private_offset = g_type_add_instance_private (foo_type_id, sizeof (FooPrivate));
	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;
}

void
call_shared (FooFunc a,
             FooFunc b,
             gpointer user_data)
{
	a (user_data);
	b (user_data);
}

void
call_shared_owned (FooFunc a,
                   FooFunc b,
                   gpointer user_data,
                   GDestroyNotify user_data_destroy_notify)
{
	a (user_data);
	b (user_data);
	(user_data_destroy_notify == NULL) ? NULL : (user_data_destroy_notify (user_data), NULL);
	a = NULL;
	user_data = NULL;
	user_data_destroy_notify = NULL;
	(user_data_destroy_notify == NULL) ? NULL : (user_data_destroy_notify (user_data), NULL);
	b = NULL;
	user_data = NULL;
	user_data_destroy_notify = NULL;
}

static Block5Data*
block5_data_ref (Block5Data* _data5_)
{
	g_atomic_int_inc (&_data5_->_ref_count_);
	return _data5_;
}

static void
block5_data_unref (void * _userdata_)
{
	Block5Data* _data5_;
	_data5_ = (Block5Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data5_->_ref_count_)) {
		_g_object_unref0 (_data5_->foo);
		g_slice_free (Block5Data, _data5_);
	}
}

static void
_vala_lambda8_ (Block5Data* _data5_)
{
	_vala_assert (_data5_->foo != NULL, "foo != null");
}

static void
__vala_lambda8__foo_func (gpointer self)
{
	_vala_lambda8_ (self);
}

static void
_vala_lambda9_ (void)
{
}

static void
__vala_lambda9__foo_func (gpointer self)
{
	_vala_lambda9_ ();
}

void
run_static_1 (void)
{
	Block5Data* _data5_;
	Foo* _tmp0_;
	_data5_ = g_slice_new0 (Block5Data);
	_data5_->_ref_count_ = 1;
	_tmp0_ = foo_new ();
	_data5_->foo = _tmp0_;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_data5_->foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	call_shared (__vala_lambda8__foo_func, __vala_lambda9__foo_func, _data5_);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_data5_->foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	block5_data_unref (_data5_);
	_data5_ = NULL;
}

static Block6Data*
block6_data_ref (Block6Data* _data6_)
{
	g_atomic_int_inc (&_data6_->_ref_count_);
	return _data6_;
}

static void
block6_data_unref (void * _userdata_)
{
	Block6Data* _data6_;
	_data6_ = (Block6Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data6_->_ref_count_)) {
		_g_object_unref0 (_data6_->foo);
		g_slice_free (Block6Data, _data6_);
	}
}

static void
_vala_lambda10_ (void)
{
}

static void
__vala_lambda10__foo_func (gpointer self)
{
	_vala_lambda10_ ();
}

static void
_vala_lambda11_ (Block6Data* _data6_)
{
	_vala_assert (_data6_->foo != NULL, "foo != null");
}

static void
__vala_lambda11__foo_func (gpointer self)
{
	_vala_lambda11_ (self);
}

void
run_static_2 (void)
{
	Block6Data* _data6_;
	Foo* _tmp0_;
	_data6_ = g_slice_new0 (Block6Data);
	_data6_->_ref_count_ = 1;
	_tmp0_ = foo_new ();
	_data6_->foo = _tmp0_;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_data6_->foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	call_shared (__vala_lambda10__foo_func, __vala_lambda11__foo_func, _data6_);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_data6_->foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	block6_data_unref (_data6_);
	_data6_ = NULL;
}

static Block7Data*
block7_data_ref (Block7Data* _data7_)
{
	g_atomic_int_inc (&_data7_->_ref_count_);
	return _data7_;
}

static void
block7_data_unref (void * _userdata_)
{
	Block7Data* _data7_;
	_data7_ = (Block7Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data7_->_ref_count_)) {
		_g_object_unref0 (_data7_->foo);
		g_slice_free (Block7Data, _data7_);
	}
}

static void
_vala_lambda12_ (Block7Data* _data7_)
{
	_vala_assert (_data7_->foo != NULL, "foo != null");
}

static void
__vala_lambda12__foo_func (gpointer self)
{
	_vala_lambda12_ (self);
}

static void
_vala_lambda13_ (void)
{
}

static void
__vala_lambda13__foo_func (gpointer self)
{
	_vala_lambda13_ ();
}

void
run_static_3 (void)
{
	Block7Data* _data7_;
	Foo* _tmp0_;
	_data7_ = g_slice_new0 (Block7Data);
	_data7_->_ref_count_ = 1;
	_tmp0_ = foo_new ();
	_data7_->foo = _tmp0_;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_data7_->foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	call_shared_owned (__vala_lambda12__foo_func, __vala_lambda13__foo_func, block7_data_ref (_data7_), block7_data_unref);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_data7_->foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	block7_data_unref (_data7_);
	_data7_ = NULL;
}

static Block8Data*
block8_data_ref (Block8Data* _data8_)
{
	g_atomic_int_inc (&_data8_->_ref_count_);
	return _data8_;
}

static void
block8_data_unref (void * _userdata_)
{
	Block8Data* _data8_;
	_data8_ = (Block8Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data8_->_ref_count_)) {
		_g_object_unref0 (_data8_->foo);
		g_slice_free (Block8Data, _data8_);
	}
}

static void
_vala_lambda14_ (void)
{
}

static void
__vala_lambda14__foo_func (gpointer self)
{
	_vala_lambda14_ ();
}

static void
_vala_lambda15_ (Block8Data* _data8_)
{
	_vala_assert (_data8_->foo != NULL, "foo != null");
}

static void
__vala_lambda15__foo_func (gpointer self)
{
	_vala_lambda15_ (self);
}

void
run_static_4 (void)
{
	Block8Data* _data8_;
	Foo* _tmp0_;
	_data8_ = g_slice_new0 (Block8Data);
	_data8_->_ref_count_ = 1;
	_tmp0_ = foo_new ();
	_data8_->foo = _tmp0_;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_data8_->foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	call_shared_owned (__vala_lambda14__foo_func, __vala_lambda15__foo_func, block8_data_ref (_data8_), block8_data_unref);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (_data8_->foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	block8_data_unref (_data8_);
	_data8_ = NULL;
}

static void
_vala_main (void)
{
	Foo* foo = NULL;
	Foo* _tmp0_;
	_tmp0_ = foo_new ();
	foo = _tmp0_;
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	foo_run_1 (foo);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	foo_run_2 (foo);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	foo_run_3 (foo);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	foo_run_4 (foo);
	_vala_assert (G_TYPE_CHECK_INSTANCE_CAST (foo, G_TYPE_OBJECT, GObject)->ref_count == ((guint) 1), "foo.ref_count == 1");
	run_static_1 ();
	run_static_2 ();
	run_static_3 ();
	run_static_4 ();
	_g_object_unref0 (foo);
}

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