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

/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <glib.h>
#include <glib-object.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <gio/gio.h>
#include <stdio.h>
#include <gisicomm.h>
#include <libgisi.h>
#include <call.h>
#include <gpds.h>
#include <gss.h>
#include <info.h>
#include <mtc.h>
#include <network.h>
#include <sim.h>
#include <simauth.h>
#include <sms.h>
#include <ss.h>

#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
typedef struct _Block1Data Block1Data;
#define _gisi_comm_modem_access_unref0(var) ((var == NULL) ? NULL : (var = (gisi_comm_modem_access_unref (var), NULL)))
typedef struct _sendCommandData sendCommandData;
typedef struct _Block2Data Block2Data;
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))

struct _Block1Data {
	int _ref_count_;
	gboolean msgok;
	gpointer _async_data_;
};

struct _sendCommandData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	gchar** args;
	gint args_length1;
	Block1Data* _data1_;
	FILE* _tmp0_;
	gchar** _tmp1_;
	gint _tmp1__length1;
	const gchar* _tmp2_;
	GIsiCommModemAccess* _tmp3_;
	GIsiCommModemAccess* modem;
	GIsiCommModemAccess* _tmp4_;
	gboolean _tmp5_;
	FILE* _tmp6_;
	gchar** _tmp7_;
	gint _tmp7__length1;
	const gchar* _tmp8_;
	guint8* _tmp9_;
	guint8* req;
	gint req_length1;
	gint _req_size_;
	guint8 resource;
	gchar** _tmp10_;
	gint _tmp10__length1;
	const gchar* _tmp11_;
	gchar** _tmp12_;
	gint _tmp12__length1;
	gchar** _tmp13_;
	gint _tmp13__length1;
	gchar** byte_collection;
	gint byte_collection_length1;
	gint _byte_collection_size_;
	gint byte_it;
	gchar* _tmp14_;
	gchar* byte;
	guint8 b;
	const gchar* _tmp15_;
	gint _tmp16_;
	FILE* _tmp17_;
	const gchar* _tmp18_;
	const gchar* _tmp19_;
	gchar* _tmp20_;
	gchar* _tmp21_;
	guint8* _tmp22_;
	gint _tmp22__length1;
	guint8 _tmp23_;
	FILE* _tmp24_;
	gchar** _tmp25_;
	gint _tmp25__length1;
	const gchar* _tmp26_;
	FILE* _tmp27_;
	guint8 _tmp28_;
	GIsiCommModemAccess* _tmp29_;
	GIsiModem* _tmp30_;
	guint8 _tmp31_;
	gboolean _tmp32_;
	FILE* _tmp33_;
	guint8 _tmp34_;
	gchar** _tmp35_;
	gint _tmp35__length1;
	FILE* _tmp36_;
	guint8 _tmp37_;
	FILE* _tmp38_;
	guint8 _tmp39_;
	GIsiCommModemAccess* _tmp40_;
	GIsiModem* _tmp41_;
	guint8 _tmp42_;
	guint8* _tmp43_;
	gint _tmp43__length1;
	GMainLoop* _tmp44_;
};

struct _Block2Data {
	int _ref_count_;
	gchar** args;
	gint args_length1;
};


extern GMainLoop* loop;
GMainLoop* loop = NULL;

void schedule (gint seconds);
gchar* hexdump (guint8* array, int array_length1, gint linelength, const gchar* prefix, guchar unknownCharacter);
static void sendCommand_data_free (gpointer _data);
static gchar** _vala_array_dup1 (gchar** self, int length);
void sendCommand (gchar** args, int args_length1, GAsyncReadyCallback _callback_, gpointer _user_data_);
void sendCommand_finish (GAsyncResult* _res_);
static gboolean sendCommand_co (sendCommandData* _data_);
static Block1Data* block1_data_ref (Block1Data* _data1_);
static void block1_data_unref (Block1Data* _data1_);
static void sendCommand_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void _vala_array_add1 (guint8** array, int* length, int* size, guint8 value);
static void __lambda0_ (Block1Data* _data1_, GIsiMessage* msg);
static void ___lambda0__gisi_notify_func (GIsiMessage* msg, gpointer self);
static void __lambda1_ (Block1Data* _data1_, GIsiMessage* msg);
static void ___lambda1__gisi_notify_func (GIsiMessage* msg, gpointer self);
void _vala_main (gchar** args, int args_length1);
static gchar** _vala_array_dup2 (gchar** self, int length);
static Block2Data* block2_data_ref (Block2Data* _data2_);
static void block2_data_unref (Block2Data* _data2_);
static gboolean __lambda2_ (Block2Data* _data2_);
static gboolean ___lambda2__gsource_func (gpointer self);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);


