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

#include <glib.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <math.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

#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))

#define TYPE_FOO (foo_get_type ())
typedef struct _Foo Foo;
#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 {
	gchar* s;
	guint64 u64;
	gboolean b;
};

VALA_EXTERN void string_conversion (void);
static GVariant* _variant_new1 (const gchar* value);
static gchar* _variant_get1 (GVariant* value);
VALA_EXTERN void string_array_conversion (void);
static GVariant* _variant_new2 (gchar** value,
                         gint value_length1);
static gchar** _variant_get2 (GVariant* value,
                       gint* result_length1);
VALA_EXTERN void string_array_2d_conversion (void);
static GVariant* _variant_new3 (gchar** value,
                         gint value_length1,
                         gint value_length2);
static gchar** _variant_get3 (GVariant* value,
                       gint* result_length1,
                       gint* result_length2);
VALA_EXTERN void string_array_3d_conversion (void);
static GVariant* _variant_new4 (gchar** value,
                         gint value_length1,
                         gint value_length2,
                         gint value_length3);
static gchar** _variant_get4 (GVariant* value,
                       gint* result_length1,
                       gint* result_length2,
                       gint* result_length3);
VALA_EXTERN void double_conversion (void);
static GVariant* _variant_new5 (gdouble value);
static gdouble _variant_get5 (GVariant* value);
VALA_EXTERN void double_array_conversion (void);
static GVariant* _variant_new6 (gdouble* value,
                         gint value_length1);
static gdouble* _variant_get6 (GVariant* value,
                        gint* result_length1);
VALA_EXTERN void double_array_2d_conversion (void);
static GVariant* _variant_new7 (gdouble* value,
                         gint value_length1,
                         gint value_length2);
static gdouble* _variant_get7 (GVariant* value,
                        gint* result_length1,
                        gint* result_length2);
VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ;
VALA_EXTERN Foo* foo_dup (const Foo* self);
VALA_EXTERN void foo_free (Foo* self);
VALA_EXTERN void foo_copy (const Foo* self,
               Foo* dest);
VALA_EXTERN void foo_destroy (Foo* self);
G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (Foo, foo_destroy)
VALA_EXTERN void struct_conversion (void);
static GVariant* _variant_new8 (Foo value);
static void _variant_get8 (GVariant* value,
                    Foo * result);
static void _vala_main (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);

static GVariant*
_variant_new1 (const gchar* value)
{
	return g_variant_ref_sink (g_variant_new_string (value));
}

static gchar*
_variant_get1 (GVariant* value)
{
	return g_variant_dup_string (value, NULL);
}

void
string_conversion (void)
{
	GVariant* v = NULL;
	GVariant* _tmp0_;
	gchar* s = NULL;
	gchar* _tmp1_;
	_tmp0_ = _variant_new1 ("foo");
	v = _tmp0_;
	_tmp1_ = _variant_get1 (v);
	s = _tmp1_;
	_vala_assert (g_strcmp0 (s, "foo") == 0, "s == \"foo\"");
	_g_free0 (s);
	_g_variant_unref0 (v);
}

static GVariant*
_variant_new2 (gchar** value,
               gint value_length1)
{
	gchar** _tmp4_;
	GVariantBuilder _tmp5_;
	gint _tmp6_;
	_tmp4_ = value;
	g_variant_builder_init (&_tmp5_, G_VARIANT_TYPE ("as"));
	for (_tmp6_ = 0; _tmp6_ < value_length1; _tmp6_++) {
		g_variant_builder_add_value (&_tmp5_, g_variant_new_string (*_tmp4_));
		_tmp4_++;
	}
	return g_variant_ref_sink (g_variant_builder_end (&_tmp5_));
}

static gchar**
_variant_get2 (GVariant* value,
               gint* result_length1)
{
	gchar** _tmp0_;
	gint _tmp0__length;
	gint _tmp0__size;
	gint _tmp0__length1;
	GVariantIter _tmp1_;
	GVariant* _tmp2_;
	_tmp0_ = g_new (gchar*, 5);
	_tmp0__length = 0;
	_tmp0__size = 4;
	_tmp0__length1 = 0;
	g_variant_iter_init (&_tmp1_, value);
	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
		if (_tmp0__size == _tmp0__length) {
			_tmp0__size = 2 * _tmp0__size;
			_tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
		}
		_tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
		g_variant_unref (_tmp2_);
	}
	*result_length1 = _tmp0__length1;
	_tmp0_[_tmp0__length] = NULL;
	return _tmp0_;
}

