/* benchmark.c generated by valac 0.21.2.4-6740f, the Vala compiler
 * generated from benchmark.vala, do not modify */

/* benchmark.vala
 *
 * Copyright (C) 2008  Jürg Billeter
 * Copyright (C) 2009  Didier Villevalois

 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * Author:
 * 	Didier 'Ptitjes Villevalois <ptitjes@free.fr>
 */

#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <gee-internals.h>
#include <math.h>
#include <float.h>

#define _g_option_context_free0(var) ((var == NULL) ? NULL : (var = (g_option_context_free (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

#define GEE_BENCHMARK_TYPE_FACTORY (gee_benchmark_factory_get_type ())
#define GEE_BENCHMARK_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_FACTORY, GeeBenchmarkFactory))
#define GEE_BENCHMARK_IS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_FACTORY))
#define GEE_BENCHMARK_FACTORY_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_BENCHMARK_TYPE_FACTORY, GeeBenchmarkFactoryIface))

typedef struct _GeeBenchmarkFactory GeeBenchmarkFactory;
typedef struct _GeeBenchmarkFactoryIface GeeBenchmarkFactoryIface;

#define GEE_BENCHMARK_TYPE_GENERATOR (gee_benchmark_generator_get_type ())
#define GEE_BENCHMARK_GENERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_GENERATOR, GeeBenchmarkGenerator))
#define GEE_BENCHMARK_IS_GENERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_GENERATOR))
#define GEE_BENCHMARK_GENERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_BENCHMARK_TYPE_GENERATOR, GeeBenchmarkGeneratorIface))

typedef struct _GeeBenchmarkGenerator GeeBenchmarkGenerator;
typedef struct _GeeBenchmarkGeneratorIface GeeBenchmarkGeneratorIface;

#define GEE_BENCHMARK_TYPE_ALGORITHM (gee_benchmark_algorithm_get_type ())
#define GEE_BENCHMARK_ALGORITHM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_ALGORITHM, GeeBenchmarkAlgorithm))
#define GEE_BENCHMARK_IS_ALGORITHM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_ALGORITHM))
#define GEE_BENCHMARK_ALGORITHM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_BENCHMARK_TYPE_ALGORITHM, GeeBenchmarkAlgorithmIface))

typedef struct _GeeBenchmarkAlgorithm GeeBenchmarkAlgorithm;
typedef struct _GeeBenchmarkAlgorithmIface GeeBenchmarkAlgorithmIface;

#define GEE_BENCHMARK_TYPE_RANDOM_INT32 (gee_benchmark_random_int32_get_type ())
#define GEE_BENCHMARK_RANDOM_INT32(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_RANDOM_INT32, GeeBenchmarkRandomInt32))
#define GEE_BENCHMARK_RANDOM_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_BENCHMARK_TYPE_RANDOM_INT32, GeeBenchmarkRandomInt32Class))
#define GEE_BENCHMARK_IS_RANDOM_INT32(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_RANDOM_INT32))
#define GEE_BENCHMARK_IS_RANDOM_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_BENCHMARK_TYPE_RANDOM_INT32))
#define GEE_BENCHMARK_RANDOM_INT32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_BENCHMARK_TYPE_RANDOM_INT32, GeeBenchmarkRandomInt32Class))

typedef struct _GeeBenchmarkRandomInt32 GeeBenchmarkRandomInt32;
typedef struct _GeeBenchmarkRandomInt32Class GeeBenchmarkRandomInt32Class;
typedef struct _GeeBenchmarkRandomInt32Private GeeBenchmarkRandomInt32Private;

#define GEE_BENCHMARK_TYPE_FIXED_VARIANCE_INT32 (gee_benchmark_fixed_variance_int32_get_type ())
#define GEE_BENCHMARK_FIXED_VARIANCE_INT32(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_FIXED_VARIANCE_INT32, GeeBenchmarkFixedVarianceInt32))
#define GEE_BENCHMARK_FIXED_VARIANCE_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_BENCHMARK_TYPE_FIXED_VARIANCE_INT32, GeeBenchmarkFixedVarianceInt32Class))
#define GEE_BENCHMARK_IS_FIXED_VARIANCE_INT32(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_FIXED_VARIANCE_INT32))
#define GEE_BENCHMARK_IS_FIXED_VARIANCE_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_BENCHMARK_TYPE_FIXED_VARIANCE_INT32))
#define GEE_BENCHMARK_FIXED_VARIANCE_INT32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_BENCHMARK_TYPE_FIXED_VARIANCE_INT32, GeeBenchmarkFixedVarianceInt32Class))

typedef struct _GeeBenchmarkFixedVarianceInt32 GeeBenchmarkFixedVarianceInt32;
typedef struct _GeeBenchmarkFixedVarianceInt32Class GeeBenchmarkFixedVarianceInt32Class;
typedef struct _GeeBenchmarkFixedVarianceInt32Private GeeBenchmarkFixedVarianceInt32Private;

#define GEE_BENCHMARK_TYPE_MOUNTS_INT32 (gee_benchmark_mounts_int32_get_type ())
#define GEE_BENCHMARK_MOUNTS_INT32(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_MOUNTS_INT32, GeeBenchmarkMountsInt32))
#define GEE_BENCHMARK_MOUNTS_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_BENCHMARK_TYPE_MOUNTS_INT32, GeeBenchmarkMountsInt32Class))
#define GEE_BENCHMARK_IS_MOUNTS_INT32(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_MOUNTS_INT32))
#define GEE_BENCHMARK_IS_MOUNTS_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_BENCHMARK_TYPE_MOUNTS_INT32))
#define GEE_BENCHMARK_MOUNTS_INT32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_BENCHMARK_TYPE_MOUNTS_INT32, GeeBenchmarkMountsInt32Class))

typedef struct _GeeBenchmarkMountsInt32 GeeBenchmarkMountsInt32;
typedef struct _GeeBenchmarkMountsInt32Class GeeBenchmarkMountsInt32Class;
typedef struct _GeeBenchmarkMountsInt32Private GeeBenchmarkMountsInt32Private;

#define GEE_BENCHMARK_TYPE_REVERSE_SORTED_INT32 (gee_benchmark_reverse_sorted_int32_get_type ())
#define GEE_BENCHMARK_REVERSE_SORTED_INT32(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_REVERSE_SORTED_INT32, GeeBenchmarkReverseSortedInt32))
#define GEE_BENCHMARK_REVERSE_SORTED_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_BENCHMARK_TYPE_REVERSE_SORTED_INT32, GeeBenchmarkReverseSortedInt32Class))
#define GEE_BENCHMARK_IS_REVERSE_SORTED_INT32(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_REVERSE_SORTED_INT32))
#define GEE_BENCHMARK_IS_REVERSE_SORTED_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_BENCHMARK_TYPE_REVERSE_SORTED_INT32))
#define GEE_BENCHMARK_REVERSE_SORTED_INT32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_BENCHMARK_TYPE_REVERSE_SORTED_INT32, GeeBenchmarkReverseSortedInt32Class))

typedef struct _GeeBenchmarkReverseSortedInt32 GeeBenchmarkReverseSortedInt32;
typedef struct _GeeBenchmarkReverseSortedInt32Class GeeBenchmarkReverseSortedInt32Class;
typedef struct _GeeBenchmarkReverseSortedInt32Private GeeBenchmarkReverseSortedInt32Private;

#define GEE_BENCHMARK_TYPE_SORTED_INT32 (gee_benchmark_sorted_int32_get_type ())
#define GEE_BENCHMARK_SORTED_INT32(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_SORTED_INT32, GeeBenchmarkSortedInt32))
#define GEE_BENCHMARK_SORTED_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_BENCHMARK_TYPE_SORTED_INT32, GeeBenchmarkSortedInt32Class))
#define GEE_BENCHMARK_IS_SORTED_INT32(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_SORTED_INT32))
#define GEE_BENCHMARK_IS_SORTED_INT32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_BENCHMARK_TYPE_SORTED_INT32))
#define GEE_BENCHMARK_SORTED_INT32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_BENCHMARK_TYPE_SORTED_INT32, GeeBenchmarkSortedInt32Class))

typedef struct _GeeBenchmarkSortedInt32 GeeBenchmarkSortedInt32;
typedef struct _GeeBenchmarkSortedInt32Class GeeBenchmarkSortedInt32Class;
typedef struct _GeeBenchmarkSortedInt32Private GeeBenchmarkSortedInt32Private;

#define GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY (gee_benchmark_array_list_factory_get_type ())
#define GEE_BENCHMARK_ARRAY_LIST_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY, GeeBenchmarkArrayListFactory))
#define GEE_BENCHMARK_ARRAY_LIST_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY, GeeBenchmarkArrayListFactoryClass))
#define GEE_BENCHMARK_IS_ARRAY_LIST_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY))
#define GEE_BENCHMARK_IS_ARRAY_LIST_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY))
#define GEE_BENCHMARK_ARRAY_LIST_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY, GeeBenchmarkArrayListFactoryClass))

typedef struct _GeeBenchmarkArrayListFactory GeeBenchmarkArrayListFactory;
typedef struct _GeeBenchmarkArrayListFactoryClass GeeBenchmarkArrayListFactoryClass;
typedef struct _GeeBenchmarkArrayListFactoryPrivate GeeBenchmarkArrayListFactoryPrivate;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))

#define GEE_BENCHMARK_TYPE_BENCHMARK (gee_benchmark_benchmark_get_type ())
#define GEE_BENCHMARK_BENCHMARK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_BENCHMARK_TYPE_BENCHMARK, GeeBenchmarkBenchmark))
#define GEE_BENCHMARK_BENCHMARK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_BENCHMARK_TYPE_BENCHMARK, GeeBenchmarkBenchmarkClass))
#define GEE_BENCHMARK_IS_BENCHMARK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_BENCHMARK_TYPE_BENCHMARK))
#define GEE_BENCHMARK_IS_BENCHMARK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_BENCHMARK_TYPE_BENCHMARK))
#define GEE_BENCHMARK_BENCHMARK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_BENCHMARK_TYPE_BENCHMARK, GeeBenchmarkBenchmarkClass))

typedef struct _GeeBenchmarkBenchmark GeeBenchmarkBenchmark;
typedef struct _GeeBenchmarkBenchmarkClass GeeBenchmarkBenchmarkClass;
typedef struct _GeeBenchmarkBenchmarkPrivate GeeBenchmarkBenchmarkPrivate;
#define _g_timer_destroy0(var) ((var == NULL) ? NULL : (var = (g_timer_destroy (var), NULL)))

struct _GeeBenchmarkFactoryIface {
	GTypeInterface parent_iface;
	GeeCollection* (*create) (GeeBenchmarkFactory* self);
	GeeCollection* (*copy) (GeeBenchmarkFactory* self, GeeCollection* collection);
};

struct _GeeBenchmarkGeneratorIface {
	GTypeInterface parent_iface;
	void (*generate_collection) (GeeBenchmarkGenerator* self, gint size, GeeCollection* collection);
	const gchar* (*get_name) (GeeBenchmarkGenerator* self);
};

struct _GeeBenchmarkAlgorithmIface {
	GTypeInterface parent_iface;
	void (*process_collection) (GeeBenchmarkAlgorithm* self, GeeCollection* collection);
	const gchar* (*get_name) (GeeBenchmarkAlgorithm* self);
};

struct _GeeBenchmarkRandomInt32 {
	GObject parent_instance;
	GeeBenchmarkRandomInt32Private * priv;
};

struct _GeeBenchmarkRandomInt32Class {
	GObjectClass parent_class;
};