void schedule (gint seconds) {
	time_t _tmp0_;
	time_t starttime;
	_tmp0_ = time (NULL);
	starttime = _tmp0_;
	while (TRUE) {
		time_t _tmp1_;
		time_t _tmp2_;
		gint _tmp3_;
		GMainContext* _tmp4_ = NULL;
		_tmp1_ = time (NULL);
		_tmp2_ = starttime;
		_tmp3_ = seconds;
		if (!(_tmp1_ < (_tmp2_ + _tmp3_))) {
			break;
		}
		_tmp4_ = g_main_context_default ();
		g_main_context_iteration (_tmp4_, FALSE);
	}
}


static gchar* string_strip (const gchar* self) {
	gchar* result = NULL;
	gchar* _tmp0_ = NULL;
	gchar* _result_;
	const gchar* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = g_strdup (self);
	_result_ = _tmp0_;
	_tmp1_ = _result_;
	g_strstrip (_tmp1_);
	result = _result_;
	return result;
}


gchar* hexdump (guint8* array, int array_length1, gint linelength, const gchar* prefix, guchar unknownCharacter) {
	gchar* result = NULL;
	guint8* _tmp0_;
	gint _tmp0__length1;
	gchar* _tmp2_;
	gchar* _result_;
	gint _tmp3_;
	gint BYTES_PER_LINE;
	const gchar* _tmp4_;
	GString* _tmp5_;
	GString* hexline;
	GString* _tmp6_;
	GString* ascline;
	guchar b = '\0';
	gint i = 0;
	gint _tmp39_;
	gint _tmp40_;
	gint _tmp41_;
	const gchar* _tmp55_;
	gchar* _tmp56_ = NULL;
	g_return_val_if_fail (prefix != NULL, NULL);
	_tmp0_ = array;
	_tmp0__length1 = array_length1;
	if (_tmp0__length1 < 1) {
		gchar* _tmp1_;
		_tmp1_ = g_strdup ("");
		result = _tmp1_;
		return result;
	}
	_tmp2_ = g_strdup ("");
	_result_ = _tmp2_;
	_tmp3_ = linelength;
	BYTES_PER_LINE = _tmp3_;
	_tmp4_ = prefix;
	_tmp5_ = g_string_new (_tmp4_);
	hexline = _tmp5_;
	_tmp6_ = g_string_new ("");
	ascline = _tmp6_;
	{
		gboolean _tmp7_;
		i = 0;
		_tmp7_ = TRUE;
		while (TRUE) {
			gboolean _tmp8_;
			gint _tmp10_;
			guint8* _tmp11_;
			gint _tmp11__length1;
			guint8* _tmp12_;
			gint _tmp12__length1;
			gint _tmp13_;
			guint8 _tmp14_;
			GString* _tmp15_;
			guchar _tmp16_;
			gboolean _tmp17_ = FALSE;
			guchar _tmp18_;
			gboolean _tmp20_;
			gint _tmp24_;
			gint _tmp25_;
			gint _tmp26_;
			_tmp8_ = _tmp7_;
			if (!_tmp8_) {
				gint _tmp9_;
				_tmp9_ = i;
				i = _tmp9_ + 1;
			}
			_tmp7_ = FALSE;
			_tmp10_ = i;
			_tmp11_ = array;
			_tmp11__length1 = array_length1;
			if (!(_tmp10_ < _tmp11__length1)) {
				break;
			}
			_tmp12_ = array;
			_tmp12__length1 = array_length1;
			_tmp13_ = i;
			_tmp14_ = _tmp12_[_tmp13_];
			b = (guchar) _tmp14_;
			_tmp15_ = hexline;
			_tmp16_ = b;
			g_string_append_printf (_tmp15_, "%02X ", (guint) _tmp16_);
			_tmp18_ = b;
			if (31 < ((gint) _tmp18_)) {
				guchar _tmp19_;
				_tmp19_ = b;
				_tmp17_ = ((gint) _tmp19_) < 128;
			} else {
				_tmp17_ = FALSE;
			}
			_tmp20_ = _tmp17_;
			if (_tmp20_) {
				GString* _tmp21_;
				guchar _tmp22_;
				_tmp21_ = ascline;
				_tmp22_ = b;
				g_string_append_printf (_tmp21_, "%c", (gint) _tmp22_);
			} else {
				GString* _tmp23_;
				_tmp23_ = ascline;
				g_string_append_printf (_tmp23_, ".");
			}
			_tmp24_ = i;
			_tmp25_ = BYTES_PER_LINE;
			_tmp26_ = BYTES_PER_LINE;
			if (((_tmp24_ % _tmp25_) + 1) == _tmp26_) {
				GString* _tmp27_;
				GString* _tmp28_;
				const gchar* _tmp29_;
				const gchar* _tmp30_;
				GString* _tmp31_;
				const gchar* _tmp32_;
				gchar* _tmp33_;
				const gchar* _tmp34_;
				gchar* _tmp35_;
				const gchar* _tmp36_;
				GString* _tmp37_;
				GString* _tmp38_;
				_tmp27_ = hexline;
				_tmp28_ = ascline;
				_tmp29_ = _tmp28_->str;
				g_string_append (_tmp27_, _tmp29_);
				_tmp30_ = _result_;
				_tmp31_ = hexline;
				_tmp32_ = _tmp31_->str;
				_tmp33_ = g_strconcat (_tmp30_, _tmp32_, NULL);
				_g_free0 (_result_);
				_result_ = _tmp33_;
				_tmp34_ = _result_;
				_tmp35_ = g_strconcat (_tmp34_, "\n", NULL);
				_g_free0 (_result_);
				_result_ = _tmp35_;
				_tmp36_ = prefix;
				_tmp37_ = g_string_new (_tmp36_);
				_g_string_free0 (hexline);
				hexline = _tmp37_;
				_tmp38_ = g_string_new ("");
				_g_string_free0 (ascline);
				ascline = _tmp38_;
			}
		}
	}
	_tmp39_ = i;
	_tmp40_ = BYTES_PER_LINE;
	_tmp41_ = BYTES_PER_LINE;
	if (((_tmp39_ % _tmp40_) + 1) != _tmp41_) {
		GString* _tmp46_;
		GString* _tmp47_;
		const gchar* _tmp48_;
		const gchar* _tmp49_;
		GString* _tmp50_;
		const gchar* _tmp51_;
		gchar* _tmp52_;
		const gchar* _tmp53_;
		gchar* _tmp54_;
		while (TRUE) {
			GString* _tmp42_;
			gssize _tmp43_;
			gint _tmp44_;
			GString* _tmp45_;
			_tmp42_ = hexline;
			_tmp43_ = _tmp42_->len;
			_tmp44_ = BYTES_PER_LINE;
			if (!(_tmp43_ < ((gssize) (3 * _tmp44_)))) {
				break;
			}
			_tmp45_ = hexline;
			g_string_append_c (_tmp45_, ' ');
		}
		_tmp46_ = hexline;
		_tmp47_ = ascline;
		_tmp48_ = _tmp47_->str;
		g_string_append (_tmp46_, _tmp48_);
		_tmp49_ = _result_;
		_tmp50_ = hexline;
		_tmp51_ = _tmp50_->str;
		_tmp52_ = g_strconcat (_tmp49_, _tmp51_, NULL);
		_g_free0 (_result_);
		_result_ = _tmp52_;
		_tmp53_ = _result_;
		_tmp54_ = g_strconcat (_tmp53_, "\n", NULL);
		_g_free0 (_result_);
		_result_ = _tmp54_;
	}
	_tmp55_ = _result_;
	_tmp56_ = string_strip (_tmp55_);
	result = _tmp56_;
	_g_string_free0 (ascline);
	_g_string_free0 (hexline);
	_g_free0 (_result_);
	return result;
}