void
string_array_conversion (void)
{
	GVariant* v = NULL;
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar** _tmp2_;
	gchar** _tmp3_;
	gint _tmp3__length1;
	GVariant* _tmp7_;
	GVariant* _tmp8_;
	gchar** sa = NULL;
	gchar** _tmp9_ = NULL;
	gint _tmp9__length1 = 0;
	gint sa_length1;
	gint _sa_size_;
	const gchar* _tmp10_;
	_tmp0_ = g_strdup ("foo");
	_tmp1_ = g_strdup ("bar");
	_tmp2_ = g_new0 (gchar*, 2 + 1);
	_tmp2_[0] = _tmp0_;
	_tmp2_[1] = _tmp1_;
	_tmp3_ = _tmp2_;
	_tmp3__length1 = 2;
	_tmp7_ = _variant_new2 (_tmp3_, 2);
	_tmp8_ = _tmp7_;
	_tmp3_ = (_vala_array_free (_tmp3_, _tmp3__length1, (GDestroyNotify) g_free), NULL);
	v = _tmp8_;
	_tmp9_ = _variant_get2 (v, &_tmp9__length1);
	sa = _tmp9_;
	sa_length1 = _tmp9__length1;
	_sa_size_ = sa_length1;
	_vala_assert (sa_length1 == 2, "sa.length == 2");
	_tmp10_ = sa[1];
	_vala_assert (g_strcmp0 (_tmp10_, "bar") == 0, "sa[1] == \"bar\"");
	sa = (_vala_array_free (sa, sa_length1, (GDestroyNotify) g_free), NULL);
	_g_variant_unref0 (v);
}

static GVariant*
_variant_new3 (gchar** value,
               gint value_length1,
               gint value_length2)
{
	gchar** _tmp6_;
	GVariantBuilder _tmp7_;
	gint _tmp8_;
	_tmp6_ = value;
	g_variant_builder_init (&_tmp7_, G_VARIANT_TYPE ("aas"));
	for (_tmp8_ = 0; _tmp8_ < value_length1; _tmp8_++) {
		GVariantBuilder _tmp9_;
		gint _tmp10_;
		g_variant_builder_init (&_tmp9_, G_VARIANT_TYPE ("as"));
		for (_tmp10_ = 0; _tmp10_ < value_length2; _tmp10_++) {
			g_variant_builder_add_value (&_tmp9_, g_variant_new_string (*_tmp6_));
			_tmp6_++;
		}
		g_variant_builder_add_value (&_tmp7_, g_variant_builder_end (&_tmp9_));
	}
	return g_variant_ref_sink (g_variant_builder_end (&_tmp7_));
}

static gchar**
_variant_get3 (GVariant* value,
               gint* result_length1,
               gint* result_length2)
{
	gchar** _tmp0_;
	gint _tmp0__length;
	gint _tmp0__size;
	gint _tmp0__length1;
	GVariantIter _tmp1_;
	GVariant* _tmp2_;
	_tmp0_ = g_new (gchar*, 5);
	_tmp0__length = 0;
	_tmp0__size = 4;
	_tmp0__length1 = 0;
	g_variant_iter_init (&_tmp1_, value);
	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
		gint _tmp0__length2;
		GVariantIter _tmp3_;
		GVariant* _tmp4_;
		_tmp0__length2 = 0;
		g_variant_iter_init (&_tmp3_, _tmp2_);
		for (; (_tmp4_ = g_variant_iter_next_value (&_tmp3_)) != NULL; _tmp0__length2++) {
			if (_tmp0__size == _tmp0__length) {
				_tmp0__size = 2 * _tmp0__size;
				_tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
			}
			_tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp4_, NULL);
			g_variant_unref (_tmp4_);
		}
		*result_length2 = _tmp0__length2;
		g_variant_unref (_tmp2_);
	}
	*result_length1 = _tmp0__length1;
	_tmp0_[_tmp0__length] = NULL;
	return _tmp0_;
}

