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

#include <glib-object.h>
#include <glib.h>
#include <string.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 TYPE_FOO (foo_get_type ())
typedef struct _Foo Foo;
#define _foo_free0(var) ((var == NULL) ? NULL : (var = (foo_free (var), NULL)))
#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

struct _Foo {
	gint64 foo;
	gint64 bar;
};

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 bar (guint8* a,
          gint a_length1);
static void _vala_main (void);
static guint8* _vala_array_dup1 (guint8* self,
                          gssize length);
static guint8* _vala_array_dup2 (guint8* self,
                          gssize length);
static guint8* _vala_array_dup3 (guint8* self,
                          gssize length);
static guint8* _vala_array_dup4 (guint8* self,
                          gssize length);
static guint8* _vala_array_dup5 (guint8* self,
                          gssize length);
static inline gpointer _vala_memdup2 (gconstpointer mem,
                        gsize byte_size);

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

void
foo_free (Foo* 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;
}

void
bar (guint8* a,
     gint a_length1)
{
	Foo* f = NULL;
	gint f_length1;
	gint _f_size_;
	Foo _tmp0_;
	Foo _tmp1_;
	f = (Foo*) a;
	f_length1 = (a_length1 * sizeof (guint8)) / sizeof (Foo);
	_f_size_ = f_length1;
	_tmp0_ = f[0];
	_vala_assert (_tmp0_.foo == (2LL << 62), "f[0].foo == 2LL << 62");
	_tmp1_ = f[0];
	_vala_assert (_tmp1_.bar == (2LL << 31), "f[0].bar == 2LL << 31");
}

static gpointer
_foo_dup0 (gpointer self)
{
	return self ? foo_dup (self) : NULL;
}

static guint8*
_vala_array_dup1 (guint8* self,
                  gssize length)
{
	if (length > 0) {
		return _vala_memdup2 (self, length * sizeof (guint8));
	}
	return NULL;
}

static guint8*
_vala_array_dup2 (guint8* self,
                  gssize length)
{
	if (length > 0) {
		return _vala_memdup2 (self, length * sizeof (guint8));
	}
	return NULL;
}

static guint8*
_vala_array_dup3 (guint8* self,
                  gssize length)
{
	if (length > 0) {
		return _vala_memdup2 (self, length * sizeof (guint8));
	}
	return NULL;
}

static guint8*
_vala_array_dup4 (guint8* self,
                  gssize length)
{
	if (length > 0) {
		return _vala_memdup2 (self, length * sizeof (guint8));
	}
	return NULL;
}

static guint8*
_vala_array_dup5 (guint8* self,
                  gssize length)
{
	if (length > 0) {
		return _vala_memdup2 (self, length * sizeof (guint8));
	}
	return NULL;
}