struct _GeeBenchmarkFixedVarianceInt32 {
	GObject parent_instance;
	GeeBenchmarkFixedVarianceInt32Private * priv;
};

struct _GeeBenchmarkFixedVarianceInt32Class {
	GObjectClass parent_class;
};

struct _GeeBenchmarkMountsInt32 {
	GObject parent_instance;
	GeeBenchmarkMountsInt32Private * priv;
};

struct _GeeBenchmarkMountsInt32Class {
	GObjectClass parent_class;
};

struct _GeeBenchmarkReverseSortedInt32 {
	GObject parent_instance;
	GeeBenchmarkReverseSortedInt32Private * priv;
};

struct _GeeBenchmarkReverseSortedInt32Class {
	GObjectClass parent_class;
};

struct _GeeBenchmarkSortedInt32 {
	GObject parent_instance;
	GeeBenchmarkSortedInt32Private * priv;
};

struct _GeeBenchmarkSortedInt32Class {
	GObjectClass parent_class;
};

struct _GeeBenchmarkArrayListFactory {
	GObject parent_instance;
	GeeBenchmarkArrayListFactoryPrivate * priv;
};

struct _GeeBenchmarkArrayListFactoryClass {
	GObjectClass parent_class;
};

struct _GeeBenchmarkArrayListFactoryPrivate {
	GType g_type;
	GBoxedCopyFunc g_dup_func;
	GDestroyNotify g_destroy_func;
};

struct _GeeBenchmarkBenchmark {
	GObject parent_instance;
	GeeBenchmarkBenchmarkPrivate * priv;
};

struct _GeeBenchmarkBenchmarkClass {
	GObjectClass parent_class;
};

struct _GeeBenchmarkBenchmarkPrivate {
	GType g_type;
	GBoxedCopyFunc g_dup_func;
	GDestroyNotify g_destroy_func;
	GeeBenchmarkFactory* factory;
	gint* sizes;
	gint sizes_length1;
	gint _sizes_size_;
	GeeList* generators;
	GeeList* algorithms;
	gint iteration_count;
	gdouble* results_sum;
	gint results_sum_length1;
	gint results_sum_length2;
	gint results_sum_length3;
	gdouble* results_squared_sum;
	gint results_squared_sum_length1;
	gint results_squared_sum_length2;
	gint results_squared_sum_length3;
};


static gpointer gee_benchmark_random_int32_parent_class = NULL;
static GeeBenchmarkGeneratorIface* gee_benchmark_random_int32_gee_benchmark_generator_parent_iface = NULL;
static gpointer gee_benchmark_fixed_variance_int32_parent_class = NULL;
static GeeBenchmarkGeneratorIface* gee_benchmark_fixed_variance_int32_gee_benchmark_generator_parent_iface = NULL;
static gpointer gee_benchmark_mounts_int32_parent_class = NULL;
static GeeBenchmarkGeneratorIface* gee_benchmark_mounts_int32_gee_benchmark_generator_parent_iface = NULL;
static gpointer gee_benchmark_reverse_sorted_int32_parent_class = NULL;
static GeeBenchmarkGeneratorIface* gee_benchmark_reverse_sorted_int32_gee_benchmark_generator_parent_iface = NULL;
static gpointer gee_benchmark_sorted_int32_parent_class = NULL;
static GeeBenchmarkGeneratorIface* gee_benchmark_sorted_int32_gee_benchmark_generator_parent_iface = NULL;
static gpointer gee_benchmark_array_list_factory_parent_class = NULL;
static GeeBenchmarkFactoryIface* gee_benchmark_array_list_factory_gee_benchmark_factory_parent_iface = NULL;
static gpointer gee_benchmark_benchmark_parent_class = NULL;

void gee_benchmark_run_benchmark_option (const gchar* long_name, gchar short_name, const gchar* description, gboolean* do_run, GOptionEntry* result);
gint gee_benchmark_main (gchar** args, int args_length1);
void gee_benchmark_benchmark_sorts (void);
GType gee_benchmark_factory_get_type (void) G_GNUC_CONST;
GeeCollection* gee_benchmark_factory_create (GeeBenchmarkFactory* self);
GeeCollection* gee_benchmark_factory_copy (GeeBenchmarkFactory* self, GeeCollection* collection);
GType gee_benchmark_generator_get_type (void) G_GNUC_CONST;
void gee_benchmark_generator_generate_collection (GeeBenchmarkGenerator* self, gint size, GeeCollection* collection);
const gchar* gee_benchmark_generator_get_name (GeeBenchmarkGenerator* self);
GType gee_benchmark_algorithm_get_type (void) G_GNUC_CONST;
void gee_benchmark_algorithm_process_collection (GeeBenchmarkAlgorithm* self, GeeCollection* collection);
const gchar* gee_benchmark_algorithm_get_name (GeeBenchmarkAlgorithm* self);
GType gee_benchmark_random_int32_get_type (void) G_GNUC_CONST;
enum  {
	GEE_BENCHMARK_RANDOM_INT32_DUMMY_PROPERTY,
	GEE_BENCHMARK_RANDOM_INT32_NAME
};
static void gee_benchmark_random_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection);
GeeBenchmarkRandomInt32* gee_benchmark_random_int32_new (void);
GeeBenchmarkRandomInt32* gee_benchmark_random_int32_construct (GType object_type);
static void _vala_gee_benchmark_random_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
GType gee_benchmark_fixed_variance_int32_get_type (void) G_GNUC_CONST;
enum  {
	GEE_BENCHMARK_FIXED_VARIANCE_INT32_DUMMY_PROPERTY,
	GEE_BENCHMARK_FIXED_VARIANCE_INT32_NAME
};
static void gee_benchmark_fixed_variance_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection);
GeeBenchmarkFixedVarianceInt32* gee_benchmark_fixed_variance_int32_new (void);
GeeBenchmarkFixedVarianceInt32* gee_benchmark_fixed_variance_int32_construct (GType object_type);
static void _vala_gee_benchmark_fixed_variance_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
GType gee_benchmark_mounts_int32_get_type (void) G_GNUC_CONST;
enum  {
	GEE_BENCHMARK_MOUNTS_INT32_DUMMY_PROPERTY,
	GEE_BENCHMARK_MOUNTS_INT32_NAME
};
static void gee_benchmark_mounts_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection);
GeeBenchmarkMountsInt32* gee_benchmark_mounts_int32_new (void);
GeeBenchmarkMountsInt32* gee_benchmark_mounts_int32_construct (GType object_type);
static void _vala_gee_benchmark_mounts_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
GType gee_benchmark_reverse_sorted_int32_get_type (void) G_GNUC_CONST;
enum  {
	GEE_BENCHMARK_REVERSE_SORTED_INT32_DUMMY_PROPERTY,
	GEE_BENCHMARK_REVERSE_SORTED_INT32_NAME
};
static void gee_benchmark_reverse_sorted_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection);
GeeBenchmarkReverseSortedInt32* gee_benchmark_reverse_sorted_int32_new (void);
GeeBenchmarkReverseSortedInt32* gee_benchmark_reverse_sorted_int32_construct (GType object_type);
static void _vala_gee_benchmark_reverse_sorted_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
GType gee_benchmark_sorted_int32_get_type (void) G_GNUC_CONST;
enum  {
	GEE_BENCHMARK_SORTED_INT32_DUMMY_PROPERTY,
	GEE_BENCHMARK_SORTED_INT32_NAME
};
static void gee_benchmark_sorted_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection);
GeeBenchmarkSortedInt32* gee_benchmark_sorted_int32_new (void);
GeeBenchmarkSortedInt32* gee_benchmark_sorted_int32_construct (GType object_type);
static void _vala_gee_benchmark_sorted_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
GType gee_benchmark_array_list_factory_get_type (void) G_GNUC_CONST;
#define GEE_BENCHMARK_ARRAY_LIST_FACTORY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY, GeeBenchmarkArrayListFactoryPrivate))
enum  {
	GEE_BENCHMARK_ARRAY_LIST_FACTORY_DUMMY_PROPERTY,
	GEE_BENCHMARK_ARRAY_LIST_FACTORY_G_TYPE,
	GEE_BENCHMARK_ARRAY_LIST_FACTORY_G_DUP_FUNC,
	GEE_BENCHMARK_ARRAY_LIST_FACTORY_G_DESTROY_FUNC
};
static GeeCollection* gee_benchmark_array_list_factory_real_create (GeeBenchmarkFactory* base);
static GeeCollection* gee_benchmark_array_list_factory_real_copy (GeeBenchmarkFactory* base, GeeCollection* collection);
GeeBenchmarkArrayListFactory* gee_benchmark_array_list_factory_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
GeeBenchmarkArrayListFactory* gee_benchmark_array_list_factory_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
static void _vala_gee_benchmark_array_list_factory_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
static void _vala_gee_benchmark_array_list_factory_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
GType gee_benchmark_benchmark_get_type (void) G_GNUC_CONST;
#define GEE_BENCHMARK_BENCHMARK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_BENCHMARK_TYPE_BENCHMARK, GeeBenchmarkBenchmarkPrivate))
enum  {
	GEE_BENCHMARK_BENCHMARK_DUMMY_PROPERTY,
	GEE_BENCHMARK_BENCHMARK_G_TYPE,
	GEE_BENCHMARK_BENCHMARK_G_DUP_FUNC,
	GEE_BENCHMARK_BENCHMARK_G_DESTROY_FUNC
};
GeeBenchmarkBenchmark* gee_benchmark_benchmark_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeBenchmarkFactory* factory, GeeList* algorithms, GeeList* generators, gint* sizes, int sizes_length1, gint iteration_count);
GeeBenchmarkBenchmark* gee_benchmark_benchmark_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeBenchmarkFactory* factory, GeeList* algorithms, GeeList* generators, gint* sizes, int sizes_length1, gint iteration_count);
static gint* _vala_array_dup1 (gint* self, int length);
void gee_benchmark_benchmark_run (GeeBenchmarkBenchmark* self);
void gee_benchmark_benchmark_display_results (GeeBenchmarkBenchmark* self, gint iteration);
static void gee_benchmark_benchmark_finalize (GObject* obj);
static void _vala_gee_benchmark_benchmark_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
static void _vala_gee_benchmark_benchmark_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);


void gee_benchmark_run_benchmark_option (const gchar* long_name, gchar short_name, const gchar* description, gboolean* do_run, GOptionEntry* result) {
	const gchar* _tmp0_ = NULL;
	gchar _tmp1_ = '\0';
	const gchar* _tmp2_ = NULL;
	GOptionEntry _tmp3_ = {0};
	g_return_if_fail (long_name != NULL);
	g_return_if_fail (description != NULL);
	_tmp0_ = long_name;
	_tmp1_ = short_name;
	_tmp2_ = description;
	memset (&_tmp3_, 0, sizeof (GOptionEntry));
	_tmp3_.long_name = _tmp0_;
	_tmp3_.short_name = _tmp1_;
	_tmp3_.flags = 0;
	_tmp3_.arg = G_OPTION_ARG_NONE;
	_tmp3_.arg_data = do_run;
	_tmp3_.description = _tmp2_;
	_tmp3_.arg_description = NULL;
	*result = _tmp3_;
	return;
}


