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


#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <gst/gst.h>
#include <stdio.h>
#include <gobject/gvaluecollector.h>


#define TYPE_AUDIO_MIXER (audio_mixer_get_type ())
#define AUDIO_MIXER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_AUDIO_MIXER, AudioMixer))
#define AUDIO_MIXER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_AUDIO_MIXER, AudioMixerClass))
#define IS_AUDIO_MIXER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_AUDIO_MIXER))
#define IS_AUDIO_MIXER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_AUDIO_MIXER))
#define AUDIO_MIXER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_AUDIO_MIXER, AudioMixerClass))

typedef struct _AudioMixer AudioMixer;
typedef struct _AudioMixerClass AudioMixerClass;
typedef struct _AudioMixerPrivate AudioMixerPrivate;
#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL)))
#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL)))
#define _gst_structure_free0(var) ((var == NULL) ? NULL : (var = (gst_structure_free (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
typedef struct _ParamSpecAudioMixer ParamSpecAudioMixer;
#define _audio_mixer_unref0(var) ((var == NULL) ? NULL : (var = (audio_mixer_unref (var), NULL)))

struct _AudioMixer {
	GTypeInstance parent_instance;
	volatile int ref_count;
	AudioMixerPrivate * priv;
};

struct _AudioMixerClass {
	GTypeClass parent_class;
	void (*finalize) (AudioMixer *self);
};

struct _AudioMixerPrivate {
	char* master_file;
	char* output_file;
	gint audio_bitrate;
	gint audio_quality;
	GMainLoop* loop;
	GstPipeline* pipe;
	gint fakesink_count;
	GstElement* master_demux;
	GstPad* master_demux_pad;
	GstBin* audio_bin;
};

struct _ParamSpecAudioMixer {
	GParamSpec parent_instance;
};


static gpointer audio_mixer_parent_class = NULL;

gpointer audio_mixer_ref (gpointer instance);
void audio_mixer_unref (gpointer instance);
GParamSpec* param_spec_audio_mixer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_audio_mixer (GValue* value, gpointer v_object);
gpointer value_get_audio_mixer (const GValue* value);
GType audio_mixer_get_type (void);
#define AUDIO_MIXER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_AUDIO_MIXER, AudioMixerPrivate))
enum  {
	AUDIO_MIXER_DUMMY_PROPERTY
};
AudioMixer* audio_mixer_new (const char* master_file, const char* output_file);
AudioMixer* audio_mixer_construct (GType object_type, const char* master_file, const char* output_file);
static inline void _dynamic_set_quality0 (GstElement* obj, gint value);
static inline void _dynamic_set_bitrate1 (GstElement* obj, gint value);
static inline void _dynamic_set_location2 (GstElement* obj, const char* value);
static void audio_mixer_on_state_changed (AudioMixer* self, GstBus* bus, GstMessage* message);
static void _audio_mixer_on_state_changed_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
static void audio_mixer_on_segment_done (AudioMixer* self, GstBus* bus, GstMessage* message);
static void _audio_mixer_on_segment_done_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
static void audio_mixer_on_master_demux_pad_added (AudioMixer* self, GstElement* demux, GstPad* demux_pad);
static void audio_mixer_on_error (AudioMixer* self, GstBus* bus, GstMessage* message);
static void audio_mixer_on_eos (AudioMixer* self, GstBus* bus, GstMessage* message);
static inline void _dynamic_set_location3 (GstElement* obj, const char* value);
static void _audio_mixer_on_master_demux_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self);
static void _audio_mixer_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
static void _audio_mixer_on_eos_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self);
void audio_mixer_run (AudioMixer* self);
static void audio_mixer_finalize (AudioMixer* obj);
gint _main (char** args, int args_length1);