static void sendCommand_data_free (gpointer _data) {
	sendCommandData* _data_;
	_data_ = _data;
	_data_->args = (_vala_array_free (_data_->args, _data_->args_length1, (GDestroyNotify) g_free), NULL);
	g_slice_free (sendCommandData, _data_);
}


static gchar** _vala_array_dup1 (gchar** self, int length) {
	gchar** result;
	int i;
	result = g_new0 (gchar*, length + 1);
	for (i = 0; i < length; i++) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (self[i]);
		result[i] = _tmp0_;
	}
	return result;
}


void sendCommand (gchar** args, int args_length1, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	sendCommandData* _data_;
	gchar** _tmp0_;
	gint _tmp0__length1;
	gchar** _tmp1_;
	gint _tmp1__length1;
	_data_ = g_slice_new0 (sendCommandData);
	_data_->_async_result = g_simple_async_result_new (g_object_newv (G_TYPE_OBJECT, 0, NULL), _callback_, _user_data_, sendCommand);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, sendCommand_data_free);
	_tmp0_ = args;
	_tmp0__length1 = args_length1;
	_tmp1_ = (_tmp0_ != NULL) ? _vala_array_dup1 (_tmp0_, _tmp0__length1) : ((gpointer) _tmp0_);
	_tmp1__length1 = _tmp0__length1;
	_data_->args = _tmp1_;
	_data_->args_length1 = _tmp1__length1;
	sendCommand_co (_data_);
}