gint gee_benchmark_main (gchar** args, int args_length1) {
	gint result = 0;
	gboolean run_sort = FALSE;
	GOptionEntry* entries = NULL;
	GOptionEntry _tmp0_ = {0};
	GOptionEntry* _tmp1_ = NULL;
	gint entries_length1 = 0;
	gint _entries_size_ = 0;
	GOptionContext* context = NULL;
	GOptionContext* _tmp2_ = NULL;
	GOptionContext* _tmp3_ = NULL;
	GOptionEntry* _tmp4_ = NULL;
	gint _tmp4__length1 = 0;
	gboolean _tmp9_ = FALSE;
	GError * _inner_error_ = NULL;
	run_sort = FALSE;
	gee_benchmark_run_benchmark_option ("run-sort", 's', "Run sorting benchmark", &run_sort, &_tmp0_);
	_tmp1_ = g_new0 (GOptionEntry, 1);
	_tmp1_[0] = _tmp0_;
	entries = _tmp1_;
	entries_length1 = 1;
	_entries_size_ = entries_length1;
	_tmp2_ = g_option_context_new ("Run various benchmarks");
	context = _tmp2_;
	_tmp3_ = context;
	_tmp4_ = entries;
	_tmp4__length1 = entries_length1;
	g_option_context_add_main_entries (_tmp3_, _tmp4_, "gee-benchmark");
	{
		GOptionContext* _tmp5_ = NULL;
		_tmp5_ = context;
		g_option_context_parse (_tmp5_, &args_length1, &args, &_inner_error_);
		if (_inner_error_ != NULL) {
			if (_inner_error_->domain == G_OPTION_ERROR) {
				goto __catch0_g_option_error;
			}
			_g_option_context_free0 (context);
			entries = (g_free (entries), NULL);
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return 0;
		}
	}
	goto __finally0;
	__catch0_g_option_error:
	{
		GError* e = NULL;
		FILE* _tmp6_ = NULL;
		GError* _tmp7_ = NULL;
		const gchar* _tmp8_ = NULL;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp6_ = stdout;
		_tmp7_ = e;
		_tmp8_ = _tmp7_->message;
		fprintf (_tmp6_, "option parsing failed: %s\n", _tmp8_);
		result = 2;
		_g_error_free0 (e);
		_g_option_context_free0 (context);
		entries = (g_free (entries), NULL);
		return result;
	}
	__finally0:
	if (_inner_error_ != NULL) {
		_g_option_context_free0 (context);
		entries = (g_free (entries), NULL);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return 0;
	}
	_tmp9_ = run_sort;
	if (_tmp9_) {
		gee_benchmark_benchmark_sorts ();
	}
	result = 0;
	_g_option_context_free0 (context);
	entries = (g_free (entries), NULL);
	return result;
}


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


GeeCollection* gee_benchmark_factory_create (GeeBenchmarkFactory* self) {
	g_return_val_if_fail (self != NULL, NULL);
	return GEE_BENCHMARK_FACTORY_GET_INTERFACE (self)->create (self);
}


GeeCollection* gee_benchmark_factory_copy (GeeBenchmarkFactory* self, GeeCollection* collection) {
	g_return_val_if_fail (self != NULL, NULL);
	return GEE_BENCHMARK_FACTORY_GET_INTERFACE (self)->copy (self, collection);
}


static void gee_benchmark_factory_base_init (GeeBenchmarkFactoryIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
	}
}


GType gee_benchmark_factory_get_type (void) {
	static volatile gsize gee_benchmark_factory_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_factory_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkFactoryIface), (GBaseInitFunc) gee_benchmark_factory_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType gee_benchmark_factory_type_id;
		gee_benchmark_factory_type_id = g_type_register_static (G_TYPE_INTERFACE, "GeeBenchmarkFactory", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (gee_benchmark_factory_type_id, G_TYPE_OBJECT);
		g_once_init_leave (&gee_benchmark_factory_type_id__volatile, gee_benchmark_factory_type_id);
	}
	return gee_benchmark_factory_type_id__volatile;
}


void gee_benchmark_generator_generate_collection (GeeBenchmarkGenerator* self, gint size, GeeCollection* collection) {
	g_return_if_fail (self != NULL);
	GEE_BENCHMARK_GENERATOR_GET_INTERFACE (self)->generate_collection (self, size, collection);
}


const gchar* gee_benchmark_generator_get_name (GeeBenchmarkGenerator* self) {
	g_return_val_if_fail (self != NULL, NULL);
	return GEE_BENCHMARK_GENERATOR_GET_INTERFACE (self)->get_name (self);
}


static void gee_benchmark_generator_base_init (GeeBenchmarkGeneratorIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
		g_object_interface_install_property (iface, g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
	}
}


GType gee_benchmark_generator_get_type (void) {
	static volatile gsize gee_benchmark_generator_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_generator_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkGeneratorIface), (GBaseInitFunc) gee_benchmark_generator_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType gee_benchmark_generator_type_id;
		gee_benchmark_generator_type_id = g_type_register_static (G_TYPE_INTERFACE, "GeeBenchmarkGenerator", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (gee_benchmark_generator_type_id, G_TYPE_OBJECT);
		g_once_init_leave (&gee_benchmark_generator_type_id__volatile, gee_benchmark_generator_type_id);
	}
	return gee_benchmark_generator_type_id__volatile;
}


void gee_benchmark_algorithm_process_collection (GeeBenchmarkAlgorithm* self, GeeCollection* collection) {
	g_return_if_fail (self != NULL);
	GEE_BENCHMARK_ALGORITHM_GET_INTERFACE (self)->process_collection (self, collection);
}


const gchar* gee_benchmark_algorithm_get_name (GeeBenchmarkAlgorithm* self) {
	g_return_val_if_fail (self != NULL, NULL);
	return GEE_BENCHMARK_ALGORITHM_GET_INTERFACE (self)->get_name (self);
}


static void gee_benchmark_algorithm_base_init (GeeBenchmarkAlgorithmIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
		g_object_interface_install_property (iface, g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
	}
}


GType gee_benchmark_algorithm_get_type (void) {
	static volatile gsize gee_benchmark_algorithm_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_algorithm_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkAlgorithmIface), (GBaseInitFunc) gee_benchmark_algorithm_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType gee_benchmark_algorithm_type_id;
		gee_benchmark_algorithm_type_id = g_type_register_static (G_TYPE_INTERFACE, "GeeBenchmarkAlgorithm", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (gee_benchmark_algorithm_type_id, G_TYPE_OBJECT);
		g_once_init_leave (&gee_benchmark_algorithm_type_id__volatile, gee_benchmark_algorithm_type_id);
	}
	return gee_benchmark_algorithm_type_id__volatile;
}


static void gee_benchmark_random_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection) {
	GeeBenchmarkRandomInt32 * self;
	self = (GeeBenchmarkRandomInt32*) base;
	g_return_if_fail (collection != NULL);
	{
		gint i = 0;
		i = 0;
		{
			gboolean _tmp0_ = FALSE;
			_tmp0_ = TRUE;
			while (TRUE) {
				gboolean _tmp1_ = FALSE;
				gint _tmp3_ = 0;
				gint _tmp4_ = 0;
				GeeCollection* _tmp5_ = NULL;
				gint _tmp6_ = 0;
				gint32 _tmp7_ = 0;
				_tmp1_ = _tmp0_;
				if (!_tmp1_) {
					gint _tmp2_ = 0;
					_tmp2_ = i;
					i = _tmp2_ + 1;
				}
				_tmp0_ = FALSE;
				_tmp3_ = i;
				_tmp4_ = size;
				if (!(_tmp3_ < _tmp4_)) {
					break;
				}
				_tmp5_ = collection;
				_tmp6_ = size;
				_tmp7_ = g_random_int_range ((gint32) 0, (gint32) (_tmp6_ - 1));
				gee_collection_add (_tmp5_, (gpointer) ((gintptr) _tmp7_));
			}
		}
	}
}


GeeBenchmarkRandomInt32* gee_benchmark_random_int32_construct (GType object_type) {
	GeeBenchmarkRandomInt32 * self = NULL;
	self = (GeeBenchmarkRandomInt32*) g_object_new (object_type, NULL);
	return self;
}


GeeBenchmarkRandomInt32* gee_benchmark_random_int32_new (void) {
	return gee_benchmark_random_int32_construct (GEE_BENCHMARK_TYPE_RANDOM_INT32);
}


static const gchar* gee_benchmark_random_int32_real_get_name (GeeBenchmarkGenerator* base) {
	const gchar* result;
	GeeBenchmarkRandomInt32* self;
	self = (GeeBenchmarkRandomInt32*) base;
	result = "FullRandom";
	return result;
}


static void gee_benchmark_random_int32_class_init (GeeBenchmarkRandomInt32Class * klass) {
	gee_benchmark_random_int32_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->get_property = _vala_gee_benchmark_random_int32_get_property;
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_RANDOM_INT32_NAME, g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
}


static void gee_benchmark_random_int32_gee_benchmark_generator_interface_init (GeeBenchmarkGeneratorIface * iface) {
	gee_benchmark_random_int32_gee_benchmark_generator_parent_iface = g_type_interface_peek_parent (iface);
	iface->generate_collection = (void (*)(GeeBenchmarkGenerator*, gint, GeeCollection*)) gee_benchmark_random_int32_real_generate_collection;
	iface->get_name = gee_benchmark_random_int32_real_get_name;
}


static void gee_benchmark_random_int32_instance_init (GeeBenchmarkRandomInt32 * self) {
}


GType gee_benchmark_random_int32_get_type (void) {
	static volatile gsize gee_benchmark_random_int32_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_random_int32_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkRandomInt32Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_benchmark_random_int32_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeBenchmarkRandomInt32), 0, (GInstanceInitFunc) gee_benchmark_random_int32_instance_init, NULL };
		static const GInterfaceInfo gee_benchmark_generator_info = { (GInterfaceInitFunc) gee_benchmark_random_int32_gee_benchmark_generator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
		GType gee_benchmark_random_int32_type_id;
		gee_benchmark_random_int32_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeBenchmarkRandomInt32", &g_define_type_info, 0);
		g_type_add_interface_static (gee_benchmark_random_int32_type_id, GEE_BENCHMARK_TYPE_GENERATOR, &gee_benchmark_generator_info);
		g_once_init_leave (&gee_benchmark_random_int32_type_id__volatile, gee_benchmark_random_int32_type_id);
	}
	return gee_benchmark_random_int32_type_id__volatile;
}


