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

#include <glib.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#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 _g_free0(var) (var = (g_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);

VALA_EXTERN gint static_negative_int;
gint static_negative_int = -1;

VALA_EXTERN void test_int (void);
static void _vala_main (void);

static gboolean
int_try_parse (const gchar* str,
               gint* _result_,
               const gchar** unparsed,
               guint _base)
{
	gint _vala__result_ = 0;
	const gchar* _vala_unparsed = NULL;
	gchar* endptr = NULL;
	glong long_result = 0L;
	gchar* _tmp0_ = NULL;
	glong _tmp1_;
	gchar* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	glong _tmp6_;
	gboolean result;
	g_return_val_if_fail (str != NULL, FALSE);
	errno = 0;
	_tmp1_ = strtol (str, &_tmp0_, (gint) _base);
	endptr = _tmp0_;
	long_result = _tmp1_;
	_tmp2_ = endptr;
	_tmp3_ = strlen (str);
	_tmp4_ = _tmp3_;
	if (_tmp2_ == (((gchar*) str) + _tmp4_)) {
		_vala_unparsed = "";
	} else {
		gchar* _tmp5_;
		_tmp5_ = endptr;
		_vala_unparsed = (const gchar*) _tmp5_;
	}
	_tmp6_ = long_result;
	if ((((glong) G_MININT) <= _tmp6_) && (_tmp6_ <= ((glong) G_MAXINT))) {
		gboolean _tmp7_ = FALSE;
		gboolean _tmp8_ = FALSE;
		_vala__result_ = (gint) long_result;
		if (errno != ERANGE) {
			_tmp8_ = errno != EINVAL;
		} else {
			_tmp8_ = FALSE;
		}
		if (_tmp8_) {
			const gchar* _tmp9_;
			gchar* _tmp10_;
			_tmp9_ = _vala_unparsed;
			_tmp10_ = endptr;
			_tmp7_ = _tmp9_ != _tmp10_;
		} else {
			_tmp7_ = FALSE;
		}
		result = _tmp7_;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	} else {
		_vala__result_ = G_MAXINT;
		result = FALSE;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	}
}

static gboolean
long_try_parse (const gchar* str,
                glong* _result_,
                const gchar** unparsed,
                guint _base)
{
	glong _vala__result_ = 0L;
	const gchar* _vala_unparsed = NULL;
	gchar* endptr = NULL;
	gchar* _tmp0_ = NULL;
	glong _tmp1_;
	gchar* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	gboolean result;
	g_return_val_if_fail (str != NULL, FALSE);
	errno = 0;
	_tmp1_ = strtol (str, &_tmp0_, (gint) _base);
	endptr = _tmp0_;
	_vala__result_ = _tmp1_;
	_tmp2_ = endptr;
	_tmp3_ = strlen (str);
	_tmp4_ = _tmp3_;
	if (_tmp2_ == (((gchar*) str) + _tmp4_)) {
		gboolean _tmp5_ = FALSE;
		_vala_unparsed = "";
		if (errno != ERANGE) {
			_tmp5_ = errno != EINVAL;
		} else {
			_tmp5_ = FALSE;
		}
		result = _tmp5_;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	} else {
		gchar* _tmp6_;
		_tmp6_ = endptr;
		_vala_unparsed = (const gchar*) _tmp6_;
		result = FALSE;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	}
}

static gboolean
uint_try_parse (const gchar* str,
                guint* _result_,
                const gchar** unparsed,
                guint _base)
{
	guint _vala__result_ = 0U;
	const gchar* _vala_unparsed = NULL;
	gchar* endptr = NULL;
	gulong ulong_result = 0UL;
	gchar* _tmp0_ = NULL;
	gulong _tmp1_;
	gchar* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	gulong _tmp6_;
	gboolean result;
	g_return_val_if_fail (str != NULL, FALSE);
	errno = 0;
	_tmp1_ = strtoul (str, &_tmp0_, (gint) _base);
	endptr = _tmp0_;
	ulong_result = _tmp1_;
	_tmp2_ = endptr;
	_tmp3_ = strlen (str);
	_tmp4_ = _tmp3_;
	if (_tmp2_ == (((gchar*) str) + _tmp4_)) {
		_vala_unparsed = "";
	} else {
		gchar* _tmp5_;
		_tmp5_ = endptr;
		_vala_unparsed = (const gchar*) _tmp5_;
	}
	_tmp6_ = ulong_result;
	if ((((gulong) 0) <= _tmp6_) && (_tmp6_ <= ((gulong) G_MAXUINT))) {
		gboolean _tmp7_ = FALSE;
		gboolean _tmp8_ = FALSE;
		_vala__result_ = (guint) ulong_result;
		if (errno != ERANGE) {
			_tmp8_ = errno != EINVAL;
		} else {
			_tmp8_ = FALSE;
		}
		if (_tmp8_) {
			const gchar* _tmp9_;
			gchar* _tmp10_;
			_tmp9_ = _vala_unparsed;
			_tmp10_ = endptr;
			_tmp7_ = _tmp9_ != _tmp10_;
		} else {
			_tmp7_ = FALSE;
		}
		result = _tmp7_;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	} else {
		_vala__result_ = G_MAXUINT;
		result = FALSE;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	}
}

