Agronode_feeder/main.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include <string.h>
#include <time.h>
#include <stdarg.h>
#define SYSLOG_NAMES
#include <syslog.h>
#include <signal.h>
#include <netdb.h>
#include <malloc.h>
#include <math.h>

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/time.h>

#include <netinet/in.h>
#include <arpa/inet.h>

#include <netdb.h>

#include <pthread.h>

#include <dlfcn.h>

#include <confuse.h>


#include "http_lib.h"

#include "simclist.h"

#include "feeder.h"


typedef struct csock_t
{
	int socket;
	void * lib_data;
	uint8_t * buf_data;
	uint32_t buf_data_len;
	struct csock_t * next;
} csock_t;

typedef struct type_t
{
	char name[64];
	unsigned int port;
	int socket;
	char lib[256];
	char address[1024];
	void * dl;
	struct csock_t * csocks;
	unsigned int lib_data_size;
	int proto;
	int timeout;
	int time;
	struct type_t * next;
} type_t;

#define PROTO_NONE	0
#define PROTO_UDP	1
#define PROTO_TCP_PAS	2
#define PROTO_TCP_ACT	3
#define PROTO_SELF	4


#define MAX_THREADS	16

struct type_t * types = NULL;
//!static MYSQL mysql;
static cfg_t * cfg;


int translate(unsigned char * data, unsigned int length, struct type_t * type, unsigned char * reply_data, int * reply_len, int fd);

char * feederGetStringPrio(int priority)
{
    int i;

    i = 0;
    while (prioritynames[i].c_name != NULL)
    {
	if (prioritynames[i].c_val == priority)
	    return prioritynames[i].c_name;
	i++;
    }
    return NULL;
}

void feederLogSyslog(int priority, char * str)
{
    syslog(priority, str);
}

char * feederLogTime(time_t * t)
{
    static char string[32];
    struct tm * timeinfo;
    
    timeinfo = localtime(t);
    
    sprintf(string, "%04d-%02d-%02d %02d:%02d:%02d",
	timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
    
    
    return string;
}


void feederLogFile(int priority, char * str)
{
    FILE * f;
    static int lf_flag = 1;
    time_t t;
    
    time(&t);
    f = fopen(cfg_getstr(cfg, "logfile"), "a");
    if (f == NULL)
	return;
    if (lf_flag)
	fprintf(f, "%s: %s: %s", feederGetStringPrio(priority), feederLogTime(&t), str);
    else
	fprintf(f, str);
    if (str[strlen(str) - 1] == '\n')
	lf_flag = 1;
    else
	lf_flag = 0;
    fclose(f);
}

void feederLogScreen(int priority, char * str)
{
    static int lf_flag = 1;
    time_t t;
    
    time(&t);
    if (lf_flag)
	printf("%s: %s: %s", feederGetStringPrio(priority), feederLogTime(&t), str);
    else
	printf(str);
    if (str[strlen(str) - 1] == '\n')
	lf_flag = 1;
    else
	lf_flag = 0;
}

void feederLog(int priority, const char * fmt, ...)
{
    va_list ap;
    char str[2048];

    if (priority <= cfg_getint(cfg, "loglevel"))
    {
	va_start(ap, fmt);
/*    if (priority <= LOG_WARNING) */
        vsnprintf(str, 2048, (char *)fmt, ap);
	va_end(ap);

        feederLogFile(priority, str);
//	feederLogSyslog(priority, str);
        feederLogScreen(priority, str);
    }
}


void * initLib(struct type_t * type)
{
	void * dl;
	int (* init)(void *);
	int (* setLog)(void *);
	int lib_data_size;
	char * name;
	
	name = type->lib;
	dl = dlopen(name, RTLD_LAZY);
	if (dl == NULL)
	{
		feederLog(LOG_WARNING, "dlopen %s\n", dlerror());
		return NULL;
	}
	else
	{
	
		feederLog(LOG_DEBUG, "Setting log function\n");
		setLog = (int(*)(void *))dlsym(dl, "setLog");//*
		if (setLog != NULL)
		{
			if (setLog((void *)feederLog) < 0)//*
			{
				feederLog(LOG_WARNING, "Library set log failure\n");
			}
		}
		else
			feederLog(LOG_WARNING, "Library set log init\n");
	
		init = (int(*)(void *))dlsym(dl, "init");//*
		if (init != NULL)
		{
			lib_data_size = init(NULL);
			if (lib_data_size < 0)
			{
				feederLog(LOG_WARNING, "Library init failure\n");
				return NULL;
			}
			else
			    type->lib_data_size = lib_data_size;
		}
		else
			feederLog(LOG_WARNING, "Library has not init\n");
	}
	return dl;
}

int setDevIds(struct type_t * type, cfg_t * cfg_type)
{
    unsigned int i;
    int (* devAdd)(unsigned char *, unsigned char);

    for (i = 0; i < cfg_size(cfg_type, "devid"); i++)
    {
	feederLog(LOG_DEBUG, "Inserting dev %s to %s\n", cfg_getnstr(cfg_type, "devid", i), type->name);
	devAdd = (int(*)(unsigned char *, unsigned char))dlsym(type->dl, "devAdd");
		if (devAdd != NULL)
		{
			if (devAdd((unsigned char *)cfg_getnstr(cfg_type, "devid", i), strlen(cfg_getnstr(cfg_type, "devid", i))) < 0)
			{
				feederLog(LOG_WARNING, "Library devid failure\n");
				return -1;
			}
		}
		else
			feederLog(LOG_WARNING, "Library has not devid\n");
    }
    return 0;
}

int initSocketTcpPassive(unsigned int port)
{
	int sock;
	struct sockaddr_in serv_addr;
	unsigned int serv_len;
	int yes = 1;
		
	feederLog(LOG_INFO, "Opening TCP passive socket on port %d\n", port);

	if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
	{
		perror("socket");
		return 0;
	}
	
	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1)
	{
	    perror("socket setsockopt");
	    return 0;
	}

	bzero((char *)&serv_addr, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port = htons(port);
	serv_len = sizeof(serv_addr);

	if (bind(sock, (struct sockaddr *)&serv_addr, serv_len) < 0)
	{
		perror("bind");
		close(sock);
		return 0;
	}

	listen(sock, 10);
	return sock;
}


int initSocketTcpActive(void)
{
	int sock;
		
	feederLog(LOG_INFO, "Opening TCP active socket\n");

	if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
	{
		perror("socket");
		return 0;
	}
	
	return sock;
}

int initSocketUdp(unsigned int port)
{
	int sock;
	struct sockaddr_in serv_addr;
	unsigned int serv_len;
	
	feederLog(LOG_INFO, "Opening UDP socket on port %d\n", port);
	
	if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
	{
		perror("socket");
		return 0;
	}

	bzero((char *)&serv_addr, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port = htons(port);
	serv_len = sizeof(serv_addr);

	if (bind(sock, (struct sockaddr *)&serv_addr, serv_len) < 0)
	{
		perror("bind");
		close(sock);
		return 0;
	}
	return sock;
}

struct type_t * addType(const char * name, const char * lib, unsigned int port, int proto, const char * server_address, int timeout)
{
	struct type_t * type;
	
	if (proto == PROTO_NONE)
	    return NULL;
	type = (type_t *)malloc(sizeof(struct type_t));
	if (type == NULL)
	{
		perror("malloc type");
		return NULL;
	}
	strncpy(type->name, name, 64);
	strncpy(type->lib, lib, 256);
	if (server_address != NULL)
		strncpy(type->address, server_address, 1024);
	else
	    type->address[0] = 0;
	type->port = port;
	type->next = NULL;
	type->csocks = NULL;
	type->proto = proto;
	type->timeout = timeout;
	type->lib_data_size = 0;
	type->time = timeout - 1;
	type->dl = initLib(type);
	
	switch (proto)
	{
	    case PROTO_TCP_ACT:
		type->socket = initSocketTcpActive();
		break;
	    case PROTO_TCP_PAS:
		type->socket = initSocketTcpPassive(type->port);
		break;
	    case PROTO_UDP:
		type->socket = initSocketUdp(type->port);
		break;
	    case PROTO_SELF:
		type->socket = 0;
		break;
	    default:
		break;
	}
	return type;
}

void initTypes(void)
{
	struct type_t * type, * type_last;
	int proto;
	unsigned int i;

	for (i = 0; i < cfg_size(cfg, "type"); i++)
	{
	    cfg_t * cfg_type = cfg_getnsec(cfg, "type", i);
	    feederLog(LOG_INFO, "Adding type %s\n", cfg_title(cfg_type));
	    
	    proto = PROTO_NONE;
	    if (strstr(cfg_getstr(cfg_type, "proto"), "PROTO_TCP_PAS") != NULL)
		proto = PROTO_TCP_PAS;
	    if (strstr(cfg_getstr(cfg_type, "proto"), "PROTO_UDP") != NULL)
		proto = PROTO_UDP;
	    if (strstr(cfg_getstr(cfg_type, "proto"), "PROTO_TCP_ACT") != NULL)
		proto = PROTO_TCP_ACT;
	    if (strstr(cfg_getstr(cfg_type, "proto"), "PROTO_SELF") != NULL)
		proto = PROTO_SELF;
		
	    type = addType(cfg_title(cfg_type),
		cfg_getstr(cfg_type, "lib"),
		cfg_getint(cfg_type, "port"),
		proto,
		cfg_getstr(cfg_type, "server"),
		cfg_getint(cfg_type, "timeout"));
		
	    if (type == NULL)
	    {
		feederLog(LOG_ERR, "Can not initialize type\n");
		exit(-1);
	    }
	    if ((type->socket == 0) && (proto != PROTO_SELF))		// pri neotevreni rovnou skonci at se muzem pokusit o restart
	    {
		feederLog(LOG_WARNING, "Can not create socket\n");
		exit(-1);
	    }
	    setDevIds(type, cfg_type);
		
	    if (types == NULL)
		types = type;
	    else
	    {
		type_last = types;
		while (type_last->next != NULL)
		    type_last = type_last->next;
		type_last->next = type;
	    }
	}
	
	/*
	type = addType("simple", "/usr/lib/simple.so", 3342, PROTO_TCP_PAS, NULL, 0);	//todo:conf, todle je fakt desny
	if (types == NULL)
		types = type;
	type = addType("chod_01", "/usr/lib/chod_01.so", 5910, PROTO_UDP, NULL, 0);
	types->next = type;
	type = addType("senso", "/usr/lib/senso.so", 4242, PROTO_UDP, NULL, 0);
	types->next->next = type;
	type = addType("sb", "/usr/lib/sb.so", 5912, PROTO_TCP_PAS, NULL, 0);
	types->next->next->next = type;
	type = addType("senso_http", "/usr/lib/senso_http.so", 5914, PROTO_TCP_PAS, NULL, 0);
	types->next->next->next->next = type;
	type = addType("logapacts2", "/usr/lib/logapacts2.so", 5913, PROTO_UDP, NULL, 0);
	types->next->next->next->next->next = type;
//	type = addType("CHMI profily toku", "/usr/lib/chmi_tok.so", 80, PROTO_TCP_ACT, "www.chmi.cz/meteo/opss/pocasi/pocasisp.php?ukazatel=stanice&pozadi=mapareg&graf=ne", 2);
////	type = addType("CHMI profily toku", "/usr/lib/chmi_tok.so", 80, PROTO_TCP_ACT, "www.chmi.cz", 2);
//	types->next->next->next->next->next->next = type;
*/
}

/*
int dbaseInsertSingle(const char * table, char * cols, char * values, cfg_t * cfg_db)
{
	char query[8192];
	int id;

	if (!mysql_real_connect(&mysql, cfg_getstr(cfg_db, "server"),
	    cfg_getstr(cfg_db, "user"), cfg_getstr(cfg_db, "password"),
	    cfg_getstr(cfg_db, "dbname"), cfg_getint(cfg_db, "port"), NULL, 0))
	{
		feederLog(LOG_ERR, "Can not connect to database. %s\n", mysql_error(&mysql));
		return 0;
	}
	sprintf(query, "INSERT INTO %s (%s) VALUES (%s)", table, cols, values);
	feederLog(LOG_DEBUG, "Database query: %s\n", query);
	if (mysql_query(&mysql, query))
	{
	    feederLog(LOG_ERR, "%s\n", mysql_error(&mysql));
	}
	id = mysql_insert_id(&mysql);
	
	mysql_close(&mysql);
	return id;
}

int dbaseInsert(const char * table, char * cols, char * values)
{
	unsigned int i;

	for (i = 0; i < cfg_size(cfg, "db"); i++)
	{
	    cfg_t * cfg_db = cfg_getnsec(cfg, "db", i);
	    dbaseInsertSingle(table, cols, values, cfg_db);
	}
	return 0;
}

int dbaseUpdateSingle(const char * table, char * update, char * cols, char * values, char * where, cfg_t * cfg_db)
{
	char query[256];
	my_ulonglong res;

	if (!mysql_real_connect(&mysql, cfg_getstr(cfg_db, "server"),
	    cfg_getstr(cfg_db, "user"), cfg_getstr(cfg_db, "password"),
	    cfg_getstr(cfg_db, "dbname"), cfg_getint(cfg_db, "port"), NULL, CLIENT_FOUND_ROWS))
	{
		feederLog(LOG_ERR, "Can not connect to database. %s\n", mysql_error(&mysql));
		return 0;
	}
	sprintf(query, "UPDATE %s SET %s WHERE %s", table, update, where);
	feederLog(LOG_DEBUG, "Database query: %s\n", query);
	if (mysql_query(&mysql, query))
	{
	    feederLog(LOG_ERR, "%s\n", mysql_error(&mysql));
	}
	res = mysql_affected_rows(&mysql);
	if (res == 0)
	{
	    feederLog(LOG_ERR, "No row for %s in %s, creating ...\n", where, table);
	    sprintf(query, "INSERT INTO %s (%s) VALUES (%s)", table, cols, values);
	    feederLog(LOG_DEBUG, "Database query: %s\n", query);
	    if (mysql_query(&mysql, query))
	    {
		feederLog(LOG_ERR, "%s\n", mysql_error(&mysql));
	    }
	}
	
	mysql_close(&mysql);
	return 1;
}

int dbaseUpdate(const char * table, char * update, char * cols, char * values, char * where)
{
	unsigned int i;

	for (i = 0; i < cfg_size(cfg, "db"); i++)
	{
	    cfg_t * cfg_db = cfg_getnsec(cfg, "db", i);
	    dbaseUpdateSingle(table, update, cols, values, where, cfg_db);
	}
	return 0;
}


int dbaseCheckDeviceSingle(unsigned long long int id, cfg_t * cfg_db)
{
	char query[256];
	MYSQL_RES * res;

	if (!mysql_real_connect(&mysql, cfg_getstr(cfg_db, "server"),
	    cfg_getstr(cfg_db, "user"), cfg_getstr(cfg_db, "password"),
	    cfg_getstr(cfg_db, "dbname"), cfg_getint(cfg_db, "port"), NULL, 0))
	{
		feederLog(LOG_ERR, "Can not connect to database. %s\n", mysql_error(&mysql));
		return 0;
	}
	sprintf(query, "SELECT * FROM device WHERE obj_id='%llu'", id);
	feederLog(LOG_DEBUG, "Database query: %s\n", query);
	if (mysql_query(&mysql, query))
	{
	    feederLog(LOG_WARNING, "%s\n", mysql_error(&mysql));
	    mysql_close(&mysql);
	    return 0;
	}
	res = mysql_store_result(&mysql);
	if ((res == NULL) || (mysql_fetch_row(res) == NULL))
	{
	    feederLog(LOG_DEBUG, "New device %llu\n", id);
	    sprintf(query, "INSERT INTO device (obj_id,disc_timeout) VALUES (%llu, 3600)", id);
	    feederLog(LOG_DEBUG, "Database query: %s\n", query);
	    if (mysql_query(&mysql, query))
	    {
		feederLog(LOG_WARNING, "%s\n", mysql_error(&mysql));
	    }
	    mysql_free_result(res);
	    mysql_close(&mysql);
	    return 2;
	}
	mysql_free_result(res);
	mysql_close(&mysql);
	return 1;
}

int dbaseCheckDevice(unsigned long long int id)
{
	unsigned int i;

	for (i = 0; i < cfg_size(cfg, "db"); i++)
	{
	    cfg_t * cfg_db = cfg_getnsec(cfg, "db", i);
	    dbaseCheckDeviceSingle(id, cfg_db);
	}
	return 0;
}
*/

unsigned char data_test_fm4_1[] = 
{
0x00, 0x0F, 0x33, 0x35, 0x32, 0x38, 0x34, 0x38, 0x30, 0x32, 0x37, 0x38, 0x39, 0x39, 0x37, 0x35, 0x32
};

unsigned char data_test_fm4_2[] = 
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x87, 0x08, 0x1E, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x48,
0x14, 0xAD, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAC, 0x00, 0x6B, 0x09,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x47, 0x29, 0xCB,
0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAC, 0x00, 0x6B, 0x09, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x46, 0x3E, 0xE9, 0x00, 0x08,
0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAA, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x45, 0x53, 0xFD, 0x00, 0x08, 0xB8, 0x99,
0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA5, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x44, 0x69, 0x1B, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D,
0xF0, 0xE0, 0x20, 0x00, 0xA5, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x3A, 0x84, 0x43, 0x7E, 0x39, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0,
0x20, 0x00, 0xA6, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x3A, 0x84, 0x42, 0x93, 0x57, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00,
0xA7, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A,
0x84, 0x41, 0xA8, 0x75, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA9, 0x00,
0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x40,
0xBD, 0x93, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA8, 0x00, 0x6B, 0x09,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x3F, 0xD2, 0xB1,
0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA7, 0x00, 0x6B, 0x09, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x3E, 0xE8, 0x0B, 0x00, 0x08,
0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAA, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x3D, 0xFD, 0x29, 0x00, 0x08, 0xB8, 0x99,
0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAA, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x3D, 0x12, 0x47, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D,
0xF0, 0xE0, 0x20, 0x00, 0xAD, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x3A, 0x84, 0x3C, 0x27, 0x65, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0,
0x20, 0x00, 0xAF, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x3A, 0x84, 0x3B, 0x3C, 0x83, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00,
0xAF, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A,
0x84, 0x3A, 0x51, 0xA1, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAF, 0x00,
0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x39,
0x66, 0xBF, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAC, 0x00, 0x6B, 0x09,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x38, 0x7B, 0xDD,
0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA9, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x37, 0x90, 0xFB, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA9, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x36, 0xA6, 0x19, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA8, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x35, 0xBB, 0x37, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA5, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x34, 0xD0, 0x55, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA5, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x33, 0xE5, 0x73, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA5, 0x00, 0x6B, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x32, 0xFA, 0x91, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xA7, 0x00, 0x6B, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x32, 0x0F, 0xAF, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAB, 0x00, 0x6B, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x31, 0x24, 0xCD, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAB, 0x00, 0x6B, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x30, 0x39, 0xEB, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAD, 0x00, 0x6B, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x2F, 0x4F, 0x09, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAC, 0x00, 0x6B, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x2E, 0x64, 0x27, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAA, 0x00, 0x6B, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3A, 0x84, 0x2D, 0x79, 0x45, 0x00, 0x08, 0xB8, 0x99, 0xA0, 0x1D, 0xF0, 0xE0, 0x20, 0x00, 0xAC, 0x00, 0x6B, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x0F, 0xB6
};

unsigned char data_test_fm4_rfid[] = 
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x08, 0x02, 0x00, 0x00, 0x01, 0x4C, 0x28, 0x82,
	0x70, 0x60, 0x00, 0x0A, 0x5E, 0x0D, 0x27, 0x1D, 0x84, 0x42, 0x0E, 0x01, 0x17, 0x00, 0xCE, 0x14,
	0x00, 0x07, 0x00, 0x16, 0x08, 0x01, 0x01, 0x15, 0x04, 0x4F, 0x00, 0x51, 0x00, 0x52, 0x00, 0x53,
	0x00, 0x55, 0x3F, 0x7F, 0x57, 0x04, 0x43, 0x25, 0xC3, 0x42, 0x34, 0x5D, 0x18, 0x00, 0x07, 0x80,
	0x00, 0x1B, 0x09, 0xC7, 0x00, 0x00, 0x00, 0x19, 0x46, 0x00, 0x00, 0x01, 0x8A, 0x91, 0x00, 0x00,
	0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x66, 0x58, 0x00, 0x00, 0x07,
	0x0E, 0x68, 0x00, 0x00, 0x08, 0x26, 0x87, 0x00, 0x00, 0x00, 0x27, 0x88, 0x00, 0x00, 0x00, 0x00,
	0x01, 0xCF, 0x00, 0x5D, 0x01, 0x00, 0x5D, 0x01, 0x00, 0x5B, 0x00, 0x00, 0x01, 0x4C, 0x28, 0x82,
	0x78, 0x6C, 0x00, 0x0A, 0x5E, 0x0B, 0xB4, 0x1D, 0x84, 0x3F, 0xC0, 0x01, 0x17, 0x00, 0xC9, 0x14,
	0x00, 0x08, 0x00, 0x16, 0x08, 0x01, 0x01, 0x15, 0x04, 0x4F, 0x00, 0x51, 0x00, 0x52, 0x00, 0x53,
	0x00, 0x55, 0x41, 0x7F, 0x57, 0x04, 0x43, 0x25, 0xC2, 0x42, 0x34, 0x67, 0x18, 0x00, 0x07, 0x80,
	0x00, 0x1B, 0x09, 0xC7, 0x00, 0x00, 0x00, 0x05, 0x46, 0x00, 0x00, 0x01, 0x8A, 0x91, 0x00, 0x00,
	0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x66, 0x58, 0x00, 0x00, 0x06,
	0xEB, 0x68, 0x00, 0x00, 0x08, 0x26, 0x87, 0x00, 0x00, 0x00, 0x28, 0x88, 0x00, 0x00, 0x00, 0x00,
	0x01, 0xCF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0xB7, 0x67
};

unsigned char data_test_fm4_rfid_on[] = 
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, 0x08, 0x01, 0x00, 0x00, 0x01, 0x4C, 0x23, 0x62,
	0x86, 0x06, 0x00, 0x0A, 0x5E, 0x6A, 0xE9, 0x1D, 0x84, 0xFE, 0x1E, 0x01, 0x1A, 0x00, 0x87, 0x16,
	0x00, 0x0A, 0x00, 0x15, 0x08, 0x01, 0x01, 0x15, 0x04, 0x4F, 0x00, 0x51, 0x01, 0x52, 0x00, 0x53,
	0x1F, 0x55, 0x58, 0x7F, 0x52, 0x04, 0x43, 0x26, 0x4A, 0x42, 0x35, 0x63, 0x18, 0x00, 0x0A, 0x80,
	0x00, 0x00, 0x08, 0xC7, 0x00, 0x00, 0x00, 0x32, 0x46, 0x00, 0x00, 0x01, 0x61, 0x50, 0x00, 0x00,
	0x00, 0x09, 0x54, 0x00, 0x00, 0x00, 0x66, 0x58, 0x00, 0x00, 0x07, 0x91, 0x68, 0x00, 0x00, 0x06,
	0x19, 0x87, 0x00, 0x00, 0x00, 0x25, 0x88, 0x00, 0x00, 0x00, 0x00, 0x01, 0xCF, 0x00, 0x5D, 0x01,
	0x01, 0x00, 0x0F, 0x9D, 0x5B, 0x01, 0x00, 0x00, 0x29, 0x57
};

