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

#include <glib-object.h>
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gobject/gvaluecollector.h>

#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif
#if !defined(VALA_EXTERN)
#if defined(_MSC_VER)
#define VALA_EXTERN __declspec(dllexport) extern
#elif __GNUC__ >= 4
#define VALA_EXTERN __attribute__((visibility("default"))) extern
#else
#define VALA_EXTERN extern
#endif
#endif

#define MAMAN_TYPE_BAR (maman_bar_get_type ())
#define MAMAN_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_BAR, MamanBar))
#define MAMAN_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_BAR, MamanBarClass))
#define MAMAN_IS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_BAR))
#define MAMAN_IS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_BAR))
#define MAMAN_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_BAR, MamanBarClass))

typedef struct _MamanBar MamanBar;
typedef struct _MamanBarClass MamanBarClass;
typedef struct _MamanBarPrivate MamanBarPrivate;
enum  {
	MAMAN_BAR_0_PROPERTY,
	MAMAN_BAR_NUM_PROPERTIES
};
static GParamSpec* maman_bar_properties[MAMAN_BAR_NUM_PROPERTIES];

#define MAMAN_TYPE_SUB_BAR (maman_sub_bar_get_type ())
#define MAMAN_SUB_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_SUB_BAR, MamanSubBar))
#define MAMAN_SUB_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_SUB_BAR, MamanSubBarClass))
#define MAMAN_IS_SUB_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_SUB_BAR))
#define MAMAN_IS_SUB_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_SUB_BAR))
#define MAMAN_SUB_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_SUB_BAR, MamanSubBarClass))

typedef struct _MamanSubBar MamanSubBar;
typedef struct _MamanSubBarClass MamanSubBarClass;
typedef struct _MamanSubBarPrivate MamanSubBarPrivate;
enum  {
	MAMAN_SUB_BAR_0_PROPERTY,
	MAMAN_SUB_BAR_NUM_PROPERTIES
};
static GParamSpec* maman_sub_bar_properties[MAMAN_SUB_BAR_NUM_PROPERTIES];
#define _g_free0(var) (var = (g_free (var), NULL))

#define MAMAN_TYPE_FOO_BAR (maman_foo_bar_get_type ())
#define MAMAN_FOO_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_FOO_BAR, MamanFooBar))
#define MAMAN_FOO_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_FOO_BAR, MamanFooBarClass))
#define MAMAN_IS_FOO_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_FOO_BAR))
#define MAMAN_IS_FOO_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_FOO_BAR))
#define MAMAN_FOO_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_FOO_BAR, MamanFooBarClass))

typedef struct _MamanFooBar MamanFooBar;
typedef struct _MamanFooBarClass MamanFooBarClass;

#define MAMAN_TYPE_SUB_FOO_BAR (maman_sub_foo_bar_get_type ())
#define MAMAN_SUB_FOO_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_SUB_FOO_BAR, MamanSubFooBar))
#define MAMAN_SUB_FOO_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_SUB_FOO_BAR, MamanSubFooBarClass))
#define MAMAN_IS_SUB_FOO_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_SUB_FOO_BAR))
#define MAMAN_IS_SUB_FOO_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_SUB_FOO_BAR))
#define MAMAN_SUB_FOO_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_SUB_FOO_BAR, MamanSubFooBarClass))

typedef struct _MamanSubFooBar MamanSubFooBar;
typedef struct _MamanSubFooBarClass MamanSubFooBarClass;

#define MAMAN_TYPE_FOO (maman_foo_get_type ())
#define MAMAN_FOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_FOO, MamanFoo))
#define MAMAN_IS_FOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_FOO))
#define MAMAN_FOO_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MAMAN_TYPE_FOO, MamanFooIface))

typedef struct _MamanFoo MamanFoo;
typedef struct _MamanFooIface MamanFooIface;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
typedef struct _MamanFooBarPrivate MamanFooBarPrivate;
enum  {
	MAMAN_FOO_BAR_0_PROPERTY,
	MAMAN_FOO_BAR_NUM_PROPERTIES
};
static GParamSpec* maman_foo_bar_properties[MAMAN_FOO_BAR_NUM_PROPERTIES];
typedef struct _MamanSubFooBarPrivate MamanSubFooBarPrivate;
enum  {
	MAMAN_SUB_FOO_BAR_0_PROPERTY,
	MAMAN_SUB_FOO_BAR_NUM_PROPERTIES
};
static GParamSpec* maman_sub_foo_bar_properties[MAMAN_SUB_FOO_BAR_NUM_PROPERTIES];

#define MAMAN_TYPE_ABSTRACT_BASE (maman_abstract_base_get_type ())
#define MAMAN_ABSTRACT_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_ABSTRACT_BASE, MamanAbstractBase))
#define MAMAN_ABSTRACT_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_ABSTRACT_BASE, MamanAbstractBaseClass))
#define MAMAN_IS_ABSTRACT_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_ABSTRACT_BASE))
#define MAMAN_IS_ABSTRACT_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_ABSTRACT_BASE))
#define MAMAN_ABSTRACT_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_ABSTRACT_BASE, MamanAbstractBaseClass))

typedef struct _MamanAbstractBase MamanAbstractBase;
typedef struct _MamanAbstractBaseClass MamanAbstractBaseClass;
typedef struct _MamanAbstractBasePrivate MamanAbstractBasePrivate;
enum  {
	MAMAN_ABSTRACT_BASE_0_PROPERTY,
	MAMAN_ABSTRACT_BASE_NUM_PROPERTIES
};
static GParamSpec* maman_abstract_base_properties[MAMAN_ABSTRACT_BASE_NUM_PROPERTIES];

#define MAMAN_TYPE_ABSTRACT_DERIVED (maman_abstract_derived_get_type ())
#define MAMAN_ABSTRACT_DERIVED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_ABSTRACT_DERIVED, MamanAbstractDerived))
#define MAMAN_ABSTRACT_DERIVED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_ABSTRACT_DERIVED, MamanAbstractDerivedClass))
#define MAMAN_IS_ABSTRACT_DERIVED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_ABSTRACT_DERIVED))
#define MAMAN_IS_ABSTRACT_DERIVED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_ABSTRACT_DERIVED))
#define MAMAN_ABSTRACT_DERIVED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_ABSTRACT_DERIVED, MamanAbstractDerivedClass))

typedef struct _MamanAbstractDerived MamanAbstractDerived;
typedef struct _MamanAbstractDerivedClass MamanAbstractDerivedClass;
typedef struct _MamanAbstractDerivedPrivate MamanAbstractDerivedPrivate;
enum  {
	MAMAN_ABSTRACT_DERIVED_0_PROPERTY,
	MAMAN_ABSTRACT_DERIVED_NUM_PROPERTIES
};
static GParamSpec* maman_abstract_derived_properties[MAMAN_ABSTRACT_DERIVED_NUM_PROPERTIES];

#define MAMAN_TYPE_DEEP_DERIVED (maman_deep_derived_get_type ())
#define MAMAN_DEEP_DERIVED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_DEEP_DERIVED, MamanDeepDerived))
#define MAMAN_DEEP_DERIVED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_DEEP_DERIVED, MamanDeepDerivedClass))
#define MAMAN_IS_DEEP_DERIVED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_DEEP_DERIVED))
#define MAMAN_IS_DEEP_DERIVED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_DEEP_DERIVED))
#define MAMAN_DEEP_DERIVED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_DEEP_DERIVED, MamanDeepDerivedClass))

typedef struct _MamanDeepDerived MamanDeepDerived;
typedef struct _MamanDeepDerivedClass MamanDeepDerivedClass;
typedef struct _MamanDeepDerivedPrivate MamanDeepDerivedPrivate;
enum  {
	MAMAN_DEEP_DERIVED_0_PROPERTY,
	MAMAN_DEEP_DERIVED_NUM_PROPERTIES
};
static GParamSpec* maman_deep_derived_properties[MAMAN_DEEP_DERIVED_NUM_PROPERTIES];

#define MAMAN_BASE_ACCESS_TYPE_IFOO (maman_base_access_ifoo_get_type ())
#define MAMAN_BASE_ACCESS_IFOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_BASE_ACCESS_TYPE_IFOO, MamanBaseAccessIFoo))
#define MAMAN_BASE_ACCESS_IS_IFOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_BASE_ACCESS_TYPE_IFOO))
#define MAMAN_BASE_ACCESS_IFOO_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MAMAN_BASE_ACCESS_TYPE_IFOO, MamanBaseAccessIFooIface))

typedef struct _MamanBaseAccessIFoo MamanBaseAccessIFoo;
typedef struct _MamanBaseAccessIFooIface MamanBaseAccessIFooIface;