static gboolean
ulong_try_parse (const gchar* str,
                 gulong* _result_,
                 const gchar** unparsed,
                 guint _base)
{
	gulong _vala__result_ = 0UL;
	const gchar* _vala_unparsed = NULL;
	gchar* endptr = NULL;
	gchar* _tmp0_ = NULL;
	gulong _tmp1_;
	gchar* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	gboolean result;
	g_return_val_if_fail (str != NULL, FALSE);
	errno = 0;
	_tmp1_ = strtoul (str, &_tmp0_, (gint) _base);
	endptr = _tmp0_;
	_vala__result_ = _tmp1_;
	_tmp2_ = endptr;
	_tmp3_ = strlen (str);
	_tmp4_ = _tmp3_;
	if (_tmp2_ == (((gchar*) str) + _tmp4_)) {
		gboolean _tmp5_ = FALSE;
		_vala_unparsed = "";
		if (errno != ERANGE) {
			_tmp5_ = errno != EINVAL;
		} else {
			_tmp5_ = FALSE;
		}
		result = _tmp5_;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	} else {
		gchar* _tmp6_;
		_tmp6_ = endptr;
		_vala_unparsed = (const gchar*) _tmp6_;
		result = FALSE;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	}
}

static gboolean
int64_try_parse (const gchar* str,
                 gint64* _result_,
                 const gchar** unparsed,
                 guint _base)
{
	gint64 _vala__result_ = 0LL;
	const gchar* _vala_unparsed = NULL;
	gchar* endptr = NULL;
	gchar* _tmp0_ = NULL;
	gint64 _tmp1_;
	gchar* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	gboolean result;
	g_return_val_if_fail (str != NULL, FALSE);
	errno = 0;
	_tmp1_ = g_ascii_strtoll (str, &_tmp0_, _base);
	endptr = _tmp0_;
	_vala__result_ = _tmp1_;
	_tmp2_ = endptr;
	_tmp3_ = strlen (str);
	_tmp4_ = _tmp3_;
	if (_tmp2_ == (((gchar*) str) + _tmp4_)) {
		gboolean _tmp5_ = FALSE;
		_vala_unparsed = "";
		if (errno != ERANGE) {
			_tmp5_ = errno != EINVAL;
		} else {
			_tmp5_ = FALSE;
		}
		result = _tmp5_;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	} else {
		gchar* _tmp6_;
		_tmp6_ = endptr;
		_vala_unparsed = (const gchar*) _tmp6_;
		result = FALSE;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	}
}

static gboolean
uint64_try_parse (const gchar* str,
                  guint64* _result_,
                  const gchar** unparsed,
                  guint _base)
{
	guint64 _vala__result_ = 0ULL;
	const gchar* _vala_unparsed = NULL;
	gchar* endptr = NULL;
	gchar* _tmp0_ = NULL;
	guint64 _tmp1_;
	gchar* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	gboolean result;
	g_return_val_if_fail (str != NULL, FALSE);
	errno = 0;
	_tmp1_ = g_ascii_strtoull (str, &_tmp0_, _base);
	endptr = _tmp0_;
	_vala__result_ = _tmp1_;
	_tmp2_ = endptr;
	_tmp3_ = strlen (str);
	_tmp4_ = _tmp3_;
	if (_tmp2_ == (((gchar*) str) + _tmp4_)) {
		gboolean _tmp5_ = FALSE;
		_vala_unparsed = "";
		if (errno != ERANGE) {
			_tmp5_ = errno != EINVAL;
		} else {
			_tmp5_ = FALSE;
		}
		result = _tmp5_;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	} else {
		gchar* _tmp6_;
		_tmp6_ = endptr;
		_vala_unparsed = (const gchar*) _tmp6_;
		result = FALSE;
		if (_result_) {
			*_result_ = _vala__result_;
		}
		if (unparsed) {
			*unparsed = _vala_unparsed;
		}
		return result;
	}
}