void
string_array_2d_conversion (void)
{
	GVariant* v = NULL;
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	gint _tmp5__length2;
	GVariant* _tmp11_;
	GVariant* _tmp12_;
	gchar** sa = NULL;
	gchar** _tmp13_ = NULL;
	gint _tmp13__length1 = 0;
	gint _tmp13__length2 = 0;
	gint sa_length1;
	gint sa_length2;
	gint _tmp14_;
	gint _tmp15_;
	const gchar* _tmp16_;
	_tmp0_ = g_strdup ("foo");
	_tmp1_ = g_strdup ("faz");
	_tmp2_ = g_strdup ("bar");
	_tmp3_ = g_strdup ("baz");
	_tmp4_ = g_new0 (gchar*, (2 * 2) + 1);
	_tmp4_[0] = _tmp0_;
	_tmp4_[1] = _tmp1_;
	_tmp4_[2] = _tmp2_;
	_tmp4_[3] = _tmp3_;
	_tmp5_ = _tmp4_;
	_tmp5__length1 = 2;
	_tmp5__length2 = 2;
	_tmp11_ = _variant_new3 (_tmp5_, 2, 2);
	_tmp12_ = _tmp11_;
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1 * _tmp5__length2, (GDestroyNotify) g_free), NULL);
	v = _tmp12_;
	_tmp13_ = _variant_get3 (v, &_tmp13__length1, &_tmp13__length2);
	sa = _tmp13_;
	sa_length1 = _tmp13__length1;
	sa_length2 = _tmp13__length2;
	_tmp14_ = sa_length1;
	_vala_assert (_tmp14_ == 2, "sa.length[0] == 2");
	_tmp15_ = sa_length2;
	_vala_assert (_tmp15_ == 2, "sa.length[1] == 2");
	_tmp16_ = sa[(1 * sa_length2) + 1];
	_vala_assert (g_strcmp0 (_tmp16_, "baz") == 0, "sa[1,1] == \"baz\"");
	sa = (_vala_array_free (sa, sa_length1 * sa_length2, (GDestroyNotify) g_free), NULL);
	_g_variant_unref0 (v);
}

static GVariant*
_variant_new4 (gchar** value,
               gint value_length1,
               gint value_length2,
               gint value_length3)
{
	gchar** _tmp10_;
	GVariantBuilder _tmp11_;
	gint _tmp12_;
	_tmp10_ = value;
	g_variant_builder_init (&_tmp11_, G_VARIANT_TYPE ("aaas"));
	for (_tmp12_ = 0; _tmp12_ < value_length1; _tmp12_++) {
		GVariantBuilder _tmp13_;
		gint _tmp14_;
		g_variant_builder_init (&_tmp13_, G_VARIANT_TYPE ("aas"));
		for (_tmp14_ = 0; _tmp14_ < value_length2; _tmp14_++) {
			GVariantBuilder _tmp15_;
			gint _tmp16_;
			g_variant_builder_init (&_tmp15_, G_VARIANT_TYPE ("as"));
			for (_tmp16_ = 0; _tmp16_ < value_length3; _tmp16_++) {
				g_variant_builder_add_value (&_tmp15_, g_variant_new_string (*_tmp10_));
				_tmp10_++;
			}
			g_variant_builder_add_value (&_tmp13_, g_variant_builder_end (&_tmp15_));
		}
		g_variant_builder_add_value (&_tmp11_, g_variant_builder_end (&_tmp13_));
	}
	return g_variant_ref_sink (g_variant_builder_end (&_tmp11_));
}