unsigned char data_test_acm4_2[] = 
{
/*0x62, 0xc2, 0x92, 0x21, 0xd4, 0x5d, 0x31, 0x5a, 0x27, 0xb1, 0x41, 0x80, 0x00, 0x18, 0x01, 0xfd,
0xfd, 0x00, 0x73, 0x4c, 0x35, 0x10, 0x29, 0x11, 0x04, 0x60, 0x55, 0x10,*/
0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB2, 0x86, 0x01, 0xD4, 0xC4, 0xC5, 0x73, 0x37, 0xA0, 0x72, 0xA8, 0x87, 0xF8, 0x01, 0xA5, 0xA5, 0x00, 0x89, 0x4C, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB2, 0xC5, 0x01, 0xD4, 0xC4, 0x2F, 0x73, 0x37, 0xA0, 0x74, 0x20, 0x87, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x89, 0xF8, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB2, 0xF4, 0xA1, 0xD4, 0xC3, 0xAB, 0x73, 0x37, 0xA0, 0x76, 0x18, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x04, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB3, 0x22, 0x41, 0xD4, 0xC3, 0x79, 0x73, 0x37, 0xA0, 0x78, 0x17, 0x87, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x0D, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB3, 0x22, 0x41, 0xD4, 0xC3, 0x79, 0x73, 0x37, 0xA0, 0x78, 0x17, 0x87, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x0D, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB3, 0x47, 0xA1, 0xD4, 0xC3, 0x43, 0x73, 0x37, 0xA0, 0x7A, 0x16, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x2B, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB3, 0x73, 0x41, 0xD4, 0xC3, 0x13, 0x73, 0x37, 0xA0, 0x7B, 0x96, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x3B, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB3, 0x98, 0x21, 0xD4, 0xC2, 0xAB, 0x73, 0x37, 0xA0, 0x7D, 0x96, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x57, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB3, 0xC0, 0xA1, 0xD4, 0xC2, 0x85, 0x73, 0x37, 0xA0, 0x81, 0x96, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x5B, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB3, 0xC0, 0xA1, 0xD4, 0xC2, 0x85, 0x73, 0x37, 0xA0, 0x81, 0x96, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x5B, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB3, 0xE9, 0x81, 0xD4, 0xC2, 0x57, 0x73, 0x37, 0xA0, 0x83, 0x96, 0x87, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x44, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB4, 0x12, 0xA1, 0xD4, 0xC2, 0x29, 0x73, 0x37, 0xA0, 0x85, 0x17, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x71, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB4, 0x39, 0x21, 0xD4, 0xC1, 0xC5, 0x73, 0x37, 0xA0, 0x87, 0x17, 0x87, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0xAC, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB4, 0x68, 0x01, 0xD4, 0xC1, 0xA1, 0x73, 0x37, 0xA0, 0x88, 0x98, 0x87, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0xD1, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB4, 0x68, 0x01, 0xD4, 0xC1, 0xA1, 0x73, 0x37, 0xA0, 0x88, 0x98, 0x87, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0xD1, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB4, 0x95, 0x81, 0xD4, 0xC1, 0x65, 0x73, 0x37, 0xA0, 0x8B, 0x1A, 0x87, 0xF8, 0x01, 0xA6, 0xA6, 0x00, 0x8B, 0x0C, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB4, 0xC4, 0xE1, 0xD4, 0xC1, 0x2D, 0x73, 0x37, 0xA0, 0x8C, 0x9B, 0x87, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x42, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB4, 0xFA, 0x61, 0xD4, 0xC0, 0xAB, 0x73, 0x37, 0xA0, 0x8E, 0x9C, 0x87, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8A, 0xFD, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB5, 0x2B, 0xE1, 0xD4, 0xC0, 0x71, 0x73, 0x37, 0xA0, 0x90, 0x9C, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8B, 0x86, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB5, 0x2B, 0xE1, 0xD4, 0xC0, 0x71, 0x73, 0x37, 0xA0, 0x90, 0x9C, 0x07, 0xF8, 0x01, 0xA8, 0xA8, 0x00, 0x8B, 0x86, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB5, 0x66, 0x61, 0xD4, 0xC0, 0x25, 0x73, 0x37, 0xA0, 0x92, 0x9D, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x8A, 0x6C, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB5, 0x97, 0x01, 0xD4, 0xBF, 0x85, 0x73, 0x37, 0xA0, 0x94, 0x1C, 0x07, 0xF8, 0x01, 0xA7, 0xA7, 0x00, 0x89, 0xE3, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB5, 0xC6, 0xA1, 0xD4, 0xBF, 0x17, 0x73, 0x37, 0xA0, 0x96, 0x1B, 0x87, 0xF8, 0x01, 0xA6, 0xA6, 0x00, 0x89, 0x8E, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB5, 0xF9, 0x61, 0xD4, 0xBE, 0x45, 0x73, 0x37, 0xA0, 0x97, 0x9A, 0x87, 0xF8, 0x01, 0xA6, 0xA6, 0x00, 0x88, 0x2C, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00, 0x62, 0xB5, 0xF9, 0x61, 0xD4, 0xBE, 0x45, 0x73, 0x37, 0xA0, 0x97, 0x9A, 0x87, 0xF8, 0x01, 0xA6, 0xA6, 0x00, 0x88, 0x2C, 0x35, 0x10
};

unsigned char data_test_acm4_1[] = 
{
0x62, 0xc2, 0x92, 0x21, 0xd4, 0x5d, 0x31, 0x5a, 0x27, 0xb1, 0x41, 0x80, 0x00, 0x18, 0x01, 0xfd,
0xfd, 0x00, 0x73, 0x4c, 0x35, 0x10, 0x29, 0x11, 0x04, 0x60, 0x55, 0x10,
/*0xC0, 0x54, 0x26, 0xB2, 0x35, 0x10, 0x29, 0x11, 0x04, 0x52, 0x35, 0x00,*/ 0x33, 0x35, 0x31, 0x30, 0x32, 0x39, 0x31, 0x31, 0x30, 0x34, 0x35, 0x32, 0x33, 0x35, 0x30, 0x30, 0x41, 0x4C, 0x41, 0x52, 0x4D, 0x20, 0x31, 0x39, 0x2F, 0x30, 0x33, 0x2F, 0x31, 0x30, 0x20, 0x31, 0x38, 0x3A, 0x33, 0x38, 0x20, 0x47
};

unsigned char data_test_acm4[] = 
{
0x00, 0x0a, 0x02, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x31, 0x33, 0x35,
0x31, 0x30, 0x32, 0x39, 0x31, 0x31, 0x30, 0x34, 0x36, 0x30, 0x35, 0x35, 0x31, 0x30, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 
0x62, 0xc2, 0x92, 0x21, 0xd4, 0x5d, 0x31, 0x5a, 0x27, 0xb1, 0x41, 0x80, 0x00, 0x18, 0x01, 0xfd,
0xfd, 0x00, 0x73, 0x4c, 0x35, 0x10, 0x29, 0x11, 0x04, 0x60, 0x55, 0x10
/*
0x62, 0xc2, 0xac, 0x21, 0xd4, 0x5f, 0xaf, 0x5a, 0x27, 0xad, 0xf8, 0x00,
0x00, 0x18, 0x01, 0xfd, 0xfd, 0x00, 0x08, 0x81, 0x35, 0x10, 0x29, 0x11, 0x04, 0x60, 0x55, 0x10*/
};

unsigned char data_test[] = 
{
/*0x00,0x0f,0x33,0x35,0x33,0x39,0x37,0x36,0x30,0x31,0x33,0x33,0x31,0x34,0x38,0x37
,0x31,*/
      0x00,0x00,0x00,0x00,0x00,0x00,0x0a,0xbb,0x07,0x38,0x43,0x54,0x96,0xe5,0x0f
,0xff,0x42,0x45,0xb0,0x11,0x41,0x6a,0x8a,0xba,0x01,0xcc,0x00,0x00,0x0a,0x25,0x44
,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d
,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0xe1,0x43,0x54,0x96,0xda
,0x0f,0xff,0x42,0x45,0xb0,0x11,0x41,0x6a,0x8a,0xbd,0x01,0xcc,0x38,0x00,0x0a,0x25
,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00
,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0xd7,0x43,0x54,0x96
,0xd1,0x0f,0xff,0x42,0x45,0xb0,0x11,0x41,0x6a,0x8a,0xc2,0x01,0xcc,0x31,0x00,0x0a
,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14
,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0xcd,0x43,0x54
,0x96,0xc7,0x0f,0xff,0x42,0x45,0xb0,0x11,0x41,0x6a,0x8a,0xc6,0x01,0xcc,0x66,0x00
,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03
,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0xc3,0x43
,0x54,0x96,0xbc,0x0f,0xff,0x42,0x45,0xb0,0x13,0x41,0x6a,0x8a,0xc8,0x01,0xcd,0x9b
,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01
,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0xb9
,0x43,0x54,0x96,0xb3,0x0f,0xff,0x42,0x45,0xb0,0x15,0x41,0x6a,0x8a,0xc9,0x01,0xcd
,0xa5,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02
,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d
,0xaf,0x43,0x54,0x96,0xa9,0x0f,0xff,0x42,0x45,0xb0,0x17,0x41,0x6a,0x8a,0xd0,0x01
,0xcd,0xf7,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61
,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00
,0x0d,0xa5,0x43,0x54,0x96,0x9e,0x0f,0xff,0x42,0x45,0xb0,0x11,0x41,0x6a,0x8a,0xd0
,0x01,0xcc,0xc3,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01
,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00
,0x00,0x0d,0x9b,0x43,0x54,0x96,0x94,0x0f,0xff,0x42,0x45,0xb0,0x11,0x41,0x6a,0x8a
,0xdc,0x01,0xcb,0xe0,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02
,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05
,0x00,0x00,0x0d,0x90,0x43,0x54,0x96,0x8b,0x0f,0xff,0x42,0x45,0xb0,0x0e,0x41,0x6a
,0x8a,0xe9,0x01,0xca,0x89,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9
,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01
,0x05,0x00,0x00,0x0d,0x87,0x43,0x54,0x96,0x80,0x0f,0xff,0x42,0x45,0xb0,0x0a,0x41
,0x6a,0x8a,0xea,0x01,0xc9,0x45,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59
,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15
,0x01,0x05,0x00,0x00,0x0d,0x7d,0x43,0x54,0x96,0x76,0x0f,0xff,0x42,0x45,0xb0,0x09
,0x41,0x6a,0x8a,0xf7,0x01,0xc9,0x00,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00
,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00
,0x15,0x01,0x05,0x00,0x00,0x0d,0x72,0x43,0x54,0x96,0x6d,0x0f,0xff,0x42,0x45,0xb0
,0x09,0x41,0x6a,0x8a,0xf7,0x01,0xc9,0x00,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00
,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16
,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0x69,0x43,0x54,0x96,0x62,0x0f,0xff,0x42,0x45
,0xb0,0x0a,0x41,0x6a,0x8a,0xf7,0x01,0xc9,0x82,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f
,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10
,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0x5f,0x43,0x54,0x96,0x58,0x0f,0xff,0x42
,0x45,0xb0,0x0b,0x41,0x6a,0x8a,0xf8,0x01,0xc9,0x05,0x00,0x0a,0x25,0x44,0xa0,0x75
,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00
,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0x54,0x43,0x54,0x96,0x4f,0x0f,0xff
,0x42,0x45,0xb0,0x08,0x41,0x6a,0x8a,0xf8,0x01,0xc8,0x97,0x00,0x0a,0x25,0x44,0xa0
,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15
,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0x4b,0x43,0x54,0x96,0x44,0x0f
,0xff,0x42,0x45,0xb0,0x09,0x41,0x6a,0x8a,0xf7,0x01,0xc8,0x81,0x00,0x0a,0x25,0x44
,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e
,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0x41,0x43,0x54,0x96,0x3a
,0x0f,0xff,0x42,0x45,0xb0,0x0a,0x41,0x6a,0x8a,0xf7,0x01,0xc8,0x33,0x00,0x0a,0x25
,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00
,0x0e,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0x36,0x43,0x54,0x96
,0x31,0x0f,0xff,0x42,0x45,0xb0,0x0b,0x41,0x6a,0x8a,0xf3,0x01,0xc8,0x40,0x00,0x0a
,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14
,0x00,0x0e,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0x2d,0x43,0x54
,0x96,0x26,0x0f,0xff,0x42,0x45,0xb0,0x0b,0x41,0x6a,0x8a,0xf3,0x01,0xc8,0x78,0x00
,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03
,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0x23,0x43
,0x54,0x96,0x1c,0x0f,0xff,0x42,0x45,0xb0,0x0c,0x41,0x6a,0x8a,0xf5,0x01,0xc9,0x1d
,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01
,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d,0x18
,0x43,0x54,0x96,0x13,0x0f,0xff,0x42,0x45,0xb0,0x0b,0x41,0x6a,0x8a,0xf1,0x01,0xc9
,0x64,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02
,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d
,0x0f,0x43,0x54,0x96,0x08,0x0f,0xff,0x42,0x45,0xb0,0x0c,0x41,0x6a,0x8a,0xf5,0x01
,0xc9,0x49,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61
,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00
,0x0d,0x05,0x43,0x54,0x95,0xfe,0x0f,0xff,0x42,0x45,0xb0,0x0d,0x41,0x6a,0x8a,0xf3
,0x01,0xc9,0x53,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01
,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00
,0x00,0x0c,0xfa,0x43,0x54,0x95,0xf4,0x0f,0xff,0x42,0x45,0xb0,0x0c,0x41,0x6a,0x8a
,0xf3,0x01,0xc9,0x06,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02
,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05
,0x00,0x00,0x0c,0xf0,0x43,0x54,0x95,0xea,0x0f,0xff,0x42,0x45,0xb0,0x0a,0x41,0x6a
,0x8a,0xee,0x01,0xc9,0x7a,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9
,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00,0x15,0x01
,0x05,0x00,0x00,0x0c,0xe7,0x43,0x54,0x95,0xe0,0x0f,0xff,0x42,0x45,0xb0,0x0b,0x41
,0x6a,0x8a,0xec,0x01,0xc9,0x6b,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59
,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00,0x15
,0x01,0x05,0x00,0x00,0x0c,0xdc,0x43,0x54,0x95,0xd6,0x0f,0xff,0x42,0x45,0xb0,0x0b
,0x41,0x6a,0x8a,0xea,0x01,0xc9,0x9d,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00
,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16,0x00
,0x15,0x01,0x05,0x00,0x00,0x0c,0xd2,0x43,0x54,0x95,0xcc,0x0f,0xff,0x42,0x45,0xb0
,0x0b,0x41,0x6a,0x8a,0xe9,0x01,0xc9,0x21,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00
,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10,0x16
,0x00,0x15,0x01,0x05,0x00,0x00,0x0c,0xc9,0x43,0x54,0x95,0xc3,0x0f,0xff,0x42,0x45
,0xb0,0x0a,0x41,0x6a,0x8a,0xe7,0x01,0xc9,0x39,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f
,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0e,0x15,0x00,0x10
,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0c,0xbf,0x43,0x54,0x95,0xb9,0x0f,0xff,0x42
,0x45,0xb0,0x0a,0x41,0x6a,0x8a,0xe7,0x01,0xc9,0x50,0x00,0x09,0x25,0x44,0xa0,0x75
,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0f,0x15,0x00
,0x11,0x16,0x00,0x16,0x01,0x05,0x00,0x00,0x0c,0xb5,0x43,0x54,0x95,0xae,0x0f,0xff
,0x42,0x45,0xb0,0x0a,0x41,0x6a,0x8a,0xe9,0x01,0xc9,0x6f,0x00,0x09,0x25,0x44,0xa0
,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0f,0x15
,0x00,0x11,0x16,0x00,0x16,0x01,0x05,0x00,0x00,0x0c,0xab,0x43,0x54,0x95,0xa5,0x0f
,0xff,0x42,0x45,0xb0,0x0b,0x41,0x6a,0x8a,0xe5,0x01,0xca,0x7b,0x00,0x09,0x25,0x44
,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0f
,0x15,0x00,0x11,0x16,0x00,0x16,0x01,0x05,0x00,0x00,0x0c,0xa1,0x43,0x54,0x95,0x9b
,0x0f,0xff,0x42,0x45,0xb0,0x0e,0x41,0x6a,0x8a,0xe2,0x01,0xcb,0x51,0x00,0x09,0x25
,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00
,0x0f,0x15,0x00,0x11,0x16,0x00,0x16,0x01,0x05,0x00,0x00,0x0c,0x97,0x43,0x54,0x95
,0x7d,0x0f,0xff,0x42,0x45,0xb0,0x10,0x41,0x6a,0x8a,0xd7,0x01,0xcb,0x6d,0x00,0x09
,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14
,0x00,0x0f,0x15,0x00,0x11,0x16,0x00,0x16,0x01,0x05,0x00,0x00,0x0c,0x79,0x43,0x54
,0x95,0x72,0x0f,0xff,0x42,0x45,0xb0,0x11,0x41,0x6a,0x8a,0xd7,0x01,0xcc,0x76,0x00
,0x09,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03
,0x14,0x00,0x0f,0x15,0x00,0x11,0x16,0x00,0x16,0x01,0x05,0x00,0x00,0x0c,0x6f,0x43
,0x54,0x95,0x90,0x0f,0xff,0x42,0x45,0xb0,0x0e,0x41,0x6a,0x8a,0xe0,0x01,0xca,0x73
,0x00,0x09,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01
,0x03,0x14,0x00,0x0f,0x15,0x00,0x11,0x16,0x00,0x16,0x01,0x05,0x00,0x00,0x0c,0x8d
,0x43,0x54,0x95,0x87,0x0f,0xff,0x42,0x45,0xb0,0x0f,0x41,0x6a,0x8a,0xde,0x01,0xcb
,0x11,0x00,0x09,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02
,0x01,0x03,0x14,0x00,0x0f,0x15,0x00,0x11,0x16,0x00,0x16,0x01,0x05,0x00,0x00,0x0c
,0x83,0x43,0x54,0x97,0x99,0x0f,0xff,0x42,0x45,0xb0,0x03,0x41,0x6a,0x8a,0xdb,0x01
,0xc7,0x00,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61
,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x14,0x01,0x05,0x00,0x00
,0x0e,0x95,0x43,0x54,0x97,0x8e,0x0f,0xff,0x42,0x45,0xb0,0x03,0x41,0x6a,0x8a,0xdb
,0x01,0xc7,0x00,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01
,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x14,0x01,0x05,0x00
,0x00,0x0e,0x8b,0x43,0x54,0x97,0x85,0x0f,0xff,0x42,0x45,0xb0,0x01,0x41,0x6a,0x8a
,0xdc,0x01,0xc6,0xc2,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02
,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05
,0x00,0x00,0x0e,0x81,0x43,0x54,0x97,0x7b,0x0f,0xff,0x42,0x45,0xb0,0x00,0x41,0x6a
,0x8a,0xfe,0x01,0xc4,0x00,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9
,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01
,0x05,0x00,0x00,0x0e,0x77,0x43,0x54,0x97,0x70,0x0f,0xff,0x42,0x45,0xb0,0x00,0x41
,0x6a,0x8a,0xfa,0x01,0xc4,0x8b,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59
,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15
,0x01,0x05,0x00,0x00,0x0e,0x6d,0x43,0x54,0x97,0x67,0x0f,0xff,0x42,0x45,0xb0,0x01
,0x41,0x6a,0x8a,0xf7,0x01,0xc4,0x76,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00
,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00
,0x15,0x01,0x05,0x00,0x00,0x0e,0x63,0x43,0x54,0x97,0x5d,0x0f,0xff,0x42,0x45,0xb0
,0x00,0x41,0x6a,0x8a,0xf3,0x01,0xc4,0x89,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00
,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16
,0x00,0x15,0x01,0x05,0x00,0x00,0x0e,0x59,0x43,0x54,0x97,0x52,0x0f,0xff,0x42,0x45
,0xb0,0x01,0x41,0x6a,0x8a,0xf0,0x01,0xc4,0xac,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f
,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10
,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0e,0x4f,0x43,0x54,0x97,0x49,0x0f,0xff,0x42
,0x45,0xb0,0x01,0x41,0x6a,0x8a,0xf1,0x01,0xc4,0x93,0x00,0x0a,0x25,0x44,0xa0,0x75
,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00
,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0e,0x45,0x43,0x54,0x97,0x3f,0x0f,0xff
,0x42,0x45,0xb0,0x01,0x41,0x6a,0x8a,0xea,0x01,0xc5,0x5d,0x00,0x0a,0x25,0x44,0xa0
,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15
,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0e,0x3b,0x43,0x54,0x97,0x34,0x0f
,0xff,0x42,0x45,0xb0,0x02,0x41,0x6a,0x8a,0xe9,0x01,0xc5,0x4a,0x00,0x0a,0x25,0x44
,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00,0x0d
,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0e,0x31,0x43,0x54,0x97,0x2b
,0x0f,0xff,0x42,0x45,0xb0,0x03,0x41,0x6a,0x8a,0xe0,0x01,0xc6,0x47,0x00,0x0a,0x25
,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14,0x00
,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0e,0x27,0x43,0x54,0x97
,0x21,0x0f,0xff,0x42,0x45,0xb0,0x04,0x41,0x6a,0x8a,0xdb,0x01,0xc6,0x93,0x00,0x0a
,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03,0x14
,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0e,0x1d,0x43,0x54
,0x97,0x16,0x0f,0xff,0x42,0x45,0xb0,0x06,0x41,0x6a,0x8a,0xdb,0x01,0xc6,0x42,0x00
,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01,0x03
,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0e,0x13,0x43
,0x54,0x97,0x0d,0x0f,0xff,0x42,0x45,0xb0,0x08,0x41,0x6a,0x8a,0xcd,0x01,0xc7,0x60
,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02,0x01
,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0e,0x09
,0x43,0x54,0x97,0x03,0x0f,0xff,0x42,0x45,0xb0,0x09,0x41,0x6a,0x8a,0xc9,0x01,0xc8
,0xc2,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61,0x02
,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00,0x0d
,0xff,0x43,0x54,0x96,0xf8,0x0f,0xff,0x42,0x45,0xb0,0x0b,0x41,0x6a,0x8a,0xc2,0x01
,0xc9,0x44,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01,0x61
,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00,0x00
,0x0d,0xf5,0x43,0x54,0x96,0xef,0x0f,0xff,0x42,0x45,0xb0,0x11,0x41,0x6a,0x8a,0xba
,0x01,0xcc,0x00,0x00,0x0a,0x25,0x44,0xa0,0x75,0x1f,0x00,0x00,0x59,0xd9,0x02,0x01
,0x61,0x02,0x01,0x03,0x14,0x00,0x0d,0x15,0x00,0x10,0x16,0x00,0x15,0x01,0x05,0x00
,0x00,0x0d,0xeb,0x38,0x00,0x00,0x6d,0xc9
};


unsigned char d1_1[] = {0x00, 0x0F, 0x33, 0x35, 0x33, 0x39, 0x37, 0x36, 0x30, 0x31, 0x33, 0x33, 0x35, 0x33, 0x37, 0x38, 0x38};