#define MAMAN_BASE_ACCESS_TYPE_FOO (maman_base_access_foo_get_type ())
#define MAMAN_BASE_ACCESS_FOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_BASE_ACCESS_TYPE_FOO, MamanBaseAccessFoo))
#define MAMAN_BASE_ACCESS_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_BASE_ACCESS_TYPE_FOO, MamanBaseAccessFooClass))
#define MAMAN_BASE_ACCESS_IS_FOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_BASE_ACCESS_TYPE_FOO))
#define MAMAN_BASE_ACCESS_IS_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_BASE_ACCESS_TYPE_FOO))
#define MAMAN_BASE_ACCESS_FOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_BASE_ACCESS_TYPE_FOO, MamanBaseAccessFooClass))

typedef struct _MamanBaseAccessFoo MamanBaseAccessFoo;
typedef struct _MamanBaseAccessFooClass MamanBaseAccessFooClass;
typedef struct _MamanBaseAccessFooPrivate MamanBaseAccessFooPrivate;
enum  {
	MAMAN_BASE_ACCESS_FOO_0_PROPERTY,
	MAMAN_BASE_ACCESS_FOO_NUM_PROPERTIES
};
static GParamSpec* maman_base_access_foo_properties[MAMAN_BASE_ACCESS_FOO_NUM_PROPERTIES];

#define MAMAN_BASE_ACCESS_TYPE_BAR (maman_base_access_bar_get_type ())
#define MAMAN_BASE_ACCESS_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_BASE_ACCESS_TYPE_BAR, MamanBaseAccessBar))
#define MAMAN_BASE_ACCESS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_BASE_ACCESS_TYPE_BAR, MamanBaseAccessBarClass))
#define MAMAN_BASE_ACCESS_IS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_BASE_ACCESS_TYPE_BAR))
#define MAMAN_BASE_ACCESS_IS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_BASE_ACCESS_TYPE_BAR))
#define MAMAN_BASE_ACCESS_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_BASE_ACCESS_TYPE_BAR, MamanBaseAccessBarClass))

typedef struct _MamanBaseAccessBar MamanBaseAccessBar;
typedef struct _MamanBaseAccessBarClass MamanBaseAccessBarClass;
typedef struct _MamanBaseAccessBarPrivate MamanBaseAccessBarPrivate;
enum  {
	MAMAN_BASE_ACCESS_BAR_0_PROPERTY,
	MAMAN_BASE_ACCESS_BAR_NUM_PROPERTIES
};
static GParamSpec* maman_base_access_bar_properties[MAMAN_BASE_ACCESS_BAR_NUM_PROPERTIES];

#define MAMAN_BASE_ACCESS_TYPE_FOO_BAR (maman_base_access_foo_bar_get_type ())
#define MAMAN_BASE_ACCESS_FOO_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_BASE_ACCESS_TYPE_FOO_BAR, MamanBaseAccessFooBar))
#define MAMAN_BASE_ACCESS_FOO_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_BASE_ACCESS_TYPE_FOO_BAR, MamanBaseAccessFooBarClass))
#define MAMAN_BASE_ACCESS_IS_FOO_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_BASE_ACCESS_TYPE_FOO_BAR))
#define MAMAN_BASE_ACCESS_IS_FOO_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_BASE_ACCESS_TYPE_FOO_BAR))
#define MAMAN_BASE_ACCESS_FOO_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_BASE_ACCESS_TYPE_FOO_BAR, MamanBaseAccessFooBarClass))

typedef struct _MamanBaseAccessFooBar MamanBaseAccessFooBar;
typedef struct _MamanBaseAccessFooBarClass MamanBaseAccessFooBarClass;
typedef struct _MamanBaseAccessFooBarPrivate MamanBaseAccessFooBarPrivate;
enum  {
	MAMAN_BASE_ACCESS_FOO_BAR_0_PROPERTY,
	MAMAN_BASE_ACCESS_FOO_BAR_NUM_PROPERTIES
};
static GParamSpec* maman_base_access_foo_bar_properties[MAMAN_BASE_ACCESS_FOO_BAR_NUM_PROPERTIES];

#define MAMAN_TYPE_CLASS_TEST (maman_class_test_get_type ())
#define MAMAN_CLASS_TEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_CLASS_TEST, MamanClassTest))
#define MAMAN_CLASS_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_CLASS_TEST, MamanClassTestClass))
#define MAMAN_IS_CLASS_TEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_CLASS_TEST))
#define MAMAN_IS_CLASS_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_CLASS_TEST))
#define MAMAN_CLASS_TEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_CLASS_TEST, MamanClassTestClass))

typedef struct _MamanClassTest MamanClassTest;
typedef struct _MamanClassTestClass MamanClassTestClass;
typedef struct _MamanClassTestPrivate MamanClassTestPrivate;
#define _maman_class_test_unref0(var) ((var == NULL) ? NULL : (var = (maman_class_test_unref (var), NULL)))
typedef struct _MamanParamSpecClassTest MamanParamSpecClassTest;
#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 _MamanBar {
	GObject parent_instance;
	MamanBarPrivate * priv;
};

struct _MamanBarClass {
	GObjectClass parent_class;
	void (*do_virtual_action) (MamanBar* self);
};

struct _MamanSubBar {
	MamanBar parent_instance;
	MamanSubBarPrivate * priv;
};

struct _MamanSubBarClass {
	MamanBarClass parent_class;
};

struct _MamanFooIface {
	GTypeInterface parent_iface;
};

struct _MamanFooBar {
	GObject parent_instance;
	MamanFooBarPrivate * priv;
};

struct _MamanFooBarClass {
	GObjectClass parent_class;
};

struct _MamanSubFooBar {
	MamanFooBar parent_instance;
	MamanSubFooBarPrivate * priv;
};

struct _MamanSubFooBarClass {
	MamanFooBarClass parent_class;
};

struct _MamanAbstractBase {
	GObject parent_instance;
	MamanAbstractBasePrivate * priv;
};

struct _MamanAbstractBaseClass {
	GObjectClass parent_class;
	void (*foo) (MamanAbstractBase* self);
};

struct _MamanAbstractDerived {
	MamanAbstractBase parent_instance;
	MamanAbstractDerivedPrivate * priv;
};

struct _MamanAbstractDerivedClass {
	MamanAbstractBaseClass parent_class;
};

struct _MamanDeepDerived {
	MamanAbstractDerived parent_instance;
	MamanDeepDerivedPrivate * priv;
};

struct _MamanDeepDerivedClass {
	MamanAbstractDerivedClass parent_class;
};

struct _MamanBaseAccessIFooIface {
	GTypeInterface parent_iface;
	gint (*interface_method) (MamanBaseAccessIFoo* self);
	gint (*virtual_interface_method) (MamanBaseAccessIFoo* self);
};

struct _MamanBaseAccessFoo {
	GObject parent_instance;
	MamanBaseAccessFooPrivate * priv;
};

struct _MamanBaseAccessFooClass {
	GObjectClass parent_class;
	gint (*virtual_method) (MamanBaseAccessFoo* self);
	gint (*virtual_interface_method) (MamanBaseAccessFoo* self);
};

struct _MamanBaseAccessBar {
	MamanBaseAccessFoo parent_instance;
	MamanBaseAccessBarPrivate * priv;
};

struct _MamanBaseAccessBarClass {
	MamanBaseAccessFooClass parent_class;
};

struct _MamanBaseAccessFooBar {
	MamanBaseAccessFoo parent_instance;
	MamanBaseAccessFooBarPrivate * priv;
};

struct _MamanBaseAccessFooBarClass {
	MamanBaseAccessFooClass parent_class;
};

struct _MamanClassTest {
	GTypeInstance parent_instance;
	volatile int ref_count;
	MamanClassTestPrivate * priv;
};

struct _MamanClassTestClass {
	GTypeClass parent_class;
	void (*finalize) (MamanClassTest *self);
};

struct _MamanParamSpecClassTest {
	GParamSpec parent_instance;
};

static gpointer maman_bar_parent_class = NULL;
static gpointer maman_sub_bar_parent_class = NULL;
static gpointer maman_foo_bar_parent_class = NULL;
static gpointer maman_sub_foo_bar_parent_class = NULL;
static MamanFooIface * maman_sub_foo_bar_maman_foo_parent_iface = NULL;
static gpointer maman_abstract_base_parent_class = NULL;
static gpointer maman_abstract_derived_parent_class = NULL;
static gpointer maman_deep_derived_parent_class = NULL;
static gpointer maman_base_access_foo_parent_class = NULL;
static MamanBaseAccessIFooIface * maman_base_access_foo_maman_base_access_ifoo_parent_iface = NULL;
static gpointer maman_base_access_bar_parent_class = NULL;
static gpointer maman_base_access_foo_bar_parent_class = NULL;
static MamanBaseAccessIFooIface * maman_base_access_foo_bar_maman_base_access_ifoo_parent_iface = NULL;
static gpointer maman_class_test_parent_class = NULL;