void sendCommand_finish (GAsyncResult* _res_) {
	sendCommandData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static Block1Data* block1_data_ref (Block1Data* _data1_) {
	g_atomic_int_inc (&_data1_->_ref_count_);
	return _data1_;
}


static void block1_data_unref (Block1Data* _data1_) {
	if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
		g_slice_free (Block1Data, _data1_);
	}
}


static void sendCommand_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	sendCommandData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	sendCommand_co (_data_);
}


static const gchar* string_to_string (const gchar* self) {
	const gchar* result = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	result = self;
	return result;
}


static void _vala_array_add1 (guint8** array, int* length, int* size, guint8 value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (guint8, *array, *size);
	}
	(*array)[(*length)++] = value;
}


static gboolean g_isi_msg_ok (GIsiMessage* self) {
	gboolean result = FALSE;
	gint _tmp0_;
	gint _tmp1_;
	g_return_val_if_fail (self != NULL, FALSE);
	_tmp0_ = g_isi_msg_error (self);
	_tmp1_ = _tmp0_;
	result = _tmp1_ >= 0;
	return result;
}


static void __lambda0_ (Block1Data* _data1_, GIsiMessage* msg) {
	GIsiMessage* _tmp0_;
	gboolean _tmp1_ = FALSE;
	g_return_if_fail (msg != NULL);
	_tmp0_ = msg;
	_tmp1_ = g_isi_msg_ok (_tmp0_);
	_data1_->msgok = _tmp1_;
	sendCommand_co (_data1_->_async_data_);
}


static void ___lambda0__gisi_notify_func (GIsiMessage* msg, gpointer self) {
	__lambda0_ (self, msg);
}


static guint8* g_isi_msg_get_data (GIsiMessage* self, int* result_length1) {
	guint8* result;
	void* _tmp0_;
	void* _tmp1_;
	guint8* array;
	gint array_length1;
	gint _array_size_;
	gsize _tmp2_;
	gsize _tmp3_;
	gint _tmp4_;
	guint8* _tmp5_;
	gint _tmp5__length1;
	guint8* _tmp6_;
	gint _tmp6__length1;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = g_isi_msg_data (self);
	_tmp1_ = _tmp0_;
	array = (guint8*) _tmp1_;
	array_length1 = -1;
	_array_size_ = array_length1;
	_tmp2_ = g_isi_msg_data_len (self);
	_tmp3_ = _tmp2_;
	array_length1 = (gint) _tmp3_;
	_tmp4_ = array_length1;
	_tmp5_ = array;
	_tmp5__length1 = array_length1;
	_tmp6_ = _tmp5_;
	_tmp6__length1 = _tmp5__length1;
	if (result_length1) {
		*result_length1 = _tmp6__length1;
	}
	result = _tmp6_;
	return result;
}