AudioMixer* audio_mixer_construct (GType object_type, const char* master_file, const char* output_file) {
	AudioMixer* self;
	char* _tmp0_;
	char* _tmp1_;
	g_return_val_if_fail (master_file != NULL, NULL);
	g_return_val_if_fail (output_file != NULL, NULL);
	self = (AudioMixer*) g_type_create_instance (object_type);
	self->priv->master_file = (_tmp0_ = g_strdup (master_file), _g_free0 (self->priv->master_file), _tmp0_);
	self->priv->output_file = (_tmp1_ = g_strdup (output_file), _g_free0 (self->priv->output_file), _tmp1_);
	return self;
}


AudioMixer* audio_mixer_new (const char* master_file, const char* output_file) {
	return audio_mixer_construct (TYPE_AUDIO_MIXER, master_file, output_file);
}


static gpointer _gst_structure_copy0 (gpointer self) {
	return self ? gst_structure_copy (self) : NULL;
}


static gpointer _gst_object_ref0 (gpointer self) {
	return self ? gst_object_ref (self) : NULL;
}


static inline void _dynamic_set_quality0 (GstElement* obj, gint value) {
	g_object_set (obj, "quality", value, NULL);
}


static inline void _dynamic_set_bitrate1 (GstElement* obj, gint value) {
	g_object_set (obj, "bitrate", value, NULL);
}


static inline void _dynamic_set_location2 (GstElement* obj, const char* value) {
	g_object_set (obj, "location", value, NULL);
}


static void _audio_mixer_on_state_changed_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
	audio_mixer_on_state_changed (self, _sender, message);
}


static void _audio_mixer_on_segment_done_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
	audio_mixer_on_segment_done (self, _sender, message);
}


static void audio_mixer_on_master_demux_pad_added (AudioMixer* self, GstElement* demux, GstPad* demux_pad) {
	GstCaps* caps;
	GstStructure* _struct_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (demux != NULL);
	g_return_if_fail (demux_pad != NULL);
	caps = gst_pad_get_caps (demux_pad);
	_struct_ = _gst_structure_copy0 (gst_caps_get_structure (caps, (guint) 0));
	if (g_str_has_prefix (gst_structure_get_name (_struct_), "audio/")) {
		GstPad* _tmp0_;
		GstBin* _tmp1_;
		GstElement* audioconvert;
		GstElement* resample;
		GstElement* lame;
		GstElement* muxer;
		GstElement* file_sink;
		char* _tmp2_;
		GstBus* _tmp3_;
		GstBus* _tmp4_;
		self->priv->master_demux_pad = (_tmp0_ = _gst_object_ref0 (demux_pad), _gst_object_unref0 (self->priv->master_demux_pad), _tmp0_);
		self->priv->audio_bin = (_tmp1_ = (GstBin*) gst_bin_new ("audio_bin"), _gst_object_unref0 (self->priv->audio_bin), _tmp1_);
		gst_bin_add ((GstBin*) self->priv->pipe, _gst_object_ref0 ((GstElement*) self->priv->audio_bin));
		audioconvert = gst_element_factory_make ("audioconvert", "audioconvert");
		resample = gst_element_factory_make ("audioresample", "audioresample");
		lame = gst_element_factory_make ("lame", "lame");
		_dynamic_set_quality0 (lame, self->priv->audio_quality);
		_dynamic_set_bitrate1 (lame, self->priv->audio_bitrate);
		muxer = gst_element_factory_make ("flvmux", "muxer");
		file_sink = gst_element_factory_make ("filesink", "fileSink");
		_dynamic_set_location2 (file_sink, self->priv->output_file);
		gst_bin_add_many (self->priv->audio_bin, _gst_object_ref0 (audioconvert), _gst_object_ref0 (resample), _gst_object_ref0 (lame), _gst_object_ref0 (muxer), _gst_object_ref0 (file_sink), NULL);
		gst_element_link_pads (demux, _tmp2_ = gst_object_get_name ((GstObject*) demux_pad), audioconvert, "sink");
		_g_free0 (_tmp2_);
		gst_element_link_many (audioconvert, resample, lame, muxer, file_sink, NULL);
		g_signal_connect (_tmp3_ = gst_pipeline_get_bus (self->priv->pipe), "message::state-changed", (GCallback) _audio_mixer_on_state_changed_gst_bus_message, self);
		_gst_object_unref0 (_tmp3_);
		g_signal_connect (_tmp4_ = gst_pipeline_get_bus (self->priv->pipe), "message::segment-done", (GCallback) _audio_mixer_on_segment_done_gst_bus_message, self);
		_gst_object_unref0 (_tmp4_);
		gst_element_set_state ((GstElement*) self->priv->audio_bin, GST_STATE_PAUSED);
		_gst_object_unref0 (audioconvert);
		_gst_object_unref0 (resample);
		_gst_object_unref0 (lame);
		_gst_object_unref0 (muxer);
		_gst_object_unref0 (file_sink);
	} else {
		char* _tmp6_;
		char* _tmp5_;
		GstBin* _tmp7_;
		GstBin* fake_bin;
		char* _tmp9_;
		char* _tmp8_;
		GstElement* _tmp10_;
		GstElement* fakesink;
		char* _tmp11_;
		fake_bin = (_tmp7_ = (GstBin*) gst_bin_new (_tmp6_ = g_strconcat ("fakeBin", _tmp5_ = g_strdup_printf ("%i", self->priv->fakesink_count), NULL)), _g_free0 (_tmp6_), _g_free0 (_tmp5_), _tmp7_);
		gst_bin_add ((GstBin*) self->priv->pipe, _gst_object_ref0 ((GstElement*) fake_bin));
		fakesink = (_tmp10_ = gst_element_factory_make ("fakesink", _tmp9_ = g_strconcat ("fakesink", _tmp8_ = g_strdup_printf ("%i", self->priv->fakesink_count), NULL)), _g_free0 (_tmp9_), _g_free0 (_tmp8_), _tmp10_);
		self->priv->fakesink_count++;
		gst_bin_add (fake_bin, _gst_object_ref0 (fakesink));
		gst_element_link_pads (demux, _tmp11_ = gst_object_get_name ((GstObject*) demux_pad), fakesink, "sink");
		_g_free0 (_tmp11_);
		gst_element_set_state ((GstElement*) fake_bin, GST_STATE_PAUSED);
		_gst_object_unref0 (fake_bin);
		_gst_object_unref0 (fakesink);
	}
	_gst_caps_unref0 (caps);
	_gst_structure_free0 (_struct_);
}