unsigned char d2_1[] = {0x00, 0x0F, 0x33, 0x35, 0x32, 0x38, 0x34, 0x38, 0x30, 0x32, 0x38, 0x32, 0x32, 0x34, 0x39, 0x32, 0x37};


	unsigned char d1_2[] = {
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x87, 0x08, 0x1E, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F,
		0x3C, 0xB3, 0x00, 0x08, 0xA8, 0xBC, 0x90, 0x1D, 0xF3, 0xFA, 0xA0, 0x00, 0xA3, 0x01, 0x46, 0x0B,
		0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F, 0x38, 0x85,
		0x00, 0x08, 0xA8, 0xBD, 0x20, 0x1D, 0xF3, 0xF9, 0xA0, 0x00, 0xA3, 0x00, 0x02, 0x0B, 0x00, 0x0E,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F, 0x28, 0xA0, 0x00, 0x08,
		0xA8, 0xB7, 0xE0, 0x1D, 0xF3, 0xF5, 0xE0, 0x00, 0xA2, 0x00, 0x20, 0x0B, 0x00, 0x0E, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F, 0x24, 0x72, 0x00, 0x08, 0xA8, 0xB7,
		0x00, 0x1D, 0xF3, 0xF4, 0xA0, 0x00, 0xA3, 0x00, 0x03, 0x0B, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F, 0x20, 0x44, 0x00, 0x08, 0xA8, 0xB7, 0x60, 0x1D,
		0xF3, 0xF3, 0x20, 0x00, 0xA3, 0x01, 0x50, 0x0B, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F, 0x0C, 0x77, 0x00, 0x08, 0xA8, 0xC6, 0x40, 0x1D, 0xF3, 0xE9,
		0xC0, 0x00, 0xA0, 0x01, 0x31, 0x0A, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x01, 0x3B, 0xB7, 0x8F, 0x8D, 0xAF, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00,
		0xAB, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B,
		0xB7, 0x8E, 0xA2, 0xA6, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xA3, 0x00,
		0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7};

	unsigned char d2_2[] = {
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x87, 0x08, 0x1E, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F,
		0x3B, 0x6E, 0x00, 0x08, 0xA8, 0xBD, 0x20, 0x1D, 0xF3, 0xFC, 0x00, 0x00, 0xA7, 0x01, 0x49, 0x0A,
		0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F, 0x37, 0x4A,
		0x00, 0x08, 0xA8, 0xBD, 0xE0, 0x1D, 0xF3, 0xFB, 0x60, 0x00, 0xA8, 0x01, 0x59, 0x0A, 0x00, 0x09,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F, 0x33, 0x26, 0x00, 0x08,
		0xA8, 0xBE, 0x40, 0x1D, 0xF3, 0xFA, 0xA0, 0x00, 0xA7, 0x00, 0x0E, 0x0A, 0x00, 0x0C, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F, 0x2A, 0xDE, 0x00, 0x08, 0xA8, 0xBC,
		0xF0, 0x1D, 0xF3, 0xF9, 0x00, 0x00, 0xA7, 0x00, 0x28, 0x0A, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x8F, 0x26, 0xB0, 0x00, 0x08, 0xA8, 0xBB, 0xA0, 0x1D,
		0xF3, 0xF8, 0x20, 0x00, 0xA7, 0x00, 0x1E, 0x0A, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x01, 0x3B, 0xBC, 0x86, 0x1E, 0xBD, 0x00, 0x08, 0xAB, 0x7C, 0x00, 0x1D, 0xF2, 0x06,
		0xA0, 0x00, 0xA7, 0x01, 0x44, 0x0B, 0x00, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x01, 0x3B, 0xBC, 0x86, 0x0A, 0xB3, 0x00, 0x08, 0xAB, 0xA0, 0xB0, 0x1D, 0xF1, 0xE5, 0xE0, 0x00,
		0xA8, 0x01, 0x43, 0x0B, 0x00, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B,
		0xBC, 0x85, 0xF6, 0xA9, 0x00, 0x08, 0xAB, 0xC7, 0xA0, 0x1D, 0xF1, 0xC7, 0x40, 0x00, 0xAA, 0x01,
		0x3C, 0x0B, 0x00, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x85,
		0xE2, 0x9F, 0x00, 0x08, 0xAB, 0xF2, 0x50, 0x1D, 0xF1, 0xAA, 0x40, 0x00, 0xAC, 0x01, 0x3C, 0x0B,
		0x00, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x85, 0xCE, 0x9E,
		0x00, 0x08, 0xAC, 0x1D, 0x00, 0x1D, 0xF1, 0x8D, 0xA0, 0x00, 0xB0, 0x01, 0x3A, 0x0B, 0x00, 0x50,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x85, 0xC2, 0xA1, 0x00, 0x08,
		0xAC, 0x42, 0x90, 0x1D, 0xF1, 0x79, 0x60, 0x00, 0xB1, 0x01, 0x30, 0x0B, 0x00, 0x51, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x85, 0xAE, 0x97, 0x00, 0x08, 0xAC, 0x76,
		0xC0, 0x1D, 0xF1, 0x63, 0x40, 0x00, 0xB4, 0x01, 0x2E, 0x0B, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x76, 0xB0, 0x13, 0x00, 0x08, 0xB1, 0x51, 0xD0, 0x1D,
		0xEF, 0x8C, 0x20, 0x00, 0xAF, 0x00, 0x17, 0x0A, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x01, 0x3B, 0xBC, 0x76, 0x88, 0x81, 0x00, 0x08, 0xB1, 0x3B, 0x50, 0x1D, 0xEF, 0x6A,
		0xA0, 0x00, 0xB0, 0x00, 0x18, 0x0B, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x01, 0x3B, 0xBC, 0x76, 0x64, 0xD7, 0x00, 0x08, 0xB1, 0x21, 0x20, 0x1D, 0xEF, 0x48, 0xC0, 0x00,
		0xAE, 0x00, 0x19, 0x0B, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B,
		0xBC, 0x76, 0x3D, 0x4E, 0x00, 0x08, 0xB1, 0x06, 0xC0, 0x1D, 0xEF, 0x26, 0xA0, 0x00, 0xAE, 0x00,
		0x10, 0x0B, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x76,
		0x38, 0xEE, 0x00, 0x08, 0xB1, 0x05, 0xB0, 0x1D, 0xEF, 0x25, 0x00, 0x00, 0xAF, 0x00, 0x06, 0x0B,
		0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x76, 0x34, 0x86,
		0x00, 0x08, 0xB1, 0x05, 0x10, 0x1D, 0xEF, 0x23, 0x40, 0x00, 0xAF, 0x01, 0x5C, 0x0B, 0x00, 0x0C,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x76, 0x30, 0x24, 0x00, 0x08,
		0xB1, 0x05, 0x40, 0x1D, 0xEF, 0x21, 0xA0, 0x00, 0xAE, 0x01, 0x50, 0x0B, 0x00, 0x08, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x76, 0x2B, 0xC4, 0x00, 0x08, 0xB1, 0x05,
		0x80, 0x1D, 0xEF, 0x20, 0x80, 0x00, 0xAE, 0x01, 0x46, 0x0B, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x76, 0x27, 0x64, 0x00, 0x08, 0xB1, 0x06, 0x30, 0x1D,
		0xEF, 0x1F, 0xC0, 0x00, 0xAD, 0x01, 0x3A, 0x0B, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x01, 0x3B, 0xBC, 0x76, 0x1F, 0x1C, 0x00, 0x08, 0xB1, 0x09, 0x80, 0x1D, 0xEF, 0x1D,
		0xC0, 0x00, 0xAE, 0x01, 0x2B, 0x0B, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x01, 0x3B, 0xBC, 0x75, 0xF3, 0xAC, 0x00, 0x08, 0xB1, 0x2C, 0xE0, 0x1D, 0xEF, 0x14, 0x80, 0x00,
		0xAF, 0x01, 0x1F, 0x0B, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B,
		0xBC, 0x75, 0xA1, 0x23, 0x00, 0x08, 0xB1, 0x2D, 0xB0, 0x1D, 0xEF, 0x14, 0x80, 0x00, 0xB2, 0x00,
		0x75, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x74,
		0xB6, 0x41, 0x00, 0x08, 0xB1, 0x2D, 0xB0, 0x1D, 0xEF, 0x14, 0x80, 0x00, 0xB2, 0x00, 0x75, 0x0B,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x73, 0xCB, 0x68,
		0x00, 0x08, 0xB1, 0x26, 0x70, 0x1D, 0xEF, 0x17, 0x40, 0x00, 0xB1, 0x00, 0x74, 0x0B, 0x00, 0x10,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x73, 0xA3, 0xE0, 0x00, 0x08,
		0xB1, 0x08, 0x90, 0x1D, 0xEF, 0x1E, 0x60, 0x00, 0xAD, 0x00, 0x68, 0x0B, 0x00, 0x11, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x73, 0x9F, 0x80, 0x00, 0x08, 0xB1, 0x05,
		0xF0, 0x1D, 0xEF, 0x1E, 0xC0, 0x00, 0xAC, 0x00, 0x5A, 0x0B, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xBC, 0x73, 0x9B, 0x20, 0x00, 0x08, 0xB1, 0x03, 0x60, 0x1D,
		0xEF, 0x1E, 0xC0, 0x00, 0xAC, 0x00, 0x3E, 0x0B, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x01, 0x3B, 0xBC, 0x73, 0x96, 0xC0, 0x00, 0x08, 0xB1, 0x01, 0x40, 0x1D, 0xEF, 0x1E,
		0x20, 0x00, 0xAD, 0x00, 0x27, 0x0B, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00,
		0x00, 0x85, 0x5A};



	unsigned char d1_3[] = {
		0x8D, 0xB7, 0xC5, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xAB, 0x00, 0x00,
		0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x8C, 0xCC,
		0xE4, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xA7, 0x00, 0x00, 0x0B, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x8B, 0xE2, 0x03, 0x00,
		0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xA8, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x8A, 0xF7, 0x22, 0x00, 0x08, 0xB8,
		0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xAA, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x8A, 0x0C, 0x42, 0x00, 0x08, 0xB8, 0x9D, 0x10,
		0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xA8, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x89, 0x21, 0x61, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0,
		0xE0, 0xC0, 0x00, 0xAC, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x01, 0x3B, 0xB7, 0x88, 0x36, 0x80, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0,
		0x00, 0xAD, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
		0x3B, 0xB7, 0x87, 0x4B, 0x9F, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xA9,
		0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7,
		0x86, 0x60, 0xBF, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xA9, 0x00, 0x00,
		0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x85, 0x75,
		0xDE, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xA8, 0x00, 0x00, 0x0B, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x84, 0x8A, 0xFD, 0x00,
		0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xAA, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x83, 0xA0, 0x1C, 0x00, 0x08, 0xB8,
		0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xAA, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x82, 0xB5, 0x3B, 0x00, 0x08, 0xB8, 0x9D, 0x10,
		0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xAD, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x81, 0xCA, 0x5B, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0,
		0xE0, 0xC0, 0x00, 0xAF, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x01, 0x3B, 0xB7, 0x80, 0xDF, 0x7A, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0,
		0x00, 0xAE, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
		0x3B, 0xB7, 0x7F, 0xF4, 0x99, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xAA,
		0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7,
		0x7F, 0x09, 0xB8, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xA6, 0x00, 0x00,
		0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x7E, 0x1E,
		0xD7, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xA9, 0x00, 0x00, 0x09, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x7D, 0x33, 0xF7, 0x00,
		0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xAB, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x7C, 0x49, 0x16, 0x00, 0x08, 0xB8,
		0x9D, 0x10, 0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xAD, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x7B, 0x5E, 0x35, 0x00, 0x08, 0xB8, 0x9D, 0x10,
		0x1D, 0xF0, 0xE0, 0xC0, 0x00, 0xAE, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x01, 0x3B, 0xB7, 0x7A, 0x73, 0x91, 0x00, 0x08, 0xB8, 0x9D, 0x10, 0x1D, 0xF0,
		0xE0, 0xC0, 0x00, 0xB0, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E,
		0x00, 0x00, 0xC4, 0x6E};

unsigned char lwf0[] = {
0xFF, 0x09, 0x9C, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x08, 0x00, 0x00, 0xC0, 0x7F, 0x00, 0x00
};