static void __lambda1_ (Block1Data* _data1_, GIsiMessage* msg) {
	GIsiMessage* _tmp0_;
	gboolean _tmp1_ = FALSE;
	g_return_if_fail (msg != NULL);
	_tmp0_ = msg;
	_tmp1_ = g_isi_msg_ok (_tmp0_);
	if (_tmp1_) {
		FILE* _tmp2_;
		GIsiMessage* _tmp3_;
		guint8* _tmp4_;
		gint _tmp4__length1;
		guint8* _tmp5_;
		gint _tmp5__length1;
		gchar* _tmp6_ = NULL;
		gchar* _tmp7_;
		_tmp2_ = stdout;
		_tmp3_ = msg;
		_tmp4_ = g_isi_msg_get_data (_tmp3_, &_tmp4__length1);
		_tmp5_ = _tmp4_;
		_tmp5__length1 = _tmp4__length1;
		_tmp6_ = hexdump (_tmp5_, _tmp5__length1, 16, "", (guchar) '?');
		_tmp7_ = _tmp6_;
		fprintf (_tmp2_, "Answer OK. Result is\n%s\n", _tmp7_);
		_g_free0 (_tmp7_);
	} else {
		FILE* _tmp8_;
		GIsiMessage* _tmp9_;
		const gchar* _tmp10_;
		const gchar* _tmp11_;
		_tmp8_ = stdout;
		_tmp9_ = msg;
		_tmp10_ = g_isi_msg_strerror (_tmp9_);
		_tmp11_ = _tmp10_;
		fprintf (_tmp8_, "Answer ERROR: %s\n", _tmp11_);
	}
	sendCommand_co (_data1_->_async_data_);
}


static void ___lambda1__gisi_notify_func (GIsiMessage* msg, gpointer self) {
	__lambda1_ (self, msg);
}