static void _vala_gee_benchmark_random_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	GeeBenchmarkRandomInt32 * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_BENCHMARK_TYPE_RANDOM_INT32, GeeBenchmarkRandomInt32);
	switch (property_id) {
		case GEE_BENCHMARK_RANDOM_INT32_NAME:
		g_value_set_string (value, gee_benchmark_generator_get_name ((GeeBenchmarkGenerator*) self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void gee_benchmark_fixed_variance_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection) {
	GeeBenchmarkFixedVarianceInt32 * self;
	gint variance = 0;
	gint _tmp0_ = 0;
	gdouble _tmp1_ = 0.0;
	self = (GeeBenchmarkFixedVarianceInt32*) base;
	g_return_if_fail (collection != NULL);
	_tmp0_ = size;
	_tmp1_ = sqrt ((gdouble) _tmp0_);
	variance = (gint) _tmp1_;
	{
		gint i = 0;
		i = 0;
		{
			gboolean _tmp2_ = FALSE;
			_tmp2_ = TRUE;
			while (TRUE) {
				gboolean _tmp3_ = FALSE;
				gint _tmp5_ = 0;
				gint _tmp6_ = 0;
				GeeCollection* _tmp7_ = NULL;
				gint _tmp8_ = 0;
				gint _tmp9_ = 0;
				gint32 _tmp10_ = 0;
				gint _tmp11_ = 0;
				_tmp3_ = _tmp2_;
				if (!_tmp3_) {
					gint _tmp4_ = 0;
					_tmp4_ = i;
					i = _tmp4_ + 1;
				}
				_tmp2_ = FALSE;
				_tmp5_ = i;
				_tmp6_ = size;
				if (!(_tmp5_ < _tmp6_)) {
					break;
				}
				_tmp7_ = collection;
				_tmp8_ = i;
				_tmp9_ = variance;
				_tmp10_ = g_random_int_range ((gint32) 0, (gint32) _tmp9_);
				_tmp11_ = variance;
				gee_collection_add (_tmp7_, (gpointer) ((gintptr) ((gint32) ((_tmp8_ + _tmp10_) - (_tmp11_ / 2)))));
			}
		}
	}
}


GeeBenchmarkFixedVarianceInt32* gee_benchmark_fixed_variance_int32_construct (GType object_type) {
	GeeBenchmarkFixedVarianceInt32 * self = NULL;
	self = (GeeBenchmarkFixedVarianceInt32*) g_object_new (object_type, NULL);
	return self;
}


GeeBenchmarkFixedVarianceInt32* gee_benchmark_fixed_variance_int32_new (void) {
	return gee_benchmark_fixed_variance_int32_construct (GEE_BENCHMARK_TYPE_FIXED_VARIANCE_INT32);
}


static const gchar* gee_benchmark_fixed_variance_int32_real_get_name (GeeBenchmarkGenerator* base) {
	const gchar* result;
	GeeBenchmarkFixedVarianceInt32* self;
	self = (GeeBenchmarkFixedVarianceInt32*) base;
	result = "FixedVariance";
	return result;
}


static void gee_benchmark_fixed_variance_int32_class_init (GeeBenchmarkFixedVarianceInt32Class * klass) {
	gee_benchmark_fixed_variance_int32_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->get_property = _vala_gee_benchmark_fixed_variance_int32_get_property;
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_FIXED_VARIANCE_INT32_NAME, g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
}


static void gee_benchmark_fixed_variance_int32_gee_benchmark_generator_interface_init (GeeBenchmarkGeneratorIface * iface) {
	gee_benchmark_fixed_variance_int32_gee_benchmark_generator_parent_iface = g_type_interface_peek_parent (iface);
	iface->generate_collection = (void (*)(GeeBenchmarkGenerator*, gint, GeeCollection*)) gee_benchmark_fixed_variance_int32_real_generate_collection;
	iface->get_name = gee_benchmark_fixed_variance_int32_real_get_name;
}


static void gee_benchmark_fixed_variance_int32_instance_init (GeeBenchmarkFixedVarianceInt32 * self) {
}


GType gee_benchmark_fixed_variance_int32_get_type (void) {
	static volatile gsize gee_benchmark_fixed_variance_int32_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_fixed_variance_int32_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkFixedVarianceInt32Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_benchmark_fixed_variance_int32_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeBenchmarkFixedVarianceInt32), 0, (GInstanceInitFunc) gee_benchmark_fixed_variance_int32_instance_init, NULL };
		static const GInterfaceInfo gee_benchmark_generator_info = { (GInterfaceInitFunc) gee_benchmark_fixed_variance_int32_gee_benchmark_generator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
		GType gee_benchmark_fixed_variance_int32_type_id;
		gee_benchmark_fixed_variance_int32_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeBenchmarkFixedVarianceInt32", &g_define_type_info, 0);
		g_type_add_interface_static (gee_benchmark_fixed_variance_int32_type_id, GEE_BENCHMARK_TYPE_GENERATOR, &gee_benchmark_generator_info);
		g_once_init_leave (&gee_benchmark_fixed_variance_int32_type_id__volatile, gee_benchmark_fixed_variance_int32_type_id);
	}
	return gee_benchmark_fixed_variance_int32_type_id__volatile;
}


static void _vala_gee_benchmark_fixed_variance_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	GeeBenchmarkFixedVarianceInt32 * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_BENCHMARK_TYPE_FIXED_VARIANCE_INT32, GeeBenchmarkFixedVarianceInt32);
	switch (property_id) {
		case GEE_BENCHMARK_FIXED_VARIANCE_INT32_NAME:
		g_value_set_string (value, gee_benchmark_generator_get_name ((GeeBenchmarkGenerator*) self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void gee_benchmark_mounts_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection) {
	GeeBenchmarkMountsInt32 * self;
	gint index = 0;
	gint last = 0;
	gint variance = 0;
	gint _tmp0_ = 0;
	gdouble _tmp1_ = 0.0;
	self = (GeeBenchmarkMountsInt32*) base;
	g_return_if_fail (collection != NULL);
	index = 0;
	last = 0;
	_tmp0_ = size;
	_tmp1_ = sqrt ((gdouble) _tmp0_);
	variance = (gint) _tmp1_;
	while (TRUE) {
		gint _tmp2_ = 0;
		gint _tmp3_ = 0;
		gint width = 0;
		gint _tmp4_ = 0;
		gint32 _tmp5_ = 0;
		gint height = 0;
		gint _tmp6_ = 0;
		gint _tmp7_ = 0;
		gint32 _tmp8_ = 0;
		gint _tmp18_ = 0;
		gint _tmp19_ = 0;
		gint _tmp20_ = 0;
		gint _tmp21_ = 0;
		_tmp2_ = index;
		_tmp3_ = size;
		if (!(_tmp2_ < _tmp3_)) {
			break;
		}
		_tmp4_ = variance;
		_tmp5_ = g_random_int_range ((gint32) 0, (gint32) _tmp4_);
		width = (gint) _tmp5_;
		_tmp6_ = variance;
		_tmp7_ = variance;
		_tmp8_ = g_random_int_range ((gint32) ((-_tmp6_) / 2), (gint32) (_tmp7_ / 2));
		height = (gint) _tmp8_;
		{
			gint i = 0;
			i = 0;
			{
				gboolean _tmp9_ = FALSE;
				_tmp9_ = TRUE;
				while (TRUE) {
					gboolean _tmp10_ = FALSE;
					gint _tmp12_ = 0;
					gint _tmp13_ = 0;
					GeeCollection* _tmp14_ = NULL;
					gint _tmp15_ = 0;
					gint _tmp16_ = 0;
					gint _tmp17_ = 0;
					_tmp10_ = _tmp9_;
					if (!_tmp10_) {
						gint _tmp11_ = 0;
						_tmp11_ = i;
						i = _tmp11_ + 1;
					}
					_tmp9_ = FALSE;
					_tmp12_ = i;
					_tmp13_ = width;
					if (!(_tmp12_ < _tmp13_)) {
						break;
					}
					_tmp14_ = collection;
					_tmp15_ = last;
					_tmp16_ = height;
					_tmp17_ = width;
					gee_collection_add (_tmp14_, (gpointer) ((gintptr) ((gint32) (_tmp15_ + (_tmp16_ / _tmp17_)))));
				}
			}
		}
		_tmp18_ = index;
		_tmp19_ = width;
		index = _tmp18_ + _tmp19_;
		_tmp20_ = last;
		_tmp21_ = height;
		last = _tmp20_ + _tmp21_;
	}
}


GeeBenchmarkMountsInt32* gee_benchmark_mounts_int32_construct (GType object_type) {
	GeeBenchmarkMountsInt32 * self = NULL;
	self = (GeeBenchmarkMountsInt32*) g_object_new (object_type, NULL);
	return self;
}


GeeBenchmarkMountsInt32* gee_benchmark_mounts_int32_new (void) {
	return gee_benchmark_mounts_int32_construct (GEE_BENCHMARK_TYPE_MOUNTS_INT32);
}


static const gchar* gee_benchmark_mounts_int32_real_get_name (GeeBenchmarkGenerator* base) {
	const gchar* result;
	GeeBenchmarkMountsInt32* self;
	self = (GeeBenchmarkMountsInt32*) base;
	result = "Mounts";
	return result;
}


static void gee_benchmark_mounts_int32_class_init (GeeBenchmarkMountsInt32Class * klass) {
	gee_benchmark_mounts_int32_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->get_property = _vala_gee_benchmark_mounts_int32_get_property;
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_MOUNTS_INT32_NAME, g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
}


static void gee_benchmark_mounts_int32_gee_benchmark_generator_interface_init (GeeBenchmarkGeneratorIface * iface) {
	gee_benchmark_mounts_int32_gee_benchmark_generator_parent_iface = g_type_interface_peek_parent (iface);
	iface->generate_collection = (void (*)(GeeBenchmarkGenerator*, gint, GeeCollection*)) gee_benchmark_mounts_int32_real_generate_collection;
	iface->get_name = gee_benchmark_mounts_int32_real_get_name;
}


static void gee_benchmark_mounts_int32_instance_init (GeeBenchmarkMountsInt32 * self) {
}


GType gee_benchmark_mounts_int32_get_type (void) {
	static volatile gsize gee_benchmark_mounts_int32_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_mounts_int32_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkMountsInt32Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_benchmark_mounts_int32_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeBenchmarkMountsInt32), 0, (GInstanceInitFunc) gee_benchmark_mounts_int32_instance_init, NULL };
		static const GInterfaceInfo gee_benchmark_generator_info = { (GInterfaceInitFunc) gee_benchmark_mounts_int32_gee_benchmark_generator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
		GType gee_benchmark_mounts_int32_type_id;
		gee_benchmark_mounts_int32_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeBenchmarkMountsInt32", &g_define_type_info, 0);
		g_type_add_interface_static (gee_benchmark_mounts_int32_type_id, GEE_BENCHMARK_TYPE_GENERATOR, &gee_benchmark_generator_info);
		g_once_init_leave (&gee_benchmark_mounts_int32_type_id__volatile, gee_benchmark_mounts_int32_type_id);
	}
	return gee_benchmark_mounts_int32_type_id__volatile;
}