static gchar**
_variant_get4 (GVariant* value,
               gint* result_length1,
               gint* result_length2,
               gint* result_length3)
{
	gchar** _tmp0_;
	gint _tmp0__length;
	gint _tmp0__size;
	gint _tmp0__length1;
	GVariantIter _tmp1_;
	GVariant* _tmp2_;
	_tmp0_ = g_new (gchar*, 5);
	_tmp0__length = 0;
	_tmp0__size = 4;
	_tmp0__length1 = 0;
	g_variant_iter_init (&_tmp1_, value);
	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
		gint _tmp0__length2;
		GVariantIter _tmp3_;
		GVariant* _tmp4_;
		_tmp0__length2 = 0;
		g_variant_iter_init (&_tmp3_, _tmp2_);
		for (; (_tmp4_ = g_variant_iter_next_value (&_tmp3_)) != NULL; _tmp0__length2++) {
			gint _tmp0__length3;
			GVariantIter _tmp5_;
			GVariant* _tmp6_;
			_tmp0__length3 = 0;
			g_variant_iter_init (&_tmp5_, _tmp4_);
			for (; (_tmp6_ = g_variant_iter_next_value (&_tmp5_)) != NULL; _tmp0__length3++) {
				if (_tmp0__size == _tmp0__length) {
					_tmp0__size = 2 * _tmp0__size;
					_tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
				}
				_tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp6_, NULL);
				g_variant_unref (_tmp6_);
			}
			*result_length3 = _tmp0__length3;
			g_variant_unref (_tmp4_);
		}
		*result_length2 = _tmp0__length2;
		g_variant_unref (_tmp2_);
	}
	*result_length1 = _tmp0__length1;
	_tmp0_[_tmp0__length] = NULL;
	return _tmp0_;
}

void
string_array_3d_conversion (void)
{
	GVariant* v = NULL;
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	gint _tmp9__length2;
	gint _tmp9__length3;
	GVariant* _tmp17_;
	GVariant* _tmp18_;
	gchar** sa = NULL;
	gchar** _tmp19_ = NULL;
	gint _tmp19__length1 = 0;
	gint _tmp19__length2 = 0;
	gint _tmp19__length3 = 0;
	gint sa_length1;
	gint sa_length2;
	gint sa_length3;
	gint _tmp20_;
	gint _tmp21_;
	gint _tmp22_;
	const gchar* _tmp23_;
	const gchar* _tmp24_;
	const gchar* _tmp25_;
	const gchar* _tmp26_;
	_tmp0_ = g_strdup ("foo");
	_tmp1_ = g_strdup ("bar");
	_tmp2_ = g_strdup ("baz");
	_tmp3_ = g_strdup ("man");
	_tmp4_ = g_strdup ("foo2");
	_tmp5_ = g_strdup ("bar2");
	_tmp6_ = g_strdup ("baz2");
	_tmp7_ = g_strdup ("man2");
	_tmp8_ = g_new0 (gchar*, ((2 * 2) * 2) + 1);
	_tmp8_[0] = _tmp0_;
	_tmp8_[1] = _tmp1_;
	_tmp8_[2] = _tmp2_;
	_tmp8_[3] = _tmp3_;
	_tmp8_[4] = _tmp4_;
	_tmp8_[5] = _tmp5_;
	_tmp8_[6] = _tmp6_;
	_tmp8_[7] = _tmp7_;
	_tmp9_ = _tmp8_;
	_tmp9__length1 = 2;
	_tmp9__length2 = 2;
	_tmp9__length3 = 2;
	_tmp17_ = _variant_new4 (_tmp9_, 2, 2, 2);
	_tmp18_ = _tmp17_;
	_tmp9_ = (_vala_array_free (_tmp9_, (_tmp9__length1 * _tmp9__length2) * _tmp9__length3, (GDestroyNotify) g_free), NULL);
	v = _tmp18_;
	_tmp19_ = _variant_get4 (v, &_tmp19__length1, &_tmp19__length2, &_tmp19__length3);
	sa = _tmp19_;
	sa_length1 = _tmp19__length1;
	sa_length2 = _tmp19__length2;
	sa_length3 = _tmp19__length3;
	_tmp20_ = sa_length1;
	_vala_assert (_tmp20_ == 2, "sa.length[0] == 2");
	_tmp21_ = sa_length2;
	_vala_assert (_tmp21_ == 2, "sa.length[1] == 2");
	_tmp22_ = sa_length3;
	_vala_assert (_tmp22_ == 2, "sa.length[2] == 2");
	_tmp23_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 0];
	_vala_assert (g_strcmp0 (_tmp23_, "baz") == 0, "sa[0,1,0] == \"baz\"");
	_tmp24_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 1];
	_vala_assert (g_strcmp0 (_tmp24_, "man") == 0, "sa[0,1,1] == \"man\"");
	_tmp25_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 0];
	_vala_assert (g_strcmp0 (_tmp25_, "baz2") == 0, "sa[1,1,0] == \"baz2\"");
	_tmp26_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 1];
	_vala_assert (g_strcmp0 (_tmp26_, "man2") == 0, "sa[1,1,1] == \"man2\"");
	sa = (_vala_array_free (sa, (sa_length1 * sa_length2) * sa_length3, (GDestroyNotify) g_free), NULL);
	_g_variant_unref0 (v);
}