static gboolean sendCommand_co (sendCommandData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		case 2:
		goto _state_2;
		case 3:
		goto _state_3;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_data1_ = g_slice_new0 (Block1Data);
	_data_->_data1_->_ref_count_ = 1;
	_data_->_data1_->_async_data_ = _data_;
	_data_->_tmp0_ = stdout;
	fprintf (_data_->_tmp0_, "sendisi 1.0.0 (C) Michael 'Mickey' Lauer comes without any warranty. D" \
"on't blame me for frying your modem!\n");
	_data_->_tmp1_ = _data_->args;
	_data_->_tmp1__length1 = _data_->args_length1;
	_data_->_tmp2_ = _data_->_tmp1_[1];
	_data_->_tmp3_ = gisi_comm_modem_access_new (_data_->_tmp2_);
	_data_->modem = _data_->_tmp3_;
	_data_->_tmp4_ = _data_->modem;
	_data_->_state_ = 1;
	gisi_comm_modem_access_connect (_data_->_tmp4_, sendCommand_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp5_ = FALSE;
	_data_->_tmp5_ = gisi_comm_modem_access_connect_finish (_data_->_tmp4_, _data_->_res_);
	if (!_data_->_tmp5_) {
		_data_->_tmp6_ = stderr;
		_data_->_tmp7_ = _data_->args;
		_data_->_tmp7__length1 = _data_->args_length1;
		_data_->_tmp8_ = _data_->_tmp7_[1];
		fprintf (_data_->_tmp6_, "Can't connect to modem via %s. Check privileges and interface\n", _data_->_tmp8_);
		exit (-1);
	}
	_data_->_tmp9_ = NULL;
	_data_->_tmp9_ = g_new0 (guint8, 0);
	_data_->req = _data_->_tmp9_;
	_data_->req_length1 = 0;
	_data_->_req_size_ = _data_->req_length1;
	_data_->resource = (guint8) 0;
	_data_->_tmp10_ = _data_->args;
	_data_->_tmp10__length1 = _data_->args_length1;
	_data_->_tmp11_ = _data_->_tmp10_[2];
	sscanf (_data_->_tmp11_, "%X", &_data_->resource);
	_data_->_tmp12_ = _data_->args;
	_data_->_tmp12__length1 = _data_->args_length1;
	_data_->_tmp13_ = _data_->args;
	_data_->_tmp13__length1 = _data_->args_length1;
	{
		_data_->byte_collection_length1 = 0;
		_data_->_byte_collection_size_ = 0;
		_data_->byte_collection = _data_->_tmp12_ + 3;
		_data_->byte_collection_length1 = _data_->_tmp13__length1 - 3;
		_data_->byte_it = 0;
		for (_data_->byte_it = 0; _data_->byte_it < (_data_->_tmp13__length1 - 3); _data_->byte_it = _data_->byte_it + 1) {
			_data_->_tmp14_ = g_strdup (_data_->byte_collection[_data_->byte_it]);
			_data_->byte = _data_->_tmp14_;
			{
				_data_->b = (guint8) 0;
				_data_->_tmp15_ = _data_->byte;
				_data_->_tmp16_ = 0;
				_data_->_tmp16_ = sscanf (_data_->_tmp15_, "%X", &_data_->b);
				if (_data_->_tmp16_ <= 0) {
					_data_->_tmp17_ = stderr;
					_data_->_tmp18_ = _data_->byte;
					_data_->_tmp19_ = NULL;
					_data_->_tmp19_ = string_to_string (_data_->_tmp18_);
					_data_->_tmp20_ = NULL;
					_data_->_tmp20_ = g_strconcat ("Can't parse ", _data_->_tmp19_, " in command", NULL);
					_data_->_tmp21_ = _data_->_tmp20_;
					fprintf (_data_->_tmp17_, "%s", _data_->_tmp21_);
					_g_free0 (_data_->_tmp21_);
					exit (-1);
				}
				_data_->_tmp22_ = _data_->req;
				_data_->_tmp22__length1 = _data_->req_length1;
				_data_->_tmp23_ = _data_->b;
				_vala_array_add1 (&_data_->req, &_data_->req_length1, &_data_->_req_size_, _data_->_tmp23_);
				_g_free0 (_data_->byte);
			}
		}
	}
	_data_->_tmp24_ = stdout;
	_data_->_tmp25_ = _data_->args;
	_data_->_tmp25__length1 = _data_->args_length1;
	_data_->_tmp26_ = _data_->_tmp25_[1];
	fprintf (_data_->_tmp24_, "Connected to ISI modem via %s", _data_->_tmp26_);
	_data_->_tmp27_ = stdout;
	_data_->_tmp28_ = _data_->resource;
	fprintf (_data_->_tmp27_, ", checking whether resource 0x%02X is reachable...\n", (guint) _data_->_tmp28_);
	_data_->_data1_->msgok = FALSE;
	_data_->_tmp29_ = _data_->modem;
	_data_->_tmp30_ = _data_->_tmp29_->m;
	_data_->_tmp31_ = _data_->resource;
	g_isi_resource_ping (_data_->_tmp30_, (guchar) _data_->_tmp31_, ___lambda0__gisi_notify_func, block1_data_ref (_data_->_data1_), block1_data_unref);
	_data_->_state_ = 2;
	return FALSE;
	_state_2:
	;
	_data_->_tmp32_ = _data_->_data1_->msgok;
	if (!_data_->_tmp32_) {
		_data_->_tmp33_ = stderr;
		_data_->_tmp34_ = _data_->resource;
		fprintf (_data_->_tmp33_, "Resource 0x%02X is not reachable, giving up\n", (guint) _data_->_tmp34_);
		exit (-1);
	}
	_data_->_tmp35_ = _data_->args;
	_data_->_tmp35__length1 = _data_->args_length1;
	if (_data_->_tmp35__length1 > 3) {
		_data_->_tmp36_ = stderr;
		_data_->_tmp37_ = _data_->resource;
		fprintf (_data_->_tmp36_, "Resource 0x%02X answering, sending message...\n", (guint) _data_->_tmp37_);
	} else {
		_data_->_tmp38_ = stdout;
		_data_->_tmp39_ = _data_->resource;
		fprintf (_data_->_tmp38_, " Resource 0x%02X answering. OK\n", (guint) _data_->_tmp39_);
		exit (0);
	}
	_data_->_tmp40_ = _data_->modem;
	_data_->_tmp41_ = _data_->_tmp40_->m;
	_data_->_tmp42_ = _data_->resource;
	_data_->_tmp43_ = _data_->req;
	_data_->_tmp43__length1 = _data_->req_length1;
	g_isi_request_send (_data_->_tmp41_, (guchar) _data_->_tmp42_, _data_->_tmp43_, _data_->_tmp43__length1, (guint) 5, ___lambda1__gisi_notify_func, block1_data_ref (_data_->_data1_), block1_data_unref);
	_data_->_state_ = 3;
	return FALSE;
	_state_3:
	;
	_data_->_tmp44_ = loop;
	g_main_loop_quit (_data_->_tmp44_);
	_data_->req = (g_free (_data_->req), NULL);
	_gisi_comm_modem_access_unref0 (_data_->modem);
	block1_data_unref (_data_->_data1_);
	_data_->_data1_ = NULL;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static gchar** _vala_array_dup2 (gchar** self, int length) {
	gchar** result;
	int i;
	result = g_new0 (gchar*, length + 1);
	for (i = 0; i < length; i++) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (self[i]);
		result[i] = _tmp0_;
	}
	return result;
}


static Block2Data* block2_data_ref (Block2Data* _data2_) {
	g_atomic_int_inc (&_data2_->_ref_count_);
	return _data2_;
}


static void block2_data_unref (Block2Data* _data2_) {
	if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
		_data2_->args = (_vala_array_free (_data2_->args, _data2_->args_length1, (GDestroyNotify) g_free), NULL);
		g_slice_free (Block2Data, _data2_);
	}
}


