#if 0
	shc Version 3.8.9, Generic Script Compiler
	Copyright (c) 1994-2012 Francisco Rosales <frosal@fi.upm.es>

	./shc -v -f match 
#endif

static  char data [] = 
#define      tst2_z	19
#define      tst2	((&data[0]))
	"\247\272\166\265\272\025\173\041\221\126\056\243\376\175\216\362"
	"\326\116\323\314\122\173"
#define      lsto_z	1
#define      lsto	((&data[22]))
	"\060"
#define      msg2_z	19
#define      msg2	((&data[23]))
	"\235\243\124\137\236\300\223\354\212\157\026\145\114\070\307\172"
	"\305\226\346\211\223\256"
#define      opts_z	1
#define      opts	((&data[45]))
	"\316"
#define      rlax_z	1
#define      rlax	((&data[46]))
	"\020"
#define      tst1_z	22
#define      tst1	((&data[52]))
	"\076\070\165\033\212\035\250\121\174\026\117\152\271\311\040\303"
	"\031\025\100\107\054\333\275\270\000\050\212\032"
#define      text_z	337
#define      text	((&data[113]))
	"\165\100\232\360\257\246\047\112\302\301\324\125\160\221\102\255"
	"\112\151\213\274\123\307\372\214\074\026\026\127\310\212\236\075"
	"\312\070\056\171\337\125\135\260\001\154\244\026\071\275\005\252"
	"\055\052\047\030\113\271\046\161\112\233\275\255\035\263\362\064"
	"\140\364\125\372\251\263\123\314\275\372\002\215\355\232\044\107"
	"\235\066\000\114\235\133\142\113\102\166\007\012\361\071\234\356"
	"\016\360\244\075\153\175\337\043\130\344\152\322\134\014\307\044"
	"\225\077\216\264\253\041\115\064\223\117\101\037\005\207\240\145"
	"\100\335\015\377\233\232\204\307\341\201\070\010\314\214\210\357"
	"\206\164\215\066\076\255\263\213\236\376\345\077\260\260\123\106"
	"\135\376\230\232\151\276\145\013\242\102\372\175\330\272\267\117"
	"\301\316\265\164\375\366\331\364\360\375\073\352\045\022\274\147"
	"\002\146\226\022\264\314\374\310\325\244\125\205\264\247\210\002"
	"\332\142\170\310\160\013\114\214\376\301\016\227\031\172\166\357"
	"\171\057\376\154\002\333\272\023\244\227\167\017\160\201\155\043"
	"\320\374\272\073\367\315\304\357\101\221\254\242\052\152\267\343"
	"\000\304\161\370\341\067\141\010\376\263\324\342\052\213\064\163"
	"\146\166\002\077\013\167\371\202\367\242\375\247\206\372\037\137"
	"\141\006\075\036\261\103\113\033\021\167\120\176\134\213\314\270"
	"\205\206\001\313\272\262\046\016\117\306\056\103\146\052\043\307"
	"\204\243\324\300\355\144\325\175\351\134\217\134\323\240\011\311"
	"\165\016\242\077\126\044\121\071\271\252\232\072\216\067\107\173"
	"\120\064\227\352\253\207\125\333\347\151\270\071\313\352\025\360"
	"\335\302\041\056\171\230\060\304\241\027\231\367\207\053\071\065"
	"\165\243\300\061\367\210\054\203\305\102\232\034\013\044"
#define      chk2_z	19
#define      chk2	((&data[474]))
	"\364\270\335\372\330\134\142\277\351\116\160\141\030\074\004\246"
	"\161\135\312\333\166\151\323\314"
#define      date_z	1
#define      date	((&data[497]))
	"\052"
#define      pswd_z	256
#define      pswd	((&data[525]))
	"\362\246\237\147\112\140\231\101\350\306\305\255\011\137\312\024"
	"\204\205\135\163\171\323\334\115\240\012\302\154\227\243\047\260"
	"\022\136\020\275\131\253\064\102\253\060\246\015\376\102\033\015"
	"\103\310\052\327\035\257\126\262\010\074\036\240\337\105\120\361"
	"\244\140\257\375\014\344\100\267\024\346\304\022\051\340\040\154"
	"\251\113\103\306\372\232\170\003\326\227\243\265\335\364\247\201"
	"\124\127\177\141\073\277\030\117\246\335\142\317\275\203\074\146"
	"\316\200\055\310\032\246\313\360\075\157\246\033\143\116\234\270"
	"\245\033\031\340\333\062\060\201\017\222\121\315\025\215\064\344"
	"\015\142\255\047\010\170\030\106\350\277\141\113\015\376\003\262"
	"\031\034\222\365\117\302\166\137\125\307\055\152\125\141\117\142"
	"\304\374\212\314\165\242\022\135\141\164\250\156\162\254\041\213"
	"\311\263\200\030\165\367\167\312\277\245\065\024\007\205\167\313"
	"\201\001\227\367\244\252\124\006\036\375\165\220\251\226\034\162"
	"\111\235\213\277\224\003\212\124\250\300\151\257\105\340\172\307"
	"\342\022\276\206\274\022\215\333\020\002\153\271\230\210\054\342"
	"\045\270\242\272\273\055\016\144\355\170\023\063\130\216\373\073"
	"\241\271\301\135\314\117\071\334\121\245\226\203\321\057\356\303"
	"\326\216\053\041\356\305\142\327\213\050\205\224\210\117\250\014"
	"\325\005\200\117\331\134"