static void audio_mixer_on_error (AudioMixer* self, GstBus* bus, GstMessage* message) {
	GError* err;
	char* debug;
	char* _tmp3_;
	char* _tmp2_ = NULL;
	GError* _tmp1_;
	GError* _tmp0_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (bus != NULL);
	g_return_if_fail (message != NULL);
	err = NULL;
	debug = NULL;
	(gst_message_parse_error (message, &_tmp0_, &_tmp2_), err = (_tmp1_ = _tmp0_, _g_error_free0 (err), _tmp1_));
	debug = (_tmp3_ = _tmp2_, _g_free0 (debug), _tmp3_);
	fprintf (stderr, "Error: %s\n", err->message);
	gst_element_set_state ((GstElement*) self->priv->pipe, GST_STATE_NULL);
	g_main_loop_quit (self->priv->loop);
	_g_error_free0 (err);
	_g_free0 (debug);
}


static void audio_mixer_on_eos (AudioMixer* self, GstBus* bus, GstMessage* message) {
	g_return_if_fail (self != NULL);
	g_return_if_fail (bus != NULL);
	g_return_if_fail (message != NULL);
	gst_element_set_state ((GstElement*) self->priv->pipe, GST_STATE_NULL);
	g_main_loop_quit (self->priv->loop);
}