static void _vala_gee_benchmark_mounts_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	GeeBenchmarkMountsInt32 * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_BENCHMARK_TYPE_MOUNTS_INT32, GeeBenchmarkMountsInt32);
	switch (property_id) {
		case GEE_BENCHMARK_MOUNTS_INT32_NAME:
		g_value_set_string (value, gee_benchmark_generator_get_name ((GeeBenchmarkGenerator*) self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void gee_benchmark_reverse_sorted_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection) {
	GeeBenchmarkReverseSortedInt32 * self;
	self = (GeeBenchmarkReverseSortedInt32*) base;
	g_return_if_fail (collection != NULL);
	{
		gint i = 0;
		i = 0;
		{
			gboolean _tmp0_ = FALSE;
			_tmp0_ = TRUE;
			while (TRUE) {
				gboolean _tmp1_ = FALSE;
				gint _tmp3_ = 0;
				gint _tmp4_ = 0;
				GeeCollection* _tmp5_ = NULL;
				gint _tmp6_ = 0;
				gint _tmp7_ = 0;
				_tmp1_ = _tmp0_;
				if (!_tmp1_) {
					gint _tmp2_ = 0;
					_tmp2_ = i;
					i = _tmp2_ + 1;
				}
				_tmp0_ = FALSE;
				_tmp3_ = i;
				_tmp4_ = size;
				if (!(_tmp3_ < _tmp4_)) {
					break;
				}
				_tmp5_ = collection;
				_tmp6_ = size;
				_tmp7_ = i;
				gee_collection_add (_tmp5_, (gpointer) ((gintptr) ((gint32) ((_tmp6_ - _tmp7_) - 1))));
			}
		}
	}
}


GeeBenchmarkReverseSortedInt32* gee_benchmark_reverse_sorted_int32_construct (GType object_type) {
	GeeBenchmarkReverseSortedInt32 * self = NULL;
	self = (GeeBenchmarkReverseSortedInt32*) g_object_new (object_type, NULL);
	return self;
}


GeeBenchmarkReverseSortedInt32* gee_benchmark_reverse_sorted_int32_new (void) {
	return gee_benchmark_reverse_sorted_int32_construct (GEE_BENCHMARK_TYPE_REVERSE_SORTED_INT32);
}


static const gchar* gee_benchmark_reverse_sorted_int32_real_get_name (GeeBenchmarkGenerator* base) {
	const gchar* result;
	GeeBenchmarkReverseSortedInt32* self;
	self = (GeeBenchmarkReverseSortedInt32*) base;
	result = "ReverseSorted";
	return result;
}


static void gee_benchmark_reverse_sorted_int32_class_init (GeeBenchmarkReverseSortedInt32Class * klass) {
	gee_benchmark_reverse_sorted_int32_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->get_property = _vala_gee_benchmark_reverse_sorted_int32_get_property;
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_REVERSE_SORTED_INT32_NAME, g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
}


static void gee_benchmark_reverse_sorted_int32_gee_benchmark_generator_interface_init (GeeBenchmarkGeneratorIface * iface) {
	gee_benchmark_reverse_sorted_int32_gee_benchmark_generator_parent_iface = g_type_interface_peek_parent (iface);
	iface->generate_collection = (void (*)(GeeBenchmarkGenerator*, gint, GeeCollection*)) gee_benchmark_reverse_sorted_int32_real_generate_collection;
	iface->get_name = gee_benchmark_reverse_sorted_int32_real_get_name;
}


static void gee_benchmark_reverse_sorted_int32_instance_init (GeeBenchmarkReverseSortedInt32 * self) {
}


GType gee_benchmark_reverse_sorted_int32_get_type (void) {
	static volatile gsize gee_benchmark_reverse_sorted_int32_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_reverse_sorted_int32_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkReverseSortedInt32Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_benchmark_reverse_sorted_int32_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeBenchmarkReverseSortedInt32), 0, (GInstanceInitFunc) gee_benchmark_reverse_sorted_int32_instance_init, NULL };
		static const GInterfaceInfo gee_benchmark_generator_info = { (GInterfaceInitFunc) gee_benchmark_reverse_sorted_int32_gee_benchmark_generator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
		GType gee_benchmark_reverse_sorted_int32_type_id;
		gee_benchmark_reverse_sorted_int32_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeBenchmarkReverseSortedInt32", &g_define_type_info, 0);
		g_type_add_interface_static (gee_benchmark_reverse_sorted_int32_type_id, GEE_BENCHMARK_TYPE_GENERATOR, &gee_benchmark_generator_info);
		g_once_init_leave (&gee_benchmark_reverse_sorted_int32_type_id__volatile, gee_benchmark_reverse_sorted_int32_type_id);
	}
	return gee_benchmark_reverse_sorted_int32_type_id__volatile;
}


static void _vala_gee_benchmark_reverse_sorted_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	GeeBenchmarkReverseSortedInt32 * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_BENCHMARK_TYPE_REVERSE_SORTED_INT32, GeeBenchmarkReverseSortedInt32);
	switch (property_id) {
		case GEE_BENCHMARK_REVERSE_SORTED_INT32_NAME:
		g_value_set_string (value, gee_benchmark_generator_get_name ((GeeBenchmarkGenerator*) self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void gee_benchmark_sorted_int32_real_generate_collection (GeeBenchmarkGenerator* base, gint size, GeeCollection* collection) {
	GeeBenchmarkSortedInt32 * self;
	self = (GeeBenchmarkSortedInt32*) base;
	g_return_if_fail (collection != NULL);
	{
		gint i = 0;
		i = 0;
		{
			gboolean _tmp0_ = FALSE;
			_tmp0_ = TRUE;
			while (TRUE) {
				gboolean _tmp1_ = FALSE;
				gint _tmp3_ = 0;
				gint _tmp4_ = 0;
				GeeCollection* _tmp5_ = NULL;
				gint _tmp6_ = 0;
				_tmp1_ = _tmp0_;
				if (!_tmp1_) {
					gint _tmp2_ = 0;
					_tmp2_ = i;
					i = _tmp2_ + 1;
				}
				_tmp0_ = FALSE;
				_tmp3_ = i;
				_tmp4_ = size;
				if (!(_tmp3_ < _tmp4_)) {
					break;
				}
				_tmp5_ = collection;
				_tmp6_ = i;
				gee_collection_add (_tmp5_, (gpointer) ((gintptr) ((gint32) _tmp6_)));
			}
		}
	}
}


GeeBenchmarkSortedInt32* gee_benchmark_sorted_int32_construct (GType object_type) {
	GeeBenchmarkSortedInt32 * self = NULL;
	self = (GeeBenchmarkSortedInt32*) g_object_new (object_type, NULL);
	return self;
}


GeeBenchmarkSortedInt32* gee_benchmark_sorted_int32_new (void) {
	return gee_benchmark_sorted_int32_construct (GEE_BENCHMARK_TYPE_SORTED_INT32);
}


static const gchar* gee_benchmark_sorted_int32_real_get_name (GeeBenchmarkGenerator* base) {
	const gchar* result;
	GeeBenchmarkSortedInt32* self;
	self = (GeeBenchmarkSortedInt32*) base;
	result = "Sorted";
	return result;
}


static void gee_benchmark_sorted_int32_class_init (GeeBenchmarkSortedInt32Class * klass) {
	gee_benchmark_sorted_int32_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->get_property = _vala_gee_benchmark_sorted_int32_get_property;
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_SORTED_INT32_NAME, g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
}


static void gee_benchmark_sorted_int32_gee_benchmark_generator_interface_init (GeeBenchmarkGeneratorIface * iface) {
	gee_benchmark_sorted_int32_gee_benchmark_generator_parent_iface = g_type_interface_peek_parent (iface);
	iface->generate_collection = (void (*)(GeeBenchmarkGenerator*, gint, GeeCollection*)) gee_benchmark_sorted_int32_real_generate_collection;
	iface->get_name = gee_benchmark_sorted_int32_real_get_name;
}


static void gee_benchmark_sorted_int32_instance_init (GeeBenchmarkSortedInt32 * self) {
}


GType gee_benchmark_sorted_int32_get_type (void) {
	static volatile gsize gee_benchmark_sorted_int32_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_sorted_int32_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkSortedInt32Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_benchmark_sorted_int32_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeBenchmarkSortedInt32), 0, (GInstanceInitFunc) gee_benchmark_sorted_int32_instance_init, NULL };
		static const GInterfaceInfo gee_benchmark_generator_info = { (GInterfaceInitFunc) gee_benchmark_sorted_int32_gee_benchmark_generator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
		GType gee_benchmark_sorted_int32_type_id;
		gee_benchmark_sorted_int32_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeBenchmarkSortedInt32", &g_define_type_info, 0);
		g_type_add_interface_static (gee_benchmark_sorted_int32_type_id, GEE_BENCHMARK_TYPE_GENERATOR, &gee_benchmark_generator_info);
		g_once_init_leave (&gee_benchmark_sorted_int32_type_id__volatile, gee_benchmark_sorted_int32_type_id);
	}
	return gee_benchmark_sorted_int32_type_id__volatile;
}


static void _vala_gee_benchmark_sorted_int32_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	GeeBenchmarkSortedInt32 * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_BENCHMARK_TYPE_SORTED_INT32, GeeBenchmarkSortedInt32);
	switch (property_id) {
		case GEE_BENCHMARK_SORTED_INT32_NAME:
		g_value_set_string (value, gee_benchmark_generator_get_name ((GeeBenchmarkGenerator*) self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static GeeCollection* gee_benchmark_array_list_factory_real_create (GeeBenchmarkFactory* base) {
	GeeBenchmarkArrayListFactory * self;
	GeeCollection* result = NULL;
	GeeArrayList* _tmp0_ = NULL;
	self = (GeeBenchmarkArrayListFactory*) base;
	_tmp0_ = gee_array_list_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, NULL, NULL, NULL);
	result = (GeeCollection*) _tmp0_;
	return result;
}


static GeeCollection* gee_benchmark_array_list_factory_real_copy (GeeBenchmarkFactory* base, GeeCollection* collection) {
	GeeBenchmarkArrayListFactory * self;
	GeeCollection* result = NULL;
	GeeArrayList* copy = NULL;
	GeeArrayList* _tmp0_ = NULL;
	self = (GeeBenchmarkArrayListFactory*) base;
	g_return_val_if_fail (collection != NULL, NULL);
	_tmp0_ = gee_array_list_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, NULL, NULL, NULL);
	copy = _tmp0_;
	{
		GeeIterator* _item_it = NULL;
		GeeCollection* _tmp1_ = NULL;
		GeeIterator* _tmp2_ = NULL;
		_tmp1_ = collection;
		_tmp2_ = gee_iterable_iterator ((GeeIterable*) _tmp1_);
		_item_it = _tmp2_;
		while (TRUE) {
			GeeIterator* _tmp3_ = NULL;
			gboolean _tmp4_ = FALSE;
			gpointer item = NULL;
			GeeIterator* _tmp5_ = NULL;
			gpointer _tmp6_ = NULL;
			GeeArrayList* _tmp7_ = NULL;
			gconstpointer _tmp8_ = NULL;
			_tmp3_ = _item_it;
			_tmp4_ = gee_iterator_next (_tmp3_);
			if (!_tmp4_) {
				break;
			}
			_tmp5_ = _item_it;
			_tmp6_ = gee_iterator_get (_tmp5_);
			item = _tmp6_;
			_tmp7_ = copy;
			_tmp8_ = item;
			gee_abstract_collection_add ((GeeAbstractCollection*) _tmp7_, _tmp8_);
			((item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (item = (self->priv->g_destroy_func (item), NULL));
		}
		_g_object_unref0 (_item_it);
	}
	result = (GeeCollection*) copy;
	return result;
}


GeeBenchmarkArrayListFactory* gee_benchmark_array_list_factory_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func) {
	GeeBenchmarkArrayListFactory * self = NULL;
	self = (GeeBenchmarkArrayListFactory*) g_object_new (object_type, NULL);
	self->priv->g_type = g_type;
	self->priv->g_dup_func = g_dup_func;
	self->priv->g_destroy_func = g_destroy_func;
	return self;
}


GeeBenchmarkArrayListFactory* gee_benchmark_array_list_factory_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func) {
	return gee_benchmark_array_list_factory_construct (GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY, g_type, g_dup_func, g_destroy_func);
}


static void gee_benchmark_array_list_factory_class_init (GeeBenchmarkArrayListFactoryClass * klass) {
	gee_benchmark_array_list_factory_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (GeeBenchmarkArrayListFactoryPrivate));
	G_OBJECT_CLASS (klass)->get_property = _vala_gee_benchmark_array_list_factory_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_gee_benchmark_array_list_factory_set_property;
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_ARRAY_LIST_FACTORY_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_ARRAY_LIST_FACTORY_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_ARRAY_LIST_FACTORY_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
}


static void gee_benchmark_array_list_factory_gee_benchmark_factory_interface_init (GeeBenchmarkFactoryIface * iface) {
	gee_benchmark_array_list_factory_gee_benchmark_factory_parent_iface = g_type_interface_peek_parent (iface);
	iface->create = (GeeCollection* (*)(GeeBenchmarkFactory*)) gee_benchmark_array_list_factory_real_create;
	iface->copy = (GeeCollection* (*)(GeeBenchmarkFactory*, GeeCollection*)) gee_benchmark_array_list_factory_real_copy;
}