#define      msg1_z	42
#define      msg1	((&data[813]))
	"\137\374\070\217\353\107\272\237\072\243\361\230\105\157\210\200"
	"\154\232\350\230\203\006\077\203\335\353\350\002\075\032\130\252"
	"\124\025\043\272\356\037\025\346\105\021\040\140\305\124\341\374"
	"\146\171\050"
#define      chk1_z	22
#define      chk1	((&data[861]))
	"\352\077\141\276\337\350\121\230\247\364\146\270\022\277\376\005"
	"\326\363\253\111\122\123\323\027\170\022\304\014\233"
#define      shll_z	8
#define      shll	((&data[890]))
	"\352\272\065\106\153\342\276\225\173\055\050"
#define      inlo_z	3
#define      inlo	((&data[899]))
	"\366\174\123"
#define      xecc_z	15
#define      xecc	((&data[902]))
	"\053\134\233\245\225\077\042\104\216\201\331\127\234\320\256\066"
	"\013\044"/* End of data[] */;
#define      hide_z	4096
#define DEBUGEXEC	0	/* Define as 1 to debug execvp calls */
#define TRACEABLE	0	/* Define as 1 to enable ptrace the executable */

/* rtc.c */

#include <sys/stat.h>
#include <sys/types.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

/* 'Alleged RC4' */

static unsigned char stte[256], indx, jndx, kndx;

/*
 * Reset arc4 stte. 
 */
void stte_0(void)
{
	indx = jndx = kndx = 0;
	do {
		stte[indx] = indx;
	} while (++indx);
}

/*
 * Set key. Can be used more than once. 
 */
void key(void * str, int len)
{
	unsigned char tmp, * ptr = (unsigned char *)str;
	while (len > 0) {
		do {
			tmp = stte[indx];
			kndx += tmp;
			kndx += ptr[(int)indx % len];
			stte[indx] = stte[kndx];
			stte[kndx] = tmp;
		} while (++indx);
		ptr += 256;
		len -= 256;
	}
}

/*
 * Crypt data. 
 */
void arc4(void * str, int len)
{
	unsigned char tmp, * ptr = (unsigned char *)str;
	while (len > 0) {
		indx++;
		tmp = stte[indx];
		jndx += tmp;
		stte[indx] = stte[jndx];
		stte[jndx] = tmp;
		tmp += stte[indx];
		*ptr ^= stte[tmp];
		ptr++;
		len--;
	}
}

/* End of ARC4 */

/*
 * Key with file invariants. 
 */
int key_with_file(char * file)
{
	struct stat statf[1];
	struct stat control[1];

	if (stat(file, statf) < 0)
		return -1;

	/* Turn on stable fields */
	memset(control, 0, sizeof(control));
	control->st_ino = statf->st_ino;
	control->st_dev = statf->st_dev;
	control->st_rdev = statf->st_rdev;
	control->st_uid = statf->st_uid;
	control->st_gid = statf->st_gid;
	control->st_size = statf->st_size;
	control->st_mtime = statf->st_mtime;
	control->st_ctime = statf->st_ctime;
	key(control, sizeof(control));
	return 0;
}

#if DEBUGEXEC
void debugexec(char * sh11, int argc, char ** argv)
{
	int i;
	fprintf(stderr, "shll=%s\n", sh11 ? sh11 : "<null>");
	fprintf(stderr, "argc=%d\n", argc);
	if (!argv) {
		fprintf(stderr, "argv=<null>\n");
	} else { 
		for (i = 0; i <= argc ; i++)
			fprintf(stderr, "argv[%d]=%.60s\n", i, argv[i] ? argv[i] : "<null>");
	}
}
#endif /* DEBUGEXEC */

void rmarg(char ** argv, char * arg)
{
	for (; argv && *argv && *argv != arg; argv++);
	for (; argv && *argv; argv++)
		*argv = argv[1];
}