VALA_EXTERN GType maman_bar_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanBar, g_object_unref)
VALA_EXTERN void maman_bar_do_virtual_action (MamanBar* self);
VALA_EXTERN void maman_bar_do_action (MamanBar* self);
VALA_EXTERN void maman_bar_do_static_action (void);
static void maman_bar_real_do_virtual_action (MamanBar* self);
VALA_EXTERN MamanBar* maman_bar_new (void);
VALA_EXTERN MamanBar* maman_bar_construct (GType object_type);
static GType maman_bar_get_type_once (void);
VALA_EXTERN GType maman_sub_bar_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanSubBar, g_object_unref)
static void maman_sub_bar_real_do_virtual_action (MamanBar* base);
static void maman_sub_bar_accept_ref_string (gchar** str);
static void maman_sub_bar_test_classes_methods_ref_parameters (void);
static gint maman_sub_bar_main (void);
VALA_EXTERN MamanSubBar* maman_sub_bar_new (void);
VALA_EXTERN MamanSubBar* maman_sub_bar_construct (GType object_type);
VALA_EXTERN GType maman_foo_bar_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanFooBar, g_object_unref)
VALA_EXTERN GType maman_sub_foo_bar_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanSubFooBar, g_object_unref)
VALA_EXTERN MamanSubFooBar* maman_sub_foo_bar_new (void);
VALA_EXTERN MamanSubFooBar* maman_sub_foo_bar_construct (GType object_type);
VALA_EXTERN GType maman_foo_get_type (void) G_GNUC_CONST ;
VALA_EXTERN void maman_foo_do_action (MamanFoo* self);
VALA_EXTERN void maman_base_access_test (void);
VALA_EXTERN void test_out (gchar** bar);
VALA_EXTERN void test_out_weak (const gchar** bar);
VALA_EXTERN void test_ref (gchar** bar);
VALA_EXTERN void test_ref_weak (const gchar** bar);
VALA_EXTERN void test_out_array_no_length (gchar*** bar);
VALA_EXTERN void maman_class_test_run_test (void);
static GType maman_sub_bar_get_type_once (void);
static GType maman_foo_get_type_once (void);
VALA_EXTERN void maman_foo_bar_do_action (MamanFooBar* self);
VALA_EXTERN MamanFooBar* maman_foo_bar_new (void);
VALA_EXTERN MamanFooBar* maman_foo_bar_construct (GType object_type);
static GType maman_foo_bar_get_type_once (void);
static GType maman_sub_foo_bar_get_type_once (void);
VALA_EXTERN GType maman_abstract_base_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanAbstractBase, g_object_unref)
VALA_EXTERN void maman_abstract_base_foo (MamanAbstractBase* self);
static void maman_abstract_base_real_foo (MamanAbstractBase* self);
VALA_EXTERN MamanAbstractBase* maman_abstract_base_construct (GType object_type);
static GType maman_abstract_base_get_type_once (void);
VALA_EXTERN GType maman_abstract_derived_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanAbstractDerived, g_object_unref)
static void maman_abstract_derived_real_foo (MamanAbstractBase* base);
VALA_EXTERN MamanAbstractDerived* maman_abstract_derived_construct (GType object_type);
static GType maman_abstract_derived_get_type_once (void);
VALA_EXTERN GType maman_deep_derived_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanDeepDerived, g_object_unref)
VALA_EXTERN MamanDeepDerived* maman_deep_derived_new (void);
VALA_EXTERN MamanDeepDerived* maman_deep_derived_construct (GType object_type);
static GType maman_deep_derived_get_type_once (void);
VALA_EXTERN GType maman_base_access_ifoo_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanBaseAccessIFoo, g_object_unref)
VALA_EXTERN gint maman_base_access_ifoo_interface_method (MamanBaseAccessIFoo* self);
VALA_EXTERN gint maman_base_access_ifoo_virtual_interface_method (MamanBaseAccessIFoo* self);
static GType maman_base_access_ifoo_get_type_once (void);
VALA_EXTERN GType maman_base_access_foo_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanBaseAccessFoo, g_object_unref)
VALA_EXTERN gint maman_base_access_foo_virtual_method (MamanBaseAccessFoo* self);
VALA_EXTERN gint maman_base_access_foo_virtual_interface_method (MamanBaseAccessFoo* self);
static gint maman_base_access_foo_real_virtual_method (MamanBaseAccessFoo* self);
static gint maman_base_access_foo_real_interface_method (MamanBaseAccessIFoo* base);
static gint maman_base_access_foo_real_virtual_interface_method (MamanBaseAccessFoo* self);
VALA_EXTERN MamanBaseAccessFoo* maman_base_access_foo_new (void);
VALA_EXTERN MamanBaseAccessFoo* maman_base_access_foo_construct (GType object_type);
static GType maman_base_access_foo_get_type_once (void);
VALA_EXTERN GType maman_base_access_bar_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanBaseAccessBar, g_object_unref)
static gint maman_base_access_bar_real_virtual_method (MamanBaseAccessFoo* base);
static gint maman_base_access_bar_real_virtual_interface_method (MamanBaseAccessFoo* base);
VALA_EXTERN MamanBaseAccessBar* maman_base_access_bar_new (void);
VALA_EXTERN MamanBaseAccessBar* maman_base_access_bar_construct (GType object_type);
static GType maman_base_access_bar_get_type_once (void);
VALA_EXTERN GType maman_base_access_foo_bar_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanBaseAccessFooBar, g_object_unref)
static gint maman_base_access_foo_bar_real_interface_method (MamanBaseAccessIFoo* base);
static gint maman_base_access_foo_bar_real_virtual_interface_method (MamanBaseAccessIFoo* base);
VALA_EXTERN MamanBaseAccessFooBar* maman_base_access_foo_bar_new (void);
VALA_EXTERN MamanBaseAccessFooBar* maman_base_access_foo_bar_construct (GType object_type);
static GType maman_base_access_foo_bar_get_type_once (void);
VALA_EXTERN gpointer maman_class_test_ref (gpointer instance);
VALA_EXTERN void maman_class_test_unref (gpointer instance);
VALA_EXTERN GParamSpec* maman_param_spec_class_test (const gchar* name,
                                         const gchar* nick,
                                         const gchar* blurb,
                                         GType object_type,
                                         GParamFlags flags);
VALA_EXTERN void maman_value_set_class_test (GValue* value,
                                 gpointer v_object);
VALA_EXTERN void maman_value_take_class_test (GValue* value,
                                  gpointer v_object);
VALA_EXTERN gpointer maman_value_get_class_test (const GValue* value);
VALA_EXTERN GType maman_class_test_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MamanClassTest, maman_class_test_unref)
VALA_EXTERN void maman_class_test_class_method (MamanClassTestClass* klass);
VALA_EXTERN void maman_class_test_instance_method (MamanClassTest* self);
VALA_EXTERN MamanClassTest* maman_class_test_new (void);
VALA_EXTERN MamanClassTest* maman_class_test_construct (GType object_type);
static void maman_class_test_finalize (MamanClassTest * obj);
static GType maman_class_test_get_type_once (void);
static void _vala_array_destroy (gpointer array,
                          gssize array_length,
                          GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array,
                       gssize array_length,
                       GDestroyNotify destroy_func);

void
maman_bar_do_action (MamanBar* self)
{
	FILE* _tmp0_;
	g_return_if_fail (MAMAN_IS_BAR (self));
	_tmp0_ = stdout;
	fprintf (_tmp0_, " 2");
}

void
maman_bar_do_static_action (void)
{
	FILE* _tmp0_;
	_tmp0_ = stdout;
	fprintf (_tmp0_, " 2");
}

static void
maman_bar_real_do_virtual_action (MamanBar* self)
{
	FILE* _tmp0_;
	_tmp0_ = stdout;
	fprintf (_tmp0_, " BAD");
}

void
maman_bar_do_virtual_action (MamanBar* self)
{
	MamanBarClass* _klass_;
	g_return_if_fail (MAMAN_IS_BAR (self));
	_klass_ = MAMAN_BAR_GET_CLASS (self);
	if (_klass_->do_virtual_action) {
		_klass_->do_virtual_action (self);
	}
}

MamanBar*
maman_bar_construct (GType object_type)
{
	MamanBar * self = NULL;
	self = (MamanBar*) g_object_new (object_type, NULL);
	return self;
}