unsigned char lwf1[] = {
0xFF, 0xF1, 0x9F, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x90, 0xF5, 0x34, 0x1D, 0xE9, 0x9F, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x32, 0x6B, 0x1B, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0xCD, 0x4C, 0x78, 0x44, 0x00, 0x70, 0x0E, 0x45, 0x14, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x00, 0xC8, 0x41, 0x00, 0xD0, 0xDD, 0x70, 0x18, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x66, 0x66, 0x50, 0x42, 0x00, 0xC0, 0x3D, 0x04, 0x1C, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x66, 0x66, 0x06, 0x40, 0x00, 0xB0, 0x16, 0x04, 0x1C, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x9A, 0x99, 0x99, 0x3F, 0x00, 0xD0, 0x64, 0x04, 0x1C, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x66, 0x66, 0x46, 0x40, 0x00, 0xF0, 0xB2, 0x04, 0x1C, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x65, 0x43, 0x00, 0xE0, 0x8B, 0x04, 0x1C, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x51, 0x43, 0x00, 0x00, 0xDA, 0x04, 0x1C, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x80, 0x80, 0x43, 0x00, 0x30, 0x26, 0x09, 0x19, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x6C, 0xA8, 0x67, 0x41, 0x00, 0x10, 0x5F, 0x9C, 0x1C, 0x14, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xAD, 0x9C, 0x1C, 0x15, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x86, 0x9C, 0x1C, 0x15, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x1C, 0x35, 0x1D, 0x15, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0x43, 0x35, 0x1D, 0x15, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

unsigned char lwf2[] = {
0xFF, 0xF1, 0x9F, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x10, 0x00, 0x00, 0x90, 0xF5, 0x34, 0x1D, 0x15, 0xA1, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC6, 0x75, 0x15, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0xEC, 0x40, 0x46, 0x00, 0xF0, 0x73, 0x77, 0x15, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x98, 0x41, 0x00, 0x10, 0x32, 0x6B, 0x1B, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x80, 0x78, 0x44, 0x00, 0x70, 0x0E, 0x45, 0x14, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0xCD, 0xCC, 0x98, 0x41, 0x00, 0xD0, 0xDD, 0x70, 0x18, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x66, 0x66, 0x82, 0x42, 0x00, 0xC0, 0x3D, 0x04, 0x1C, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0xCD, 0xCC, 0x4C, 0x3F, 0x00, 0xB0, 0x16, 0x04, 0x1C, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x9A, 0x99, 0x19, 0x3F, 0x00, 0xD0, 0x64, 0x04, 0x1C, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x66, 0x66, 0x66, 0x3F, 0x00, 0xF0, 0xB2, 0x04, 0x1C, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x3E, 0x43, 0x00, 0xE0, 0x8B, 0x04, 0x1C, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x2F, 0x43, 0x00, 0x00, 0xDA, 0x04, 0x1C, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x46, 0x43, 0x00, 0x30, 0x26, 0x09, 0x19, 0xF8, 0xF8, 0xBC, 0x51, 0x08, 0x01, 0x89, 0x46, 0x41, 0x00, 0x10, 0x5F, 0x9C, 0x1C, 0xF9, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xAD, 0x9C, 0x1C, 0xF9, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x86, 0x9C, 0x1C, 0xF9, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

unsigned char lwf3[] = {
0xFF, 0xF1, 0x9F, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0xA0, 0x1C, 0x35, 0x1D, 0xF9, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0x43, 0x35, 0x1D, 0xF9, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0xF5, 0x34, 0x1D, 0xF9, 0xF8, 0xBC, 0x51, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

unsigned char fm4_cihon_west_hemi[] = {
	       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x08, 0x01, 0x00, 0x00, 0x01, 0x4E, 0x44, 0x68,
	       0x07, 0x18, 0x01, 0xFE, 0xBC, 0xF2, 0x90, 0x15, 0xE8, 0x7E, 0x40, 0x00, 0x25, 0x01, 0x0E, 0x04,
	       0x00, 0x0E, 0x18, 0x06, 0x03, 0x01, 0x00, 0x45, 0x01, 0x15, 0x00, 0x03, 0x42, 0x34, 0x97, 0x46,
	       0x01, 0xC0, 0x18, 0x00, 0x0E, 0x00, 0x00, 0x01, 0x00, 0x00, 0x99, 0x5A
};

unsigned char sensob_honey1[] = {
0xFF, 0x01, 0xED, 0x32, 0x06, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x03, 0x00, 0x00, 0x41, 0xA7, 0x6B, 0x1B, 0xCC, 0x67, 0xE3, 0x55, 0x08, 0x52, 0xB8, 0x4E, 0x40, 0x00, 0x81, 0xA6, 0x47, 0x14, 0xCD, 0x67, 0xE3, 0x55, 0x08, 0x33, 0x33, 0x05, 0x42, 0x00, 0x11, 0x7A, 0x71, 0x18, 0xCE, 0x67, 0xE3, 0x55, 0x08, 0xC1, 0xCA, 0x21, 0x3F, 0x00, 0x00
};
unsigned char sensob_honey2[] = {
0xFF, 0x01, 0xEB, 0x32, 0x06, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x03, 0x00, 0x00, 0x40, 0xA7, 0x6B, 0x1B, 0xC9, 0x67, 0xE3, 0x55, 0x08, 0x00, 0x00, 0xE0, 0x3F, 0x00, 0x80, 0xA6, 0x47, 0x14, 0xCA, 0x67, 0xE3, 0x55, 0x08, 0x00, 0x00, 0xBC, 0x41, 0x00, 0x10, 0x7A, 0x71, 0x18, 0xCB, 0x67, 0xE3, 0x55, 0x08, 0xAC, 0x1C, 0x1A, 0x3F, 0x00, 0x00 
};

unsigned char sensob_honey3[] = {
0xFF, 0x01, 0xEB, 0x32, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x03, 0x00, 0x00, 0x40, 0xA7, 0x6B, 0x1B, 0x21, 0xEC, 0xF7, 0x55, 0x08, 0x48, 0xE1, 0xBA, 0x3F, 0x00, 0x80, 0xA6, 0x47, 0x14, 0x22, 0xEC, 0xF7, 0x55, 0x08, 0xCD, 0xCC, 0x80, 0x41, 0x00, 0x10, 0x7A, 0x71, 0x18, 0x23, 0xEC, 0xF7, 0x55, 0x08, 0x31, 0x08, 0x4C, 0x3F, 0x00, 0x00
};

unsigned char sensob_honey4[] = {
0xFF, 0x01, 0xED, 0x32, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x03, 0x00, 0x00, 0x41, 0xA7, 0x6B, 0x1B, 0x24, 0xEC, 0xF7, 0x55, 0x08, 0xD7, 0xA3, 0x20, 0x40, 0x00, 0x81, 0xA6, 0x47, 0x14, 0x25, 0xEC, 0xF7, 0x55, 0x08, 0x66, 0x66, 0xC6, 0x41, 0x00, 0x11, 0x7A, 0x71, 0x18, 0x26, 0xEC, 0xF7, 0x55, 0x08, 0x56, 0x0E, 0x4D, 0x3F, 0x00, 0x00
};

unsigned char sensob_iridium[] = {
0x01, 0x00, 0x26, 0x01, 0x00, 0x1C, 0x35, 0x66, 0x56, 0x99, 0x33, 0x30, 0x30, 0x34, 0x33, 0x34, 0x30, 0x36, 0x31, 0x37, 0x31, 0x36, 0x39, 0x34, 0x30, 0x00, 0x00, 0x08, 0x00, 0x00, 0x56, 0x98, 0xC6, 0x81, 0x02, 0x00, 0x04, 0x61, 0x68, 0x6F, 0x6A
};

unsigned char sensob_iridium_pow[] = {
0x01, 0x00, 0x31, 0x01, 0x00, 0x1C, 0x3F, 0xF7, 0x86, 0x83, 0x33, 0x30, 0x30, 0x34, 0x33, 0x34, 0x30, 0x36, 0x31, 0x37, 0x31, 0x36, 0x39, 0x34, 0x30, 0x00, 0x02, 0x03, 0x00, 0x00, 0x56, 0xC1, 0x33, 0x3B, 0x02, 0x00, 0x0F, 0x5A, 0x44, 0x2C, 0x42, 0x06, 0x53, 0x31, 0xC1, 0x56, 0x01, 0x00, 0xCC, 0xE7, 0x3D, 0x40 
};

unsigned char sensob_iridium_t1[] = {
0x01, 0x00, 0x54, 0x01, 0x00, 0x1C, 0x3F, 0x7B, 0x17, 0xC5, 0x33, 0x30, 0x30, 0x34, 0x33, 0x34, 0x30, 0x36, 0x31, 0x37, 0x31, 0x36, 0x39, 0x34, 0x30, 0x00, 0x01, 0xEE, 0x00, 0x00, 0x56, 0xBF, 0x2B, 0x04, 0x02, 0x00, 0x32, 0x5A, 0x44, 0x2C, 0x42, 0x06, 0xD4, 0x28, 0xBF, 0x56, 0x08, 0x91, 0x9A, 0x99, 0x9D, 0xC1, 0xB1, 0x00, 0x00, 0xB8, 0x41, 0x92, 0xCD, 0xCC, 0xB0, 0xC1, 0xB2, 0x66, 0x66, 0xAE, 0x41, 0x93, 0x9A, 0x99, 0x71, 0xC1, 0xB3, 0x33, 0x33, 0xA3, 0x41, 0x74, 0x9A, 0x99, 0xA5, 0x41, 0x84, 0xCE, 0xAA, 0x4F, 0x3F
};

unsigned char sensob_iridium_t2[] = {
0x01, 0x00, 0x45, 0x01, 0x00, 0x1C, 0x3F, 0x7B, 0x19, 0xC6, 0x33, 0x30, 0x30, 0x34, 0x33, 0x34, 0x30, 0x36, 0x31, 0x37, 0x31, 0x36, 0x39, 0x34, 0x30, 0x00, 0x01, 0xEF, 0x00, 0x00, 0x56, 0xBF, 0x2B, 0x0D, 0x02, 0x00, 0x23, 0x5A, 0x48, 0x2C, 0x42, 0x06, 0xED, 0x28, 0xBF, 0x56, 0x05, 0x91, 0x66, 0x66, 0xC7, 0xC2, 0xB1, 0x66, 0x66, 0xB6, 0x41, 0x92, 0x00, 0x00, 0x54, 0xC2, 0xB2, 0xCD, 0xCC, 0xA8, 0x41, 0x93, 0x66, 0x66, 0x10, 0xC2
};

unsigned char sensob_iridium_t3[] = {
0x01, 0x00, 0x31, 0x01, 0x00, 0x1C, 0x3F, 0x7B, 0x1B, 0x28, 0x33, 0x30, 0x30, 0x34, 0x33, 0x34, 0x30, 0x36, 0x31, 0x37, 0x31, 0x36, 0x39, 0x34, 0x30, 0x00, 0x01, 0xF0, 0x00, 0x00, 0x56, 0xBF, 0x2B, 0x16, 0x02, 0x00, 0x0F, 0x5A, 0x3F, 0x2D, 0x42, 0x06, 0xFD, 0x28, 0xBF, 0x56, 0x01, 0x0F, 0x00, 0x00, 0xC0, 0x7F
};

unsigned char sensob_iridium_node4[] = {
0x01, 0x00, 0x4A, 0x01, 0x00, 0x1C, 0x40, 0x79, 0xAC, 0x6D, 0x33, 0x30, 0x30, 0x34, 0x33, 0x34, 0x30, 0x36, 0x31, 0x37, 0x31, 0x36, 0x39, 0x34, 0x30, 0x00, 0x02, 0x16, 0x00, 0x00, 0x56, 0xC3, 0x21, 0xAD, 0x02, 0x00, 0x28, 0x5A, 0x44, 0x2C, 0x42, 0x06, 0xBC, 0x1F, 0xC3, 0x56, 0x06, 0x92, 0x00, 0x00, 0xC0, 0x7F, 0xB2, 0x33, 0x33, 0xB3, 0x41, 0x93, 0x00, 0x00, 0xC0, 0x7F, 0xB3, 0x33, 0x33, 0xA7, 0x41, 0x74, 0x00, 0x00, 0xC0, 0x7F, 0x84, 0x00, 0x00, 0xC0, 0x7F
};

unsigned char sensob_iridium_node3[] = {
0x01, 0x00, 0x4A, 0x01, 0x00, 0x1C, 0x40, 0x79, 0xB7, 0x39, 0x33, 0x30, 0x30, 0x34, 0x33, 0x34, 0x30, 0x36, 0x31, 0x37, 0x31, 0x36, 0x39, 0x34, 0x30, 0x00, 0x02, 0x19, 0x00, 0x00, 0x56, 0xC3, 0x21, 0xCF, 0x02, 0x00, 0x28, 0x5A, 0x43, 0x2C, 0x42, 0x06, 0xEE, 0x21, 0xC3, 0x56, 0x06, 0x91, 0xCD, 0x4C, 0x1A, 0xC3, 0xB1, 0x71, 0x3D, 0xC4, 0x41, 0x92, 0x66, 0x26, 0xCA, 0xC3, 0xB2, 0x71, 0x3D, 0xBC, 0x41, 0x93, 0x33, 0x33, 0x41, 0xC2, 0xB3, 0x9A, 0x99, 0xB1, 0x41
};

unsigned char sensob_timestamp[] = {
0xFF, 0xF4, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x02, 0x10, 0x00, 0x00, 0x30, 0xAD, 0x9C, 0x1C, 0x25, 0x00, 0x45, 0x57, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x1C, 0x35, 0x1D, 0x26, 0x00, 0x45, 0x57, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0x43, 0x35, 0x1D, 0x26, 0x00, 0x45, 0x57, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0xF5, 0x34, 0x1D, 0x26, 0x00, 0x45, 0x57, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0x16, 0x04, 0x1C, 0x55, 0x13, 0x4D, 0x57, 0x08, 0xCD, 0xCC, 0xCC, 0x3D, 0x00, 0x70, 0x0E, 0x45, 0x14, 0x4B, 0x01, 0x45, 0x57, 0x08, 0x33, 0x33, 0x4B, 0x41, 0x00, 0xD0, 0xDD, 0x70, 0x18, 0x4B, 0x01, 0x45, 0x57, 0x08, 0x33, 0x33, 0xB3, 0x42, 0x00, 0xE0, 0x8B, 0x04, 0x1C, 0x55, 0x13, 0x4D, 0x57, 0x08, 0x00, 0x00, 0x16, 0x43, 0x00, 0x00, 0xDA, 0x04, 0x1C, 0x55, 0x13, 0x4D, 0x57, 0x08, 0x00, 0x00, 0x45, 0x43, 0x00, 0xD0, 0x64, 0x04, 0x1C, 0x4B, 0x01, 0x45, 0x57, 0x08, 0x66, 0x66, 0x66, 0x3F, 0x00, 0xF0, 0xB2, 0x04, 0x1C, 0x4B, 0x01, 0x45, 0x57, 0x08, 0x00, 0x00, 0xC0, 0x42, 0x00, 0xE0, 0x8B, 0x04, 0x1C, 0x4B, 0x01, 0x45, 0x57, 0x08, 0x00, 0x00, 0x82, 0x42, 0x00, 0x00, 0xDA, 0x04, 0x1C, 0x4B, 0x01, 0x45, 0x57, 0x08, 0x00, 0x00, 0x0B, 0x43, 0x00, 0x30, 0x26, 0x09, 0x19, 0x4B, 0x01, 0x45, 0x57, 0x08, 0x1F, 0x8B, 0x30, 0x41, 0x00, 0x10, 0x5F, 0x9C, 0x1C, 0x4B, 0x01, 0x45, 0x57, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xAD, 0x9C, 0x1C, 0x4B, 0x01, 0x45, 0x57, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

unsigned char fm4_at_badval[] = {
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xB2, 0x08, 0x0B, 0x00, 0x00, 0x01, 0x57, 0x0A, 0x36,
	0x43, 0xD8, 0x00, 0x08, 0xC2, 0xF8, 0x80, 0x1D, 0x72, 0xF4, 0x60, 0x01, 0xD0, 0x00, 0x00, 0x05,
	0x00, 0x00, 0xF0, 0x04, 0x03, 0x01, 0x36, 0x16, 0x01, 0xF0, 0x00, 0x01, 0x67, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x01, 0x57, 0x0A, 0x13, 0xDF, 0x28, 0x00, 0x08, 0xC2, 0xF8, 0x80, 0x1D, 0x72,
	0xF4, 0x60, 0x01, 0xD0, 0x00, 0x00, 0x05, 0x00, 0x00, 0x9D, 0x05, 0x04, 0x01, 0x36, 0x16, 0x01,
	0x9D, 0x01, 0xF0, 0x01, 0x01, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x57, 0x0A, 0x04,
	0xE3, 0x38, 0x00, 0x08, 0xC3, 0x14, 0xD0, 0x1D, 0x72, 0xF4, 0x00, 0x01, 0xDD, 0x00, 0x5E, 0x04,
	0x00, 0x15, 0xF0, 0x04, 0x03, 0x01, 0x36, 0x16, 0x05, 0xF0, 0x01, 0x01, 0x67, 0x05, 0x1F, 0x00,
	0x00, 0x00, 0x00, 0x01, 0x57, 0x09, 0xFB, 0x71, 0x40, 0x00, 0x08, 0xC2, 0xFA, 0x30, 0x1D, 0x72,
	0xF4, 0x20, 0x01, 0xD1, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03, 0x01, 0x36, 0x16, 0x05,
	0xF0, 0x00, 0x01, 0x67, 0x05, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x01, 0x57, 0x09, 0xF1, 0xF3, 0x90,
	0x00, 0x08, 0xC2, 0xFA, 0xC0, 0x1D, 0x72, 0xF4, 0xA0, 0x01, 0xD1, 0x00, 0x00, 0x06, 0x00, 0x00,
	0x00, 0x04, 0x03, 0x01, 0x36, 0x16, 0x05, 0xF0, 0x00, 0x01, 0x67, 0x05, 0x1F, 0x00, 0x00, 0x00,
	0x00, 0x01, 0x57, 0x09, 0xE8, 0x75, 0xE0, 0x00, 0x08, 0xC2, 0xFA, 0x00, 0x1D, 0x72, 0xF4, 0xC0,
	0x01, 0xD1, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x03, 0x01, 0x36, 0x16, 0x05, 0xF0, 0x00,
	0x01, 0x67, 0x05, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x01, 0x57, 0x09, 0xDE, 0xE8, 0x90, 0x00, 0x08,
	0xC2, 0xF9, 0xA0, 0x1D, 0x72, 0xF4, 0x60, 0x01, 0xD5, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04,
	0x03, 0x01, 0x36, 0x16, 0x05, 0xF0, 0x00, 0x01, 0x67, 0x05, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x01,
	0x57, 0x09, 0xD5, 0x6A, 0xE0, 0x00, 0x08, 0xC2, 0xFA, 0xE0, 0x1D, 0x72, 0xF3, 0xE0, 0x01, 0xD4,
	0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x03, 0x01, 0x36, 0x16, 0x05, 0xF0, 0x00, 0x01, 0x67,
	0x05, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x01, 0x57, 0x09, 0xCB, 0xED, 0x30, 0x00, 0x08, 0xC2, 0xFA,
	0x40, 0x1D, 0x72, 0xF4, 0x60, 0x01, 0xD1, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x03, 0x01,
	0x36, 0x16, 0x05, 0xF0, 0x00, 0x01, 0x67, 0x05, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x01, 0x57, 0x09,
	0xC2, 0x6F, 0x80, 0x00, 0x08, 0xC2, 0xF9, 0xD0, 0x1D, 0x72, 0xF4, 0xC0, 0x01, 0xD0, 0x00, 0x00,
	0x06, 0x00, 0x00, 0x00, 0x04, 0x03, 0x01, 0x36, 0x16, 0x05, 0xF0, 0x00, 0x01, 0x67, 0x05, 0x1F,
	0x00, 0x00, 0x00, 0x00, 0x01, 0x57, 0x09, 0xB8, 0xF1, 0xD0, 0x00, 0x08, 0xC2, 0xF9, 0x10, 0x1D,
	0x72, 0xF4, 0x60, 0x01, 0xD3, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03, 0x01, 0x36, 0x16,
	0x05, 0xF0, 0x00, 0x01, 0x67, 0x05, 0x1F, 0x00, 0x00, 0x0B, 0x00, 0x00, 0xB3, 0x84
};

unsigned char fm4_at2000[] = {
0x01, 0x01, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x33, 0x35, 0x37, 0x34, 0x35, 0x34, 0x30, 0x37, 0x31, 0x36, 0x30, 0x38, 0x33, 0x33, 0x33,
0x4F, 0x77, 0x53, 0x36, 0x59, 0x50, 0x92, 0x15, 0x58, 0x5D, 0xBE, 0x13, 0x32, 0xD1, 0x27, 0x3D,
0x78, 0xA0, 0x37, 0xE1, 0x2F, 0x34, 0x27, 0xD8, 0x7E, 0xA2, 0xB5, 0xEA, 0x47, 0x6A, 0x91, 0xE5
};

unsigned char wli[] = {
0x02, 0x31, 0x00, 0x05, 0x00, 0xBB, 0x55, 0x80, 0xC9, 0x00, 0x01, 0x00, 0x34, 0x00, 0x05, 0x00,
0xFF, 0x00, 0x10, 0x01, 0xC4, 0x56, 0x68, 0x00, 0x86, 0x93, 0x2C, 0x00, 0x08, 0x3B, 0xC3, 0x13,
0x0C, 0x0A, 0x08, 0x00, 0x06, 0x00, 0x32, 0x00, 0x09, 0x00, 0x33, 0x35, 0x37, 0x00, 0x13, 0x00,
0x30, 0x00, 0x33, 0x00, 0x31, 0x00, 0x34, 0x00, 0xFF, 0x00, 0x1C, 0xDB, 0xD2, 0x14, 0x11, 0xDB,
0xD3, 0x07, 0x10, 0xDB, 0xD3, 0x0C, 0x01, 0xC4, 0x56, 0x68, 0x00, 0x86, 0x93, 0x2C, 0x00, 0x08,
0x0A, 0x08, 0x00, 0x00, 0x01, 0x65, 0x00, 0x00, 0x12, 0xB3, 0x00, 0x46, 0x00, 0x30, 0x00, 0xF3,
0x00, 0x30, 0x00, 0xF5, 0x00, 0x33, 0x35, 0x38, 0x36, 0x37, 0x39, 0x30, 0x36, 0x31, 0x31, 0x33,
0x38, 0x39, 0x36, 0x31, 0x00, 0xF6, 0x00, 0x31, 0x2C, 0x38, 0x2C, 0x30, 0x2C, 0x33, 0x39, 0x33,
0x2C, 0x2D, 0x31, 0x00, 0xF7, 0x00, 0x38, 0x33, 0x32, 0x37, 0x35, 0x30, 0x00, 0xF8, 0x00, 0x30,
0x2C, 0x31, 0x35, 0x36, 0x36, 0x2C, 0x31, 0x2C, 0x32, 0x2C, 0x30, 0x2C, 0x32, 0x33, 0x2C, 0x2C,
0x2C, 0x2C, 0x2C, 0x2C, 0x31, 0x2C, 0x32, 0x00, 0xF9, 0x00, 0x31, 0x00, 0xFA, 0x00, 0x39, 0x31,
0x00, 0xFB, 0x00, 0x30, 0x00, 0xFC, 0x00, 0x30, 0x00, 0xFF, 0x00, 0x31, 0x34, 0x38, 0x38, 0x39,
0x30, 0x32, 0x35, 0x39, 0x32, 0x00, 0x03, 0x02, 0x31, 0x00, 0x06, 0x00, 0xB9, 0x05, 0xA0, 0xFE,
0x00, 0x01, 0x00, 0x33, 0x00, 0x07, 0x00, 0x4D, 0x32, 0x2E, 0x31, 0x39, 0x35, 0x54, 0x20, 0x4A,
0x61, 0x6E, 0x20, 0x32, 0x36, 0x20, 0x32, 0x30, 0x31, 0x37, 0x00, 0x08, 0x00, 0x31, 0x37, 0x00,
0x09, 0x00, 0x32, 0x30, 0x35, 0x38, 0x38, 0x00, 0x17, 0x00, 0x34, 0x30, 0x39, 0x36, 0x36, 0x35,
0x35, 0x33, 0x33, 0x00, 0x18, 0x00, 0x32, 0x32, 0x2F, 0x30, 0x31, 0x2F, 0x32, 0x33, 0x36, 0x38,
0x20, 0x32, 0x32, 0x3A, 0x35, 0x34, 0x3A, 0x32, 0x30, 0x00, 0x1B, 0x00, 0x32, 0x00, 0xF3, 0x00,
0x30, 0x00, 0xF5, 0x00, 0x33, 0x35, 0x38, 0x36, 0x37, 0x39, 0x30, 0x36, 0x31, 0x31, 0x33, 0x38,
0x39, 0x36, 0x31, 0x00, 0xF6, 0x00, 0x31, 0x2C, 0x38, 0x2C, 0x30, 0x2C, 0x34, 0x31, 0x32, 0x2C,
0x2D, 0x31, 0x00, 0xF7, 0x00, 0x38, 0x33, 0x32, 0x37, 0x35, 0x30, 0x00, 0xF8, 0x00, 0x30, 0x2C,
0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x35, 0x31, 0x2C, 0x30, 0x2C, 0x38,
0x37, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x32, 0x00, 0xF9, 0x00, 0x31, 0x00, 0xFA, 0x00,
0x38, 0x37, 0x00, 0xFB, 0x00, 0x30, 0x00, 0xFC, 0x00, 0x30, 0x00, 0xFF, 0x00, 0x31, 0x34, 0x38,
0x38, 0x39, 0x30, 0x31, 0x30, 0x31, 0x31, 0x00, 0x03, 0x02, 0x31, 0x00, 0x07, 0x00, 0x97, 0xD1,
0xF7, 0xCB, 0x00, 0x01, 0x00, 0x34, 0x00, 0xDB, 0xD2, 0x00, 0x30, 0x00, 0xDB, 0xD3, 0x00, 0x30,
0x00, 0x06, 0x00, 0x30, 0x00, 0x07, 0x00, 0x30, 0x00, 0x0C, 0x00, 0x30, 0x00, 0x0D, 0x00, 0x30,
0x00, 0x10, 0x00, 0x31, 0x35, 0x3A, 0x33, 0x36, 0x3A, 0x35, 0x30, 0x00, 0x12, 0x00, 0x30, 0x33,
0x2F, 0x30, 0x37, 0x2F, 0x31, 0x37, 0x00, 0xF3, 0x00, 0x30, 0x00, 0xF5, 0x00, 0x33, 0x35, 0x38,
0x36, 0x37, 0x39, 0x30, 0x36, 0x31, 0x31, 0x33, 0x38, 0x39, 0x36, 0x31, 0x00, 0xF6, 0x00, 0x31,
0x2C, 0x38, 0x2C, 0x30, 0x2C, 0x34, 0x31, 0x32, 0x2C, 0x2D, 0x31, 0x00, 0xF7, 0x00, 0x38, 0x33,
0x32, 0x37, 0x35, 0x30, 0x00, 0xF8, 0x00, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30,
0x2C, 0x30, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C, 0x30, 0x2C, 0x32, 0x00, 0xF9, 0x00, 0x31, 0x00,
0xFA, 0x00, 0x38, 0x37, 0x00, 0xFB, 0x00, 0x30, 0x00, 0xFC, 0x00, 0x30, 0x00, 0xFF, 0x00, 0x31,
0x34, 0x38, 0x38, 0x39, 0x30, 0x31, 0x30, 0x31, 0x30, 0x00, 0x03};

unsigned char cra_minus_one[] = {
0x50,0x4F,0x53,0x54,0x20,0x2F,0x20,0x48,0x54,0x54,0x50,0x2F,0x31,0x2E,0x31,0x0D,
0x0A,0x62,0x72,0x65,0x61,0x64,0x63,0x72,0x75,0x6D,0x62,0x49,0x64,0x3A,0x20,0x49,
0x44,0x3A,0x66,0x75,0x73,0x65,0x32,0x2D,0x34,0x34,0x37,0x32,0x39,0x2D,0x31,0x36,
0x30,0x31,0x39,0x33,0x35,0x33,0x30,0x32,0x31,0x34,0x31,0x2D,0x31,0x3A,0x36,0x3A,
0x33,0x32,0x3A,0x31,0x3A,0x36,0x35,0x33,0x38,0x31,0x0D,0x0A,0x43,0x6F,0x6E,0x74,
0x65,0x6E,0x74,0x2D,0x4C,0x65,0x6E,0x67,0x74,0x68,0x3A,0x20,0x38,0x32,0x31,0x0D,
0x0A,0x43,0x6F,0x6E,0x74,0x65,0x6E,0x74,0x2D,0x54,0x79,0x70,0x65,0x3A,0x20,0x61,
0x70,0x70,0x6C,0x69,0x63,0x61,0x74,0x69,0x6F,0x6E,0x2F,0x6A,0x73,0x6F,0x6E,0x0D,
0x0A,0x48,0x6F,0x73,0x74,0x3A,0x20,0x38,0x38,0x2E,0x38,0x36,0x2E,0x31,0x31,0x33,
0x2E,0x32,0x32,0x37,0x3A,0x34,0x32,0x35,0x34,0x0D,0x0A,0x43,0x6F,0x6E,0x6E,0x65,
0x63,0x74,0x69,0x6F,0x6E,0x3A,0x20,0x4B,0x65,0x65,0x70,0x2D,0x41,0x6C,0x69,0x76,
0x65,0x0D,0x0A,0x55,0x73,0x65,0x72,0x2D,0x41,0x67,0x65,0x6E,0x74,0x3A,0x20,0x41,
0x70,0x61,0x63,0x68,0x65,0x2D,0x48,0x74,0x74,0x70,0x43,0x6C,0x69,0x65,0x6E,0x74,
0x2F,0x34,0x2E,0x35,0x2E,0x32,0x20,0x28,0x4A,0x61,0x76,0x61,0x2F,0x31,0x2E,0x38,
0x2E,0x30,0x5F,0x32,0x35,0x32,0x29,0x0D,0x0A,0x41,0x63,0x63,0x65,0x70,0x74,0x2D,
0x45,0x6E,0x63,0x6F,0x64,0x69,0x6E,0x67,0x3A,0x20,0x67,0x7A,0x69,0x70,0x2C,0x64,
0x65,0x66,0x6C,0x61,0x74,0x65,0x0D,0x0A,0x0D,0x0A,0x7B,0x22,0x74,0x79,0x70,0x65,
0x22,0x3A,0x20,0x22,0x44,0x22,0x2C,0x20,0x22,0x64,0x61,0x74,0x61,0x22,0x3A,0x20,
0x22,0x7B,0x5C,0x22,0x63,0x6D,0x64,0x5C,0x22,0x3A,0x5C,0x22,0x67,0x77,0x5C,0x22,
0x2C,0x5C,0x22,0x45,0x55,0x49,0x5C,0x22,0x3A,0x5C,0x22,0x30,0x30,0x30,0x34,0x41,
0x33,0x30,0x42,0x30,0x30,0x45,0x37,0x41,0x34,0x39,0x46,0x5C,0x22,0x2C,0x5C,0x22,
0x74,0x73,0x5C,0x22,0x3A,0x31,0x36,0x30,0x32,0x33,0x36,0x37,0x32,0x38,0x30,0x35,
0x31,0x39,0x2C,0x5C,0x22,0x66,0x63,0x6E,0x74,0x5C,0x22,0x3A,0x31,0x36,0x35,0x2C,
0x5C,0x22,0x70,0x6F,0x72,0x74,0x5C,0x22,0x3A,0x31,0x2C,0x5C,0x22,0x66,0x72,0x65,
0x71,0x5C,0x22,0x3A,0x38,0x36,0x37,0x33,0x30,0x30,0x30,0x30,0x30,0x2C,0x5C,0x22,
0x74,0x6F,0x61,0x5C,0x22,0x3A,0x39,0x37,0x2C,0x5C,0x22,0x64,0x72,0x5C,0x22,0x3A,
0x5C,0x22,0x53,0x46,0x37,0x20,0x42,0x57,0x31,0x32,0x35,0x20,0x34,0x2F,0x35,0x5C,
0x22,0x2C,0x5C,0x22,0x61,0x63,0x6B,0x5C,0x22,0x3A,0x66,0x61,0x6C,0x73,0x65,0x2C,
0x5C,0x22,0x67,0x77,0x73,0x5C,0x22,0x3A,0x5B,0x7B,0x5C,0x22,0x72,0x73,0x73,0x69,
0x5C,0x22,0x3A,0x2D,0x31,0x30,0x31,0x2C,0x5C,0x22,0x73,0x6E,0x72,0x5C,0x22,0x3A,
0x39,0x2C,0x5C,0x22,0x74,0x73,0x5C,0x22,0x3A,0x31,0x36,0x30,0x32,0x33,0x36,0x37,
0x32,0x38,0x30,0x35,0x31,0x39,0x2C,0x5C,0x22,0x74,0x6D,0x6D,0x73,0x5C,0x22,0x3A,
0x30,0x2C,0x5C,0x22,0x74,0x69,0x6D,0x65,0x5C,0x22,0x3A,0x5C,0x22,0x32,0x30,0x32,
0x30,0x2D,0x31,0x30,0x2D,0x31,0x30,0x54,0x32,0x32,0x3A,0x30,0x31,0x3A,0x32,0x30,
0x2E,0x32,0x36,0x39,0x30,0x36,0x34,0x30,0x30,0x30,0x5A,0x5C,0x22,0x2C,0x5C,0x22,
0x67,0x77,0x65,0x75,0x69,0x5C,0x22,0x3A,0x5C,0x22,0x36,0x34,0x37,0x46,0x44,0x41,
0x46,0x46,0x46,0x46,0x30,0x30,0x39,0x35,0x34,0x33,0x5C,0x22,0x2C,0x5C,0x22,0x61,
0x6E,0x74,0x5C,0x22,0x3A,0x30,0x2C,0x5C,0x22,0x6C,0x61,0x74,0x5C,0x22,0x3A,0x35,
0x30,0x2E,0x30,0x32,0x34,0x39,0x32,0x32,0x35,0x2C,0x5C,0x22,0x6C,0x6F,0x6E,0x5C,
0x22,0x3A,0x31,0x34,0x2E,0x36,0x30,0x33,0x30,0x31,0x33,0x36,0x7D,0x2C,0x7B,0x5C,
0x22,0x72,0x73,0x73,0x69,0x5C,0x22,0x3A,0x2D,0x31,0x30,0x39,0x2C,0x5C,0x22,0x73,
0x6E,0x72,0x5C,0x22,0x3A,0x33,0x2E,0x32,0x2C,0x5C,0x22,0x74,0x73,0x5C,0x22,0x3A,
0x31,0x36,0x30,0x32,0x33,0x36,0x37,0x32,0x38,0x30,0x35,0x31,0x38,0x2C,0x5C,0x22,
0x74,0x6D,0x6D,0x73,0x5C,0x22,0x3A,0x31,0x32,0x38,0x36,0x34,0x30,0x32,0x34,0x39,
0x38,0x32,0x36,0x38,0x2C,0x5C,0x22,0x74,0x69,0x6D,0x65,0x5C,0x22,0x3A,0x5C,0x22,
0x32,0x30,0x32,0x30,0x2D,0x31,0x30,0x2D,0x31,0x30,0x54,0x32,0x32,0x3A,0x30,0x31,
0x3A,0x32,0x30,0x2E,0x32,0x36,0x39,0x30,0x38,0x31,0x30,0x30,0x30,0x5A,0x5C,0x22,
0x2C,0x5C,0x22,0x67,0x77,0x65,0x75,0x69,0x5C,0x22,0x3A,0x5C,0x22,0x42,0x38,0x32,
0x37,0x45,0x42,0x46,0x46,0x46,0x46,0x43,0x43,0x31,0x32,0x43,0x45,0x5C,0x22,0x2C,
0x5C,0x22,0x61,0x6E,0x74,0x5C,0x22,0x3A,0x30,0x2C,0x5C,0x22,0x6C,0x61,0x74,0x5C,
0x22,0x3A,0x35,0x30,0x2E,0x30,0x30,0x33,0x39,0x30,0x34,0x36,0x36,0x30,0x31,0x34,
0x31,0x37,0x37,0x2C,0x5C,0x22,0x6C,0x6F,0x6E,0x5C,0x22,0x3A,0x31,0x34,0x2E,0x36,
0x39,0x30,0x34,0x33,0x35,0x32,0x38,0x39,0x32,0x37,0x34,0x35,0x34,0x36,0x7D,0x2C,
0x7B,0x5C,0x22,0x72,0x73,0x73,0x69,0x5C,0x22,0x3A,0x2D,0x31,0x31,0x39,0x2C,0x5C,
0x22,0x73,0x6E,0x72,0x5C,0x22,0x3A,0x2D,0x34,0x2C,0x5C,0x22,0x74,0x73,0x5C,0x22,
0x3A,0x31,0x36,0x30,0x32,0x33,0x36,0x37,0x32,0x38,0x30,0x39,0x37,0x31,0x2C,0x5C,
0x22,0x74,0x6D,0x6D,0x73,0x5C,0x22,0x3A,0x32,0x30,0x30,0x30,0x2C,0x5C,0x22,0x74,
0x69,0x6D,0x65,0x5C,0x22,0x3A,0x5C,0x22,0x32,0x30,0x32,0x30,0x2D,0x31,0x30,0x2D,
0x31,0x30,0x54,0x32,0x32,0x3A,0x30,0x31,0x3A,0x32,0x30,0x2E,0x32,0x36,0x39,0x30,
0x37,0x35,0x30,0x30,0x30,0x5A,0x5C,0x22,0x2C,0x5C,0x22,0x67,0x77,0x65,0x75,0x69,
0x5C,0x22,0x3A,0x5C,0x22,0x36,0x34,0x37,0x46,0x44,0x41,0x46,0x46,0x46,0x46,0x30,
0x30,0x39,0x35,0x37,0x43,0x5C,0x22,0x2C,0x5C,0x22,0x61,0x6E,0x74,0x5C,0x22,0x3A,
0x30,0x2C,0x5C,0x22,0x6C,0x61,0x74,0x5C,0x22,0x3A,0x35,0x30,0x2E,0x30,0x34,0x33,
0x33,0x38,0x35,0x38,0x2C,0x5C,0x22,0x6C,0x6F,0x6E,0x5C,0x22,0x3A,0x31,0x34,0x2E,
0x35,0x35,0x33,0x30,0x39,0x34,0x32,0x7D,0x5D,0x2C,0x5C,0x22,0x62,0x61,0x74,0x5C,
0x22,0x3A,0x32,0x35,0x35,0x2C,0x5C,0x22,0x64,0x61,0x74,0x61,0x5C,0x22,0x3A,0x5C,
0x22,0x5C,0x22,0x7D,0x22,0x2C,0x20,0x22,0x74,0x65,0x63,0x68,0x22,0x3A,0x20,0x22,
0x4C,0x22,0x2C,0x20,0x22,0x74,0x61,0x67,0x73,0x22,0x3A,0x20,0x5B,0x5D,0x7D};

unsigned char vhcp[] = {
'#', 
'D', 
4, 1, 0, 0, 
10, 0,
1, 0, 0, 0,
3, 0, 0, 0,
4, 0, 0, 0,
1,
0, 0,
100,
0,
0,
0, 0, 0, 0,
0, 0,
0, 0,
0, 10,
0, 0,
120,
80,
0
};

unsigned char vhcp_2[] = {
'#', 
'D', 
14, 1, 0, 0, 
10, 0,
1, 0, 0, 0,
3, 0, 0, 0,
4, 0, 0, 0,
1,
0, 0,
100,
0,
0,
0, 0, 0, 0,
0, 0,
0, 0,
0, 10,
0, 0,
120,
80,
0
};

unsigned char rest_1[] = {
	0x47, 0x45, 0x54, 0x20, 0x2F, 0x44, 0x42, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4F, 0x54,
	0x2F, 0x46, 0x65, 0x65, 0x64, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x6C, 0x65, 0x74, 0x3F, 0x4F,
	0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3D, 0x49, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x4F,
	0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x26, 0x64, 0x61, 0x74, 0x65, 0x3D,
	0x31, 0x35, 0x31, 0x35, 0x38, 0x35, 0x32, 0x30, 0x30, 0x30, 0x26, 0x76, 0x61, 0x6C, 0x75, 0x65,
	0x3D, 0x33, 0x34, 0x35, 0x36, 0x2E, 0x36, 0x37, 0x39, 0x37, 0x26, 0x75, 0x6E, 0x69, 0x74, 0x5F,
	0x69, 0x64, 0x3D, 0x33, 0x37, 0x30, 0x36, 0x37, 0x36, 0x26, 0x73, 0x65, 0x6E, 0x73, 0x6F, 0x72,
	0x5F, 0x69, 0x64, 0x3D, 0x33, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x26, 0x73, 0x65,
	0x71, 0x3D, 0x35, 0x37, 0x32, 0x20, 0x48, 0x54, 0x54, 0x50, 0x2F, 0x31, 0x2E, 0x31, 0x0D, 0x0A,
	0x68, 0x6F, 0x73, 0x74, 0x3A, 0x20, 0x73, 0x65, 0x6E, 0x73, 0x6F, 0x72, 0x73, 0x2E, 0x6C, 0x65,
	0x73, 0x70, 0x72, 0x6F, 0x6A, 0x65, 0x6B, 0x74, 0x2E, 0x63, 0x7A, 0x3A, 0x34, 0x32, 0x36, 0x30,
	0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x6C, 0x61, 0x6E, 0x67, 0x75, 0x61, 0x67,
	0x65, 0x3A, 0x20, 0x66, 0x72, 0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x65, 0x6E,
	0x63, 0x6F, 0x64, 0x69, 0x6E, 0x67, 0x3A, 0x20, 0x67, 0x7A, 0x69, 0x70, 0x2C, 0x64, 0x65, 0x66,
	0x6C, 0x61, 0x74, 0x65, 0x0D, 0x0A, 0x75, 0x73, 0x65, 0x72, 0x2D, 0x61, 0x67, 0x65, 0x6E, 0x74,
	0x3A, 0x20, 0x53, 0x49, 0x47, 0x46, 0x4F, 0x58, 0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74,
	0x2D, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3A, 0x20, 0x55, 0x54, 0x46, 0x2D, 0x38, 0x3B,
	0x71, 0x3D, 0x30, 0x2E, 0x39, 0x2C, 0x2A, 0x3B, 0x71, 0x3D, 0x30, 0x2E, 0x37, 0x0D, 0x0A, 0x0D,
	0x0A
};

unsigned char cra_1[] = {
	0x50, 0x4F, 0x53, 0x54, 0x20, 0x2F, 0x20, 0x48, 0x54, 0x54, 0x50, 0x2F, 0x31, 0x2E, 0x31, 0x0D,
	0x0A, 0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x7A, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3A, 0x20,
	0x6E, 0x75, 0x6C, 0x6C, 0x0D, 0x0A, 0x43, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x2D, 0x4C, 0x65,
	0x6E, 0x67, 0x74, 0x68, 0x3A, 0x20, 0x36, 0x36, 0x30, 0x0D, 0x0A, 0x43, 0x6F, 0x6E, 0x74, 0x65,
	0x6E, 0x74, 0x2D, 0x54, 0x79, 0x70, 0x65, 0x3A, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61,
	0x74, 0x69, 0x6F, 0x6E, 0x2F, 0x6A, 0x73, 0x6F, 0x6E, 0x0D, 0x0A, 0x48, 0x6F, 0x73, 0x74, 0x3A,
	0x20, 0x38, 0x38, 0x2E, 0x38, 0x36, 0x2E, 0x31, 0x31, 0x33, 0x2E, 0x32, 0x33, 0x33, 0x3A, 0x34,
	0x32, 0x35, 0x39, 0x0D, 0x0A, 0x43, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3A,
	0x20, 0x4B, 0x65, 0x65, 0x70, 0x2D, 0x41, 0x6C, 0x69, 0x76, 0x65, 0x0D, 0x0A, 0x55, 0x73, 0x65,
	0x72, 0x2D, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3A, 0x20, 0x41, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2D,
	0x48, 0x74, 0x74, 0x70, 0x43, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x2F, 0x34, 0x2E, 0x35, 0x2E, 0x32,
	0x20, 0x28, 0x4A, 0x61, 0x76, 0x61, 0x2F, 0x31, 0x2E, 0x38, 0x2E, 0x30, 0x5F, 0x31, 0x36, 0x32,
	0x29, 0x0D, 0x0A, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x45, 0x6E, 0x63, 0x6F, 0x64, 0x69,
	0x6E, 0x67, 0x3A, 0x20, 0x67, 0x7A, 0x69, 0x70, 0x2C, 0x64, 0x65, 0x66, 0x6C, 0x61, 0x74, 0x65,
	0x0D, 0x0A, 0x0D, 0x0A, 0x7B, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3A, 0x20, 0x22, 0x44, 0x22,
	0x2C, 0x20, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x3A, 0x20, 0x22, 0x7B, 0x5C, 0x22, 0x63, 0x6D,
	0x64, 0x5C, 0x22, 0x3A, 0x5C, 0x22, 0x67, 0x77, 0x5C, 0x22, 0x2C, 0x5C, 0x22, 0x73, 0x65, 0x71,
	0x6E, 0x6F, 0x5C, 0x22, 0x3A, 0x31, 0x35, 0x36, 0x36, 0x34, 0x34, 0x38, 0x33, 0x2C, 0x5C, 0x22,
	0x45, 0x55, 0x49, 0x5C, 0x22, 0x3A, 0x5C, 0x22, 0x30, 0x30, 0x30, 0x34, 0x41, 0x33, 0x30, 0x42,
	0x30, 0x30, 0x32, 0x32, 0x30, 0x38, 0x38, 0x46, 0x5C, 0x22, 0x2C, 0x5C, 0x22, 0x74, 0x73, 0x5C,
	0x22, 0x3A, 0x31, 0x35, 0x32, 0x35, 0x35, 0x32, 0x37, 0x31, 0x33, 0x32, 0x39, 0x32, 0x35, 0x2C,
	0x5C, 0x22, 0x66, 0x63, 0x6E, 0x74, 0x5C, 0x22, 0x3A, 0x30, 0x2C, 0x5C, 0x22, 0x70, 0x6F, 0x72,
	0x74, 0x5C, 0x22, 0x3A, 0x31, 0x2C, 0x5C, 0x22, 0x66, 0x72, 0x65, 0x71, 0x5C, 0x22, 0x3A, 0x38,
	0x36, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2C, 0x5C, 0x22, 0x74, 0x6F, 0x61, 0x5C, 0x22,
	0x3A, 0x31, 0x39, 0x37, 0x34, 0x2C, 0x5C, 0x22, 0x64, 0x72, 0x5C, 0x22, 0x3A, 0x5C, 0x22, 0x53,
	0x46, 0x31, 0x32, 0x20, 0x42, 0x57, 0x31, 0x32, 0x35, 0x20, 0x34, 0x2F, 0x35, 0x5C, 0x22, 0x2C,
	0x5C, 0x22, 0x61, 0x63, 0x6B, 0x5C, 0x22, 0x3A, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x2C, 0x5C, 0x22,
	0x67, 0x77, 0x73, 0x5C, 0x22, 0x3A, 0x5B, 0x7B, 0x5C, 0x22, 0x72, 0x73, 0x73, 0x69, 0x5C, 0x22,
	0x3A, 0x2D, 0x31, 0x31, 0x33, 0x2C, 0x5C, 0x22, 0x73, 0x6E, 0x72, 0x5C, 0x22, 0x3A, 0x34, 0x2E,
	0x35, 0x2C, 0x5C, 0x22, 0x74, 0x73, 0x5C, 0x22, 0x3A, 0x31, 0x35, 0x32, 0x35, 0x35, 0x32, 0x37,
	0x31, 0x33, 0x32, 0x39, 0x32, 0x39, 0x2C, 0x5C, 0x22, 0x74, 0x69, 0x6D, 0x65, 0x5C, 0x22, 0x3A,
	0x5C, 0x22, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x35, 0x2D, 0x30, 0x35, 0x54, 0x31, 0x33, 0x3A,
	0x33, 0x32, 0x3A, 0x31, 0x32, 0x2E, 0x38, 0x38, 0x37, 0x39, 0x33, 0x31, 0x30, 0x34, 0x34, 0x5A,
	0x5C, 0x22, 0x2C, 0x5C, 0x22, 0x67, 0x77, 0x65, 0x75, 0x69, 0x5C, 0x22, 0x3A, 0x5C, 0x22, 0x30,
	0x32, 0x34, 0x42, 0x30, 0x42, 0x46, 0x46, 0x46, 0x46, 0x30, 0x33, 0x30, 0x34, 0x32, 0x42, 0x5C,
	0x22, 0x2C, 0x5C, 0x22, 0x6C, 0x61, 0x74, 0x5C, 0x22, 0x3A, 0x34, 0x39, 0x2E, 0x33, 0x37, 0x39,
	0x39, 0x39, 0x33, 0x30, 0x33, 0x37, 0x38, 0x33, 0x32, 0x38, 0x35, 0x34, 0x2C, 0x5C, 0x22, 0x6C,
	0x6F, 0x6E, 0x5C, 0x22, 0x3A, 0x31, 0x34, 0x2E, 0x36, 0x34, 0x31, 0x36, 0x33, 0x34, 0x38, 0x36,
	0x34, 0x37, 0x30, 0x34, 0x32, 0x30, 0x31, 0x7D, 0x2C, 0x7B, 0x5C, 0x22, 0x72, 0x73, 0x73, 0x69,
	0x5C, 0x22, 0x3A, 0x2D, 0x31, 0x31, 0x39, 0x2C, 0x5C, 0x22, 0x73, 0x6E, 0x72, 0x5C, 0x22, 0x3A,
	0x2D, 0x31, 0x37, 0x2E, 0x38, 0x2C, 0x5C, 0x22, 0x74, 0x73, 0x5C, 0x22, 0x3A, 0x31, 0x35, 0x32,
	0x35, 0x35, 0x32, 0x37, 0x31, 0x33, 0x32, 0x39, 0x32, 0x35, 0x2C, 0x5C, 0x22, 0x74, 0x69, 0x6D,
	0x65, 0x5C, 0x22, 0x3A, 0x5C, 0x22, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x35, 0x2D, 0x30, 0x35,
	0x54, 0x31, 0x33, 0x3A, 0x33, 0x32, 0x3A, 0x31, 0x32, 0x2E, 0x38, 0x38, 0x37, 0x39, 0x33, 0x31,
	0x30, 0x34, 0x34, 0x5A, 0x5C, 0x22, 0x2C, 0x5C, 0x22, 0x67, 0x77, 0x65, 0x75, 0x69, 0x5C, 0x22,
	0x3A, 0x5C, 0x22, 0x30, 0x32, 0x34, 0x42, 0x30, 0x42, 0x46, 0x46, 0x46, 0x46, 0x30, 0x33, 0x30,
	0x34, 0x32, 0x42, 0x5C, 0x22, 0x2C, 0x5C, 0x22, 0x6C, 0x61, 0x74, 0x5C, 0x22, 0x3A, 0x34, 0x39,
	0x2E, 0x33, 0x37, 0x39, 0x39, 0x39, 0x33, 0x30, 0x33, 0x37, 0x38, 0x33, 0x32, 0x38, 0x35, 0x34,
	0x2C, 0x5C, 0x22, 0x6C, 0x6F, 0x6E, 0x5C, 0x22, 0x3A, 0x31, 0x34, 0x2E, 0x36, 0x34, 0x31, 0x36,
	0x33, 0x34, 0x38, 0x36, 0x34, 0x37, 0x30, 0x34, 0x32, 0x30, 0x31, 0x7D, 0x2C, 0x7B, 0x5C, 0x22,
	0x72, 0x73, 0x73, 0x69, 0x5C, 0x22, 0x3A, 0x2D, 0x31, 0x31, 0x39, 0x2C, 0x5C, 0x22, 0x73, 0x6E,
	0x72, 0x5C, 0x22, 0x3A, 0x2D, 0x31, 0x37, 0x2E, 0x38, 0x2C, 0x5C, 0x22, 0x74, 0x73, 0x5C, 0x22,
	0x3A, 0x31, 0x35, 0x32, 0x35, 0x35, 0x32, 0x37, 0x31, 0x33, 0x32, 0x39, 0x32, 0x35, 0x2C, 0x5C,
	0x22, 0x74, 0x69, 0x6D, 0x65, 0x5C, 0x22, 0x3A, 0x5C, 0x22, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30,
	0x35, 0x2D, 0x30, 0x35, 0x54, 0x31, 0x33, 0x3A, 0x33, 0x32, 0x3A, 0x31, 0x32, 0x2E, 0x39, 0x32,
	0x30, 0x39, 0x30, 0x33, 0x5A, 0x5C, 0x22, 0x2C, 0x5C, 0x22, 0x67, 0x77, 0x65, 0x75, 0x69, 0x5C,
	0x22, 0x3A, 0x5C, 0x22, 0x42, 0x38, 0x32, 0x37, 0x45, 0x42, 0x46, 0x46, 0x46, 0x46, 0x46, 0x30,
	0x32, 0x33, 0x30, 0x41, 0x5C, 0x22, 0x2C, 0x5C, 0x22, 0x6C, 0x61, 0x74, 0x5C, 0x22, 0x3A, 0x34,
	0x39, 0x2E, 0x34, 0x30, 0x36, 0x35, 0x31, 0x37, 0x31, 0x34, 0x34, 0x38, 0x32, 0x39, 0x37, 0x31,
	0x2C, 0x5C, 0x22, 0x6C, 0x6F, 0x6E, 0x5C, 0x22, 0x3A, 0x31, 0x34, 0x2E, 0x36, 0x35, 0x36, 0x37,
	0x35, 0x36, 0x37, 0x37, 0x32, 0x32, 0x35, 0x32, 0x37, 0x32, 0x7D, 0x5D, 0x2C, 0x5C, 0x22, 0x62,
	0x61, 0x74, 0x5C, 0x22, 0x3A, 0x32, 0x35, 0x35, 0x2C, 0x5C, 0x22, 0x64, 0x61, 0x74, 0x61, 0x5C,
	0x22, 0x3A, 0x5C, 0x22, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30,
	0x34, 0x30, 0x33, 0x37, 0x37, 0x38, 0x31, 0x35, 0x61, 0x63, 0x63, 0x30, 0x63, 0x65, 0x31, 0x32,
	0x30, 0x65, 0x38, 0x30, 0x31, 0x37, 0x37, 0x37, 0x31, 0x39, 0x5C, 0x22, 0x7D, 0x22, 0x2C, 0x20,
	0x22, 0x74, 0x65, 0x63, 0x68, 0x22, 0x3A, 0x20, 0x22, 0x4C, 0x22, 0x7D, 0xD, 0xA
};

unsigned char cra_2[] = {
	0x50, 0x4F, 0x53, 0x54, 0x20, 0x2F, 0x20, 0x48, 0x54, 0x54, 0x50, 0x2F, 0x31, 0x2E, 0x31, 0x0D,
	0x0A, 0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x7A, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3A, 0x20,
	0x6E, 0x75, 0x6C, 0x6C, 0x0D, 0x0A, 0x43, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x2D, 0x4C, 0x65,
	0x6E, 0x67, 0x74, 0x68, 0x3A, 0x20, 0x38, 0x31, 0x32, 0x0D, 0x0A, 0x43, 0x6F, 0x6E, 0x74, 0x65,
	0x6E, 0x74, 0x2D, 0x54, 0x79, 0x70, 0x65, 0x3A, 0x20, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61,
	0x74, 0x69, 0x6F, 0x6E, 0x2F, 0x6A, 0x73, 0x6F, 0x6E, 0x0D, 0x0A, 0x48, 0x6F, 0x73, 0x74, 0x3A,
	0x20, 0x38, 0x38, 0x2E, 0x38, 0x36, 0x2E, 0x31, 0x31, 0x33, 0x2E, 0x32, 0x32, 0x37, 0x3A, 0x34,
	0x32, 0x35, 0x39, 0x0D, 0x0A, 0x43, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3A,
	0x20, 0x4B, 0x65, 0x65, 0x70, 0x2D, 0x41, 0x6C, 0x69, 0x76, 0x65, 0x0D, 0x0A, 0x55, 0x73, 0x65,
	0x72, 0x2D, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3A, 0x20, 0x41, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2D,
	0x48, 0x74, 0x74, 0x70, 0x43, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x2F, 0x34, 0x2E, 0x35, 0x2E, 0x32,
	0x20, 0x28, 0x4A, 0x61, 0x76, 0x61, 0x2F, 0x31, 0x2E, 0x38, 0x2E, 0x30, 0x5F, 0x31, 0x39, 0x31,
	0x29, 0x0D, 0x0A, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x45, 0x6E, 0x63, 0x6F, 0x64, 0x69,
	0x6E, 0x67, 0x3A, 0x20, 0x67, 0x7A, 0x69, 0x70, 0x2C, 0x64, 0x65, 0x66, 0x6C, 0x61, 0x74, 0x65,
	0x0D, 0x0A, 0x0D, 0x0A, 0x7B, 0x22, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3A, 0x20, 0x22, 0x44, 0x22,
	0x2C, 0x20, 0x22, 0x64, 0x61, 0x74, 0x61, 0x22, 0x3A, 0x20, 0x22, 0x7B, 0x5C, 0x22, 0x74, 0x79,
	0x70, 0x65, 0x5C, 0x22, 0x3A, 0x20, 0x5C, 0x22, 0x44, 0x5C, 0x22, 0x2C, 0x20, 0x5C, 0x22, 0x64,
	0x61, 0x74, 0x61, 0x5C, 0x22, 0x3A, 0x20, 0x5C, 0x22, 0x7B, 0x5C, 0x5C, 0x5C, 0x22, 0x63, 0x6D,
	0x64, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x5C, 0x5C, 0x5C, 0x22, 0x67, 0x77, 0x5C, 0x5C, 0x5C, 0x22,
	0x2C, 0x5C, 0x5C, 0x5C, 0x22, 0x73, 0x65, 0x71, 0x6E, 0x6F, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x35,
	0x34, 0x34, 0x35, 0x36, 0x38, 0x38, 0x34, 0x2C, 0x5C, 0x5C, 0x5C, 0x22, 0x45, 0x55, 0x49, 0x5C,
	0x5C, 0x5C, 0x22, 0x3A, 0x5C, 0x5C, 0x5C, 0x22, 0x30, 0x30, 0x30, 0x34, 0x41, 0x33, 0x30, 0x42,
	0x30, 0x30, 0x32, 0x32, 0x36, 0x32, 0x46, 0x30, 0x5C, 0x5C, 0x5C, 0x22, 0x2C, 0x5C, 0x5C, 0x5C,
	0x22, 0x74, 0x73, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x31, 0x35, 0x34, 0x34, 0x34, 0x38, 0x30, 0x33,
	0x30, 0x35, 0x34, 0x34, 0x34, 0x2C, 0x5C, 0x5C, 0x5C, 0x22, 0x66, 0x63, 0x6E, 0x74, 0x5C, 0x5C,
	0x5C, 0x22, 0x3A, 0x39, 0x30, 0x31, 0x34, 0x2C, 0x5C, 0x5C, 0x5C, 0x22, 0x70, 0x6F, 0x72, 0x74,
	0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x31, 0x2C, 0x5C, 0x5C, 0x5C, 0x22, 0x66, 0x72, 0x65, 0x71, 0x5C,
	0x5C, 0x5C, 0x22, 0x3A, 0x38, 0x36, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2C, 0x5C, 0x5C,
	0x5C, 0x22, 0x74, 0x6F, 0x61, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x35, 0x36, 0x2C, 0x5C, 0x5C, 0x5C,
	0x22, 0x64, 0x72, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x5C, 0x5C, 0x5C, 0x22, 0x53, 0x46, 0x37, 0x20,
	0x42, 0x57, 0x31, 0x32, 0x35, 0x20, 0x34, 0x2F, 0x35, 0x5C, 0x5C, 0x5C, 0x22, 0x2C, 0x5C, 0x5C,
	0x5C, 0x22, 0x61, 0x63, 0x6B, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x2C,
	0x5C, 0x5C, 0x5C, 0x22, 0x67, 0x77, 0x73, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x5B, 0x7B, 0x5C, 0x5C,
	0x5C, 0x22, 0x72, 0x73, 0x73, 0x69, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x2D, 0x31, 0x31, 0x32, 0x2C,
	0x5C, 0x5C, 0x5C, 0x22, 0x73, 0x6E, 0x72, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x35, 0x2E, 0x32, 0x2C,
	0x5C, 0x5C, 0x5C, 0x22, 0x74, 0x73, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x31, 0x35, 0x34, 0x34, 0x34,
	0x38, 0x30, 0x33, 0x30, 0x35, 0x34, 0x34, 0x34, 0x2C, 0x5C, 0x5C, 0x5C, 0x22, 0x74, 0x69, 0x6D,
	0x65, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x5C, 0x5C, 0x5C, 0x22, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x31,
	0x32, 0x2D, 0x31, 0x30, 0x54, 0x32, 0x32, 0x3A, 0x31, 0x38, 0x3A, 0x32, 0x35, 0x2E, 0x34, 0x33,
	0x30, 0x38, 0x32, 0x32, 0x32, 0x32, 0x37, 0x5A, 0x5C, 0x5C, 0x5C, 0x22, 0x2C, 0x5C, 0x5C, 0x5C,
	0x22, 0x67, 0x77, 0x65, 0x75, 0x69, 0x5C, 0x5C, 0x5C, 0x22, 0x3A, 0x5C, 0x5C, 0x5C, 0x22, 0x30,
	0x32, 0x34, 0x42, 0x30, 0x42, 0x46, 0x46, 0x46, 0x46, 0x30, 0x33, 0x30, 0x34, 0x32, 0x42, 0x5C,
	0x5C, 0x5C, 0x22, 0x2C, 0x5C, 0x5C, 0x5C, 0x22, 0x6C, 0x61, 0x7D
};

unsigned char sigfox[] = {
0x47, 0x45, 0x54, 0x20, 0x2F, 0x44, 0x42, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4F, 0x54,
0x2F, 0x46, 0x65, 0x65, 0x64, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x6C, 0x65, 0x74, 0x3F, 0x4F,
0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3D, 0x49, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x4F,
0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x26, 0x64, 0x61, 0x74, 0x65, 0x3D,
0x31, 0x35, 0x35, 0x35, 0x32, 0x36, 0x32, 0x31, 0x39, 0x31, 0x26, 0x76, 0x61, 0x6C, 0x75, 0x65,
0x3D, 0x31, 0x31, 0x30, 0x33, 0x32, 0x30, 0x36, 0x38, 0x31, 0x30, 0x26, 0x75, 0x6E, 0x69, 0x74,
0x5F, 0x69, 0x64, 0x3D, 0x33, 0x36, 0x44, 0x30, 0x38, 0x37, 0x26, 0x73, 0x65, 0x6E, 0x73, 0x6F,
0x72, 0x5F, 0x69, 0x64, 0x3D, 0x31, 0x34, 0x31, 0x34, 0x30, 0x30, 0x31, 0x38, 0x32, 0x36, 0x26,
0x73, 0x65, 0x71, 0x3D, 0x31, 0x36, 0x35, 0x26, 0x74, 0x73, 0x3D, 0x31, 0x35, 0x35, 0x35, 0x32,
0x35, 0x36, 0x33, 0x30, 0x31, 0x26, 0x64, 0x61, 0x74, 0x61, 0x3D, 0x35, 0x63, 0x62, 0x33, 0x36,
0x61, 0x65, 0x66, 0x35, 0x34, 0x34, 0x37, 0x66, 0x34, 0x61, 0x32, 0x34, 0x31, 0x63, 0x31, 0x39,
0x39, 0x39, 0x61, 0x20, 0x48, 0x54, 0x54, 0x50, 0x2F, 0x31, 0x2E, 0x31, 0x0D, 0x0A, 0x68, 0x6F,
0x73, 0x74, 0x3A, 0x20, 0x73, 0x65, 0x6E, 0x73, 0x6F, 0x72, 0x2E, 0x6C, 0x65, 0x73, 0x70, 0x72,
0x6F, 0x6A, 0x65, 0x6B, 0x74, 0x2E, 0x63, 0x7A, 0x3A, 0x34, 0x32, 0x35, 0x30, 0x0D, 0x0A, 0x61,
0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x6C, 0x61, 0x6E, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3A, 0x20,
0x66, 0x72, 0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x65, 0x6E, 0x63, 0x6F, 0x64,
0x69, 0x6E, 0x67, 0x3A, 0x20, 0x67, 0x7A, 0x69, 0x70, 0x2C, 0x64, 0x65, 0x66, 0x6C, 0x61, 0x74,
0x65, 0x0D, 0x0A, 0x75, 0x73, 0x65, 0x72, 0x2D, 0x61, 0x67, 0x65, 0x6E, 0x74, 0x3A, 0x20, 0x53,
0x49, 0x47, 0x46, 0x4F, 0x58, 0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x63, 0x68,
0x61, 0x72, 0x73, 0x65, 0x74, 0x3A, 0x20, 0x55, 0x54, 0x46, 0x2D, 0x38, 0x3B, 0x71, 0x3D, 0x30,
0x2E, 0x39, 0x2C, 0x2A, 0x3B, 0x71, 0x3D, 0x30, 0x2E, 0x37, 0x0D, 0x0A, 0x0D
};

unsigned char sigfox_2[] = {
0x47, 0x45, 0x54, 0x20, 0x2F, 0x44, 0x42, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4F, 0x54,
0x2F, 0x46, 0x65, 0x65, 0x64, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x6C, 0x65, 0x74, 0x3F, 0x4F,
0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3D, 0x49, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x4F,
0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x26, 0x64, 0x61, 0x74, 0x65, 0x3D,
0x31, 0x35, 0x35, 0x35, 0x32, 0x36, 0x38, 0x32, 0x30, 0x34, 0x26, 0x76, 0x61, 0x6C, 0x75, 0x65,
0x3D, 0x33, 0x33, 0x33, 0x32, 0x31, 0x37, 0x35, 0x39, 0x37, 0x34, 0x26, 0x75, 0x6E, 0x69, 0x74,
0x5F, 0x69, 0x64, 0x3D, 0x33, 0x36, 0x44, 0x30, 0x38, 0x37, 0x26, 0x73, 0x65, 0x6E, 0x73, 0x6F,
0x72, 0x5F, 0x69, 0x64, 0x3D, 0x31, 0x37, 0x38, 0x33, 0x37, 0x35, 0x31, 0x38, 0x32, 0x36, 0x26,
0x73, 0x65, 0x71, 0x3D, 0x31, 0x38, 0x34, 0x26, 0x74, 0x73, 0x3D, 0x31, 0x35, 0x35, 0x35, 0x32,
0x36, 0x31, 0x31, 0x30, 0x32, 0x26, 0x64, 0x61, 0x74, 0x61, 0x3D, 0x35, 0x63, 0x62, 0x33, 0x38,
0x32, 0x36, 0x63, 0x36, 0x61, 0x35, 0x31, 0x65, 0x34, 0x39, 0x32, 0x63, 0x36, 0x39, 0x63, 0x66,
0x38, 0x36, 0x36, 0x20, 0x48, 0x54, 0x54, 0x50, 0x2F, 0x31, 0x2E, 0x31, 0x0D, 0x0A, 0x68, 0x6F,
0x73, 0x74, 0x3A, 0x20, 0x73, 0x65, 0x6E, 0x73, 0x6F, 0x72, 0x2E, 0x6C, 0x65, 0x73, 0x70, 0x72,
0x6F, 0x6A, 0x65, 0x6B, 0x74, 0x2E, 0x63, 0x7A, 0x3A, 0x34, 0x32, 0x35, 0x30, 0x0D, 0x0A, 0x61,
0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x6C, 0x61, 0x6E, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3A, 0x20,
0x66, 0x72, 0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x65, 0x6E, 0x63, 0x6F, 0x64,
0x69, 0x6E, 0x67, 0x3A, 0x20, 0x67, 0x7A, 0x69, 0x70, 0x2C, 0x64, 0x65, 0x66, 0x6C, 0x61, 0x74,
0x65, 0x0D, 0x0A, 0x75, 0x73, 0x65, 0x72, 0x2D, 0x61, 0x67, 0x65, 0x6E, 0x74, 0x3A, 0x20, 0x53,
0x49, 0x47, 0x46, 0x4F, 0x58, 0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x63, 0x68,
0x61, 0x72, 0x73, 0x65, 0x74, 0x3A, 0x20, 0x55, 0x54, 0x46, 0x2D, 0x38, 0x3B, 0x71, 0x3D, 0x30,
0x2E, 0x39, 0x2C, 0x2A, 0x3B, 0x71, 0x3D, 0x30, 0x2E, 0x37, 0x0D, 0x0A, 0x0D, 0x0A
};

unsigned char sigfox_3[] = {
0x47, 0x45, 0x54, 0x20, 0x2F, 0x44, 0x42, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4F, 0x54,
0x2F, 0x46, 0x65, 0x65, 0x64, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x6C, 0x65, 0x74, 0x3F, 0x4F,
0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3D, 0x49, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x4F,
0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x26, 0x64, 0x61, 0x74, 0x65, 0x3D,
0x31, 0x35, 0x35, 0x35, 0x32, 0x36, 0x38, 0x34, 0x30, 0x30, 0x26, 0x76, 0x61, 0x6C, 0x75, 0x65,
0x3D, 0x34, 0x39, 0x38, 0x30, 0x37, 0x34, 0x26, 0x75, 0x6E, 0x69, 0x74, 0x5F, 0x69, 0x64, 0x3D,
0x33, 0x36, 0x44, 0x31, 0x32, 0x37, 0x26, 0x73, 0x65, 0x6E, 0x73, 0x6F, 0x72, 0x5F, 0x69, 0x64,
0x3D, 0x33, 0x34, 0x30, 0x33, 0x34, 0x30, 0x30, 0x39, 0x32, 0x26, 0x73, 0x65, 0x71, 0x3D, 0x37,
0x32, 0x34, 0x26, 0x74, 0x73, 0x3D, 0x31, 0x35, 0x35, 0x35, 0x32, 0x36, 0x34, 0x35, 0x31, 0x32,
0x26, 0x64, 0x61, 0x74, 0x61, 0x3D, 0x35, 0x63, 0x62, 0x33, 0x38, 0x33, 0x33, 0x30, 0x31, 0x34,
0x34, 0x39, 0x32, 0x64, 0x37, 0x63, 0x30, 0x30, 0x30, 0x37, 0x39, 0x39, 0x39, 0x61, 0x20, 0x48,
0x54, 0x54, 0x50, 0x2F, 0x31, 0x2E, 0x31, 0x0D, 0x0A, 0x68, 0x6F, 0x73, 0x74, 0x3A, 0x20, 0x73,
0x65, 0x6E, 0x73, 0x6F, 0x72, 0x2E, 0x6C, 0x65, 0x73, 0x70, 0x72, 0x6F, 0x6A, 0x65, 0x6B, 0x74,
0x2E, 0x63, 0x7A, 0x3A, 0x34, 0x32, 0x35, 0x30, 0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74,
0x2D, 0x6C, 0x61, 0x6E, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3A, 0x20, 0x66, 0x72, 0x0D, 0x0A, 0x61,
0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x65, 0x6E, 0x63, 0x6F, 0x64, 0x69, 0x6E, 0x67, 0x3A, 0x20,
0x67, 0x7A, 0x69, 0x70, 0x2C, 0x64, 0x65, 0x66, 0x6C, 0x61, 0x74, 0x65, 0x0D, 0x0A, 0x75, 0x73,
0x65, 0x72, 0x2D, 0x61, 0x67, 0x65, 0x6E, 0x74, 0x3A, 0x20, 0x53, 0x49, 0x47, 0x46, 0x4F, 0x58,
0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74,
0x3A, 0x20, 0x55, 0x54, 0x46, 0x2D, 0x38, 0x3B, 0x71, 0x3D, 0x30, 0x2E, 0x39, 0x2C, 0x2A, 0x3B,
0x71, 0x3D, 0x30, 0x2E, 0x37, 0x0D, 0x0A, 0x0D, 0x0A
};

unsigned char sigfox_4[] = {
0x47, 0x45, 0x54, 0x20, 0x2F, 0x44, 0x42, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4F, 0x54, 
0x2F, 0x46, 0x65, 0x65, 0x64, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x6C, 0x65, 0x74, 0x3F, 0x4F, 
0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3D, 0x49, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x4F, 
0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x26, 0x64, 0x61, 0x74, 0x65, 0x3D, 
0x31, 0x35, 0x35, 0x35, 0x32, 0x37, 0x32, 0x35, 0x31, 0x36, 0x26, 0x76, 0x61, 0x6C, 0x75, 0x65, 
0x3D, 0x33, 0x33, 0x33, 0x32, 0x37, 0x37, 0x36, 0x30, 0x33, 0x38, 0x26, 0x75, 0x6E, 0x69, 0x74, 
0x5F, 0x69, 0x64, 0x3D, 0x33, 0x36, 0x44, 0x30, 0x38, 0x37, 0x26, 0x73, 0x65, 0x6E, 0x73, 0x6F, 
0x72, 0x5F, 0x69, 0x64, 0x3D, 0x31, 0x37, 0x38, 0x33, 0x37, 0x35, 0x31, 0x38, 0x32, 0x36, 0x26, 
0x73, 0x65, 0x71, 0x3D, 0x31, 0x39, 0x39, 0x26, 0x74, 0x73, 0x3D, 0x31, 0x35, 0x35, 0x35, 0x32, 
0x36, 0x35, 0x34, 0x34, 0x38, 0x26, 0x64, 0x61, 0x74, 0x61, 0x3D, 0x35, 0x63, 0x62, 0x33, 0x39, 
0x33, 0x34, 0x34, 0x36, 0x61, 0x35, 0x31, 0x65, 0x34, 0x39, 0x32, 0x63, 0x36, 0x61, 0x36, 0x32, 
0x30, 0x36, 0x36, 0x20, 0x48, 0x54, 0x54, 0x50, 0x2F, 0x31, 0x2E, 0x31, 0x0D, 0x0A, 0x68, 0x6F, 
0x73, 0x74, 0x3A, 0x20, 0x73, 0x65, 0x6E, 0x73, 0x6F, 0x72, 0x2E, 0x6C, 0x65, 0x73, 0x70, 0x72, 
0x6F, 0x6A, 0x65, 0x6B, 0x74, 0x2E, 0x63, 0x7A, 0x3A, 0x34, 0x32, 0x35, 0x30, 0x0D, 0x0A, 0x61, 
0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x6C, 0x61, 0x6E, 0x67, 0x75, 0x61, 0x67, 0x65, 0x3A, 0x20, 
0x66, 0x72, 0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x65, 0x6E, 0x63, 0x6F, 0x64, 
0x69, 0x6E, 0x67, 0x3A, 0x20, 0x67, 0x7A, 0x69, 0x70, 0x2C, 0x64, 0x65, 0x66, 0x6C, 0x61, 0x74, 
0x65, 0x0D, 0x0A, 0x75, 0x73, 0x65, 0x72, 0x2D, 0x61, 0x67, 0x65, 0x6E, 0x74, 0x3A, 0x20, 0x53, 
0x49, 0x47, 0x46, 0x4F, 0x58, 0x0D, 0x0A, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2D, 0x63, 0x68, 
0x61, 0x72, 0x73, 0x65, 0x74, 0x3A, 0x20, 0x55, 0x54, 0x46, 0x2D, 0x38, 0x3B, 0x71, 0x3D, 0x30, 
0x2E, 0x39, 0x2C, 0x2A, 0x3B, 0x71, 0x3D, 0x30, 0x2E, 0x37, 0x0D, 0x0A, 0x0D, 0x0A
};

unsigned char tiny[] = 
{0x50,0x4F,0x53,0x54,0x20,0x2F,0x20,0x48,0x54,0x54,0x50,0x2F,0x31,0x2E,0x31,0x0D
,0x0A,0x41,0x75,0x74,0x68,0x6F,0x72,0x69,0x7A,0x61,0x74,0x69,0x6F,0x6E,0x3A,0x20
,0x6E,0x75,0x6C,0x6C,0x0D,0x0A,0x62,0x72,0x65,0x61,0x64,0x63,0x72,0x75,0x6D,0x62
,0x49,0x64,0x3A,0x20,0x49,0x44,0x3A,0x66,0x75,0x73,0x65,0x34,0x2D,0x33,0x34,0x36
,0x36,0x36,0x2D,0x31,0x36,0x30,0x31,0x39,0x33,0x35,0x34,0x30,0x33,0x34,0x30,0x32
,0x2D,0x31,0x3A,0x36,0x3A,0x33,0x32,0x3A,0x31,0x3A,0x37,0x38,0x33,0x32,0x35,0x0D
,0x0A,0x43,0x6F,0x6E,0x74,0x65,0x6E,0x74,0x2D,0x4C,0x65,0x6E,0x67,0x74,0x68,0x3A
,0x20,0x35,0x31,0x30,0x0D,0x0A,0x43,0x6F,0x6E,0x74,0x65,0x6E,0x74,0x2D,0x54,0x79
,0x70,0x65,0x3A,0x20,0x61,0x70,0x70,0x6C,0x69,0x63,0x61,0x74,0x69,0x6F,0x6E,0x2F
,0x6A,0x73,0x6F,0x6E,0x0D,0x0A,0x48,0x6F,0x73,0x74,0x3A,0x20,0x38,0x38,0x2E,0x38
,0x36,0x2E,0x31,0x31,0x33,0x2E,0x32,0x32,0x37,0x3A,0x34,0x32,0x35,0x39,0x0D,0x0A
,0x43,0x6F,0x6E,0x6E,0x65,0x63,0x74,0x69,0x6F,0x6E,0x3A,0x20,0x4B,0x65,0x65,0x70
,0x2D,0x41,0x6C,0x69,0x76,0x65,0x0D,0x0A,0x55,0x73,0x65,0x72,0x2D,0x41,0x67,0x65
,0x6E,0x74,0x3A,0x20,0x41,0x70,0x61,0x63,0x68,0x65,0x2D,0x48,0x74,0x74,0x70,0x43
,0x6C,0x69,0x65,0x6E,0x74,0x2F,0x34,0x2E,0x35,0x2E,0x32,0x20,0x28,0x4A,0x61,0x76
,0x61,0x2F,0x31,0x2E,0x38,0x2E,0x30,0x5F,0x32,0x35,0x32,0x29,0x0D,0x0A,0x41,0x63
,0x63,0x65,0x70,0x74,0x2D,0x45,0x6E,0x63,0x6F,0x64,0x69,0x6E,0x67,0x3A,0x20,0x67
,0x7A,0x69,0x70,0x2C,0x64,0x65,0x66,0x6C,0x61,0x74,0x65,0x0D,0x0A,0x0D,0x0A,0x7B
,0x22,0x74,0x79,0x70,0x65,0x22,0x3A,0x20,0x22,0x44,0x22,0x2C,0x20,0x22,0x64,0x61
,0x74,0x61,0x22,0x3A,0x20,0x22,0x7B,0x5C,0x22,0x63,0x6D,0x64,0x5C,0x22,0x3A,0x5C
,0x22,0x67,0x77,0x5C,0x22,0x2C,0x5C,0x22,0x73,0x65,0x71,0x6E,0x6F,0x5C,0x22,0x3A
,0x32,0x38,0x34,0x39,0x34,0x32,0x33,0x32,0x39,0x2C,0x5C,0x22,0x45,0x55,0x49,0x5C
,0x22,0x3A,0x5C,0x22,0x30,0x30,0x30,0x34,0x41,0x33,0x30,0x42,0x30,0x30,0x45,0x43
,0x30,0x44,0x44,0x38,0x5C,0x22,0x2C,0x5C,0x22,0x74,0x73,0x5C,0x22,0x3A,0x31,0x36
,0x30,0x32,0x34,0x30,0x30,0x32,0x33,0x30,0x32,0x33,0x39,0x2C,0x5C,0x22,0x66,0x63
,0x6E,0x74,0x5C,0x22,0x3A,0x32,0x33,0x32,0x37,0x34,0x2C,0x5C,0x22,0x70,0x6F,0x72
,0x74,0x5C,0x22,0x3A,0x31,0x2C,0x5C,0x22,0x66,0x72,0x65,0x71,0x5C,0x22,0x3A,0x38
,0x36,0x37,0x37,0x30,0x30,0x30,0x30,0x30,0x2C,0x5C,0x22,0x74,0x6F,0x61,0x5C,0x22
,0x3A,0x38,0x32,0x2C,0x5C,0x22,0x64,0x72,0x5C,0x22,0x3A,0x5C,0x22,0x53,0x46,0x37
,0x20,0x42,0x57,0x31,0x32,0x35,0x20,0x34,0x2F,0x35,0x5C,0x22,0x2C,0x5C,0x22,0x61
,0x63,0x6B,0x5C,0x22,0x3A,0x66,0x61,0x6C,0x73,0x65,0x2C,0x5C,0x22,0x67,0x77,0x73
,0x5C,0x22,0x3A,0x5B,0x7B,0x5C,0x22,0x72,0x73,0x73,0x69,0x5C,0x22,0x3A,0x2D,0x31
,0x32,0x30,0x2C,0x5C,0x22,0x73,0x6E,0x72,0x5C,0x22,0x3A,0x2D,0x37,0x2E,0x38,0x2C
,0x5C,0x22,0x74,0x73,0x5C,0x22,0x3A,0x31,0x36,0x30,0x32,0x34,0x30,0x30,0x32,0x33
,0x30,0x32,0x33,0x39,0x2C,0x5C,0x22,0x74,0x6D,0x6D,0x73,0x5C,0x22,0x3A,0x32,0x30
,0x30,0x30,0x2C,0x5C,0x22,0x74,0x69,0x6D,0x65,0x5C,0x22,0x3A,0x5C,0x22,0x32,0x30
,0x32,0x30,0x2D,0x31,0x30,0x2D,0x31,0x31,0x54,0x30,0x37,0x3A,0x31,0x30,0x3A,0x33
,0x30,0x2E,0x32,0x32,0x33,0x34,0x30,0x36,0x30,0x30,0x30,0x5A,0x5C,0x22,0x2C,0x5C
,0x22,0x67,0x77,0x65,0x75,0x69,0x5C,0x22,0x3A,0x5C,0x22,0x36,0x34,0x37,0x46,0x44
,0x41,0x46,0x46,0x46,0x46,0x30,0x30,0x36,0x41,0x33,0x43,0x5C,0x22,0x2C,0x5C,0x22
,0x61,0x6E,0x74,0x5C,0x22,0x3A,0x30,0x2C,0x5C,0x22,0x6C,0x61,0x74,0x5C,0x22,0x3A
,0x35,0x30,0x2E,0x30,0x34,0x33,0x31,0x32,0x31,0x34,0x2C,0x5C,0x22,0x6C,0x6F,0x6E
,0x5C,0x22,0x3A,0x31,0x34,0x2E,0x35,0x35,0x32,0x39,0x36,0x35,0x32,0x30,0x30,0x30
,0x30,0x30,0x30,0x31,0x37,0x7D,0x5D,0x2C,0x5C,0x22,0x62,0x61,0x74,0x5C,0x22,0x3A
,0x32,0x35,0x34,0x2C,0x5C,0x22,0x64,0x61,0x74,0x61,0x5C,0x22,0x3A,0x5C,0x22,0x61
,0x39,0x30,0x30,0x30,0x30,0x30,0x31,0x33,0x33,0x30,0x30,0x30,0x30,0x30,0x30,0x30
,0x30,0x30,0x30,0x30,0x31,0x39,0x37,0x30,0x30,0x65,0x63,0x38,0x30,0x30,0x30,0x30
,0x35,0x62,0x33,0x30,0x30,0x36,0x32,0x65,0x62,0x30,0x30,0x30,0x31,0x30,0x30,0x5C
,0x22,0x7D,0x22,0x2C,0x20,0x22,0x74,0x65,0x63,0x68,0x22,0x3A,0x20,0x22,0x4C,0x22
,0x2C,0x20,0x22,0x74,0x61,0x67,0x73,0x22,0x3A,0x20,0x5B,0x5D,0x7D};


static struct sockaddr_in cli_addr;
static unsigned int cli_len;

int httpSendThreadMain(uint64_t id, uint64_t sensor, time_t tp, char * values_text, char * operation, cfg_t * cfg_db)
{
/*
static http_retcode http_query(command, url, additional_header, mode,
			      data, length, pfd) 
{
*/
    int     s;
    struct  hostent *hp;
    struct  sockaddr_in server;
    char header[1024];
    char * response;
    int hlg;
    int ret;
    struct tm rec_time;
    fd_set fds;
    int res;
    struct timeval timeout;
    unsigned int length;

    char url[512];

//    cfg_t * cfg_db = cfg_getnsec(cfg, "db", 0);

    ret = 0;

    feederLog(LOG_DEBUG, "Contacting server %s\n", cfg_getstr(cfg_db, "server"));

//old version
//    localtime_r(&tp, &rec_time);
//new version
    gmtime_r(&tp, &rec_time);
    
    sprintf(url, "%s?%s&date=%04d-%02d-%02d+%02d:%02d:%02d%s&%s&unit_id=%lld",
	cfg_getstr(cfg_db, "uri"),
	operation,
	rec_time.tm_year + 1900, rec_time.tm_mon + 1, rec_time.tm_mday, rec_time.tm_hour, rec_time.tm_min, rec_time.tm_sec,
	(cfg_getstr(cfg_db, "timezone") != NULL) ? cfg_getstr(cfg_db, "timezone") : "",
	values_text,
	(unsigned long long int)id);
    if (sensor != 0)
	sprintf(url + strlen(url), "&sensor_id=%lld", (unsigned long long int)sensor);
	
//    feederLog(LOG_DEBUG, "Insert url: %s\n", url);
    
    if ((hp = gethostbyname(cfg_getstr(cfg_db, "server"))))//todo: boha
    {
	memset((char *) &server,0, sizeof(server));
	memmove((char *) &server.sin_addr, hp->h_addr, hp->h_length);
	server.sin_family = hp->h_addrtype;
	server.sin_port = (unsigned short) htons(cfg_getint(cfg_db, "port"));
    }
    else
	return ERRHOST;

    if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	return ERRSOCK;
    setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, 0, 0);

    if (connect(s, (struct sockaddr *)&server, sizeof(server)) < 0)
	ret = ERRCONN;
    else
    {
    
	sprintf(header,
	    "%s /%.256s HTTP/1.0\015\012User-Agent: %s\015\012%s\015\012",
	    "GET",
	    url,
	    "Sensors receiver",
	    ""
	);
	hlg = strlen(header);

	if (write(s, header, hlg) != hlg)
    	    ret = ERRWRHD;
    }

    FD_ZERO(&fds);
    FD_SET(s, &fds);
    
    timeout.tv_sec = 10;
    timeout.tv_usec = 0;
    
    res = select(FD_SETSIZE, &fds, (fd_set *)0, (fd_set *)0, (struct timeval *)&timeout);
    if (res < 1)
    {
	ret = ERRRDHD;
    }
    if (res == 0)
    {
	ret = ERRRDHD;
	feederLog(LOG_WARNING, "Server %s timeouted\n", cfg_getstr(cfg_db, "server"));
    }
    if (res > 0)
    {
    	ioctl(s, FIONREAD, &length);

	response = (char *)malloc(length + 1);
	if (response != NULL)
	{
	    hlg = read(s, response, length);	//todo: tady to muze zustat viset kdyz server nedpovi
	    response[length] = 0;
//    feederLog(LOG_DEBUG, "Insert url: %s\n", url);
	    feederLog(LOG_INFO, "Server response for url %s%s, len %d:\n%s\n", cfg_getstr(cfg_db, "server"), url, length, response);
	    free(response);
	}
    }
    
    close(s);
/*
    free(values_text);
    free(operation);*/
    
    return ret;
}


typedef struct http_send_t
{
    uint64_t id;
    uint64_t sensor;
    time_t tp;
    char * values_text;
    char * operation;
} http_send_t;


list_t thread_list;
int thread_counter = 0;
pthread_mutex_t thread_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t thread_max_mutex = PTHREAD_MUTEX_INITIALIZER;

typedef struct server_t
{
    uint8_t thread_running;
    pthread_mutex_t thread_mutex;
    cfg_t * cfg_db;
    list_t list;
//    uin32_t max_messages;
} server_t;

struct server_t servers[16];


void timerCallback(int signo)
{
	unsigned int (* timeout_func)(void *, int, unsigned char *);
	
	struct type_t * type;
	unsigned int len;
	unsigned char data[1024];
	struct hostent * hostinfo;
	unsigned int list_full;
//	uint8_t i;
	
	(void)signo;
	
	type = types;	
	while (type != NULL)
	{
	    if (type->timeout > 0)
	    {
		type->time++;
		if (type->time >= type->timeout)
		{
		    type->time = 0;
		    feederLog(LOG_DEBUG, "Type %s timeouted\n", type->name);
		    timeout_func = (unsigned int(*)(void *, int, unsigned char *))dlsym(type->dl, "timeout");
		    
		    if (timeout_func != NULL)
		    {
			
			list_full = 0;
/*			i = 0;
		        while (servers[i].cfg_db != NULL)
		        {
    			    pthread_mutex_lock(&servers[i].thread_mutex);
    			    if (list_size(&servers[i].list) > 1000)	//todo: konfigurovatelne
    				list_full++;
    			    pthread_mutex_unlock(&servers[i].thread_mutex);
    			    i++;
    			    feederLog(LOG_DEBUG, "List size is %d\n", list_size(&servers[i].list));
    			}
*/		    
			len = 0;
			if (list_full > 0)
			    feederLog(LOG_DEBUG, "List is full\n", len);
			else
			    len = timeout_func(NULL, type->socket, data);
			    
			if (type->proto != PROTO_SELF)
			    feederLog(LOG_DEBUG, "Timeout %d bytes\n", len);
			if (len > 0)
			{
			    hostinfo = gethostbyname(type->address);
			    if (hostinfo == NULL)
			    {
				feederLog(LOG_WARNING, "No host %s\n", type->address);
			    }
			    else
			    {
				feederLog(LOG_DEBUG, "Host is on %s\n", hostinfo->h_name);
			    }
			}
			if (type->proto == PROTO_SELF)
			{
			    translate(NULL, 0, type, NULL, NULL, type->socket);
			}
		    }
		    else
			feederLog(LOG_WARNING, "No timeout function\n");
		}
	    }	
	    type = type->next;
	}

}

void initTimer(void)
{
    struct itimerval value;
    
    value.it_value.tv_sec = 1;
    value.it_value.tv_usec = 0;
    
    value.it_interval.tv_sec = 1;
    value.it_interval.tv_usec = 0;
    
    signal(SIGALRM, timerCallback);
    setitimer(ITIMER_REAL, &value, 0);
    
    
}




void * httpSendThread(void * ptr)
{
    struct http_send_t * http_send;
    struct server_t * server;
    struct mallinfo minfo;
    
    struct timespec delay_time, remaining_time;

/*    thread = pthread_self();
    pthread_mutex_lock(&thread_mutex);
    list_append(&thread_list, &thread);
    thread_counter++;
    feederLog(LOG_DEBUG, "Thread %d, currently running %d send threads\n", thread, list_size(&thread_list));
    pthread_mutex_unlock(&thread_mutex);*/

    server = (struct server_t *)ptr;
    
    while (1)//todo: acm4 obcas udelal, ze exitne thread a pritom nenastavi promennou running na 0 -> hlavni vlakno si mysli ze thread bezi a nevytvari nove -> efektivne se zastavi posilani dat
    //hack: nebudeme vlakno vypinat, jen ho na nejaky cas suspendnem, coz zpomali cestu dat (na cas suspendnuti) nyni 1s (viz sleep)
    //slo by predelat s pthread_cond_timewait
    {
    
    while (pthread_mutex_lock(&server->thread_mutex), http_send = (struct http_send_t *)(list_fetch(&server->list)), pthread_mutex_unlock(&server->thread_mutex), http_send != NULL)
    {

	minfo = mallinfo();
	feederLog(LOG_DEBUG, "Memory allocated: %lld\n", minfo.arena);
	feederLog(LOG_INFO, "Messages in list: %lld\n", list_size(&server->list));
    
	if (httpSendThreadMain(http_send->id, http_send->sensor, http_send->tp, http_send->values_text, http_send->operation, server->cfg_db) >= 0)
	{
	    free(http_send->values_text);
	    free(http_send->operation);
	    free(http_send);
	}
        else
        {
    	    feederLog(LOG_WARNING, "Can not send GET, reinserting in list\n");
    	    pthread_mutex_lock(&server->thread_mutex);
    	    list_append(&server->list, http_send);
    	    pthread_mutex_unlock(&server->thread_mutex);
    	    delay_time.tv_sec = cfg_getint(cfg, "serverdelay");
    	    delay_time.tv_nsec = 0;
    	    nanosleep(&delay_time, &remaining_time);
	}
    }
    
    
	sleep(1);
    }
    
/*    pthread_mutex_lock(&thread_mutex);
    thread_pos = list_locate(&thread_list, &thread);
    if (thread_pos >= 0)
    {
	list_delete_at(&thread_list, thread_pos);
    }
    thread_counter--;
    pthread_mutex_unlock(&thread_mutex);*/

    feederLog(LOG_DEBUG, "Exiting thread\n");

    server->thread_running = 0;
    
    pthread_exit(NULL);

    return NULL;
}

void initServers(void)
{
    uint8_t i;
    cfg_t * cfg_db;

    i = 0;
    while (cfg_db = cfg_getnsec(cfg, "db", i), cfg_db != NULL)	//todo: kontrolvat maximum serveru (16) 
    {
	servers[i].thread_running = 0;
	servers[i].cfg_db = cfg_db;
	list_init(&servers[i].list);	//todo: jestli se povedlo
        pthread_mutex_init(&(servers[i].thread_mutex), NULL);
	i++;
    }
    servers[i].thread_running = 0;
    servers[i].cfg_db = NULL;
    pthread_mutex_init(&(servers[i].thread_mutex), NULL);
}
/*
int getListSize(
{
	pthread_mutex_lock(&servers[i].thread_mutex);
    	if (list_size(&servers[i].list) > 1000)
    	    list_full++;
    	pthread_mutex_unlock(&servers[i].thread_mutex);
}
*/
int httpSend(uint64_t id, uint64_t sensor, time_t tp, char * values_text, char * operation)
{
    pthread_t thread;
    struct http_send_t * http_send;
    uint8_t i;

    feederLog(LOG_DEBUG, "Sending %s, timestamp %ld, id %lld, sensor %lld, operation %s\n", values_text, tp, id, sensor, operation);

    i = 0;
//    while (cfg_db = cfg_getnsec(cfg, "db", i), cfg_db != NULL)
    while (servers[i].cfg_db != NULL)
    {
	http_send = (struct http_send_t *)malloc(sizeof(struct http_send_t));
	feederLog(LOG_DEBUG, "Http send\n");
        http_send->id = id;
	http_send->sensor = sensor;
        http_send->tp = tp;
	http_send->values_text = (char *)malloc(strlen(values_text) + 1);//*
        strcpy(http_send->values_text, values_text);
	http_send->operation = (char *)malloc(strlen(operation) + 1);//*
        strcpy(http_send->operation, operation);
        
        while (cfg_getint(servers[i].cfg_db, "max_msg") < list_size(&servers[i].list))
        {
    	    feederLog(LOG_DEBUG, "Message queue for %s is full, waiting\n", cfg_getstr(servers[i].cfg_db, "server"));
    	    sleep(1);
        }
        
        pthread_mutex_lock(&servers[i].thread_mutex);
        list_append(&servers[i].list, http_send);
        pthread_mutex_unlock(&servers[i].thread_mutex);

        if (servers[i].thread_running == 0)
        {
    	    feederLog(LOG_DEBUG, "Creating thread for %s\n", cfg_getstr(servers[i].cfg_db, "server"));
        
	    pthread_create(&thread, NULL, httpSendThread, &servers[i]);
	    servers[i].thread_running = 1;
    	    pthread_detach(thread);
    	}
    	else
    	    feederLog(LOG_DEBUG, "Thread for %s already started\n", cfg_getstr(servers[i].cfg_db, "server"));
    	
	
	i++;
    }

    return 0;
}

int httpSendPosition(uint64_t id, time_t tp, double lat, double lon, double alt, double dop, double speed)
{
    char values_text[256];
    
    sprintf(values_text, "lat=%f&lon=%f&alt=%f&dop=%f&speed=%f", lat, lon, alt, dop, speed);
    return httpSend(id, 0, tp, values_text, (char *)"Operation=InsertPosition");
}

int httpSendObservation(uint64_t id, uint64_t sensor, time_t tp, double val)
{
    char values_text[64];
    
    sprintf(values_text, "value=%.4f", (float)val);
    return httpSend(id, sensor, tp, values_text, (char *)"Operation=InsertObservation");
//    return httpSend(id, sensor, tp, values_text, (char *)"Operation=SLEEP");		//todo:ZRUSIT, tohle je pouze pro test vyhniti serveru
}

int httpSendAlert(uint64_t id, int32_t alert, time_t tp)
{
    char values_text[64];
    
    sprintf(values_text, "alert_id=%d", alert);
    return httpSend(id, 0, tp, values_text, (char *)"Operation=InsertAlertEvent");
}


void initFds(fd_set * fds)
{
	struct type_t * type;
	
	FD_ZERO(fds);
	type = types;
	while (type != NULL)
	{
		if ((type->socket != 0) && (type->proto != PROTO_TCP_ACT) && (type->proto != PROTO_SELF))
			FD_SET(type->socket, fds);
		type = type->next;
	}
}

struct type_t * findType(int sock)
{
	struct type_t * type;
	
	type = types;	
	while (type != NULL)
	{
		if (type->socket == sock)
			return type;
		type = type->next;
	}
	return NULL;
}

struct csock_t * findSockClientTcp(struct type_t * type, int sock)
{
	struct csock_t * csock;
			
	csock = type->csocks;
	while (csock != NULL)
	{
		if (csock->socket == sock)
			return csock;
		csock = csock->next;
	}
	return NULL;
}


struct type_t * findTypeClientTcp(int sock)
{
	struct type_t * type;
	struct csock_t * csock;
			
	type = types;
	while (type != NULL)
	{
		csock = type->csocks;
		while (csock != NULL)
		{
			if (csock->socket == sock)
				return type;
			csock = csock->next;
		}
		type = type->next;
	}
	return NULL;
}

struct type_t * findTypeClientUdp(int sock)
{
	struct type_t * type;
			
	type = types;	
	while (type != NULL)
	{
		if (type->socket == sock)
			return type;
		type = type->next;
	}
	return NULL;
}


#define BUF_DATA_SIZE 65536
struct csock_t * addClient(struct type_t * type, int sock)
{
	struct csock_t * csock, * csock_last;
	
	csock = (csock_t *)malloc(sizeof(struct csock_t));
	if (csock == NULL)
	{
		feederLog(LOG_WARNING, "Can not allocate client socket data\n");
		return NULL;
	}
	
	csock->buf_data = (uint8_t *)malloc(BUF_DATA_SIZE);
	if (csock->buf_data == NULL)
	{
		feederLog(LOG_WARNING, "Can not allocate client socket data buffer\n");
		free(csock);
		return NULL;
	}
	csock->buf_data_len = 0;
	
	csock->socket = sock;
	if (type->lib_data_size > 0)
	{
	    csock->lib_data = malloc(type->lib_data_size);
	    if (csock->lib_data == NULL)
	    {
		feederLog(LOG_WARNING, "Can not allocate lib data for client\n");
		free(csock);
		return NULL;
	    }
	}
	else
	{
	    csock->lib_data = NULL;
	}
	
	csock->next = NULL;
	feederLog(LOG_DEBUG, "Lib data allocated, size %d\n", type->lib_data_size);
	
	
	if (type->csocks == NULL)
		type->csocks = csock;
	else
	{
		csock_last = type->csocks;
		while (csock_last->next != NULL)
			csock_last = csock_last->next;
		csock_last->next = csock;
	}
	return csock;
}

void remClient(struct type_t * type, int sock)
{
	struct csock_t * csock, * csock_last;
	
	csock = type->csocks;
	csock_last = NULL;
	while (csock->socket != sock)
	{
		csock_last = csock;
		csock = csock->next;
	}
	if (csock_last == NULL)
		type->csocks = csock->next;
	else
		csock_last->next = csock->next;
	free(csock->lib_data);
	free(csock->buf_data);
	free(csock);
}

void logHex(unsigned char * data, unsigned int length)
//void logHex(char * buffer, unsigned char * data, unsigned int length)
{
    unsigned int i, l;
    char buffer[256];

    buffer[0] = 0;
    l = 0;
    buffer[0] = 0;
    for (i = 0; i < length; i++)
    {
    	sprintf(buffer + strlen(buffer), "%02X ", data[i]);
    	l++;
    	if (l == 16)
    	{
    	    feederLog(LOG_DEBUG, "%s\n", buffer);
    	    l = 0;
    	    buffer[0] = 0;
    	}
    }
    if (l != 0)
        feederLog(LOG_DEBUG, "%s\n", buffer);
}

uint16_t ifaceGetReq(uint64_t id, uint8_t * data);

int translate(unsigned char * data, unsigned int length, struct type_t * type, unsigned char * reply_data, int * reply_len, int fd)
{
	unsigned int (* process)(void *, int, unsigned char *, unsigned int, unsigned long long int *, time_t *, double *, uint64_t *, unsigned int *);
	/*	unsigned int (* process_gps)(unsigned char *, unsigned int, double *, double *, double *);*/
/*	unsigned int (* process_id)(unsigned char *, unsigned int, unsigned int *, char *, char *);*/
	int (* reply)(void *, int, unsigned char *);
    int (* cmd)(void *, int, unsigned char *, unsigned int, unsigned char *);
	
	unsigned long long int id;
//	unsigned int status, pbb_status;
	time_t tp;
	int i, len, res;
	unsigned int data_type;
	
	double values[64];
	uint64_t sensors[64];
	void * lib_data = NULL;
	struct csock_t * csock;
	
//	char buffer[8192];
	
/*	
	unsigned int id_code;
	char id_name[64], id_group[64];
	int rid; * db row auto id *
*/	
	res = 0;

	if (type == NULL)
	{
		feederLog(LOG_WARNING, "Client data without type\n");
		return -1;
	}
	feederLog(LOG_INFO, "Data from type %s\n", type->name);
	
	csock = findSockClientTcp(type, fd);
	if (csock != NULL)
	    lib_data = csock->lib_data;
	else
	    lib_data = NULL;
	    
	process = (unsigned int(*)(void *, int, unsigned char *, unsigned int, unsigned long long int *, time_t *, double *, uint64_t *, unsigned int *))dlsym(type->dl, "process");//*
	
	if (process != NULL)
	{
		len = process(lib_data, fd, data, length, &id, &tp, values, sensors, &data_type);
		
		while (len > 0)
		{
		    if (len == 10000)
		    {
			len = process(lib_data, fd, NULL, 0, &id, &tp, values, sensors, &data_type);
			continue;
		    }
		    
		    feederLog(LOG_DEBUG, "Id %llu\n", id);
		    feederLog(LOG_DEBUG, "Timestamp %lu\n", tp);
		    for (i = 0; i < len; i++)
			feederLog(LOG_DEBUG, "Value %d: %llu=%G, data_type=%d, id=%llu\n", i, sensors[i], values[i], data_type, id);
		    if (data_type == VALUES_TYPE_POS)
		    {
			if (len < 3)
			    values[2] = 0.0;
			if (len < 4)
			    values[3] = 1.0;
			if (len < 5)
			    values[4] = 0.0;
			res = httpSendPosition(id, tp, values[0], values[1], values[2], values[3], values[4]);
		    }
/*		    if (data_type == VALUES_TYPE_ALARM)
		    for (i = 0; i < len; i++)
		    {
		        res = httpSendObservation(id, sensors[i], tp, values[i]);
		    }*/
//			res = httpSendObservation(id, sensors[0], tp, values[0]);
		    if (data_type == VALUES_TYPE_OBS)
		    {
			for (i = 0; i < len; i++)
			{
			    res = httpSendObservation(id, sensors[i], tp, values[i]);
			//vojta - spocitame vwc z permitivity
			    if ((sensors[i] == 690020005) && (id == 3592324))
			    {
				double e, vwc;
				e = values[i];
//				vwc = 4.3*pow(10,-6)*pow(e,3)-5.5*pow(10,-4)*pow(e,2)+2.92*pow(10,-2)*e-5.3*pow(10,-2);
				vwc = 4.3E-6*pow(e,3)-5.5E-4*pow(e,2)+2.92E-2*e-5.3E-2;
				res = httpSendObservation(id, 700020005, tp, vwc);
			    }
			//konec vojty
			}
		    }
		    if (data_type == VALUES_TYPE_ALERT)
		    {
			for (i = 0; i < len; i++)
			{
		    	    res = httpSendAlert(id, sensors[i], tp);
			}
			//res = httpSendAlert(id, sensors[0], tp);
		    }
		    if (res < 0)
			feederLog(LOG_WARNING, "Can not send record to server, err %d\n", res * -1);
		    
			
		    len = process(lib_data, fd, NULL, 0, &id, &tp, values, sensors, &data_type);
		}
		    
/*		
		gps_valid = 0;
		process_gps = dlsym(type->dl, "processGps");
		if (process_gps != NULL)
		{
		    gps_valid = process_gps(data, length, &lat, &lon, &alt);
		}
*/		
/*
		if (len != 0)//todo: pri chybe by asi mel vratiti -1, ale mame navratovej typ unsigned 
		{
		
//!		    feederLog(LOG_DEBUG, "Processed: status %d\n", pbb_status);

		    localtime_r(&tp, &t_p);
		    t = time(NULL);
		    localtime_r(&t, &t_s);
		    sprintf(query, "'%llu','%04d-%02d-%02d %02d:%02d:%02d','%04d-%02d-%02d %02d:%02d:%02d','%d','%d'",
			id,
		        t_s.tm_year + 1900, t_s.tm_mon + 1, t_s.tm_mday, t_s.tm_hour, t_s.tm_min, t_s.tm_sec,
			t_p.tm_year + 1900, t_p.tm_mon + 1, t_p.tm_mday, t_p.tm_hour, t_p.tm_min, t_p.tm_sec,
		        pbb_status,
			data_type);
		    sprintf(col, "obj_id,rec_tstamp,prim_tstamp,status_code,data_type");
		
		    if (len > 0)
		    {
			sprintf(query + strlen(query), ",%s", data);;
			for (i = 0; i < len; i++)
			    sprintf(col + strlen(col), ",event_%d", i + 1);
		    }
		    
//!		    dbaseCheckDevice(id);
//		    rid = dbaseInsert("log", col, query); //todo:check id against cases table
//!		    dbaseInsert("log", col, query);
		
		    sprintf(query, "'%llu','%d','%04d-%02d-%02d %02d:%02d:%02d'",
			id, pbb_status,
			t_s.tm_year + 1900, t_s.tm_mon + 1, t_s.tm_mday, t_s.tm_hour, t_s.tm_min, t_s.tm_sec);
		    sprintf(col, "obj_id,status_code, rec_tstamp");
		    sprintf(where, "obj_id='%llu'", id);
		    sprintf(update, "obj_id='%llu',status_code='%d',rec_tstamp='%04d-%02d-%02d %02d:%02d:%02d'",
			id, pbb_status,
			t_s.tm_year + 1900, t_s.tm_mon + 1, t_s.tm_mday, t_s.tm_hour, t_s.tm_min, t_s.tm_sec);
		    
		    
		    if (alt < 100000.0)
		    {
			printf(query + strlen(query), ",'%lf','%lf','%lf'",
			    lat, lon, alt);
    			sprintf(col + strlen(col), ",gps_lat,gps_lon,gps_alt");
			sprintf(update + strlen(update), ",gps_lat='%lf',gps_lon='%lf',gps_alt='%lf'",
			    lat, lon, alt);
		    }
//!		    dbaseUpdate("online", update, col, query, where);
		}*/
	}
	else
		feederLog(LOG_WARNING, "Library has no process function\n");
/*	todo: proc to bylo a k cemu to bylo?
	process_id = dlsym(type->dl, "processId");
	if (process_id != NULL)
	{
	    if (process_id(data, length, &id_code, id_name, id_group) > 0)
	    {
		sprintf(query, "'%d','%d','%s','%s'",
		    rid,
		    id_code, id_name, id_group);
		sprintf(col, "log_nbr,id_code,id_name,id_group");
		dbaseInsert("log_id", col, query);
	    }
    	
	}
	else
	    feederLog(LOG_WARNING, "Library has no process id function\n");
*/		
	
	if ((reply_data != NULL) && (reply_len != NULL))
	{
	    reply = (int(*)(void *, int, unsigned char *))dlsym(type->dl, "reply");//*
	    if (reply != NULL)
	    {
		while (*reply_len = reply(lib_data, fd, reply_data), *reply_len > 0)
		{
		    sendto(fd, reply_data, *reply_len, 0, (struct sockaddr *)&cli_addr, cli_len);

    		feederLog(LOG_DEBUG, "Outgoing reply data: len %d: ", *reply_len);
		    logHex(reply_data, *reply_len);
		    *reply_len = 0;
		}

		
	    }
	    else
	    {
		feederLog(LOG_WARNING, "Library has no reply function\n");
		*reply_len = 0;
	    }
	}



    cmd = (int(*)(void *, int, unsigned char *, unsigned int, unsigned char *))dlsym(type->dl, "cmd");
    if (cmd != NULL)
    {
        unsigned int cmd_data_len;
        unsigned char cmd_data[1024];
        
        cmd_data_len = ifaceGetReq(id, cmd_data);
        if (cmd_data_len > 0)
        {
            *reply_len = cmd(lib_data, fd, cmd_data, cmd_data_len, reply_data);
            if (*reply_len > 0) //todo: vic najednou? tedy while
            {
                sendto(fd, reply_data, *reply_len, 0, (struct sockaddr *)&cli_addr, cli_len);
                
                feederLog(LOG_DEBUG, "Outgoing cmd data: len %d: ", *reply_len);
                logHex(reply_data, *reply_len);
                *reply_len = 0;
            }
        }
    }

	
	return 0;
}

void dataFailTest(uint8_t * data, uint16_t len)
{
    (void)data;
    (void)len;
/*    uint16_t i;
    
    for (i = 0; i < len / 2; i++)
	data[i] = i;*/
}

void sigFn(int sig)
{
    printf("Signal %d\n", sig);

    exit(0);
}

//------------------------------------------------------------------------------------------------------------------

#define IFACE_DATA_SIZE 512
typedef struct iface_message_t
{
    uint64_t id;
    uint8_t data[IFACE_DATA_SIZE];
    uint16_t data_len;
    struct iface_message_t * next;
} iface_message_t;

struct iface_message_t * iface_messages = NULL;

void ifaceUriFindVar(char * uri, const char * varname, char * buf)
{
    char * s;
    
    if (s = strstr(uri, varname), s != NULL)
    {
        if (s = strchr(s, '='), s != NULL)
        {
            s++;
            while ((*s > ' ') && (*s != '&'))
                *buf++ = *s++;
            *buf = '\0';
        }
    }
}

uint16_t ifaceGetReq(uint64_t id, uint8_t * data)
{
    struct iface_message_t * message, * message_prev;
    uint16_t len;
    
    message = iface_messages;
    message_prev = NULL;
    while (message != NULL)
    {
        if (message->id == id)
        {
            feederLog(LOG_DEBUG, "Iface getting req for unit: %lld\n", id);
            memcpy(data, message->data, message->data_len);
            len = message->data_len;
            
            if (message_prev == NULL)
                iface_messages = message->next;
            else
                message_prev->next = message->next;
            
            free(message);
            return len;
        }
        message_prev = message;
        message = message->next;
    }
    return 0;
}

int ifaceAddReq(uint64_t id, uint8_t * data, uint16_t data_len)
{
    struct iface_message_t * message, * message_last;

    feederLog(LOG_DEBUG, "Iface enquying req for unit: %lld\n", id);
    logHex(data, data_len);

    message = (struct iface_message_t *)malloc(sizeof(struct iface_message_t));
    if (message != NULL)
    {
        message->id = id;
        memcpy(message->data, data, data_len);
        message->data_len = data_len;
        message->next = NULL;
        
        if (iface_messages == NULL)
            iface_messages = message;
        else
        {
            message_last = iface_messages;
            while (message_last->next != NULL)
                message_last = message_last->next;
            message_last->next = message;
        }    
    }
    return 0;
}

uint16_t hexstr2bin(char * str, uint8_t * data)
{
    uint16_t i, l;

    i = strlen(str);
    l = i;
    str = str + i - 1;
    
    memset(data, 0, (i + 1) / 2);
    while (i > 0)
    {
        if ((i - 1) % 2)
            data[(i - 1) / 2] |= 0x0F & (*str - ((*str >= 'A')?('A' - 10):'0'));//todo: pokud je pocet digitu lichy priradit nulu na zacatek a ne na konec jako ted
        else
            data[(i - 1) / 2] |= 0xF0 & ((*str - ((*str >= 'A')?('A' - 10):'0')) << 4);
        str--;
        i--;
    }
    return (l + 1) / 2;
}


int ifaceServiceMessages(int fd)
{
    struct iface_message_t * message;
    char buf[1024];
    uint16_t i;
    
    feederLog(LOG_DEBUG, "Service messages\n");
    
    message = iface_messages;
//    sprintf(buf, "<table>\r\n");
//    send(fd, buf, strlen(buf), 0);
    
    while (message != NULL)
    {
        //sprintf(buf, "<tr><td>%lld<td>", (long long int)message->id);
        sprintf(buf, "%lld\t\t", (long long int)message->id);
        send(fd, buf, strlen(buf), 0);
        for (i = 0; i < message->data_len; i++)
        {
            sprintf(buf, "%02X", message->data[i]);
            send(fd, buf, strlen(buf), 0);
    	}
        sprintf(buf, "\r\n");
        send(fd, buf, strlen(buf), 0);
        
        message = message->next;
    }
//    sprintf(buf, "</table>\r\n");
//    send(fd, buf, strlen(buf), 0);
    return 0;
}

int ifaceServiceSend(int fd, char * uri)
{
    char unit_id_str[64], data_str[1024];
    uint8_t data_bin[512];
    uint16_t data_len;
    char buf[1024];    

    feederLog(LOG_DEBUG, "Service send\n");
    
    unit_id_str[0] = data_str[0] = '\0';
    ifaceUriFindVar(uri, "unit_id", unit_id_str);
    ifaceUriFindVar(uri, "data", data_str);
    if (strlen(unit_id_str) > 0)
    {
        data_len = hexstr2bin(data_str, data_bin);
        ifaceAddReq(atoll(unit_id_str), data_bin, data_len);
    }
    
    sprintf(buf, "OK");
    send(fd, buf, strlen(buf), 0);
    
    return 0;
}

int ifaceParseUri(int fd, char * uri)
{
    char service_str[32];
    
    ifaceUriFindVar(uri, "service", service_str);
    if (strcmp(service_str, "messages") == 0)
        ifaceServiceMessages(fd);
    if (strcmp(service_str, "send") == 0)
        ifaceServiceSend(fd, uri);
    return 0;
}

#define IFACE_BUFSIZE 1024
void * ifaceThread(void * ptr)
{
    int fds;                /* server socket*/
    int fdc;               /* client socket */
    int optval;            /* flag value for setsockopt */
    struct sockaddr_in serveraddr; /* server's addr */
    struct sockaddr_in clientaddr; /* client addr */    
    int portno;            /* port to listen on */
    int clientlen;         /* byte size of client's address */
    int length;
    
    
  /* variables for connection I/O */
//    FILE *stream;          /* stream version of childfd */
    char buf[IFACE_BUFSIZE];     /* message buffer */
    char str[IFACE_BUFSIZE];     /* message buffer */
    char *b;
/*    char method[IFACE_BUFSIZE];  * request method *
    char uri[IFACE_BUFSIZE];     * request uri *
    char version[IFACE_BUFSIZE]; * request method *
*/
    char *uri;
    
    fds = socket(AF_INET, SOCK_STREAM, 0);
    if (fds < 0) 
    {
        feederLog(LOG_ERR, "Failed to open iface socket\n");
        return NULL;
    }
    optval = 1;
    setsockopt(fds, SOL_SOCKET, SO_REUSEADDR, 
	     (const void *)&optval , sizeof(int));

    /* bind port to socket */
    bzero((char *) &serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    portno = *((int *)ptr);
    serveraddr.sin_port = htons((unsigned short)portno);
    if (bind(fds, (struct sockaddr *) &serveraddr, sizeof(serveraddr)) < 0) 
    {
        feederLog(LOG_ERR, "Failed to bind iface socket\n");
        return NULL;
    }

    /* get us ready to accept connection requests */
    if (listen(fds, 5) < 0) /* allow 5 requests to queue up */ 
    {
        feederLog(LOG_ERR, "Failed to listen on iface socket\n");
        return NULL;
    }    

    feederLog(LOG_DEBUG, "Iface ready on %d\n", portno);
    
    while (1)
    {
        /* wait for a connection request */
        fdc = accept(fds, (struct sockaddr *) &clientaddr, (socklen_t *)&clientlen);
        if (fdc < 0) 
        {
            feederLog(LOG_ERR, "Error on iface client fd\n");
            continue;
        }
        feederLog(LOG_DEBUG, "Iface activity from:\n");//todo: doplnit klienta
        
        buf[0] = '\0';
/*        ioctl(fdc, FIONREAD, &length);
        length = read(fdc, buf, length);
*/
        
        length = recv(fdc, buf, IFACE_BUFSIZE, 0);
        buf[length] = '\0';
     
        /* open the child socket descriptor as a stream */
/*        if ((stream = fdopen(fdc, "r+")) == NULL)
        {
            feederLog(LOG_ERR, "Iface stream\n");
            continue;
        }
        * get the HTTP request line *
        fgets(buf, IFACE_BUFSIZE, stream);*/
        
        if (length > 0)
        {
            feederLog(LOG_DEBUG, "Iface request length %d: %s\n", length, buf);
            //sscanf(buf, "%s %s %s\n", method, uri, version);//todo: nahradit sscanf !!!
            b = strchr(buf, ' ');
            uri = NULL;
            if (b != NULL)
            {
                uri = b + 1;
                b = strchr(uri, ' ');
                if (b != NULL)
                    *b = '\0';
            }
            feederLog(LOG_DEBUG, "uri %s\n", uri);
            
          
            sprintf(str, "HTTP/1.1 200 OK\r\n");
            send(fdc, str, strlen(str), 0);
            sprintf(str, "Server: Feeder Web Server\r\n");
            send(fdc, str, strlen(str), 0);
    //        sprintf(str, "Content-length: %d\r\n", //(int)sbuf.st_size);
      //      send(fdc, str, strlen(str), 0);
            sprintf(str, "Content-type: text/plain\r\n");
            send(fdc, str, strlen(str), 0);
            sprintf(str, "Connection: close\r\n");
            send(fdc, str, strlen(str), 0);
            sprintf(str, "\r\n");
            send(fdc, str, strlen(str), 0);
            
            feederLog(LOG_DEBUG, "uriiii %s\n", uri);
            ifaceParseUri(fdc, uri);
            
            
            /* print response header */
            //fprintf(stream, "HTTP/1.1 200 OK\r\n");
            //fprintf(stream, "Server: Feeder Web Server\r\n");
            //fprintf(stream, "Content-length: %d\r\n", 2);//(int)sbuf.st_size);
            //fprintf(stream, "Content-type: text/html\r\n");
            //fprintf(stream, "Connection: close\r\n");
            //fprintf(stream, "\r\n"); 
            //fflush(stream);
            
            //fprintf(stream, "OK"); 
            //fflush(stream);
            
            /* clean up */
            //fclose(stream);
        }
        close(fdc);
        feederLog(LOG_DEBUG, "Iface client exit\n");
    }

    feederLog(LOG_DEBUG, "Exiting iface thread\n");


    pthread_exit(NULL);

    return NULL;
}

void initIface(void)
{
    pthread_t iface_thread;
    static int portno; /* must be static, accessed in other thread */
    
    feederLog(LOG_DEBUG, "Creating iface thread\n");
        
    portno = 4242; //todo: port sebrat z conf filu
	pthread_create(&iface_thread, NULL, ifaceThread, &portno);
    pthread_detach(iface_thread);
}

int main(int argc, char * argv[])
{
	int (* close_fn)(void *, int);
	int (* open_fn)(void *, int);

	int sock_client, fd;
	fd_set fds, fds_test;
//	struct sockaddr_in cli_addr;
//	unsigned int cli_len;
	int res;

	unsigned char data[32768];
	int length;
	
	struct type_t * type;
	struct csock_t * csock;
	
	int daemonmode = 0;
	pid_t dpid;
//	char buffer[16384];
	
	unsigned char reply_data[1024];
	int reply_len;
	
	unsigned int i;
	
	/*! \brief Type branch
	 * lib Libary name to parse this type of device
	 * port Port number to open for this devie type
	 * proto Protokol on which device communicates - can be PROTO_UDP, PROTO_TCP_PAS, PROTO_TCP_ACT
	 * server Server name - valid only for PROTO_TCP_ACT devices.
	 * timeout How often grab data - valid only for PROTO_TCP_ACT devices.
	 */
	cfg_opt_t type_opts[] =
	{
	    CFG_STR((char *)"lib", 0, CFGF_NONE),
	    CFG_INT((char *)"port", 0, CFGF_NONE),
	    CFG_STR((char *)"proto", 0, CFGF_NONE),
	    CFG_STR((char *)"server", 0, CFGF_NONE),
	    CFG_INT((char *)"timeout", 0, CFGF_NONE),
	    CFG_STR_LIST((char *)"devid", 0, CFGF_NONE),
	    CFG_STR((char *)"user", 0, CFGF_NONE),
	    CFG_STR((char *)"pass", 0, CFGF_NONE),
	    CFG_END()
	};
	
	/*! \brief Database branch
	 * server Server address - can be ip numbers or url
	 * port Network port on which database feeder is accepting connections
	 * uri Location of database feeder on the server - part after '/'
	 * timezone Timezone of the database server
	 */
	cfg_opt_t db_opts[] =
	{
	    CFG_STR((char *)"server", 0, CFGF_NONE),
	    CFG_INT((char *)"port", 0, CFGF_NONE),
	    CFG_STR((char *)"uri", 0, CFGF_NONE),
	    CFG_STR((char *)"timezone", 0, CFGF_NONE),
	    CFG_INT((char *)"max_msg", 0, CFGF_NONE),
	    CFG_END()
	};

	/*! \brief Options root
	 * db_opts Database branch
	 * type_opts Type branch
	 * logfile Name of of to log into with full path
	 * serverdelay Delay between each try to insert data into database in seconds*/
	cfg_opt_t cfg_opts[] = 
	{
	    CFG_SEC((char *)"db", db_opts, CFGF_MULTI | CFGF_TITLE),
	    CFG_SEC((char *)"type", type_opts, CFGF_MULTI | CFGF_TITLE),
	    CFG_STR((char *)"logfile", 0, CFGF_NONE),
	    CFG_INT((char *)"loglevel", 7, CFGF_NONE),
	    CFG_INT((char *)"serverdelay", 0, CFGF_NONE),
	    CFG_END()
	};
	
	cfg = cfg_init(cfg_opts, CFGF_NONE);
	if (cfg_parse(cfg, "feeder.conf") != CFG_SUCCESS)
	{
	    return 1;
	}

	feederLog(LOG_INFO, "Mort receiver started\n");
	
//	signal(SIGINT, sigFn);//*
		
	if ((argc > 1) && (strcmp(argv[1], "-d") == 0))
    	    daemonmode = 1;

	if (daemonmode)
	{
    	    dpid = fork();
	    switch (dpid)
    	    {
        	case -1:
            	    feederLog(LOG_ERR, "Daemon mode failed! Terminating\n");
            	    return 1;
        	case 0:
            	    feederLog(LOG_INFO, "Daemon running!\n");
            	    break;
        	default:
            	    feederLog(LOG_INFO, "Daemon launched with PID: %i\n", dpid);
            	    return 0;
    	    }
	}

	for (i = 0; i < cfg_size(cfg, "db"); i++)
	{
	    cfg_t * cfg_db = cfg_getnsec(cfg, "db", i);
	    feederLog(LOG_INFO, "Database is on %s, port %d\n", cfg_getstr(cfg_db, "server"), cfg_getint(cfg_db, "port"));
	    
	}
	
//!	mysql_init(&mysql);	//todo: check
	initTypes();
	initFds(&fds);	
	initTimer();
	initServers();
//	initIface();

//	translate(data_test, sizeof(data_test), types, reply_data, &reply_len);
//	translate(0,data_test_acm4, sizeof(data_test_acm4), types, reply_data, &reply_len);
//	translate(data_test_acm4_2, sizeof(data_test_acm4_1), types, reply_data, &reply_len);
//	httpSendPosition(1, 0, 100, 3 ,3 ,3,1);
//	translate(data_test_fm4_1, sizeof(data_test_fm4_1), types, reply_data, &reply_len, 1);
//	translate(data_test_fm4_rfid_on, sizeof(data_test_fm4_rfid_on), types, reply_data, &reply_len, 1);
//	translate(fm4_cihon_west_hemi, sizeof(fm4_cihon_west_hemi), types, reply_data, &reply_len, 1);

// fm4 test prolinani dat - krejza
/*	translate(d1_1, sizeof(d1_1), types, reply_data, &reply_len, 11);
	translate(d2_1, sizeof(d2_1), types, reply_data, &reply_len, 12);
	translate(d1_2, sizeof(d1_2), types, reply_data, &reply_len, 11);
	translate(d2_2, sizeof(d2_2), types, reply_data, &reply_len, 12);
	translate(d1_3, sizeof(d1_3), types, reply_data, &reply_len, 11);*/
//

// sensob test hryzajici se prijimac - trvale vytizeny cpu
/*	translate(lwf0, sizeof(lwf0), types, reply_data, &reply_len, 1);
	translate(lwf1, sizeof(lwf1), types, reply_data, &reply_len, 1);
	translate(lwf2, sizeof(lwf2), types, reply_data, &reply_len, 1);
	translate(lwf3, sizeof(lwf3), types, reply_data, &reply_len, 1);*/
	
//sensob - med data co jsem nzkonfiguroval aby sla do db pri startu
/*	while (1)
	{
	    int k;
    	    translate(sensob_honey1, sizeof(sensob_honey1), types, reply_data, &reply_len, 1);
	    translate(sensob_honey2, sizeof(sensob_honey2), types, reply_data, &reply_len, 1);
	    for (k =0; k<60; k++)
	        sleep(1);
	}
*/	
/*
    	    translate(sensob_honey3, sizeof(sensob_honey3), types, reply_data, &reply_len, 1);
	    translate(sensob_honey4, sizeof(sensob_honey4), types, reply_data, &reply_len, 1);
*/
/*
        translate(sensob_iridium, sizeof(sensob_iridium), types, reply_data, &reply_len, 1);
*/
/*
        translate(sensob_iridium_pow, sizeof(sensob_iridium_pow), types, reply_data, &reply_len, 1);
*/
/*        translate(sensob_iridium_t1, sizeof(sensob_iridium_t1), types, reply_data, &reply_len, 1);
        translate(sensob_iridium_t2, sizeof(sensob_iridium_t2), types, reply_data, &reply_len, 1);
        translate(sensob_iridium_t3, sizeof(sensob_iridium_t3), types, reply_data, &reply_len, 1);
*/
/*
        translate(sensob_iridium_node4, sizeof(sensob_iridium_node4), types, reply_data, &reply_len, 1);
        translate(sensob_iridium_node3, sizeof(sensob_iridium_node3), types, reply_data, &reply_len, 1);
*/
/*        translate(sensob_timestamp, sizeof(sensob_timestamp), types, reply_data, &reply_len, 1);*/
/*
        translate(vhcp, sizeof(vhcp), types, reply_data, &reply_len, 1);
        translate(vhcp_2, sizeof(vhcp_2), types, reply_data, &reply_len, 1);
*/
    
//        translate(fm4_at_badval, sizeof(fm4_at_badval), types, reply_data, &reply_len, 1);
        
//        translate(fm4_at2000, sizeof(fm4_at2000), types, reply_data, &reply_len, 1);
//        translate(wli, sizeof(wli), types, reply_data, &reply_len, 1);

/*
	while (1)
	{
		uint8_t temp[sizeof(rest_1)];
		rest_1[104] += 1;
		if (rest_1[104] > '9')
		    rest_1[104] = '0';
		memcpy(temp, rest_1, sizeof(rest_1));
        	translate(temp, sizeof(rest_1), types, reply_data, &reply_len, 1);
        	sleep(1);
        }
*/        	

//        translate(cra_1, sizeof(cra_1), types, reply_data, &reply_len, 1);
//        translate(cra_2, sizeof(cra_2), types, reply_data, &reply_len, 1);

//        translate(sigfox_4, sizeof(sigfox_4), types, reply_data, &reply_len, 1);

//        translate(cra_minus_one, sizeof(cra_minus_one), types, reply_data, &reply_len, 1);


//        translate(tiny, sizeof(tiny), types, reply_data, &reply_len, 1);
        
	while (1)
	{
		fds_test = fds;

		res = select(FD_SETSIZE, &fds_test, (fd_set *)0, (fd_set *)0, (struct timeval *)0);
		if (res < 0)
		{
		    switch (errno)
		    {
			case EINTR:
			break;
			case EBADF:
			        feederLog(LOG_ERR, "Handled error %d on socket select\n", errno);
				initFds(&fds);			//Sensob on luigis devices  sometimes (very stochastic) does not remove socket from fds -> this leads to loop in eslect with -EBADF -> total hang of feeder
				sleep(2);			//Not fill log
			break;
			default:
				feederLog(LOG_ERR, "Unhandled error %d on socket select\n", errno);
				initFds(&fds);			//Sensob on luigis devices  sometimes (very stochastic) does not remove socket from fds -> this leads to loop in eslect with -EBADF -> total hang of feeder
				sleep(2);			//Not fill log
			break;
		    }
		    continue;
		}
		for (fd = 0; fd < FD_SETSIZE; fd++)
		{
			if (FD_ISSET(fd, &fds_test))
			{
				feederLog(LOG_DEBUG, "Socket activity - socket %d\n", fd);
				type = findType(fd);
				if (type != NULL)
				{
				    if (type->proto == PROTO_TCP_PAS)
				    {
					cli_len = sizeof(cli_addr);
					sock_client = accept(type->socket, (struct sockaddr *)&cli_addr, &cli_len);
/*					
					int buf_size = 1024*1024;
					setsockopt(sock_client, SOL_SOCKET, SO_RCVBUF, &buf_size, sizeof(buf_size));
*/					
					csock = addClient(type, sock_client);
					if (csock != NULL)
					{
					    FD_SET(sock_client, &fds);
					
					    open_fn = (int(*)(void *, int))dlsym(findTypeClientTcp(sock_client)->dl, "open");//*
//						open_fn = dlsym(findType(fd)->dl, "open");
					    feederLog(LOG_DEBUG, "Session opened - socket %d\n", sock_client);

					    if (open_fn != NULL)
					    {
						open_fn(csock->lib_data, sock_client);
					    }
					}
				    }
				    if (type->proto == PROTO_UDP)
				    {
					cli_len = sizeof(cli_addr);
					length = recvfrom(fd, data, 2048, 0, (struct sockaddr *)&cli_addr, &cli_len);
					if (length > 0)
					{
					    feederLog(LOG_DEBUG, "Incoming data: len %d: ", length);
					    logHex(data, length);
					    //feederLog(LOG_DEBUG, "%s\n", buffer);
					    
//					    dataFailTest(data, length);	//todo:zakomentovat, tohle testuje co se stane kdyz se data zblbnou
					    
					    translate(data, length, findTypeClientUdp(fd), reply_data, &reply_len, fd);
					    if (reply_len > 0)
					    {
						sendto(fd, reply_data, reply_len, 0, (struct sockaddr *)&cli_addr, cli_len);
						feederLog(LOG_DEBUG, "Outgoing data: len %d: ", reply_len);
						logHex(reply_data, reply_len);
						//feederLog(LOG_DEBUG, "%s\n", buffer);
					    }
					    
					}
				    }
				}
				else
				{
					ioctl(fd, FIONREAD, &length);
					if (length == 0)
					{
						feederLog(LOG_DEBUG, "Session closed - socket %d\n", fd);
						
						type = findTypeClientTcp(fd);
						close_fn = (int(*)(void *, int))dlsym(type->dl, "close");//*
						if (close_fn != NULL)
						{
						    close_fn(findSockClientTcp(type, fd)->lib_data, fd);
						}
						remClient(type, fd);
						
						shutdown(fd, SHUT_RDWR);		//todo: overit funkcnost - toto by melo zajisiti ze close skutecne probehne, jinak nam totiz reference count drzi serverovy thready na 0 (asi)
						close(fd);
						FD_CLR(fd, &fds);
					}
					else if (length > 0)
					{
						feederLog(LOG_DEBUG, "Incoming data: len %d\n", length);
					
						length = read(fd, data, length);
						data[length] = 0;
						logHex(data, length);
						
						type = findTypeClientTcp(fd);
						csock = findSockClientTcp(type, fd);
						memcpy(csock->buf_data + csock->buf_data_len, data, length);
						csock->buf_data_len += length;
						
//						feederLog(LOG_DEBUG, "\n");
						//feederLog(LOG_DEBUG, "%s\n", buffer);
						
//						translate(data, length, findTypeClientTcp(fd), reply_data, &reply_len, fd);
						ioctl(fd, FIONREAD, &length);
						if (length == 0)
						{
						    translate(csock->buf_data, csock->buf_data_len, findTypeClientTcp(fd), reply_data, &reply_len, fd);
						    csock->buf_data_len = 0;
						}

						if (reply_len > 0)
						{
						    write(fd, reply_data, reply_len);
						    feederLog(LOG_DEBUG, "Outgoing data: len %d: ", reply_len);
						    logHex(reply_data, reply_len);
						    //feederLog(LOG_DEBUG, "%s\n", buffer);
						}
						if (reply_len < 0)
						{
						    feederLog(LOG_DEBUG, "Forcing session close\n");
						
						    close(fd);
						    FD_CLR(fd, &fds);
						
						    type = findTypeClientTcp(fd);
						    close_fn = (int(*)(void *, int))dlsym(type->dl, "close");
						    if (close_fn != NULL)
						    {
							close_fn(findSockClientTcp(type, fd)->lib_data, fd);
						    }
						    remClient(type, fd);
						}
					}
				}
			}
		}
	}

	return EXIT_SUCCESS;
}