static void gee_benchmark_array_list_factory_instance_init (GeeBenchmarkArrayListFactory * self) {
	self->priv = GEE_BENCHMARK_ARRAY_LIST_FACTORY_GET_PRIVATE (self);
}


GType gee_benchmark_array_list_factory_get_type (void) {
	static volatile gsize gee_benchmark_array_list_factory_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_array_list_factory_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkArrayListFactoryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_benchmark_array_list_factory_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeBenchmarkArrayListFactory), 0, (GInstanceInitFunc) gee_benchmark_array_list_factory_instance_init, NULL };
		static const GInterfaceInfo gee_benchmark_factory_info = { (GInterfaceInitFunc) gee_benchmark_array_list_factory_gee_benchmark_factory_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
		GType gee_benchmark_array_list_factory_type_id;
		gee_benchmark_array_list_factory_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeBenchmarkArrayListFactory", &g_define_type_info, 0);
		g_type_add_interface_static (gee_benchmark_array_list_factory_type_id, GEE_BENCHMARK_TYPE_FACTORY, &gee_benchmark_factory_info);
		g_once_init_leave (&gee_benchmark_array_list_factory_type_id__volatile, gee_benchmark_array_list_factory_type_id);
	}
	return gee_benchmark_array_list_factory_type_id__volatile;
}


static void _vala_gee_benchmark_array_list_factory_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	GeeBenchmarkArrayListFactory * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY, GeeBenchmarkArrayListFactory);
	switch (property_id) {
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void _vala_gee_benchmark_array_list_factory_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
	GeeBenchmarkArrayListFactory * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_BENCHMARK_TYPE_ARRAY_LIST_FACTORY, GeeBenchmarkArrayListFactory);
	switch (property_id) {
		case GEE_BENCHMARK_ARRAY_LIST_FACTORY_G_TYPE:
		self->priv->g_type = g_value_get_gtype (value);
		break;
		case GEE_BENCHMARK_ARRAY_LIST_FACTORY_G_DUP_FUNC:
		self->priv->g_dup_func = g_value_get_pointer (value);
		break;
		case GEE_BENCHMARK_ARRAY_LIST_FACTORY_G_DESTROY_FUNC:
		self->priv->g_destroy_func = g_value_get_pointer (value);
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static gpointer _g_object_ref0 (gpointer self) {
	return self ? g_object_ref (self) : NULL;
}


static gint* _vala_array_dup1 (gint* self, int length) {
	return g_memdup (self, length * sizeof (gint));
}


GeeBenchmarkBenchmark* gee_benchmark_benchmark_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeBenchmarkFactory* factory, GeeList* algorithms, GeeList* generators, gint* sizes, int sizes_length1, gint iteration_count) {
	GeeBenchmarkBenchmark * self = NULL;
	GeeBenchmarkFactory* _tmp0_ = NULL;
	GeeBenchmarkFactory* _tmp1_ = NULL;
	GeeList* _tmp2_ = NULL;
	GeeList* _tmp3_ = NULL;
	gint* _tmp4_ = NULL;
	gint _tmp4__length1 = 0;
	gint* _tmp5_ = NULL;
	gint _tmp5__length1 = 0;
	GeeList* _tmp6_ = NULL;
	GeeList* _tmp7_ = NULL;
	gint _tmp8_ = 0;
	g_return_val_if_fail (factory != NULL, NULL);
	g_return_val_if_fail (algorithms != NULL, NULL);
	g_return_val_if_fail (generators != NULL, NULL);
	self = (GeeBenchmarkBenchmark*) g_object_new (object_type, NULL);
	self->priv->g_type = g_type;
	self->priv->g_dup_func = g_dup_func;
	self->priv->g_destroy_func = g_destroy_func;
	_tmp0_ = factory;
	_tmp1_ = _g_object_ref0 (_tmp0_);
	_g_object_unref0 (self->priv->factory);
	self->priv->factory = _tmp1_;
	_tmp2_ = algorithms;
	_tmp3_ = _g_object_ref0 (_tmp2_);
	_g_object_unref0 (self->priv->algorithms);
	self->priv->algorithms = _tmp3_;
	_tmp4_ = sizes;
	_tmp4__length1 = sizes_length1;
	_tmp5_ = (_tmp4_ != NULL) ? _vala_array_dup1 (_tmp4_, _tmp4__length1) : ((gpointer) _tmp4_);
	_tmp5__length1 = _tmp4__length1;
	self->priv->sizes = (g_free (self->priv->sizes), NULL);
	self->priv->sizes = _tmp5_;
	self->priv->sizes_length1 = _tmp5__length1;
	self->priv->_sizes_size_ = self->priv->sizes_length1;
	_tmp6_ = generators;
	_tmp7_ = _g_object_ref0 (_tmp6_);
	_g_object_unref0 (self->priv->generators);
	self->priv->generators = _tmp7_;
	_tmp8_ = iteration_count;
	self->priv->iteration_count = _tmp8_;
	return self;
}


GeeBenchmarkBenchmark* gee_benchmark_benchmark_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeBenchmarkFactory* factory, GeeList* algorithms, GeeList* generators, gint* sizes, int sizes_length1, gint iteration_count) {
	return gee_benchmark_benchmark_construct (GEE_BENCHMARK_TYPE_BENCHMARK, g_type, g_dup_func, g_destroy_func, factory, algorithms, generators, sizes, sizes_length1, iteration_count);
}