MamanBar*
maman_bar_new (void)
{
	return maman_bar_construct (MAMAN_TYPE_BAR);
}

static void
maman_bar_class_init (MamanBarClass * klass,
                      gpointer klass_data)
{
	maman_bar_parent_class = g_type_class_peek_parent (klass);
	((MamanBarClass *) klass)->do_virtual_action = (void (*) (MamanBar*)) maman_bar_real_do_virtual_action;
}

static void
maman_bar_instance_init (MamanBar * self,
                         gpointer klass)
{
}

static GType
maman_bar_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanBarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanBar), 0, (GInstanceInitFunc) maman_bar_instance_init, NULL };
	GType maman_bar_type_id;
	maman_bar_type_id = g_type_register_static (G_TYPE_OBJECT, "MamanBar", &g_define_type_info, 0);
	return maman_bar_type_id;
}

GType
maman_bar_get_type (void)
{
	static volatile gsize maman_bar_type_id__once = 0;
	if (g_once_init_enter (&maman_bar_type_id__once)) {
		GType maman_bar_type_id;
		maman_bar_type_id = maman_bar_get_type_once ();
		g_once_init_leave (&maman_bar_type_id__once, maman_bar_type_id);
	}
	return maman_bar_type_id__once;
}

static void
maman_sub_bar_real_do_virtual_action (MamanBar* base)
{
	MamanSubBar * self;
	FILE* _tmp0_;
	self = G_TYPE_CHECK_INSTANCE_CAST (base, MAMAN_TYPE_SUB_BAR, MamanSubBar);
	_tmp0_ = stdout;
	fprintf (_tmp0_, " 2");
}

static void
maman_sub_bar_accept_ref_string (gchar** str)
{
	g_return_if_fail (*str != NULL);
}

static void
maman_sub_bar_test_classes_methods_ref_parameters (void)
{
	gchar* str = NULL;
	gchar* _tmp0_;
	_tmp0_ = g_strdup ("hello");
	str = _tmp0_;
	maman_sub_bar_accept_ref_string (&str);
	_g_free0 (str);
}

static gint
maman_sub_bar_main (void)
{
	FILE* _tmp0_;
	MamanSubBar* bar = NULL;
	MamanSubBar* _tmp1_;
	MamanSubBar* _tmp2_;
	FILE* _tmp3_;
	FILE* _tmp4_;
	FILE* _tmp5_;
	FILE* _tmp6_;
	MamanSubBar* _tmp7_;
	FILE* _tmp8_;
	FILE* _tmp9_;
	MamanSubFooBar* foobar = NULL;
	MamanSubFooBar* _tmp10_;
	MamanSubFooBar* _tmp11_;
	FILE* _tmp12_;
	gchar* str = NULL;
	gchar* str2 = NULL;
	const gchar* weak_str = NULL;
	gchar** array = NULL;
	gint array_length1 = 0;
	gint _array_size_ = 0;
	gchar* _tmp13_ = NULL;
	const gchar* _tmp14_;
	const gchar* _tmp15_ = NULL;
	const gchar* _tmp16_;
	const gchar* _tmp17_ = NULL;
	gchar* _tmp18_;
	const gchar* _tmp19_;
	const gchar* _tmp20_;
	const gchar* _tmp21_;
	gchar** _tmp22_ = NULL;
	gchar** _tmp23_;
	gint _tmp23__length1;
	const gchar* _tmp24_;
	gchar** _tmp25_;
	gint _tmp25__length1;
	const gchar* _tmp26_;
	gchar** _tmp27_;
	gint _tmp27__length1;
	gchar** _tmp28_;
	gint _tmp28__length1;
	gint result;
	_tmp0_ = stdout;
	fprintf (_tmp0_, "Inheritance Test: 1");
	_tmp1_ = maman_sub_bar_new ();
	bar = _tmp1_;
	_tmp2_ = bar;
	maman_bar_do_action (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, MAMAN_TYPE_BAR, MamanBar));
	_tmp3_ = stdout;
	fprintf (_tmp3_, " 3\n");
	_tmp4_ = stdout;
	fprintf (_tmp4_, "Static Inheritance Test: 1");
	maman_bar_do_static_action ();
	_tmp5_ = stdout;
	fprintf (_tmp5_, " 3\n");
	_tmp6_ = stdout;
	fprintf (_tmp6_, "Virtual Method Test: 1");
	_tmp7_ = bar;
	maman_bar_do_virtual_action (G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, MAMAN_TYPE_BAR, MamanBar));
	_tmp8_ = stdout;
	fprintf (_tmp8_, " 3\n");
	_tmp9_ = stdout;
	fprintf (_tmp9_, "Interface Inheritance Test: 1");
	_tmp10_ = maman_sub_foo_bar_new ();
	foobar = _tmp10_;
	_tmp11_ = foobar;
	maman_foo_do_action (G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, MAMAN_TYPE_FOO, MamanFoo));
	_tmp12_ = stdout;
	fprintf (_tmp12_, " 3\n");
	maman_sub_bar_test_classes_methods_ref_parameters ();
	maman_base_access_test ();
	test_out (&_tmp13_);
	_g_free0 (str);
	str = _tmp13_;
	_tmp14_ = str;
	_vala_assert (g_strcmp0 (_tmp14_, "hello") == 0, "str == \"hello\"");
	test_out_weak (&_tmp15_);
	weak_str = _tmp15_;
	_tmp16_ = weak_str;
	_vala_assert (g_strcmp0 (_tmp16_, "hello") == 0, "weak_str == \"hello\"");
	test_out_weak (&_tmp17_);
	_g_free0 (str2);
	_tmp18_ = g_strdup (_tmp17_);
	str2 = _tmp18_;
	_tmp19_ = str2;
	_vala_assert (g_strcmp0 (_tmp19_, "hello") == 0, "str2 == \"hello\"");
	test_ref (&str);
	_tmp20_ = str;
	_vala_assert (g_strcmp0 (_tmp20_, "world") == 0, "str == \"world\"");
	test_ref_weak (&weak_str);
	_tmp21_ = weak_str;
	_vala_assert (g_strcmp0 (_tmp21_, "world") == 0, "weak_str == \"world\"");
	test_out_array_no_length (&_tmp22_);
	array = (_vala_array_free (array, array_length1, (GDestroyNotify) g_free), NULL);
	array = _tmp22_;
	array_length1 = -1;
	_array_size_ = array_length1;
	_tmp23_ = array;
	_tmp23__length1 = array_length1;
	_tmp24_ = _tmp23_[0];
	_vala_assert (g_strcmp0 (_tmp24_, "hello") == 0, "array[0] == \"hello\"");
	_tmp25_ = array;
	_tmp25__length1 = array_length1;
	_tmp26_ = _tmp25_[1];
	_vala_assert (g_strcmp0 (_tmp26_, "world") == 0, "array[1] == \"world\"");
	_tmp27_ = array;
	_tmp27__length1 = array_length1;
	_vala_assert (_tmp27__length1 < 0, "array.length < 0");
	_tmp28_ = array;
	_tmp28__length1 = array_length1;
	if (_tmp28__length1 == -1) {
		gchar** _tmp29_;
		gint _tmp29__length1;
		_tmp29_ = array;
		_tmp29__length1 = array_length1;
		array_length1 = (gint) g_strv_length (_tmp29_);
	}
	maman_class_test_run_test ();
	result = 0;
	array = (_vala_array_free (array, array_length1, (GDestroyNotify) g_free), NULL);
	_g_free0 (str2);
	_g_free0 (str);
	_g_object_unref0 (foobar);
	_g_object_unref0 (bar);
	return result;
}

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

MamanSubBar*
maman_sub_bar_construct (GType object_type)
{
	MamanSubBar * self = NULL;
	self = (MamanSubBar*) maman_bar_construct (object_type);
	return self;
}

MamanSubBar*
maman_sub_bar_new (void)
{
	return maman_sub_bar_construct (MAMAN_TYPE_SUB_BAR);
}

static void
maman_sub_bar_class_init (MamanSubBarClass * klass,
                          gpointer klass_data)
{
	maman_sub_bar_parent_class = g_type_class_peek_parent (klass);
	((MamanBarClass *) klass)->do_virtual_action = (void (*) (MamanBar*)) maman_sub_bar_real_do_virtual_action;
}

static void
maman_sub_bar_instance_init (MamanSubBar * self,
                             gpointer klass)
{
}

static GType
maman_sub_bar_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanSubBarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_sub_bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanSubBar), 0, (GInstanceInitFunc) maman_sub_bar_instance_init, NULL };
	GType maman_sub_bar_type_id;
	maman_sub_bar_type_id = g_type_register_static (MAMAN_TYPE_BAR, "MamanSubBar", &g_define_type_info, 0);
	return maman_sub_bar_type_id;
}