static void
_vala_main (void)
{
	guint8* tu = NULL;
	gint tu_length1 = 0;
	gint _tu_size_ = 0;
	guint8* to = NULL;
	gint to_length1 = 0;
	gint _to_size_ = 0;
	Foo fstack = {0};
	Foo _tmp0_ = {0};
	Foo* fheap = NULL;
	Foo _tmp1_ = {0};
	Foo* _tmp2_;
	guint8* _tmp3_;
	gint _tmp3__length1;
	guint8* _tmp4_;
	gint _tmp4__length1;
	guint8* _tmp5_;
	gint _tmp5__length1;
	guint8* _tmp6_;
	gint _tmp6__length1;
	guint8* _tmp7_;
	gint _tmp7__length1;
	Foo _tmp8_;
	Foo _tmp9_;
	guint8* _tmp10_;
	gint _tmp10__length1;
	guint8* _tmp11_;
	gint _tmp11__length1;
	Foo _tmp12_;
	guint8* _tmp13_;
	gint _tmp13__length1;
	guint8* _tmp14_;
	gint _tmp14__length1;
	guint8* _tmp15_;
	gint _tmp15__length1;
	guint8* _tmp16_;
	gint _tmp16__length1;
	guint8* _tmp17_;
	gint _tmp17__length1;
	guint8* _tmp18_;
	gint _tmp18__length1;
	guint8* _tmp19_;
	gint _tmp19__length1;
	guint8* _tmp20_;
	gint _tmp20__length1;
	gint32 i32 = 0;
	guint8* _tmp21_;
	gint _tmp21__length1;
	guint8* _tmp22_;
	gint _tmp22__length1;
	guint8* _tmp23_;
	gint _tmp23__length1;
	guint8* _tmp24_;
	gint _tmp24__length1;
	guint64 u64 = 0ULL;
	guint8* _tmp25_;
	gint _tmp25__length1;
	guint8* _tmp26_;
	gint _tmp26__length1;
	guint8* _tmp27_;
	gint _tmp27__length1;
	guint8* _tmp28_;
	gint _tmp28__length1;
	_tmp0_.foo = 2LL << 62;
	_tmp0_.bar = 2LL << 31;
	fstack = _tmp0_;
	_tmp1_.foo = 2LL << 62;
	_tmp1_.bar = 2LL << 31;
	_tmp2_ = _foo_dup0 (&_tmp1_);
	fheap = _tmp2_;
	bar ((guint8*) (&fstack), (gint) (sizeof (Foo) / sizeof (guint8)));
	tu = (guint8*) (&fstack);
	tu_length1 = sizeof (Foo) / sizeof (guint8);
	_tu_size_ = tu_length1;
	_tmp3_ = tu;
	_tmp3__length1 = tu_length1;
	_vala_assert (_tmp3__length1 == 16, "tu.length == 16");
	_tmp4_ = tu;
	_tmp4__length1 = tu_length1;
	bar (_tmp4_, (gint) _tmp4__length1);
	_tmp5_ = _vala_array_dup1 ((guint8*) (&fstack), sizeof (Foo) / sizeof (guint8));
	_tmp5__length1 = sizeof (Foo) / sizeof (guint8);
	to = (g_free (to), NULL);
	to = _tmp5_;
	to_length1 = _tmp5__length1;
	_to_size_ = to_length1;
	_tmp6_ = to;
	_tmp6__length1 = to_length1;
	_vala_assert (_tmp6__length1 == 16, "to.length == 16");
	_tmp7_ = to;
	_tmp7__length1 = to_length1;
	bar (_tmp7_, (gint) _tmp7__length1);
	_tmp8_ = fstack;
	bar ((guint8*) (&_tmp8_), (gint) (sizeof (Foo) / sizeof (guint8)));
	_tmp9_ = fstack;
	tu = (guint8*) (&_tmp9_);
	tu_length1 = sizeof (Foo) / sizeof (guint8);
	_tu_size_ = tu_length1;
	_tmp10_ = tu;
	_tmp10__length1 = tu_length1;
	_vala_assert (_tmp10__length1 == 16, "tu.length == 16");
	_tmp11_ = tu;
	_tmp11__length1 = tu_length1;
	bar (_tmp11_, (gint) _tmp11__length1);
	_tmp12_ = fstack;
	_tmp13_ = _vala_array_dup2 ((guint8*) (&_tmp12_), sizeof (Foo) / sizeof (guint8));
	_tmp13__length1 = sizeof (Foo) / sizeof (guint8);
	to = (g_free (to), NULL);
	to = _tmp13_;
	to_length1 = _tmp13__length1;
	_to_size_ = to_length1;
	_tmp14_ = to;
	_tmp14__length1 = to_length1;
	_vala_assert (_tmp14__length1 == 16, "to.length == 16");
	_tmp15_ = to;
	_tmp15__length1 = to_length1;
	bar (_tmp15_, (gint) _tmp15__length1);
	bar ((guint8*) fheap, (gint) (sizeof (Foo) / sizeof (guint8)));
	tu = (guint8*) fheap;
	tu_length1 = sizeof (Foo) / sizeof (guint8);
	_tu_size_ = tu_length1;
	_tmp16_ = tu;
	_tmp16__length1 = tu_length1;
	_vala_assert (_tmp16__length1 == 16, "tu.length == 16");
	_tmp17_ = tu;
	_tmp17__length1 = tu_length1;
	bar (_tmp17_, (gint) _tmp17__length1);
	_tmp18_ = (((guint8*) fheap) != NULL) ? _vala_array_dup3 ((guint8*) fheap, sizeof (Foo) / sizeof (guint8)) : ((guint8*) fheap);
	_tmp18__length1 = sizeof (Foo) / sizeof (guint8);
	to = (g_free (to), NULL);
	to = _tmp18_;
	to_length1 = _tmp18__length1;
	_to_size_ = to_length1;
	_tmp19_ = to;
	_tmp19__length1 = to_length1;
	_vala_assert (_tmp19__length1 == 16, "to.length == 16");
	_tmp20_ = to;
	_tmp20__length1 = to_length1;
	bar (_tmp20_, (gint) _tmp20__length1);
	i32 = (gint32) (2 << 28);
	tu = (guint8*) (&i32);
	tu_length1 = sizeof (gint32) / sizeof (guint8);
	_tu_size_ = tu_length1;
	_tmp21_ = tu;
	_tmp21__length1 = tu_length1;
	_vala_assert (_tmp21__length1 == 4, "tu.length == 4");
	tu = (guint8*) (&i32);
	tu_length1 = sizeof (gint32) / sizeof (guint8);
	_tu_size_ = tu_length1;
	_tmp22_ = tu;
	_tmp22__length1 = tu_length1;
	_vala_assert (_tmp22__length1 == 4, "tu.length == 4");
	_tmp23_ = _vala_array_dup4 ((guint8*) (&i32), sizeof (gint32) / sizeof (guint8));
	_tmp23__length1 = sizeof (gint32) / sizeof (guint8);
	to = (g_free (to), NULL);
	to = _tmp23_;
	to_length1 = _tmp23__length1;
	_to_size_ = to_length1;
	_tmp24_ = to;
	_tmp24__length1 = to_length1;
	_vala_assert (_tmp24__length1 == 4, "to.length == 4");
	u64 = (guint64) (2UL << 30);
	tu = (guint8*) (&u64);
	tu_length1 = sizeof (guint64) / sizeof (guint8);
	_tu_size_ = tu_length1;
	_tmp25_ = tu;
	_tmp25__length1 = tu_length1;
	_vala_assert (_tmp25__length1 == 8, "tu.length == 8");
	tu = (guint8*) (&u64);
	tu_length1 = sizeof (guint64) / sizeof (guint8);
	_tu_size_ = tu_length1;
	_tmp26_ = tu;
	_tmp26__length1 = tu_length1;
	_vala_assert (_tmp26__length1 == 8, "tu.length == 8");
	_tmp27_ = _vala_array_dup5 ((guint8*) (&u64), sizeof (guint64) / sizeof (guint8));
	_tmp27__length1 = sizeof (guint64) / sizeof (guint8);
	to = (g_free (to), NULL);
	to = _tmp27_;
	to_length1 = _tmp27__length1;
	_to_size_ = to_length1;
	_tmp28_ = to;
	_tmp28__length1 = to_length1;
	_vala_assert (_tmp28__length1 == 8, "to.length == 8");
	_foo_free0 (fheap);
	to = (g_free (to), NULL);
}

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

static inline gpointer
_vala_memdup2 (gconstpointer mem,
               gsize byte_size)
{
	gpointer new_mem;
	if (mem && byte_size != 0) {
		new_mem = g_malloc (byte_size);
		memcpy (new_mem, mem, byte_size);
	} else {
		new_mem = NULL;
	}
	return new_mem;
}