static void audio_mixer_on_state_changed (AudioMixer* self, GstBus* bus, GstMessage* message) {
	GstState old_state = 0;
	GstState new_state = 0;
	GstState pending = 0;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	g_return_if_fail (self != NULL);
	g_return_if_fail (bus != NULL);
	g_return_if_fail (message != NULL);
	gst_message_parse_state_changed (message, &old_state, &new_state, &pending);
	if (message->src == GST_OBJECT (self->priv->master_demux)) {
		_tmp1_ = old_state == GST_STATE_READY;
	} else {
		_tmp1_ = FALSE;
	}
	if (_tmp1_) {
		_tmp0_ = new_state == GST_STATE_PAUSED;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		fprintf (stdout, "sending seek event...\n");
		gst_pad_send_event (self->priv->master_demux_pad, gst_event_new_seek (1.0, GST_FORMAT_TIME, (GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH) | GST_SEEK_FLAG_ACCURATE, GST_SEEK_TYPE_SET, (gint64) 0, GST_SEEK_TYPE_NONE, (gint64) (-1)));
	}
}


static void audio_mixer_on_segment_done (AudioMixer* self, GstBus* bus, GstMessage* message) {
	g_return_if_fail (self != NULL);
	g_return_if_fail (bus != NULL);
	g_return_if_fail (message != NULL);
	fprintf (stdout, "End of segment reached, resending seek event...\n");
	gst_pad_send_event (self->priv->master_demux_pad, gst_event_new_seek (1.0, GST_FORMAT_TIME, (GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH) | GST_SEEK_FLAG_ACCURATE, GST_SEEK_TYPE_SET, (gint64) 0, GST_SEEK_TYPE_NONE, (gint64) (-1)));
}


static inline void _dynamic_set_location3 (GstElement* obj, const char* value) {
	g_object_set (obj, "location", value, NULL);
}


static void _audio_mixer_on_master_demux_pad_added_gst_element_pad_added (GstElement* _sender, GstPad* pad, gpointer self) {
	audio_mixer_on_master_demux_pad_added (self, _sender, pad);
}


static void _audio_mixer_on_error_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
	audio_mixer_on_error (self, _sender, message);
}


static void _audio_mixer_on_eos_gst_bus_message (GstBus* _sender, GstMessage* message, gpointer self) {
	audio_mixer_on_eos (self, _sender, message);
}


void audio_mixer_run (AudioMixer* self) {
	GstElement* src;
	GstElement* _tmp0_;
	GstBus* bus;
	g_return_if_fail (self != NULL);
	src = gst_element_factory_make ("filesrc", "src");
	_dynamic_set_location3 (src, self->priv->master_file);
	self->priv->master_demux = (_tmp0_ = gst_element_factory_make ("decodebin2", "master_demux"), _gst_object_unref0 (self->priv->master_demux), _tmp0_);
	gst_bin_add_many ((GstBin*) self->priv->pipe, _gst_object_ref0 (src), _gst_object_ref0 (self->priv->master_demux), NULL);
	gst_element_link (src, self->priv->master_demux);
	g_signal_connect (self->priv->master_demux, "pad-added", (GCallback) _audio_mixer_on_master_demux_pad_added_gst_element_pad_added, self);
	bus = gst_pipeline_get_bus (self->priv->pipe);
	gst_bus_add_signal_watch (bus);
	g_signal_connect (bus, "message::error", (GCallback) _audio_mixer_on_error_gst_bus_message, self);
	g_signal_connect (bus, "message::eos", (GCallback) _audio_mixer_on_eos_gst_bus_message, self);
	gst_element_set_state ((GstElement*) self->priv->pipe, GST_STATE_PLAYING);
	g_main_loop_run (self->priv->loop);
	_gst_object_unref0 (src);
	_gst_object_unref0 (bus);
}


static void value_audio_mixer_init (GValue* value) {
	value->data[0].v_pointer = NULL;
}


static void value_audio_mixer_free_value (GValue* value) {
	if (value->data[0].v_pointer) {
		audio_mixer_unref (value->data[0].v_pointer);
	}
}


static void value_audio_mixer_copy_value (const GValue* src_value, GValue* dest_value) {
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = audio_mixer_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}


static gpointer value_audio_mixer_peek_pointer (const GValue* value) {
	return value->data[0].v_pointer;
}