int chkenv(int argc)
{
	char buff[512];
	unsigned long mask, m;
	int l, a, c;
	char * string;
	extern char ** environ;

	mask  = (unsigned long)&chkenv;
	mask ^= (unsigned long)getpid() * ~mask;
	sprintf(buff, "x%lx", mask);
	string = getenv(buff);
#if DEBUGEXEC
	fprintf(stderr, "getenv(%s)=%s\n", buff, string ? string : "<null>");
#endif
	l = strlen(buff);
	if (!string) {
		/* 1st */
		sprintf(&buff[l], "=%lu %d", mask, argc);
		putenv(strdup(buff));
		return 0;
	}
	c = sscanf(string, "%lu %d%c", &m, &a, buff);
	if (c == 2 && m == mask) {
		/* 3rd */
		rmarg(environ, &string[-l - 1]);
		return 1 + (argc - a);
	}
	return -1;
}

#if !TRACEABLE

#define _LINUX_SOURCE_COMPAT
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

#if !defined(PTRACE_ATTACH) && defined(PT_ATTACH)
#	define PTRACE_ATTACH	PT_ATTACH
#endif
void untraceable(char * argv0)
{
	char proc[80];
	int pid, mine;

	switch(pid = fork()) {
	case  0:
		pid = getppid();
		/* For problematic SunOS ptrace */
#if defined(__FreeBSD__)
		sprintf(proc, "/proc/%d/mem", (int)pid);
#else
		sprintf(proc, "/proc/%d/as",  (int)pid);
#endif
		close(0);
		mine = !open(proc, O_RDWR|O_EXCL);
		if (!mine && errno != EBUSY)
			mine = !ptrace(PTRACE_ATTACH, pid, 0, 0);
		if (mine) {
			kill(pid, SIGCONT);
		} else {
			perror(argv0);
			kill(pid, SIGKILL);
		}
		_exit(mine);
	case -1:
		break;
	default:
		if (pid == waitpid(pid, 0, 0))
			return;
	}
	perror(argv0);
	_exit(1);
}
#endif /* !TRACEABLE */

char * xsh(int argc, char ** argv)
{
	char * scrpt;
	int ret, i, j;
	char ** varg;
	char * me = getenv("_");
	if (me == NULL) { me = argv[0]; }

	stte_0();
	 key(pswd, pswd_z);
	arc4(msg1, msg1_z);
	arc4(date, date_z);
	if (date[0] && (atoll(date)<time(NULL)))
		return msg1;
	arc4(shll, shll_z);
	arc4(inlo, inlo_z);
	arc4(xecc, xecc_z);
	arc4(lsto, lsto_z);
	arc4(tst1, tst1_z);
	 key(tst1, tst1_z);
	arc4(chk1, chk1_z);
	if ((chk1_z != tst1_z) || memcmp(tst1, chk1, tst1_z))
		return tst1;
	ret = chkenv(argc);
	arc4(msg2, msg2_z);
	if (ret < 0)
		return msg2;
	varg = (char **)calloc(argc + 10, sizeof(char *));
	if (!varg)
		return 0;
	if (ret) {
		arc4(rlax, rlax_z);
		if (!rlax[0] && key_with_file(shll))
			return shll;
		arc4(opts, opts_z);
		arc4(text, text_z);
		arc4(tst2, tst2_z);
		 key(tst2, tst2_z);
		arc4(chk2, chk2_z);
		if ((chk2_z != tst2_z) || memcmp(tst2, chk2, tst2_z))
			return tst2;
		/* Prepend hide_z spaces to script text to hide it. */
		scrpt = malloc(hide_z + text_z);
		if (!scrpt)
			return 0;
		memset(scrpt, (int) ' ', hide_z);
		memcpy(&scrpt[hide_z], text, text_z);
	} else {			/* Reexecute */
		if (*xecc) {
			scrpt = malloc(512);
			if (!scrpt)
				return 0;
			sprintf(scrpt, xecc, me);
		} else {
			scrpt = me;
		}
	}
	j = 0;
	varg[j++] = argv[0];		/* My own name at execution */
	if (ret && *opts)
		varg[j++] = opts;	/* Options on 1st line of code */
	if (*inlo)
		varg[j++] = inlo;	/* Option introducing inline code */
	varg[j++] = scrpt;		/* The script itself */
	if (*lsto)
		varg[j++] = lsto;	/* Option meaning last option */
	i = (ret > 1) ? ret : 0;	/* Args numbering correction */
	while (i < argc)
		varg[j++] = argv[i++];	/* Main run-time arguments */
	varg[j] = 0;			/* NULL terminated array */
#if DEBUGEXEC
	debugexec(shll, j, varg);
#endif
	execvp(shll, varg);
	return shll;
}

int main(int argc, char ** argv)
{
#if DEBUGEXEC
	debugexec("main", argc, argv);
#endif
#if !TRACEABLE
	untraceable(argv[0]);
#endif
	argv[1] = xsh(argc, argv);
	fprintf(stderr, "%s%s%s: %s\n", argv[0],
		errno ? ": " : "",
		errno ? strerror(errno) : "",
		argv[1] ? argv[1] : "<null>"
	);
	return 1;
}