void gee_benchmark_benchmark_run (GeeBenchmarkBenchmark* self) {
	gint* _tmp0_ = NULL;
	gint _tmp0__length1 = 0;
	GeeList* _tmp1_ = NULL;
	gint _tmp2_ = 0;
	gint _tmp3_ = 0;
	GeeList* _tmp4_ = NULL;
	gint _tmp5_ = 0;
	gint _tmp6_ = 0;
	gdouble* _tmp7_ = NULL;
	gint* _tmp8_ = NULL;
	gint _tmp8__length1 = 0;
	GeeList* _tmp9_ = NULL;
	gint _tmp10_ = 0;
	gint _tmp11_ = 0;
	GeeList* _tmp12_ = NULL;
	gint _tmp13_ = 0;
	gint _tmp14_ = 0;
	gdouble* _tmp15_ = NULL;
	GTimer* timer = NULL;
	GTimer* _tmp45_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->priv->sizes;
	_tmp0__length1 = self->priv->sizes_length1;
	_tmp1_ = self->priv->generators;
	_tmp2_ = gee_collection_get_size ((GeeCollection*) _tmp1_);
	_tmp3_ = _tmp2_;
	_tmp4_ = self->priv->algorithms;
	_tmp5_ = gee_collection_get_size ((GeeCollection*) _tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = g_new0 (gdouble, (_tmp0__length1 * _tmp3_) * _tmp6_);
	self->priv->results_sum = (g_free (self->priv->results_sum), NULL);
	self->priv->results_sum = _tmp7_;
	self->priv->results_sum_length1 = _tmp0__length1;
	self->priv->results_sum_length2 = _tmp3_;
	self->priv->results_sum_length3 = _tmp6_;
	_tmp8_ = self->priv->sizes;
	_tmp8__length1 = self->priv->sizes_length1;
	_tmp9_ = self->priv->generators;
	_tmp10_ = gee_collection_get_size ((GeeCollection*) _tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = self->priv->algorithms;
	_tmp13_ = gee_collection_get_size ((GeeCollection*) _tmp12_);
	_tmp14_ = _tmp13_;
	_tmp15_ = g_new0 (gdouble, (_tmp8__length1 * _tmp11_) * _tmp14_);
	self->priv->results_squared_sum = (g_free (self->priv->results_squared_sum), NULL);
	self->priv->results_squared_sum = _tmp15_;
	self->priv->results_squared_sum_length1 = _tmp8__length1;
	self->priv->results_squared_sum_length2 = _tmp11_;
	self->priv->results_squared_sum_length3 = _tmp14_;
	{
		gint i = 0;
		i = 0;
		{
			gboolean _tmp16_ = FALSE;
			_tmp16_ = TRUE;
			while (TRUE) {
				gboolean _tmp17_ = FALSE;
				gint _tmp19_ = 0;
				gint* _tmp20_ = NULL;
				gint _tmp20__length1 = 0;
				_tmp17_ = _tmp16_;
				if (!_tmp17_) {
					gint _tmp18_ = 0;
					_tmp18_ = i;
					i = _tmp18_ + 1;
				}
				_tmp16_ = FALSE;
				_tmp19_ = i;
				_tmp20_ = self->priv->sizes;
				_tmp20__length1 = self->priv->sizes_length1;
				if (!(_tmp19_ < _tmp20__length1)) {
					break;
				}
				{
					gint j = 0;
					j = 0;
					{
						gboolean _tmp21_ = FALSE;
						_tmp21_ = TRUE;
						while (TRUE) {
							gboolean _tmp22_ = FALSE;
							gint _tmp24_ = 0;
							GeeList* _tmp25_ = NULL;
							gint _tmp26_ = 0;
							gint _tmp27_ = 0;
							_tmp22_ = _tmp21_;
							if (!_tmp22_) {
								gint _tmp23_ = 0;
								_tmp23_ = j;
								j = _tmp23_ + 1;
							}
							_tmp21_ = FALSE;
							_tmp24_ = j;
							_tmp25_ = self->priv->generators;
							_tmp26_ = gee_collection_get_size ((GeeCollection*) _tmp25_);
							_tmp27_ = _tmp26_;
							if (!(_tmp24_ < _tmp27_)) {
								break;
							}
							{
								gint k = 0;
								k = 0;
								{
									gboolean _tmp28_ = FALSE;
									_tmp28_ = TRUE;
									while (TRUE) {
										gboolean _tmp29_ = FALSE;
										gint _tmp31_ = 0;
										GeeList* _tmp32_ = NULL;
										gint _tmp33_ = 0;
										gint _tmp34_ = 0;
										gdouble* _tmp35_ = NULL;
										gint _tmp35__length1 = 0;
										gint _tmp35__length2 = 0;
										gint _tmp35__length3 = 0;
										gint _tmp36_ = 0;
										gint _tmp37_ = 0;
										gint _tmp38_ = 0;
										gdouble _tmp39_ = 0.0;
										gdouble* _tmp40_ = NULL;
										gint _tmp40__length1 = 0;
										gint _tmp40__length2 = 0;
										gint _tmp40__length3 = 0;
										gint _tmp41_ = 0;
										gint _tmp42_ = 0;
										gint _tmp43_ = 0;
										gdouble _tmp44_ = 0.0;
										_tmp29_ = _tmp28_;
										if (!_tmp29_) {
											gint _tmp30_ = 0;
											_tmp30_ = k;
											k = _tmp30_ + 1;
										}
										_tmp28_ = FALSE;
										_tmp31_ = k;
										_tmp32_ = self->priv->algorithms;
										_tmp33_ = gee_collection_get_size ((GeeCollection*) _tmp32_);
										_tmp34_ = _tmp33_;
										if (!(_tmp31_ < _tmp34_)) {
											break;
										}
										_tmp35_ = self->priv->results_sum;
										_tmp35__length1 = self->priv->results_sum_length1;
										_tmp35__length2 = self->priv->results_sum_length2;
										_tmp35__length3 = self->priv->results_sum_length3;
										_tmp36_ = i;
										_tmp37_ = j;
										_tmp38_ = k;
										_tmp35_[(((_tmp36_ * _tmp35__length2) + _tmp37_) * _tmp35__length3) + _tmp38_] = (gdouble) 0;
										_tmp39_ = _tmp35_[(((_tmp36_ * _tmp35__length2) + _tmp37_) * _tmp35__length3) + _tmp38_];
										_tmp40_ = self->priv->results_squared_sum;
										_tmp40__length1 = self->priv->results_squared_sum_length1;
										_tmp40__length2 = self->priv->results_squared_sum_length2;
										_tmp40__length3 = self->priv->results_squared_sum_length3;
										_tmp41_ = i;
										_tmp42_ = j;
										_tmp43_ = k;
										_tmp40_[(((_tmp41_ * _tmp40__length2) + _tmp42_) * _tmp40__length3) + _tmp43_] = (gdouble) 0;
										_tmp44_ = _tmp40_[(((_tmp41_ * _tmp40__length2) + _tmp42_) * _tmp40__length3) + _tmp43_];
									}
								}
							}
						}
					}
				}
			}
		}
	}
	_tmp45_ = g_timer_new ();
	timer = _tmp45_;
	{
		gint iteration = 0;
		iteration = 1;
		{
			gboolean _tmp46_ = FALSE;
			_tmp46_ = TRUE;
			while (TRUE) {
				gboolean _tmp47_ = FALSE;
				gint _tmp49_ = 0;
				gint _tmp50_ = 0;
				gint _tmp107_ = 0;
				FILE* _tmp110_ = NULL;
				gint _tmp111_ = 0;
				_tmp47_ = _tmp46_;
				if (!_tmp47_) {
					gint _tmp48_ = 0;
					_tmp48_ = iteration;
					iteration = _tmp48_ + 1;
				}
				_tmp46_ = FALSE;
				_tmp49_ = iteration;
				_tmp50_ = self->priv->iteration_count;
				if (!(_tmp49_ <= _tmp50_)) {
					break;
				}
				{
					gint i = 0;
					i = 0;
					{
						gboolean _tmp51_ = FALSE;
						_tmp51_ = TRUE;
						while (TRUE) {
							gboolean _tmp52_ = FALSE;
							gint _tmp54_ = 0;
							gint* _tmp55_ = NULL;
							gint _tmp55__length1 = 0;
							gint size = 0;
							gint* _tmp56_ = NULL;
							gint _tmp56__length1 = 0;
							gint _tmp57_ = 0;
							gint _tmp58_ = 0;
							_tmp52_ = _tmp51_;
							if (!_tmp52_) {
								gint _tmp53_ = 0;
								_tmp53_ = i;
								i = _tmp53_ + 1;
							}
							_tmp51_ = FALSE;
							_tmp54_ = i;
							_tmp55_ = self->priv->sizes;
							_tmp55__length1 = self->priv->sizes_length1;
							if (!(_tmp54_ < _tmp55__length1)) {
								break;
							}
							_tmp56_ = self->priv->sizes;
							_tmp56__length1 = self->priv->sizes_length1;
							_tmp57_ = i;
							_tmp58_ = _tmp56_[_tmp57_];
							size = _tmp58_;
							{
								gint j = 0;
								j = 0;
								{
									gboolean _tmp59_ = FALSE;
									_tmp59_ = TRUE;
									while (TRUE) {
										gboolean _tmp60_ = FALSE;
										gint _tmp62_ = 0;
										GeeList* _tmp63_ = NULL;
										gint _tmp64_ = 0;
										gint _tmp65_ = 0;
										GeeCollection* collection = NULL;
										GeeBenchmarkFactory* _tmp66_ = NULL;
										GeeCollection* _tmp67_ = NULL;
										GeeList* _tmp68_ = NULL;
										gint _tmp69_ = 0;
										gpointer _tmp70_ = NULL;
										GeeBenchmarkGenerator* _tmp71_ = NULL;
										gint _tmp72_ = 0;
										GeeCollection* _tmp73_ = NULL;
										_tmp60_ = _tmp59_;
										if (!_tmp60_) {
											gint _tmp61_ = 0;
											_tmp61_ = j;
											j = _tmp61_ + 1;
										}
										_tmp59_ = FALSE;
										_tmp62_ = j;
										_tmp63_ = self->priv->generators;
										_tmp64_ = gee_collection_get_size ((GeeCollection*) _tmp63_);
										_tmp65_ = _tmp64_;
										if (!(_tmp62_ < _tmp65_)) {
											break;
										}
										_tmp66_ = self->priv->factory;
										_tmp67_ = gee_benchmark_factory_create (_tmp66_);
										collection = _tmp67_;
										_tmp68_ = self->priv->generators;
										_tmp69_ = j;
										_tmp70_ = gee_list_get (_tmp68_, _tmp69_);
										_tmp71_ = (GeeBenchmarkGenerator*) _tmp70_;
										_tmp72_ = size;
										_tmp73_ = collection;
										gee_benchmark_generator_generate_collection (_tmp71_, _tmp72_, _tmp73_);
										_g_object_unref0 (_tmp71_);
										{
											gint k = 0;
											k = 0;
											{
												gboolean _tmp74_ = FALSE;
												_tmp74_ = TRUE;
												while (TRUE) {
													gboolean _tmp75_ = FALSE;
													gint _tmp77_ = 0;
													GeeList* _tmp78_ = NULL;
													gint _tmp79_ = 0;
													gint _tmp80_ = 0;
													GeeCollection* copy = NULL;
													GeeBenchmarkFactory* _tmp81_ = NULL;
													GeeCollection* _tmp82_ = NULL;
													GeeCollection* _tmp83_ = NULL;
													GTimer* _tmp84_ = NULL;
													GTimer* _tmp85_ = NULL;
													GeeList* _tmp86_ = NULL;
													gint _tmp87_ = 0;
													gpointer _tmp88_ = NULL;
													GeeBenchmarkAlgorithm* _tmp89_ = NULL;
													GeeCollection* _tmp90_ = NULL;
													GTimer* _tmp91_ = NULL;
													gdouble elapsed = 0.0;
													GTimer* _tmp92_ = NULL;
													gdouble _tmp93_ = 0.0;
													gdouble* _tmp94_ = NULL;
													gint _tmp94__length1 = 0;
													gint _tmp94__length2 = 0;
													gint _tmp94__length3 = 0;
													gint _tmp95_ = 0;
													gint _tmp96_ = 0;
													gint _tmp97_ = 0;
													gdouble _tmp98_ = 0.0;
													gdouble _tmp99_ = 0.0;
													gdouble* _tmp100_ = NULL;
													gint _tmp100__length1 = 0;
													gint _tmp100__length2 = 0;
													gint _tmp100__length3 = 0;
													gint _tmp101_ = 0;
													gint _tmp102_ = 0;
													gint _tmp103_ = 0;
													gdouble _tmp104_ = 0.0;
													gdouble _tmp105_ = 0.0;
													gdouble _tmp106_ = 0.0;
													_tmp75_ = _tmp74_;
													if (!_tmp75_) {
														gint _tmp76_ = 0;
														_tmp76_ = k;
														k = _tmp76_ + 1;
													}
													_tmp74_ = FALSE;
													_tmp77_ = k;
													_tmp78_ = self->priv->algorithms;
													_tmp79_ = gee_collection_get_size ((GeeCollection*) _tmp78_);
													_tmp80_ = _tmp79_;
													if (!(_tmp77_ < _tmp80_)) {
														break;
													}
													_tmp81_ = self->priv->factory;
													_tmp82_ = collection;
													_tmp83_ = gee_benchmark_factory_copy (_tmp81_, _tmp82_);
													copy = _tmp83_;
													_tmp84_ = timer;
													g_timer_reset (_tmp84_);
													_tmp85_ = timer;
													g_timer_start (_tmp85_);
													_tmp86_ = self->priv->algorithms;
													_tmp87_ = k;
													_tmp88_ = gee_list_get (_tmp86_, _tmp87_);
													_tmp89_ = (GeeBenchmarkAlgorithm*) _tmp88_;
													_tmp90_ = copy;
													gee_benchmark_algorithm_process_collection (_tmp89_, _tmp90_);
													_g_object_unref0 (_tmp89_);
													_tmp91_ = timer;
													g_timer_stop (_tmp91_);
													_tmp92_ = timer;
													_tmp93_ = g_timer_elapsed (_tmp92_, NULL);
													elapsed = _tmp93_;
													_tmp94_ = self->priv->results_sum;
													_tmp94__length1 = self->priv->results_sum_length1;
													_tmp94__length2 = self->priv->results_sum_length2;
													_tmp94__length3 = self->priv->results_sum_length3;
													_tmp95_ = i;
													_tmp96_ = j;
													_tmp97_ = k;
													_tmp98_ = elapsed;
													_tmp94_[(((_tmp95_ * _tmp94__length2) + _tmp96_) * _tmp94__length3) + _tmp97_] += _tmp98_;
													_tmp99_ = _tmp94_[(((_tmp95_ * _tmp94__length2) + _tmp96_) * _tmp94__length3) + _tmp97_];
													_tmp100_ = self->priv->results_squared_sum;
													_tmp100__length1 = self->priv->results_squared_sum_length1;
													_tmp100__length2 = self->priv->results_squared_sum_length2;
													_tmp100__length3 = self->priv->results_squared_sum_length3;
													_tmp101_ = i;
													_tmp102_ = j;
													_tmp103_ = k;
													_tmp104_ = elapsed;
													_tmp105_ = pow (_tmp104_, (gdouble) 2);
													_tmp100_[(((_tmp101_ * _tmp100__length2) + _tmp102_) * _tmp100__length3) + _tmp103_] += _tmp105_;
													_tmp106_ = _tmp100_[(((_tmp101_ * _tmp100__length2) + _tmp102_) * _tmp100__length3) + _tmp103_];
													_g_object_unref0 (copy);
												}
											}
										}
										_g_object_unref0 (collection);
									}
								}
							}
						}
					}
				}
				_tmp107_ = iteration;
				if ((_tmp107_ % 10) == 0) {
					FILE* _tmp108_ = NULL;
					_tmp108_ = stdout;
					fprintf (_tmp108_, "|");
				} else {
					FILE* _tmp109_ = NULL;
					_tmp109_ = stdout;
					fprintf (_tmp109_, "*");
				}
				_tmp110_ = stdout;
				fflush (_tmp110_);
				_tmp111_ = iteration;
				if ((_tmp111_ % 100) == 0) {
					FILE* _tmp112_ = NULL;
					gint _tmp113_ = 0;
					_tmp112_ = stdout;
					fprintf (_tmp112_, "\n\n");
					_tmp113_ = iteration;
					gee_benchmark_benchmark_display_results (self, _tmp113_);
				}
			}
		}
	}
	_g_timer_destroy0 (timer);
}


void gee_benchmark_benchmark_display_results (GeeBenchmarkBenchmark* self, gint iteration) {
	FILE* _tmp0_ = NULL;
	gint _tmp1_ = 0;
	FILE* _tmp70_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = stdout;
	_tmp1_ = iteration;
	fprintf (_tmp0_, "After %d iterations: (average [sample standard deviation] in seconds)\n" \
"\n", _tmp1_);
	{
		gint i = 0;
		i = 0;
		{
			gboolean _tmp2_ = FALSE;
			_tmp2_ = TRUE;
			while (TRUE) {
				gboolean _tmp3_ = FALSE;
				gint _tmp5_ = 0;
				gint* _tmp6_ = NULL;
				gint _tmp6__length1 = 0;
				FILE* _tmp7_ = NULL;
				gint* _tmp8_ = NULL;
				gint _tmp8__length1 = 0;
				gint _tmp9_ = 0;
				gint _tmp10_ = 0;
				FILE* _tmp11_ = NULL;
				FILE* _tmp26_ = NULL;
				FILE* _tmp69_ = NULL;
				_tmp3_ = _tmp2_;
				if (!_tmp3_) {
					gint _tmp4_ = 0;
					_tmp4_ = i;
					i = _tmp4_ + 1;
				}
				_tmp2_ = FALSE;
				_tmp5_ = i;
				_tmp6_ = self->priv->sizes;
				_tmp6__length1 = self->priv->sizes_length1;
				if (!(_tmp5_ < _tmp6__length1)) {
					break;
				}
				_tmp7_ = stdout;
				_tmp8_ = self->priv->sizes;
				_tmp8__length1 = self->priv->sizes_length1;
				_tmp9_ = i;
				_tmp10_ = _tmp8_[_tmp9_];
				fprintf (_tmp7_, "%d elements:\n", _tmp10_);
				_tmp11_ = stdout;
				fprintf (_tmp11_, "%20s\t", "");
				{
					gint k = 0;
					k = 0;
					{
						gboolean _tmp12_ = FALSE;
						_tmp12_ = TRUE;
						while (TRUE) {
							gboolean _tmp13_ = FALSE;
							gint _tmp15_ = 0;
							GeeList* _tmp16_ = NULL;
							gint _tmp17_ = 0;
							gint _tmp18_ = 0;
							FILE* _tmp19_ = NULL;
							GeeList* _tmp20_ = NULL;
							gint _tmp21_ = 0;
							gpointer _tmp22_ = NULL;
							GeeBenchmarkAlgorithm* _tmp23_ = NULL;
							const gchar* _tmp24_ = NULL;
							const gchar* _tmp25_ = NULL;
							_tmp13_ = _tmp12_;
							if (!_tmp13_) {
								gint _tmp14_ = 0;
								_tmp14_ = k;
								k = _tmp14_ + 1;
							}
							_tmp12_ = FALSE;
							_tmp15_ = k;
							_tmp16_ = self->priv->algorithms;
							_tmp17_ = gee_collection_get_size ((GeeCollection*) _tmp16_);
							_tmp18_ = _tmp17_;
							if (!(_tmp15_ < _tmp18_)) {
								break;
							}
							_tmp19_ = stdout;
							_tmp20_ = self->priv->algorithms;
							_tmp21_ = k;
							_tmp22_ = gee_list_get (_tmp20_, _tmp21_);
							_tmp23_ = (GeeBenchmarkAlgorithm*) _tmp22_;
							_tmp24_ = gee_benchmark_algorithm_get_name (_tmp23_);
							_tmp25_ = _tmp24_;
							fprintf (_tmp19_, "%-20s\t", _tmp25_);
							_g_object_unref0 (_tmp23_);
						}
					}
				}
				_tmp26_ = stdout;
				fprintf (_tmp26_, "\n");
				{
					gint j = 0;
					j = 0;
					{
						gboolean _tmp27_ = FALSE;
						_tmp27_ = TRUE;
						while (TRUE) {
							gboolean _tmp28_ = FALSE;
							gint _tmp30_ = 0;
							GeeList* _tmp31_ = NULL;
							gint _tmp32_ = 0;
							gint _tmp33_ = 0;
							FILE* _tmp34_ = NULL;
							GeeList* _tmp35_ = NULL;
							gint _tmp36_ = 0;
							gpointer _tmp37_ = NULL;
							GeeBenchmarkGenerator* _tmp38_ = NULL;
							const gchar* _tmp39_ = NULL;
							const gchar* _tmp40_ = NULL;
							FILE* _tmp68_ = NULL;
							_tmp28_ = _tmp27_;
							if (!_tmp28_) {
								gint _tmp29_ = 0;
								_tmp29_ = j;
								j = _tmp29_ + 1;
							}
							_tmp27_ = FALSE;
							_tmp30_ = j;
							_tmp31_ = self->priv->generators;
							_tmp32_ = gee_collection_get_size ((GeeCollection*) _tmp31_);
							_tmp33_ = _tmp32_;
							if (!(_tmp30_ < _tmp33_)) {
								break;
							}
							_tmp34_ = stdout;
							_tmp35_ = self->priv->generators;
							_tmp36_ = j;
							_tmp37_ = gee_list_get (_tmp35_, _tmp36_);
							_tmp38_ = (GeeBenchmarkGenerator*) _tmp37_;
							_tmp39_ = gee_benchmark_generator_get_name (_tmp38_);
							_tmp40_ = _tmp39_;
							fprintf (_tmp34_, "%20s\t", _tmp40_);
							_g_object_unref0 (_tmp38_);
							{
								gint k = 0;
								k = 0;
								{
									gboolean _tmp41_ = FALSE;
									_tmp41_ = TRUE;
									while (TRUE) {
										gboolean _tmp42_ = FALSE;
										gint _tmp44_ = 0;
										GeeList* _tmp45_ = NULL;
										gint _tmp46_ = 0;
										gint _tmp47_ = 0;
										gdouble average = 0.0;
										gdouble* _tmp48_ = NULL;
										gint _tmp48__length1 = 0;
										gint _tmp48__length2 = 0;
										gint _tmp48__length3 = 0;
										gint _tmp49_ = 0;
										gint _tmp50_ = 0;
										gint _tmp51_ = 0;
										gdouble _tmp52_ = 0.0;
										gint _tmp53_ = 0;
										gdouble squared_deviation = 0.0;
										gdouble* _tmp54_ = NULL;
										gint _tmp54__length1 = 0;
										gint _tmp54__length2 = 0;
										gint _tmp54__length3 = 0;
										gint _tmp55_ = 0;
										gint _tmp56_ = 0;
										gint _tmp57_ = 0;
										gdouble _tmp58_ = 0.0;
										gint _tmp59_ = 0;
										gdouble _tmp60_ = 0.0;
										gdouble _tmp61_ = 0.0;
										gint _tmp62_ = 0;
										gdouble deviation = 0.0;
										gdouble _tmp63_ = 0.0;
										gdouble _tmp64_ = 0.0;
										FILE* _tmp65_ = NULL;
										gdouble _tmp66_ = 0.0;
										gdouble _tmp67_ = 0.0;
										_tmp42_ = _tmp41_;
										if (!_tmp42_) {
											gint _tmp43_ = 0;
											_tmp43_ = k;
											k = _tmp43_ + 1;
										}
										_tmp41_ = FALSE;
										_tmp44_ = k;
										_tmp45_ = self->priv->algorithms;
										_tmp46_ = gee_collection_get_size ((GeeCollection*) _tmp45_);
										_tmp47_ = _tmp46_;
										if (!(_tmp44_ < _tmp47_)) {
											break;
										}
										_tmp48_ = self->priv->results_sum;
										_tmp48__length1 = self->priv->results_sum_length1;
										_tmp48__length2 = self->priv->results_sum_length2;
										_tmp48__length3 = self->priv->results_sum_length3;
										_tmp49_ = i;
										_tmp50_ = j;
										_tmp51_ = k;
										_tmp52_ = _tmp48_[(((_tmp49_ * _tmp48__length2) + _tmp50_) * _tmp48__length3) + _tmp51_];
										_tmp53_ = iteration;
										average = _tmp52_ / _tmp53_;
										_tmp54_ = self->priv->results_squared_sum;
										_tmp54__length1 = self->priv->results_squared_sum_length1;
										_tmp54__length2 = self->priv->results_squared_sum_length2;
										_tmp54__length3 = self->priv->results_squared_sum_length3;
										_tmp55_ = i;
										_tmp56_ = j;
										_tmp57_ = k;
										_tmp58_ = _tmp54_[(((_tmp55_ * _tmp54__length2) + _tmp56_) * _tmp54__length3) + _tmp57_];
										_tmp59_ = iteration;
										_tmp60_ = average;
										_tmp61_ = pow (_tmp60_, (gdouble) 2);
										_tmp62_ = iteration;
										squared_deviation = (_tmp58_ - (((gdouble) _tmp59_) * _tmp61_)) / (_tmp62_ - 1);
										_tmp63_ = squared_deviation;
										_tmp64_ = sqrt (_tmp63_);
										deviation = _tmp64_;
										_tmp65_ = stdout;
										_tmp66_ = average;
										_tmp67_ = deviation;
										fprintf (_tmp65_, "%8f [%8f] \t", _tmp66_, _tmp67_);
									}
								}
							}
							_tmp68_ = stdout;
							fprintf (_tmp68_, "\n");
						}
					}
				}
				_tmp69_ = stdout;
				fprintf (_tmp69_, "\n");
			}
		}
	}
	_tmp70_ = stdout;
	fprintf (_tmp70_, "\n\n");
}


static void gee_benchmark_benchmark_class_init (GeeBenchmarkBenchmarkClass * klass) {
	gee_benchmark_benchmark_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (GeeBenchmarkBenchmarkPrivate));
	G_OBJECT_CLASS (klass)->get_property = _vala_gee_benchmark_benchmark_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_gee_benchmark_benchmark_set_property;
	G_OBJECT_CLASS (klass)->finalize = gee_benchmark_benchmark_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_BENCHMARK_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_BENCHMARK_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_BENCHMARK_BENCHMARK_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
}


static void gee_benchmark_benchmark_instance_init (GeeBenchmarkBenchmark * self) {
	self->priv = GEE_BENCHMARK_BENCHMARK_GET_PRIVATE (self);
}


static void gee_benchmark_benchmark_finalize (GObject* obj) {
	GeeBenchmarkBenchmark * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_BENCHMARK_TYPE_BENCHMARK, GeeBenchmarkBenchmark);
	_g_object_unref0 (self->priv->factory);
	self->priv->sizes = (g_free (self->priv->sizes), NULL);
	_g_object_unref0 (self->priv->generators);
	_g_object_unref0 (self->priv->algorithms);
	self->priv->results_sum = (g_free (self->priv->results_sum), NULL);
	self->priv->results_squared_sum = (g_free (self->priv->results_squared_sum), NULL);
	G_OBJECT_CLASS (gee_benchmark_benchmark_parent_class)->finalize (obj);
}