static gchar* value_audio_mixer_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	if (collect_values[0].v_pointer) {
		AudioMixer* object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = audio_mixer_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}


static gchar* value_audio_mixer_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	AudioMixer** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = audio_mixer_ref (value->data[0].v_pointer);
	}
	return NULL;
}


GParamSpec* param_spec_audio_mixer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
	ParamSpecAudioMixer* spec;
	g_return_val_if_fail (g_type_is_a (object_type, TYPE_AUDIO_MIXER), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}


gpointer value_get_audio_mixer (const GValue* value) {
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_AUDIO_MIXER), NULL);
	return value->data[0].v_pointer;
}


void value_set_audio_mixer (GValue* value, gpointer v_object) {
	AudioMixer* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_AUDIO_MIXER));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_AUDIO_MIXER));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		audio_mixer_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		audio_mixer_unref (old);
	}
}


static void audio_mixer_class_init (AudioMixerClass * klass) {
	audio_mixer_parent_class = g_type_class_peek_parent (klass);
	AUDIO_MIXER_CLASS (klass)->finalize = audio_mixer_finalize;
	g_type_class_add_private (klass, sizeof (AudioMixerPrivate));
}


static void audio_mixer_instance_init (AudioMixer * self) {
	self->priv = AUDIO_MIXER_GET_PRIVATE (self);
	self->priv->audio_bitrate = 128;
	self->priv->audio_quality = 9;
	self->priv->loop = g_main_loop_new (NULL, FALSE);
	self->priv->pipe = (GstPipeline*) gst_pipeline_new ("pipeline");
	self->priv->fakesink_count = 0;
	self->ref_count = 1;
}


static void audio_mixer_finalize (AudioMixer* obj) {
	AudioMixer * self;
	self = AUDIO_MIXER (obj);
	_g_free0 (self->priv->master_file);
	_g_free0 (self->priv->output_file);
	_g_main_loop_unref0 (self->priv->loop);
	_gst_object_unref0 (self->priv->pipe);
	_gst_object_unref0 (self->priv->master_demux);
	_gst_object_unref0 (self->priv->master_demux_pad);
	_gst_object_unref0 (self->priv->audio_bin);
}


GType audio_mixer_get_type (void) {
	static GType audio_mixer_type_id = 0;
	if (audio_mixer_type_id == 0) {
		static const GTypeValueTable g_define_type_value_table = { value_audio_mixer_init, value_audio_mixer_free_value, value_audio_mixer_copy_value, value_audio_mixer_peek_pointer, "p", value_audio_mixer_collect_value, "p", value_audio_mixer_lcopy_value };
		static const GTypeInfo g_define_type_info = { sizeof (AudioMixerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) audio_mixer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (AudioMixer), 0, (GInstanceInitFunc) audio_mixer_instance_init, &g_define_type_value_table };
		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
		audio_mixer_type_id = g_type_register_fundamental (g_type_fundamental_next (), "AudioMixer", &g_define_type_info, &g_define_type_fundamental_info, 0);
	}
	return audio_mixer_type_id;
}


gpointer audio_mixer_ref (gpointer instance) {
	AudioMixer* self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}


void audio_mixer_unref (gpointer instance) {
	AudioMixer* self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		AUDIO_MIXER_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}


gint _main (char** args, int args_length1) {
	gint result;
	char* input_file;
	char* output_file;
	AudioMixer* mixer;
	gst_init (&args_length1, &args);
	if (args_length1 < 3) {
		fprintf (stdout, "Please pass the following arguments: inputFile flvOutputFile\n");
		result = -1;
		return result;
	}
	input_file = g_strdup (args[1]);
	output_file = g_strdup (args[2]);
	mixer = audio_mixer_new (input_file, output_file);
	audio_mixer_run (mixer);
	result = 0;
	_g_free0 (input_file);
	_g_free0 (output_file);
	_audio_mixer_unref0 (mixer);
	return result;
}


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