GType
maman_sub_bar_get_type (void)
{
	static volatile gsize maman_sub_bar_type_id__once = 0;
	if (g_once_init_enter (&maman_sub_bar_type_id__once)) {
		GType maman_sub_bar_type_id;
		maman_sub_bar_type_id = maman_sub_bar_get_type_once ();
		g_once_init_leave (&maman_sub_bar_type_id__once, maman_sub_bar_type_id);
	}
	return maman_sub_bar_type_id__once;
}

void
maman_foo_do_action (MamanFoo* self)
{
	FILE* _tmp0_;
	_tmp0_ = stdout;
	fprintf (_tmp0_, " 2");
}

static void
maman_foo_default_init (MamanFooIface * iface,
                        gpointer iface_data)
{
}

static GType
maman_foo_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanFooIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_foo_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
	GType maman_foo_type_id;
	maman_foo_type_id = g_type_register_static (G_TYPE_INTERFACE, "MamanFoo", &g_define_type_info, 0);
	return maman_foo_type_id;
}

GType
maman_foo_get_type (void)
{
	static volatile gsize maman_foo_type_id__once = 0;
	if (g_once_init_enter (&maman_foo_type_id__once)) {
		GType maman_foo_type_id;
		maman_foo_type_id = maman_foo_get_type_once ();
		g_once_init_leave (&maman_foo_type_id__once, maman_foo_type_id);
	}
	return maman_foo_type_id__once;
}

void
maman_foo_bar_do_action (MamanFooBar* self)
{
	FILE* _tmp0_;
	g_return_if_fail (MAMAN_IS_FOO_BAR (self));
	_tmp0_ = stdout;
	fprintf (_tmp0_, " BAD");
}

MamanFooBar*
maman_foo_bar_construct (GType object_type)
{
	MamanFooBar * self = NULL;
	self = (MamanFooBar*) g_object_new (object_type, NULL);
	return self;
}

MamanFooBar*
maman_foo_bar_new (void)
{
	return maman_foo_bar_construct (MAMAN_TYPE_FOO_BAR);
}

static void
maman_foo_bar_class_init (MamanFooBarClass * klass,
                          gpointer klass_data)
{
	maman_foo_bar_parent_class = g_type_class_peek_parent (klass);
}

static void
maman_foo_bar_instance_init (MamanFooBar * self,
                             gpointer klass)
{
}

static GType
maman_foo_bar_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanFooBarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_foo_bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanFooBar), 0, (GInstanceInitFunc) maman_foo_bar_instance_init, NULL };
	GType maman_foo_bar_type_id;
	maman_foo_bar_type_id = g_type_register_static (G_TYPE_OBJECT, "MamanFooBar", &g_define_type_info, 0);
	return maman_foo_bar_type_id;
}

GType
maman_foo_bar_get_type (void)
{
	static volatile gsize maman_foo_bar_type_id__once = 0;
	if (g_once_init_enter (&maman_foo_bar_type_id__once)) {
		GType maman_foo_bar_type_id;
		maman_foo_bar_type_id = maman_foo_bar_get_type_once ();
		g_once_init_leave (&maman_foo_bar_type_id__once, maman_foo_bar_type_id);
	}
	return maman_foo_bar_type_id__once;
}

MamanSubFooBar*
maman_sub_foo_bar_construct (GType object_type)
{
	MamanSubFooBar * self = NULL;
	self = (MamanSubFooBar*) maman_foo_bar_construct (object_type);
	return self;
}

MamanSubFooBar*
maman_sub_foo_bar_new (void)
{
	return maman_sub_foo_bar_construct (MAMAN_TYPE_SUB_FOO_BAR);
}

static void
maman_sub_foo_bar_class_init (MamanSubFooBarClass * klass,
                              gpointer klass_data)
{
	maman_sub_foo_bar_parent_class = g_type_class_peek_parent (klass);
}

static void
maman_sub_foo_bar_maman_foo_interface_init (MamanFooIface * iface,
                                            gpointer iface_data)
{
	maman_sub_foo_bar_maman_foo_parent_iface = g_type_interface_peek_parent (iface);
}

static void
maman_sub_foo_bar_instance_init (MamanSubFooBar * self,
                                 gpointer klass)
{
}

static GType
maman_sub_foo_bar_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanSubFooBarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_sub_foo_bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanSubFooBar), 0, (GInstanceInitFunc) maman_sub_foo_bar_instance_init, NULL };
	static const GInterfaceInfo maman_foo_info = { (GInterfaceInitFunc) maman_sub_foo_bar_maman_foo_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	GType maman_sub_foo_bar_type_id;
	maman_sub_foo_bar_type_id = g_type_register_static (MAMAN_TYPE_FOO_BAR, "MamanSubFooBar", &g_define_type_info, 0);
	g_type_add_interface_static (maman_sub_foo_bar_type_id, MAMAN_TYPE_FOO, &maman_foo_info);
	return maman_sub_foo_bar_type_id;
}

GType
maman_sub_foo_bar_get_type (void)
{
	static volatile gsize maman_sub_foo_bar_type_id__once = 0;
	if (g_once_init_enter (&maman_sub_foo_bar_type_id__once)) {
		GType maman_sub_foo_bar_type_id;
		maman_sub_foo_bar_type_id = maman_sub_foo_bar_get_type_once ();
		g_once_init_leave (&maman_sub_foo_bar_type_id__once, maman_sub_foo_bar_type_id);
	}
	return maman_sub_foo_bar_type_id__once;
}

static void
maman_abstract_base_real_foo (MamanAbstractBase* self)
{
	g_critical ("Type `%s' does not implement abstract method `maman_abstract_base_foo'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
	return;
}

void
maman_abstract_base_foo (MamanAbstractBase* self)
{
	MamanAbstractBaseClass* _klass_;
	g_return_if_fail (MAMAN_IS_ABSTRACT_BASE (self));
	_klass_ = MAMAN_ABSTRACT_BASE_GET_CLASS (self);
	if (_klass_->foo) {
		_klass_->foo (self);
	}
}

MamanAbstractBase*
maman_abstract_base_construct (GType object_type)
{
	MamanAbstractBase * self = NULL;
	self = (MamanAbstractBase*) g_object_new (object_type, NULL);
	return self;
}

static void
maman_abstract_base_class_init (MamanAbstractBaseClass * klass,
                                gpointer klass_data)
{
	maman_abstract_base_parent_class = g_type_class_peek_parent (klass);
	((MamanAbstractBaseClass *) klass)->foo = (void (*) (MamanAbstractBase*)) maman_abstract_base_real_foo;
}

static void
maman_abstract_base_instance_init (MamanAbstractBase * self,
                                   gpointer klass)
{
}

static GType
maman_abstract_base_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanAbstractBaseClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_abstract_base_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanAbstractBase), 0, (GInstanceInitFunc) maman_abstract_base_instance_init, NULL };
	GType maman_abstract_base_type_id;
	maman_abstract_base_type_id = g_type_register_static (G_TYPE_OBJECT, "MamanAbstractBase", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
	return maman_abstract_base_type_id;
}

GType
maman_abstract_base_get_type (void)
{
	static volatile gsize maman_abstract_base_type_id__once = 0;
	if (g_once_init_enter (&maman_abstract_base_type_id__once)) {
		GType maman_abstract_base_type_id;
		maman_abstract_base_type_id = maman_abstract_base_get_type_once ();
		g_once_init_leave (&maman_abstract_base_type_id__once, maman_abstract_base_type_id);
	}
	return maman_abstract_base_type_id__once;
}

static void
maman_abstract_derived_real_foo (MamanAbstractBase* base)
{
	MamanAbstractDerived * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (base, MAMAN_TYPE_ABSTRACT_DERIVED, MamanAbstractDerived);
}

MamanAbstractDerived*
maman_abstract_derived_construct (GType object_type)
{
	MamanAbstractDerived * self = NULL;
	self = (MamanAbstractDerived*) maman_abstract_base_construct (object_type);
	return self;
}

static void
maman_abstract_derived_class_init (MamanAbstractDerivedClass * klass,
                                   gpointer klass_data)
{
	maman_abstract_derived_parent_class = g_type_class_peek_parent (klass);
	((MamanAbstractBaseClass *) klass)->foo = (void (*) (MamanAbstractBase*)) maman_abstract_derived_real_foo;
}

static void
maman_abstract_derived_instance_init (MamanAbstractDerived * self,
                                      gpointer klass)
{
}