static GVariant*
_variant_new5 (gdouble value)
{
	return g_variant_ref_sink (g_variant_new_double (value));
}

static gdouble
_variant_get5 (GVariant* value)
{
	return g_variant_get_double (value);
}

void
double_conversion (void)
{
	GVariant* v = NULL;
	GVariant* _tmp0_;
	gdouble d = 0.0;
	gdouble _tmp1_;
	_tmp0_ = _variant_new5 (42.23);
	v = _tmp0_;
	_tmp1_ = _variant_get5 (v);
	d = _tmp1_;
	_vala_assert (d == 42.23, "d == 42.23");
	_g_variant_unref0 (v);
}

static GVariant*
_variant_new6 (gdouble* value,
               gint value_length1)
{
	gdouble* _tmp2_;
	GVariantBuilder _tmp3_;
	gint _tmp4_;
	_tmp2_ = value;
	g_variant_builder_init (&_tmp3_, G_VARIANT_TYPE ("ad"));
	for (_tmp4_ = 0; _tmp4_ < value_length1; _tmp4_++) {
		g_variant_builder_add_value (&_tmp3_, g_variant_new_double (*_tmp2_));
		_tmp2_++;
	}
	return g_variant_ref_sink (g_variant_builder_end (&_tmp3_));
}

static gdouble*
_variant_get6 (GVariant* value,
               gint* result_length1)
{
	gdouble* _tmp0_;
	gint _tmp0__length;
	gint _tmp0__size;
	gint _tmp0__length1;
	GVariantIter _tmp1_;
	GVariant* _tmp2_;
	_tmp0_ = g_new (gdouble, 5);
	_tmp0__length = 0;
	_tmp0__size = 4;
	_tmp0__length1 = 0;
	g_variant_iter_init (&_tmp1_, value);
	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
		if (_tmp0__size == _tmp0__length) {
			_tmp0__size = 2 * _tmp0__size;
			_tmp0_ = g_renew (gdouble, _tmp0_, _tmp0__size + 1);
		}
		_tmp0_[_tmp0__length++] = g_variant_get_double (_tmp2_);
		g_variant_unref (_tmp2_);
	}
	*result_length1 = _tmp0__length1;
	return _tmp0_;
}

void
double_array_conversion (void)
{
	GVariant* v = NULL;
	gdouble* _tmp0_;
	gdouble* _tmp1_;
	gint _tmp1__length1;
	GVariant* _tmp5_;
	GVariant* _tmp6_;
	gdouble* da = NULL;
	gdouble* _tmp7_ = NULL;
	gint _tmp7__length1 = 0;
	gint da_length1;
	gint _da_size_;
	gdouble _tmp8_;
	_tmp0_ = g_new0 (gdouble, 2);
	_tmp0_[0] = 42.23;
	_tmp0_[1] = 47.11;
	_tmp1_ = _tmp0_;
	_tmp1__length1 = 2;
	_tmp5_ = _variant_new6 (_tmp1_, 2);
	_tmp6_ = _tmp5_;
	_tmp1_ = (g_free (_tmp1_), NULL);
	v = _tmp6_;
	_tmp7_ = _variant_get6 (v, &_tmp7__length1);
	da = _tmp7_;
	da_length1 = _tmp7__length1;
	_da_size_ = da_length1;
	_vala_assert (da_length1 == 2, "da.length == 2");
	_tmp8_ = da[1];
	_vala_assert (_tmp8_ == 47.11, "da[1] == 47.11");
	da = (g_free (da), NULL);
	_g_variant_unref0 (v);
}

