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

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

#define TYPE_ASCII_ART_BENCHMARK (ascii_art_benchmark_get_type ())
#define ASCII_ART_BENCHMARK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ASCII_ART_BENCHMARK, AsciiArtBenchmark))
#define ASCII_ART_BENCHMARK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ASCII_ART_BENCHMARK, AsciiArtBenchmarkClass))
#define IS_ASCII_ART_BENCHMARK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ASCII_ART_BENCHMARK))
#define IS_ASCII_ART_BENCHMARK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ASCII_ART_BENCHMARK))
#define ASCII_ART_BENCHMARK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ASCII_ART_BENCHMARK, AsciiArtBenchmarkClass))

typedef struct _AsciiArtBenchmark AsciiArtBenchmark;
typedef struct _AsciiArtBenchmarkClass AsciiArtBenchmarkClass;
typedef struct _AsciiArtBenchmarkPrivate AsciiArtBenchmarkPrivate;
enum  {
	ASCII_ART_BENCHMARK_0_PROPERTY,
	ASCII_ART_BENCHMARK_NUM_PROPERTIES
};
static GParamSpec* ascii_art_benchmark_properties[ASCII_ART_BENCHMARK_NUM_PROPERTIES];
#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))

struct _AsciiArtBenchmark {
	GObject parent_instance;
	AsciiArtBenchmarkPrivate * priv;
};

struct _AsciiArtBenchmarkClass {
	GObjectClass parent_class;
};

static gpointer ascii_art_benchmark_parent_class = NULL;

GType ascii_art_benchmark_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (AsciiArtBenchmark, g_object_unref)
void ascii_art_benchmark_benchmark (AsciiArtBenchmark* self);
static void ascii_art_benchmark_main (void);
AsciiArtBenchmark* ascii_art_benchmark_new (void);
AsciiArtBenchmark* ascii_art_benchmark_construct (GType object_type);
static GType ascii_art_benchmark_get_type_once (void);

static glong
string_strnlen (gchar* str,
                glong maxlen)
{
	gchar* end = NULL;
	gchar* _tmp0_;
	gchar* _tmp1_;
	glong result = 0L;
	_tmp0_ = memchr (str, 0, (gsize) maxlen);
	end = _tmp0_;
	_tmp1_ = end;
	if (_tmp1_ == NULL) {
		result = maxlen;
		return result;
	} else {
		gchar* _tmp2_;
		_tmp2_ = end;
		result = (glong) (_tmp2_ - str);
		return result;
	}
}

static gchar*
string_substring (const gchar* self,
                  glong offset,
                  glong len)
{
	glong string_length = 0L;
	gboolean _tmp0_ = FALSE;
	gchar* _tmp3_;
	gchar* result = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	if (offset >= ((glong) 0)) {
		_tmp0_ = len >= ((glong) 0);
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		string_length = string_strnlen ((gchar*) self, offset + len);
	} else {
		gint _tmp1_;
		gint _tmp2_;
		_tmp1_ = strlen (self);
		_tmp2_ = _tmp1_;
		string_length = (glong) _tmp2_;
	}
	if (offset < ((glong) 0)) {
		offset = string_length + offset;
		g_return_val_if_fail (offset >= ((glong) 0), NULL);
	} else {
		g_return_val_if_fail (offset <= string_length, NULL);
	}
	if (len < ((glong) 0)) {
		len = string_length - offset;
	}
	g_return_val_if_fail ((offset + len) <= string_length, NULL);
	_tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
	result = _tmp3_;
	return result;
}