static GType
maman_abstract_derived_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanAbstractDerivedClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_abstract_derived_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanAbstractDerived), 0, (GInstanceInitFunc) maman_abstract_derived_instance_init, NULL };
	GType maman_abstract_derived_type_id;
	maman_abstract_derived_type_id = g_type_register_static (MAMAN_TYPE_ABSTRACT_BASE, "MamanAbstractDerived", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
	return maman_abstract_derived_type_id;
}

GType
maman_abstract_derived_get_type (void)
{
	static volatile gsize maman_abstract_derived_type_id__once = 0;
	if (g_once_init_enter (&maman_abstract_derived_type_id__once)) {
		GType maman_abstract_derived_type_id;
		maman_abstract_derived_type_id = maman_abstract_derived_get_type_once ();
		g_once_init_leave (&maman_abstract_derived_type_id__once, maman_abstract_derived_type_id);
	}
	return maman_abstract_derived_type_id__once;
}

MamanDeepDerived*
maman_deep_derived_construct (GType object_type)
{
	MamanDeepDerived * self = NULL;
	self = (MamanDeepDerived*) maman_abstract_derived_construct (object_type);
	return self;
}

MamanDeepDerived*
maman_deep_derived_new (void)
{
	return maman_deep_derived_construct (MAMAN_TYPE_DEEP_DERIVED);
}

static void
maman_deep_derived_class_init (MamanDeepDerivedClass * klass,
                               gpointer klass_data)
{
	maman_deep_derived_parent_class = g_type_class_peek_parent (klass);
}

static void
maman_deep_derived_instance_init (MamanDeepDerived * self,
                                  gpointer klass)
{
}

static GType
maman_deep_derived_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanDeepDerivedClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_deep_derived_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanDeepDerived), 0, (GInstanceInitFunc) maman_deep_derived_instance_init, NULL };
	GType maman_deep_derived_type_id;
	maman_deep_derived_type_id = g_type_register_static (MAMAN_TYPE_ABSTRACT_DERIVED, "MamanDeepDerived", &g_define_type_info, 0);
	return maman_deep_derived_type_id;
}

GType
maman_deep_derived_get_type (void)
{
	static volatile gsize maman_deep_derived_type_id__once = 0;
	if (g_once_init_enter (&maman_deep_derived_type_id__once)) {
		GType maman_deep_derived_type_id;
		maman_deep_derived_type_id = maman_deep_derived_get_type_once ();
		g_once_init_leave (&maman_deep_derived_type_id__once, maman_deep_derived_type_id);
	}
	return maman_deep_derived_type_id__once;
}

gint
maman_base_access_ifoo_interface_method (MamanBaseAccessIFoo* self)
{
	MamanBaseAccessIFooIface* _iface_;
	g_return_val_if_fail (MAMAN_BASE_ACCESS_IS_IFOO (self), 0);
	_iface_ = MAMAN_BASE_ACCESS_IFOO_GET_INTERFACE (self);
	if (_iface_->interface_method) {
		return _iface_->interface_method (self);
	}
	return -1;
}

gint
maman_base_access_ifoo_virtual_interface_method (MamanBaseAccessIFoo* self)
{
	MamanBaseAccessIFooIface* _iface_;
	g_return_val_if_fail (MAMAN_BASE_ACCESS_IS_IFOO (self), 0);
	_iface_ = MAMAN_BASE_ACCESS_IFOO_GET_INTERFACE (self);
	if (_iface_->virtual_interface_method) {
		return _iface_->virtual_interface_method (self);
	}
	return -1;
}

static void
maman_base_access_ifoo_default_init (MamanBaseAccessIFooIface * iface,
                                     gpointer iface_data)
{
}

static GType
maman_base_access_ifoo_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanBaseAccessIFooIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_base_access_ifoo_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
	GType maman_base_access_ifoo_type_id;
	maman_base_access_ifoo_type_id = g_type_register_static (G_TYPE_INTERFACE, "MamanBaseAccessIFoo", &g_define_type_info, 0);
	g_type_interface_add_prerequisite (maman_base_access_ifoo_type_id, G_TYPE_OBJECT);
	return maman_base_access_ifoo_type_id;
}

GType
maman_base_access_ifoo_get_type (void)
{
	static volatile gsize maman_base_access_ifoo_type_id__once = 0;
	if (g_once_init_enter (&maman_base_access_ifoo_type_id__once)) {
		GType maman_base_access_ifoo_type_id;
		maman_base_access_ifoo_type_id = maman_base_access_ifoo_get_type_once ();
		g_once_init_leave (&maman_base_access_ifoo_type_id__once, maman_base_access_ifoo_type_id);
	}
	return maman_base_access_ifoo_type_id__once;
}

static gint
maman_base_access_foo_real_virtual_method (MamanBaseAccessFoo* self)
{
	gint result;
	result = 1;
	return result;
}

gint
maman_base_access_foo_virtual_method (MamanBaseAccessFoo* self)
{
	MamanBaseAccessFooClass* _klass_;
	g_return_val_if_fail (MAMAN_BASE_ACCESS_IS_FOO (self), 0);
	_klass_ = MAMAN_BASE_ACCESS_FOO_GET_CLASS (self);
	if (_klass_->virtual_method) {
		return _klass_->virtual_method (self);
	}
	return -1;
}

static gint
maman_base_access_foo_real_interface_method (MamanBaseAccessIFoo* base)
{
	MamanBaseAccessFoo * self;
	gint result;
	self = G_TYPE_CHECK_INSTANCE_CAST (base, MAMAN_BASE_ACCESS_TYPE_FOO, MamanBaseAccessFoo);
	result = 2;
	return result;
}

static gint
maman_base_access_foo_real_virtual_interface_method (MamanBaseAccessFoo* self)
{
	gint result;
	result = 3;
	return result;
}

gint
maman_base_access_foo_virtual_interface_method (MamanBaseAccessFoo* self)
{
	MamanBaseAccessFooClass* _klass_;
	g_return_val_if_fail (MAMAN_BASE_ACCESS_IS_FOO (self), 0);
	_klass_ = MAMAN_BASE_ACCESS_FOO_GET_CLASS (self);
	if (_klass_->virtual_interface_method) {
		return _klass_->virtual_interface_method (self);
	}
	return -1;
}

MamanBaseAccessFoo*
maman_base_access_foo_construct (GType object_type)
{
	MamanBaseAccessFoo * self = NULL;
	self = (MamanBaseAccessFoo*) g_object_new (object_type, NULL);
	return self;
}

MamanBaseAccessFoo*
maman_base_access_foo_new (void)
{
	return maman_base_access_foo_construct (MAMAN_BASE_ACCESS_TYPE_FOO);
}

static void
maman_base_access_foo_class_init (MamanBaseAccessFooClass * klass,
                                  gpointer klass_data)
{
	maman_base_access_foo_parent_class = g_type_class_peek_parent (klass);
	((MamanBaseAccessFooClass *) klass)->virtual_method = (gint (*) (MamanBaseAccessFoo*)) maman_base_access_foo_real_virtual_method;
	((MamanBaseAccessFooClass *) klass)->virtual_interface_method = (gint (*) (MamanBaseAccessFoo*)) maman_base_access_foo_real_virtual_interface_method;
}

static void
maman_base_access_foo_maman_base_access_ifoo_interface_init (MamanBaseAccessIFooIface * iface,
                                                             gpointer iface_data)
{
	maman_base_access_foo_maman_base_access_ifoo_parent_iface = g_type_interface_peek_parent (iface);
	iface->interface_method = (gint (*) (MamanBaseAccessIFoo*)) maman_base_access_foo_real_interface_method;
	iface->virtual_interface_method = (gint (*) (MamanBaseAccessIFoo*)) maman_base_access_foo_virtual_interface_method;
}

static void
maman_base_access_foo_instance_init (MamanBaseAccessFoo * self,
                                     gpointer klass)
{
}

static GType
maman_base_access_foo_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanBaseAccessFooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_base_access_foo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanBaseAccessFoo), 0, (GInstanceInitFunc) maman_base_access_foo_instance_init, NULL };
	static const GInterfaceInfo maman_base_access_ifoo_info = { (GInterfaceInitFunc) maman_base_access_foo_maman_base_access_ifoo_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	GType maman_base_access_foo_type_id;
	maman_base_access_foo_type_id = g_type_register_static (G_TYPE_OBJECT, "MamanBaseAccessFoo", &g_define_type_info, 0);
	g_type_add_interface_static (maman_base_access_foo_type_id, MAMAN_BASE_ACCESS_TYPE_IFOO, &maman_base_access_ifoo_info);
	return maman_base_access_foo_type_id;
}