static GVariant*
_variant_new7 (gdouble* value,
               gint value_length1,
               gint value_length2)
{
	gdouble* _tmp2_;
	GVariantBuilder _tmp3_;
	gint _tmp4_;
	_tmp2_ = value;
	g_variant_builder_init (&_tmp3_, G_VARIANT_TYPE ("aad"));
	for (_tmp4_ = 0; _tmp4_ < value_length1; _tmp4_++) {
		GVariantBuilder _tmp5_;
		gint _tmp6_;
		g_variant_builder_init (&_tmp5_, G_VARIANT_TYPE ("ad"));
		for (_tmp6_ = 0; _tmp6_ < value_length2; _tmp6_++) {
			g_variant_builder_add_value (&_tmp5_, g_variant_new_double (*_tmp2_));
			_tmp2_++;
		}
		g_variant_builder_add_value (&_tmp3_, g_variant_builder_end (&_tmp5_));
	}
	return g_variant_ref_sink (g_variant_builder_end (&_tmp3_));
}

static gdouble*
_variant_get7 (GVariant* value,
               gint* result_length1,
               gint* result_length2)
{
	gdouble* _tmp0_;
	gint _tmp0__length;
	gint _tmp0__size;
	gint _tmp0__length1;
	GVariantIter _tmp1_;
	GVariant* _tmp2_;
	_tmp0_ = g_new (gdouble, 5);
	_tmp0__length = 0;
	_tmp0__size = 4;
	_tmp0__length1 = 0;
	g_variant_iter_init (&_tmp1_, value);
	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
		gint _tmp0__length2;
		GVariantIter _tmp3_;
		GVariant* _tmp4_;
		_tmp0__length2 = 0;
		g_variant_iter_init (&_tmp3_, _tmp2_);
		for (; (_tmp4_ = g_variant_iter_next_value (&_tmp3_)) != NULL; _tmp0__length2++) {
			if (_tmp0__size == _tmp0__length) {
				_tmp0__size = 2 * _tmp0__size;
				_tmp0_ = g_renew (gdouble, _tmp0_, _tmp0__size + 1);
			}
			_tmp0_[_tmp0__length++] = g_variant_get_double (_tmp4_);
			g_variant_unref (_tmp4_);
		}
		*result_length2 = _tmp0__length2;
		g_variant_unref (_tmp2_);
	}
	*result_length1 = _tmp0__length1;
	return _tmp0_;
}

void
double_array_2d_conversion (void)
{
	GVariant* v = NULL;
	gdouble* _tmp0_;
	gdouble* _tmp1_;
	gint _tmp1__length1;
	gint _tmp1__length2;
	GVariant* _tmp7_;
	GVariant* _tmp8_;
	gdouble* da = NULL;
	gdouble* _tmp9_ = NULL;
	gint _tmp9__length1 = 0;
	gint _tmp9__length2 = 0;
	gint da_length1;
	gint da_length2;
	gint _tmp10_;
	gint _tmp11_;
	gdouble _tmp12_;
	_tmp0_ = g_new0 (gdouble, 2 * 2);
	_tmp0_[0] = 42.23;
	_tmp0_[1] = 11.47;
	_tmp0_[2] = 47.11;
	_tmp0_[3] = 23.42;
	_tmp1_ = _tmp0_;
	_tmp1__length1 = 2;
	_tmp1__length2 = 2;
	_tmp7_ = _variant_new7 (_tmp1_, 2, 2);
	_tmp8_ = _tmp7_;
	_tmp1_ = (g_free (_tmp1_), NULL);
	v = _tmp8_;
	_tmp9_ = _variant_get7 (v, &_tmp9__length1, &_tmp9__length2);
	da = _tmp9_;
	da_length1 = _tmp9__length1;
	da_length2 = _tmp9__length2;
	_tmp10_ = da_length1;
	_vala_assert (_tmp10_ == 2, "da.length[0] == 2");
	_tmp11_ = da_length2;
	_vala_assert (_tmp11_ == 2, "da.length[1] == 2");
	_tmp12_ = da[(1 * da_length2) + 1];
	_vala_assert (_tmp12_ == 23.42, "da[1,1] == 23.42");
	da = (g_free (da), NULL);
	_g_variant_unref0 (v);
}