GType gee_benchmark_benchmark_get_type (void) {
	static volatile gsize gee_benchmark_benchmark_type_id__volatile = 0;
	if (g_once_init_enter (&gee_benchmark_benchmark_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (GeeBenchmarkBenchmarkClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_benchmark_benchmark_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeBenchmarkBenchmark), 0, (GInstanceInitFunc) gee_benchmark_benchmark_instance_init, NULL };
		GType gee_benchmark_benchmark_type_id;
		gee_benchmark_benchmark_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeBenchmarkBenchmark", &g_define_type_info, 0);
		g_once_init_leave (&gee_benchmark_benchmark_type_id__volatile, gee_benchmark_benchmark_type_id);
	}
	return gee_benchmark_benchmark_type_id__volatile;
}


static void _vala_gee_benchmark_benchmark_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	GeeBenchmarkBenchmark * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_BENCHMARK_TYPE_BENCHMARK, GeeBenchmarkBenchmark);
	switch (property_id) {
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void _vala_gee_benchmark_benchmark_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
	GeeBenchmarkBenchmark * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_BENCHMARK_TYPE_BENCHMARK, GeeBenchmarkBenchmark);
	switch (property_id) {
		case GEE_BENCHMARK_BENCHMARK_G_TYPE:
		self->priv->g_type = g_value_get_gtype (value);
		break;
		case GEE_BENCHMARK_BENCHMARK_G_DUP_FUNC:
		self->priv->g_dup_func = g_value_get_pointer (value);
		break;
		case GEE_BENCHMARK_BENCHMARK_G_DESTROY_FUNC:
		self->priv->g_destroy_func = g_value_get_pointer (value);
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}