GType
maman_base_access_foo_get_type (void)
{
	static volatile gsize maman_base_access_foo_type_id__once = 0;
	if (g_once_init_enter (&maman_base_access_foo_type_id__once)) {
		GType maman_base_access_foo_type_id;
		maman_base_access_foo_type_id = maman_base_access_foo_get_type_once ();
		g_once_init_leave (&maman_base_access_foo_type_id__once, maman_base_access_foo_type_id);
	}
	return maman_base_access_foo_type_id__once;
}

static gint
maman_base_access_bar_real_virtual_method (MamanBaseAccessFoo* base)
{
	MamanBaseAccessBar * self;
	gint result;
	self = G_TYPE_CHECK_INSTANCE_CAST (base, MAMAN_BASE_ACCESS_TYPE_BAR, MamanBaseAccessBar);
	result = (MAMAN_BASE_ACCESS_FOO_CLASS (maman_base_access_bar_parent_class)->virtual_method (G_TYPE_CHECK_INSTANCE_CAST (self, MAMAN_BASE_ACCESS_TYPE_FOO, MamanBaseAccessFoo)) * 10) + 4;
	return result;
}

static gint
maman_base_access_bar_real_virtual_interface_method (MamanBaseAccessFoo* base)
{
	MamanBaseAccessBar * self;
	gint result;
	self = G_TYPE_CHECK_INSTANCE_CAST (base, MAMAN_BASE_ACCESS_TYPE_BAR, MamanBaseAccessBar);
	result = (MAMAN_BASE_ACCESS_FOO_CLASS (maman_base_access_bar_parent_class)->virtual_interface_method (G_TYPE_CHECK_INSTANCE_CAST (self, MAMAN_BASE_ACCESS_TYPE_FOO, MamanBaseAccessFoo)) * 10) + 5;
	return result;
}

MamanBaseAccessBar*
maman_base_access_bar_construct (GType object_type)
{
	MamanBaseAccessBar * self = NULL;
	self = (MamanBaseAccessBar*) maman_base_access_foo_construct (object_type);
	return self;
}

MamanBaseAccessBar*
maman_base_access_bar_new (void)
{
	return maman_base_access_bar_construct (MAMAN_BASE_ACCESS_TYPE_BAR);
}

static void
maman_base_access_bar_class_init (MamanBaseAccessBarClass * klass,
                                  gpointer klass_data)
{
	maman_base_access_bar_parent_class = g_type_class_peek_parent (klass);
	((MamanBaseAccessFooClass *) klass)->virtual_method = (gint (*) (MamanBaseAccessFoo*)) maman_base_access_bar_real_virtual_method;
	((MamanBaseAccessFooClass *) klass)->virtual_interface_method = (gint (*) (MamanBaseAccessFoo*)) maman_base_access_bar_real_virtual_interface_method;
}

static void
maman_base_access_bar_instance_init (MamanBaseAccessBar * self,
                                     gpointer klass)
{
}

static GType
maman_base_access_bar_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanBaseAccessBarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_base_access_bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanBaseAccessBar), 0, (GInstanceInitFunc) maman_base_access_bar_instance_init, NULL };
	GType maman_base_access_bar_type_id;
	maman_base_access_bar_type_id = g_type_register_static (MAMAN_BASE_ACCESS_TYPE_FOO, "MamanBaseAccessBar", &g_define_type_info, 0);
	return maman_base_access_bar_type_id;
}

GType
maman_base_access_bar_get_type (void)
{
	static volatile gsize maman_base_access_bar_type_id__once = 0;
	if (g_once_init_enter (&maman_base_access_bar_type_id__once)) {
		GType maman_base_access_bar_type_id;
		maman_base_access_bar_type_id = maman_base_access_bar_get_type_once ();
		g_once_init_leave (&maman_base_access_bar_type_id__once, maman_base_access_bar_type_id);
	}
	return maman_base_access_bar_type_id__once;
}

static gint
maman_base_access_foo_bar_real_interface_method (MamanBaseAccessIFoo* base)
{
	MamanBaseAccessFooBar * self;
	gint result;
	self = G_TYPE_CHECK_INSTANCE_CAST (base, MAMAN_BASE_ACCESS_TYPE_FOO_BAR, MamanBaseAccessFooBar);
	result = (maman_base_access_foo_bar_maman_base_access_ifoo_parent_iface->interface_method (G_TYPE_CHECK_INSTANCE_CAST (G_TYPE_CHECK_INSTANCE_CAST (self, MAMAN_BASE_ACCESS_TYPE_FOO, MamanBaseAccessFoo), MAMAN_BASE_ACCESS_TYPE_IFOO, MamanBaseAccessIFoo)) * 10) + 6;
	return result;
}

static gint
maman_base_access_foo_bar_real_virtual_interface_method (MamanBaseAccessIFoo* base)
{
	MamanBaseAccessFooBar * self;
	gint result;
	self = G_TYPE_CHECK_INSTANCE_CAST (base, MAMAN_BASE_ACCESS_TYPE_FOO_BAR, MamanBaseAccessFooBar);
	result = -1;
	return result;
}

MamanBaseAccessFooBar*
maman_base_access_foo_bar_construct (GType object_type)
{
	MamanBaseAccessFooBar * self = NULL;
	self = (MamanBaseAccessFooBar*) maman_base_access_foo_construct (object_type);
	return self;
}

MamanBaseAccessFooBar*
maman_base_access_foo_bar_new (void)
{
	return maman_base_access_foo_bar_construct (MAMAN_BASE_ACCESS_TYPE_FOO_BAR);
}

static void
maman_base_access_foo_bar_class_init (MamanBaseAccessFooBarClass * klass,
                                      gpointer klass_data)
{
	maman_base_access_foo_bar_parent_class = g_type_class_peek_parent (klass);
}

static void
maman_base_access_foo_bar_maman_base_access_ifoo_interface_init (MamanBaseAccessIFooIface * iface,
                                                                 gpointer iface_data)
{
	maman_base_access_foo_bar_maman_base_access_ifoo_parent_iface = g_type_interface_peek_parent (iface);
	iface->interface_method = (gint (*) (MamanBaseAccessIFoo*)) maman_base_access_foo_bar_real_interface_method;
	iface->virtual_interface_method = (gint (*) (MamanBaseAccessIFoo*)) maman_base_access_foo_bar_real_virtual_interface_method;
}

static void
maman_base_access_foo_bar_instance_init (MamanBaseAccessFooBar * self,
                                         gpointer klass)
{
}

static GType
maman_base_access_foo_bar_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MamanBaseAccessFooBarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_base_access_foo_bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanBaseAccessFooBar), 0, (GInstanceInitFunc) maman_base_access_foo_bar_instance_init, NULL };
	static const GInterfaceInfo maman_base_access_ifoo_info = { (GInterfaceInitFunc) maman_base_access_foo_bar_maman_base_access_ifoo_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	GType maman_base_access_foo_bar_type_id;
	maman_base_access_foo_bar_type_id = g_type_register_static (MAMAN_BASE_ACCESS_TYPE_FOO, "MamanBaseAccessFooBar", &g_define_type_info, 0);
	g_type_add_interface_static (maman_base_access_foo_bar_type_id, MAMAN_BASE_ACCESS_TYPE_IFOO, &maman_base_access_ifoo_info);
	return maman_base_access_foo_bar_type_id;
}

GType
maman_base_access_foo_bar_get_type (void)
{
	static volatile gsize maman_base_access_foo_bar_type_id__once = 0;
	if (g_once_init_enter (&maman_base_access_foo_bar_type_id__once)) {
		GType maman_base_access_foo_bar_type_id;
		maman_base_access_foo_bar_type_id = maman_base_access_foo_bar_get_type_once ();
		g_once_init_leave (&maman_base_access_foo_bar_type_id__once, maman_base_access_foo_bar_type_id);
	}
	return maman_base_access_foo_bar_type_id__once;
}

void
maman_base_access_test (void)
{
	MamanBaseAccessBar* bar = NULL;
	MamanBaseAccessBar* _tmp0_;
	MamanBaseAccessFooBar* foobar = NULL;
	MamanBaseAccessFooBar* _tmp1_;
	_tmp0_ = maman_base_access_bar_new ();
	bar = _tmp0_;
	_tmp1_ = maman_base_access_foo_bar_new ();
	foobar = _tmp1_;
	_vala_assert (maman_base_access_foo_virtual_method (G_TYPE_CHECK_INSTANCE_CAST (bar, MAMAN_BASE_ACCESS_TYPE_FOO, MamanBaseAccessFoo)) == 14, "bar.virtual_method () == 14");
	_vala_assert (maman_base_access_foo_virtual_interface_method (G_TYPE_CHECK_INSTANCE_CAST (bar, MAMAN_BASE_ACCESS_TYPE_FOO, MamanBaseAccessFoo)) == 35, "bar.virtual_interface_method () == 35");
	_vala_assert (maman_base_access_ifoo_interface_method (G_TYPE_CHECK_INSTANCE_CAST (foobar, MAMAN_BASE_ACCESS_TYPE_IFOO, MamanBaseAccessIFoo)) == 26, "foobar.interface_method () == 26");
	_g_object_unref0 (foobar);
	_g_object_unref0 (bar);
}