static gboolean __lambda2_ (Block2Data* _data2_) {
	gboolean result = FALSE;
	gchar** _tmp0_;
	gint _tmp0__length1;
	_tmp0_ = _data2_->args;
	_tmp0__length1 = _data2_->args_length1;
	sendCommand (_tmp0_, _tmp0__length1, NULL, NULL);
	result = FALSE;
	return result;
}


static gboolean ___lambda2__gsource_func (gpointer self) {
	gboolean result;
	result = __lambda2_ (self);
	return result;
}


void _vala_main (gchar** args, int args_length1) {
	Block2Data* _data2_;
	gchar** _tmp0_;
	gint _tmp0__length1;
	gchar** _tmp1_;
	gint _tmp1__length1;
	gchar** _tmp2_;
	gint _tmp2__length1;
	GMainLoop* _tmp6_;
	GMainLoop* _tmp7_;
	_data2_ = g_slice_new0 (Block2Data);
	_data2_->_ref_count_ = 1;
	_tmp0_ = args;
	_tmp0__length1 = args_length1;
	_tmp1_ = (_tmp0_ != NULL) ? _vala_array_dup2 (_tmp0_, _tmp0__length1) : ((gpointer) _tmp0_);
	_tmp1__length1 = _tmp0__length1;
	_data2_->args = _tmp1_;
	_data2_->args_length1 = _tmp1__length1;
	_tmp2_ = _data2_->args;
	_tmp2__length1 = _data2_->args_length1;
	if (_tmp2__length1 < 3) {
		FILE* _tmp3_;
		gchar** _tmp4_;
		gint _tmp4__length1;
		const gchar* _tmp5_;
		_tmp3_ = stderr;
		_tmp4_ = _data2_->args;
		_tmp4__length1 = _data2_->args_length1;
		_tmp5_ = _tmp4_[0];
		fprintf (_tmp3_, "Usage: %s <iface> <resource> [firstbyte] ...\n", _tmp5_);
		exit (-1);
	}
	_tmp6_ = g_main_loop_new (NULL, FALSE);
	_g_main_loop_unref0 (loop);
	loop = _tmp6_;
	g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, ___lambda2__gsource_func, block2_data_ref (_data2_), block2_data_unref);
	_tmp7_ = loop;
	g_main_loop_run (_tmp7_);
	block2_data_unref (_data2_);
	_data2_ = NULL;
}


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


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	if ((array != NULL) && (destroy_func != NULL)) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}