void
foo_copy (const Foo* self,
          Foo* dest)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	_tmp0_ = (*self).s;
	_tmp1_ = g_strdup (_tmp0_);
	_g_free0 ((*dest).s);
	(*dest).s = _tmp1_;
	(*dest).u64 = (*self).u64;
	(*dest).b = (*self).b;
}

void
foo_destroy (Foo* self)
{
	_g_free0 ((*self).s);
}

Foo*
foo_dup (const Foo* self)
{
	Foo* dup;
	dup = g_new0 (Foo, 1);
	foo_copy (self, dup);
	return dup;
}

void
foo_free (Foo* self)
{
	foo_destroy (self);
	g_free (self);
}

static GType
foo_get_type_once (void)
{
	GType foo_type_id;
	foo_type_id = g_boxed_type_register_static ("Foo", (GBoxedCopyFunc) foo_dup, (GBoxedFreeFunc) foo_free);
	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;
}

static GVariant*
_variant_new8 (Foo value)
{
	GVariantBuilder _tmp3_;
	g_variant_builder_init (&_tmp3_, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_tmp3_, g_variant_new_string (value.s));
	g_variant_builder_add_value (&_tmp3_, g_variant_new_uint64 (value.u64));
	g_variant_builder_add_value (&_tmp3_, g_variant_new_boolean (value.b));
	return g_variant_ref_sink (g_variant_builder_end (&_tmp3_));
}

static void
_variant_get8 (GVariant* value,
               Foo * result)
{
	Foo _tmp0_;
	GVariantIter _tmp1_;
	GVariant* _tmp2_;
	GVariant* _tmp3_;
	GVariant* _tmp4_;
	g_variant_iter_init (&_tmp1_, value);
	_tmp2_ = g_variant_iter_next_value (&_tmp1_);
	_tmp0_.s = g_variant_dup_string (_tmp2_, NULL);
	g_variant_unref (_tmp2_);
	_tmp3_ = g_variant_iter_next_value (&_tmp1_);
	_tmp0_.u64 = g_variant_get_uint64 (_tmp3_);
	g_variant_unref (_tmp3_);
	_tmp4_ = g_variant_iter_next_value (&_tmp1_);
	_tmp0_.b = g_variant_get_boolean (_tmp4_);
	g_variant_unref (_tmp4_);
	*result = _tmp0_;
}

void
struct_conversion (void)
{
	Foo s = {0};
	gchar* _tmp0_;
	Foo _tmp1_ = {0};
	GVariant* v = NULL;
	Foo _tmp2_;
	GVariant* _tmp4_;
	Foo st = {0};
	Foo _tmp5_;
	Foo _tmp6_;
	const gchar* _tmp7_;
	Foo _tmp8_;
	Foo _tmp9_;
	_tmp0_ = g_strdup ("foo");
	_g_free0 (_tmp1_.s);
	_tmp1_.s = _tmp0_;
	_tmp1_.u64 = G_MAXUINT64;
	_tmp1_.b = TRUE;
	s = _tmp1_;
	_tmp2_ = s;
	_tmp4_ = _variant_new8 (_tmp2_);
	v = _tmp4_;
	_variant_get8 (v, &_tmp5_);
	st = _tmp5_;
	_tmp6_ = st;
	_tmp7_ = _tmp6_.s;
	_vala_assert (g_strcmp0 (_tmp7_, "foo") == 0, "st.s == \"foo\"");
	_tmp8_ = st;
	_vala_assert (_tmp8_.u64 == G_MAXUINT64, "st.u64 == uint64.MAX");
	_tmp9_ = st;
	_vala_assert (_tmp9_.b == TRUE, "st.b == true");
	foo_destroy (&st);
	_g_variant_unref0 (v);
	foo_destroy (&s);
}

static void
_vala_main (void)
{
	string_conversion ();
	string_array_conversion ();
	double_conversion ();
	double_array_conversion ();
	struct_conversion ();
	string_array_2d_conversion ();
	double_array_2d_conversion ();
	string_array_3d_conversion ();
}

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

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);
}