void
test_out (gchar** bar)
{
	gchar* _vala_bar = NULL;
	gchar* _tmp0_;
	_tmp0_ = g_strdup ("hello");
	_g_free0 (_vala_bar);
	_vala_bar = _tmp0_;
	if (bar) {
		*bar = _vala_bar;
	} else {
		_g_free0 (_vala_bar);
	}
}

void
test_out_weak (const gchar** bar)
{
	const gchar* _vala_bar = NULL;
	_vala_bar = "hello";
	if (bar) {
		*bar = _vala_bar;
	}
}

void
test_ref (gchar** bar)
{
	gchar* _tmp0_;
	g_return_if_fail (*bar != NULL);
	_vala_assert (g_strcmp0 (*bar, "hello") == 0, "bar == \"hello\"");
	_tmp0_ = g_strdup ("world");
	_g_free0 (*bar);
	*bar = _tmp0_;
}

void
test_ref_weak (const gchar** bar)
{
	g_return_if_fail (*bar != NULL);
	_vala_assert (g_strcmp0 (*bar, "hello") == 0, "bar == \"hello\"");
	*bar = "world";
}

void
test_out_array_no_length (gchar*** bar)
{
	gchar** _vala_bar = NULL;
	gint _vala_bar_length1 = 0;
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar** _tmp2_;
	_tmp0_ = g_strdup ("hello");
	_tmp1_ = g_strdup ("world");
	_tmp2_ = g_new0 (gchar*, 2 + 1);
	_tmp2_[0] = _tmp0_;
	_tmp2_[1] = _tmp1_;
	_vala_bar = (g_free (_vala_bar), NULL);
	_vala_bar = _tmp2_;
	if (bar) {
		*bar = _vala_bar;
	} else {
		_vala_bar = (g_free (_vala_bar), NULL);
	}
}

void
maman_class_test_class_method (MamanClassTestClass* klass)
{
	FILE* _tmp0_;
	_tmp0_ = stdout;
	fprintf (_tmp0_, " OK\n");
}

void
maman_class_test_instance_method (MamanClassTest* self)
{
	FILE* _tmp0_;
	g_return_if_fail (MAMAN_IS_CLASS_TEST (self));
	_tmp0_ = stdout;
	fprintf (_tmp0_, "Access class method in instance method:");
	maman_class_test_class_method (MAMAN_CLASS_TEST_GET_CLASS (self));
}

void
maman_class_test_run_test (void)
{
	MamanClassTest* c = NULL;
	MamanClassTest* _tmp0_;
	FILE* _tmp1_;
	_tmp0_ = maman_class_test_new ();
	c = _tmp0_;
	_tmp1_ = stdout;
	fprintf (_tmp1_, "Access class method by member access:");
	maman_class_test_class_method (MAMAN_CLASS_TEST_GET_CLASS (c));
	maman_class_test_instance_method (c);
	_maman_class_test_unref0 (c);
}

MamanClassTest*
maman_class_test_construct (GType object_type)
{
	MamanClassTest* self = NULL;
	self = (MamanClassTest*) g_type_create_instance (object_type);
	return self;
}

MamanClassTest*
maman_class_test_new (void)
{
	return maman_class_test_construct (MAMAN_TYPE_CLASS_TEST);
}

static void
maman_value_class_test_init (GValue* value)
{
	value->data[0].v_pointer = NULL;
}

static void
maman_value_class_test_free_value (GValue* value)
{
	if (value->data[0].v_pointer) {
		maman_class_test_unref (value->data[0].v_pointer);
	}
}

static void
maman_value_class_test_copy_value (const GValue* src_value,
                                   GValue* dest_value)
{
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = maman_class_test_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}

static gpointer
maman_value_class_test_peek_pointer (const GValue* value)
{
	return value->data[0].v_pointer;
}

static gchar*
maman_value_class_test_collect_value (GValue* value,
                                      guint n_collect_values,
                                      GTypeCValue* collect_values,
                                      guint collect_flags)
{
	if (collect_values[0].v_pointer) {
		MamanClassTest * object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = maman_class_test_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}

static gchar*
maman_value_class_test_lcopy_value (const GValue* value,
                                    guint n_collect_values,
                                    GTypeCValue* collect_values,
                                    guint collect_flags)
{
	MamanClassTest ** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = maman_class_test_ref (value->data[0].v_pointer);
	}
	return NULL;
}

GParamSpec*
maman_param_spec_class_test (const gchar* name,
                             const gchar* nick,
                             const gchar* blurb,
                             GType object_type,
                             GParamFlags flags)
{
	MamanParamSpecClassTest* spec;
	g_return_val_if_fail (g_type_is_a (object_type, MAMAN_TYPE_CLASS_TEST), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}

gpointer
maman_value_get_class_test (const GValue* value)
{
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MAMAN_TYPE_CLASS_TEST), NULL);
	return value->data[0].v_pointer;
}

void
maman_value_set_class_test (GValue* value,
                            gpointer v_object)
{
	MamanClassTest * old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MAMAN_TYPE_CLASS_TEST));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MAMAN_TYPE_CLASS_TEST));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		maman_class_test_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		maman_class_test_unref (old);
	}
}

void
maman_value_take_class_test (GValue* value,
                             gpointer v_object)
{
	MamanClassTest * old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MAMAN_TYPE_CLASS_TEST));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MAMAN_TYPE_CLASS_TEST));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		maman_class_test_unref (old);
	}
}

static void
maman_class_test_base_init (MamanClassTestClass * klass)
{
	FILE* _tmp0_;
	_tmp0_ = stdout;
	fprintf (_tmp0_, "Access class method in class constructor:");
	maman_class_test_class_method (klass);
}

static void
maman_class_test_class_init (MamanClassTestClass * klass,
                             gpointer klass_data)
{
	FILE* _tmp0_;
	maman_class_test_parent_class = g_type_class_peek_parent (klass);
	((MamanClassTestClass *) klass)->finalize = maman_class_test_finalize;
	_tmp0_ = stdout;
	fprintf (_tmp0_, "Access class method in static constructor:");
	maman_class_test_class_method (klass);
}

static void
maman_class_test_instance_init (MamanClassTest * self,
                                gpointer klass)
{
	self->ref_count = 1;
}

static void
maman_class_test_finalize (MamanClassTest * obj)
{
	MamanClassTest * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, MAMAN_TYPE_CLASS_TEST, MamanClassTest);
	g_signal_handlers_destroy (self);
}

static GType
maman_class_test_get_type_once (void)
{
	static const GTypeValueTable g_define_type_value_table = { maman_value_class_test_init, maman_value_class_test_free_value, maman_value_class_test_copy_value, maman_value_class_test_peek_pointer, "p", maman_value_class_test_collect_value, "p", maman_value_class_test_lcopy_value };
	static const GTypeInfo g_define_type_info = { sizeof (MamanClassTestClass), (GBaseInitFunc) maman_class_test_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) maman_class_test_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MamanClassTest), 0, (GInstanceInitFunc) maman_class_test_instance_init, &g_define_type_value_table };
	static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
	GType maman_class_test_type_id;
	maman_class_test_type_id = g_type_register_fundamental (g_type_fundamental_next (), "MamanClassTest", &g_define_type_info, &g_define_type_fundamental_info, 0);
	return maman_class_test_type_id;
}

GType
maman_class_test_get_type (void)
{
	static volatile gsize maman_class_test_type_id__once = 0;
	if (g_once_init_enter (&maman_class_test_type_id__once)) {
		GType maman_class_test_type_id;
		maman_class_test_type_id = maman_class_test_get_type_once ();
		g_once_init_leave (&maman_class_test_type_id__once, maman_class_test_type_id);
	}
	return maman_class_test_type_id__once;
}

gpointer
maman_class_test_ref (gpointer instance)
{
	MamanClassTest * self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}

void
maman_class_test_unref (gpointer instance)
{
	MamanClassTest * self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		MAMAN_CLASS_TEST_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}

static void
_vala_array_destroy (gpointer array,
                     gssize array_length,
                     GDestroyNotify destroy_func)
{
	if ((array != NULL) && (destroy_func != NULL)) {
		gssize 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,
                  gssize array_length,
                  GDestroyNotify destroy_func)
{
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}