void
test_int (void)
{
	gint i = 0;
	gint j = 0;
	gchar* s = NULL;
	gchar* _tmp0_;
	const gchar* _tmp1_;
	const gchar* unparsed = NULL;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gint _tmp4_ = 0;
	const gchar* _tmp5_ = NULL;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	const gchar* _tmp8_;
	gint _tmp9_ = 0;
	gboolean _tmp10_;
	gchar* _tmp11_;
	glong l = 0L;
	const gchar* _tmp12_;
	glong _tmp13_ = 0L;
	const gchar* _tmp14_ = NULL;
	const gchar* _tmp15_;
	gchar* _tmp16_;
	const gchar* _tmp17_;
	glong _tmp18_ = 0L;
	gboolean _tmp19_;
	gchar* _tmp20_;
	guint u = 0U;
	const gchar* _tmp21_;
	guint _tmp22_ = 0U;
	const gchar* _tmp23_ = NULL;
	const gchar* _tmp24_;
	gchar* _tmp25_;
	const gchar* _tmp26_;
	guint _tmp27_ = 0U;
	gboolean _tmp28_;
	gchar* _tmp29_;
	gulong ul = 0UL;
	const gchar* _tmp30_;
	gulong _tmp31_ = 0UL;
	const gchar* _tmp32_ = NULL;
	const gchar* _tmp33_;
	gchar* _tmp34_;
	const gchar* _tmp35_;
	gulong _tmp36_ = 0UL;
	gboolean _tmp37_;
	gint64 i64 = 0LL;
	gint64 _tmp38_ = 0LL;
	const gchar* _tmp39_ = NULL;
	const gchar* _tmp40_;
	gint64 _tmp41_ = 0LL;
	guint64 ui64 = 0ULL;
	guint64 _tmp42_ = 0ULL;
	const gchar* _tmp43_ = NULL;
	const gchar* _tmp44_;
	guint64 _tmp45_ = 0ULL;
	i = 42;
	_vala_assert (i == 42, "i == 42");
	i = 23;
	_vala_assert (i == 23, "i == 23");
	j = i;
	_vala_assert (j == 23, "j == 23");
	i = 42 + 23;
	_vala_assert (i == 65, "i == 65");
	i += 7;
	_vala_assert (i == 72, "i == 72");
	i = 42 - 23;
	_vala_assert (i == 19, "i == 19");
	i -= 7;
	_vala_assert (i == 12, "i == 12");
	i = 42 * 23;
	_vala_assert (i == 966, "i == 966");
	i *= 7;
	_vala_assert (i == 6762, "i == 6762");
	i = 42 / 23;
	_vala_assert (i == 1, "i == 1");
	i /= 1;
	_vala_assert (i == 1, "i == 1");
	i = 42 % 23;
	_vala_assert (i == 19, "i == 19");
	i %= 7;
	_vala_assert (i == 5, "i == 5");
	i = 42 << 3;
	_vala_assert (i == 336, "i == 336");
	i <<= 7;
	_vala_assert (i == 43008, "i == 43008");
	i = 42 >> 3;
	_vala_assert (i == 5, "i == 5");
	i >>= 2;
	_vala_assert (i == 1, "i == 1");
	i = 42 & 23;
	_vala_assert (i == 2, "i == 2");
	i &= 1;
	_vala_assert (i == 0, "i == 0");
	i = 42 | 23;
	_vala_assert (i == 63, "i == 63");
	i |= 128;
	_vala_assert (i == 191, "i == 191");
	i = 42 ^ 23;
	_vala_assert (i == 61, "i == 61");
	i ^= 23;
	_vala_assert (i == 42, "i == 42");
	i = 42;
	_vala_assert (i == 42, "i == 42");
	_vala_assert (i != 50, "i != 50");
	_vala_assert (i < 50, "i < 50");
	_vala_assert (!(i < 40), "!(i < 40)");
	_vala_assert (i <= 42, "i <= 42");
	_vala_assert (!(i <= 41), "!(i <= 41)");
	_vala_assert (i >= 42, "i >= 42");
	_vala_assert (!(i >= 43), "!(i >= 43)");
	_vala_assert (i > 40, "i > 40");
	_vala_assert (!(i > 50), "!(i > 50)");
	_tmp0_ = g_strdup_printf ("%i", i);
	s = _tmp0_;
	_tmp1_ = s;
	_vala_assert (g_strcmp0 (_tmp1_, "42") == 0, "s == \"42\"");
	_tmp2_ = g_strdup_printf ("%im", G_MININT);
	_g_free0 (s);
	s = _tmp2_;
	_tmp3_ = s;
	int_try_parse (_tmp3_, &_tmp4_, &_tmp5_, (guint) 0);
	i = _tmp4_;
	unparsed = _tmp5_;
	_vala_assert (i == G_MININT, "i == int.MIN");
	_tmp6_ = unparsed;
	_vala_assert (g_strcmp0 (_tmp6_, "m") == 0, "unparsed == \"m\"");
	_tmp7_ = g_strdup_printf ("%um", G_MAXUINT);
	_g_free0 (s);
	s = _tmp7_;
	_tmp8_ = s;
	_tmp10_ = int_try_parse (_tmp8_, &_tmp9_, NULL, (guint) 0);
	i = _tmp9_;
	_vala_assert (!_tmp10_, "!int.try_parse (s, out i)");
	_tmp11_ = g_strdup_printf ("%lim", G_MINLONG);
	_g_free0 (s);
	s = _tmp11_;
	_tmp12_ = s;
	long_try_parse (_tmp12_, &_tmp13_, &_tmp14_, (guint) 0);
	l = _tmp13_;
	unparsed = _tmp14_;
	_vala_assert (l == G_MINLONG, "l == long.MIN");
	_tmp15_ = unparsed;
	_vala_assert (g_strcmp0 (_tmp15_, "m") == 0, "unparsed == \"m\"");
	_tmp16_ = g_strdup_printf ("%lum", G_MAXULONG);
	_g_free0 (s);
	s = _tmp16_;
	_tmp17_ = s;
	_tmp19_ = long_try_parse (_tmp17_, &_tmp18_, NULL, (guint) 0);
	l = _tmp18_;
	_vala_assert (!_tmp19_, "!long.try_parse (s, out l)");
	_tmp20_ = g_strdup_printf ("%um", G_MAXUINT);
	_g_free0 (s);
	s = _tmp20_;
	_tmp21_ = s;
	uint_try_parse (_tmp21_, &_tmp22_, &_tmp23_, (guint) 0);
	u = _tmp22_;
	unparsed = _tmp23_;
	_vala_assert (u == G_MAXUINT, "u == uint.MAX");
	_tmp24_ = unparsed;
	_vala_assert (g_strcmp0 (_tmp24_, "m") == 0, "unparsed == \"m\"");
	_tmp25_ = g_strdup_printf ("%im", G_MININT);
	_g_free0 (s);
	s = _tmp25_;
	_tmp26_ = s;
	_tmp28_ = uint_try_parse (_tmp26_, &_tmp27_, NULL, (guint) 0);
	u = _tmp27_;
	_vala_assert (!_tmp28_, "!uint.try_parse (s, out u)");
	_tmp29_ = g_strdup_printf ("%lum", G_MAXULONG);
	_g_free0 (s);
	s = _tmp29_;
	_tmp30_ = s;
	ulong_try_parse (_tmp30_, &_tmp31_, &_tmp32_, (guint) 0);
	ul = _tmp31_;
	unparsed = _tmp32_;
	_vala_assert (ul == G_MAXULONG, "ul == ulong.MAX");
	_tmp33_ = unparsed;
	_vala_assert (g_strcmp0 (_tmp33_, "m") == 0, "unparsed == \"m\"");
	_tmp34_ = g_strdup_printf ("%lim", G_MINLONG);
	_g_free0 (s);
	s = _tmp34_;
	_tmp35_ = s;
	_tmp37_ = ulong_try_parse (_tmp35_, &_tmp36_, NULL, (guint) 0);
	ul = _tmp36_;
	_vala_assert (!_tmp37_, "!ulong.try_parse (s, out ul)");
	int64_try_parse ("-4711inch", &_tmp38_, &_tmp39_, (guint) 0);
	i64 = _tmp38_;
	unparsed = _tmp39_;
	_vala_assert (i64 == -4711LL, "i64 == -4711LL");
	_tmp40_ = unparsed;
	_vala_assert (g_strcmp0 (_tmp40_, "inch") == 0, "unparsed == \"inch\"");
	int64_try_parse ("-31415km", &_tmp41_, NULL, (guint) 0);
	i64 = _tmp41_;
	_vala_assert (i64 == ((gint64) -31415), "i64 == -31415");
	uint64_try_parse ("4711yards", &_tmp42_, &_tmp43_, (guint) 0);
	ui64 = _tmp42_;
	unparsed = _tmp43_;
	_vala_assert (ui64 == 4711ULL, "ui64 == 4711ULL");
	_tmp44_ = unparsed;
	_vala_assert (g_strcmp0 (_tmp44_, "yards") == 0, "unparsed == \"yards\"");
	uint64_try_parse ("31415yards", &_tmp45_, NULL, (guint) 0);
	ui64 = _tmp45_;
	_vala_assert (ui64 == ((guint64) 31415), "ui64 == 31415");
	i = G_MININT;
	_vala_assert (i == G_MININT, "i == int.MIN");
	_vala_assert (i < G_MAXINT, "i < int.MAX");
	i = G_MAXINT;
	_vala_assert (i == G_MAXINT, "i == int.MAX");
	_vala_assert (i > G_MININT, "i > int.MIN");
	_g_free0 (s);
}

static void
_vala_main (void)
{
	test_int ();
}

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