void
ascii_art_benchmark_benchmark (AsciiArtBenchmark* self)
{
	gint x = 0;
	gint y = 0;
	gint i = 0;
	gfloat a = 0.0F;
	gfloat b = 0.0F;
	gfloat ca = 0.0F;
	gfloat cb = 0.0F;
	gfloat t = 0.0F;
	gchar* c = NULL;
	gchar* _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = g_strdup ("0123456789ABCDEF ");
	c = _tmp0_;
	{
		gboolean _tmp1_ = FALSE;
		y = -12;
		_tmp1_ = TRUE;
		while (TRUE) {
			FILE* _tmp11_;
			if (!_tmp1_) {
				gint _tmp2_;
				_tmp2_ = y;
				y = _tmp2_ + 1;
			}
			_tmp1_ = FALSE;
			if (!(y <= 12)) {
				break;
			}
			{
				gboolean _tmp3_ = FALSE;
				x = -39;
				_tmp3_ = TRUE;
				while (TRUE) {
					FILE* _tmp7_;
					const gchar* _tmp8_;
					gchar* _tmp9_;
					gchar* _tmp10_;
					if (!_tmp3_) {
						gint _tmp4_;
						_tmp4_ = x;
						x = _tmp4_ + 1;
					}
					_tmp3_ = FALSE;
					if (!(x <= 39)) {
						break;
					}
					ca = x * 0.0458f;
					a = ca;
					cb = y * 0.08333f;
					b = cb;
					{
						gboolean _tmp5_ = FALSE;
						i = 0;
						_tmp5_ = TRUE;
						while (TRUE) {
							if (!_tmp5_) {
								gint _tmp6_;
								_tmp6_ = i;
								i = _tmp6_ + 1;
							}
							_tmp5_ = FALSE;
							if (!(i <= 15)) {
								break;
							}
							t = ((a * a) - (b * b)) + ca;
							b = ((2 * a) * b) + cb;
							a = t;
							if (((a * a) + (b * b)) > ((gfloat) 4)) {
								break;
							}
						}
					}
					_tmp7_ = stdout;
					_tmp8_ = c;
					_tmp9_ = string_substring (_tmp8_, (glong) i, (glong) 1);
					_tmp10_ = _tmp9_;
					fprintf (_tmp7_, "%s", _tmp10_);
					_g_free0 (_tmp10_);
				}
			}
			_tmp11_ = stdout;
			fprintf (_tmp11_, "\n");
		}
	}
	_g_free0 (c);
}

static void
ascii_art_benchmark_main (void)
{
	AsciiArtBenchmark* test = NULL;
	AsciiArtBenchmark* _tmp0_;
	_tmp0_ = ascii_art_benchmark_new ();
	test = _tmp0_;
	ascii_art_benchmark_benchmark (test);
	_g_object_unref0 (test);
}

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

AsciiArtBenchmark*
ascii_art_benchmark_construct (GType object_type)
{
	AsciiArtBenchmark * self = NULL;
	self = (AsciiArtBenchmark*) g_object_new (object_type, NULL);
	return self;
}

AsciiArtBenchmark*
ascii_art_benchmark_new (void)
{
	return ascii_art_benchmark_construct (TYPE_ASCII_ART_BENCHMARK);
}

static void
ascii_art_benchmark_class_init (AsciiArtBenchmarkClass * klass,
                                gpointer klass_data)
{
	ascii_art_benchmark_parent_class = g_type_class_peek_parent (klass);
}

static void
ascii_art_benchmark_instance_init (AsciiArtBenchmark * self,
                                   gpointer klass)
{
}

static GType
ascii_art_benchmark_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (AsciiArtBenchmarkClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ascii_art_benchmark_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (AsciiArtBenchmark), 0, (GInstanceInitFunc) ascii_art_benchmark_instance_init, NULL };
	GType ascii_art_benchmark_type_id;
	ascii_art_benchmark_type_id = g_type_register_static (G_TYPE_OBJECT, "AsciiArtBenchmark", &g_define_type_info, 0);
	return ascii_art_benchmark_type_id;
}

GType
ascii_art_benchmark_get_type (void)
{
	static volatile gsize ascii_art_benchmark_type_id__volatile = 0;
	if (g_once_init_enter (&ascii_art_benchmark_type_id__volatile)) {
		GType ascii_art_benchmark_type_id;
		ascii_art_benchmark_type_id = ascii_art_benchmark_get_type_once ();
		g_once_init_leave (&ascii_art_benchmark_type_id__volatile, ascii_art_benchmark_type_id);
	}
	return ascii_art_benchmark_type_id__volatile;
}