initial

78 files changed, 16624 insertions, 0 deletions

diff --git a/other/burneye/src/BANNER b/other/burneye/src/BANNER
new file mode 100644
index 0000000..5a88210
--- /dev/null
+++ b/other/burneye/src/BANNER
@@ -0,0 +1,12 @@
+/***                                                       ***/
+/*** TESO CONFIDENTIAL - BINARY EXECUTEABLE                ***/
+/***                                                       ***/
+/*** This is unpublished proprietary code of TESO Security ***/
+/***                                                       ***/
+/*** The contents of these coded  instructions, statements ***/
+/*** and computer  programs may not be  disclosed to third ***/
+/*** parties, copied or  duplicated in any  form, in whole ***/
+/*** or in part,  without the prior written  permission of ***/
+/*** TESO Security.                                        ***/
+/***                                                       ***/
+
diff --git a/other/burneye/src/BANNER-BURNEYE b/other/burneye/src/BANNER-BURNEYE
new file mode 100644
index 0000000..6b1b45f
--- /dev/null
+++ b/other/burneye/src/BANNER-BURNEYE
@@ -0,0 +1,16 @@
+***
+*** WARNING
+***
+*** This is program does not guarantee any functionality and may break your
+*** entire system. Do not use it for malicious purposes, but to protect your
+*** stuff from malicious people. Also, please be aware that in the
+*** non-passworded or non-fingerprinted mode (you can combine both for extra
+*** security) any serious reverse engineer is able to unwrap the binary in
+*** minutes. In the passworded binary however, it is hardly possible if the
+*** password is not known. Rule of thumb: if the binary runs, it can be broken.
+*** The binding is still very weak between the encryption engine and the
+*** binary, so unwrapping is possible.
+***
+*** If you have understood the above limitations, enter 'accept' now.
+***
+
diff --git a/other/burneye/src/Makefile b/other/burneye/src/Makefile
new file mode 100644
index 0000000..55cf561
--- /dev/null
+++ b/other/burneye/src/Makefile
@@ -0,0 +1,116 @@
+
+ifeq ($(debug),on)
+CFLAGS += -g -ggdb
+DFLAGS += -DDEBUG -DVDEBUG
+MPASS += debug=on
+endif
+
+CFLAGS += -Wall $(DFLAGS)
+
+CC=gcc
+OBJS =  common.o \
+        cipher-glfsr.o cipher-rc4.o cipher-sha1.o fingerprint.o rs.o
+
+# basic targets
+#
+
+all:    debug fingerprint stub/stub.bin burneye.c $(OBJS)
+        $(CC) $(CFLAGS) -o burneye burneye.c $(OBJS)
+
+harddist:       clean stub/stub.bin burneye.c $(OBJS)
+        diet $(CC) -DSTANDALONE $(CFLAGS) -o fingerprint -static \
+                stub/fingerprint.c rs.o cipher-sha1.o
+        strip fingerprint
+        stub/utils/sstrip fingerprint
+
+        diet $(CC) $(CFLAGS) -o burneye burneye.c -static $(OBJS)
+        strip burneye
+        stub/utils/sstrip burneye
+
+        ./burneye fingerprint
+        mv output fingerprint
+        chmod 700 fingerprint
+        readelf -l fingerprint
+
+        # burneye itself should be the last binary, for that it will
+        # modify itself
+        ./burneye -B BANNER-BURNEYE -p accept burneye
+        mv output burneye
+        chmod 700 burneye
+        readelf -l burneye
+
+
+# release=release-string should be set ;)
+release:        clean harddist
+        mkdir ../dist/burneye-$(release)/
+        cp burneye fingerprint ../dist/burneye-$(release)/
+        cp ../doc/DIST-README ../dist/burneye-$(release)/README
+        chmod 600 ../dist/burneye-$(release)/README
+        chmod 700 ../dist/burneye-$(release)/burneye \
+                ../dist/burneye-$(release)/fingerprint
+
+# clean targets
+#
+
+clean:
+        rm -f debug/memdump
+        rm -f *.o burneye
+        rm -f fingerprint
+        rm -f rstest
+        rm -f output date.eye
+        make -C stub clean
+
+
+# debug targets
+#
+
+debug:  debug/memdump
+
+debug/memdump:  debug/memdump.c
+        $(CC) $(CFLAGS) -o debug/memdump debug/memdump.c
+
+regress:        regress-clean all date.eye regress.sh
+        ./regress.sh
+
+regress-clean:  clean
+        rm -f date.eye
+        rm -f date.*.0x* date.*.regs
+
+date.eye:       date all
+        ./burneye date
+        mv output date.eye
+        chmod 700 date.eye
+
+
+# sub object-targets
+#
+
+cipher-glfsr.o: stub/cipher-glfsr.asm
+        nasm $(DFLAGS) -f elf -o cipher-glfsr.o stub/cipher-glfsr.asm
+
+cipher-rc4.o:   stub/cipher-rc4.c
+        $(CC) $(CFLAGS) -c stub/cipher-rc4.c -o cipher-rc4.o
+
+cipher-sha1.o:  stub/cipher-sha1.c
+        $(CC) $(CFLAGS) -c stub/cipher-sha1.c -o cipher-sha1.o
+
+fingerprint.o:  stub/fingerprint.c
+        $(CC) $(CFLAGS) -c stub/fingerprint.c -o fingerprint.o
+
+rs.o:   stub/rs.c
+        $(CC) $(CFLAGS) -c stub/rs.c -o rs.o
+
+stub/stub.bin:
+        make -C stub rel=on $(MPASS) clean all
+
+
+# testing tool targets
+#
+
+fingerprint:    stub/fingerprint.c cipher-sha1.o rs.o
+        $(CC) -DSTANDALONE $(CFLAGS) -o fingerprint \
+                stub/fingerprint.c rs.o cipher-sha1.o
+
+rstest: rstest.c rs.o
+        $(CC) $(CFLAGS) -o rstest rstest.c rs.o
+
diff --git a/other/burneye/src/burneye.c b/other/burneye/src/burneye.c
new file mode 100644
index 0000000..bfef2e7
--- /dev/null
+++ b/other/burneye/src/burneye.c
@@ -0,0 +1,968 @@
+/* burneye - main wrapping functions
+ */
+
+#define VERSION "1.0.1"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <elf.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>             /* getopt */
+#include "stub/stubhdr.h"
+#include "stub/cipher-rc4.h"
+#include "stub/cipher-sha1.h"
+#include "stub/cipher-glfsr.h"
+#include "stub/fingerprint.h"
+
+
+/* prototypes
+ */
+void usage (char *progname);
+
+void wrap (char *program, unsigned char *stub_data,
+        unsigned long int stub_len);
+
+unsigned long int getmaxbrk (unsigned char *elf);
+
+unsigned char * file_read (char *pathname);
+
+void prepare_fingerprint (fp_fin *f);
+void read_fingerprint (fp_s *fp, char *pathname);
+
+
+/*** global variables
+ */
+unsigned long int       entry_vaddr = 0;
+unsigned long int       enc_start = 0;
+unsigned long int       entry_next = 0;
+
+/* file to pull randomness from */
+#define RANDOM_DEV      "/dev/urandom"
+FILE *                  frandom = NULL;
+
+
+char *                  inputname = NULL;
+
+
+/* output file options
+ */
+char *                  outputname = "output";
+
+unsigned char *         unlink_env = NULL;
+
+stubhdr *               shdr;
+int                     pw_enc = 0;     /* do password encryption */
+char *                  pw_pass = NULL; /* password used */
+char *                  pw_env = NULL;  /* environment variable with pass */
+int                     pw_check = 1;   /* check for correct decryption */
+
+unsigned char *         banner = NULL;  /* points to banner string or NULL */
+int                     banner_tty = 0; /* show it on tty */
+
+int                     do_fp = 0;              /* do fingerprinting */
+int                     do_seal = 0;            /* SEAL mode flag */
+int                     fp_len = 0;
+int                     fp_check = 1;
+int                     fp_fromhost = 0;        /* use current host for fp */
+unsigned long int       fp_tests = FP_TEMPLATE; /* tests to do on -F */
+char *                  fp_name = NULL;         /* filename of fp file */
+FILE *                  fp_in = NULL;           /* stream pointer */
+int                     fp_tolerance = 0;       /* tolerance or zero */
+int                     fp_WARN = 1;            /* erasure warning */
+fp_fin                  fp;                     /* fingerprint structure */
+
+int             tag_used = 0;           /* whether a tag is present */
+unsigned char   tag_env[16];            /* tag environment variable */
+unsigned char   tag_key[16];            /* tag key (not stored in bin) */
+unsigned char   tag_value[64];          /* tag value/string */
+
+
+#define FILE_OFFSET(addr) (((unsigned char *)(addr)) - stub_data)
+#define SEAL_STORE(to,addr) { \
+        if (do_seal) { (to) = (unsigned long int) (FILE_OFFSET(addr)); } \
+}
+
+
+/* real stub included here, this is no common include, but a one-time include
+ * it defines some very important values, which can be overwritten by .be
+ * definition files though (TODO: not yet implemented, of course ;)
+ */
+#include "stub/stub-bin.h"
+
+unsigned long int       be_layer0_start = BE_LAYER0_START;
+unsigned long int       be_layer0_size = BE_LAYER0_SIZE;
+unsigned long int       be_layer0_cont = BE_LAYER0_CONT;
+
+
+void
+usage (char *progname)
+{
+        fprintf (stderr, "usage: %s [options] <program>\n\n", progname);
+
+        fprintf (stderr,
+                "banner options\n"
+                "\t-b file\t\tdisplay banner from 'file' before start\n"
+                "\t-B file\t\tdisplay banner from 'file' on tty before start\n"
+                "\n"
+                "password protect options\n"
+                "\t-p pass\t\tuse password encryption with 'pass' as password\n"
+                "\t-P env\t\tfirst try to read password from environment 'env',\n"
+                "\t\t\twill use password from 'env' now, too, if its there\n"
+                "\t-i\t\tignore invalid entered password and execute junk\n"
+                "\t\t\tnot recommended (default: off)\n"
+                "\n"
+                "fingerprinting options\n"
+                "\t-S\t\tSEAL mode (options F,f,t are ignored)\n"
+                "\t-f file\t\tuse fingerprint from 'file' to protect binary\n"
+                "\t-F\t\tuse fingerprint of current host (do not use -f and -F)\n"
+                "\t-t num\t\ttolerate 'num' deviations in fingerprint\n"
+                "\t-q\t\tbe quiet about wrong fingerprint, just exit\n"
+                "\t\t\t(default: 0)\n"
+                "\t-E\t\tdo tolerance even if erasure warning is given\n"
+                "\t-l\t\tlist fingerprint tests that can be done\n"
+                "\t-e test\t\tenable fingerprint test 'test'\n"
+                "\t-d test\t\tdisable fingerprint test 'test'\n"
+                "\n"
+                "generic options\n"
+                "\t-o out\t\tspecify another output file name (default: output)\n"
+                "\n"
+                "minor features\n"
+                "\t-U env\t\tunlink file securely if 'env' is in the environment\n"
+                "\t-T tag\t\tstore a string as tag to the binary. 'tag' is an\n"
+                "\t\t\tenvironment variable: tag=%%env:%%key:%%string, see README\n"
+                "\n"
+                "example: %s -B aint.for.hack.co.za.txt \\\n"
+                "\t\t-p gov-boi-cant-code -o ls /bin/ls\n"
+                "\n"
+                "  would encrypt /bin/ls to ./ls with password "
+                        "\"gov-boi-cant-code\" and\n"
+                "  displays the content of aint.for.hack.co.za.txt before "
+                        "asking for pass.\n", progname);
+
+        fprintf (stderr, "\n");
+
+        exit (EXIT_FAILURE);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+        char                    c;
+        char *                  progname = argv[0];
+
+        unsigned long int       stub_len;
+        unsigned char *         stub_data;
+
+
+        printf ("burneye - TESO ELF Encryption Engine\n"
+                "version "VERSION"\n"
+                "------------------------------------------------------------"
+                "-------------------\n\n");
+
+        if (argc < 2)
+                usage (progname);
+
+        while ((c = getopt (argc, argv, "T:B:b:p:P:iSf:Ft:qEle:d:o:U:")) != EOF) {
+                switch (c) {
+                /* UNDOCUMENTED TAG OPTION */
+                case 'T':
+                        if (getenv (optarg) != NULL) {
+                                sscanf (getenv (optarg),
+                                        "%15[^:]:%15[^:]:%63s",
+                                        tag_env, tag_key, tag_value);
+                                tag_used = 1;
+                        }
+                        break;
+                case 'B':
+                        banner_tty = 1;
+                        /* FALLTHROUGH */
+                case 'b':
+                        banner = file_read (optarg);
+                        if (banner == NULL) {
+                                fprintf (stderr, "failed to read content "
+                                        "from banner file\n");
+
+                                exit (EXIT_FAILURE);
+                        }
+                        break;
+                case 'p':
+                        pw_enc = 1;
+                        pw_pass = optarg;
+                        break;
+                case 'P':
+                        pw_enc = 1;
+                        pw_env = optarg;
+                        break;
+                case 'i':
+                        pw_check = 0;
+                        break;
+                case 'S':
+                        do_seal = 1;
+                        break;
+                case 'f':
+                        do_fp = 1;
+                        fp_name = optarg;
+                        break;
+                case 'F':
+                        do_fp = 1;
+                        fp_fromhost = 1;
+                        break;
+                case 't':
+                        if (sscanf (optarg, "%d", &fp_tolerance) != 1 ||
+                                fp_tolerance < 0)
+                        {
+                                fprintf (stderr, "invalid tolerance value\n");
+                                exit (EXIT_FAILURE);
+                        }
+                        break;
+                case 'q':
+                        fp_check = 0;
+                        break;
+                case 'E':
+                        fp_WARN = 0;
+                        break;
+                case 'l':
+                        fp_tlist (fp_tests);
+                        exit (EXIT_SUCCESS);
+                        break;
+                case 'e':
+                        fp_tests |= fp_tlookup (optarg);
+                        break;
+                case 'd':
+                        fp_tests &= ~(fp_tlookup (optarg));
+                        break;
+                case 'o':
+                        outputname = optarg;
+                        break;
+                case 'U':
+                        unlink_env = optarg;
+                        break;
+                default:
+                        usage (progname);
+                        break;
+                }
+        }
+
+        inputname = argv[argc - 1];
+        if (inputname[0] == '-')
+                usage (progname);
+
+        if (do_seal) {
+                if (do_fp != 0 || fp_name != NULL || fp_fromhost != 0) {
+                        fprintf (stderr, "SEAL mode overwrote "
+                                "fingerprint options\n");
+                }
+                do_fp = 0;
+                fp_name = NULL;
+                fp_fromhost = 0;
+        }
+
+        if (do_fp && fp_name != NULL && fp_fromhost != 0) {
+                fprintf (stderr, "cannot use both, fingerprint from file and "
+                        "host (multiple fingerprints not impl. yet)\n");
+
+                exit (EXIT_FAILURE);
+        }
+
+        frandom = fopen (RANDOM_DEV, "rb");
+        if (frandom == NULL) {
+                fprintf (stderr, "could not gain access to random device\n");
+                exit (EXIT_FAILURE);
+        }
+
+        if (do_seal || do_fp)
+                memset (&fp, '\x00', sizeof (fp));
+
+        if (do_fp)
+                prepare_fingerprint (&fp);
+
+        if (do_seal) {
+                fp.fp.tests = fp_tests;
+        }
+
+        stub_len = sizeof (stub_bin) - 1;
+        stub_data = malloc (stub_len + SHDR_MAXSIZE);
+        memcpy (stub_data, stub_bin, stub_len);
+
+        printf ("loaded %lu bytes @ 0x%08lx\n",
+                stub_len, (unsigned long int) stub_data);
+
+        if (be_layer0_size == 0) {
+                printf ("doing no entire pre-stub encryption\n");
+        } else {
+                if (stub_len < be_layer0_size) {
+                        fprintf (stderr, "first layer encryption start is "
+                                "greater than stub length\n");
+
+                        exit (EXIT_FAILURE);
+                }
+
+                printf ("doing pre-stub encryption (@ 0x%08lx) from "
+                        "offset 0x%08lx\n", be_layer0_start, be_layer0_size);
+                printf ("next entry point is 0x%08lx\n", be_layer0_cont);
+        }
+
+        wrap (inputname, stub_data, stub_len);
+        free (stub_data);
+
+        fclose (frandom);
+
+        printf ("\n---------------------------------------------------------"
+                "----------------------\n\n");
+
+
+        exit (EXIT_SUCCESS);
+}
+
+
+void
+wrap (char *program, unsigned char *stub_data, unsigned long int stub_len)
+{
+        FILE *                  fexe;
+        unsigned char *         exe_data;
+        unsigned long int       exe_len;
+        Elf32_Ehdr *            ehdr;
+        Elf32_Phdr *            phdr;
+        unsigned long int       maxbrk;
+        unsigned char *         output;
+        unsigned char *         shdr_sub;
+
+        stubhdr_pass            sp_save;
+        fp_fin *                seal;   /* where the SEAL stored */
+
+
+
+        ehdr = (Elf32_Ehdr *) stub_data;
+        phdr = (Elf32_Phdr *) (stub_data + ehdr->e_phoff);
+        if (ehdr->e_phnum != 2) {
+                fprintf (stderr, "stub.bin must have exactly two program "
+                        "headers, aborting.\n");
+                exit (EXIT_FAILURE);
+        }
+        if (ehdr->e_shoff != 0) {
+                fprintf (stderr, "stub.bin contains section headers, "
+                        "aborting.\n");
+                exit (EXIT_FAILURE);
+        }
+        if (phdr[0].p_memsz != phdr[0].p_filesz) {
+                fprintf (stderr, "first segment in stub.bin has diverging "
+                        "file/mem sizes, aborting.\n");
+                exit (EXIT_FAILURE);
+        }
+
+        printf ("end of segment 1: 0x%08lx\n",
+                (unsigned long int) (phdr[0].p_offset + phdr[0].p_memsz));
+
+        if (stub_len != phdr[0].p_offset + phdr[0].p_memsz) {
+                fprintf (stderr, "bogus bytes at the end, i.e. something "
+                        "between segments end and file end.\n");
+                exit (EXIT_FAILURE);
+        }
+
+        fexe = fopen (program, "rb");
+        if (fexe == NULL) {
+                fprintf (stderr, "failed to open %s\n", program);
+                exit (EXIT_FAILURE);
+        }
+
+        fseek (fexe, 0, SEEK_END);
+        exe_len = ftell (fexe);
+        fseek (fexe, 0, SEEK_SET);
+
+        exe_data = malloc (exe_len);
+        if (fread (exe_data, exe_len, 1, fexe) != 1) {
+                fprintf (stderr, "failed to read %s into memory\n", program);
+                exit (EXIT_FAILURE);
+        }
+        fclose (fexe);
+
+
+        /* get maximum brk call we have to enforce. do this before the
+         * executeable is getting encrypted ;)
+         */
+        maxbrk = getmaxbrk (exe_data);
+        printf ("brk(0) to force is 0x%08lx\n", maxbrk);
+
+
+        /* sizeof (unsigned long int), because we have the dummy magic value
+         * in there to detect the stub-running-on-its-own case */
+        stub_len -= sizeof (unsigned long int); /* dummy, be_stubhdr_u */
+        shdr = (stubhdr *) (stub_data + stub_len);
+        shdr->flags = 0x00000000;
+        SEAL_STORE (fp.stubhdr_flags_ofs, &shdr->flags);
+        shdr->payload_len = exe_len;
+
+        shdr_sub = ((unsigned char *) shdr) + sizeof (stubhdr);
+
+
+        /* stubhdr_size contains the minimum size now, any optional/dynamic
+         * data that is following. 'shdr_sub' walks with the header end, so
+         * you can/must add/append to it and move it.
+         */
+
+        if (unlink_env != NULL) {
+                stubhdr_unlink *        su;
+
+                su = (stubhdr_unlink *) shdr_sub;
+                shdr_sub += sizeof (stubhdr_unlink);
+
+                if (strlen (unlink_env) >= sizeof (su->ul_env)) {
+                        fprintf (stderr, "too long unlink environment "
+                                "variable\n");
+
+                        exit (EXIT_FAILURE);
+                }
+
+                memset (su->ul_env, '\0', sizeof (su->ul_env));
+                memcpy (su->ul_env, unlink_env, strlen (unlink_env));
+
+                shdr->flags |= BE_FLAG_UNLINK;
+                fprintf (stderr, "added self deletion on environment "
+                        "variable '%s'\n", unlink_env);
+        }
+
+        if (tag_used) {
+                stubhdr_tag *           st;
+                unsigned int            tw;
+                unsigned char           tag_hash[20];
+                rc4_key                 key_t;
+
+
+                st = (stubhdr_tag *) shdr_sub;
+                shdr_sub += sizeof (stubhdr_tag);
+
+                /* obfuscate the environment variable a bit (strings !)
+                 */
+                for (tw = 0 ; tw < sizeof (tag_env) ; ++tw) {
+                        st->tag_env[tw] = (0xaa + (~tw << (tw % 4))) ^
+                                tag_env[tw];
+                }
+
+                /* encrypt tag value
+                 */
+                SHA1HashLen (tag_key, strlen (tag_key), tag_hash);
+                rc4_prepare_key (tag_hash, sizeof (tag_hash), &key_t);
+                rc4_cipher (tag_value, sizeof (tag_value), &key_t);
+                memcpy (st->tag_value, tag_value, sizeof (tag_value));
+
+                shdr->flags |= BE_FLAG_TAGGED;
+        }
+
+        if (banner != NULL) {
+                stubhdr_banner *        sb;
+
+                if (strlen (banner) >= MAX_BANNER) {
+                        fprintf (stderr, "banner size exceeded.\n");
+                        exit (EXIT_FAILURE);
+                }
+
+                shdr->flags |= BE_FLAG_BANNER;
+                if (banner_tty)
+                        shdr->flags |= BE_FLAG_BANNER_TTY;
+
+                sb = (stubhdr_banner *) shdr_sub;
+                sb->banner_len = strlen (banner);
+
+                shdr_sub += sizeof (stubhdr_banner);
+                memcpy ((unsigned char *) shdr_sub, banner, sb->banner_len);
+                shdr_sub += sb->banner_len;
+        }
+
+        /* do password encryption ? */
+        if (pw_enc) {
+                /* add a random 20 byte block to add some dynamic element, i.e.
+                 * to generate two completely different outputs, even if the
+                 * same input key is used
+                 */
+                unsigned char   xor_hash[20];   /* xor hash */
+                unsigned char   pw_hash[20];    /* real hash */
+                int             key_n;
+                rc4_key         key_r;
+                stubhdr_pass *  sp = &sp_save;
+
+
+                memset (sp, '\x00', sizeof (stubhdr_pass));
+
+                /* if we should check for correct decryption (recommended),
+                 * then hash decrypted data before and store first four bytes
+                 * of hash for verification
+                 */
+                if (pw_check) {
+                        unsigned char   hash[20];
+
+                        SHA1HashLen (exe_data, exe_len, hash);
+                        shdr->flags |= BE_FLAG_PASSWORD_CHECK;
+                        memcpy (sp->pw_check, hash, 4);
+                }
+
+                if (fread (&xor_hash, sizeof (xor_hash), 1, frandom) != 1) {
+                        fprintf (stderr, "seeding xor_hash key failed\n");
+
+                        exit (EXIT_FAILURE);
+                }
+
+                /* add infos to stub header */
+                shdr->flags |= BE_FLAG_PASSWORD;
+                memcpy (sp->pw_xor, xor_hash, sizeof (xor_hash));
+
+                /* password from environment ?
+                 */
+                memset (sp->pw_env, '\0', sizeof (sp->pw_env));
+
+                if (pw_env != NULL) {
+                        /* check if it fits into the structure */
+                        if (strlen (pw_env) >= sizeof (sp->pw_env)) {
+                                fprintf (stderr, "password environment "
+                                        "variable '%s' too long, aborting\n",
+                                        pw_env);
+
+                                exit (EXIT_FAILURE);
+                        }
+
+                        memcpy (sp->pw_env, pw_env, strlen (pw_env) + 1);
+
+                        /* little magic: overwrite currently set password with
+                         * the one in the environment variable, this is what
+                         * you want, usually. really, you want it :)
+                         */
+                        if (getenv (sp->pw_env) != NULL)
+                                pw_pass = getenv (sp->pw_env);
+                }
+
+                if (pw_pass == NULL) {
+                        fprintf (stderr, "you want password encryption, so "
+                                "set a password, jerk!\n");
+
+                        exit (EXIT_FAILURE);
+                }
+
+                /* merge keys and encrypt */
+                /* key = H (H (P) ^ xor_hash) */
+                SHA1HashLen (pw_pass, strlen (pw_pass), pw_hash);
+                for (key_n = 0 ; key_n < sizeof (pw_hash) ; ++key_n)
+                        pw_hash[key_n] ^= xor_hash[key_n];
+                SHA1HashLen (pw_hash, sizeof (pw_hash), pw_hash);
+
+                rc4_prepare_key (pw_hash, sizeof (pw_hash), &key_r);
+                rc4_cipher (exe_data, exe_len, &key_r);
+        }
+
+        /* do fingerprint layer now, password header will follow us
+         */
+        if (do_fp) {
+                int             n;
+                unsigned char   key[20];
+                rc4_key         key_r;
+                fp_fin *        fp_target;      /* where it is stored */
+
+
+                if (fp_check) {
+                        unsigned char   chk_hash[20];
+
+                        shdr->flags |= BE_FLAG_FINGERPRINT_CHK;
+
+                        SHA1HashLen (exe_data, exe_len, chk_hash);
+                        memcpy (fp.fp_check, chk_hash, 4);
+                }
+
+                shdr->flags |= BE_FLAG_FINGERPRINT;
+
+#ifdef DEBUG
+                fprintf (stderr, "  fp: %02x %02x %02x %02x\n",
+                        fp.fp.hash_arr[0], fp.fp.hash_arr[1],
+                        fp.fp.hash_arr[2], fp.fp.hash_arr[3]);
+#endif
+                SHA1HashLen (fp.fp.hash_arr, fp_len, key);
+#ifdef DEBUG
+                fprintf (stderr, "mkey: %02x %02x %02x %02x\n",
+                        key[0], key[1], key[2], key[3]);
+#endif
+
+                for (n = 0 ; n < sizeof (key) ; ++n)
+                        key[n] ^= fp.fp_xor[n];
+
+                SHA1HashLen (key, sizeof (key), key);
+                rc4_prepare_key (key, sizeof (key), &key_r);
+                rc4_cipher (exe_data, exe_len, &key_r);
+
+                /* do the real installation now
+                 */
+                fp_target = (fp_fin *) shdr_sub;
+                memcpy (fp_target, &fp, sizeof (fp_fin));
+                shdr_sub += sizeof (fp_fin);
+
+                if (fp.par_len > 0) {
+                        memcpy (shdr_sub, fp.par_data, fp.par_len);
+                        shdr_sub += fp.par_len;
+                        free (fp_target->par_data);
+                }
+
+                /* now clean data, which was allocated by prepate_fingerprint
+                 */
+                free (fp_target->fp.hash_arr);
+                fp_target->fp.hash_arr = NULL;
+                fp_target->par_data = NULL;
+
+        /* seal and fingerprinting cannot co-exist, for that the seal header
+         * is a fingerprint header which is not activated yet, but will be in
+         * the sealed executeable, where it will become a full fingerprint
+         * header
+         */
+        } else if (do_seal) {
+
+                seal = (fp_fin *) shdr_sub;
+                shdr_sub += sizeof (fp_fin);
+
+                memcpy (seal, &fp, sizeof (fp_fin));
+
+                SEAL_STORE (seal->sealhdr_ofs, seal);
+                seal->be_layer0_filestart = BE_LAYER0_FILESTART;
+                seal->be_layer0_size = BE_LAYER0_SIZE;
+                seal->be_layer0_cont = BE_LAYER0_CONT;
+
+                shdr->flags |= BE_FLAG_SEALNOW;
+        }
+
+        /* we have to write the header in reverse order for decryption
+         */
+        if (pw_enc) {
+                stubhdr_pass *  sp;
+
+                sp = (stubhdr_pass *) shdr_sub;
+                shdr_sub += sizeof (stubhdr_pass);
+
+                memcpy (sp, &sp_save, sizeof (stubhdr_pass));
+        }
+
+        /* XXX: add other layers here
+         */
+
+        /* this is the real final lenght of the stub header, it does not
+         * change from below here
+         */
+        shdr->stubhdr_size = (unsigned char *) shdr_sub -
+                (unsigned char *) shdr;
+
+        /* do not change anything here */
+        stub_len += shdr->stubhdr_size;
+        fprintf (stderr, "XXX: stub_len = 0x%08lx\n", stub_len);
+
+        /* XXX: no further additions to the stub from here, only modifications
+         */
+        if (do_seal) {
+                seal->payload_ofs = stub_len;
+                seal->payload_len = exe_len;
+
+                /* XXX: DEBUG */
+                fprintf (stderr, "exe_data: %02x %02x %02x %02x %02x\n",
+                        exe_data[0], exe_data[1], exe_data[2],
+                        exe_data[3], exe_data[4]);
+        }
+
+        fprintf (stderr, "phdr 1 @ 0x%08lx\n", (unsigned long int) phdr[0].p_vaddr);
+        fprintf (stderr, "phdr 2 @ 0x%08lx\n", (unsigned long int) phdr[1].p_vaddr);
+
+
+        /* fixup program headers */
+        phdr[0].p_filesz -= sizeof (unsigned long int);
+        phdr[0].p_filesz += shdr->stubhdr_size;
+        phdr[0].p_filesz += exe_len;
+
+        phdr[0].p_memsz += exe_len;
+        phdr[0].p_memsz += 0x1000 - (phdr[0].p_memsz % 0x1000);
+
+        /* patch a zero sized second header to fix brk(0) value set by kernel.
+         * make it use the byte directly behind the first header.
+         */
+        phdr[1].p_memsz = phdr[1].p_filesz = 0;
+        phdr[1].p_vaddr = maxbrk;
+        phdr[1].p_paddr = maxbrk;
+        phdr[1].p_offset = phdr[0].p_offset + phdr[0].p_filesz;
+
+
+        /* merge stub and executeable */
+        output = malloc (stub_len + exe_len);
+        memcpy (output, stub_data, stub_len);
+        memcpy (output + stub_len, exe_data, exe_len);
+        free (exe_data);
+
+
+        /* simple outer obfuscation layer */
+        if (be_layer0_size != 0) {
+                unsigned long int *     lp;
+                unsigned long int       chunk_data,
+                                        crypt_len,
+                                        crypt_key;
+
+                /* relative pointer at place where to encrypt */
+                chunk_data = be_layer0_start - phdr[0].p_vaddr +
+                        be_layer0_size;
+
+                /* pointer to store key and length in binary */
+                lp = (unsigned long int *) (be_layer0_start - phdr[0].p_vaddr +
+                        output);
+
+                /* length of data to en/decrypt */
+                crypt_len = phdr[0].p_filesz - chunk_data;
+
+                if (do_seal == 0) {
+                        if (fread (&crypt_key, sizeof (crypt_key), 1, frandom) != 1) {
+                                fprintf (stderr, "seeding crypto key failed\n");
+                                exit (EXIT_FAILURE);
+                        }
+                        printf ("obfuscation layer: key = 0x%08lx\n", crypt_key);
+
+                        glfsr_crypt (output + chunk_data, output + chunk_data,
+                                crypt_len, crypt_key);
+                } else {
+                        crypt_len = crypt_key = 0;
+                }
+
+                *lp++ = crypt_len;
+                *lp++ = crypt_key;
+                *lp++ = be_layer0_cont;
+        }
+
+
+        /* dump new executeable to disk */
+        fexe = fopen (outputname, "wb");
+        if (fwrite (output, stub_len + exe_len, 1, fexe) != 1) {
+                fprintf (stderr, "failed to write %lu output bytes to file 'output'\n",
+                        stub_len + exe_len);
+
+                exit (EXIT_FAILURE);
+        }
+
+        fclose (fexe);
+        chmod (outputname, S_IRUSR | S_IWUSR | S_IXUSR);
+
+        free (output);
+
+        return;
+}
+
+
+unsigned long int
+getmaxbrk (unsigned char *elf)
+{
+        int                     n;
+        unsigned long int       mbrk = 0;
+        Elf32_Ehdr *            ehdr = (Elf32_Ehdr *) elf;
+        Elf32_Phdr *            phdr = (Elf32_Phdr *) (elf + ehdr->e_phoff);
+
+        for (n = 0 ; n < ehdr->e_phnum ; ++n) {
+                if (phdr[n].p_type != PT_LOAD)
+                        continue;
+
+                if ((phdr[n].p_vaddr + phdr[n].p_memsz) > mbrk)
+                        mbrk = phdr[n].p_vaddr + phdr[n].p_memsz;
+        }
+
+        return (mbrk);
+}
+
+
+unsigned char *
+file_read (char *pathname)
+{
+        FILE *          bf;
+        unsigned char   c;
+        unsigned int    cont_len;
+        unsigned char * cont = NULL;
+
+
+        bf = fopen (pathname, "r");
+        if (bf == NULL)
+                return (NULL);
+
+        /* yepp, its slow. f* caches internally though */
+        for (cont_len = 0 ; fread (&c, 1, 1, bf) == 1 ; ++cont_len) {
+                cont = realloc (cont, cont_len + 1);
+                cont[cont_len] = c;
+        }
+        fclose (bf);
+
+        cont = realloc (cont, cont_len + 1);
+        cont[cont_len] = '\0';
+
+        return (cont);
+}
+
+
+void
+prepare_fingerprint (fp_fin *f)
+{
+        unsigned int    ha_len;
+        unsigned char * ha =
+                malloc ((N_TEST * N_SUBHASH) + 4);
+
+
+        if (fread (f->fp_xor, sizeof (f->fp_xor), 1, frandom) != 1) {
+                fprintf (stderr, "failed to read fingerprint xor block\n");
+                exit (EXIT_FAILURE);
+        }
+
+        /* read fingerprint and tests into fp, either from file or from
+         * current host
+         */
+        f->fp.hash_arr = ha;
+        if (fp_fromhost) {
+                f->fp.tests = fp_tests;
+                fp_get (&f->fp);
+        } else {
+                read_fingerprint (&f->fp, fp_name);
+        }
+        ha_len = fp_len = fp_counttests (&f->fp) * N_SUBHASH;
+#ifdef DEBUG
+        fprintf (stderr, "test: 0x%08lx\n", f->fp.tests);
+#endif
+
+        if (fp_len == 0) {
+                fprintf (stderr, "no fingerprints given\n");
+
+                exit (EXIT_FAILURE);
+        }
+
+        /* warn on erasure possible attack
+         */
+        if (fp_tolerance != 0 &&
+                (fp_tolerance * N_SUBHASH) >= (fp_len - N_SUBHASH))
+        {
+                printf ("WARNING: erasure attack on fingerprint deviation "
+                        "algorithm possible\n");
+                printf ("         decrease tolerance or use more tests !\n");
+                printf ("\n");
+
+                if (fp_WARN) {
+                        printf ("ABORTING: use -E to overwrite. do this only "
+                                        "if you are absolutely\n"
+                                "          mentally stable and know exactly "
+                                        "what you are doing!)\n\n");
+
+                        exit (EXIT_FAILURE);
+                }
+        }
+
+        printf ("prepared fingerprint (%d %s, %d bytes)\n",
+                fp_counttests (&f->fp),
+                fp_counttests (&f->fp) == 1 ? "test" : "tests",
+                fp_len);
+
+        /* generate correction pad for fingerprint
+         */
+        if (fp_tolerance != 0) {
+                unsigned char * par_tmp_data =
+                        malloc (N_TEST * N_SUBHASH * 2);
+
+                f->par_len = fp_padgen (ha, ha_len, par_tmp_data,
+                        N_TEST * N_SUBHASH * 2, fp_tolerance * N_SUBHASH);
+
+                /* strip unneeded bytes and store pad. this pad will be stored
+                 * into the stub header of the wrapped executeable. but the
+                 * pointer par_data is used only temporarily and will be
+                 * NULL'ed out. the stub does recreate the pointer itself
+                 */
+                par_tmp_data = realloc (par_tmp_data, f->par_len);
+                f->par_data = par_tmp_data;
+
+                printf ("using parity block of %lu bytes to restore %d "
+                        "bytes (%d tests) in subhashes\n",
+                        f->par_len, fp_tolerance * N_SUBHASH,
+                        fp_tolerance);
+        } else
+                printf ("using no parity block, fingerprint has "
+                        "no tolerance\n");
+
+        printf ("\n");
+
+
+        return;
+}
+
+
+/* yah, you're right, it looks a bit messy, originally i wanted to put a
+ * small .y parse in, will come at some time, if the complexity of the
+ * possible configuration options exceed commandline/file freedom. ;-)
+ */
+
+void
+read_fingerprint (fp_s *fp, char *pathname)
+{
+        int             in_fp = 0;
+        FILE *          inf;
+        unsigned char   line[128];
+        unsigned char   keyword[64];
+        unsigned char * ha_p;
+        unsigned char * ha_p_end;
+
+
+        inf = fopen (pathname, "r");
+        if (inf == NULL) {
+                fprintf (stderr, "failed to open fingerprint file \"%s\"\n",
+                        pathname);
+                exit (EXIT_FAILURE);
+        }
+
+        fp->tests = 0;  /* file is going to tell us what to enable */
+
+        /* read in test values and fingerprint raw data
+         * all the enable statements must preceed the fingerprint data !
+         */
+        ha_p = fp->hash_arr;
+        ha_p_end = ha_p + (N_TEST * N_SUBHASH);
+
+        while (fgets (line, sizeof (line), inf) != NULL) {
+                if (in_fp && strcmp (line, "end\n") == 0) {
+                        if ((ha_p - fp->hash_arr) !=
+                                (fp_counttests (fp) * N_SUBHASH))
+                        {
+                                fprintf (stderr, "test count and fingerprint "
+                                        "do not match (%d to file: %d) !\n",
+                                        fp_counttests (fp) * N_SUBHASH,
+                                        ha_p - fp->hash_arr);
+
+                                exit (EXIT_FAILURE);
+                        }
+
+                        fclose (inf);
+                        return;
+                }
+                if (in_fp) {
+                        unsigned char * lp;
+
+#define HEXCHECK(c) { if (strchr(hexarr,(c)) == NULL) {\
+        fprintf(stderr, "invalid character \\x%02x in fingerprint data\n", (c));\
+        exit (EXIT_FAILURE);}}
+#define HEXTRANS(c) ((unsigned int)(strchr(hexarr,(c)) - hexarr))
+
+                        for (lp = line ; strlen (lp) > 2 && ha_p < ha_p_end ; lp += 2) {
+                                char    hexarr[] = "0123456789abcdef";
+
+                                HEXCHECK(lp[0]); HEXCHECK(lp[1]);
+                                ha_p[0] = (HEXTRANS(lp[0]) << 4) |
+                                        HEXTRANS(lp[1]);
+                                ha_p += 1;
+                        }
+                } else if (strcmp (line, "begin\n") == 0) {
+                        in_fp = 1;
+                } else if (sscanf (line, "enable %64s\n", keyword) == 1) {
+                        keyword[sizeof (keyword) - 1] = '\0';
+                        fp_tenable (fp, keyword);
+                } else if (sscanf (line, "disable %64s\n", keyword) == 1) {
+                        keyword[sizeof (keyword) - 1] = '\0';
+                        fp_tdisable (fp, keyword);
+                } else if (strlen (line) != 1 && line[0] != '#') {
+                        goto bail;
+                }
+        }
+
+bail:
+        fprintf (stderr, "syntax error in fingerprint file\n");
+
+        exit (EXIT_FAILURE);
+}
+
+
diff --git a/other/burneye/src/common.c b/other/burneye/src/common.c
new file mode 100644
index 0000000..51eabad
--- /dev/null
+++ b/other/burneye/src/common.c
@@ -0,0 +1,53 @@
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "common.h"
+
+
+void *
+xrealloc (void *m_ptr, size_t newsize)
+{
+        void    *n_ptr;
+
+        n_ptr = realloc (m_ptr, newsize);
+        if (n_ptr == NULL) {
+                fprintf (stderr, "realloc failed\n");
+                exit (EXIT_FAILURE);
+        }
+
+        return (n_ptr);
+}
+
+
+char *
+xstrdup (char *str)
+{
+        char    *b;
+
+        b = strdup (str);
+        if (b == NULL) {
+                fprintf (stderr, "strdup failed\n");
+                exit (EXIT_FAILURE);
+        }
+
+        return (b);
+}
+
+
+void *
+xcalloc (int factor, size_t size)
+{
+        void    *bla;
+
+        bla = calloc (factor, size);
+
+        if (bla == NULL) {
+                fprintf (stderr, "no memory left\n");
+                exit (EXIT_FAILURE);
+        }
+
+        return (bla);
+}
+
+
diff --git a/other/burneye/src/common.h b/other/burneye/src/common.h
new file mode 100644
index 0000000..1a58e61
--- /dev/null
+++ b/other/burneye/src/common.h
@@ -0,0 +1,12 @@
+
+#ifndef COMMON_H
+#define COMMON_H
+
+#include <sys/types.h>
+
+void * xrealloc (void *m_ptr, size_t newsize);
+char * xstrdup (char *str);
+void * xcalloc (int factor, size_t size);
+
+#endif
+
diff --git a/other/burneye/src/conf/Makefile b/other/burneye/src/conf/Makefile
new file mode 100644
index 0000000..b6ff8b2
--- /dev/null
+++ b/other/burneye/src/conf/Makefile
@@ -0,0 +1,21 @@
+
+CFLAGS  = -Wall
+ifeq ($(debug),on)
+CFLAGS  += -ggdb
+DFLAGS  += -DDEBUG
+else
+CFLAGS  += -O2
+endif
+
+YACC    = bison
+YACCOPT = -b conf-parser -p cf -d -t -v
+LEX     = flex
+LEXOPT  = -pcf -oconf-lexer.c
+
+
+conf-lexer.c:   config.l
+        $(LEX) $(LEXOPT) config.l
+
+clean:
+#       rm -f conf-parser.[ch] conf-parser.output
+#       rm -f conf-lexer.c
diff --git a/other/burneye/src/conf/config.l b/other/burneye/src/conf/config.l
new file mode 100644
index 0000000..ee7db57
--- /dev/null
+++ b/other/burneye/src/conf/config.l
@@ -0,0 +1,50 @@
+/* burneye - configuration file lexer
+ *
+ * -scut
+ */
+
+%{
+
+#include <string.h>
+#include "../common.h"
+
+%}
+
+%%
+
+[\n\t ]+        ;
+
+\{      {
+        return (EXPR_BLOCK_BEGIN);
+        }
+
+\}      {
+        return (EXPR_BLOCK_END);
+        }
+
+\"[^\"]*\"      {
+        cflval.str = xstrdup (cftext + 1);
+        cflval.str[strlen (cflval.str) - 1] = '\0';
+
+        return (QSTRING);
+        }
+
+function        {
+        return (FUNCTION);
+        }
+
+0x[0123456789abcdef]+   {
+        sscanf (cftext, "0x%lx", &cflval.num);
+
+        return (NUM);
+        }
+
+[0123456789]+ {
+        sscanf (cftext, "%lu", &cflval.num);
+
+        return (NUM);
+}
+
+.       return (cftext[0]);
+
+
diff --git a/other/burneye/src/conf/config.y b/other/burneye/src/conf/config.y
new file mode 100644
index 0000000..4285e75
--- /dev/null
+++ b/other/burneye/src/conf/config.y
@@ -0,0 +1,27 @@
+/* burneye - configuration file parser
+ *
+ * -scut
+ */
+
+%{
+
+%}
+
+%union {
+        unsigned char *         str;
+        unsigned long int       num;
+}
+
+%token  <str>   EXPR_BLOCK_BEGIN
+%token  <str>   EXPR_BLOCK_END
+%token  <str>   QSTRING
+%token  <str>   FUNCTION
+%token  <num>   NUM
+
+/* types here */
+/* %type <pp_element> script */
+
+%%
+
+configuration:
+        
diff --git a/other/burneye/src/conf/tmp/Makefile b/other/burneye/src/conf/tmp/Makefile
new file mode 100644
index 0000000..035b9c1
--- /dev/null
+++ b/other/burneye/src/conf/tmp/Makefile
@@ -0,0 +1,39 @@
+CC      = gcc
+#CFLAGS = -Wall -O2 -static
+CFLAGS  = -Wall -ggdb
+#CFLAGS = -Wall -ggdb -DDEBUG
+#CFLAGS = -Wall -ggdb -DYYDEBUG -DDEBUG
+
+LIBS    =
+
+YACC    = yacc
+YACCOPT = -d -v -t
+LEX     = lex
+LEXOPT  =
+
+OBJS    = ../../shared/common.o condition.o compiler_main.o branch.o call.o \
+                element.o functions.o script.o symbol.o y.tab.o lex.yy.o
+
+
+all:            compiler-test
+
+link:           $(OBJS)
+
+dist:           lex.yy.c y.tab.h
+
+compiler-test:  $(OBJS) compiler-test.c
+                $(CC) -o compiler-test compiler-test.c $(OBJS) $(CFLAGS) $(LIBS)
+
+lex.yy.o:       lex.yy.c y.tab.h
+
+lex.yy.c:       compiler.l
+                $(LEX) $(LEXOPT) compiler.l
+
+y.tab.c y.tab.h:        compiler.y
+                        $(YACC) $(YACCOPT) compiler.y
+
+clean:
+        rm -f y.tab.c y.tab.h y.output lex.yy.c
+        rm -f compiler-test
+        rm -f *.o
+
diff --git a/other/burneye/src/conf/tmp/branch.c b/other/burneye/src/conf/tmp/branch.c
new file mode 100644
index 0000000..3e0f336
--- /dev/null
+++ b/other/burneye/src/conf/tmp/branch.c
@@ -0,0 +1,61 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting branching routines
+ */
+
+#include <stdlib.h>
+#include "../../shared/common.h"
+#include "condition.h"
+#include "branch.h"
+
+
+branch *
+br_create (void)
+{
+        branch *        new = xcalloc (1, sizeof (branch));
+
+        return (new);
+}
+
+
+void
+br_free (branch *br)
+{
+        elem_list_free (br->b_true);
+        elem_list_free (br->b_false);
+        cond_free (br->cond);
+        free (br);
+
+        return;
+}
+
+
+branch *
+br_set_condition (branch *br, condition *cond)
+{
+        br->cond = cond;
+
+        return (br);
+}
+
+
+branch *
+br_set_block_if (branch *br, element **bl)
+{
+        br->b_true = bl;
+
+        return (br);
+}
+
+
+branch *
+br_set_block_else (branch *br, element **bl)
+{
+        br->b_false = bl;
+
+        return (br);
+}
+
+
diff --git a/other/burneye/src/conf/tmp/branch.h b/other/burneye/src/conf/tmp/branch.h
new file mode 100644
index 0000000..8fdf9a4
--- /dev/null
+++ b/other/burneye/src/conf/tmp/branch.h
@@ -0,0 +1,74 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting branching includes
+ */
+
+#ifndef FNX_BRANCH_H
+#define FNX_BRANCH_H
+
+#include "condition.h"
+#include "element.h"
+
+
+typedef struct {
+        condition *     cond;
+        element **      b_true;
+        element **      b_false;
+} branch;
+
+
+/* br_create
+ *
+ * branch constructor. create a new branch structure
+ *
+ * return a pointer to the new structure
+ */
+
+branch *        br_create (void);
+
+
+/* br_free
+ *
+ * free the whole branch pointed to by `br'
+ *
+ * return in any case
+ */
+
+void    br_free (branch *br);
+
+
+/* br_set_condition
+ *
+ * set condition `cond' for branch `br'
+ *
+ * return pointer to structure
+ */
+
+branch *        br_set_condition (branch *br, condition *cond);
+
+
+/* br_set_block_if
+ *
+ * set block `bl' for branch `br' on true case
+ *
+ * return pointer to structure
+ */
+
+branch *        br_set_block_if (branch *br, element **bl);
+
+
+/* br_set_block_else
+ *
+ * set block `bl' for branch `br' on false case
+ *
+ * return pointer to structure
+ */
+
+branch *        br_set_block_else (branch *br, element **bl);
+
+
+#endif
+
+
diff --git a/other/burneye/src/conf/tmp/call.c b/other/burneye/src/conf/tmp/call.c
new file mode 100644
index 0000000..a4bf073
--- /dev/null
+++ b/other/burneye/src/conf/tmp/call.c
@@ -0,0 +1,56 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting call routines
+ */
+
+
+#include <stdlib.h>
+#include "../../shared/common.h"
+#include "symbol.h"
+#include "call.h"
+
+
+call *
+call_create (void)
+{
+        call *  new = xcalloc (1, sizeof (call));
+
+        return (new);
+}
+
+
+void
+call_free (call *c)
+{
+        if (c == NULL)
+                return;
+
+        sym_free (c->parameters);
+        if (c->name != NULL)
+                free (c->name);
+        free (c);
+
+        return;
+}
+
+
+call *
+call_set_name (call *c, char *name)
+{
+        c->name = name;
+
+        return (c);
+}
+
+
+call *
+call_set_parameters (call *c, sym_elem **par)
+{
+        c->parameters = par;
+
+        return (c);
+}
+
+
diff --git a/other/burneye/src/conf/tmp/call.h b/other/burneye/src/conf/tmp/call.h
new file mode 100644
index 0000000..33d2b8f
--- /dev/null
+++ b/other/burneye/src/conf/tmp/call.h
@@ -0,0 +1,62 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting call includes
+ */
+
+#ifndef FNX_CALL_H
+#define FNX_CALL_H
+
+#include "symbol.h"
+
+
+typedef struct {
+        char *          name;
+        sym_elem **     parameters;
+} call;
+
+
+/* call_create
+ *
+ * call constructor.
+ *
+ * return a pointer to a new call structure
+ */
+
+call *  call_create (void);
+
+
+/* call_free
+ *
+ * free a call structure pointed to by `c' completely, including any symbol
+ * information
+ *
+ * return in any case
+ */
+
+void    call_free (call *c);
+
+
+/* call_set_name
+ *
+ * set the name `name' for a call structure pointed to by `c'
+ *
+ * return pointer to the structure
+ */
+
+call *  call_set_name (call *c, char *name);
+
+
+/* call_set_parameters
+ *
+ * set parameters `par' for a call structure pointed to by `c'
+ *
+ * return pointer to the structure
+ */
+
+call *  call_set_parameters (call *c, sym_elem **par);
+
+
+#endif
+
diff --git a/other/burneye/src/conf/tmp/compiler-test.c b/other/burneye/src/conf/tmp/compiler-test.c
new file mode 100644
index 0000000..969ae4d
--- /dev/null
+++ b/other/burneye/src/conf/tmp/compiler-test.c
@@ -0,0 +1,74 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * compiler test program
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "../../shared/common.h"
+#include "element.h"
+#include "compiler.h"
+#include "script.h"
+
+
+extern void     scr_elem_exec (element **el);
+char *          file_read (char *filename);
+
+
+char *
+file_read (char *filename)
+{
+        FILE                    *fp;
+        char                    *array = NULL;
+        unsigned long int       readbytes = 0;
+        size_t                  rb;
+
+        fp = fopen (filename, "r");
+        if (fp == NULL)
+                return (NULL);
+
+        do {
+                array = xrealloc (array, readbytes + 1024);
+                rb = fread (array + readbytes, 1, 1024, fp);
+                readbytes += rb;
+        } while (rb > 0);
+
+        fclose (fp);
+
+        return (array);
+}
+
+
+int
+main (int argc, char **argv)
+{
+        element **      script_c;
+        char *          script;
+
+        if (argc != 2) {
+                printf ("usage: %s <inputfile>\n\n", argv[0]);
+                exit (EXIT_FAILURE);
+        }
+
+        script = file_read (argv[1]);
+        if (script == NULL) {
+                fprintf (stderr, "couldn't open %s, aborting\n", argv[1]);
+                exit (EXIT_FAILURE);
+        }
+
+        script_c = cp_compile (script, strlen (script));
+        printf ("-------------------------------------------------------------------------------\n");
+        printf ("compilation of script %s %s.\n\n", argv[1], (script_c == NULL) ? "failed" : "successful");
+
+        printf ("\ntrying to run it...\n");
+        scr_elem_exec (script_c);
+
+        elem_list_free (script_c);
+
+        exit (EXIT_SUCCESS);
+}
+
+
diff --git a/other/burneye/src/conf/tmp/compiler.h b/other/burneye/src/conf/tmp/compiler.h
new file mode 100644
index 0000000..db49e1f
--- /dev/null
+++ b/other/burneye/src/conf/tmp/compiler.h
@@ -0,0 +1,18 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * compiler include file
+ */
+
+#ifndef FNX_COMPILER_H
+#define FNX_COMPILER_H
+
+int             yyerror (char *str);
+int             yywrap (void);
+element **      cp_compile (char *buf, int buf_len);
+int             cp_yyinput (char *buf, int size_max);
+
+#endif
+
+
diff --git a/other/burneye/src/conf/tmp/compiler.l b/other/burneye/src/conf/tmp/compiler.l
new file mode 100644
index 0000000..1dbb21b
--- /dev/null
+++ b/other/burneye/src/conf/tmp/compiler.l
@@ -0,0 +1,95 @@
+/* fornax - distributed packet network
+ *
+ * by team teso
+ *
+ * lex command lexical analyzer
+ */
+
+
+%{
+#undef  yywrap
+
+#include <string.h>
+#include "../../shared/common.h"
+#include "branch.h"
+#include "call.h"
+#include "compiler.h"
+#include "condition.h"
+#include "element.h"
+#include "symbol.h"
+#include "y.tab.h"
+
+#undef  ECHO
+#undef  YY_INPUT
+#define YY_INPUT(b, r, ms) (r = cp_yyinput (b, ms))
+
+%}
+
+%%
+
+[\n\t ]+        ;        /* strip any whitespaces */
+
+\{      {
+                return (EXPR_BLOCK_BEGIN);
+        }
+
+\}      {
+                return (EXPR_BLOCK_END);
+        }
+
+\"[^\"]*\"      {
+                        yylval.str = xstrdup (yytext + 1);
+                        yylval.str[strlen (yylval.str) - 1] = '\x00';
+
+                        return (ASTRING);
+                }
+
+[iI][fF]        {
+                        return (IF);
+                }
+
+[eE][lL][sS][eE]        {
+                                return (ELSE);
+                        }
+
+\$[a-zA-Z\_]+[a-zA-Z0-9\_]*     {
+                                        yylval.str = xstrdup (yytext);
+
+                                        return (VARIABLE);
+                                }
+
+(\&\&)|(\|\|)   {
+                        if (strcmp (yytext, "&&") == 0)
+                                yylval.logoper = LO_AND;
+                        else if (strcmp (yytext, "||") == 0)
+                                yylval.logoper = LO_OR;
+
+                        return (LOG_OPER);
+                }
+
+(\=\=)|(\>\=)|(\<\=)|(\!\=)     {
+                                        if (strcmp (yytext, "==") == 0)
+                                                yylval.eq = EQ_EQUAL;
+                                        else if (strcmp (yytext, ">=") == 0)
+                                                yylval.eq = EQ_GREATEQ;
+                                        else if (strcmp (yytext, "<=") == 0)
+                                                yylval.eq = EQ_LOWEREQ;
+                                        else if (strcmp (yytext, "!=") == 0)
+                                                yylval.eq = EQ_NOTEQ;
+
+                                        return (EQ_OP);
+                                }
+
+[a-zA-Z0-9\.\_]+        {
+                                yylval.str = xstrdup (yytext);
+
+                                return (STRING);
+                        }
+
+[=]             {
+                        return (EQ);
+                }
+
+.       return (yytext[0]);
+
+
diff --git a/other/burneye/src/conf/tmp/compiler.y b/other/burneye/src/conf/tmp/compiler.y
new file mode 100644
index 0000000..d33ca67
--- /dev/null
+++ b/other/burneye/src/conf/tmp/compiler.y
@@ -0,0 +1,271 @@
+/* fornax - distributed packet network
+ *
+ * by team teso
+ *
+ * yacc command parser
+ */
+
+%{
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+#include <stdlib.h>
+#include "branch.h"
+#include "call.h"
+#include "compiler.h"
+#include "condition.h"
+#include "element.h"
+#include "symbol.h"
+
+extern element **       gl_script;
+
+%}
+
+
+%union {
+        int             eq;             /* equality test operator */
+        int             logoper;        /* logical operator */
+        char *          str;            /* generic string pointer */
+        element **      pp_element;
+        element *       p_element;
+        call *          p_call;
+        branch *        p_branch;
+        condition *     p_condition;
+        sym_elem *      p_sym_elem;
+        sym_elem **     pp_sym_elem;
+}
+
+
+%token  <eq>            EQ
+%token  <eq>            EQ_OP
+%token  <logoper>       LOG_OPER
+%token  <str>           STRING
+%token  <str>           ASTRING
+%token  <str>           VARIABLE
+%token  <str>           SET
+%token  <str>           IF
+%token  <str>           ELSE
+%token  <str>           EXPR_BLOCK_BEGIN
+%token  <str>           EXPR_BLOCK_END
+
+%type   <pp_element>    script
+%type   <pp_element>    block
+%type   <pp_element>    elementlist
+%type   <p_element>     element
+%type   <p_call>        call
+%type   <p_branch>      branch
+%type   <p_condition>   condition
+%type   <p_sym_elem>    set
+%type   <pp_sym_elem>   setlist
+
+%%
+
+
+script:
+                block
+        {
+                gl_script = $1;
+        }
+
+        ;
+
+/* a block is a list of expression elements. the block is started with a
+ * `{' bracket and terminated by a `}' bracket. the simplest block just
+ * consists out of "{}"
+ */
+
+block:
+                EXPR_BLOCK_BEGIN elementlist EXPR_BLOCK_END
+        {
+                $$ = $2;
+        }
+
+        |       EXPR_BLOCK_BEGIN EXPR_BLOCK_END
+        {
+                $$ = NULL;
+        }
+
+        ;
+
+/* an elementlist is a concatation of single elements, which could be either
+ * expressions, settings or blocks
+ */
+
+elementlist:
+                elementlist element
+        {
+#ifdef DEBUG
+                printf ("element %08x added to elementlist %08x\n", $2, $1);
+#endif
+                $$ = elem_add ($1, $2);
+        }
+
+        |       element
+        {
+#ifdef DEBUG
+                printf ("element %08x added to elementlist NULL\n", $1);
+#endif
+                $$ = NULL;
+                $$ = elem_add ($$, $1);
+        }
+
+        ;
+
+
+/* an element is actually the gut of a program. elements are the pieces that
+ * are executed in a linear way, but an element can contain a block of other
+ * elements *shrug*
+ */
+
+element:
+                call
+        {
+#ifdef DEBUG
+                printf ("call element %08x experienced \n", $1);
+#endif
+                $$ = elem_create ();
+                $$ = elem_set_type ($$, ELEM_TYPE_CALL);
+                $$ = elem_set_data ($$, $1);
+        }
+
+        |       branch
+        {
+#ifdef DEBUG
+                printf ("branch element %08x experienced \n", $1);
+#endif
+                $$ = elem_create ();
+                $$ = elem_set_type ($$, ELEM_TYPE_BRANCH);
+                $$ = elem_set_data ($$, $1);
+        }
+
+        |       set
+        {
+#ifdef DEBUG
+                printf ("set element %08x experienced \n", $1);
+#endif
+                $$ = elem_create ();
+                $$ = elem_set_type ($$, ELEM_TYPE_SET);
+                $$ = elem_set_data ($$, $1);
+        }
+
+        ;
+
+call:
+                STRING '(' setlist ')'
+        {
+#ifdef DEBUG
+                printf ("call with parameters to symbol \"%s\" experienced \n", $1);
+#endif
+                $$ = call_create ();
+                $$ = call_set_name ($$, $1);
+                $$ = call_set_parameters ($$, $3);
+        }
+
+        |       STRING '(' ')'
+        {
+#ifdef DEBUG
+                printf ("call without parameters to symbol \"%s\" experienced \n", $1);
+#endif
+                $$ = call_create ();
+                $$ = call_set_name ($$, $1);
+                $$ = call_set_parameters ($$, NULL);
+        }
+
+        ;
+
+setlist:
+                setlist set
+        {
+#ifdef DEBUG
+                printf ("symbol %08x added to symbol table at %08x\n", $2, $1);
+#endif
+                $$ = sym_elem_add ($1, $2);
+        }
+
+        |       set
+        {
+#ifdef DEBUG
+                printf ("symbol %08x added to NULL symbol table\n", $1);
+#endif
+                $$ = NULL;
+                $$ = sym_elem_add ($$, $1);
+        }
+
+        ;
+
+set:
+                STRING EQ ASTRING
+        {
+#ifdef DEBUG
+                printf ("symbol pair (%s = \"%s\") created\n", $1, $3);
+#endif
+                $$ = sym_elem_create ($1, $3);
+        }
+
+        ;
+
+branch:
+                IF '(' condition ')' block
+        {
+#ifdef DEBUG
+                printf ("if block with condition at %08x and block at %08x created\n", $3, $5);
+#endif
+                $$ = br_create ();
+                $$ = br_set_condition ($$, $3);
+                $$ = br_set_block_if ($$, $5);
+                $$ = br_set_block_else ($$, NULL);
+        }
+
+        |       IF '(' condition ')' block ELSE block
+        {
+#ifdef DEBUG
+                printf ("if block with condition at %08x and blocks at %08x/%08x created\n", $3, $5, $7);
+#endif
+                $$ = br_create ();
+                $$ = br_set_condition ($$, $3);
+                $$ = br_set_block_if ($$, $5);
+                $$ = br_set_block_else ($$, $7);
+        }
+
+        ;
+
+condition:
+                '(' condition LOG_OPER condition ')'
+        {
+#ifdef DEBUG
+                printf ("condition1 at %08x LOG_OPER condition2 at %08x created\n", $2, $4);
+#endif
+                $$ = cond_create ();
+                $$ = cond_set_cond1 ($$, $2);
+                $$ = cond_set_logoper ($$, $3);
+                $$ = cond_set_cond2 ($$, $4);
+                $$ = cond_set_val1 ($$, NULL);
+                $$ = cond_set_val2 ($$, NULL);
+        }
+
+        |       STRING EQ_OP ASTRING
+        {
+#ifdef DEBUG
+                printf ("%s EQ_OP \"%s\"\n", $1, $3);
+#endif
+                $$ = cond_create ();
+                $$ = cond_set_cond1 ($$, NULL);
+                $$ = cond_set_cond1 ($$, NULL);
+                $$ = cond_set_val1 ($$, $1);
+                $$ = cond_set_eqop ($$, $2);
+                $$ = cond_set_val2 ($$, $3);
+        }
+
+        ;
+
+%%
+
+#include "script.h"
+#include "branch.h"
+#include "call.h"
+#include "compiler.h"
+#include "condition.h"
+#include "element.h"
+#include "symbol.h"
+
+
diff --git a/other/burneye/src/conf/tmp/compiler_main.c b/other/burneye/src/conf/tmp/compiler_main.c
new file mode 100644
index 0000000..7a75786
--- /dev/null
+++ b/other/burneye/src/conf/tmp/compiler_main.c
@@ -0,0 +1,127 @@
+/* fornax distributed packet network
+ *
+ * by team teso
+ *
+ * scripting compiler routines
+ */
+
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <string.h>
+#include "../../shared/common.h"
+#include "branch.h"
+#include "call.h"
+#include "compiler.h"
+#include "condition.h"
+#include "element.h"
+#include "script.h"
+#include "symbol.h"
+
+
+extern int      yydebug;
+extern FILE *   yyout;
+
+element **      gl_script;
+
+char *          cp_input_ptr;
+int             cp_input_lim;
+
+jmp_buf         cp_yy_error_jmp;
+
+extern int      yyparse (void);
+
+
+/* yacc functions
+ */
+
+int
+yyerror (char *str)
+{
+        /* to handle that errors, go to compiler
+         */
+        longjmp (cp_yy_error_jmp, 1);
+
+        exit (EXIT_FAILURE);
+}
+
+
+int
+yywrap (void)
+{
+#ifdef YYDEBUG
+        printf ("yywrap called\n");
+#endif
+        return (1);
+}
+
+
+/* input functions
+ *
+ * cp_input_lim is the number of bytes stored in the buffer pointed to by
+ * cp_input_ptr. the pointer and the value of cp_input_lim will change while
+ * parsing the input
+ */
+
+/* cp_parse
+ *
+ * parse a action string pointed to by `buf' with a length of `buf_len'
+ *
+ * return the parsed action structure
+ */
+
+element **
+cp_compile (char *buf, int buf_len)
+{
+        gl_script = NULL;
+        cp_input_ptr = buf;
+        cp_input_lim = buf_len;
+
+#ifdef YYDEBUG
+        yydebug = 1;
+#endif
+
+        /* set compilation error jump point, if called handle the errors
+         */
+        if (setjmp (cp_yy_error_jmp) != 0) {
+                if (gl_script != NULL)
+                        elem_list_free (gl_script);
+
+                return (NULL);
+        }
+
+        yyparse ();
+
+
+        return (gl_script);
+}
+
+
+/* cp_yyinput
+ *
+ * input functions for the yacc parser to feed strings into it
+ *
+ * return number of bytes "read"
+ */
+
+int
+cp_yyinput (char *buf, int size_max)
+{
+        int     n = 0;
+
+        n = (size_max >= cp_input_lim) ?
+                (cp_input_lim) :
+                (size_max);
+
+        if (n > 0) {
+                memmove (buf, cp_input_ptr, n);
+                cp_input_ptr += n;
+                cp_input_lim -= n;
+        }
+
+        return (n);
+}
+
+
diff --git a/other/burneye/src/conf/tmp/condition.c b/other/burneye/src/conf/tmp/condition.c
new file mode 100644
index 0000000..368aa73
--- /dev/null
+++ b/other/burneye/src/conf/tmp/condition.c
@@ -0,0 +1,157 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting condition routines
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "../../shared/common.h"
+#include "condition.h"
+#include "symbol.h"
+
+extern sym_elem **      gl_ns;
+
+
+int
+cond_verify (condition *cnd)
+{
+        /* condition is invalid and hence cannot be met
+         */
+        if (cnd->cond1 == NULL && cnd->val1 == NULL)
+                return (0);
+
+        /* pair condition
+         */
+        if (cnd->cond1 != NULL) {
+                int     c1_ret, c2_ret;
+
+                c1_ret = cond_verify (cnd->cond1);
+                c2_ret = cond_verify (cnd->cond2);
+
+                if (cnd->logoper == LO_OR) {
+                        return ((c1_ret == 1 || c2_ret == 1) ? 1 : 0);
+                } else if (cnd->logoper == LO_AND) {
+                        return ((c1_ret == 1 && c2_ret == 1) ? 1 : 0);
+                }
+
+                /* shouldn't happen
+                 */
+                return (0);
+        } else {
+                int     eq_val = 0;
+                char *  val1_s;
+                char *  val2_s;
+
+                /* normal equality test (broken-down-case)
+                 * first substitute each side then compare according to the
+                 * equality operator
+                 */
+                val1_s = (char *) sym_resolve (gl_ns, cnd->val1);
+                val2_s = sym_subst (gl_ns, cnd->val2);
+
+                switch (cnd->eqop) {
+                case (EQ_EQUAL):
+                        eq_val = (strcasecmp (val1_s, val2_s) == 0) ? 1 : 0;
+                        break;
+                case (EQ_NOTEQ):
+                        eq_val = (strcasecmp (val1_s, val2_s) == 0) ? 0 : 1;
+                        break;
+                /* to be implemented
+                 */
+                case (EQ_GREATEQ):
+                case (EQ_LOWEREQ):
+                        break;
+                default:
+                        break;
+                }
+
+                free (val2_s);
+
+                return (eq_val);
+        }
+}
+
+
+condition *
+cond_create (void)
+{
+        condition *     new = xcalloc (1, sizeof (condition));
+
+        return (new);
+}
+
+
+void
+cond_free (condition *c)
+{
+        if (c->val1 != NULL)
+                free (c->val1);
+        if (c->val2 != NULL)
+                free (c->val2);
+        if (c->cond1 != NULL)
+                cond_free (c->cond1);
+        if (c->cond2 != NULL)
+                cond_free (c->cond2);
+        free (c);
+
+        return;
+}
+
+
+condition *
+cond_set_cond1 (condition *c, condition *c1)
+{
+        c->cond1 = c1;
+
+        return (c);
+}
+
+
+condition *
+cond_set_cond2 (condition *c, condition *c2)
+{
+        c->cond2 = c2;
+
+        return (c);
+}
+
+
+condition *
+cond_set_logoper (condition *c, int lo)
+{
+        c->logoper = lo;
+
+        return (c);
+}
+
+
+condition *
+cond_set_eqop (condition *c, int eo)
+{
+        c->eqop = eo;
+
+        return (c);
+}
+
+
+condition *
+cond_set_val1 (condition *c, char *val)
+{
+        c->val1 = val;
+
+        return (c);
+}
+
+
+condition *
+cond_set_val2 (condition *c, char *val)
+{
+        c->val2 = val;
+
+        return (c);
+}
+
+
+
diff --git a/other/burneye/src/conf/tmp/condition.h b/other/burneye/src/conf/tmp/condition.h
new file mode 100644
index 0000000..fffc486
--- /dev/null
+++ b/other/burneye/src/conf/tmp/condition.h
@@ -0,0 +1,125 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting condition includes
+ */
+
+#ifndef FNX_CONDITION_H
+#define FNX_CONDITION_H
+
+
+#define LO_OR           1
+#define LO_AND          2
+
+#define EQ_EQUAL        1
+#define EQ_GREATEQ      2
+#define EQ_LOWEREQ      3
+#define EQ_NOTEQ        4
+
+
+typedef struct condition {
+        struct condition *      cond1;
+        int                     logoper;
+        struct condition *      cond2;
+
+        char *                  val1;
+        int                     eqop;
+        char *                  val2;
+} condition;
+
+
+/* cond_verify
+ *
+ * verify whether a condition is met or not
+ *
+ * return 1 if the condition is met
+ * return 0 if not or an error was experienced during parsing
+ */
+
+int     cond_verify (condition *cnd);
+
+
+/* cond_create
+ *
+ * condition constructor. create a new condition structure
+ *
+ * return a pointer to the new structure
+ */
+
+condition *     cond_create (void);
+
+
+/* cond_free
+ *
+ * free the whole condition pointed to by `c'
+ *
+ * return in any case
+ */
+
+void    cond_free (condition *c);
+
+
+/* cond_set_cond1
+ *
+ * set subcondition condition `c1' for condition `c'
+ *
+ * return pointer to structure
+ */
+
+condition *     cond_set_cond1 (condition *c, condition *c1);
+
+
+/* cond_set_cond2
+ *
+ * set subcondition condition `c2' for condition `c'
+ *
+ * return pointer to structure
+ */
+
+condition *     cond_set_cond2 (condition *c, condition *c2);
+
+
+/* cond_set_logoper
+ *
+ * set logical operator `lo' for the two subconditions in condition `c'.
+ *
+ * return pointer to structure
+ */
+
+condition *     cond_set_logoper (condition *c, int lo);
+
+
+/* cond_set_eqop
+ *
+ * set equeality operator `eo' for the comparison in condition `c'.
+ *
+ * return pointer to structure
+ */
+
+condition *     cond_set_eqop (condition *c, int eo);
+
+
+/* cond_set_val1
+ *
+ * set first value `val' in condition `c'
+ *
+ * return pointer to structure
+ */
+
+condition *     cond_set_val1 (condition *c, char *val);
+
+
+/* cond_set_val2
+ *
+ * set second value `val' in condition `c'
+ *
+ * return pointer to structure
+ */
+
+condition *     cond_set_val2 (condition *c, char *val);
+
+
+#endif
+
+
diff --git a/other/burneye/src/conf/tmp/element.c b/other/burneye/src/conf/tmp/element.c
new file mode 100644
index 0000000..ee7633e
--- /dev/null
+++ b/other/burneye/src/conf/tmp/element.c
@@ -0,0 +1,115 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting element routines
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include "../../shared/common.h"
+#include "call.h"
+#include "branch.h"
+#include "element.h"
+#include "symbol.h"
+
+
+/* static function declarations
+ */
+static int      elem_count (element **el);
+
+
+void
+elem_list_free (element **el)
+{
+        if (el == NULL)
+                return;
+
+        while (elem_count (el) > 0) {
+                elem_free (el[0]);
+                memmove (&el[0], &el[1], (elem_count (&el[1]) + 1) * sizeof (element *));
+        }
+
+        if (el != NULL)
+                free (el);
+}
+
+
+static int
+elem_count (element **el)
+{
+        int     count;
+
+        if (el == NULL)
+                return (0);
+
+        for (count = 0 ; el[count] != NULL ; ++count)
+                ;
+
+        return (count);
+}
+
+
+element **
+elem_add (element **el, element *e)
+{
+        int     ec = elem_count (el);
+
+        el = xrealloc (el, (ec + 2) * sizeof (element *));
+        el[ec] = e;
+        el[ec + 1] = NULL;
+
+        return (el);
+}
+
+
+element *
+elem_create (void)
+{
+        element *       new = xcalloc (1, sizeof (element));
+
+        return (new);
+}
+
+
+void
+elem_free (element *e)
+{
+        switch (e->type) {
+        case (ELEM_TYPE_CALL):
+                call_free ((call *) e->data);
+                break;
+        case (ELEM_TYPE_BRANCH):
+                br_free ((branch *) e->data);
+                break;
+        case (ELEM_TYPE_SET):
+                sym_elem_free ((sym_elem *) e->data);
+                break;
+        default:
+                break;
+        }
+
+        free (e);
+
+        return;
+}
+
+
+element *
+elem_set_type (element *e, int type)
+{
+        e->type = type;
+
+        return (e);
+}
+
+
+element *
+elem_set_data (element *e, void *data)
+{
+        e->data = data;
+
+        return (e);
+}
+
+
diff --git a/other/burneye/src/conf/tmp/element.h b/other/burneye/src/conf/tmp/element.h
new file mode 100644
index 0000000..36b9a23
--- /dev/null
+++ b/other/burneye/src/conf/tmp/element.h
@@ -0,0 +1,85 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting element includes
+ */
+
+#ifndef FNX_ELEMENT_H
+#define FNX_ELEMENT_H
+
+
+#define ELEM_TYPE_CALL          1
+#define ELEM_TYPE_BRANCH        2
+#define ELEM_TYPE_SET           3
+
+typedef struct {
+        int             type;
+        void *          data;
+} element;
+
+
+/* elem_list_free
+ *
+ * free a list of elements pointed to by `el'
+ *
+ * return in any case
+ */
+
+void    elem_list_free (element **el);
+
+
+/* elem_add
+ *
+ * add element pointed to by `e' to the element list pointed to by `el'. if the
+ * element list is empty, create a new one
+ *
+ * return a pointer to the modified/created element list
+ */
+
+element **      elem_add (element **el, element *e);
+
+
+/* elem_create
+ *
+ * element constructor. create a new element structure
+ *
+ * return a pointer to the new structure
+ */
+
+element *       elem_create (void);
+
+
+/* elem_free
+ *
+ * free the whole element pointed to by `e'
+ *
+ * return in any case
+ */
+
+void    elem_free (element *e);
+
+
+/* elem_set_type
+ *
+ * set element type `type' for element pointed to by `e'
+ *
+ * return pointer to structure
+ */
+
+element *       elem_set_type (element *e, int type);
+
+
+/* elem_set_data
+ *
+ * set element data to `data' for element pointed to by `e'
+ *
+ * return pointer to structure
+ */
+
+element *       elem_set_data (element *e, void *data);
+
+
+#endif
+
+
diff --git a/other/burneye/src/conf/tmp/functionlist.h b/other/burneye/src/conf/tmp/functionlist.h
new file mode 100644
index 0000000..67d062f
--- /dev/null
+++ b/other/burneye/src/conf/tmp/functionlist.h
@@ -0,0 +1,20 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * script functions
+ */
+
+#ifndef FNX_FUNCTIONLIST_H
+#define FNX_FUNCTIONLIST_H
+
+#include "symbol.h"
+
+int     f_listen (sym_elem **sl);       /* net.listen */
+int     node_self (sym_elem **stab);    /* sys.self */
+int     tt_schedule (sym_elem **stab);  /* time.schedule */
+int     tt_erase (sym_elem **stab);     /* time.erase */
+
+#endif
+
+
diff --git a/other/burneye/src/conf/tmp/functions.c b/other/burneye/src/conf/tmp/functions.c
new file mode 100644
index 0000000..96af53c
--- /dev/null
+++ b/other/burneye/src/conf/tmp/functions.c
@@ -0,0 +1,66 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * function routines
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "functions.h"
+#include "functionlist.h"
+#include "symbol.h"
+
+
+int     fnc_debug (sym_elem **stab);
+
+function        gl_fnc[] = {
+        /* primitives */
+        { "nop",                NULL },
+        { "debug",              fnc_debug },
+
+        /* network */
+        { "net.listen",         f_listen },
+
+        /* fornax system */
+        { "sys.self",           node_self },
+
+        /* time management */
+        { "time.schedule",      tt_schedule },
+        { "time.erase",         tt_erase },
+
+        /* end of list */
+        { NULL,         NULL },
+};
+
+
+fnc_handler
+fnc_find (function ftab[], char *name)
+{
+        int     stp_p;  /* step pointer */
+
+        for (stp_p = 0 ; ftab[stp_p].name != NULL ; ++stp_p) {
+                if (strcasecmp (ftab[stp_p].name, name) == 0)
+                        return (ftab[stp_p].f_handler);
+        }
+
+        return (NULL);
+}
+
+
+int
+fnc_debug (sym_elem **stab)
+{
+        int     n;
+
+        if (stab == NULL)
+                return (0);
+
+        for (n = 0 ; stab[n] != NULL ; ++n) {
+                printf ("%s . %s\n", (stab[n]->key == NULL) ? "NULL" : stab[n]->key,
+                        (stab[n]->value == NULL) ? "NULL" : stab[n]->value);
+        }
+
+        return (0);
+}
+
diff --git a/other/burneye/src/conf/tmp/functions.h b/other/burneye/src/conf/tmp/functions.h
new file mode 100644
index 0000000..4626c1c
--- /dev/null
+++ b/other/burneye/src/conf/tmp/functions.h
@@ -0,0 +1,35 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * function definitions
+ */
+
+#ifndef FNX_FUNCTION_H
+#define FNX_FUNCTION_H
+
+#include "symbol.h"
+
+typedef int (* fnc_handler)(sym_elem **par);
+
+typedef struct {
+        char *          name;           /* symbolic function name */
+        fnc_handler     f_handler;      /* function handler */
+} function;
+
+
+/* fnc_find
+ *
+ * find a function with the function name `name' from the function table
+ * pointed to by `ftab'
+ *
+ * return fnc_handler pointer on success
+ * return NULL on failure
+ */
+
+fnc_handler     fnc_find (function ftab[], char *name);
+
+
+#endif
+
+
diff --git a/other/burneye/src/conf/tmp/script.c b/other/burneye/src/conf/tmp/script.c
new file mode 100644
index 0000000..3fc7634
--- /dev/null
+++ b/other/burneye/src/conf/tmp/script.c
@@ -0,0 +1,154 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting capabilities routines
+ */
+
+#include <stdio.h>
+#include "branch.h"
+#include "call.h"
+#include "compiler.h"
+#include "element.h"
+#include "functions.h"
+#include "script.h"
+#include "symbol.h"
+
+sym_elem **     gl_ns = NULL;
+extern function gl_fnc[];
+
+
+/* static functions
+ */
+
+void    scr_elem_exec (element **el);
+static void     scr_call (call *c);
+static void     scr_branch (branch * br);
+
+
+/* scr_elem_exec
+ *
+ * execute the element list pointed to by `el'
+ *
+ * return in any case
+ */
+
+void
+scr_elem_exec (element **el)
+{
+        int             el_ptr;
+        element *       ec;
+
+        if (el == NULL || el[0] == NULL)
+                return;
+
+        for (el_ptr = 0 ; el[el_ptr] != NULL ; ++el_ptr) {
+                ec = el[el_ptr];
+
+                switch (ec->type) {
+                case (ELEM_TYPE_CALL):
+                        scr_call ((call *) ec->data);
+                        break;
+
+                case (ELEM_TYPE_BRANCH):
+                        scr_branch ((branch *) ec->data);
+                        break;
+
+                /* in case it is a set element, just add the symbol element
+                 * to the global namespace
+                 */
+                case (ELEM_TYPE_SET):
+                        gl_ns = scr_ns_add (gl_ns, (sym_elem *) ec->data);
+                        break;
+
+                /* should never happen
+                 */
+                default:
+                        break;
+                }
+        }
+
+        return;
+}
+
+
+/* scr_call
+ *
+ * make a call, just like et did when he phoned home. well, not really, but
+ * quite similar
+ *
+ * return in any case
+ */
+
+static void
+scr_call (call *c)
+{
+        fnc_handler     f_h;
+
+        /* nothing to execute today, baby
+         */
+        if (c == NULL || c->name == NULL)
+                return;
+
+        f_h = fnc_find (gl_fnc, c->name);
+
+        /* no function found or nop -> return
+         */
+        if (f_h == NULL)
+                return;
+
+        (void) f_h (c->parameters);
+
+        return;
+}
+
+
+static void
+scr_branch (branch * br)
+{
+        if (cond_verify (br->cond) == 1) {
+                scr_elem_exec (br->b_true);
+        } else {
+                scr_elem_exec (br->b_false);
+        }
+
+        return;
+}
+
+
+sym_elem **
+scr_ns_add (sym_elem **ns, sym_elem *elem)
+{
+        return (sym_elem_add (ns, elem));
+}
+
+
+int
+scr_exec (char *script)
+{
+        element **      scr;
+
+        scr = cp_compile (script, strlen (script));
+        if (scr == NULL)
+                return (0);
+
+        scr_elem_exec (scr);
+
+        elem_list_free (scr);
+
+        return (1);
+}
+
+
+element **
+scr_compile (char *script)
+{
+        element **      scr = NULL;
+
+        if (script != NULL)
+                scr = cp_compile (script, strlen (script));
+
+        return (scr);
+}
+
+
diff --git a/other/burneye/src/conf/tmp/script.h b/other/burneye/src/conf/tmp/script.h
new file mode 100644
index 0000000..7235218
--- /dev/null
+++ b/other/burneye/src/conf/tmp/script.h
@@ -0,0 +1,50 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * scripting capabilities
+ */
+
+#ifndef FNX_SCRIPT_H
+#define FNX_SCRIPT_H
+
+#include "element.h"
+#include "symbol.h"
+
+
+/* scr_exec
+ *
+ * compile and execute a script pointed to by `script'. after execution,
+ * free the compiled script
+ *
+ * return 1 if the execution was successful (ie compilation succeeded)
+ * return 0 on error (compilation/interpreter failed)
+ */
+
+int     scr_exec (char *script);
+
+
+/* scr_ns_add
+ *
+ * add a symbol element `elem' to the namespace pointed to by `ns'
+ *
+ * return pointer to modified namespace
+ */
+
+sym_elem **     scr_ns_add (sym_elem **ns, sym_elem *elem);
+
+
+/* scr_compile
+ *
+ * compile a script pointed to by `script'
+ *
+ * return a pointer to the readily compiled parse tree on success
+ * return NULL on failure
+ */
+
+element **      scr_compile (char *script);
+
+
+#endif
+
+
diff --git a/other/burneye/src/conf/tmp/script1 b/other/burneye/src/conf/tmp/script1
new file mode 100644
index 0000000..dcc359e
--- /dev/null
+++ b/other/burneye/src/conf/tmp/script1
@@ -0,0 +1,16 @@
+{
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+
+        net.icmp.send ( forked = "yes" )
+
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+}
diff --git a/other/burneye/src/conf/tmp/script2 b/other/burneye/src/conf/tmp/script2
new file mode 100644
index 0000000..a7d8e0a
--- /dev/null
+++ b/other/burneye/src/conf/tmp/script2
@@ -0,0 +1,6218 @@
+{
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+        net.icmp.send ( forked = "yes" )
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+}
diff --git a/other/burneye/src/conf/tmp/script3 b/other/burneye/src/conf/tmp/script3
new file mode 100644
index 0000000..687d4a5
--- /dev/null
+++ b/other/burneye/src/conf/tmp/script3
@@ -0,0 +1,19 @@
+{
+        net.icmp.sendrate = "25"
+        net.icmp.packetsize = "650"
+
+        net.icmp.send ( forked = "yes" )
+
+        if (net.icmp.packetsize >= "600") {
+                if (net.icmp.sendrate >= "20") {
+                } else {
+                        net.msg ( node = "$masternode" content = "too fast" )
+                }
+        } else {
+                net.msg ( node = "$masternode" content = "done" )
+                net.msg ( node = "$self" content = "foo" )
+        }
+
+        havoc ( )
+        shutdown ( node = "self" )
+}
diff --git a/other/burneye/src/conf/tmp/script4 b/other/burneye/src/conf/tmp/script4
new file mode 100644
index 0000000..334d728
--- /dev/null
+++ b/other/burneye/src/conf/tmp/script4
@@ -0,0 +1,3 @@
+{
+        nop ( )
+}
diff --git a/other/burneye/src/conf/tmp/symbol.c b/other/burneye/src/conf/tmp/symbol.c
new file mode 100644
index 0000000..b469fd4
--- /dev/null
+++ b/other/burneye/src/conf/tmp/symbol.c
@@ -0,0 +1,299 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * symbol management routines
+ */
+
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include "../../shared/common.h"
+#include "symbol.h"
+
+static int              sym_count (sym_elem **tab);
+static sym_elem *       sym_elem_bykey (sym_elem **tab, char *key);
+static sym_elem **      sym_elem_remove (sym_elem **tab, sym_elem *se);
+
+
+/* sym_count
+ *
+ * count the number of elements within the symbol table pointed to by `tab'
+ *
+ * return the number of entries
+ */
+
+static int
+sym_count (sym_elem **tab)
+{
+        int     count;
+
+        if (tab == NULL)
+                return (0);
+
+        for (count = 0 ; tab[count] != NULL ; ++count)
+                ;
+
+        return (count);
+}
+
+
+/* sym_elem_bykey
+ *
+ * search the symbol table for a structure element which matches the key value
+ * of `key'. if `key' is NULL return the first element.
+ *
+ * return pointer to first found element on success
+ * return NULL if element was not found
+ */
+
+static sym_elem *
+sym_elem_bykey (sym_elem **tab, char *key)
+{
+        int             walker;
+
+        if (tab == NULL)
+                return (NULL);
+
+        if (key == NULL)
+                return (tab[0]);
+
+        for (walker = 0 ; tab[walker] != NULL ; ++walker) {
+                if (strcasecmp (tab[walker]->key, key) == 0)
+                        return (tab[walker]);
+        }
+
+        return (NULL);
+}
+
+
+/* sym_elem_remove
+ *
+ * remove an element pointed to by `se' from the symbol table pointed to by
+ * `tab'
+ *
+ * return in any case
+ */
+
+static sym_elem **
+sym_elem_remove (sym_elem **tab, sym_elem *se)
+{
+        int     walker;
+
+        if (tab == NULL)
+                return (NULL);
+
+        for (walker = 0 ; tab != NULL && tab[walker] != NULL ;) {
+                if (tab[walker] == se) {
+                        sym_elem_free (se);
+
+                        memmove (&tab[walker], &tab[walker + 1],
+                                (sym_count (&tab[walker + 1]) + 1) *
+                                (sizeof (sym_elem *)));
+
+                        tab = xrealloc (tab, (sym_count (tab) + 1) *
+                                sizeof (sym_elem *));
+                        tab[sym_count (tab)] = NULL;
+                } else {
+                        ++walker;
+                }
+        }
+
+        return (tab);
+}
+
+
+char *
+sym_subst (sym_elem **stab, char *str)
+{
+        int     var_count = 0;  /* variable-in-str counter */
+        char *  stp_p;          /* step pointer */
+        char *  new = NULL;     /* created string */
+
+        if (str == NULL)
+                return (NULL);
+
+        /* count variables
+         */
+        for (stp_p = str ; *stp_p != '\x00' ; ++stp_p) {
+                if (*stp_p == '$')
+                        var_count += 1;
+        }
+
+        /* if string doesn't contain anything to substitute, just return a copy
+         */
+        if (var_count == 0)
+                return (xstrdup (str));
+
+        for (stp_p = str ; *stp_p != '\x00' ; ++stp_p) {
+                if (*stp_p == '$') {
+                        int     n;
+                        char    var_name[256];
+                        char *  var_content = NULL;
+
+                        memset (var_name, '\x00', sizeof (var_name));
+
+                        /* extract variable name
+                         */
+                        for (n = 1 ; isalnum (stp_p[n]) != 0 ; ++n) {
+                                var_name[n - 1] = stp_p[n];
+                        }
+                        stp_p += (n - 1);
+                        if (strlen (var_name) > 0)
+                                var_content = (char *) sym_resolve (stab, var_name);
+
+                        if (var_content != NULL)
+                                alloccat (&new, var_content);
+                } else {
+                        int     nv_len; /* no variable length */
+
+                        for (nv_len = 1 ; stp_p[nv_len] != '$' &&
+                                stp_p[nv_len] != '\x00' ; ++nv_len)
+                                ;
+                        allocncat (&new, stp_p, nv_len);
+                        stp_p += (nv_len - 1);
+                }
+        }
+
+        return (new);
+}
+
+
+void
+sym_elem_free (sym_elem *se)
+{
+        free (se->key);
+        free (se->value);
+        free (se);
+
+        return;
+}
+
+
+sym_elem *
+sym_elem_create (char *key, char *value)
+{
+        sym_elem *      new = xcalloc (1, sizeof (sym_elem));
+
+        new->key = key;
+        new->value = value;
+
+        return (new);
+}
+
+
+sym_elem **
+sym_elem_add (sym_elem **tab, sym_elem *elem)
+{
+        int             count;
+
+
+        /* if table is empty or the symbol is not within table
+         */
+        if (tab == NULL || sym_resolve (tab, elem->key) == NULL) {
+                count = sym_count (tab);
+                tab = xrealloc (tab, sizeof (sym_elem *) * (count + 2));
+                tab[count] = elem;
+                tab[count + 1] = NULL;
+        } else {
+                sym_elem *      elem_dupe;
+
+                /* find element, then free the old data, overwritting it with
+                 * the new value
+                 */
+                elem_dupe = sym_elem_bykey (tab, elem->key);
+                free (elem_dupe->key);
+                free (elem_dupe->value);
+                elem_dupe->key = elem->key;
+                elem_dupe->value = elem->value;
+                free (elem);
+        }
+
+        return (tab);
+}
+
+
+sym_elem **
+sym_remove (sym_elem **tab, char *key)
+{
+        sym_elem *      se;
+
+        /* if there is nothing to remove, return at once
+         */
+
+        if (tab == NULL)
+                return (NULL);
+
+        /* if tab is not NULL but no element is within the table
+         * then just free the table
+         */
+        se = sym_elem_bykey (tab, key);
+        if (se == NULL) {
+                if (sym_count (tab) == 0) {
+                        free (tab);
+                        tab = NULL;
+                }
+
+                return (tab);
+        }
+
+        tab = sym_elem_remove (tab, se);
+
+        return (tab);
+}
+
+
+sym_elem **
+sym_add (sym_elem **tab, char *key, char *value)
+{
+        sym_elem *      new;
+
+
+        if (key == NULL)
+                return (tab);
+
+        if (value == NULL) {
+                tab = sym_remove (tab, key);
+                return (tab);
+        }
+
+        new = sym_elem_create (key, value);
+        tab = sym_elem_add (tab, new);
+
+        return (tab);
+}
+
+
+const char *
+sym_resolve (sym_elem **stab, char *key)
+{
+        int             walker;
+
+        if (stab == NULL || key == NULL)
+                return (NULL);
+
+        for (walker = 0 ; stab[walker] != NULL ; ++walker) {
+                if (strcasecmp (stab[walker]->key, key) == 0)
+                        return (stab[walker]->value);
+        }
+
+        return (NULL);
+}
+
+
+void
+sym_free (sym_elem **stab)
+{
+        if (stab == NULL)
+                return;
+
+        /* while there are elements free the first element
+         */
+        while (stab != NULL) {
+                stab = sym_remove (stab, NULL);
+        }
+
+        return;
+}
+
+
diff --git a/other/burneye/src/conf/tmp/symbol.h b/other/burneye/src/conf/tmp/symbol.h
new file mode 100644
index 0000000..fd765e9
--- /dev/null
+++ b/other/burneye/src/conf/tmp/symbol.h
@@ -0,0 +1,108 @@
+/* fornax - distributed network
+ *
+ * by team teso
+ *
+ * symbol management include file
+ */
+
+#ifndef FNX_SYMBOL_H
+#define FNX_SYMBOL_H
+
+typedef struct  sym_elem {
+        char            *key;   /* string of variable name */
+        char            *value; /* NULL or string */
+} sym_elem;
+
+
+/* sym_subst
+ *
+ * substitute symbol information contained in string `str' using the global
+ * symbol table
+ *
+ * return newly allocated char pointer
+ */
+
+char *  sym_subst (sym_elem **stab, char *str);
+
+
+/* sym_elem_create
+ *
+ * symbol element constructor. create a new symbol element and set values
+ * to `key' and `value'
+ *
+ * return pointer to new sym_elem structure
+ */
+
+sym_elem *      sym_elem_create (char *key, char *value);
+
+
+/* sym_elem_free
+ *
+ * free symbol element pointed to by `se'
+ *
+ * return in any case
+ */
+
+void    sym_elem_free (sym_elem *se);
+
+
+/* sym_elem_add
+ *
+ * add a symbol element pointed to by `elem' to the symbol table pointed to
+ * by `tab'. if the table doesn't exist yet, just create it
+ *
+ * return in any case
+ */
+
+sym_elem **     sym_elem_add (sym_elem **tab, sym_elem *elem);
+
+
+/* sym_remove
+ *
+ * remove a symbol with the key `key' from the symbol table pointed to by
+ * `tab'
+ *
+ * return in any case
+ */
+
+sym_elem **     sym_remove (sym_elem **tab, char *key);
+
+
+/* sym_add
+ *
+ * create a new symbol table entry in the table `tab'. if `tab' is empty or
+ * is a NULL pointer create a new table. add the key `key' with the value
+ * `value' to this table. if it already exists within the table overwrite it.
+ * if `value' is a NULL pointer remove the element from the table, freeing
+ * the table if it was the last symbol entry.
+ *
+ * return pointer to modified list
+ */
+
+sym_elem **     sym_add (sym_elem **tab, char *key, char *value);
+
+
+/* sym_resolve
+ *
+ * find the character value associated to the key `key' in the symbol table
+ * `stab'
+ *
+ * return pointer to ASCIIZ value on success
+ * return NULL on failure
+ */
+
+const char *    sym_resolve (sym_elem **stab, char *key);
+
+
+/* sym_free
+ *
+ * free a symbol table pointed to by `stab'
+ *
+ * return in any case
+ */
+
+void    sym_free (sym_elem **stab);
+
+
+#endif
+
diff --git a/other/burneye/src/debug/memdump.c b/other/burneye/src/debug/memdump.c
new file mode 100644
index 0000000..3215d20
--- /dev/null
+++ b/other/burneye/src/debug/memdump.c
@@ -0,0 +1,249 @@
+/* memory dump utility
+ * -scut
+ */
+
+#include <sys/types.h>
+#include <sys/ptrace.h>
+#include <sys/wait.h>
+#include <sys/user.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <libgen.h>     /* basename */
+
+
+void
+hexdump (unsigned char *data, unsigned int amount);
+
+
+int
+main (int argc, char *argv[])
+{
+        pid_t                   fpid;           /* child pid, gets ptraced */
+        char *                  argv0;
+        struct user             regs;           /* PTRACE pulled registers */
+        unsigned long int       addr,           /* segment start address */
+                                addr_end,       /* segment end address */
+                                len;            /* length of segment */
+        unsigned long int       addr_walker,    /* walker to dump memory */
+                                eip;            /* current childs eip */
+
+        /* array to temporarily store data into */
+        unsigned char           data_saved[sizeof (unsigned long int)];
+
+        /* file to read mapping information */
+        FILE *                  map_f;          /* /proc/<pid>/maps stream */
+        unsigned char           map_line[256];  /* one line each from map */
+
+        /* data for the dump files */
+        FILE *                  dump_f;         /* stream */
+        char                    dump_name[64];  /* filename buffer */
+
+
+        if (argc < 3 || sscanf (argv[1], "0x%lx", &eip) != 1) {
+                printf ("usage: %s <eip> <argv0 [argv1 [...]]>\n\n", argv[0]);
+                printf ("will run 'argv0' as program with given arguments, "
+                                "until 'eip' is reached, then\n"
+                        "dumping 'len' bytes from 'addr'.\n\n"
+                        "example: %s 0x08049014 0x08048000 0x100 /bin/ls "
+                                "-l\n\n", argv[0]);
+
+                exit (EXIT_FAILURE);
+        }
+
+        argv0 = argv[2];
+
+        fpid = fork ();
+        if (fpid < 0) {
+                perror ("fork");
+                exit (EXIT_FAILURE);
+        }
+        if (fpid == 0) {        /* child */
+                if (ptrace (PTRACE_TRACEME, 0, NULL, NULL) != 0) {
+                        perror ("ptrace PTRACE_TRACEME");
+                        exit (EXIT_FAILURE);
+                }
+                fprintf (stderr, "  child: TRACEME set\n");
+
+                fprintf (stderr, "  child: executing: %s\n", argv[2]);
+                close (1);
+                dup2 (2, 1);
+                execve (argv[2], &argv[2], NULL);
+
+                /* failed ? */
+                perror ("execve");
+                exit (EXIT_FAILURE);
+        }
+
+        wait (NULL);
+
+        memset (&regs, 0, sizeof (regs));
+
+        if (ptrace (PTRACE_GETREGS, fpid, NULL, &regs) < 0) {
+                perror ("ptrace PTRACE_GETREGS");
+                exit (EXIT_FAILURE);
+        }
+        fprintf (stderr, "[0x%08lx] first stop\n", regs.regs.eip);
+
+        /* now single step until given eip is reached */
+        do {
+                if (ptrace (PTRACE_SINGLESTEP, fpid, NULL, NULL) < 0) {
+                        perror ("ptrace PTRACE_SINGLESTEP");
+                        exit (EXIT_FAILURE);
+                }
+                wait (NULL);
+
+                memset (&regs, 0, sizeof (regs));
+                if (ptrace (PTRACE_GETREGS, fpid, NULL, &regs) < 0) {
+                        perror ("ptrace PTRACE_GETREGS");
+                        exit (EXIT_FAILURE);
+                }
+        } while (regs.regs.eip != eip);
+
+        fprintf (stderr, "MEMDUMP: eip @ 0x%08lx, dumping...\n", eip);
+
+        snprintf (dump_name, sizeof (dump_name), "%s.regs",
+                basename (argv0));
+        dump_name[sizeof (dump_name) - 1] = '\0';
+        dump_f = fopen (dump_name, "w");
+        if (dump_f == NULL) {
+                perror ("fopen dumpfile regs");
+                exit (EXIT_FAILURE);
+        }
+        fprintf (dump_f, "eax = 0x%08lx\n", regs.regs.eax);
+        fprintf (dump_f, "ebx = 0x%08lx\n", regs.regs.ebx);
+        fprintf (dump_f, "ecx = 0x%08lx\n", regs.regs.ecx);
+        fprintf (dump_f, "edx = 0x%08lx\n", regs.regs.edx);
+        fprintf (dump_f, "esi = 0x%08lx\n", regs.regs.esi);
+        fprintf (dump_f, "edi = 0x%08lx\n", regs.regs.edi);
+        fprintf (dump_f, "ebp = 0x%08lx\n", regs.regs.ebp);
+        fprintf (dump_f, "esp = 0x%08lx\n", regs.regs.esp);
+        fprintf (dump_f, "eflags = 0x%08lx\n", regs.regs.eflags);
+        fprintf (dump_f, "xcs = 0x%08lx\n", regs.regs.xcs);
+        fprintf (dump_f, "xds = 0x%08lx\n", regs.regs.xds);
+        fprintf (dump_f, "xes = 0x%08lx\n", regs.regs.xes);
+        fprintf (dump_f, "xss = 0x%08lx\n", regs.regs.xss);
+        fclose (dump_f);
+
+        snprintf (map_line, sizeof (map_line), "/proc/%d/maps", fpid);
+        map_line[sizeof (map_line) -  1] = '\0';
+        map_f = fopen (map_line, "r");
+        if (map_f == NULL) {
+                perror ("fopen map-file");
+
+                exit (EXIT_FAILURE);
+        }
+
+        while (fgets (map_line, sizeof (map_line), map_f) != NULL) {
+                char            map_perm[8];
+
+                if (sscanf (map_line, "%08lx-%08lx %7[rwxp-] ",
+                        &addr, &addr_end, map_perm) != 3)
+                {
+                        perror ("invalid map-line");
+
+                        exit (EXIT_FAILURE);
+                }
+                if (addr_end < addr) {
+                        fprintf (stderr, "sanity required, not so: "
+                                "addr = 0x%08lx, addr_end = 0x%08lx",
+                                addr, addr_end);
+
+                        exit (EXIT_FAILURE);
+                }
+                len = addr_end - addr;
+                map_perm[sizeof (map_perm) - 1] = '\0'; /* ;-) */
+
+                fprintf (stderr, "MEMDUMP: -> 0x%08lx (0x%08lx bytes, "
+                        "perm %s)\n", addr, len, map_perm);
+
+                snprintf (dump_name, sizeof (dump_name),
+                        "%s.0x%08lx.0x%08lx.%s",
+                        basename (argv0), addr, len, map_perm);
+                dump_name[sizeof (dump_name) - 1] = '\0';
+                dump_f = fopen (dump_name, "wb");
+                if (dump_f == NULL) {
+                        perror ("fopen dumpfile");
+
+                        exit (EXIT_FAILURE);
+                }
+
+                /* save data, assuming addr is page aligned */
+                for (addr_walker = 0 ; addr_walker < len ;
+                        addr_walker += sizeof (data_saved))
+                {
+                        errno = 0;
+
+                        *((unsigned long int *) &data_saved[0]) =
+                                ptrace (PTRACE_PEEKDATA, fpid,
+                                        addr + addr_walker, NULL);
+
+                        if (errno == 0 && fwrite (&data_saved[0], 1, 4,
+                                dump_f) != 4)
+                        {
+                                perror ("fwrite dumpfile");
+
+                                exit (EXIT_FAILURE);
+                        } else if (errno != 0) {
+                                fprintf (stderr,
+                                        "[0x%08lx] invalid PTRACE_PEEKDATA\n",
+                                        addr + addr_walker);
+
+                                exit (EXIT_FAILURE);
+                        }
+                }
+
+                fclose (dump_f);
+        }
+        fclose (map_f);
+
+        if (ptrace (PTRACE_DETACH, fpid, NULL, NULL) < 0) {
+                perror ("ptrace PTRACE_DETACH");
+                exit (EXIT_FAILURE);
+        }
+
+        fprintf (stderr, "MEMDUMP: success. terminating.\n");
+        exit (EXIT_SUCCESS);
+}
+
+
+
+void
+hexdump (unsigned char *data, unsigned int amount)
+{
+        unsigned int    dp, p;  /* data pointer */
+        const char      trans[] =
+                "................................ !\"#$%&'()*+,-./0123456789"
+                ":;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklm"
+                "nopqrstuvwxyz{|}~...................................."
+                "....................................................."
+                "........................................";
+
+        for (dp = 1; dp <= amount; dp++) {
+                printf ("%02x ", data[dp-1]);
+                if ((dp % 8) == 0)
+                        printf (" ");
+                if ((dp % 16) == 0) {
+                        printf ("| ");
+                        p = dp;
+                        for (dp -= 16; dp < p; dp++)
+                                printf ("%c", trans[data[dp]]);
+                        printf ("\n");
+                }
+        }
+        if ((amount % 16) != 0) {
+                p = dp = 16 - (amount % 16);
+                for (dp = p; dp > 0; dp--) {
+                        printf ("   ");
+                        if (((dp % 8) == 0) && (p != 8))
+                                printf (" ");
+                }
+                printf (" | ");
+                for (dp = (amount - (16 - p)); dp < amount; dp++)
+                        printf ("%c", trans[data[dp]]);
+        }
+        printf ("\n");
+
+        return;
+}
diff --git a/other/burneye/src/debug/memdump.c.old b/other/burneye/src/debug/memdump.c.old
new file mode 100644
index 0000000..eda7963
--- /dev/null
+++ b/other/burneye/src/debug/memdump.c.old
@@ -0,0 +1,164 @@
+
+#include <sys/types.h>
+#include <sys/ptrace.h>
+#include <sys/wait.h>
+#include <sys/user.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+void
+hexdump (unsigned char *data, unsigned int amount);
+
+int
+main (int argc, char *argv[])
+{
+        pid_t                   fpid;
+        struct user             regs;
+        unsigned long int       addr,
+                                len;
+        unsigned long int       addr_walker,
+                                eip;
+        unsigned char           data_saved[256];
+
+        if (argc < 5 || sscanf (argv[1], "0x%lx", &eip) != 1 ||
+                sscanf (argv[2], "0x%lx", &addr) != 1 ||
+                sscanf (argv[3], "0x%lx", &len) != 1)
+        {
+                printf ("usage: %s <eip> <addr> <len> <argv0 [argv1 [...]]>\n\n", argv[0]);
+                printf ("will run 'argv0' as program with given arguments, until 'eip' is reached, then\n"
+                        "dumping 'len' bytes from 'addr'.\n\n"
+                        "example: %s 0x08049014 0x08048000 0x100 /bin/ls -l\n\n", argv[0]);
+                exit (EXIT_FAILURE);
+        }
+
+        fpid = fork ();
+        if (fpid < 0) {
+                perror ("fork");
+                exit (EXIT_FAILURE);
+        }
+        if (fpid == 0) {        /* child */
+                if (ptrace (PTRACE_TRACEME, 0, NULL, NULL) != 0) {
+                        perror ("ptrace PTRACE_TRACEME");
+                        exit (EXIT_FAILURE);
+                }
+                fprintf (stderr, "  child: TRACEME set\n");
+
+                fprintf (stderr, "  child: executing: %s\n", argv[4]);
+                close (1);
+                dup2 (2, 1);
+                execve (argv[4], &argv[4], NULL);
+
+                /* failed ? */
+                perror ("execve");
+                exit (EXIT_FAILURE);
+        }
+
+#if 0
+        if (ptrace (PTRACE_ATTACH, fpid, NULL, NULL) < 0) {
+                perror ("ptrace");
+                exit (EXIT_FAILURE);
+        }
+        fprintf (stderr, "attached to pid %d (from us, the parent, pid %d)\n", fpid, getpid ());
+#endif
+//      sleep (1);
+
+#if 0
+        /* trace until trap'ed */
+        if (ptrace (PTRACE_CONT, fpid, NULL, NULL) < 0) {
+                perror ("ptrace PTRACE_CONT");
+                exit (EXIT_FAILURE);
+        }
+#endif
+        fprintf (stderr, "it should execve now\n");
+        sleep (1);
+
+        memset (&regs, 0, sizeof (regs));
+
+        if (ptrace (PTRACE_GETREGS, fpid, NULL, &regs) < 0) {
+                perror ("ptrace PTRACE_GETREGS");
+                exit (EXIT_FAILURE);
+        }
+        fprintf (stderr, "[0x%08lx] first stop\n", regs.regs.eip);
+
+        /* now single step until given eip is reached */
+        do {
+                if (ptrace (PTRACE_SINGLESTEP, fpid, NULL, NULL) < 0) {
+                        perror ("ptrace PTRACE_SINGLESTEP");
+                        exit (EXIT_FAILURE);
+                }
+                wait (NULL);
+
+                memset (&regs, 0, sizeof (regs));
+                if (ptrace (PTRACE_GETREGS, fpid, NULL, &regs) < 0) {
+                        perror ("ptrace PTRACE_GETREGS");
+                        exit (EXIT_FAILURE);
+                }
+        } while (regs.regs.eip != eip);
+
+        fprintf (stderr, "hook traped @ 0x%08lx\n", eip);
+        fprintf (stderr, "dumping 0x%lx bytes @ 0x%08lx\n", len, addr);
+
+        /* save data */
+        for (addr_walker = 0 ; addr_walker < len ; ++addr_walker) {
+                errno = 0;
+                *((unsigned long int *) &data_saved[0]) = ptrace (PTRACE_PEEKDATA, fpid,
+                        addr + addr_walker, NULL);
+                if (errno == 0)
+                        write (1, &data_saved[0], 1);
+                else
+                        fprintf (stderr, "- [0x%08lx] invalid PTRACE_PEEKDATA\n",
+                                addr + addr_walker), _exit(1);
+        }
+//      hexdump (data_saved, sizeof (data_saved));
+
+        if (ptrace (PTRACE_DETACH, fpid, NULL, NULL) < 0) {
+                perror ("ptrace PTRACE_DETACH");
+                exit (EXIT_FAILURE);
+        }
+
+        fprintf (stderr, "success. terminating.\n");
+        exit (EXIT_SUCCESS);
+}
+
+
+
+void
+hexdump (unsigned char *data, unsigned int amount)
+{
+        unsigned int    dp, p;  /* data pointer */
+        const char      trans[] =
+                "................................ !\"#$%&'()*+,-./0123456789"
+                ":;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklm"
+                "nopqrstuvwxyz{|}~...................................."
+                "....................................................."
+                "........................................";
+
+        for (dp = 1; dp <= amount; dp++) {
+                printf ("%02x ", data[dp-1]);
+                if ((dp % 8) == 0)
+                        printf (" ");
+                if ((dp % 16) == 0) {
+                        printf ("| ");
+                        p = dp;
+                        for (dp -= 16; dp < p; dp++)
+                                printf ("%c", trans[data[dp]]);
+                        printf ("\n");
+                }
+        }
+        if ((amount % 16) != 0) {
+                p = dp = 16 - (amount % 16);
+                for (dp = p; dp > 0; dp--) {
+                        printf ("   ");
+                        if (((dp % 8) == 0) && (p != 8))
+                                printf (" ");
+                }
+                printf (" | ");
+                for (dp = (amount - (16 - p)); dp < amount; dp++)
+                        printf ("%c", trans[data[dp]]);
+        }
+        printf ("\n");
+
+        return;
+}
diff --git a/other/burneye/src/debug/ptrace-legit b/other/burneye/src/debug/ptrace-legit
new file mode 100644
index 0000000..85bc5a1
--- /dev/null
+++ b/other/burneye/src/debug/ptrace-legit
diff --git a/other/burneye/src/debug/ptrace-legit.c b/other/burneye/src/debug/ptrace-legit.c
new file mode 100644
index 0000000..a6c53d7
--- /dev/null
+++ b/other/burneye/src/debug/ptrace-legit.c
@@ -0,0 +1,143 @@
+/* -scutstyle */
+
+#include <sys/types.h>
+#include <sys/ptrace.h>
+#include <sys/wait.h>
+#include <sys/user.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+void
+hexdump (unsigned char *data, unsigned int amount);
+
+unsigned char   shellcode[] = "\x90\x90\xcc\x73";
+
+int
+main (int argc, char *argv[])
+{
+        pid_t                   cpid;
+        struct user             regs;
+        unsigned long int       safed_eip;
+        unsigned long int       addr,
+                                addr_walker;
+        unsigned char           data_saved[256];
+
+
+#if 1
+        if (argc != 2 || sscanf (argv[1], "%d", &cpid) != 1) {
+                printf ("usage: %s <pid>\n", argv[0]);
+                exit (EXIT_FAILURE);
+        }
+#else
+        cpid = getppid();
+#endif
+
+        printf ("pid = %d\n", cpid);
+
+        printf ("exploiting\n\n");
+
+        if (ptrace (PTRACE_ATTACH, cpid, NULL, NULL) < 0) {
+                perror ("ptrace");
+                exit (EXIT_FAILURE);
+        }
+
+        /* save data */
+        addr = 0xbffff010;
+        for (addr_walker = 0 ; addr_walker < 256 ; ++addr_walker) {
+                data_saved[addr_walker] = ptrace (PTRACE_PEEKDATA, cpid,
+                        addr + addr_walker, NULL);
+        }
+        hexdump (data_saved, sizeof (data_saved));
+
+        /* write */
+        for (addr_walker = 0 ; addr_walker < sizeof (shellcode) ;
+                ++addr_walker)
+        {
+                ptrace (PTRACE_POKEDATA, cpid, addr + addr_walker,
+                        shellcode[addr_walker] & 0xff);
+        }
+
+        /* redirect eip */
+        memset (&regs, 0, sizeof (regs));
+        if (ptrace (PTRACE_GETREGS, cpid, NULL, &regs) < 0) {
+                perror ("ptrace PTRACE_GETREGS");
+                exit (EXIT_FAILURE);
+        }
+        // write eip */
+        safed_eip = regs.regs.eip;
+        regs.regs.eip = 0xbffff010;
+        if (ptrace (PTRACE_SETREGS, cpid, NULL, &regs) < 0) {
+                perror ("ptrace PTRACE_GETREGS");
+                exit (EXIT_FAILURE);
+        }
+
+        if (ptrace (PTRACE_CONT, cpid, NULL, NULL) < 0) {
+                perror ("ptrace PTRACE_CONT");
+                exit (EXIT_FAILURE);
+        }
+
+        wait (NULL);
+        printf ("detrap\n");
+
+        /* restore */
+        for (addr_walker = 0 ; addr_walker < 256 ; ++addr_walker) {
+                ptrace (PTRACE_POKEDATA, cpid, addr + addr_walker,
+                        data_saved[addr_walker] & 0xff);
+        }
+
+        /* restore regs */
+        regs.regs.eip = safed_eip;
+        if (ptrace (PTRACE_SETREGS, cpid, NULL, &regs) < 0) {
+                perror ("ptrace PTRACE_GETREGS");
+                exit (EXIT_FAILURE);
+        }
+
+        if (ptrace (PTRACE_DETACH, cpid, NULL, NULL) < 0) {
+                perror ("ptrace PTRACE_DETACH");
+                exit (EXIT_FAILURE);
+        }
+
+        exit (EXIT_SUCCESS);
+}
+
+
+
+void
+hexdump (unsigned char *data, unsigned int amount)
+{
+        unsigned int    dp, p;  /* data pointer */
+        const char      trans[] =
+                "................................ !\"#$%&'()*+,-./0123456789"
+                ":;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklm"
+                "nopqrstuvwxyz{|}~...................................."
+                "....................................................."
+                "........................................";
+
+        for (dp = 1; dp <= amount; dp++) {
+                printf ("%02x ", data[dp-1]);
+                if ((dp % 8) == 0)
+                        printf (" ");
+                if ((dp % 16) == 0) {
+                        printf ("| ");
+                        p = dp;
+                        for (dp -= 16; dp < p; dp++)
+                                printf ("%c", trans[data[dp]]);
+                        printf ("\n");
+                }
+        }
+        if ((amount % 16) != 0) {
+                p = dp = 16 - (amount % 16);
+                for (dp = p; dp > 0; dp--) {
+                        printf ("   ");
+                        if (((dp % 8) == 0) && (p != 8))
+                                printf (" ");
+                }
+                printf (" | ");
+                for (dp = (amount - (16 - p)); dp < amount; dp++)
+                        printf ("%c", trans[data[dp]]);
+        }
+        printf ("\n");
+
+        return;
+}
diff --git a/other/burneye/src/descr.be b/other/burneye/src/descr.be
new file mode 100644
index 0000000..da15674
--- /dev/null
+++ b/other/burneye/src/descr.be
@@ -0,0 +1,36 @@
+# burneye protection description file
+#
+# comments must have "^#.*" match, i.e. no end of line comments
+
+
+##################
+# stub description
+
+stubfile = "..."
+
+# first encryption layer (glfsr)
+stubcrypt0_at = 0x........
+stubcrypt0_len = 0x........
+
+
+#################
+# hostify options
+# XXX: allow multiple fingerprints here
+
+fingerprint = { file "foofile" | block "..." }
+fingerprint_tolerance = 2
+
+
+##########################
+# wrapped file description
+
+infile = "input"
+wrapfile = "output"
+
+function_file = "..."
+function_default { "default", encryption-mode }
+
+# individual function definitions
+function { "name", 0xvaddr, 0xlen, encryption-mode }
+
+
diff --git a/other/burneye/src/foo b/other/burneye/src/foo
new file mode 100644
index 0000000..8d9956b
--- /dev/null
+++ b/other/burneye/src/foo
@@ -0,0 +1,11 @@
+enable sysbase
+enable procpci
+enable proccpu
+enable procroute
+begin
+0b8ea7a8b01a586245cdc9fcba674445
+1e536e073cacc75619f73ef4557d762c
+fb77cc77210c4d2a5d18cb1934d3b989
+daadfa2cccd905030dc54f66464c466a
+b9c96362cc5d3866
+end
diff --git a/other/burneye/src/ls b/other/burneye/src/ls
new file mode 100644
index 0000000..0a2c7f2
--- /dev/null
+++ b/other/burneye/src/ls
diff --git a/other/burneye/src/regress.sh b/other/burneye/src/regress.sh
new file mode 100644
index 0000000..2fbf926
--- /dev/null
+++ b/other/burneye/src/regress.sh
@@ -0,0 +1,58 @@
+#!/bin/sh
+
+rm -f date.*.0x* date.*.0x*.hex date.*.0x*.diff date.*.regs
+
+# $entry = ld-linux.so.2 entry point
+entry=`objdump -f /lib/ld-linux.so.2 | \
+        grep "start address" | cut -d ' ' -f3 | \
+        sed "s/0x0000/0x4000/g"`
+
+debug/memdump $entry ./date.eye
+debug/memdump $entry ./date.upx
+
+clear
+
+for file in date.eye.0x*
+do
+        upx_file=`echo $file | sed s/eye/upx/`
+        if [ -f $upx_file ]; then
+                if cmp $file $upx_file
+                then
+                        echo $file, $upx_file are identical
+                else
+                        echo $file, $upx_file are different, analyzing
+
+                        hexdump < $file > $file.hex
+                        hexdump < $upx_file > $upx_file.hex
+                fi
+        else
+                echo "$upx_file does not exist."
+        fi
+done
+
+if ls date.eye.0x*.hex >/dev/null 2>/dev/null
+then
+for file in date.eye.0x*.hex
+do
+        upx_file=`echo $file | sed s/eye/upx/`
+        linecount=`diff -u $file $upx_file | wc | awk '{ print $1 }'`
+        if [ $linecount -gt 20 ]
+        then
+                echo "$file, $upx_file, more than 20 lines different"
+                echo "   dumping to $file.diff"
+                diff -u $file $upx_file > $file.diff
+        else
+                echo "$file, $upx_file, differences:"
+                diff -u $file $upx_file > $file.diff
+        fi
+done
+fi
+
+if cmp date.eye.regs date.upx.regs
+then
+        echo "registers are identical"
+else
+        echo "registers are different (first eye, then upx):"
+        diff -C 0 date.eye.regs date.upx.regs | grep "^!"
+fi
+
diff --git a/other/burneye/src/rstest.c b/other/burneye/src/rstest.c
new file mode 100644
index 0000000..404b865
--- /dev/null
+++ b/other/burneye/src/rstest.c
@@ -0,0 +1,158 @@
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "rs.h"
+
+
+extern unsigned int     KK;
+
+unsigned int
+rs_kkcompute (unsigned int n, unsigned int fix);
+
+void
+rs_trans (unsigned char *buffer, unsigned long int buf_len,
+        unsigned int *trans, unsigned long int trans_len);
+
+void
+rs_detrans (unsigned char *buffer, unsigned long int buf_len,
+        unsigned int *trans, unsigned long int trans_len);
+
+
+int
+main (int argc, char *argv[])
+{
+        int             n;
+        unsigned char   buffer[6144];
+        unsigned int    transform[4096];
+
+
+        memset (buffer, '\0', sizeof (buffer));
+        strcpy (buffer, "This is a test for the Reed Solomon encoder/decoder");
+        printf ("before: %s\n", buffer);
+
+        rs_trans (buffer, strlen (buffer), transform, sizeof (transform) /
+                sizeof (transform[0]));
+        memset (buffer, '\0', sizeof (buffer));
+
+        KK = rs_kkcompute (NN, (36 * 8) / 12 + 1);
+        encode_rs (&transform[0], &transform[KK]);
+
+        srandom (time (NULL));
+        for (n = 0 ; n < 25 ; ++n) {
+                unsigned int    ai;
+
+                do {
+                        ai = random () % KK;
+                } while ((transform[ai] & 0x1000) == 0x1000);
+
+                transform[ai] = (random () & 0x0fff) | 0x1000;
+        }
+        for (n = 0 ; n < KK ; ++n)
+                transform[n] &= ~ 0x1000;
+
+//      printf (" trash: %s\n", buffer);
+        n = eras_dec_rs (transform, NULL, 0);
+
+        rs_detrans (buffer, sizeof (buffer), transform, sizeof (transform) /
+                sizeof (transform[0]));
+        printf ("c (%2d): %s\n", n, buffer);
+
+
+        exit (EXIT_SUCCESS);
+}
+
+
+/* rs_kkcompute
+ *
+ * for our fingerprint deviation method we need to go the reverse way in error
+ * correction. instead of trying to find the optimum signal-noise/correction
+ * ratio, we know exactly how many bytes we want to fix and can guarantee a
+ * perfect reliability for our parity check bits. so this is the function that
+ * computes the correct KK value for `n' symbols, where we want to be able to
+ * fixup up to `fix' symbols.
+ *
+ * return the correct value for KK
+ */
+
+unsigned int
+rs_kkcompute (unsigned int n, unsigned int fix)
+{
+        /* assume sanity of all input values */
+        return (n - (2 * fix));
+}
+
+
+void
+rs_trans (unsigned char *buffer, unsigned long int buf_len,
+        unsigned int *trans, unsigned long int trans_len)
+{
+        unsigned int    n,
+                        t;
+
+
+        memset (trans, '\0', sizeof (trans[0]) * trans_len);
+        if (((((buf_len + 1) * 12) / 8)) > trans_len) {
+                fprintf (stderr, "translation output size too low\n");
+                exit (EXIT_FAILURE);
+        }
+
+        /* 8 to 12 bit expander to use 2^12 galois field */
+        for (n = 0, t = 0 ; n < buf_len ; ++n) {
+                switch (n % 3) {
+                case (0):
+                        trans[t] = buffer[n];
+                        break;
+                case (1):
+                        trans[t] |= (buffer[n] & 0x0f) << 8;
+                        trans[t + 1] = buffer[n] >> 4;
+                        t += 1;
+                        break;
+                case (2):
+                        trans[t] |= buffer[n] << 4;
+                        t += 1;
+                        break;
+                }
+        }
+
+        return;
+}
+
+
+/* and the reverse (12 to 8 bit)
+ */
+void
+rs_detrans (unsigned char *buffer, unsigned long int buf_len,
+        unsigned int *trans, unsigned long int trans_len)
+{
+        unsigned int    n,
+                        t;
+
+
+        memset (buffer, '\0', buf_len);
+
+        if (((trans_len * 12) / 8) > buf_len) {
+                fprintf (stderr, "translation output buffer too low\n");
+                exit (EXIT_FAILURE);
+        }
+
+        for (n = 0, t = 0 ; t < trans_len ; ++t) {
+                switch (t % 2) {
+                case (0):
+                        buffer[n] = trans[t] & 0xff;
+                        buffer[n + 1] = trans[t] >> 8;
+                        n += 1;
+                        break;
+                case (1):
+                        buffer[n] |= (trans[t] & 0x0f) << 4;
+                        buffer[n + 1] = trans[t] >> 4;
+                        n += 2;
+                        break;
+                }
+        }
+
+        return;
+}
+
+
diff --git a/other/burneye/src/stub/Makefile b/other/burneye/src/stub/Makefile
new file mode 100644
index 0000000..1800ab9
--- /dev/null
+++ b/other/burneye/src/stub/Makefile
@@ -0,0 +1,111 @@
+
+ifeq ($(debug),on)
+CFLAGS += -g -ggdb
+DFLAGS += -DDEBUG -DVDEBUG
+ENTRY_POINT = be_entry
+else
+ENTRY_POINT = glent
+endif
+DFLAGS += -DIN_STUB
+
+CFLAGS += -Wall -fconserve-space -Os -fno-builtin $(DFLAGS)
+
+OBJS =  callgate.o cgate.o helper.o init.o stub.o snprintf.o \
+        cipher-glfsr.o cipher-glfsr-c.o cipher-rc4.o cipher-sha1.o \
+        rs.o fingerprint.o
+
+
+# basic targets
+#
+# all = generic stub-only target
+# rel = target when creating real stub
+#
+
+all:    buildtools unlinkstub.bin.h stub.bin.h
+
+
+# clean target
+#
+
+clean:
+        make -C utils clean
+        rm -f *.o *.map *.bin
+        rm -f utils/sstrip
+        rm -f stub-bin stub-bin.lds stub-bin.h
+        rm -f unlinkstub.bin unlinkstub-bin.h
+
+
+# main stub target
+#
+
+stub.bin:       buildtools $(OBJS) stub.lds
+        sed s/entry_point/$(ENTRY_POINT)/ < stub.lds > stub-bin.lds
+        ld -Map stub.map -s -T stub-bin.lds -o stub.bin $(OBJS)
+        rm -f stub-bin.lds
+ifeq ($(rel),on)
+        strip stub.bin
+        utils/sstrip stub.bin
+endif
+
+stub.bin.h:     stub.bin
+        echo "unsigned char     stub_bin[] =" > stub-bin.h
+        utils/hdump < stub.bin >> stub-bin.h
+ifeq ($(debug),on)
+        echo "#define BE_LAYER0_START 0x0" >> stub-bin.h
+        echo "#define BE_LAYER0_FILESTART 0x0" >> stub-bin.h
+        echo "#define BE_LAYER0_SIZE 0x0" >> stub-bin.h
+        echo "#define BE_LAYER0_CONT 0x0" >> stub-bin.h
+else
+        egrep "\.text.+0x.+0x.+cipher-glfsr.o" stub.map | \
+                awk '{ printf ("#define BE_LAYER0_START %s\n", $$2); }' \
+                >> stub-bin.h
+        readelf -l stub.bin | grep LOAD | head -1 | \
+                awk '{ printf ("#define BE_LAYER0_FILESTART (BE_LAYER0_START - %s)\n", $$3); }' \
+                >> stub-bin.h
+        egrep "\.text.+0x.+0x.+cipher-glfsr.o" stub.map | \
+                awk '{ printf ("#define BE_LAYER0_SIZE %s\n", $$3); }' \
+                >> stub-bin.h
+        egrep "be_entry" stub.map | \
+                awk '{ printf ("#define BE_LAYER0_CONT %s\n", $$1); }' \
+                >> stub-bin.h
+endif
+#       utils/sstrip stub.bin
+
+unlinkstub.bin.h:       unlinkstub.bin
+        echo "unsigned char     ul_stub[] =" > unlinkstub-bin.h
+        utils/hdump < unlinkstub.bin >> unlinkstub-bin.h
+
+unlinkstub.bin: unlink_stub.asm
+        nasm -f bin -o unlinkstub.bin unlink_stub.asm
+
+
+# tool target
+#
+
+buildtools:
+        make -C utils all
+
+sstrip: utils/sstrip.c
+        $(CC) -o utils/sstrip -O2 -Wall utils/sstrip.c
+
+hdump:  utils/hdump.c
+        $(CC) -o utils/hdump -O2 -Wall utils/hdump.c
+
+
+# sub object-targets
+#
+cipher-glfsr-c.o:       cipher-glfsr.asm
+        nasm -DCONSERVE_SPACE -f elf -o cipher-glfsr-c.o cipher-glfsr.asm
+
+cipher-glfsr.o: cipher-glfsr.asm
+        nasm $(DFLAGS) -f elf -o cipher-glfsr.o cipher-glfsr.asm
+
+init.o: init.asm
+        nasm $(DFLAGS) -f elf -o init.o init.asm
+
+callgate.o:     callgate.asm
+        nasm -f elf -o callgate.o callgate.asm
+
+lde32.o:        lde32.asm
+        nasm -f elf -o lde32.o lde32.asm
+
diff --git a/other/burneye/src/stub/callgate.asm b/other/burneye/src/stub/callgate.asm
new file mode 100644
index 0000000..2129026
--- /dev/null
+++ b/other/burneye/src/stub/callgate.asm
@@ -0,0 +1,71 @@
+; call gate transition
+
+        GLOBAL  cg_entry
+
+        EXTERN  cg_decrypt
+        EXTERN  cg_find
+
+
+        struc   callgate
+sav0:   resd    1
+sav4:   resd    1
+ra_sav: resd    1
+ar_beg: resd    1
+ar_len: resd    1
+keyptr: resd    1
+        endstruc
+
+; the central call gate jump-point
+;
+; we are called by an encrypted function if we land here. we have to restore
+; its encrypted state, then decrypt it. afterwards we optionally setup a trap
+; return address that will return into a re-encryption function.
+;
+
+; 0x0000: 0x50                          push    %eax    == gate address
+; 0x0001: 0x60                          pusha  
+; 0x0002: 0x9c                          pushf
+; 0x0003: 0xe8 0x00 0x00 0x00 0x00      call    cg_entry
+
+cg_entry:
+;       int     0x03
+        push    eax
+        pusha
+        pushf
+        call    cg_foo
+        ret
+        nop
+        nop
+
+cg_foo:
+        pop     esi
+        sub     esi, 8
+
+        push    esi
+        call    cg_find                 ; in: esi, out: eax = struct *
+        add     esp, dword 4
+
+        ; restore bytes taken by the gate
+        mov     edx, [eax + sav0]
+        mov     [esi], edx
+        mov     edx, [eax + sav4]
+        mov     [esi + 4], edx
+
+        ; save real return address, overwrite with encryption gate addr, yay!
+        mov     edx, [esp + 0x28]
+        mov     [eax + ra_sav], edx
+        mov     [esp + 0x28], dword cg_encryptgate
+
+        ; decrypt the whole encrypted function
+        push    eax
+        call    cg_decrypt
+        add     esp, dword 4
+
+        mov     [esp + 0x24], esi       ; overwrite dummy eax value
+        popf
+        popa
+        ret
+
+cg_encryptgate:
+        ret
+
diff --git a/other/burneye/src/stub/cgate.c b/other/burneye/src/stub/cgate.c
new file mode 100644
index 0000000..1f8bb3f
--- /dev/null
+++ b/other/burneye/src/stub/cgate.c
@@ -0,0 +1,42 @@
+
+#include "include/int80.h"
+#include "include/unistd.h"
+#include "helper.h"
+
+
+typedef struct {
+        unsigned long int       sav0,
+                                sav4;   /* first 8 saved bytes of function */
+        unsigned long int       ra_sav; /* saved return address */
+        unsigned char *         ar_beg; /* begin address of encrypted area */
+        unsigned long int       ar_len; /* length of function */
+        void *                  keyptr; /* key structure pointer */
+} callgate;
+
+
+callgate * cg_find (unsigned long int addr);
+
+void
+cg_decrypt (callgate *cg)
+{
+#ifdef VDEBUG
+        be_printf ("cg_decrypt (0x%08lx, 0x%08lx, %lu)\n", cg->keyptr, cg->ar_beg, cg->ar_len);
+#endif
+}
+
+
+
+callgate sample = {
+        0x01234567, 0x89abcdef,
+        0x00000000,
+        (void *) 0x40404040, 0x00001000,
+        (void *) 0x80808080,
+};
+
+
+callgate *
+cg_find (unsigned long int addr)
+{
+        return (&sample);
+}
+
diff --git a/other/burneye/src/stub/cipher-glfsr-c.c b/other/burneye/src/stub/cipher-glfsr-c.c
new file mode 100644
index 0000000..28d55df
--- /dev/null
+++ b/other/burneye/src/stub/cipher-glfsr-c.c
@@ -0,0 +1,33 @@
+
+
+void
+glfsr_crypt (unsigned char *dst, unsigned char *src,
+        unsigned int len, unsigned int key)
+{
+        int                     n;
+        unsigned long int       state = key,
+                                fillup;
+
+        while (len--) {
+                for (n = 0 ; n < 8 ; ++n) {
+                        fillup = 0;
+
+                        if (state & 0x1) {
+                                state >>= 1;
+                                fillup |= 0x80000000;
+                        } else {
+                                state >>= 1;
+                                state ^= 0xc0000057;
+                        }
+                        fillup >>= 1;
+                }
+                fillup >>= 24;
+                fillup &= 0x000000ff;
+
+                *dst++ = *src++ ^ fillup;
+        }
+
+        return;
+}
+
+
diff --git a/other/burneye/src/stub/cipher-glfsr.asm b/other/burneye/src/stub/cipher-glfsr.asm
new file mode 100644
index 0000000..7b4871f
--- /dev/null
+++ b/other/burneye/src/stub/cipher-glfsr.asm
@@ -0,0 +1,79 @@
+; minimalistic size-optimized cipher 'glfsr'
+;
+; using one single 32 bit galois linear feedback shifting register with a
+; fixed tap sequence. can be broken easily but its better than the
+; standard xor cipher and it looks neat, takes only ~25 bytes of code ;)
+
+%ifdef IN_STUB
+        GLOBAL  glent
+
+glen:   dd      0x00000000
+gkey:   dd      0x00000000
+gnent:  dd      0x00000000
+
+        db      'TEEE burneye - TESO ELF Encryption Engine'
+
+glent:; int3
+        push    dword [gnent]
+        pushf
+        pusha
+        mov     ecx, [glen]
+        jmp     hunk
+hret:   pop     esi
+        mov     edi, esi
+        mov     ebx, [gkey]
+
+        or      ebx, ebx        ; zero key = skip, used for SEAL mode
+        jz      hcont
+%else
+        GLOBAL  glfsr_crypt     ; glfsr_crypt (uchar *dst, uchar *src, int len, int key)
+
+glfsr_crypt:
+        push    ebp
+        mov     ebp, esp
+        pusha
+        mov     edi, dword [ebp + 8]
+        mov     esi, dword [ebp + 12]
+        mov     ecx, dword [ebp + 16]
+        mov     ebx, dword [ebp + 20]
+%endif
+
+; esi = source
+; edi = dest (can overlap/be the same) with source
+; ecx = number of bytes
+; ebx = 32 bit key
+
+        xor     edx, edx
+glls:   mov     eax, 8
+gll0:   shrd    edx, ebx, 1             ; edx = >>output, ebx = |lfsr|
+        shr     ebx, 1                  ; cf = lfsr[0]
+        jnc     gll1                    ; == 1 ?
+        xor     ebx, 0xc0000057         ; binary tap sequence
+gll1:   dec     eax
+        jnz     gll0
+        shr     edx, 32 - 8             ; take highest 8 bits
+        lodsb
+        xor     al, dl
+        stosb
+        dec     ecx
+        jnz     glls
+
+%ifdef IN_STUB
+hcont:  popa
+        popf
+        ret
+
+hunk:   call    hret
+%else
+%ifdef CONSERVE_SPACE
+        popa
+        pop     ebp
+        ret     16
+%else
+        popa
+        pop     ebp                     ; only restore, no stack space
+        ret
+%endif
+%endif
+
+
diff --git a/other/burneye/src/stub/cipher-glfsr.h b/other/burneye/src/stub/cipher-glfsr.h
new file mode 100644
index 0000000..93e0eaf
--- /dev/null
+++ b/other/burneye/src/stub/cipher-glfsr.h
@@ -0,0 +1,26 @@
+/* cipher-glfsr.h - galois linear feedback shifting register include file
+ *
+ * -scut
+ */
+
+#ifndef CIPHER_GLFSR_H
+#define CIPHER_GLFSR_H
+
+
+/* glfsr_crypt
+ *
+ * main encryption and decryption function. its a symmetric 32bit key stream
+ * cipher. it is not secure, only used here for obfuscation. the same key is
+ * used for encryption and decryption.
+ * encrypt 'len' bytes from 'src' to 'dst' with key 'key'. 'src' and 'dst' can
+ * overlap as they want, only if 'src' >= 'dst'.
+ *
+ * return in any case
+ */
+
+void
+glfsr_crypt (unsigned char *dest, unsigned char *src,
+        unsigned int len, unsigned int key);
+
+#endif
+
diff --git a/other/burneye/src/stub/cipher-rc4.c b/other/burneye/src/stub/cipher-rc4.c
new file mode 100644
index 0000000..651c270
--- /dev/null
+++ b/other/burneye/src/stub/cipher-rc4.c
@@ -0,0 +1,89 @@
+/* rc4 */
+
+#include "cipher-rc4.h"
+#include "cipher-sha1.h"
+
+#ifdef IN_STUB
+#include "helper.h"
+#else
+#include <stdio.h>
+#endif
+
+
+static void swap_byte (unsigned char *a, unsigned char *b);
+
+void
+rc4_prepare_key (unsigned char *key_data_ptr, int key_data_len, rc4_key *key)
+{
+        unsigned char   i1, i2;
+        unsigned char   *s;
+        short           c;
+
+        s = &key->state[0];
+        for (c = 0; c < 256; c++)
+                s[c] = c;
+
+        key->x = key->y = 0;
+        i1 = i2 = 0;
+
+        for (c = 0; c < 256; c++) {
+                i2 = (key_data_ptr[i1] + s[c] + i2) % 256;
+                swap_byte (&s[c], &s[i2]);
+                i1 = (i1 + 1) % key_data_len;
+        }
+}
+
+
+void
+rc4_encipher (unsigned char *buffer, unsigned long int buffer_len, char *key)
+{
+        rc4_key         key_r;
+        unsigned char   hash[20];       /* hash of the key */
+
+        if (key == NULL || buffer == NULL || buffer_len == 0)
+                return;
+
+        SHA1HashLen (key, strlen (key), hash);
+        rc4_prepare_key (hash, sizeof (hash), &key_r);
+        rc4_cipher (buffer, buffer_len, &key_r);
+
+        return;
+}
+
+
+void
+rc4_cipher (unsigned char *buffer_ptr, int buffer_len, rc4_key *key)
+{ 
+        unsigned char   x;
+        unsigned char   y;
+        unsigned char   *state;
+        unsigned char   xi;
+        unsigned int    counter;
+   
+        x = key->x;
+        y = key->y;
+   
+        state = &key->state[0];
+        for(counter = 0; counter < buffer_len; counter ++) {
+                x = (x + 1) % 256;
+                y = (state[x] + y) % 256;
+                swap_byte(&state[x], &state[y]);
+                xi = (state[x] + state[y]) % 256;
+                buffer_ptr[counter] ^= state[xi];
+        }
+
+        key->x = x;
+        key->y = y;
+}
+
+
+static void
+swap_byte (unsigned char *a, unsigned char *b)
+{
+        unsigned char   sb; 
+
+        sb = *a;
+        *a = *b;
+        *b = sb;
+}
+
diff --git a/other/burneye/src/stub/cipher-rc4.h b/other/burneye/src/stub/cipher-rc4.h
new file mode 100644
index 0000000..aa8908e
--- /dev/null
+++ b/other/burneye/src/stub/cipher-rc4.h
@@ -0,0 +1,24 @@
+
+#ifndef CIPHER_RC4_H
+#define CIPHER_RC4_H
+
+#ifdef IN_STUB
+#include "helper.h"
+#endif
+
+
+typedef struct  rc4_key {
+        unsigned char   state[256];
+        unsigned char   x;
+        unsigned char   y;
+} rc4_key;
+
+
+void    rc4_prepare_key (unsigned char *key_data_ptr, int key_data_len, rc4_key *key);
+void    rc4_encipher (unsigned char *buffer, unsigned long int buffer_len, char *key);
+#define rc4_decipher rc4_encipher
+void    rc4_cipher (unsigned char *buffer_ptr, int buffer_len, rc4_key *key);
+
+
+#endif
+
diff --git a/other/burneye/src/stub/cipher-sha1.c b/other/burneye/src/stub/cipher-sha1.c
new file mode 100644
index 0000000..5b60c1e
--- /dev/null
+++ b/other/burneye/src/stub/cipher-sha1.c
@@ -0,0 +1,212 @@
+/* sha-1 implementation
+ *
+ * by steve reid <steve@edmweb.com>
+ * modified by scut
+ */
+
+/* #define LITTLE_ENDIAN * This should be #define'd if true. */
+
+#include "cipher-sha1.h"
+#ifdef IN_STUB
+#include "helper.h"
+#endif
+
+typedef struct {
+        unsigned long state[5];
+        unsigned long count[2];
+        unsigned char buffer[64];
+} SHA1_CTX;
+
+static void     SHA1Transform (unsigned long state[5],
+        unsigned char buffer[64]);
+static void     SHA1Init (SHA1_CTX* context);
+static void     SHA1Update (SHA1_CTX* context, unsigned char* data,
+        unsigned int len);
+static void     SHA1Final (unsigned char digest[20], SHA1_CTX* context);
+
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+#ifdef LITTLE_ENDIAN
+#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
+    |(rol(block->l[i],8)&0x00FF00FF))
+#else
+#define blk0(i) block->l[i]
+#endif
+#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
+    ^block->l[(i+2)&15]^block->l[i&15],1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5),w=rol(w,30);
+#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5),w=rol(w,30);
+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5),w=rol(w,30);
+#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5),w=rol(w,30);
+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5),w=rol(w,30);
+
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+
+void
+SHA1Transform (unsigned long state[5], unsigned char buffer[64])
+{
+        unsigned long           a, b, c, d, e;
+        typedef union {
+                unsigned char   c[64];
+                unsigned long   l[16];
+        } CHAR64LONG16;
+        CHAR64LONG16            *block;
+        static unsigned char    workspace[64];
+
+        block = (CHAR64LONG16 *) workspace;
+        memcpy (block, buffer, 64);
+
+        /* Copy context->state[] to working vars */
+        a = state[0];
+        b = state[1];
+        c = state[2];
+        d = state[3];
+        e = state[4];
+
+        /* 4 rounds of 20 operations each. Loop unrolled. */
+        R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
+        R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
+        R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
+        R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
+        R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
+        R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
+        R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
+        R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
+        R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
+        R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
+        R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
+        R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
+        R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
+        R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
+        R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
+        R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
+        R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
+        R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
+        R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
+        R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
+
+        /* Add the working vars back into context.state[] */
+        state[0] += a;
+        state[1] += b;
+        state[2] += c;
+        state[3] += d;
+        state[4] += e;
+
+        /* Wipe variables */
+        a = b = c = d = e = 0;
+
+        return;
+}
+
+
+/* SHA1Init - Initialize new context */
+
+void
+SHA1Init (SHA1_CTX *context)
+{
+        /* SHA1 initialization constants */
+        context->state[0] = 0x67452301;
+        context->state[1] = 0xEFCDAB89;
+        context->state[2] = 0x98BADCFE;
+        context->state[3] = 0x10325476;
+        context->state[4] = 0xC3D2E1F0;
+        context->count[0] = context->count[1] = 0;
+
+        return;
+}
+
+
+/* Run your data through this. */
+
+void
+SHA1Update (SHA1_CTX* context, unsigned char* data, unsigned int len)
+{
+        unsigned int    i, j;
+
+        j = (context->count[0] >> 3) & 63;
+        if ((context->count[0] += len << 3) < (len << 3))
+                context->count[1]++;
+
+        context->count[1] += (len >> 29);
+
+        if ((j + len) > 63) {
+                memcpy (&context->buffer[j], data, (i = 64-j));
+                SHA1Transform (context->state, context->buffer);
+
+                for ( ; i + 63 < len ; i += 64) {
+                        SHA1Transform (context->state, &data[i]);
+                }
+
+                j = 0;
+        } else
+                i = 0;
+
+        memcpy (&context->buffer[j], &data[i], len - i);
+
+        return;
+}
+
+
+/* Add padding and return the message digest. */
+
+void
+SHA1Final (unsigned char digest[20], SHA1_CTX* context)
+{
+        unsigned long   i, j;
+        unsigned char   finalcount[8];
+
+        for (i = 0 ; i < 8 ; i++) {
+                finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >> ((3-(i & 3)) * 8) ) & 255);
+        }
+
+        SHA1Update (context, (unsigned char *)"\200", 1);
+        while ((context->count[0] & 504) != 448) {
+                SHA1Update (context, (unsigned char *)"\0", 1);
+        }
+
+        /* Should cause a SHA1Transform() */
+        SHA1Update (context, finalcount, 8);
+        for (i = 0 ; i < 20 ; i++) {
+                digest[i] = (unsigned char) ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
+        }
+
+        /* Wipe variables */
+        i = j = 0;
+
+        memset (context->buffer, 0, 64);
+        memset (context->state, 0, 20);
+        memset (context->count, 0, 8);
+        memset (&finalcount, 0, 8);
+
+        SHA1Transform (context->state, context->buffer);
+
+        return;
+}
+
+
+void
+SHA1HashLen (unsigned char *data, unsigned long int data_len, unsigned char *hash)
+{
+        SHA1_CTX        context;
+
+        SHA1Init (&context);
+        SHA1Update (&context, data, data_len);
+        SHA1Final (hash, &context);
+
+        return;
+}
+
+
+void
+SHA1Hash (char *password, unsigned char *hash)
+{
+        SHA1HashLen (password, strlen (password), hash);
+
+        return;
+}
diff --git a/other/burneye/src/stub/cipher-sha1.h b/other/burneye/src/stub/cipher-sha1.h
new file mode 100644
index 0000000..92a3382
--- /dev/null
+++ b/other/burneye/src/stub/cipher-sha1.h
@@ -0,0 +1,36 @@
+/* sha-1 implementation
+ *
+ * by steve reid <steve@edmweb.com>
+ * modified by scut
+ *
+ * include file
+ */
+
+#ifndef CIPHER_SHA1_H
+#define CIPHER_SHA1_H
+
+
+/* SHA1Hash
+ *
+ * hash an binary string `data' with `data_len' bytes into a 20 byte long hash
+ * byte buffer pointed to by `hash'
+ *
+ * return in any case
+ */
+
+void    SHA1HashLen (unsigned char *data, unsigned long int data_len,
+        unsigned char *hash);
+
+
+/* SHA1Hash
+ *
+ * hash an ASCIIZ password into a 20 byte long hash byte buffer
+ *
+ * return in any case
+ */
+
+void    SHA1Hash (char *password, unsigned char *hash);
+
+
+#endif
+
diff --git a/other/burneye/src/stub/fingerprint.c b/other/burneye/src/stub/fingerprint.c
new file mode 100644
index 0000000..4273f3a
--- /dev/null
+++ b/other/burneye/src/stub/fingerprint.c
@@ -0,0 +1,593 @@
+/* fingerprinting functions
+ *
+ * we use 18 byte subhashes (first 144 bit of sha1 160 bit hash) here, to
+ * better line up with the pre reed solomon transformation. then finally,
+ * the key is a real 20 byte sha1 hash of the subhash array
+ */
+
+#ifndef IN_STUB
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/utsname.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#else
+#include "include/int80.h"
+#include "include/unistd.h"
+#include "helper.h"
+#endif
+
+#include "fingerprint.h"
+#include "cipher-sha1.h"
+#include "rs.h"
+
+/* externals */
+extern unsigned int     KK;
+
+/* prototypes */
+static unsigned int
+fp_sgrep (char *pathname, char *seq, unsigned char *buf,
+        unsigned int buf_len);
+void strlcat (unsigned char *tgt, unsigned int len, unsigned char *str);
+
+
+#ifndef IN_STUB
+int     test_sysbase = 1;       /* fixed information */
+int     test_sysinstall = 1;    /* information that varies each installation */
+int     test_procpci = 1;       /* /proc/pci | grep "bridge:" output */
+int     test_proccpu = 1;       /* /proc/cpuinfo, certain characteristics */
+int     test_procmem = 1;       /* /proc/meminfo, total system memory */
+int     test_procroute = 1;     /* /proc/net/route, system routing table */
+int     test_procpartitions = 1;/* /proc/partitions, harddisk partitions */
+
+
+/* option table */
+typedef struct {
+        char *                  name;
+        unsigned long int       c_num;
+} elem;
+
+/* the order is important, low bits come first */
+elem    e_list[] = {
+        { "sysbase", FP_SYSBASE },
+        { "sysinstall", FP_SYSINSTALL },
+        { "procpci", FP_PROCPCI },
+        { "proccpu", FP_PROCCPU },
+        { "procmem", FP_PROCMEM },
+        { "procroute", FP_PROCROUTE },
+        { "procpartitions", FP_PROCPARTITIONS },
+        { NULL, 0 },
+};
+
+
+void
+fp_tenable (fp_s *fp, char *arg)
+{
+        fp->tests |= fp_tlookup (arg);
+}
+
+
+void
+fp_tdisable (fp_s *fp, char *arg)
+{
+        fp->tests &= ~(fp_tlookup (arg));
+}
+
+
+int
+fp_counttests (fp_s *fp)
+{
+        int     n,
+                count = 0;
+
+        for (n = 0 ; n < 32 ; ++n) {
+                if (fp->tests & (1 << n))
+                        count += 1;
+        }
+
+        return (count);
+}
+
+
+unsigned long int
+fp_tlookup (char *arg)
+{
+        int     n;
+
+        for (n = 0 ; e_list[n].name != NULL ; ++n)
+                if (strcmp (e_list[n].name, arg) == 0)
+                        return (e_list[n].c_num);
+
+        fprintf (stderr, "invalid symbol\n");
+
+        exit (EXIT_FAILURE);
+}
+
+
+void
+fp_tlist (unsigned long int tests)
+{
+        int     n;
+
+        printf ("%-17s     value\n", "name of test");
+        printf ("----------------+----------\n");
+        for (n = 0 ; e_list[n].name != NULL ; ++n)
+                printf ("%-17s0x%08lx (default: %s)\n", e_list[n].name,
+                        e_list[n].c_num,
+                        tests & fp_tlookup (e_list[n].name) ?
+                        "enabled" : "disabled");
+        printf ("----------------+----------\n");
+}
+
+
+#endif
+
+
+#ifdef  STANDALONE
+static void usage (char *progname);
+
+void
+hexdump_s (FILE *outf, unsigned char *data, unsigned int amount);
+
+void
+hexdump (unsigned char *data, unsigned int amount);
+
+
+fp_s    template = {
+        NULL,   /* hash array pointer */
+
+        /* default fingerprints to take */
+        FP_TEMPLATE,
+};
+
+char *  outname = NULL;
+FILE *  outf = NULL;
+
+
+
+static void
+usage (char *progname)
+{
+        fprintf (stderr, "usage: %s [options]\n\n"
+                "\t-h\tthis help\n"
+                "\t-e opt\tenable fingerprint option\n"
+                "\t-d opt\tdisable fingerprint option\n"
+                "\t-l\tlist fingerprint options\n"
+                "\t-f name\tset output file name (default: stdout)\n\n",
+                progname);
+
+        exit (EXIT_FAILURE);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+        int             n;
+        char            c;
+        char *          progname = argv[0];
+        int             out_c;
+        unsigned char   hash_arr[N_TEST * N_SUBHASH];
+
+
+        if (argc == 1)
+                fprintf (stderr, "run %s -h for options\n\n", progname);
+
+        template.hash_arr = hash_arr;
+
+        while ((c = getopt (argc, argv, "he:d:lf:")) != EOF) {
+                switch (c) {
+                case 'h':
+                        usage (progname);
+                        break;
+                case 'e':
+                        fp_tenable (&template, optarg);
+                        break;
+                case 'd':
+                        fp_tdisable (&template, optarg);
+                        break;
+                case 'l':
+                        fp_tlist (template.tests);
+                        exit (EXIT_SUCCESS);
+                        break;
+                case 'f':
+                        outname = optarg;
+                        break;
+                default:
+                        usage (progname);
+                        break;
+                }
+        }
+
+        if (outname != NULL) {
+                outf = fopen (outname, "w");
+                if (outf == NULL) {
+                        perror ("fopen output file");
+                        exit (EXIT_FAILURE);
+                }
+        } else
+                outf = stdout;
+
+        out_c = fp_get (&template);
+
+        for (n = 0 ; e_list[n].name != NULL ; ++n)
+                if (template.tests & e_list[n].c_num)
+                        fprintf (outf, "enable %s\n", e_list[n].name);
+
+        fprintf (outf, "begin\n");
+        hexdump_s (outf, template.hash_arr, out_c);
+        fprintf (outf, "end\n");
+
+        exit (EXIT_SUCCESS);
+}
+#endif
+
+
+unsigned int
+fp_get (fp_s *fs)
+{
+        struct utsname  un;
+        unsigned char * ha;
+        unsigned char   tmpstr[1024];
+
+
+        memset (fs->hash_arr, '\0', N_TEST * N_SUBHASH);
+        ha = fs->hash_arr;
+
+
+        if ((fs->tests & FP_SYSBASE) || (fs->tests & FP_SYSINSTALL))
+                uname (&un);
+
+        /* (fs->tests & FP_sysbase: sysname, nodename, machine */
+        if (fs->tests & FP_SYSBASE) {
+                memset (tmpstr, '\0', sizeof (tmpstr));
+                strlcat (tmpstr, sizeof (tmpstr), un.sysname);
+                strlcat (tmpstr, sizeof (tmpstr), un.nodename);
+                strlcat (tmpstr, sizeof (tmpstr), un.machine);
+                tmpstr[sizeof (tmpstr) - 1] = '\0';
+                SHA1Hash (tmpstr, ha);
+                ha += N_SUBHASH;
+        }
+
+        /* (fs->tests & FP_sysinstall: release, version XXX: more strict than sysbase */
+        if (fs->tests & FP_SYSINSTALL) {
+                memset (tmpstr, '\0', sizeof (tmpstr));
+                strlcat (tmpstr, sizeof (tmpstr), un.release);
+                strlcat (tmpstr, sizeof (tmpstr), un.version);
+                tmpstr[sizeof (tmpstr) - 1] = '\0';
+                SHA1Hash (tmpstr, ha);
+                ha += N_SUBHASH;
+        }
+
+        /* (fs->tests & FP_procpci: pci registered bridges */
+        if (fs->tests & FP_PROCPCI) {
+                memset (tmpstr, '\0', sizeof (tmpstr));
+                fp_sgrep ("/proc/pci", "bridge:", tmpstr, sizeof (tmpstr));
+                tmpstr[sizeof (tmpstr) - 1] = '\0';
+                SHA1Hash (tmpstr, ha);
+                ha += N_SUBHASH;
+        }
+
+        /* (fs->tests & FP_proccpu: generic cpu fingerprint */
+        if (fs->tests & FP_PROCCPU) {
+                memset (tmpstr, '\0', sizeof (tmpstr));
+                fp_sgrep ("/proc/cpuinfo", "vendor_id",
+                        tmpstr, sizeof (tmpstr));
+                tmpstr[sizeof (tmpstr) - 1] = '\0';
+                fp_sgrep ("/proc/cpuinfo", "model",
+                        tmpstr + strlen (tmpstr),
+                        sizeof (tmpstr) - strlen (tmpstr));
+                tmpstr[sizeof (tmpstr) - 1] = '\0';
+                fp_sgrep ("/proc/cpuinfo", "flags",
+                        tmpstr + strlen (tmpstr),
+                        sizeof (tmpstr) - strlen (tmpstr));
+                tmpstr[sizeof (tmpstr) - 1] = '\0';
+
+                SHA1Hash (tmpstr, ha);
+                ha += N_SUBHASH;
+        }
+
+        /* (fs->tests & FP_procmem: total system memory size */
+        if (fs->tests & FP_PROCMEM) {
+                memset (tmpstr, '\0', sizeof (tmpstr));
+                fp_sgrep ("/proc/meminfo", "MemTotal:",
+                        tmpstr, sizeof (tmpstr));
+                tmpstr[sizeof (tmpstr) - 1] = '\0';
+
+                SHA1Hash (tmpstr, ha);
+                ha += N_SUBHASH;
+        }
+
+        /* (fs->tests & FP_procroute: routing table */
+        if (fs->tests & FP_PROCROUTE) {
+                memset (tmpstr, '\0', sizeof (tmpstr));
+                fp_sgrep ("/proc/net/route", NULL, tmpstr, sizeof (tmpstr));
+                tmpstr[sizeof (tmpstr) - 1] = '\0';
+
+                SHA1Hash (tmpstr, ha);
+                ha += N_SUBHASH;
+        }
+
+        /* (fs->tests & FP_procpartitions: partition tables */
+        if (fs->tests & FP_PROCPARTITIONS) {
+                memset (tmpstr, '\0', sizeof (tmpstr));
+                fp_sgrep ("/proc/partitions", NULL, tmpstr, sizeof (tmpstr));
+                tmpstr[sizeof (tmpstr) - 1] = '\0';
+
+                SHA1Hash (tmpstr, ha);
+                ha += N_SUBHASH;
+        }
+
+
+        return (ha - fs->hash_arr);
+}
+
+
+/* fp_sgrep
+ *
+ * simple single sequence grep with only syscalls. read from file with
+ * pathname 'pathname' only lines that contain the sequence 'seq' (or every
+ * line, when NULL), appending all lines (including '\n') to buffer 'buf',
+ * which is 'buf_len' bytes long.
+ *
+ * return number of bytes in buffer
+ */
+
+static unsigned int
+fp_sgrep (char *pathname, char *seq, unsigned char *buf, unsigned int buf_len)
+{
+        int             fd,
+                        n;
+        unsigned char * lp;
+        unsigned char * sp;
+        unsigned char   line[256];
+        unsigned int    ret = 0;
+
+
+        fd = open (pathname, O_RDONLY, 0);
+        if (fd < 0) {
+#ifndef IN_STUB
+                perror ("fp_sgrep:open");
+                exit (EXIT_FAILURE);
+#else
+                _exit (73);
+#endif
+        }
+
+        /* uhh yes, i know it looks like a kludge, but i cannot rely on any
+         * library function, for that the same code runs from within the stub,
+         * syscall wise too. :(
+         */
+        do {
+                lp = line;
+                do {
+                        n = read (fd, lp, 1);
+                } while (n == 1 && *lp != '\0' && *lp != '\n' &&
+                        lp++ <= (line + sizeof (line)));
+
+                if (n <= 0) {
+                        close (fd);
+
+                        return (ret);
+                }
+
+                if (seq == NULL) {
+                        memcpy (buf, line, lp - line + 1);
+                        buf += (lp - line) + 1;
+                        ret += (lp - line) + 1;
+                } else {
+                        for (sp = line ; sp < (lp - strlen (seq)) ; ++sp) {
+                                if (memcmp (sp, seq, strlen (seq)) == 0 &&
+                                        (lp - line) < buf_len)
+                                {
+                                        memcpy (buf, line, lp - line + 1);
+                                        buf += (lp - line) + 1;
+                                        ret += (lp - line) + 1;
+                                        sp = lp;        /* one time is enough */
+                                }
+                        }
+                }
+        } while (1);
+}
+
+
+#ifdef STANDALONE
+void
+hexdump_s (FILE *outf, unsigned char *data, unsigned int amount)
+{
+        unsigned int    dp;     /* data pointer */
+
+        for (dp = 1 ; dp <= amount ; ++dp) {
+                fprintf (outf, "%02x", data[dp-1]);
+                if (dp % 16 == 0)
+                        fprintf (outf, "\n");
+        }
+        if ((dp - 1) % 16 != 0)
+                fprintf (outf, "\n");
+
+        return;
+}
+
+
+void
+hexdump (unsigned char *data, unsigned int amount)
+{
+        unsigned int    dp, p;  /* data pointer */
+        const char      trans[] =
+                "................................ !\"#$%&'()*+,-./0123456789"
+                ":;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklm"
+                "nopqrstuvwxyz{|}~...................................."
+                "....................................................."
+                "........................................";
+
+        for (dp = 1; dp <= amount; dp++) {
+                printf ("%02x ", data[dp-1]);
+                if ((dp % 8) == 0)
+                        printf (" ");
+                if ((dp % 16) == 0) {
+                        printf ("| ");
+                        p = dp;
+                        for (dp -= 16; dp < p; dp++)
+                                printf ("%c", trans[data[dp]]);
+                        printf ("\n");
+                }
+        }
+        if ((amount % 16) != 0) {
+                p = dp = 16 - (amount % 16);
+                for (dp = p; dp > 0; dp--) {
+                        printf ("   ");
+                        if (((dp % 8) == 0) && (p != 8))
+                                printf (" ");
+                }
+                printf (" | ");
+                for (dp = (amount - (16 - p)); dp < amount; dp++)
+                        printf ("%c", trans[data[dp]]);
+        }
+        printf ("\n");
+
+        return;
+}
+#endif
+
+
+void
+strlcat (unsigned char *tgt, unsigned int len, unsigned char *str)
+{
+        len -= strlen (tgt);
+        tgt += strlen (tgt);
+        memcpy (tgt, str, (strlen (str) + 1) > len ? len : (strlen (str) + 1));
+}
+
+
+unsigned long int
+fp_padgen (unsigned char *data, unsigned int data_len, unsigned char *pad,
+        unsigned int pad_len, unsigned int data_recover)
+{
+        unsigned int    tr_arr[NN];
+
+
+        /* assume a good (n * 8/12 < NN) length here, rs_* will check
+         */
+        memset (tr_arr, '\0', sizeof (tr_arr));
+        rs_trans (data, data_len, &tr_arr[0], NN);
+
+        /* computing the number of data symbols */
+        data_len *= 8;
+        data_len /= 12;
+        data_recover *= 8;
+        data_recover /= 12;
+
+        /* the following line is the pure essence of the entire fingerprint
+         * deviation mathematics we do here
+         */
+        KK = NN - (2 * data_recover);
+
+        /* generate error correction block
+         */
+        rs_encode (&tr_arr[0], &tr_arr[KK]);
+
+        /* now we have the following layout of the tr_arr array:
+         *
+         * 0                  data_len         KK
+         * [data_len symbols] | [zero padding] | [error correction symbols]
+         *
+         * package the error correction symbols back into a byte array
+         */
+        rs_detrans (pad, pad_len, &tr_arr[KK], NN - KK);
+
+        /* number of parity bytes. always fits.
+         */
+        return ((12 * 2 * data_recover) / 8);
+}
+
+
+int
+fp_padfix (unsigned char *data, unsigned int data_len,
+        unsigned char *pad, unsigned int pad_len)
+{
+        int             n;
+        unsigned int    tr_arr[NN];
+
+
+        /* again, transform 8 to 12 bits */
+        memset (tr_arr, '\0', sizeof (tr_arr));
+        rs_trans (data, data_len, tr_arr, NN);
+
+        data_len *= 8;
+        data_len /= 12;
+
+        /* calculate KK accordingly to the pad length
+         */
+        KK = NN - ((pad_len * 8) / 12);
+        rs_trans (pad, pad_len, &tr_arr[KK], NN - KK);
+
+        /* now, we try to fixup any errors. since the knowledge about possible
+         * erasures (i.e. known places of errors) can double the number of
+         * corrected symbols there may be a way to shortcut brute force attacks
+         * by giving the sha1 subhash boundaries through erasures, much like
+         * the reed solomon features at correcting burst errors. this is bad.
+         */
+        n = rs_eras_dec (tr_arr, NULL, 0);
+
+        rs_detrans (data, ((data_len * 12) / 8), &tr_arr[0], data_len);
+
+        return (n != -1 ? 0 : 1);
+}
+
+
+#ifdef IN_STUB
+
+void
+fp_process (fp_fin *fpf, unsigned char *key)
+{
+#ifdef FP_DEBUG
+        int             pad_res;
+#endif
+        unsigned int    ha_len;
+        unsigned char   hash_arr[N_TEST * N_SUBHASH];
+
+#ifdef DEBUG
+        be_printf ("test: 0x%08lx\n", fpf->fp.tests);
+#endif
+
+        fpf->fp.hash_arr = hash_arr;
+        ha_len = fp_get (&fpf->fp);
+
+#ifdef DEBUG
+        be_printf ("  fp: %02x %02x %02x %02x\n",
+                hash_arr[0], hash_arr[1], hash_arr[2], hash_arr[3]);
+#endif
+
+        /* if there is a rescue pad to fix deviation with, apply it.
+         */
+        if (fpf->par_len != 0) {
+                fpf->par_data = ((unsigned char *) &fpf->par_data) +
+                        sizeof (fpf->par_data);
+#ifdef FP_DEBUG
+                pad_res =
+#endif
+                fp_padfix (hash_arr, ha_len, fpf->par_data, fpf->par_len);
+#ifdef FP_DEBUG
+                if (pad_res == 0) {
+                        be_printf ("valid fingerprint\n");
+                } else {
+                        be_printf ("invalid fingerprint\n");
+                }
+#endif
+        }
+
+        /* generate final 160 bit sha1 hash out of (possibly corrected) host
+         * characteristics
+         */
+        SHA1HashLen (hash_arr, ha_len, key);
+
+        return;
+}
+
+
+#endif
+
+
diff --git a/other/burneye/src/stub/fingerprint.h b/other/burneye/src/stub/fingerprint.h
new file mode 100644
index 0000000..276b7e3
--- /dev/null
+++ b/other/burneye/src/stub/fingerprint.h
@@ -0,0 +1,159 @@
+
+#ifndef FINGERPRINT_H
+#define FINGERPRINT_H
+
+
+#define N_TEST          7       /* number of overall available tests */
+#define N_SUBHASH       18      /* size in bytes of subhash */
+
+/* yes, i wish bitfields would support pointer-wise addressing, too,
+ * so shut up */
+#define FP_SYSBASE              0x00000001
+#define FP_SYSINSTALL           0x00000002
+#define FP_PROCPCI              0x00000004
+#define FP_PROCCPU              0x00000008
+#define FP_PROCMEM              0x00000010
+#define FP_PROCROUTE            0x00000020
+#define FP_PROCPARTITIONS       0x00000040
+
+#define FP_TEMPLATE     (FP_SYSBASE | \
+        FP_PROCPCI | FP_PROCCPU | \
+        FP_PROCROUTE)
+
+typedef struct {
+        unsigned char *         hash_arr;
+        unsigned long int       tests;
+} fp_s;
+
+
+typedef struct {
+        /* only used when SEALNOW is set */
+        unsigned long int       stubhdr_flags_ofs;
+        unsigned long int       sealhdr_ofs;    /* this headers offset */
+
+        unsigned long int       payload_ofs;
+        unsigned long int       payload_len;
+
+        unsigned long int       be_layer0_filestart;
+        unsigned long int       be_layer0_size;
+        unsigned long int       be_layer0_cont;
+
+        /* real fingerprint data */
+        fp_s                    fp;
+        unsigned char           fp_xor[20];     /* xor hash */
+        unsigned char           fp_check[4];    /* check hash */
+        unsigned long int       par_len;        /* parity length */
+
+        /* must be last defined element in structure */
+        unsigned char *         par_data;       /* parity data */
+        /* par_arr here */
+} fp_fin;
+
+
+#ifndef IN_STUB
+/* fp_tenable
+ *
+ * lookup symbolic test `arg' and enable it in `fp'
+ */
+
+void
+fp_tenable (fp_s *fp, char *arg);
+
+
+/* fp_tdisable
+ *
+ * lookup symbolic test `arg' and disable it in `fp'
+ */
+
+void
+fp_tdisable (fp_s *fp, char *arg);
+
+
+/* fp_tlist
+ *
+ * list available fingerprint tests, defaults are printed ('tests')
+ */
+
+void
+fp_tlist (unsigned long int tests);
+
+
+/* fp_counttests
+ *
+ * count the number of tests used in the fingerprint described by `fp'
+ *
+ * return the number of tests
+ */
+
+int
+fp_counttests (fp_s *fp);
+
+
+/* fp_tlookup
+ *
+ * convert symbolic test `arg' to a flag value used in fingerprint structures
+ *
+ * return flag value
+ */
+
+unsigned long int
+fp_tlookup (char *arg);
+#endif
+
+
+/* fp_get
+ *
+ * retrieve some host fingerprint into the fingerprint structure pointed to by
+ * `fs'. the individual tests are done as specified by the `fs->tests' field.
+ *
+ * return number of bytes stored into `fs->hash_arr'
+ */
+
+unsigned int
+fp_get (fp_s *fs);
+
+
+/* fp_padgen
+ *
+ * generate a reed solomon rescue pad at `pad', which is `pad_len' bytes long
+ * (does not have to be the exact size, but should be large enough), which can
+ * recover up to `data_recover' bytes from `data_len' bytes at `data'.
+ *
+ * return the number of bytes of the pad
+ */
+
+unsigned long int
+fp_padgen (unsigned char *data, unsigned int data_len, unsigned char *pad,
+        unsigned int pad_len, unsigned int data_recover);
+
+
+/* fp_padfix
+ *
+ * use the supplied byte based pad `pad', which is `pad_len' bytes long, to
+ * correct as much errors as possible in data block `data', which is
+ * `data_len' bytes long.
+ *
+ * return 0 on success
+ * return 1 on failure
+ */
+
+int
+fp_padfix (unsigned char *data, unsigned int data_len,
+        unsigned char *pad, unsigned int pad_len);
+
+
+#ifdef IN_STUB
+
+/* fp_process
+ *
+ * called to process a fingerprint from within the stub
+ */
+
+void
+fp_process (fp_fin *fpf, unsigned char *key);
+
+#endif
+
+#endif
+
+
diff --git a/other/burneye/src/stub/fptest.c b/other/burneye/src/stub/fptest.c
new file mode 100644
index 0000000..a647217
--- /dev/null
+++ b/other/burneye/src/stub/fptest.c
@@ -0,0 +1,27 @@
+
+#include <stdio.h>
+#include "fingerprint.h"
+
+int
+main (int argc, char *argv[])
+{
+        fp_s                    fp;
+
+        unsigned int            ha_len;
+        unsigned char           ha[N_TEST * 18];
+
+        int                     pad_res;
+        unsigned long int       pad_len;
+        unsigned char           pad[256];
+
+
+        fp.tests = FP_SYSBASE | FP_PROCPCI | FP_PROCMEM;
+        fp.hash_arr = ha;
+        ha_len = fp_get (&fp);
+
+        pad_len = fp_padgen (ha, ha_len, pad, sizeof (pad), 1 * 18);
+
+        pad_res = fp_padfix (ha, ha_len, pad, pad_len);
+}
+
+
diff --git a/other/burneye/src/stub/helper.c b/other/burneye/src/stub/helper.c
new file mode 100644
index 0000000..00abbf5
--- /dev/null
+++ b/other/burneye/src/stub/helper.c
@@ -0,0 +1,139 @@
+/* helper functions
+ */
+
+#include <stdarg.h>
+#include "include/int80.h"
+#include "include/unistd.h"
+#include "helper.h"
+
+
+void
+memset (void *dst, unsigned char c, unsigned int len)
+{
+        unsigned char * p = (unsigned char *) dst;
+
+        while (len--)
+                *p++ = c;
+}
+
+
+int
+memcmp (void *dst, void *src, unsigned int len)
+{
+        unsigned char * d = (unsigned char *) dst;
+        unsigned char * s = (unsigned char *) src;
+
+        while (len-- > 0) {
+                if (*d++ != *s++)
+                        return (1);
+        }
+
+        return (0);
+}
+
+
+void
+memcpy (void *dst, void *src, unsigned int len)
+{
+        unsigned char * d = (unsigned char *) dst;
+        unsigned char * s = (unsigned char *) src;
+
+        while (len--)
+                *d++ = *s++;
+}
+
+
+int
+strlen (unsigned char *str)
+{
+        int     n = 0;
+
+        while (*str++)
+                n++;
+
+        return (n);
+}
+
+
+
+#ifdef VDEBUG
+void
+be_printf (char *str, ...)
+{
+        int     len;
+        va_list vl;
+        char    buf[1024];
+
+        va_start (vl, str);
+        len = vsnprintf (buf, sizeof (buf), str, vl);
+        va_end (vl);
+        buf[sizeof (buf) - 1] = '\0';
+
+        write (1, buf, len);
+
+        return;
+}
+#endif
+
+
+/* based on the dietlibc version, which was ripped elsewhere ;) */
+void
+getpass (unsigned char *buf, unsigned int buf_len)
+{
+        int             tty_fd;
+        unsigned int    buf_just,
+                        buf_read = 0;
+        termios         t_backup,
+                        t_noecho;
+
+
+        tty_fd = open ("/dev/tty", O_RDWR, 0);
+        if (tty_fd < 0)
+                _exit (73);
+
+        /* set terminal to non-echo'ing mode */
+        if (ioctl (tty_fd, TCGETS, (unsigned long int) &t_backup) != 0)
+                _exit (73);
+
+        memcpy (&t_noecho, &t_backup, sizeof (t_backup));
+        t_noecho.c_lflag &= ~(ECHO | ISIG);
+        if (ioctl (tty_fd, TCSETSF, (unsigned long int) &t_noecho) != 0)
+                _exit (73);
+
+        write (tty_fd, "password: ", 10);
+
+        do {
+                buf_just = read (tty_fd, buf + buf_read, buf_len - buf_read);
+                if (buf_just < 0)
+                        _exit (73);
+
+                buf_read += buf_just;
+        } while (buf_read < buf_len && buf[buf_read - 1] != '\n');
+
+        buf[buf_read > 0 ? (buf_read - 1) : 0] = '\0';
+        buf[buf_len - 1] = '\0';
+        write (tty_fd, "\n", 1);
+
+        if (ioctl (tty_fd, TCSETSF, (unsigned long int) &t_backup) != 0)
+                _exit (73);
+        close (tty_fd);
+
+        return;
+}
+
+
+void
+write_tty (unsigned char *buf, unsigned int buf_len)
+{
+        int     tty_fd;
+
+
+        tty_fd = open ("/dev/tty", O_RDWR, 0);
+        if (tty_fd < 0)
+                return;
+
+        write (tty_fd, buf, buf_len);
+        close (tty_fd);
+}
+
+
diff --git a/other/burneye/src/stub/helper.h b/other/burneye/src/stub/helper.h
new file mode 100644
index 0000000..20bf88e
--- /dev/null
+++ b/other/burneye/src/stub/helper.h
@@ -0,0 +1,32 @@
+/* helper functions include file
+ */
+
+#ifndef HELPER_H
+#define HELPER_H
+
+#ifdef VDEBUG
+#include <stdarg.h>
+#endif
+
+#ifndef NULL
+#define NULL ((void *) 0)
+#endif
+
+#ifndef VDEBUG
+#define be_printf(str,a...)
+#else
+void be_printf (char *str, ...);
+int vsnprintf(char *str, int count, const char *fmt, va_list args);
+#endif
+
+int memcmp (void *dst, void *src, unsigned int len);
+void memcpy (void *dst, void *src, unsigned int len);
+void memset (void *dst, unsigned char c, unsigned int len);
+int strlen (unsigned char *str);
+
+void getpass (unsigned char *buf, unsigned int buf_len);
+void write_tty (unsigned char *buf, unsigned int buf_len);
+
+#endif
+
+
diff --git a/other/burneye/src/stub/include/int80-test.c b/other/burneye/src/stub/include/int80-test.c
new file mode 100644
index 0000000..9e87ab5
--- /dev/null
+++ b/other/burneye/src/stub/include/int80-test.c
@@ -0,0 +1,9 @@
+
+#include "int80.h"
+
+int
+main (int argc, char *argv[])
+{
+        lseek (0, 10, 20);
+}
+
diff --git a/other/burneye/src/stub/include/int80-test.o b/other/burneye/src/stub/include/int80-test.o
new file mode 100644
index 0000000..a2418b1
--- /dev/null
+++ b/other/burneye/src/stub/include/int80-test.o
diff --git a/other/burneye/src/stub/include/int80.h b/other/burneye/src/stub/include/int80.h
new file mode 100644
index 0000000..25d05b0
--- /dev/null
+++ b/other/burneye/src/stub/include/int80.h
@@ -0,0 +1,437 @@
+/* from hellkit by stealth
+ */
+
+#ifndef INT80_H
+#define INT80_H
+
+#include "unistd.h"
+
+#ifndef _I386_FCNTL_H
+#define O_RDONLY    00
+#define O_WRONLY    01
+#define O_RDWR      02
+#define O_CREAT   0100
+#define O_TRUNC  01000
+#define O_APPEND 02000
+#define F_DUPFD         0       /* Duplicate file descriptor.  */
+#define F_GETFD         1       /* Get file descriptor flags.  */
+#define F_SETFD         2       /* Set file descriptor flags.  */
+#define F_GETFL         3       /* Get file status flags.  */
+#define F_SETFL         4       /* Set file status flags.  */
+#endif
+
+/* from bits/termios.h */
+#define TCGETS          0x5401
+#define TCSETS          0x5402
+#define TCSETSW         0x5403
+#define TCSETSF         0x5404
+
+#define ISIG    0000001
+#define ECHO    0000010
+
+
+typedef unsigned char   cc_t;
+typedef unsigned int    speed_t;
+typedef unsigned int    tcflag_t;
+
+#define NCCS    32
+
+typedef struct {
+        tcflag_t        c_iflag;        /* input mode flags */
+        tcflag_t        c_oflag;        /* output mode flags */
+        tcflag_t        c_cflag;        /* control mode flags */
+        tcflag_t        c_lflag;        /* local mode flags */
+        cc_t            c_line;         /* line discipline */
+        cc_t            c_cc[NCCS];     /* control characters */
+        speed_t         c_ispeed;       /* input speed */
+        speed_t         c_ospeed;       /* output speed */
+} termios;
+
+/* from bits/utsname.h and sys/utsname.h */
+#define _UTSNAME_LENGTH 65
+#define _UTSNAME_DOMAIN_LENGTH _UTSNAME_LENGTH
+#define _UTSNAME_NODENAME_LENGTH _UTSNAME_LENGTH
+
+struct utsname {
+        char    sysname[_UTSNAME_LENGTH];
+        char    nodename[_UTSNAME_NODENAME_LENGTH];
+        char    release[_UTSNAME_LENGTH];
+        char    version[_UTSNAME_LENGTH];
+        char    machine[_UTSNAME_LENGTH];
+        char    domainname[_UTSNAME_DOMAIN_LENGTH];
+};
+
+
+/* from bits/mman.h */
+#define PROT_READ       0x1
+#define PROT_WRITE      0x2
+#define PROT_EXEC       0x4
+#define PROT_NONE       0x0
+#define MAP_SHARED      0x01
+#define MAP_PRIVATE     0x02
+#define MAP_TYPE        0x0f
+#define MAP_FIXED       0x10
+#define MAP_ANONYMOUS   0x20
+
+/* from unistd.h */
+#define SEEK_SET        0
+#define SEEK_CUR        1
+#define SEEK_END        2
+
+extern int      errno;
+
+#if 0
+/* XXX: one would have to make a wrap-around cpp script to avoid defining
+ *      the functions in their code as it happens now :/ that is the reason
+ *      why we include every function un-macro'd
+ */
+_syscall3(int,lseek,int,fd,long,offset,int,whence);
+#endif
+
+static int mmap (void  *start, long length, int prot, int flags,
+        int fd, long offset)
+{
+        long    ret;
+
+        __asm__ __volatile__ (  "int    $0x80"
+                : "=a" (ret)
+                : "a" (__NR_mmap), "b" (&start));
+
+        return (ret);
+}
+
+
+static inline int munmap (char *start, int length)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_munmap), "S" ((long)start),
+                              "c" ((int)length): "bx");
+        return ret;
+}
+
+static inline int ioctl (int d, int request, int argp)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_ioctl), "S" ((long)d),
+                              "c" ((long)request), "d" ((long)argp): "bx");
+        return ret;
+}
+
+static inline int fcntl (int fd, int cmd, long arg)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_fcntl), "S" ((long)fd),
+                              "c" ((long)cmd), "d" ((long)arg): "bx");
+        return ret;
+}
+
+static inline int lseek (int fd, unsigned long int offset, int whence)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_lseek), "S" ((long)fd),
+                              "c" ((long)offset), "d" ((long)whence): "bx");
+        return ret;
+}
+
+static inline int mprotect(void *addr, long len, int prot)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_mprotect), "S" ((long)addr),
+                              "c" ((long)len), "d" ((long)prot): "bx");
+        return ret;
+}
+
+
+static inline int read(int fd, void *buf, long count)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_read), "S" ((long)fd),
+                              "c" ((long)buf), "d" ((long)count): "bx");
+        return ret;
+}
+
+
+static inline int write(int fd, void *buf, long count)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_write), "S" ((int)fd),
+                              "c" ((long)buf), "d" ((long)count): "bx");
+        return ret;
+}
+
+
+static inline int execve(char *s, char **argv, char **envp)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_execve), "S" ((long)s),
+                              "c" ((long)argv), "d" ((long)envp): "bx");
+        return ret;
+}
+
+
+static inline int setreuid(int reuid, int euid)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_setreuid), "S" ((long)reuid),
+                              "c" ((long)euid): "bx");
+        return ret;
+}
+
+static inline int uname(struct utsname *un)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_uname), "S" ((long)un): "bx");
+        return ret;
+}
+
+static inline int unlink(char *pathname)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_unlink), "S" ((long)pathname): "bx");
+        return ret;
+}
+
+static inline int chroot(char *path)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_chroot), "S" ((long)path): "bx");
+        return ret;
+}
+
+static inline int brk(void *addr)
+{
+        long    ret;
+
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                              :"=a" (ret)
+                              :"0" (__NR_brk), "S" (addr): "bx");
+        return (ret);
+}
+
+static inline int _exit(int level)
+{
+        long    ret;
+
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                              :"=a" (ret)
+                              :"0" (__NR_exit), "S" (level): "bx");
+        return (ret);
+}
+
+static inline int dup(int fd)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_dup), "S" (fd): "bx");
+        return ret;
+}
+
+
+static inline int dup2(int ofd, int nfd)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_dup2), "S" (ofd), "c" (nfd): "bx");
+        return ret;
+}
+
+
+static inline int open(char *path, int mode, int flags)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_open), "S" ((long)path),
+                              "c" ((int)mode), "d" ((int)flags): "bx");
+        return ret;
+}
+
+
+
+static inline int chdir(char *path)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_chdir), "S" ((long)path): "bx");
+        return ret;
+}
+
+static inline int close(int fd)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_close), "S" ((int)fd): "bx");
+        return ret;
+}
+
+
+static inline int chown(char *path, int uid, int gid)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_chown), "S" ((long)path),
+                              "c" ((int)uid), "d" ((int)gid): "bx");
+        return ret;
+}
+
+static inline int rename(char *oldpath, char *newpath)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_rename), "S" ((long)oldpath),
+                              "c" ((int)newpath): "bx");
+        return ret;
+}
+
+static inline int chmod(char *path, int mode)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("pushl %%ebx\n\t"
+                              "movl %%esi, %%ebx\n\t"
+                              "int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_chmod), "S" ((long)path),
+                              "c" ((int)mode): "bx");
+        return ret;
+}
+
+static inline int sync(void)
+{
+        long ret;
+
+        __asm__ __volatile__ ("int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_sync));
+
+        return (ret);
+}
+
+static inline int fork(void)
+{
+        long ret;
+
+        __asm__ __volatile__ ("int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_fork));
+
+        return (ret);
+}
+
+static inline int antistrace(void)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("int $0x03\n\t"
+                             :"=a" (ret)
+                             : );
+        return (ret);
+}
+
+#define SIGTRAP          5
+
+static inline int signal(int signum, void *handler)
+{
+        long ret;
+        
+        __asm__ __volatile__ ("int $0x80"
+                             :"=a" (ret)
+                             :"0" (__NR_signal), "b" ((long)signum),
+                              "c" ((int)handler));
+        return ret;
+}
+
+
+#endif
+
diff --git a/other/burneye/src/stub/include/unistd.h b/other/burneye/src/stub/include/unistd.h
new file mode 100644
index 0000000..cc8537b
--- /dev/null
+++ b/other/burneye/src/stub/include/unistd.h
@@ -0,0 +1,280 @@
+#ifndef ASM_I386_UNISTD_H
+#define ASM_I386_UNISTD_H
+
+#ifndef NULL
+#define NULL    ((void *) 0x0)
+#endif
+/*
+ * This file contains the system call numbers.
+ */
+
+#define __NR_exit                 1
+#define __NR_fork                 2
+#define __NR_read                 3
+#define __NR_write                4
+#define __NR_open                 5
+#define __NR_close                6
+#define __NR_waitpid              7
+#define __NR_creat                8
+#define __NR_link                 9
+#define __NR_unlink              10
+#define __NR_execve              11
+#define __NR_chdir               12
+#define __NR_time                13
+#define __NR_mknod               14
+#define __NR_chmod               15
+#define __NR_lchown              16
+#define __NR_break               17
+#define __NR_oldstat             18
+#define __NR_lseek               19
+#define __NR_getpid              20
+#define __NR_mount               21
+#define __NR_umount              22
+#define __NR_setuid              23
+#define __NR_getuid              24
+#define __NR_stime               25
+#define __NR_ptrace              26
+#define __NR_alarm               27
+#define __NR_oldfstat            28
+#define __NR_pause               29
+#define __NR_utime               30
+#define __NR_stty                31
+#define __NR_gtty                32
+#define __NR_access              33
+#define __NR_nice                34
+#define __NR_ftime               35
+#define __NR_sync                36
+#define __NR_kill                37
+#define __NR_rename              38
+#define __NR_mkdir               39
+#define __NR_rmdir               40
+#define __NR_dup                 41
+#define __NR_pipe                42
+#define __NR_times               43
+#define __NR_prof                44
+#define __NR_brk                 45
+#define __NR_setgid              46
+#define __NR_getgid              47
+#define __NR_signal              48
+#define __NR_geteuid             49
+#define __NR_getegid             50
+#define __NR_acct                51
+#define __NR_umount2             52
+#define __NR_lock                53
+#define __NR_ioctl               54
+#define __NR_fcntl               55
+#define __NR_mpx                 56
+#define __NR_setpgid             57
+#define __NR_ulimit              58
+#define __NR_oldolduname         59
+#define __NR_umask               60
+#define __NR_chroot              61
+#define __NR_ustat               62
+#define __NR_dup2                63
+#define __NR_getppid             64
+#define __NR_getpgrp             65
+#define __NR_setsid              66
+#define __NR_sigaction           67
+#define __NR_sgetmask            68
+#define __NR_ssetmask            69
+#define __NR_setreuid            70
+#define __NR_setregid            71
+#define __NR_sigsuspend          72
+#define __NR_sigpending          73
+#define __NR_sethostname         74
+#define __NR_setrlimit           75
+#define __NR_getrlimit           76
+#define __NR_getrusage           77
+#define __NR_gettimeofday        78
+#define __NR_settimeofday        79
+#define __NR_getgroups           80
+#define __NR_setgroups           81
+#define __NR_select              82
+#define __NR_symlink             83
+#define __NR_oldlstat            84
+#define __NR_readlink            85
+#define __NR_uselib              86
+#define __NR_swapon              87
+#define __NR_reboot              88
+#define __NR_readdir             89
+#define __NR_mmap                90
+#define __NR_munmap              91
+#define __NR_truncate            92
+#define __NR_ftruncate           93
+#define __NR_fchmod              94
+#define __NR_fchown              95
+#define __NR_getpriority         96
+#define __NR_setpriority         97
+#define __NR_profil              98
+#define __NR_statfs              99
+#define __NR_fstatfs            100
+#define __NR_ioperm             101
+#define __NR_socketcall         102
+#define __NR_syslog             103
+#define __NR_setitimer          104
+#define __NR_getitimer          105
+#define __NR_stat               106
+#define __NR_lstat              107
+#define __NR_fstat              108
+#define __NR_olduname           109
+#define __NR_iopl               110
+#define __NR_vhangup            111
+#define __NR_idle               112
+#define __NR_vm86old            113
+#define __NR_wait4              114
+#define __NR_swapoff            115
+#define __NR_sysinfo            116
+#define __NR_ipc                117
+#define __NR_fsync              118
+#define __NR_sigreturn          119
+#define __NR_clone              120
+#define __NR_setdomainname      121
+#define __NR_uname              122
+#define __NR_modify_ldt         123
+#define __NR_adjtimex           124
+#define __NR_mprotect           125
+#define __NR_sigprocmask        126
+#define __NR_create_module      127
+#define __NR_init_module        128
+#define __NR_delete_module      129
+#define __NR_get_kernel_syms    130
+#define __NR_quotactl           131
+#define __NR_getpgid            132
+#define __NR_fchdir             133
+#define __NR_bdflush            134
+#define __NR_sysfs              135
+#define __NR_personality        136
+#define __NR_afs_syscall        137 /* Syscall for Andrew File System */
+#define __NR_setfsuid           138
+#define __NR_setfsgid           139
+#define __NR__llseek            140
+#define __NR_getdents           141
+#define __NR__newselect         142
+#define __NR_flock              143
+#define __NR_msync              144
+#define __NR_readv              145
+#define __NR_writev             146
+#define __NR_getsid             147
+#define __NR_fdatasync          148
+#define __NR__sysctl            149
+#define __NR_mlock              150
+#define __NR_munlock            151
+#define __NR_mlockall           152
+#define __NR_munlockall         153
+#define __NR_sched_setparam             154
+#define __NR_sched_getparam             155
+#define __NR_sched_setscheduler         156
+#define __NR_sched_getscheduler         157
+#define __NR_sched_yield                158
+#define __NR_sched_get_priority_max     159
+#define __NR_sched_get_priority_min     160
+#define __NR_sched_rr_get_interval      161
+#define __NR_nanosleep          162
+#define __NR_mremap             163
+#define __NR_setresuid          164
+#define __NR_getresuid          165
+#define __NR_vm86               166
+#define __NR_query_module       167
+#define __NR_poll               168
+#define __NR_nfsservctl         169
+#define __NR_setresgid          170
+#define __NR_getresgid          171
+#define __NR_prctl              172
+#define __NR_rt_sigreturn       173
+#define __NR_rt_sigaction       174
+#define __NR_rt_sigprocmask     175
+#define __NR_rt_sigpending      176
+#define __NR_rt_sigtimedwait    177
+#define __NR_rt_sigqueueinfo    178
+#define __NR_rt_sigsuspend      179
+#define __NR_pread              180
+#define __NR_pwrite             181
+#define __NR_chown              182
+#define __NR_getcwd             183
+#define __NR_capget             184
+#define __NR_capset             185
+#define __NR_sigaltstack        186
+#define __NR_sendfile           187
+#define __NR_getpmsg            188     /* some people actually want streams */
+#define __NR_putpmsg            189     /* some people actually want streams */
+#define __NR_vfork              190
+
+/* user-visible error numbers are in the range -1 - -122: see <asm-i386/errno.h> */
+
+#define __syscall_return(type, res) \
+do { \
+        if ((unsigned long)(res) >= (unsigned long)(-125)) { \
+                errno = -(res); \
+                res = -1; \
+        } \
+        return (type) (res); \
+} while (0)
+
+/* XXX - _foo needs to be __foo, while __NR_bar could be _NR_bar. */
+#define _syscall0(type,name) \
+type name(void) \
+{ \
+long __res; \
+__asm__ volatile ("int $0x80" \
+        : "=a" (__res) \
+        : "0" (__NR_##name)); \
+__syscall_return(type,__res); \
+}
+
+#define _syscall1(type,name,type1,arg1) \
+type name(type1 arg1) \
+{ \
+long __res; \
+__asm__ volatile ("int $0x80" \
+        : "=a" (__res) \
+        : "0" (__NR_##name),"b" ((long)(arg1))); \
+__syscall_return(type,__res); \
+}
+
+#define _syscall2(type,name,type1,arg1,type2,arg2) \
+type name(type1 arg1,type2 arg2) \
+{ \
+long __res; \
+__asm__ volatile ("int $0x80" \
+        : "=a" (__res) \
+        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); \
+__syscall_return(type,__res); \
+}
+
+#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
+type name(type1 arg1,type2 arg2,type3 arg3) \
+{ \
+long __res; \
+__asm__ volatile ("int $0x80" \
+        : "=a" (__res) \
+        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
+                  "d" ((long)(arg3))); \
+__syscall_return(type,__res); \
+}
+
+#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
+type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
+{ \
+long __res; \
+__asm__ volatile ("int $0x80" \
+        : "=a" (__res) \
+        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
+          "d" ((long)(arg3)),"S" ((long)(arg4))); \
+__syscall_return(type,__res); \
+} 
+
+#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
+          type5,arg5) \
+type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
+{ \
+long __res; \
+__asm__ volatile ("int $0x80" \
+        : "=a" (__res) \
+        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
+          "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
+__syscall_return(type,__res); \
+}
+
+
+#endif /* _ASM_I386_UNISTD_H_ */
+
diff --git a/other/burneye/src/stub/init.asm b/other/burneye/src/stub/init.asm
new file mode 100644
index 0000000..3633dab
--- /dev/null
+++ b/other/burneye/src/stub/init.asm
@@ -0,0 +1,158 @@
+; burneye initialization function
+
+        GLOBAL  be_entry
+
+        EXTERN  burneye
+
+; this is the central entry point of the program
+; we have to take care about not destorying the kernel supplied auxv's
+;
+
+; WARNING: this code is quite unclean, you do not want to mess with it, really
+
+be_entry:
+        pushf
+
+        ; ebx = addr, ecx = len, edx = prot
+;       mov     ebx, 0x05370000 ; addr
+;       mov     edx, 0x0007     ; PROT_READ | PROT_WRITE | PROT_EXEC
+;       mov     ecx, be_payload
+;       mov     ecx, 0x0000b000
+;       sub     ecx, 0x05371000
+
+;       mov     eax, 0x7d       ; __NR_mprotect
+;       int     0x80
+
+        pop     ebx
+
+        mov     esi, esp
+        call    be_auxv         ; ecx = number of vectors, edx = base
+        mov     ebp, edx        ; base of auxv
+
+        cmp     ecx, 32         ; more than 32 vectors
+        jl      rel_auxv        ;   not enough -> relocate
+
+        xor     eax, eax
+        jmp     do_auxv
+
+        ; we need eax more vectors
+rel_auxv:
+        mov     eax, 32
+        sub     eax, ecx
+        shl     eax, 3          ; * 8
+
+do_auxv:
+        mov     esi, esp
+        sub     esp, eax
+        mov     edi, esp
+        sub     ebp, eax
+
+        ; relocate auxiliary vectors
+        call    be_auxvreloc    ; in: esi = &argc ; out: edx = env[0]
+
+        pop     eax             ; eax = argc
+        push    eax
+        push    ebx             ; SAVE flag register
+
+        push    eax             ; argc
+        mov     eax, esp
+        add     eax, 12         ; &argv[0]
+        push    eax
+
+        push    edx             ; env
+        push    ebp             ; lowest vector
+        push    ecx             ; number of real vectors, space is for 32
+        call    burneye         ; returns: eax = entry point of rtld/exe
+        add     esp, (5 * 4)
+
+        pop     ebx             ; RESTORE flag register
+        push    eax             ; save entry point on stack, to 'ret' to
+
+        ; make an 'oops... i did it again' virgin stack space
+%define BRITNEY 1024
+        lea     edi, [esp - 4 * BRITNEY]
+        pusha
+        sub     esp, (BRITNEY * 4)
+        mov     ecx, BRITNEY
+        xor     eax, eax
+        rep     stosd           ; zap array
+        add     esp, (BRITNEY * 4)
+
+        ; thanks to john reiser <jreister@bitwagon.com> for fixing this nasty
+        ; bug :-)
+        push    ebx             ; i hate x86 register poorness
+        popf                    ; restore original flags
+        push    dword 0         ; clear stack element
+        pop     ebx
+
+
+%ifdef VDEBUG
+        int3                    ; FINAL BREAKPOINT
+%endif
+
+        popa                    ; all regs except eip/esp are zero'ed now
+        ret                     ; return to entry point of ld-linux.so.*
+
+
+; be_auxvreloc, insert 
+;
+; in: esi = source &argc, edi = dest
+; out: edi = &old_auxv[AT_NULL]
+;
+
+be_auxvreloc:
+rarg:   lodsd
+        stosd
+        or      eax, eax
+        jnz     be_auxvreloc
+
+        mov     edx, edi        ; new &env[0]
+renv:   lodsd
+        stosd
+        or      eax, eax
+        jnz     renv
+
+raux:   lodsd
+        stosd
+        or      eax, eax
+        lodsd
+        stosd
+        jnz     raux
+
+        sub     edi, 8
+        ret
+
+; be_auxv, find and count aux vectors
+;
+; stack looks like (at esi);
+; <argc> <argc pointers> <NULL> <env[0], env[1], ...> <NULL> <aux> <env>
+be_auxv:
+        ; skip arguments
+        lodsd
+        shl     eax, 2
+        add     eax, 4
+        add     esi, eax
+
+        ; skip environment
+skenv:  lodsd
+        or      eax, eax
+        jnz     skenv
+
+        xor     ecx, ecx        ; counter = 0
+        mov     edx, esi        ; &auxv[0]
+skaux:  lodsd
+        inc     ecx
+        or      eax, eax
+        lodsd
+        jnz     skaux
+
+        ; we have ecx vectors now, INCLUDING the AT_NULL vector
+        ret
+
+; be_findenv, find environment pointer array
+;
+; esi = pointer to lowest vector
+;
+; return: esi = env[0]
+;
+
diff --git a/other/burneye/src/stub/lde-test b/other/burneye/src/stub/lde-test
new file mode 100644
index 0000000..fce700b
--- /dev/null
+++ b/other/burneye/src/stub/lde-test
diff --git a/other/burneye/src/stub/lde-test.c b/other/burneye/src/stub/lde-test.c
new file mode 100644
index 0000000..b43e9f9
--- /dev/null
+++ b/other/burneye/src/stub/lde-test.c
@@ -0,0 +1,62 @@
+/* lde testing
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "lde32.h"
+
+
+int disasm_me (int a, int b);
+
+
+int
+main (int argc, char *argv[])
+{
+        int             n,
+                        len;
+        unsigned char * d;
+        unsigned char   lde_data[2048];
+
+
+        memset (lde_data, '\0', sizeof (lde_data));
+        lde_init ((lde_table *) lde_data);
+
+        for (d = (unsigned char *) disasm_me ; *d != 0xcc ; d += len) {
+
+                len = lde_dis (d, (lde_table *) lde_data);
+
+                if (len <= 0) {
+                        fprintf (stderr, "len = %d\n", len);
+
+                        exit (EXIT_FAILURE);
+                }
+
+                printf ("0x%08lx [%2d]: ", (unsigned long int) d, len);
+                for (n = 0 ; n < len ; ++n)
+                        printf ("%02x ", d[n]);
+
+                printf ("\n");
+        }
+
+        exit (EXIT_SUCCESS);
+}
+
+
+int
+disasm_me (int a, int b)
+{
+        a *= b;
+        a >>= (b & 0x04);
+        a += b & ~0x04;
+        a ^= b;
+        b ^= a;
+        a ^= b;
+        a ^= ~b;
+        b *= a | b;
+
+        return (a + b);
+
+        asm ("int3");
+}
+
+
diff --git a/other/burneye/src/stub/lde32.asm b/other/burneye/src/stub/lde32.asm
new file mode 100644
index 0000000..4eacf3a
--- /dev/null
+++ b/other/burneye/src/stub/lde32.asm
@@ -0,0 +1,345 @@
+

+; LDE32 -- Length-Disassembler Engine

+; FREEWARE

+;

+; programmed by Z0MBiE, http://z0mbie.cjb.net

+;

+; release 1.00          8-12-99

+; release 1.01          9-12-99

+; release 1.02         17-03-00  0xF6/0xF7 'test' opcode bugfixed

+; release 1.03         21-04-00  bugfix: some prefixes before 0F were cleared

+;                                bugfix: error in MODRM analysis

+;                                CD 20 now is 6 bytes length

+; release 1.04          1-05-00  AAM & AAD bugfixed (was 1-byte len)

+; release 1.05         xx-xx-xx  special edition, flags changed

+; release 1.06          3-01-01  partially rewritten, __cdecl

+

+; some very small mods/changes by scut to compile under nasm

+

+

+C_ERROR         equ     -1              ; never change it

+

+C_MEM1          equ     0x0001       ; |

+C_MEM2          equ     0x0002       ; |may be used simultaneously

+C_MEM4          equ     0x0004       ; |

+C_DATA1         equ     0x0100       ; |

+C_DATA2         equ     0x0200       ; |may be used simultaneously

+C_DATA4         equ     0x0400       ; |

+C_67            equ     0x0010       ; used with C_PREFIX

+C_MEM67         equ     0x0020       ; C_67 ? C_MEM2 : C_MEM4

+C_66            equ     0x1000       ; used with C_PREFIX

+C_DATA66        equ     0x2000       ; C_66 ? C_DATA2 : C_DATA4

+C_PREFIX        equ     0x0008       ; prefix. take opcode again

+C_MODRM         equ     0x4000       ; MODxxxR/M

+C_DATAW0        equ     0x8000       ; opc&1 ? C_DATA66 : C_DATA1

+

+

+; void __cdecl lde_init(void* tableptr);

+

+        BITS    32

+

+        GLOBAL  lde_init

+

+lde_init:

+        pusha

+        mov     edi, [esp+32+4]

+        cld

+

+        ; Huffman-compressed 2048-byte table

+        xor     eax, eax

+        push    eax

+        push    eax

+        push    eax

+        push    dword 0x002AAA800

+        push    dword 0x03FFF687F

+        push    dword 0x0FFE6DEA0

+        push    dword 0x0DBD5FFFF

+        push    dword 0x0FFFEAAAA

+        push    dword 0x0AAAAAAAA

+        push    dword 0x0AAAA0000

+        push    eax

+        push    eax

+        push    eax

+        push    eax

+        push    eax

+        push    eax

+        push    dword 0x000000154

+        push    dword 0x041FFF555

+        push    dword 0x055DEDDAA

+        push    dword 0x019955111

+        push    dword 0x011111FFF

+        push    dword 0x0FA11FFAA

+        push    dword 0x08E60CF96

+        push    dword 0x0FC72D6AA

+        push    dword 0x0AAAAAA88

+        push    dword 0x0888888D5

+        push    dword 0x0528D559B

+        push    dword 0x0366CD553

+        push    dword 0x0355555FF

+        push    dword 0x0FFFED6F9

+        push    dword 0x068888888

+        push    dword 0x088888888

+        push    dword 0x08D5347CA

+        push    dword 0x0DCC67BDF

+        push    dword 0x0AAAAAAAA

+        push    dword 0x0AAAAAAAA

+        push    dword 0x0ABA94FFD

+        push    dword 0x0D4A7FEEA

+        push    dword 0x053FF7529

+        push    dword 0x0FFA4A7FE

+        push    dword 0x0929FFA4A

+        push    dword 0x07FE929FF

+

+        mov     ecx, 512

+        xor     ebx, ebx

+cycle:  xor     eax, eax

+        call    tree

+        stosd

+        loop    cycle

+

+        popa

+        retn

+

+getbit: or      ebx, ebx

+        jnz     skip

+        pop     ebp

+        pop     esi

+        pop     edx

+        push    esi

+        push    ebp

+        mov     bl, 32

+skip:   dec     ebx

+        shr     edx, 1

+        retn

+

+        ; Huffman-tree, compiled into decompressor code

+tree:   call    getbit

+        jnc     tree0

+tree1:  call    getbit

+        jnc     tree10

+tree11: mov     ah, (C_MODRM >> 8)

+        retn

+tree10: call    getbit

+        jc      tree101

+tree100:

+        call    getbit

+        jnc     tree1000

+tree1001:

+        call    getbit

+        jnc     tree10010

+tree10011:

+        call    getbit

+        jc      tree100111

+tree100110:

+        call    getbit

+        jnc     tree1001100

+tree1001101:

+        mov     al, C_MEM67

+        retn

+tree1001100:

+        call    getbit

+        jnc     tree10011000

+tree10011001:

+        mov     ax, C_DATA66+C_MEM2

+        retn

+tree10011000:

+        call    getbit

+        jnc     tree100110000

+tree100110001:

+        mov     ax, C_PREFIX+C_66

+        retn

+tree100110000:

+        mov     ah, ((C_DATA2+C_DATA1) >> 8)

+        retn

+tree100111:

+        call    getbit

+        jnc     tree1001110

+tree1001111:

+        mov     ah, ((C_MODRM+C_DATA66) >> 8)

+        retn

+tree1001110:

+        call    getbit

+        jnc     tree10011100

+tree10011101:

+        mov     al, C_PREFIX+C_67

+        retn

+tree10011100:

+        mov     ah, (C_DATA2 >> 8)

+        retn

+tree10010:

+        mov     ah, (C_DATAW0 >> 8)

+        retn

+tree1000:

+        mov     ah, (C_DATA1 >> 8)

+        retn

+tree101:

+        call    getbit

+        jnc     tree1010

+tree1011:

+        call    getbit

+        jnc     tree10110

+tree10111:

+        mov     al, C_PREFIX

+        retn

+tree10110:

+        mov     ah, ((C_MODRM+C_DATA1) >> 8)

+        retn

+tree1010:

+        mov     ah, (C_DATA66 >> 8)

+        retn

+tree0:  call    getbit

+;       jc      tree01

+        adc     al, 0

+tree00: dec     eax

+tree01: retn

+

+

+; int __cdecl lde_dis(void* opcodeptr, void* tableptr)

+; {

+

+; returns opcode length in EAX or -1 if error

+

+        GLOBAL  lde_dis

+

+lde_dis:

+        pusha

+

+        mov     esi, [esp+32+4] ; tableptr

+        mov     ecx, [esp+32+8] ; param = opcode ptr

+

+        xor     edx, edx        ; flags

+        xor     eax, eax

+

+prefix: and     dl, ~C_PREFIX

+

+        mov     al, [ecx]

+        inc     ecx

+

+        or      edx, [esi+eax*4]

+

+        test    dl, C_PREFIX

+        jnz     prefix

+

+        cmp     al, 0xf6

+        je      btest

+        cmp     al, 0xf7

+        je      btest

+

+        cmp     al, 0xcd

+        je      bint

+

+        cmp     al, 0x0f

+        je      b0F

+

+cont:   test    dh, (C_DATAW0 >> 8)

+        jnz     dataw0

+

+dataw0done:

+        test    dh, (C_MODRM >> 8)

+        jnz     near modrm

+

+exitmodrm:

+        test    dl, C_MEM67

+        jnz     mem67

+

+mem67done:

+        test    dh, (C_DATA66 >> 8)

+        jnz     data66

+

+data66done:

+        mov     eax, ecx

+        sub     eax, [esp+32+8]

+

+        and     edx, C_MEM1+C_MEM2+C_MEM4 + C_DATA1+C_DATA2+C_DATA4

+        add     al, dl

+        add     al, dh

+

+exit:   mov     [esp+7*4], eax

+        popa

+        retn

+

+btest:  or      dh, (C_MODRM >> 8)

+        test    byte [ecx], 00111000b   ; F6/F7 -- test

+        jnz     cont

+        or      dh, (C_DATAW0 >> 8)

+        jmp     cont

+

+bint:   or      dh, (C_DATA1 >> 8)

+        cmp     byte [ecx], 0x20

+        jne     cont

+        or      dh, (C_DATA4 >> 8)

+        jmp     cont

+

+b0F:    mov     al, [ecx]

+        inc     ecx

+        or      edx, [esi+eax*4+1024]   ; 2nd half

+        cmp     edx, -1

+        jne     cont

+

+error:  mov     eax, edx

+        jmp     exit

+

+dataw0: xor     dh, (C_DATA66 >> 8)

+        test    al, 00000001b

+        jnz     dataw0done

+        xor     dh, ((C_DATA66+C_DATA1) >> 8)

+        jmp     dataw0done

+

+mem67:  xor     dl, C_MEM2

+        test    dl, C_67

+        jnz     mem67done

+        xor     dl, C_MEM4+C_MEM2

+        jmp     mem67done

+

+data66: xor     dh, (C_DATA2 >> 8)

+        test    dh, (C_66 >> 8)

+        jnz     data66done

+        xor     dh, ((C_DATA4+C_DATA2) >> 8)

+        jmp     data66done

+

+modrm:  mov     al, [ecx]

+        inc     ecx

+

+        mov     ah, al          ; ah=mod, al=rm

+

+        and     ax, 0xc007

+        cmp     ah, 0xc0

+        je      near exitmodrm

+

+        test    dl, C_67

+        jnz     modrm16

+

+modrm32:

+        cmp     al, 0x04

+        jne     a

+

+        mov     al, [ecx]       ; sib

+        inc     ecx

+        and     al, 0x07

+

+a:      cmp     ah, 0x40

+        je      mem1

+        cmp     ah, 0x80

+        je      mem4

+

+        cmp     ax, 0x0005

+        jne     near exitmodrm

+

+mem4:   or      dl, C_MEM4

+        jmp     exitmodrm

+

+mem1:   or      dl, C_MEM1

+        jmp     exitmodrm

+

+modrm16:

+        cmp     ax, 0x0006

+        je      mem2

+        cmp     ah, 0x40

+        je      mem1

+        cmp     ah, 0x80

+        jne     near exitmodrm

+

+mem2:   or      dl, C_MEM2

+        jmp     exitmodrm

+

+

diff --git a/other/burneye/src/stub/lde32.h b/other/burneye/src/stub/lde32.h
new file mode 100644
index 0000000..71f030b
--- /dev/null
+++ b/other/burneye/src/stub/lde32.h
@@ -0,0 +1,31 @@
+/* length disassembling engine - C interface header file
+ */
+
+#ifndef LDE32_H
+#define LDE32_H
+
+typedef void    lde_table;
+
+/* lde_init
+ *
+ * initialize 2048 byte table for use with LDE at `tableptr'. `tableptr' has
+ * to point to at least 2048 reserved bytes.
+ *
+ * return in any case
+ */
+
+void
+lde_init (lde_table *tableptr);
+
+
+/* lde_dis
+ *
+ * return opcode length in bytes on success
+ * return -1 on failure
+ */
+
+int
+lde_dis (unsigned char *instr, lde_table *tableptr);
+
+#endif
+
diff --git a/other/burneye/src/stub/rs.c b/other/burneye/src/stub/rs.c
new file mode 100644
index 0000000..3cecc39
--- /dev/null
+++ b/other/burneye/src/stub/rs.c
@@ -0,0 +1,573 @@
+
+/*
+ * Reed-Solomon coding and decoding
+ * Phil Karn (karn at ka9q.ampr.org) September 1996
+ * small mods by scut
+ * 
+ * This file is derived from the program "new_rs_erasures.c" by Robert
+ * Morelos-Zaragoza (robert at spectra.eng.hawaii.edu) and Hari Thirumoorthy
+ * (harit at spectra.eng.hawaii.edu), Aug 1995
+ *
+ * I've made changes to improve performance, clean up the code and make it
+ * easier to follow. Data is now passed to the encoding and decoding functions
+ * through arguments rather than in global arrays. The decode function returns
+ * the number of corrected symbols, or -1 if the word is uncorrectable.
+ *
+ * This code supports a symbol size from 2 bits up to 16 bits,
+ * implying a block size of 3 2-bit symbols (6 bits) up to 65535
+ * 16-bit symbols (1,048,560 bits). The code parameters are set in rs.h.
+ *
+ * Note that if symbols larger than 8 bits are used, the type of each
+ * data array element switches from unsigned char to unsigned int. The
+ * caller must ensure that elements larger than the symbol range are
+ * not passed to the encoder or decoder.
+ *
+ */
+#include "rs.h"
+
+#ifdef IN_STUB
+#include "helper.h"
+#include "include/int80.h"
+#include "include/unistd.h"
+#else
+#include <stdio.h>
+#endif
+
+
+/* Initialization function */
+static void rs_init (void);
+
+/* These two functions *must* be called in this order (e.g.,
+ * by init_rs()) before any encoding/decoding
+ */
+
+static void generate_gf (void); /* Generate Galois Field */
+static void gen_poly (void);    /* Generate generator polynomial */
+
+
+
+/* global variables
+ */
+
+unsigned int    KK = 4015;
+
+/* This defines the type used to store an element of the Galois Field
+ * used by the code. Make sure this is something larger than a char if
+ * if anything larger than GF(256) is used.
+ *
+ * Note: unsigned char will work up to GF(256) but int seems to run
+ * faster on the Pentium.
+ */
+typedef int gf;
+
+/* 1+x+x^4+x^6+x^12 */
+int Pp[MM+1] = { 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1 };
+
+/* Alpha exponent for the first root of the generator polynomial */
+#define B0      1
+
+/* index->polynomial form conversion table */
+gf *    Alpha_to = NULL;
+
+/* Polynomial->index form conversion table */
+gf *    Index_of = NULL;
+
+/* No legal value in index form represents zero, so
+ * we need a special value for this purpose
+ */
+#define A0      (NN)
+
+/* Generator polynomial g(x)
+ * Degree of g(x) = 2*TT
+ * has roots @**B0, @**(B0+1), ... ,@^(B0+2*TT-1)
+ */
+gf *    Gg = NULL;
+
+
+/* Compute x % NN, where NN is 2**MM - 1,
+ * without a slow divide
+ */
+static inline gf
+modnn(int x)
+{
+        while (x >= NN) {
+                x -= NN;
+                x = (x >> MM) + (x & NN);
+        }
+        return x;
+}
+
+#define min(a,b)        ((a) < (b) ? (a) : (b))
+
+#define CLEAR(a,n) {\
+        int ci;\
+        for(ci=(n)-1;ci >=0;ci--)\
+                (a)[ci] = 0;\
+        }
+
+#define COPY(a,b,n) {\
+        int ci;\
+        for(ci=(n)-1;ci >=0;ci--)\
+                (a)[ci] = (b)[ci];\
+        }
+#define COPYDOWN(a,b,n) {\
+        int ci;\
+        for(ci=(n)-1;ci >=0;ci--)\
+                (a)[ci] = (b)[ci];\
+        }
+
+static void
+rs_init (void)
+{
+        generate_gf();
+        gen_poly();
+}
+
+/* generate GF(2**m) from the irreducible polynomial p(X) in p[0]..p[m]
+   lookup tables:  index->polynomial form   alpha_to[] contains j=alpha**i;
+                   polynomial form -> index form  index_of[j=alpha**i] = i
+   alpha=2 is the primitive element of GF(2**m)
+   HARI's COMMENT: (4/13/94) alpha_to[] can be used as follows:
+        Let @ represent the primitive element commonly called "alpha" that
+   is the root of the primitive polynomial p(x). Then in GF(2^m), for any
+   0 <= i <= 2^m-2,
+        @^i = a(0) + a(1) @ + a(2) @^2 + ... + a(m-1) @^(m-1)
+   where the binary vector (a(0),a(1),a(2),...,a(m-1)) is the representation
+   of the integer "alpha_to[i]" with a(0) being the LSB and a(m-1) the MSB. Thu
+s for
+   example the polynomial representation of @^5 would be given by the binary
+   representation of the integer "alpha_to[5]".
+                   Similarily, index_of[] can be used as follows:
+        As above, let @ represent the primitive element of GF(2^m) that is
+   the root of the primitive polynomial p(x). In order to find the power
+   of @ (alpha) that has the polynomial representation
+        a(0) + a(1) @ + a(2) @^2 + ... + a(m-1) @^(m-1)
+   we consider the integer "i" whose binary representation with a(0) being LSB
+   and a(m-1) MSB is (a(0),a(1),...,a(m-1)) and locate the entry
+   "index_of[i]". Now, @^index_of[i] is that element whose polynomial 
+    representation is (a(0),a(1),a(2),...,a(m-1)).
+   NOTE:
+        The element alpha_to[2^m-1] = 0 always signifying that the
+   representation of "@^infinity" = 0 is (0,0,0,...,0).
+        Similarily, the element index_of[0] = A0 always signifying
+   that the power of alpha which has the polynomial representation
+   (0,0,...,0) is "infinity".
+ 
+*/
+
+static void
+generate_gf (void)
+{
+        register int i, mask;
+
+        mask = 1;
+        Alpha_to[MM] = 0;
+        for (i = 0; i < MM; i++) {
+                Alpha_to[i] = mask;
+                Index_of[Alpha_to[i]] = i;
+                /* If Pp[i] == 1 then, term @^i occurs in poly-repr of @^MM */
+                if (Pp[i] != 0)
+                        Alpha_to[MM] ^= mask;   /* Bit-wise EXOR operation */
+                mask <<= 1;     /* single left-shift */
+        }
+        Index_of[Alpha_to[MM]] = MM;
+        /*
+         * Have obtained poly-repr of @^MM. Poly-repr of @^(i+1) is given by
+         * poly-repr of @^i shifted left one-bit and accounting for any @^MM
+         * term that may occur when poly-repr of @^i is shifted.
+         */
+        mask >>= 1;
+        for (i = MM + 1; i < NN; i++) {
+                if (Alpha_to[i - 1] >= mask)
+                        Alpha_to[i] = Alpha_to[MM] ^ ((Alpha_to[i - 1] ^ mask) << 1);
+                else
+                        Alpha_to[i] = Alpha_to[i - 1] << 1;
+                Index_of[Alpha_to[i]] = i;
+        }
+        Index_of[0] = A0;
+        Alpha_to[NN] = 0;
+}
+
+
+/*
+ * Obtain the generator polynomial of the TT-error correcting, length
+ * NN=(2**MM -1) Reed Solomon code from the product of (X+@**(B0+i)), i = 0,
+ * ... ,(2*TT-1)
+ *
+ * Examples:
+ *
+ * If B0 = 1, TT = 1. deg(g(x)) = 2*TT = 2.
+ * g(x) = (x+@) (x+@**2)
+ *
+ * If B0 = 0, TT = 2. deg(g(x)) = 2*TT = 4.
+ * g(x) = (x+1) (x+@) (x+@**2) (x+@**3)
+ */
+static void
+gen_poly(void)
+{
+        register int i, j;
+
+        Gg[0] = Alpha_to[B0];
+        Gg[1] = 1;              /* g(x) = (X+@**B0) initially */
+        for (i = 2; i <= NN - KK; i++) {
+                Gg[i] = 1;
+                /*
+                 * Below multiply (Gg[0]+Gg[1]*x + ... +Gg[i]x^i) by
+                 * (@**(B0+i-1) + x)
+                 */
+                for (j = i - 1; j > 0; j--)
+                        if (Gg[j] != 0)
+                                Gg[j] = Gg[j - 1] ^ Alpha_to[modnn((Index_of[Gg[j]]) + B0 + i - 1)];
+                        else
+                                Gg[j] = Gg[j - 1];
+                /* Gg[0] can never be zero */
+                Gg[0] = Alpha_to[modnn((Index_of[Gg[0]]) + B0 + i - 1)];
+        }
+        /* convert Gg[] to index form for quicker encoding */
+        for (i = 0; i <= NN - KK; i++)
+                Gg[i] = Index_of[Gg[i]];
+}
+
+
+/*
+ * take the string of symbols in data[i], i=0..(k-1) and encode
+ * systematically to produce NN-KK parity symbols in bb[0]..bb[NN-KK-1] data[]
+ * is input and bb[] is output in polynomial form. Encoding is done by using
+ * a feedback shift register with appropriate connections specified by the
+ * elements of Gg[], which was generated above. Codeword is   c(X) =
+ * data(X)*X**(NN-KK)+ b(X)
+ */
+int
+rs_encode (dtype data[KK], dtype bb[NN-KK])
+{
+        int     i,
+                j;
+        gf      feedback;
+        gf      Alpha_to_s[NN + 1];
+        gf      Index_of_s[NN + 1];
+        gf      Gg_s[NN - KK + 1];
+
+
+        /* tradeoff: gain .bss space, lose time */
+        Alpha_to = Alpha_to_s;
+        Index_of = Index_of_s;
+        Gg = Gg_s;
+        rs_init ();
+
+        CLEAR(bb,NN-KK);
+        for (i = KK - 1; i >= 0; i--) {
+                if(data[i] > NN)
+                        return -1;      /* Illegal symbol */
+
+                feedback = Index_of[data[i] ^ bb[NN - KK - 1]];
+                if (feedback != A0) {   /* feedback term is non-zero */
+                        for (j = NN - KK - 1; j > 0; j--)
+                                if (Gg[j] != A0)
+                                        bb[j] = bb[j - 1] ^ Alpha_to[modnn(Gg[j] + feedback)];
+                                else
+                                        bb[j] = bb[j - 1];
+                        bb[0] = Alpha_to[modnn(Gg[0] + feedback)];
+                } else {        /* feedback term is zero. encoder becomes a
+                                 * single-byte shifter */
+                        for (j = NN - KK - 1; j > 0; j--)
+                                bb[j] = bb[j - 1];
+                        bb[0] = 0;
+                }
+        }
+        return 0;
+}
+
+/*
+ * Performs ERRORS+ERASURES decoding of RS codes. If decoding is successful,
+ * writes the codeword into data[] itself. Otherwise data[] is unaltered.
+ *
+ * Return number of symbols corrected, or -1 if codeword is illegal
+ * or uncorrectable.
+ * 
+ * First "no_eras" erasures are declared by the calling program. Then, the
+ * maximum # of errors correctable is t_after_eras = floor((NN-KK-no_eras)/2).
+ * If the number of channel errors is not greater than "t_after_eras" the
+ * transmitted codeword will be recovered. Details of algorithm can be found
+ * in R. Blahut's "Theory ... of Error-Correcting Codes".
+ */
+int
+rs_eras_dec (dtype data[NN], int eras_pos[NN-KK], int no_eras)
+{
+        int     deg_lambda,
+                deg_omega,
+                el;
+        int     i,
+                j,
+                r;
+        gf      u,
+                q,
+                tmp,
+                num1,
+                num2,
+                den,
+                discr_r;
+        gf      recd[NN];
+        gf      lambda[NN-KK + 1],
+                s[NN-KK + 1];     /* Err+Eras Locator poly and syndrome poly */
+        gf      b[NN-KK + 1],
+                t[NN-KK + 1],
+                omega[NN-KK + 1];
+        gf      root[NN-KK],
+                reg[NN-KK + 1],
+                loc[NN-KK];
+        int     syn_error,
+                count;
+
+        gf      Alpha_to_s[NN + 1];
+        gf      Index_of_s[NN + 1];
+        gf      Gg_s[NN - KK + 1];
+
+
+        /* tradeoff: gain .bss space, lose time */
+        Alpha_to = Alpha_to_s;
+        Index_of = Index_of_s;
+        Gg = Gg_s;
+        rs_init ();
+
+        /* data[] is in polynomial form, copy and convert to index form */
+        for (i = NN-1; i >= 0; i--){
+                if(data[i] > NN)
+                        return -1;      /* Illegal symbol */
+
+                recd[i] = Index_of[data[i]];
+        }
+        /* first form the syndromes; i.e., evaluate recd(x) at roots of g(x)
+         * namely @**(B0+i), i = 0, ... ,(NN-KK-1)
+         */
+        syn_error = 0;
+        for (i = 1; i <= NN-KK; i++) {
+                tmp = 0;
+                for (j = 0; j < NN; j++)
+                        if (recd[j] != A0)      /* recd[j] in index form */
+                                tmp ^= Alpha_to[modnn(recd[j] + (B0+i-1)*j)];
+                syn_error |= tmp;       /* set flag if non-zero syndrome =>
+                                         * error */
+                /* store syndrome in index form  */
+                s[i] = Index_of[tmp];
+        }
+        if (!syn_error) {
+                /*
+                 * if syndrome is zero, data[] is a codeword and there are no
+                 * errors to correct. So return data[] unmodified
+                 */
+                return 0;
+        }
+        CLEAR(&lambda[1],NN-KK);
+        lambda[0] = 1;
+        if (no_eras > 0) {
+                /* Init lambda to be the erasure locator polynomial */
+                lambda[1] = Alpha_to[eras_pos[0]];
+                for (i = 1; i < no_eras; i++) {
+                        u = eras_pos[i];
+                        for (j = i+1; j > 0; j--) {
+                                tmp = Index_of[lambda[j - 1]];
+                                if(tmp != A0)
+                                        lambda[j] ^= Alpha_to[modnn(u + tmp)];
+                        }
+                }
+        }
+        for(i=0;i<NN-KK+1;i++)
+                b[i] = Index_of[lambda[i]];
+
+        /*
+         * Begin Berlekamp-Massey algorithm to determine error+erasure
+         * locator polynomial
+         */
+        r = no_eras;
+        el = no_eras;
+        while (++r <= NN-KK) {  /* r is the step number */
+                /* Compute discrepancy at the r-th step in poly-form */
+                discr_r = 0;
+                for (i = 0; i < r; i++){
+                        if ((lambda[i] != 0) && (s[r - i] != A0)) {
+                                discr_r ^= Alpha_to[modnn(Index_of[lambda[i]] + s[r - i])];
+                        }
+                }
+                discr_r = Index_of[discr_r];    /* Index form */
+                if (discr_r == A0) {
+                        /* 2 lines below: B(x) <-- x*B(x) */
+                        COPYDOWN(&b[1],b,NN-KK);
+                        b[0] = A0;
+                } else {
+                        /* 7 lines below: T(x) <-- lambda(x) - discr_r*x*b(x) */
+                        t[0] = lambda[0];
+                        for (i = 0 ; i < NN-KK; i++) {
+                                if(b[i] != A0)
+                                        t[i+1] = lambda[i+1] ^ Alpha_to[modnn(discr_r + b[i])];
+                                else
+                                        t[i+1] = lambda[i+1];
+                        }
+                        if (2 * el <= r + no_eras - 1) {
+                                el = r + no_eras - el;
+                                /*
+                                 * 2 lines below: B(x) <-- inv(discr_r) *
+                                 * lambda(x)
+                                 */
+                                for (i = 0; i <= NN-KK; i++)
+                                        b[i] = (lambda[i] == 0) ? A0 : modnn(Index_of[lambda[i]] - discr_r + NN);
+                        } else {
+                                /* 2 lines below: B(x) <-- x*B(x) */
+                                COPYDOWN(&b[1],b,NN-KK);
+                                b[0] = A0;
+                        }
+                        COPY(lambda,t,NN-KK+1);
+                }
+        }
+
+        /* Convert lambda to index form and compute deg(lambda(x)) */
+        deg_lambda = 0;
+        for(i=0;i<NN-KK+1;i++){
+                lambda[i] = Index_of[lambda[i]];
+                if(lambda[i] != A0)
+                        deg_lambda = i;
+        }
+        /*
+         * Find roots of the error+erasure locator polynomial. By Chien
+         * Search
+         */
+        COPY(&reg[1],&lambda[1],NN-KK);
+        count = 0;              /* Number of roots of lambda(x) */
+        for (i = 1; i <= NN; i++) {
+                q = 1;
+                for (j = deg_lambda; j > 0; j--)
+                        if (reg[j] != A0) {
+                                reg[j] = modnn(reg[j] + j);
+                                q ^= Alpha_to[reg[j]];
+                        }
+                if (!q) {
+                        /* store root (index-form) and error location number */
+                        root[count] = i;
+                        loc[count] = NN - i;
+                        count++;
+                }
+        }
+
+        if (deg_lambda != count) {
+                /*
+                 * deg(lambda) unequal to number of roots => uncorrectable
+                 * error detected
+                 */
+                return -1;
+        }
+        /*
+         * Compute err+eras evaluator poly omega(x) = s(x)*lambda(x) (modulo
+         * x**(NN-KK)). in index form. Also find deg(omega).
+         */
+        deg_omega = 0;
+        for (i = 0; i < NN-KK;i++){
+                tmp = 0;
+                j = (deg_lambda < i) ? deg_lambda : i;
+                for(;j >= 0; j--){
+                        if ((s[i + 1 - j] != A0) && (lambda[j] != A0))
+                                tmp ^= Alpha_to[modnn(s[i + 1 - j] + lambda[j])];
+                }
+                if(tmp != 0)
+                        deg_omega = i;
+                omega[i] = Index_of[tmp];
+        }
+        omega[NN-KK] = A0;
+
+        /*
+         * Compute error values in poly-form. num1 = omega(inv(X(l))), num2 =
+         * inv(X(l))**(B0-1) and den = lambda_pr(inv(X(l))) all in poly-form
+         */
+        for (j = count-1; j >=0; j--) {
+                num1 = 0;
+                for (i = deg_omega; i >= 0; i--) {
+                        if (omega[i] != A0)
+                                num1  ^= Alpha_to[modnn(omega[i] + i * root[j])];
+                }
+                num2 = Alpha_to[modnn(root[j] * (B0 - 1) + NN)];
+                den = 0;
+
+                /* lambda[i+1] for i even is the formal derivative lambda_pr of
+ lambda[i] */
+                for (i = min(deg_lambda,NN-KK-1) & ~1; i >= 0; i -=2) {
+                        if(lambda[i+1] != A0)
+                                den ^= Alpha_to[modnn(lambda[i+1] + i * root[j])];
+                }
+                if (den == 0) {
+                        return -1;
+                }
+                /* Apply error to data */
+                if (num1 != 0) {
+                        data[loc[j]] ^= Alpha_to[modnn(Index_of[num1] + Index_of[num2] + NN - Index_of[den])];
+                }
+        }
+        return count;
+}
+
+
+void
+rs_trans (unsigned char *buffer, unsigned long int buf_len,
+        unsigned int *trans, unsigned long int trans_len)
+{
+        unsigned int    n,
+                        t;
+
+
+        memset (trans, '\0', sizeof (trans[0]) * trans_len);
+        if ((((buf_len * 8) / 12)) > trans_len)
+                _exit (73);
+
+        /* 8 to 12 bit expander to use 2^12 galois field */
+        for (n = 0, t = 0 ; n < buf_len ; ++n) {
+                switch (n % 3) {
+                case (0):
+                        trans[t] = buffer[n];
+                        break;
+                case (1):
+                        trans[t] |= (buffer[n] & 0x0f) << 8;
+                        trans[t + 1] = buffer[n] >> 4;
+                        t += 1;
+                        break;
+                case (2):
+                        trans[t] |= buffer[n] << 4;
+                        t += 1;
+                        break;
+                }
+        }
+
+        return;
+}
+
+
+/* and the reverse (12 to 8 bit)
+ */
+void
+rs_detrans (unsigned char *buffer, unsigned long int buf_len,
+        unsigned int *trans, unsigned long int trans_len)
+{
+        unsigned int    n,
+                        t;
+
+
+        memset (buffer, '\0', buf_len);
+
+        if (((trans_len * 12) / 8) > buf_len)
+                _exit (73);
+
+        for (n = 0, t = 0 ; t < trans_len ; ++t) {
+                switch (t % 2) {
+                case (0):
+                        buffer[n] = trans[t] & 0xff;
+                        buffer[n + 1] = trans[t] >> 8;
+                        n += 1;
+                        break;
+                case (1):
+                        buffer[n] |= (trans[t] & 0x0f) << 4;
+                        buffer[n + 1] = trans[t] >> 4;
+                        n += 2;
+                        break;
+                }
+        }
+
+        return;
+}
+
+
diff --git a/other/burneye/src/stub/rs.h b/other/burneye/src/stub/rs.h
new file mode 100644
index 0000000..70ce7d0
--- /dev/null
+++ b/other/burneye/src/stub/rs.h
@@ -0,0 +1,62 @@
+
+/* Global definitions for Reed-Solomon encoder/decoder
+ * Phil Karn KA9Q, September 1996
+ *
+ * The parameters MM and KK specify the Reed-Solomon code parameters.
+ *
+ * Set MM to be the size of each code symbol in bits. The Reed-Solomon
+ * block size will then be NN = 2**M - 1 symbols. Supported values are
+ * defined in rs.c.
+ *
+ * Set KK to be the number of data symbols in each block, which must be
+ * less than the block size. The code will then be able to correct up
+ * to NN-KK erasures or (NN-KK)/2 errors, or combinations thereof with
+ * each error counting as two erasures.
+ */
+
+#ifndef RS_H
+#define RS_H
+
+#define MM      12                      /* RS code over GF(2**MM) - change to suit */
+//#define       KK      4015    /* 223 */       /* KK = number of information symbols */
+
+#define NN      ((1 << MM) - 1)
+
+#if (MM <= 8)
+typedef unsigned char dtype;
+#else
+typedef unsigned int dtype;
+#endif
+
+
+/* Reed-Solomon encoding
+ * data[] is the input block, parity symbols are placed in bb[]
+ * bb[] may lie past the end of the data, e.g., for (255,223):
+ *      encode_rs(&data[0],&data[223]);
+ */
+int rs_encode (dtype data[], dtype bb[]);
+
+/* Reed-Solomon erasures-and-errors decoding
+ * The received block goes into data[], and a list of zero-origin
+ * erasure positions, if any, goes in eras_pos[] with a count in no_eras.
+ *
+ * The decoder corrects the symbols in place, if possible and returns
+ * the number of corrected symbols. If the codeword is illegal or
+ * uncorrectible, the data array is unchanged and -1 is returned
+ */
+int rs_eras_dec (dtype data[], int eras_pos[], int no_eras);
+
+
+/* buf_len is the constraining factor here */
+void
+rs_trans (unsigned char *buffer, unsigned long int buf_len,
+        unsigned int *trans, unsigned long int trans_len);
+
+/* here it is trans_len ! */
+void
+rs_detrans (unsigned char *buffer, unsigned long int buf_len,
+        unsigned int *trans, unsigned long int trans_len);
+
+
+#endif
+
diff --git a/other/burneye/src/stub/snprintf.c b/other/burneye/src/stub/snprintf.c
new file mode 100644
index 0000000..1ee1e83
--- /dev/null
+++ b/other/burneye/src/stub/snprintf.c
@@ -0,0 +1,367 @@
+/****************************************************************************  
+ 
+  Copyright (c) 1999,2000 WU-FTPD Development Group.  
+  All rights reserved.
+  
+  Portions Copyright (c) 1980, 1985, 1988, 1989, 1990, 1991, 1993, 1994
+    The Regents of the University of California.
+  Portions Copyright (c) 1993, 1994 Washington University in Saint Louis.
+  Portions Copyright (c) 1996, 1998 Berkeley Software Design, Inc.
+  Portions Copyright (c) 1989 Massachusetts Institute of Technology.
+  Portions Copyright (c) 1998 Sendmail, Inc.
+  Portions Copyright (c) 1983, 1995, 1996, 1997 Eric P.  Allman.
+  Portions Copyright (c) 1997 by Stan Barber.
+  Portions Copyright (c) 1997 by Kent Landfield.
+  Portions Copyright (c) 1991, 1992, 1993, 1994, 1995, 1996, 1997
+    Free Software Foundation, Inc.  
+ 
+  Use and distribution of this software and its source code are governed 
+  by the terms and conditions of the WU-FTPD Software License ("LICENSE").
+ 
+  If you did not receive a copy of the license, it may be obtained online
+  at http://www.wu-ftpd.org/license.html.
+ 
+  $Id: snprintf.c,v 1.1 2001/07/06 19:23:39 scut Exp $
+ 
+****************************************************************************/
+
+#ifdef VDEBUG
+
+
+#ifndef __P
+#define __P(p)  p
+#endif
+
+#include <stdarg.h>
+#define VA_LOCAL_DECL   va_list ap;
+#define VA_START(f)     va_start(ap, f)
+#define VA_END          va_end(ap)
+
+#ifdef SOLARIS2
+#ifdef _FILE_OFFSET_BITS
+#define SOLARIS26
+#endif
+#endif
+
+#ifdef SOLARIS26
+#define HAS_SNPRINTF
+#define HAS_VSNPRINTF
+#endif
+#ifdef _SCO_DS_
+#define HAS_SNPRINTF
+#endif
+#ifdef luna2
+#define HAS_VSNPRINTF
+#endif
+/*
+   **  SNPRINTF, VSNPRINT -- counted versions of printf
+   **
+   **   These versions have been grabbed off the net.  They have been
+   **   cleaned up to compile properly and support for .precision and
+   **   %lx has been added.
+ */
+
+/**************************************************************
+ * Original:
+ * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
+ * A bombproof version of doprnt (dopr) included.
+ * Sigh.  This sort of thing is always nasty do deal with.  Note that
+ * the version here does not include floating point...
+ *
+ * snprintf() is used instead of sprintf() as it does limit checks
+ * for string length.  This covers a nasty loophole.
+ *
+ * The other functions are there to prevent NULL pointers from
+ * causing nast effects.
+ **************************************************************/
+
+/*static char _id[] = "$Id: snprintf.c,v 1.1 2001/07/06 19:23:39 scut Exp $"; */
+static void dopr(char *, const char *, va_list);
+static char *end;
+
+#ifndef HAS_VSNPRINTF
+int vsnprintf(char *str, int count, const char *fmt, va_list args)
+{
+    int n = 0;
+    str[0] = 0;
+    end = str + count - 1;
+    dopr(str, fmt, args);
+    if (count > 0)
+        end[0] = 0;
+    while (*str++)
+            n++;
+    return n;
+}
+
+#ifndef HAS_SNPRINTF
+/* VARARGS3 */
+int snprintf(char *str, int count, const char *fmt,...)
+{
+    int len;
+    VA_LOCAL_DECL
+
+        VA_START(fmt);
+    len = vsnprintf(str, count, fmt, ap);
+    VA_END;
+    return len;
+}
+#endif
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
+
+static void fmtstr __P((char *value, int ljust, int len, int zpad, int maxwidth));
+static void fmtnum __P((long value, int base, int dosign, int ljust, int len, int zpad));
+static void dostr __P((char *, int));
+static char *output;
+static void dopr_outch __P((int c));
+
+static void dopr(char *buffer, const char *format, va_list args)
+{
+    int ch;
+    long value;
+    int longflag = 0;
+    int pointflag = 0;
+    int maxwidth = 0;
+    char *strvalue;
+    int ljust;
+    int len;
+    int zpad;
+
+    output = buffer;
+    while ((ch = *format++)) {
+        switch (ch) {
+        case '%':
+            ljust = len = zpad = maxwidth = 0;
+            longflag = pointflag = 0;
+          nextch:
+            ch = *format++;
+            switch (ch) {
+            case 0:
+                dostr("**end of format**", 0);
+                return;
+            case '-':
+                ljust = 1;
+                goto nextch;
+            case '0':           /* set zero padding if len not set */
+                if (len == 0 && !pointflag)
+                    zpad = '0';
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                if (pointflag)
+                    maxwidth = maxwidth * 10 + ch - '0';
+                else
+                    len = len * 10 + ch - '0';
+                goto nextch;
+            case '*':
+                if (pointflag)
+                    maxwidth = va_arg(args, int);
+                else
+                    len = va_arg(args, int);
+                goto nextch;
+            case '.':
+                pointflag = 1;
+                goto nextch;
+            case 'l':
+                longflag = 1;
+                goto nextch;
+            case 'u':
+            case 'U':
+                /*fmtnum(value,base,dosign,ljust,len,zpad) */
+                if (longflag) {
+                    value = va_arg(args, long);
+                }
+                else {
+                    value = va_arg(args, int);
+                }
+                fmtnum(value, 10, 0, ljust, len, zpad);
+                break;
+            case 'o':
+            case 'O':
+                /*fmtnum(value,base,dosign,ljust,len,zpad) */
+                if (longflag) {
+                    value = va_arg(args, long);
+                }
+                else {
+                    value = va_arg(args, int);
+                }
+                fmtnum(value, 8, 0, ljust, len, zpad);
+                break;
+            case 'd':
+            case 'D':
+                if (longflag) {
+                    value = va_arg(args, long);
+                }
+                else {
+                    value = va_arg(args, int);
+                }
+                fmtnum(value, 10, 1, ljust, len, zpad);
+                break;
+            case 'x':
+                if (longflag) {
+                    value = va_arg(args, long);
+                }
+                else {
+                    value = va_arg(args, int);
+                }
+                fmtnum(value, 16, 0, ljust, len, zpad);
+                break;
+            case 'X':
+                if (longflag) {
+                    value = va_arg(args, long);
+                }
+                else {
+                    value = va_arg(args, int);
+                }
+                fmtnum(value, -16, 0, ljust, len, zpad);
+                break;
+            case 's':
+                strvalue = va_arg(args, char *);
+                if (maxwidth > 0 || !pointflag) {
+                    if (pointflag && len > maxwidth)
+                        len = maxwidth;         /* Adjust padding */
+                    fmtstr(strvalue, ljust, len, zpad, maxwidth);
+                }
+                break;
+            case 'c':
+                ch = va_arg(args, int);
+                dopr_outch(ch);
+                break;
+            case '%':
+                dopr_outch(ch);
+                continue;
+            default:
+                dostr("???????", 0);
+            }
+            break;
+        default:
+            dopr_outch(ch);
+            break;
+        }
+    }
+    *output = 0;
+}
+
+static void fmtstr(char *value, int ljust, int len, int zpad, int maxwidth)
+{
+    int padlen, strlen;         /* amount to pad */
+
+    if (value == 0) {
+        value = "<NULL>";
+    }
+    for (strlen = 0; value[strlen]; ++strlen);  /* strlen */
+    if (strlen > maxwidth && maxwidth)
+        strlen = maxwidth;
+    padlen = len - strlen;
+    if (padlen < 0)
+        padlen = 0;
+    if (ljust)
+        padlen = -padlen;
+    while (padlen > 0) {
+        dopr_outch(' ');
+        --padlen;
+    }
+    dostr(value, maxwidth);
+    while (padlen < 0) {
+        dopr_outch(' ');
+        ++padlen;
+    }
+}
+
+static void fmtnum(long value, int base, int dosign, int ljust, int len, int zpad)
+{
+    int signvalue = 0;
+    unsigned long uvalue;
+    char convert[20];
+    int place = 0;
+    int padlen = 0;             /* amount to pad */
+    int caps = 0;
+
+    /* DEBUGP(("value 0x%x, base %d, dosign %d, ljust %d, len %d, zpad %d\n",
+       value, base, dosign, ljust, len, zpad )); */
+    uvalue = value;
+    if (dosign) {
+        if (value < 0) {
+            signvalue = '-';
+            uvalue = -value;
+        }
+    }
+    if (base < 0) {
+        caps = 1;
+        base = -base;
+    }
+    do {
+        convert[place++] =
+            (caps ? "0123456789ABCDEF" : "0123456789abcdef")
+            [uvalue % (unsigned) base];
+        uvalue = (uvalue / (unsigned) base);
+    } while (uvalue);
+    convert[place] = 0;
+    padlen = len - place;
+    if (padlen < 0)
+        padlen = 0;
+    if (ljust)
+        padlen = -padlen;
+    /* DEBUGP(( "str '%s', place %d, sign %c, padlen %d\n",
+       convert,place,signvalue,padlen)); */
+    if (zpad && padlen > 0) {
+        if (signvalue) {
+            dopr_outch(signvalue);
+            --padlen;
+            signvalue = 0;
+        }
+        while (padlen > 0) {
+            dopr_outch(zpad);
+            --padlen;
+        }
+    }
+    while (padlen > 0) {
+        dopr_outch(' ');
+        --padlen;
+    }
+    if (signvalue)
+        dopr_outch(signvalue);
+    while (place > 0)
+        dopr_outch(convert[--place]);
+    while (padlen < 0) {
+        dopr_outch(' ');
+        ++padlen;
+    }
+}
+
+static void dostr(char *str, int cut)
+{
+    if (cut) {
+        while (*str && cut-- > 0)
+            dopr_outch(*str++);
+    }
+    else {
+        while (*str)
+            dopr_outch(*str++);
+    }
+}
+
+static void dopr_outch(int c)
+{
+#if 0
+    if (iscntrl(c) && c != '\n' && c != '\t') {
+        c = '@' + (c & 0x1F);
+        if (end == 0 || output < end)
+            *output++ = '^';
+    }
+#endif
+    if (end == 0 || output < end)
+        *output++ = c;
+}
+
+#endif
+
+#endif
diff --git a/other/burneye/src/stub/stub.c b/other/burneye/src/stub/stub.c
new file mode 100644
index 0000000..cdfe8b6
--- /dev/null
+++ b/other/burneye/src/stub/stub.c
@@ -0,0 +1,1254 @@
+/* burneye - main stub loader
+ */
+
+#include <elf.h>
+#include "include/int80.h"
+#include "include/unistd.h"
+#include "cipher-rc4.h"
+#include "cipher-sha1.h"
+#include "cipher-glfsr.h"
+#include "fingerprint.h"
+#include "helper.h"
+#include "stubhdr.h"
+
+
+/* from asm/page.h */
+#define PAGE_SHIFT      12
+#define PAGE_SIZE       (1UL << PAGE_SHIFT)
+#define PAGE_MASK       (~0u << 12)
+
+#define OVERHEAD        2048
+#define MAX_PHDR        32
+
+
+typedef struct {
+        int                     file_fd;        /* fd or -1 if none */
+        unsigned long int       file_size;      /* filesize or 0 if unknown */
+        unsigned char *         file_mem;       /* entire file or NULL */
+} elf_file;
+
+
+extern unsigned long int        be_stubhdr_u;
+
+
+/* prototypes */
+char * getenv (char *varname);
+
+int burneye (unsigned long int auxc, Elf32_auxv_t *auxv, char *envp[],
+        char *argv[], int argc);
+void be_seal (unsigned char *shdr_p);
+void be_sigtrap (int signum);
+
+void be_auxv_reloc (unsigned long int auxc, Elf32_auxv_t *auxv);
+void be_auxv_set (Elf32_auxv_t *auxv, unsigned int auxc,
+        unsigned int a_type, long int a_val);
+
+static Elf32_Addr be_remap (elf_file *elf);
+static Elf32_Addr be_findphdrs (elf_file *elf);
+static Elf32_Addr be_mapinterpreter (elf_file *pretee, Elf32_Ehdr *pehdr);
+int be_loadmap (elf_file *elf, Elf32_Ehdr *ehdr, unsigned long int base);
+void be_loadehdr (elf_file *elf, Elf32_Ehdr *ehdr);
+int be_loadphdr (elf_file *elf, Elf32_Ehdr *ehdr, Elf32_Phdr *phdr,
+        int phnum);
+int be_loadseg (elf_file *elf, Elf32_Ehdr *ehdr, Elf32_Phdr *phdr,
+        unsigned long int base);
+static void * be_brk (unsigned char *end);
+void be_unlink (unsigned char *pathname, unsigned char *replacement);
+
+
+/* globals, all initialized (to avoid .bss)
+ */
+char ** env = NULL;             /* environ */
+char *  progfile = NULL;        /* this executeable as pathname */
+int     nottraced = 0;          /* will be > 0 if traced */
+
+/* unlink stub encoded in a .h
+ */
+#include "unlinkstub-bin.h"
+
+
+static inline int killme()
+{
+        long ret;
+        
+        __asm__ __volatile__ ("xorl     %%eax, %%eax\t\n"
+                              "xorl     %%ebx, %%ebx\t\n"
+                              "xorl     %%ecx, %%ecx\t\n"
+                              "xorl     %%edx, %%edx\t\n"
+                              "xorl     %%esi, %%esi\t\n"
+                              "xorl     %%edi, %%edi\t\n"
+                              "xorl     %%ebp, %%ebp\t\n"
+                              "xorl     %%esp, %%esp\t\n"
+                              "jmp      %%esi"
+                             :"=a" (ret)
+                             : );
+        return ret;
+}
+
+
+char *
+getenv (char *varname)
+{
+        int     walker;
+
+
+        if (env == NULL)
+                return (NULL);
+
+        for (walker = 0 ; env[walker] != NULL ; ++walker) {
+                char *  a;
+                char *  b;
+
+                /* what a kludge, uhhohh ! */
+                for (a = env[walker], b = varname ;
+                        *a && *b && *a != '=' && *a == *b ;
+                        ++a, ++b)
+                        ;
+                if (*a == '=' && *b == '\0')
+                        return (a + 1);
+        }
+
+        /* not found */
+        return (NULL);
+}
+
+
+/* burneye
+ *
+ * 'auxc' is the number of direct Elf32_auxv_t structures that are located
+ * at 'auxv'. at 'auxv' there is space for exactly 32 of such structures, so
+ * the first thing we do is to resort them in a proper array for easy
+ * convenient access. there are quite remarkable differences between the entry
+ * stack layout between different kernel versions, so we stick to some generic
+ * approach here. john reiser <jreiser@bitwagon.com> noted that the major
+ * differences appeared after kernel 2.4.2. this code should cope with any
+ * possible valid layout
+ *
+ * return nothing meaningful yet
+ */
+
+int
+burneye (unsigned long int auxc, Elf32_auxv_t *auxv, char *envp[],
+        char *argv[], int argc)
+{
+        Elf32_Ehdr      ehdr;           /* elf header, wrapped executeable */
+        Elf32_Addr      this_entry,     /* entry point, wrapped executeable */
+                        this_phdrs;     /* vaddr of program header table */
+        elf_file        this_exe;       /* elf_file struct for the exe file */
+
+        Elf32_Addr      inter_entry;    /* entry point, ld-linux interpreter */
+
+        stubhdr *       be_stubhdr;     /* = &be_stubhdr_u */
+        unsigned char * be_payload;     /* the real payload starts here */
+        unsigned char * shdr_p;
+
+
+        /* first generate a sane 32 entry Elf32_auxv_t array
+         */
+        be_auxv_reloc (auxc, auxv);
+        auxc = 32;
+
+        /* initialize environment, just as usual. getenv needs it.
+         */
+        env = envp;
+
+        /* supposed program file (could be forged, but we do not care)
+         */
+        progfile = argv[0];
+
+
+        /* if the payload length has this magic number, there is no payload
+         * at all
+         */
+        if (be_stubhdr_u == 0x41012345) {
+                be_printf ("WARNING: stub is running on its own, without"
+                        "payload, is this what you want?\n");
+        }
+        
+#ifndef DEBUG
+        /* setup signal handler
+         */
+        signal (SIGTRAP, be_sigtrap);
+#endif
+
+        be_stubhdr = (stubhdr *) &be_stubhdr_u;
+        be_printf ("be_stubhdr = 0x%08lx\n", (unsigned long int) be_stubhdr);
+
+        /* since the stub header is dynamically sized, we have to pull the
+         * length of it from itself
+         */
+        be_printf ("be_stubhdr->stubhdr_size = %lu\n",
+                be_stubhdr->stubhdr_size);
+        be_payload = ((unsigned char *) be_stubhdr) +
+                be_stubhdr->stubhdr_size;
+
+        be_printf ("payload @ 0x%08lx, 0x%08lx bytes\n",
+                (unsigned long int) be_payload,
+                be_stubhdr->payload_len);
+        be_printf ("%lu auxiliary vectors @ 0x%08lx\n", auxc,
+                (unsigned long int) auxv);
+        be_printf ("brk @ 0x%08lx\n", brk(0));
+        
+#ifndef DEBUG
+        /* detect l/strace and other crappy stuff
+         */
+        antistrace ();
+        
+        if (nottraced == 0)
+                killme ();
+#endif
+
+        /* points always to the actual element */
+        shdr_p = ((unsigned char *) be_stubhdr) + sizeof (stubhdr);
+
+        /* check on unlink */
+        if (be_stubhdr->flags & BE_FLAG_UNLINK) {
+                stubhdr_unlink *        su;
+
+                su = (stubhdr_unlink *) shdr_p;
+                shdr_p += sizeof (stubhdr_unlink);
+
+                if (getenv (su->ul_env) != NULL) {
+                        be_unlink (progfile, NULL);
+                        _exit (73);
+                }
+        }
+
+        /* tagged binary ?
+         */
+        if (be_stubhdr->flags & BE_FLAG_TAGGED) {
+                int                     tw;
+                stubhdr_tag *           st;
+
+                st = (stubhdr_tag *) shdr_p;
+                shdr_p += sizeof (stubhdr_tag);
+
+                /* deobfuscate
+                 */
+                for (tw = 0 ; tw < sizeof (st->tag_env) ; ++tw) {
+                        st->tag_env[tw] = (0xaa + (~tw << (tw % 4))) ^
+                                st->tag_env[tw];
+                }
+
+                if (getenv (st->tag_env) != NULL) {
+                        unsigned char   tag_key[16];
+                        unsigned char   tag_hash[20];
+                        rc4_key         key_t;
+
+
+                        if (strlen (getenv (st->tag_env)) >= sizeof (tag_key))
+                                _exit (73);
+                        memcpy (tag_key, getenv (st->tag_env),
+                                strlen (getenv (st->tag_env)));
+
+                        SHA1HashLen (tag_key, strlen (tag_key), tag_hash);
+                        rc4_prepare_key (tag_hash, sizeof (tag_hash), &key_t);
+                        rc4_cipher (st->tag_value,
+                                sizeof (st->tag_value), &key_t);
+
+                        st->tag_value[sizeof (st->tag_value) - 1] = '\0';
+                        write (2, st->tag_value, strlen (st->tag_value));
+                        write (2, "\n", 1);
+
+                        _exit (0);
+                }
+        }
+
+        /* show banner ? */
+        if (be_stubhdr->flags & BE_FLAG_BANNER) {
+                stubhdr_banner *        sb;
+                unsigned char *         banner;
+
+                sb = (stubhdr_banner *) shdr_p;
+                shdr_p += sizeof (stubhdr_banner) + sb->banner_len;
+                banner = ((unsigned char *) sb) + sizeof (sb->banner_len);
+
+                if (be_stubhdr->flags & BE_FLAG_BANNER_TTY)
+                        write_tty (banner, sb->banner_len);
+                else
+                        write (2, banner, sb->banner_len);
+        }
+
+        /* do we have to seal this binary ?
+         * be_seal will never return
+         */
+        if (be_stubhdr->flags & BE_FLAG_SEALNOW)
+                be_seal (shdr_p);
+
+        /* fingerprinted ? */
+        if (be_stubhdr->flags & BE_FLAG_FINGERPRINT) {
+                fp_fin *        fpf;
+
+                int             mkey_n;
+                unsigned char   mkey[20];
+                rc4_key         mkey_r;
+
+
+                fpf = (fp_fin *) shdr_p;
+                shdr_p += sizeof (fp_fin) + fpf->par_len;
+#ifdef DEBUG
+                be_printf ("about to FINGERPRINT (par_len = 0x%08lx\n",
+                        fpf->par_len);
+#endif
+
+                fp_process (fpf, mkey);
+
+#ifdef DEBUG
+                be_printf ("  fp: %02x %02x %02x %02x\n", mkey[0], mkey[1],
+                        mkey[2], mkey[3]);
+#endif
+                for (mkey_n = 0 ; mkey_n < sizeof (mkey) ; ++mkey_n)
+                        mkey[mkey_n] ^= fpf->fp_xor[mkey_n];
+                SHA1HashLen (mkey, sizeof (mkey), mkey);
+#ifdef DEBUG
+                be_printf ("real: %02x %02x %02x %02x\n", mkey[0], mkey[1],
+                        mkey[2], mkey[3]);
+
+                be_printf ("encrypted: %02x %02x %02x %02x %02x\n",
+                        be_payload[0],
+                        be_payload[1],
+                        be_payload[2],
+                        be_payload[3],
+                        be_payload[4]);
+#endif
+
+                rc4_prepare_key (mkey, sizeof (mkey), &mkey_r);
+                rc4_cipher (be_payload, be_stubhdr->payload_len, &mkey_r);
+#ifdef DEBUG
+                be_printf ("decrypted: %02x %02x %02x %02x %02x\n",
+                        be_payload[0],
+                        be_payload[1],
+                        be_payload[2],
+                        be_payload[3],
+                        be_payload[4]);
+#endif
+
+                if (be_stubhdr->flags & BE_FLAG_FINGERPRINT_CHK) {
+                        unsigned char   hash[20];
+
+                        SHA1HashLen (be_payload, be_stubhdr->payload_len,
+                                hash);
+
+                        if (memcmp (hash, fpf->fp_check, 4) != 0) {
+                                write (2, "invalid fingerprint\n", 20);
+                                _exit (73);
+                        }
+                }
+        }
+
+        /* password encrypted binary ? */
+        if (be_stubhdr->flags & BE_FLAG_PASSWORD) {
+                unsigned char * pw;
+                unsigned char   pass[64];
+                unsigned char   pw_hash[20];
+                int             key_n;
+                rc4_key         key_r;
+                stubhdr_pass *  sp;
+
+
+                sp = (stubhdr_pass *) shdr_p;
+                shdr_p += sizeof (stubhdr_pass);
+
+                /* check whether we are allowed to pull the password from some
+                 * environment variable, and if its possible, do it. else just
+                 * fall back to pulling it from the tty
+                 */
+                if (sp->pw_env[0] != '\0' && getenv (sp->pw_env) != NULL) {
+                        int     e_len;
+
+                        e_len = strlen (getenv (sp->pw_env));
+                        if (e_len > sizeof (pass))
+                                e_len = sizeof (pass);
+
+                        memcpy (pass, getenv (sp->pw_env), e_len);
+                } else {
+                        getpass (pass, sizeof (pass));
+                }
+                pass[sizeof (pass) - 1] = '\0';
+
+                /* proper chop, looks ugly, right?
+                 */
+                for (pw = pass ; *pw != '\0'; ++pw)
+                        ;
+                if (pw > pass)
+                        pw -= 1;
+                while (pw >= pass && (*pw == '\r' || *pw == '\n'))
+                        *pw-- = '\0';
+
+                /* combine hash's and decrypt
+                 */
+                SHA1HashLen (pass, strlen (pass), pw_hash);
+                for (key_n = 0 ; key_n < sizeof (pw_hash) ; ++key_n)
+                        pw_hash[key_n] ^= sp->pw_xor[key_n];
+
+                SHA1HashLen (pw_hash, sizeof (pw_hash), pw_hash);
+
+                /* use the combined hashes as key for the payload decryption
+                 */
+                rc4_prepare_key (pw_hash, sizeof (pw_hash), &key_r);
+                rc4_cipher (be_payload, be_stubhdr->payload_len, &key_r);
+
+                if (be_stubhdr->flags & BE_FLAG_PASSWORD_CHECK) {
+                        unsigned char   hash[20];
+
+                        SHA1HashLen (be_payload, be_stubhdr->payload_len,
+                                hash);
+
+                        if (memcmp (hash, sp->pw_check, 4) != 0) {
+                                write (2, "invalid key\n", 12);
+                                _exit (73);
+                        }
+                }
+        }
+
+        /* load this executeable file into memory
+         */
+        this_exe.file_fd = -1;
+        this_exe.file_size = be_stubhdr->payload_len;
+        this_exe.file_mem = be_payload;
+
+#ifdef DEBUG
+        be_printf ("payload = 0x%08lx (%d)\n",
+                (unsigned long int) be_payload, be_stubhdr->payload_len);
+
+        be_printf ("executeable: %02x %02x %02x %02x\n",
+                this_exe.file_mem[0],
+                this_exe.file_mem[1],
+                this_exe.file_mem[2],
+                this_exe.file_mem[3]);
+#endif
+
+        this_entry = be_remap (&this_exe);
+        this_phdrs = be_findphdrs (&this_exe);
+        be_printf ("found program headers @ 0x%08lx\n",
+                this_phdrs);
+        be_loadehdr (&this_exe, &ehdr);
+
+        be_auxv_set (auxv, auxc, AT_PHDR, this_phdrs);
+        be_auxv_set (auxv, auxc, AT_PHENT, ehdr.e_phentsize);
+        be_auxv_set (auxv, auxc, AT_PHNUM, ehdr.e_phnum);
+        be_auxv_set (auxv, auxc, AT_PAGESZ, PAGE_SIZE);
+        be_auxv_set (auxv, auxc, AT_ENTRY, this_entry);
+
+
+        /* find and load possible program interpreter
+         */
+        inter_entry = be_mapinterpreter (&this_exe, &ehdr);
+        be_printf ("PT_INTERP program interpreter mapped, entry @ 0x%08lx\n",
+                (unsigned long int) inter_entry);
+
+        /* unload old executeable */
+#ifdef WHEN_I_WILL_HAVE_THE_TIME_AND_MOTIVATION_TO_FIX_THIS
+#define BE_UNMAP_EXTRA  0x2000
+        be_printf ("munmap (0x%08lx, 0x%lx)\n",
+                be_payload, be_stubhdr->payload_len + BE_UNMAP_EXTRA);
+        n = munmap ((void *) be_payload,
+                be_stubhdr->payload_len + BE_UNMAP_EXTRA);
+        be_printf ("UNMAP = %d\n", n);
+#endif
+
+        /* usually shared linked binaries */
+        if (inter_entry != (Elf32_Addr) NULL)
+                return (inter_entry);
+
+        /* static binaries go here */
+        return (this_entry);
+}
+
+void
+be_sigtrap (int signum)
+{
+        nottraced++;
+}
+
+void
+be_seal (unsigned char *shdr_p)
+{
+        fp_fin *                seal;
+        int                     n;
+        int                     fd_i,   /* burneye input binary */
+                                fd_o;   /* burneye output binary */
+        char                    fd_o_name[256];
+        unsigned char           fd_copybuf[1024];
+        unsigned long int       m_flags;
+
+        unsigned char           key[20];        /* fingerprint key */
+
+        unsigned long int       m_len,
+                                be_layer0_filestart,
+                                be_layer0_size,
+                                be_layer0_cont;
+
+#ifdef DEBUG
+        be_printf ("about to SEAL\n");
+#endif
+        /* prepare to copy the current executeable
+         */
+        if (strlen (progfile) >= (sizeof (fd_o_name) - 4))
+                _exit (73);
+
+        memset (fd_o_name, '\0', sizeof (fd_o_name));
+        memcpy (fd_o_name, progfile, strlen (progfile));
+        memcpy (fd_o_name + strlen (fd_o_name), ".sl", 3);
+
+        fd_i = open (progfile, O_RDONLY, 0);
+        fd_o = open (fd_o_name, O_RDWR | O_CREAT, 0);
+        if (fd_i < 0 || fd_o < 0)
+                _exit (73);
+
+        /* what a mess for a simple copy, isn't it?
+         * TODO: maybe put this into helper.c
+         */
+        do {
+                int             m;
+                unsigned char * fdc;
+
+                n = read (fd_i, fd_copybuf, sizeof (fd_copybuf));
+                if (n < 0)
+                        _exit (73);
+
+                if (n == 0)
+                        break;
+
+                for (fdc = fd_copybuf ; n > 0 ; n -= m, fdc += m) {
+                        m = write (fd_o, fdc, n);
+                        if (m <= 0)
+                                _exit (73);
+                }
+        } while (1);
+
+        close (fd_i);
+
+
+        /* now seal the new binary
+         * TODO: should errorcheck here (lseek/read/write calls)
+         */
+        seal = (fp_fin *) shdr_p;
+
+        /* adjust stubheader flags */
+        lseek (fd_o, seal->stubhdr_flags_ofs, SEEK_SET);
+        read (fd_o, (unsigned char *) &m_flags, sizeof (m_flags));
+        m_flags &= ~BE_FLAG_SEALNOW;    /* remove sealnow flag */
+        m_flags |= BE_FLAG_SEALED;
+        m_flags |= BE_FLAG_FINGERPRINT | BE_FLAG_FINGERPRINT_CHK;
+        lseek (fd_o, seal->stubhdr_flags_ofs, SEEK_SET);
+        write (fd_o, (unsigned char *) &m_flags, sizeof (m_flags));
+
+        /* generate fingerprint, hah i like gcc auto stacks
+         */
+        {
+                unsigned int    fp_len;
+                unsigned char   hash_arr[N_TEST * N_SUBHASH];
+
+                seal->fp.hash_arr = hash_arr;
+                fp_len = fp_get (&seal->fp);
+
+                SHA1HashLen (seal->fp.hash_arr, fp_len, key);
+                seal->fp.hash_arr = NULL;
+#ifdef DEBUG
+                be_printf ("  fp: %02x %02x %02x %02x\n", key[0],
+                        key[1], key[2], key[3]);
+#endif
+        }
+
+
+        /* combine and hash the key using the dynamic xor pad
+         */
+        fd_i = open ("/dev/urandom", O_RDONLY, 0);
+        read (fd_i, seal->fp_xor, sizeof (seal->fp_xor));
+        close (fd_i);
+
+        for (n = 0 ; n < sizeof (key) ; ++n)
+                key[n] ^= seal->fp_xor[n];
+        SHA1HashLen (key, sizeof (key), key);
+
+#ifdef DEBUG
+        be_printf ("real: %02x %02x %02x %02x\n", key[0],
+                key[1], key[2], key[3]);
+#endif
+
+        /* hash and encrypt fingerprint-protected data
+         */
+        {
+                rc4_key         key_r;
+//              unsigned char   payload_data[seal->payload_len];
+                unsigned char * payload_data;
+                unsigned char   payload_check[20];
+
+
+                payload_data = (void *) mmap ((void *) 0x04000000,
+                        seal->payload_len,
+                        PROT_READ | PROT_WRITE, /* | PROT_EXEC, */
+                        MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+#ifdef DEBUG
+                be_printf ("seal->payload_ofs = 0x%08lx\n", seal->payload_ofs);
+#endif
+                lseek (fd_o, seal->payload_ofs, SEEK_SET);
+                if (read (fd_o, payload_data, seal->payload_len) !=
+                        seal->payload_len)
+                {
+                        _exit (73);
+                }
+#ifdef DEBUG
+                be_printf ("SEALING exe_data: %02x %02x %02x %02x %02x\n",
+                        payload_data[0], payload_data[1], payload_data[2],
+                        payload_data[3], payload_data[4]);
+#endif
+
+                /* generate 4 byte pad array of decryted data
+                 */
+                SHA1HashLen (payload_data, seal->payload_len, payload_check);
+                memcpy (seal->fp_check, payload_check,
+                        sizeof (seal->fp_check));
+
+                rc4_prepare_key (key, sizeof (key), &key_r);
+                rc4_cipher (payload_data, seal->payload_len, &key_r);
+#ifdef DEBUG
+                be_printf ("encrypted: %02x %02x %02x %02x %02x\n",
+                        payload_data[0], payload_data[1], payload_data[2],
+                        payload_data[3], payload_data[4]);
+#endif
+
+                lseek (fd_o, seal->payload_ofs, SEEK_SET);
+                if (write (fd_o, payload_data, seal->payload_len) !=
+                        seal->payload_len)
+                {
+                        _exit (73);
+                }
+
+                munmap (payload_data, seal->payload_len);
+        }
+
+        /* now cleanup the seal structure to a real fingerprint one
+         * and dump it to the new executeable
+         */
+        lseek (fd_o, seal->sealhdr_ofs, SEEK_SET);
+        seal->stubhdr_flags_ofs = 0;
+        seal->sealhdr_ofs = seal->payload_ofs = seal->payload_len = 0;
+
+        /* sealmode allows no tolerance (yet) */
+        seal->par_len = 0;
+        seal->par_data = NULL;
+
+        be_layer0_filestart = seal->be_layer0_filestart;
+        be_layer0_size = seal->be_layer0_size;
+        be_layer0_cont = seal->be_layer0_cont;
+
+        seal->be_layer0_filestart = seal->be_layer0_size =
+                seal->be_layer0_cont = 0;
+        write (fd_o, seal, sizeof (*seal));
+
+#ifndef DEBUG
+        /* now the only thing is to add the obfuscation layer
+         */
+        m_len = lseek (fd_o, 0, SEEK_END);
+        m_len -= be_layer0_filestart;
+        {
+                unsigned long int *     lp;
+                unsigned long int       crypt_len,
+                                        crypt_key;
+                unsigned char *         l0_data;
+
+
+                l0_data = (void *) mmap ((void *) 0x04000000,
+                        m_len,
+                        PROT_READ | PROT_WRITE, /* | PROT_EXEC, */
+                        MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+
+                fd_i = open ("/dev/urandom", O_RDONLY, 0);
+                read (fd_i, &crypt_key, sizeof (crypt_key));
+                close (fd_i);
+
+                /* read all data following the crypt stub
+                 */
+                lseek (fd_o, be_layer0_filestart, SEEK_SET);
+                read (fd_o, l0_data, m_len);
+
+                /* encrypt the data using the random key
+                 */
+                crypt_len = m_len - be_layer0_size;
+                glfsr_crypt (l0_data + be_layer0_size,
+                        l0_data + be_layer0_size,
+                        crypt_len, crypt_key);
+
+                lp = (unsigned long int *) l0_data;
+                *lp++ = crypt_len;
+                *lp++ = crypt_key;
+                *lp++ = be_layer0_cont;
+
+                lseek (fd_o, be_layer0_filestart, SEEK_SET);
+                write (fd_o, l0_data, m_len);
+
+                munmap (l0_data, m_len);
+        }
+#endif
+
+        close (fd_o);
+
+        write (2, "sealed.\n", 8);
+
+        /* delete the old binary
+         * TODO: replace the chmod with a real stat/mode copy thing
+         */
+        chmod (fd_o_name, 0700);
+
+        be_unlink (progfile, fd_o_name);
+
+        _exit (73);     /* will never happen */
+}
+
+
+void
+be_auxv_reloc (unsigned long int auxc, Elf32_auxv_t *auxv)
+{
+        int             n;
+        Elf32_auxv_t    a_copy[32];
+
+
+        /* initialize all structures */
+        for (n = 0 ; n < 32 ; ++n) {
+                a_copy[n].a_type = AT_IGNORE;
+                a_copy[n].a_un.a_val = 0x00000000;
+        }
+        a_copy[0].a_type = AT_IGNORE;
+        a_copy[31].a_type = AT_NULL;
+
+        /* now insertion-sort the given array */
+        for (n = 0 ; n < auxc ; ++n) {
+                if (auxv[n].a_type >= 32) {
+                        be_printf ("FATAL: invalid AT_* entry detected\n");
+                        _exit (73);
+                }
+
+                if (auxv[n].a_type != AT_NULL) {
+                        a_copy[auxv[n].a_type].a_type = auxv[n].a_type;
+                        a_copy[auxv[n].a_type].a_un.a_val = auxv[n].a_un.a_val;
+                        be_printf ("AUXV: 0x%08lx : 0x%08lx\n", auxv[n].a_type,
+                                auxv[n].a_un.a_val);
+                }
+        }
+        memcpy (auxv, a_copy, sizeof (Elf32_auxv_t) * 32);
+
+        return;
+}
+
+
+void
+be_auxv_set (Elf32_auxv_t *auxv, unsigned int auxc,
+        unsigned int a_type, long int a_val)
+{
+        if (a_type >= auxc) {
+                be_printf ("FATAL: tried to set invalid AT_* type\n");
+                _exit (73);
+        }
+
+        auxv[a_type].a_type = a_type;
+        auxv[a_type].a_un.a_val = a_val;
+
+        return;
+}
+
+
+/* return interpreter entry point
+ */
+static Elf32_Addr
+be_mapinterpreter (elf_file *pretee, Elf32_Ehdr *pehdr)
+{
+        int             n,
+                        fd;
+        Elf32_Addr      entry;
+        Elf32_Phdr      pphdr[MAX_PHDR];
+        elf_file        inter_file;
+
+
+        be_loadphdr (pretee, pehdr, pphdr, MAX_PHDR);
+        for (n = 0 ; n < pehdr->e_phnum ; ++n) {
+                if (pphdr[n].p_type != PT_INTERP)
+                        continue;
+
+                /* XXX: assume the name is mapped, better check, doh!
+                 */
+                fd = open ((char *) pphdr[n].p_vaddr, O_RDONLY, 0);
+                if (fd < 0) {
+                        be_printf ("failed to open program interpreter\n");
+
+                        _exit (73);
+                }
+
+                inter_file.file_fd = fd;
+                inter_file.file_size = 0;
+                inter_file.file_mem = NULL;
+
+                entry = be_remap (&inter_file);
+                close (fd);
+
+                return (entry);
+        }
+
+        /* either statically linked or broken
+         */
+        return ((Elf32_Addr) NULL);
+}
+
+
+/* assume file is mapped already at its virtual address
+ */
+static Elf32_Addr
+be_findphdrs (elf_file *elf)
+{
+        int             n;
+        Elf32_Ehdr      ehdr;
+        Elf32_Phdr      phdr[MAX_PHDR];
+
+
+        be_loadehdr (elf, &ehdr);
+        be_loadphdr (elf, &ehdr, phdr, MAX_PHDR);
+
+        /* cycle all program headers, and if they are mapped into memory and
+         * cover the program header table from the file, we found it
+         */
+        for (n = 0 ; n < ehdr.e_phnum ; ++n) {
+                if (phdr[n].p_type == PT_LOAD &&
+                        (phdr[n].p_offset <= ehdr.e_phoff) &&
+                        (phdr[n].p_offset + phdr[n].p_filesz) >
+                        (ehdr.e_phoff +
+                                ehdr.e_phentsize * ehdr.e_phnum))
+                {
+                        /* found, so relocate and return
+                         */
+                        return (phdr[n].p_vaddr +
+                                (ehdr.e_phoff - phdr[n].p_offset));
+                }
+        }
+
+        return ((Elf32_Addr) NULL);
+}
+
+
+/* inspired by svr4 i386 abi, linux fs/binfmt_elf.c and UPX sources
+ * `elf' is one entire loadable elf object
+ *
+ * return entry point of mapped object
+ */
+static Elf32_Addr
+be_remap (elf_file *elf)
+{
+        unsigned long int       base;
+        Elf32_Ehdr              ehdr;
+
+
+        be_loadehdr (elf, &ehdr);
+        base = (ehdr.e_type == ET_DYN) ? 0x40000000 : 0;
+        be_loadmap (elf, &ehdr, base);
+
+        return (ehdr.e_entry + base);
+}
+
+
+int
+be_loadmap (elf_file *elf, Elf32_Ehdr *ehdr, unsigned long int base)
+{
+        int                     n;
+        Elf32_Phdr              phdr[MAX_PHDR];
+        Elf32_Phdr *            p;
+
+
+        /* first, load in program headers of the object
+         */
+        be_loadphdr (elf, ehdr, phdr, MAX_PHDR);
+        p = phdr;
+
+        for (n = 0 ; n < ehdr->e_phnum ; ++p, ++n) {
+                be_printf ("obj (entry 0x%08lx): parsing %d/%d, type 0x%04x [",
+                        ehdr->e_entry, n, ehdr->e_phnum - 1, p->p_type);
+
+                if (p->p_type == PT_LOAD) {
+                        be_printf ("PT_LOAD (@ 0x%08lx)]\n", p->p_vaddr);
+                        be_loadseg (elf, ehdr, p, base);
+                } else
+                        be_printf ("?]\n");
+        }
+
+        return (0);
+}
+
+
+int
+be_loadseg (elf_file *elf, Elf32_Ehdr *ehdr, Elf32_Phdr *phdr,
+        unsigned long int base)
+{
+        int                     memprot = 0;
+        unsigned long int       overhead;
+        unsigned char *         addr_start;
+        unsigned char *         addr_end;
+        unsigned char *         addr_dest;
+        unsigned long int       end_frag;
+
+
+        addr_start = (unsigned char *) phdr->p_vaddr;
+        if (ehdr->e_type == ET_DYN)
+                addr_start += base;
+
+        addr_end = addr_start + phdr->p_memsz;
+        overhead = (unsigned long int) addr_start & (PAGE_SIZE - 1);
+
+        /* XXX: check if necessary */
+        if (ehdr->e_type != ET_DYN) {
+                be_brk (addr_end + OVERHEAD);
+        }
+
+//      be_brk (addr_end + OVERHEAD);
+
+        /* XXX/TODO: optimize shared libraries using non-private/non-anonmyous
+         *           pages
+         */
+        if (ehdr->e_type == ET_DYN) {
+                be_printf ("ET_DYN mmap: phdr->p_memsz = %d (phdr->p_filesz = %d)\noverhead = %d\n",
+                        phdr->p_memsz, phdr->p_filesz, overhead);
+
+                addr_dest = (void *) mmap (addr_start - overhead,
+                        phdr->p_filesz + overhead,
+                        PROT_READ | PROT_WRITE, /* XXX: | PROT_EXEC, */
+                        MAP_FIXED | MAP_PRIVATE, elf->file_fd, phdr->p_offset - overhead);
+
+                /* XXX: assume that (p_offset - overhead) is positive */
+
+        } else {
+                addr_dest = (void *) mmap (addr_start - overhead,
+                        phdr->p_filesz + overhead,
+                        PROT_READ | PROT_WRITE, /* | PROT_EXEC, */
+                        MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+        }
+
+        if (addr_dest == (unsigned char *) (-1)) {
+                be_printf ("failed to mmap necessary segment\n");
+
+                _exit (73);
+        }
+
+        /* zero out lower and upper fragmented page space
+         */
+        if (overhead > 0)
+                memset (addr_dest, '\0', overhead);
+
+        end_frag = (-(overhead + phdr->p_filesz)) & ~PAGE_MASK;
+        be_printf ("end_frag = 0x%lx, clear 0x%08lx to 0x%08lx\n",
+                end_frag, addr_start + phdr->p_filesz,
+                addr_start + phdr->p_filesz + end_frag);
+        if (end_frag > 0)
+                memset (addr_start + phdr->p_filesz, '\0', end_frag);
+
+        be_printf ("0x%08lx = mmap (0x%08lx - 0x%08lx, 0x%08lx, ..)\n",
+                (unsigned long int) addr_dest,
+                (unsigned long int) addr_start, overhead,
+                phdr->p_filesz + overhead);
+
+#if 0
+        /* if it is a segment containing .bss pages, then round back with
+         * memsz and re-mmap the entire pages. hope this works -sc.
+         */
+        if (ehdr->e_type == ET_DYN && phdr->p_memsz > phdr->p_filesz) {
+                unsigned long int       addr_bsspages;
+                unsigned long int       remlen;
+
+#ifdef DEBUG
+                be_printf ("  BSS mmap: memsz = 0x%08lx (from filesz 0x%08lx)\n",
+                        phdr->p_memsz, phdr->p_filesz);
+#endif
+
+#if 0
+                addr_dest += phdr->p_memsz + overhead;  /* next rounded page */
+                remlen = phdr->p_memsz + overhead;
+#endif
+                remlen = phdr->p_memsz + overhead;
+
+#ifdef DEBUG
+                be_printf ("  BSS mmap: mmap (0x%08lx, 0x%08lx, ...)\n",
+                        addr_dest, remlen);
+#endif
+                addr_bsspages = mmap (addr_dest, remlen,
+                        PROT_READ | PROT_WRITE,
+                        MAP_FIXED | MAP_PRIVATE,
+                        elf->file_fd, phdr->p_offset - overhead);
+
+                if (addr_bsspages != (unsigned long int) addr_dest) {
+                        be_printf ("  BSS mmap: dyn bss mmap failed"
+                                "(addr_bsspages = 0x%08lx)\n", addr_bsspages);
+                        _exit (73);
+                }
+
+                memset (addr_dest + phdr->p_filesz, '\0',
+                        phdr->p_memsz - phdr->p_filesz);
+
+                return (0);
+        }
+#endif
+
+        if (ehdr->e_type != ET_DYN) {
+                be_printf ("TRANSFER %d bytes @ 0x%08lx (lowfrag: 0x%04lx)\n",
+                        phdr->p_filesz, addr_dest + overhead, overhead);
+
+                if (elf->file_mem != NULL &&
+                        (phdr->p_offset + phdr->p_filesz) <= elf->file_size)
+                {
+                        memcpy (addr_dest + overhead,
+                                elf->file_mem + phdr->p_offset,
+                                phdr->p_filesz);
+
+                } else if (elf->file_fd != -1) {
+
+                        lseek (elf->file_fd, phdr->p_offset, SEEK_SET);
+                        if (read (elf->file_fd, addr_dest + overhead,
+                                phdr->p_filesz) != phdr->p_filesz)
+                        {
+                                be_printf ("failed to load segment from file\n");
+
+                                _exit (73);
+                        }
+                } else {
+                        be_printf ("failed to load segment into memory\n");
+
+                        _exit (73);
+                }
+        }
+
+        if (phdr->p_memsz > phdr->p_filesz && ehdr->e_type == ET_DYN) {
+                unsigned long int       addr_pageb,
+                                        len;
+        
+                be_printf ("XXX: ET_DYN phdr->p_memsz > phdr->p_filesz\n");
+        
+#if 0
+>                                   addr              +---optional page boundary(ies)
+>                           <- frag->                 |
+>    |   :                  :       |                 |      :      |
+>    |   :                  :       |<----... mlen ...|..--->:      |
+>    |   :                  :       |                 |      :      |
+>                                                            haddr   
+
+where haddr is on the hi side of the first page boundary after (p_filesz +
+p_vaddr), then we must supply zero-filled memory from addr to haddr.
+
+#endif
+
+                /* find the first page boundary after (p_vaddr + p_filesz),
+                 * thanks t john f. reiser for explaining this to me :)
+                 */
+                addr_pageb = (unsigned long int) addr_start +  phdr->p_filesz;
+                addr_pageb += PAGE_SIZE;
+                addr_pageb &= PAGE_MASK;
+
+                /* in case the (p_vaddr + p_memsz) address is below the next
+                 * page boundary we can just skip this
+                 */
+#if 0
+                if ((unsigned long int) addr_end <= addr_pageb)
+                        break;
+#endif
+
+                /* mmap space up to the next page boundary and zero it out
+                 */
+                if ((unsigned long int) addr_end > addr_pageb) {
+                        len = (unsigned long int) addr_end - addr_pageb;
+                        be_printf ("     mmap (0x%08lx, %lu, ..)\n", addr_pageb, len);
+
+                        if (mmap ((void *) addr_pageb, len,
+                                PROT_READ | PROT_WRITE,
+                                MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
+                                0, 0) != addr_pageb)
+                        {
+                                be_printf ("failed to map further .bss pages\n");
+                                _exit (73);
+                        }
+                        memset ((void *) addr_pageb, '\0', len);
+                } else {
+                        be_printf ("within page\n");
+                }
+
+        } else if (phdr->p_memsz == phdr->p_filesz) {
+
+                if (phdr->p_flags & PF_R)
+                        memprot |= PROT_READ;
+                if (phdr->p_flags & PF_W)
+                        memprot |= PROT_WRITE;
+                if (phdr->p_flags & PF_X)
+                        memprot |= PROT_EXEC;
+
+                if (mprotect (addr_dest, phdr->p_memsz, memprot) != 0) {
+                        be_printf ("failed to mprotect segment\n");
+
+                        _exit (73);
+                }
+        }
+
+        if (ehdr->e_type != ET_DYN)
+                be_brk (addr_end);
+
+        be_printf ("mapped 0x%08lx to 0x%08lx (%d bytes), prot:%s%s%s\n",
+                addr_dest, addr_dest + phdr->p_memsz, phdr->p_memsz,
+                memprot & PROT_READ ? " PROT_READ" : "",
+                memprot & PROT_WRITE ? " PROT_WRITE" : "",
+                memprot & PROT_EXEC ? " PROT_EXEC" : "");
+
+
+        return (0);
+}
+
+
+void
+be_loadehdr (elf_file *elf, Elf32_Ehdr *ehdr)
+{
+        if (elf->file_mem != NULL) {
+                memcpy (ehdr, elf->file_mem, sizeof (Elf32_Ehdr));
+
+                return;
+        } else if (elf->file_fd != -1) {
+                lseek (elf->file_fd, 0, SEEK_SET);
+                if (read (elf->file_fd, ehdr, sizeof (Elf32_Ehdr)) !=
+                        sizeof (Elf32_Ehdr))
+                {
+                        be_printf ("failed to load the Elf32_Ehdr from file\n");
+
+                        _exit (73);
+                }
+                return;
+        }
+
+        be_printf ("failed to load even the Elf32_Ehdr\n");
+
+        _exit (73);
+}
+
+
+int
+be_loadphdr (elf_file *elf, Elf32_Ehdr *ehdr, Elf32_Phdr *phdr, int phnum)
+{
+        if (ehdr->e_phnum > phnum) {
+                be_printf ("too many program headers\n");
+
+                _exit (73);
+        }
+
+        if (ehdr->e_phentsize != sizeof (Elf32_Phdr)) {
+                be_printf ("odd size of program header elements\n");
+
+                _exit (73);
+        }
+
+        if (elf->file_mem != NULL) {
+                if (ehdr->e_phoff + (ehdr->e_phentsize * ehdr->e_phnum) >
+                        elf->file_size)
+                {
+                        be_printf ("odd program header locations\n");
+
+                        _exit (73);
+                }
+
+                memcpy (phdr, elf->file_mem + ehdr->e_phoff,
+                        ehdr->e_phentsize * ehdr->e_phnum);
+
+                return (0);
+        }
+
+        if (elf->file_fd != -1) {
+                if (lseek (elf->file_fd, ehdr->e_phoff, SEEK_SET) == -1) {
+                        be_printf ("failed to seek in file (to 0x%08lx)\n",
+                                ehdr->e_phoff);
+
+                        _exit (73);
+                }
+
+                if (read (elf->file_fd, phdr, ehdr->e_phentsize *
+                        ehdr->e_phnum) != (ehdr->e_phentsize * ehdr->e_phnum))
+                {
+                        be_printf ("failed to read in all program headers from file\n");
+
+                        _exit (73);
+                }
+
+                return (0);
+        }
+
+
+        /* found no way to fetch program headers of elf object
+         */
+        be_printf ("failed to find a way to load program headers at all\n");
+        _exit (73);
+
+        return (1);     /* gcc is happy, thats the highest goal */
+}
+
+
+unsigned char *
+be_source (unsigned char *vaddr)
+{
+        return (NULL);
+}
+
+
+static void *
+be_brk (unsigned char *end)
+{
+        void *  brk_ret;
+
+
+        brk_ret = (void *) brk (end);
+        be_printf ("0x%08lx = brk (0x%08lx)\n", (unsigned long int) brk_ret,
+                (unsigned long int) end);
+
+        return (brk_ret);
+}
+
+
+/* rather safe unlink
+ * if `replacement' is non-NULL it will be renamed to `pathname' afterwards
+ */
+
+void
+be_unlink (unsigned char *pathname, unsigned char *replacement)
+{
+        int                     fdr,
+                                ul_fd;
+        unsigned char           ul_name[256];
+        char *                  ul_argv[4];
+
+
+        /* close all filedescriptors */
+        for (fdr = 10 ; fdr >= 0 ; --fdr)
+                close (fdr);
+
+        /* open files and ensure FD_CLOEXEC is zero, so they stay open across
+         * the execve call
+         */
+        /* fd 0 */
+        fdr = open ("/dev/urandom", O_RDONLY, 0);
+        fcntl (fdr, F_SETFD, 0);
+
+        memset (ul_name, '\0', sizeof (ul_name));
+        memcpy (ul_name, progfile, sizeof (ul_name) - 4);
+        memcpy (ul_name + strlen (ul_name), ".ul\0", 4);
+
+        /* no error checking, would be bogus anyway, we are about to
+         * kill ourself
+         */
+        ul_fd = open (ul_name, O_CREAT | O_WRONLY, 0);
+        write (ul_fd, ul_stub, sizeof (ul_stub));
+        close (ul_fd);
+        chmod (ul_name, 0700);
+
+        ul_argv[0] = pathname;
+        ul_argv[1] = ul_name;
+
+        if (replacement != NULL) {
+                ul_argv[2] = replacement;
+                ul_argv[3] = NULL;
+        } else {
+                ul_argv[2] = NULL;
+        }
+
+        execve (ul_name, ul_argv, NULL);
+
+        /* never return, we will get erased now, yay! :) */
+}
+
+
diff --git a/other/burneye/src/stub/stub.lds b/other/burneye/src/stub/stub.lds
new file mode 100644
index 0000000..bce02ea
--- /dev/null
+++ b/other/burneye/src/stub/stub.lds
@@ -0,0 +1,41 @@
+
+OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
+OUTPUT_ARCH(i386)
+
+ENTRY(entry_point)
+
+PHDRS
+{
+        text PT_LOAD FILEHDR PHDRS FLAGS (0x0007);      /* PF_R | PF_W | PF_X */
+        data PT_LOAD FLAGS (0x0006);                    /* PF_R | PF_W */
+}
+
+SECTIONS
+{
+        . = 0x05371000 ;
+        .text : {
+                cipher-glfsr.o(.text)
+                init.o(.text)
+                *(.text)
+                *(.data)
+                *(.rodata)
+                *(.bss)
+                callgate.o(.text)
+
+                PROVIDE (be_stubhdr_u = ABSOLUTE(.)) ;
+                LONG (0x41012345) ;
+        } : text
+
+
+        /* dummy segment to set fixed brk(0) value in kernelspace */
+        . = 0x08048000 ;
+        .data : {
+        } : data
+
+        /* save calls to objcopy, huh */
+        /DISCARD/ : {
+                *(.eh_frame)
+                *(.comment)
+                *(.note)
+        }
+}
diff --git a/other/burneye/src/stub/stubhdr.h b/other/burneye/src/stub/stubhdr.h
new file mode 100644
index 0000000..6505749
--- /dev/null
+++ b/other/burneye/src/stub/stubhdr.h
@@ -0,0 +1,78 @@
+/* burneye - stub appended header
+ *
+ * -scut
+ *
+ * this is appended to the stub binary. see stub.lds, stub.c and wrap.c
+ * for further description
+ */
+
+#ifndef BURNEYE_STUBHDR_H
+#define BURNEYE_STUBHDR_H
+
+#define BE_FLAG_PASSWORD        0x0001          /* password protected */
+#define BE_FLAG_PASSWORD_CHECK  0x0002          /* check if it was valid */
+#define BE_FLAG_BANNER          0x0004          /* show banner */
+#define BE_FLAG_BANNER_TTY      0x0008          /* .. on tty */
+#define BE_FLAG_FINGERPRINT     0x0010          /* fingeprinted */
+#define BE_FLAG_FINGERPRINT_CHK 0x0020          /* check success */
+#define BE_FLAG_UNLINK          0x0040          /* unlink on env */
+#define BE_FLAG_SEALNOW         0x0080          /* to-be-sealed binary */
+#define BE_FLAG_SEALED          0x0100          /* just a tag-flag */
+#define BE_FLAG_TAGGED          0x0200          /* is binary tagged ? */
+
+
+typedef struct {
+        unsigned char           ul_env[16];     /* variable */
+} stubhdr_unlink;
+
+
+typedef struct {
+        unsigned char           tag_env[20];
+        unsigned char           tag_value[64];
+} stubhdr_tag;
+
+
+typedef struct {
+        unsigned long int       banner_len;     /* length of banner[] bytes */
+
+        /* variable sized banner here */
+/*      unsigned char           banner[]; */
+} stubhdr_banner;
+
+
+typedef struct {
+        unsigned char           pw_check[4];    /* first 4 bytes of hash */
+        unsigned char           pw_xor[20];     /* dynamic xor hash */
+        unsigned char           pw_env[16];     /* environment variable */
+} stubhdr_pass;
+
+
+typedef struct {
+        unsigned long int       stubhdr_size;   /* length of this header */
+        unsigned long int       payload_len;    /* length of payload */
+        unsigned long int       flags;          /* generic flags */
+
+        /*** DYNAMIC/OPTIONAL elements come here */
+
+#if 0   /* appended if BE_FLAG_BANNER */
+        stubhdr_banner          banner;
+#endif
+
+#if 0   /* appended if BE_FLAG_PASSWORD */
+        stubhdr_pass            spass;
+#endif
+
+        /* ... variable lenght content from here on ... */
+} stubhdr;
+
+#define MAX_BANNER      1024
+#define MAX_FINGERPRINT 4096
+
+#define SHDR_MAXSIZE    (sizeof (stubhdr) + \
+        sizeof (stubhdr_unlink) + sizeof (stubhdr_tag) + \
+        sizeof (stubhdr_banner) + MAX_BANNER + \
+        sizeof (stubhdr_pass) + MAX_FINGERPRINT)
+
+#endif
+
+
diff --git a/other/burneye/src/stub/unlink_stub.asm b/other/burneye/src/stub/unlink_stub.asm
new file mode 100644
index 0000000..ce47d73
--- /dev/null
+++ b/other/burneye/src/stub/unlink_stub.asm
@@ -0,0 +1,133 @@
+
+        BITS 32
+
+        org     0x08048000
+
+ehdr:                                   ; Elf32_Ehdr
+        db      0x7F, "ELF", 1, 1, 1    ;  e_ident
+        times 9 db      0
+        dw      2                       ;  e_type
+        dw      3                       ;  e_machine
+        dd      1                       ;  e_version
+        dd      _start                  ;  e_entry
+        dd      phdr - $$               ;  e_phoff
+        dd      0                       ;  e_shoff
+        dd      0                       ;  e_flags
+        dw      ehdrsize                ;  e_ehsize
+        dw      phdrsize                ;  e_phentsize
+        dw      1                       ;  e_phnum
+        dw      0                       ;  e_shentsize
+        dw      0                       ;  e_shnum
+        dw      0                       ;  e_shstrndx
+
+ehdrsize        equ     ($ - ehdr)
+
+phdr:                           ; Elf32_Phdr
+        dd      1               ;  p_type
+        dd      0               ;  p_offset
+        dd      $$              ;  p_vaddr
+        dd      $$              ;  p_paddr
+        dd      filesize        ;  p_filesz
+        dd      filesize        ;  p_memsz
+        dd      5               ;  p_flags
+        dd      0x1000          ;  p_align
+
+phdrsize        equ     ($ - phdr)
+
+; fd 0 = random file
+; fd 1 = output file
+_start:
+;       int3
+
+        mov     ebx, [esp + 4]  ; pathname
+        mov     ecx, 1          ; mode = O_WRONLY
+        xor     edx, edx        ; flags = 0
+        mov     eax, 5          ; __NR_open
+        int     0x80            ; fd will be 1, hopefully
+
+        ; get output file length
+        xor     ecx, ecx        ; ecx = offset = 0
+        mov     edx, 2          ; edx = SEEK_END = 2
+        mov     ebx, 1          ; ebx = out_fd = 1
+        mov     eax, 19         ; __NR_lseek
+        int     0x80
+
+        shr     eax, 10         ; / 1024
+        inc     eax             ; round up to next boundary
+        push    eax             ; file length / 1024
+
+        mov     ebp, 0x07
+cloop:  pop     eax
+        push    eax
+        push    eax             ; create a copy of the file length
+        ; 1. overwrite
+        ; lseek (1, 0, SEEK_SET);
+        xor     ecx, ecx        ; ecx = offset = 0
+        xor     edx, edx        ; edx = SEEK_SET = 0
+        mov     ebx, 1          ; ebx = out_fd = 1
+        mov     eax, 19         ; __NR_lseek
+        int     0x80
+
+wloop:  sub     esp, 1024 + 4
+        mov     ebx, 0          ; ebx = in_fd = 0
+        mov     ecx, esp        ; temp space on stack
+        mov     edx, 1024       ; read 1024 bytes a time
+        mov     eax, 3          ; __NR_read
+        int     0x80
+
+        mov     ebx, 1          ; ebx = out_fd = 1
+        mov     ecx, esp        ; buffer
+        mov     edx, 1024       ; edx = write 1024 bytes
+        mov     eax, 4          ; __NR_write
+        int     0x80
+
+        add     esp, 1024 + 4   ; yea, fsck with the cache %-/
+
+        pop     eax
+        dec     eax             ; remaining 2^10 pages to clear
+        push    eax
+        jnz     wloop
+
+        pop     eax
+
+        ; 2. sync
+        mov     eax, 36         ; __NR_sync
+        int     0x80
+
+        ; 3. loop
+        dec     ebp             ; number of remaining passes
+        jnz     cloop
+
+        pop     eax             ; original file length / 1024
+
+        ; 4. unlink
+        pop     eax             ; argc (should be 2)
+        pop     ebx             ; ebx = unlink-stub
+        push    ebx
+        mov     eax, 10         ; __NR_unlink
+        int     0x80
+
+
+        pop     edx             ; pathname
+        pop     ebx
+        push    edx
+        mov     eax, 10
+        int     0x80
+
+        pop     ecx             ; newpath = pathname
+        pop     ebx             ; oldpath = .sl filename
+        or      ebx, ebx
+        jz      doexit
+        mov     eax, 38
+        int     0x80
+
+doexit: mov     eax, 1
+        xor     ebx, ebx        ; exit with level 0
+        int     0x80
+
+flen    dd      0
+flenl   dd      0
+
+filesize        equ     ($ - $$)
+
+
diff --git a/other/burneye/src/stub/utils/Makefile b/other/burneye/src/stub/utils/Makefile
new file mode 100644
index 0000000..11bfb1d
--- /dev/null
+++ b/other/burneye/src/stub/utils/Makefile
@@ -0,0 +1,11 @@
+
+CFLAGS = -O2 -Wall
+
+
+all:    hdump.c sstrip.c
+        $(CC) -o hdump hdump.c $(CFLAGS)
+        $(CC) -o sstrip sstrip.c $(CFLAGS)
+
+clean:
+        rm -f *.o hdump sstrip
+
diff --git a/other/burneye/src/stub/utils/hdump.c b/other/burneye/src/stub/utils/hdump.c
new file mode 100644
index 0000000..7d057f1
--- /dev/null
+++ b/other/burneye/src/stub/utils/hdump.c
@@ -0,0 +1,45 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+
+int
+main (int argc, char *argv[])
+{
+        unsigned char   i;
+        unsigned int    dp = 0; /* data pointer */
+
+
+        while (read (0, &i, 1) > 0) {
+                if (dp % 16 == 0)
+                        printf ("\"");
+
+                printf ("\\x%02x", i);
+
+                dp += 1;
+                if (dp % 16 == 0)
+                        printf ("\"\n");
+        }
+
+        if (dp % 16 != 0)
+                printf ("\";\n");
+        else
+                printf ("\"\";\n");
+
+        exit (EXIT_SUCCESS);
+}
+
+
diff --git a/other/burneye/src/stub/utils/lde32.asm b/other/burneye/src/stub/utils/lde32.asm
new file mode 100644
index 0000000..6c5d2d5
--- /dev/null
+++ b/other/burneye/src/stub/utils/lde32.asm
@@ -0,0 +1,315 @@
+

+; LDE32 -- Length-Disassembler Engine

+; FREEWARE

+;

+; programmed by Z0MBiE, http://z0mbie.cjb.net

+;

+; release 1.00          8-12-99

+; release 1.01          9-12-99

+; release 1.02         17-03-00  0xF6/0xF7 'test' opcode bugfixed

+; release 1.03         21-04-00  bugfix: some prefixes before 0F were cleared

+;                                bugfix: error in MODRM analysis

+;                                CD 20 now is 6 bytes length

+; release 1.04          1-05-00  AAM & AAD bugfixed (was 1-byte len)

+; release 1.05         xx-xx-xx  special edition, flags changed

+; release 1.06          3-01-01  partially rewritten, __cdecl

+

+

+C_ERROR         equ     -1              ; never change it

+

+C_MEM1          equ     0x0001       ; |

+C_MEM2          equ     0x0002       ; |may be used simultaneously

+C_MEM4          equ     0x0004       ; |

+C_DATA1         equ     0x0100       ; |

+C_DATA2         equ     0x0200       ; |may be used simultaneously

+C_DATA4         equ     0x0400       ; |

+C_67            equ     0x0010       ; used with C_PREFIX

+C_MEM67         equ     0x0020       ; C_67 ? C_MEM2 : C_MEM4

+C_66            equ     0x1000       ; used with C_PREFIX

+C_DATA66        equ     0x2000       ; C_66 ? C_DATA2 : C_DATA4

+C_PREFIX        equ     0x0008       ; prefix. take opcode again

+C_MODRM         equ     0x4000       ; MODxxxR/M

+C_DATAW0        equ     0x8000       ; opc&1 ? C_DATA66 : C_DATA1

+

+

+; void __cdecl disasm_init(void* tableptr);

+

+

+disasm_init:

+_disasm_init:

+DISASM_INIT:

+                        pusha

+                        mov     edi, [esp+32+4]

+                        cld

+

+                        ; Huffman-compressed 2048-byte table

+                        xor     eax, eax

+                        push    eax

+                        push    eax

+                        push    eax

+                        push    dword 0x002AAA800

+                        push    dword 0x03FFF687F

+                        push    dword 0x0FFE6DEA0

+                        push    dword 0x0DBD5FFFF

+                        push    dword 0x0FFFEAAAA

+                        push    dword 0x0AAAAAAAA

+                        push    dword 0x0AAAA0000

+                        push    eax

+                        push    eax

+                        push    eax

+                        push    eax

+                        push    eax

+                        push    eax

+                        push    dword 0x000000154

+                        push    dword 0x041FFF555

+                        push    dword 0x055DEDDAA

+                        push    dword 0x019955111

+                        push    dword 0x011111FFF

+                        push    dword 0x0FA11FFAA

+                        push    dword 0x08E60CF96

+                        push    dword 0x0FC72D6AA

+                        push    dword 0x0AAAAAA88

+                        push    dword 0x0888888D5

+                        push    dword 0x0528D559B

+                        push    dword 0x0366CD553

+                        push    dword 0x0355555FF

+                        push    dword 0x0FFFED6F9

+                        push    dword 0x068888888

+                        push    dword 0x088888888

+                        push    dword 0x08D5347CA

+                        push    dword 0x0DCC67BDF

+                        push    dword 0x0AAAAAAAA

+                        push    dword 0x0AAAAAAAA

+                        push    dword 0x0ABA94FFD

+                        push    dword 0x0D4A7FEEA

+                        push    dword 0x053FF7529

+                        push    dword 0x0FFA4A7FE

+                        push    dword 0x0929FFA4A

+                        push    dword 0x07FE929FF

+

+                        mov     ecx, 512

+                        xor     ebx, ebx

+cycle:                xor     eax, eax

+                        call    tree

+                        stosd

+                        loop    cycle

+

+                        popa

+                        retn

+

+getbit:               or      ebx, ebx

+                        jnz     skip

+                        pop     ebp

+                        pop     esi

+                        pop     edx

+                        push    esi

+                        push    ebp

+                        mov     bl, 32

+skip:                 dec     ebx

+                        shr     edx, 1

+                        retn

+

+                        ; Huffman-tree, compiled into decompressor code

+tree:                 call    getbit

+                        jnc     tree0

+tree1:                call    getbit

+                        jnc     tree10

+tree11:               mov     ah, (C_MODRM >> 8)

+                        retn

+tree10:               call    getbit

+                        jc      tree101

+tree100:              call    getbit

+                        jnc     tree1000

+tree1001:             call    getbit

+                        jnc     tree10010

+tree10011:            call    getbit

+                        jc      tree100111

+tree100110:           call    getbit

+                        jnc     tree1001100

+tree1001101:          mov     al, C_MEM67

+                        retn

+tree1001100:          call    getbit

+                        jnc     tree10011000

+tree10011001:         mov     ax, C_DATA66+C_MEM2

+                        retn

+tree10011000:         call    getbit

+                        jnc     tree100110000

+tree100110001:        mov     ax, C_PREFIX+C_66

+                        retn

+tree100110000:        mov     ah, ((C_DATA2+C_DATA1) >> 8)

+                        retn

+tree100111:           call    getbit

+                        jnc     tree1001110

+tree1001111:          mov     ah, ((C_MODRM+C_DATA66) >> 8)

+                        retn

+tree1001110:          call    getbit

+                        jnc     tree10011100

+tree10011101:         mov     al, C_PREFIX+C_67

+                        retn

+tree10011100:         mov     ah, (C_DATA2 >> 8)

+                        retn

+tree10010:            mov     ah, (C_DATAW0 >> 8)

+                        retn

+tree1000:             mov     ah, (C_DATA1 >> 8)

+                        retn

+tree101:              call    getbit

+                        jnc     tree1010

+tree1011:             call    getbit

+                        jnc     tree10110

+tree10111:            mov     al, C_PREFIX

+                        retn

+tree10110:            mov     ah, ((C_MODRM+C_DATA1) >> 8)

+                        retn

+tree1010:             mov     ah, (C_DATA66 >> 8)

+                        retn

+tree0:                call    getbit

+;                       jc      tree01

+                        adc     al, 0

+tree00:               dec     eax

+tree01:               retn

+

+

+; int __cdecl disasm_main(void* opcodeptr, void* tableptr)

+; {

+

+; returns opcode length in EAX or -1 if error

+

+disasm_main:

+DISASM_MAIN:            pusha

+

+                        mov     esi, [esp+32+4]    ; tableptr

+                        mov     ecx, [esp+32+8]    ; param = opcode ptr

+

+                        xor     edx, edx        ; flags

+                        xor     eax, eax

+

+prefix:               and     dl, ~C_PREFIX

+

+                        mov     al, [ecx]

+                        inc     ecx

+

+                        or      edx, [esi+eax*4]

+

+                        test    dl, C_PREFIX

+                        jnz     prefix

+

+                        cmp     al, 0xf6

+                        je      btest

+                        cmp     al, 0xf7

+                        je      btest

+

+                        cmp     al, 0xcd

+                        je      bint

+

+                        cmp     al, 0x0f

+                        je      b0F

+cont:

+                        test    dh, (C_DATAW0 >> 8)

+                        jnz     dataw0

+dataw0done:

+                        test    dh, (C_MODRM >> 8)

+                        jnz     near modrm

+exitmodrm:

+                        test    dl, C_MEM67

+                        jnz     mem67

+mem67done:

+                        test    dh, (C_DATA66 >> 8)

+                        jnz     data66

+data66done:

+                        mov     eax, ecx

+                        sub     eax, [esp+32+8]

+

+                        and     edx, C_MEM1+C_MEM2+C_MEM4 + C_DATA1+C_DATA2+C_DATA4

+                        add     al, dl

+                        add     al, dh

+

+exit:                 mov     [esp+7*4], eax

+

+                        popa

+                        retn

+

+btest:                 or      dh, (C_MODRM >> 8)

+                        test    byte [ecx], 00111000b  ; F6/F7 -- test

+                        jnz     cont

+                        or      dh, (C_DATAW0 >> 8)

+                        jmp     cont

+

+bint:                  or      dh, (C_DATA1 >> 8)

+                        cmp     byte [ecx], 0x20

+                        jne     cont

+                        or      dh, (C_DATA4 >> 8)

+                        jmp     cont

+

+b0F:                   mov     al, [ecx]

+                        inc     ecx

+                        or      edx, [esi+eax*4+1024]      ; 2nd half

+

+                        cmp     edx, -1

+                        jne     cont

+

+error:                mov     eax, edx

+                        jmp     exit

+

+dataw0:               xor     dh, (C_DATA66 >> 8)

+                        test    al, 00000001b

+                        jnz     dataw0done

+                        xor     dh, ((C_DATA66+C_DATA1) >> 8)

+                        jmp     dataw0done

+

+mem67:                xor     dl, C_MEM2

+                        test    dl, C_67

+                        jnz     mem67done

+                        xor     dl, C_MEM4+C_MEM2

+                        jmp     mem67done

+

+data66:               xor     dh, (C_DATA2 >> 8)

+                        test    dh, (C_66 >> 8)

+                        jnz     data66done

+                        xor     dh, ((C_DATA4+C_DATA2) >> 8)

+                        jmp     data66done

+

+modrm:                mov     al, [ecx]

+                        inc     ecx

+

+                        mov     ah, al  ; ah=mod, al=rm

+

+                        and     ax, 0xc007

+                        cmp     ah, 0xc0

+                        je      near exitmodrm

+

+                        test    dl, C_67

+                        jnz     modrm16

+

+modrm32:              cmp     al, 0x04

+                        jne     a

+

+                        mov     al, [ecx]       ; sib

+                        inc     ecx

+                        and     al, 0x07

+

+a:                    cmp     ah, 0x40

+                        je      mem1

+                        cmp     ah, 0x80

+                        je      mem4

+

+                        cmp     ax, 0x0005

+                        jne     near exitmodrm

+

+mem4:                 or      dl, C_MEM4

+                        jmp     exitmodrm

+

+mem1:                 or      dl, C_MEM1

+                        jmp     exitmodrm

+

+modrm16:              cmp     ax, 0x0006

+                        je      mem2

+                        cmp     ah, 0x40

+                        je      mem1

+                        cmp     ah, 0x80

+                        jne     near exitmodrm

+

+mem2:                 or      dl, C_MEM2

+                        jmp     exitmodrm

+

+                        endp

+

diff --git a/other/burneye/src/stub/utils/sstrip.c b/other/burneye/src/stub/utils/sstrip.c
new file mode 100644
index 0000000..d0997b9
--- /dev/null
+++ b/other/burneye/src/stub/utils/sstrip.c
@@ -0,0 +1,309 @@
+/* sstrip: Copyright (C) 1999-2001 by Brian Raiter, under the GNU
+ * General Public License. No warranty. See COPYING for details.
+ */
+
+#include        <stdio.h>
+#include        <stdlib.h>
+#include        <string.h>
+#include        <errno.h>
+#include        <unistd.h>
+#include        <fcntl.h>
+#include        <elf.h>
+#include        <asm/elf.h>
+
+#ifndef TRUE
+#define TRUE            1
+#define FALSE           0
+#endif
+
+#if ELF_CLASS == ELFCLASS32
+#define Elf_Ehdr        Elf32_Ehdr
+#define Elf_Phdr        Elf32_Phdr
+#else
+#define Elf_Ehdr        Elf64_Ehdr
+#define Elf_Phdr        Elf64_Phdr
+#endif
+
+/* The name of the program.
+ */
+static char const      *progname;
+
+/* The name of the current file.
+ */
+static char const      *filename;
+
+
+/* A simple error-handling function. FALSE is always returned for the
+ * convenience of the caller.
+ */
+static int err(char const *errmsg)
+{
+    fprintf(stderr, "%s: %s: %s\n", progname, filename, errmsg);
+    return FALSE;
+}
+
+/* A macro for I/O errors: The given error message is used only when
+ * errno is not set.
+ */
+#define ferr(msg)       (err(errno ? strerror(errno) : (msg)))
+
+/* readelfheader() reads the ELF header into our global variable, and
+ * checks to make sure that this is in fact a file that we should be
+ * munging.
+ */
+static int readelfheader(int fd, Elf_Ehdr *ehdr)
+{
+    errno = 0;
+    if (read(fd, ehdr, sizeof *ehdr) != sizeof *ehdr)
+        return ferr("missing or incomplete ELF header.");
+
+    /* Check the ELF signature.
+     */
+    if (!(ehdr->e_ident[EI_MAG0] == ELFMAG0 &&
+          ehdr->e_ident[EI_MAG1] == ELFMAG1 &&
+          ehdr->e_ident[EI_MAG2] == ELFMAG2 &&
+          ehdr->e_ident[EI_MAG3] == ELFMAG3))
+        return err("missing ELF signature.");
+
+    /* Compare the file's class and endianness with the program's.
+     */
+    if (ehdr->e_ident[EI_DATA] != ELF_DATA)
+        return err("ELF file has different endianness.");
+    if (ehdr->e_ident[EI_CLASS] != ELF_CLASS)
+        return err("ELF file has different word size.");
+
+    /* Check the target architecture.
+     */
+    if (ehdr->e_machine != ELF_ARCH)
+        return err("ELF file created for different architecture.");
+
+    /* Verify the sizes of the ELF header and the program segment
+     * header table entries.
+     */
+    if (ehdr->e_ehsize != sizeof(Elf_Ehdr))
+        return err("unrecognized ELF header size.");
+    if (ehdr->e_phentsize != sizeof(Elf_Phdr))
+        return err("unrecognized program segment header size.");
+
+    /* Finally, check the file type.
+     */
+    if (ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
+        return err("not an executable or shared-object library.");
+
+    return TRUE;
+}
+
+/* readphdrtable() loads the program segment header table into memory.
+ */
+static int readphdrtable(int fd, Elf_Ehdr const *ehdr, Elf_Phdr **phdrs)
+{
+    size_t      size;
+
+    if (!ehdr->e_phoff || !ehdr->e_phnum)
+        return err("ELF file has no program header table.");
+
+    size = ehdr->e_phnum * sizeof **phdrs;
+    if (!(*phdrs = malloc(size)))
+        return err("Out of memory!");
+
+    errno = 0;
+    if (read(fd, *phdrs, size) != (ssize_t)size)
+        return ferr("missing or incomplete program segment header table.");
+
+    return TRUE;
+}
+
+/* getmemorysize() determines the offset of the last byte of the file
+ * that is referenced by an entry in the program segment header table.
+ * (Anything in the file after that point is not used when the program
+ * is executing, and thus can be safely discarded.)
+ */
+static int getmemorysize(Elf_Ehdr const *ehdr, Elf_Phdr const *phdrs,
+                         unsigned long *newsize)
+{
+    Elf32_Phdr const   *phdr;
+    unsigned long       size, n;
+    int                 i;
+
+    /* Start by setting the size to include the ELF header and the
+     * complete program segment header table.
+     */
+    size = ehdr->e_phoff + ehdr->e_phnum * sizeof *phdrs;
+    if (size < sizeof *ehdr)
+        size = sizeof *ehdr;
+
+    /* Then keep extending the size to include whatever data the
+     * program segment header table references.
+     */
+    for (i = 0, phdr = phdrs ; i < ehdr->e_phnum ; ++i, ++phdr) {
+        if (phdr->p_type != PT_NULL) {
+            n = phdr->p_offset + phdr->p_filesz;
+            if (n > size)
+                size = n;
+        }
+    }
+
+    *newsize = size;
+    return TRUE;
+}
+
+/* truncatezeros() examines the bytes at the end of the file's
+ * size-to-be, and reduces the size to exclude any trailing zero
+ * bytes.
+ */
+static int truncatezeros(int fd, unsigned long *newsize)
+{
+    unsigned char       contents[1024];
+    unsigned long       size, n;
+
+    size = *newsize;
+    do {
+        n = sizeof contents;
+        if (n > size)
+            n = size;
+        if (lseek(fd, size - n, SEEK_SET) == (off_t)-1)
+            return ferr("cannot seek in file.");
+        if (read(fd, contents, n) != (ssize_t)n)
+            return ferr("cannot read file contents");
+        while (n && !contents[--n])
+            --size;
+    } while (size && !n);
+
+    /* Sanity check.
+     */
+    if (!size)
+        return err("ELF file is completely blank!");
+
+    *newsize = size;
+    return TRUE;
+}
+
+/* modifyheaders() removes references to the section header table if
+ * it was stripped, and reduces program header table entries that
+ * included truncated bytes at the end of the file.
+ */
+static int modifyheaders(Elf_Ehdr *ehdr, Elf_Phdr *phdrs,
+                         unsigned long newsize)
+{
+    Elf32_Phdr *phdr;
+    int         i;
+
+    /* If the section header table is gone, then remove all references
+     * to it in the ELF header.
+     */
+    if (ehdr->e_shoff >= newsize) {
+        ehdr->e_shoff = 0;
+        ehdr->e_shnum = 0;
+        ehdr->e_shentsize = 0;
+        ehdr->e_shstrndx = 0;
+    }
+
+    /* The program adjusts the file size of any segment that was
+     * truncated. The case of a segment being completely stripped out
+     * is handled separately.
+     */
+    for (i = 0, phdr = phdrs ; i < ehdr->e_phnum ; ++i, ++phdr) {
+        if (phdr->p_offset >= newsize) {
+            phdr->p_offset = newsize;
+            phdr->p_filesz = 0;
+        } else if (phdr->p_offset + phdr->p_filesz > newsize) {
+            phdr->p_filesz = newsize - phdr->p_offset;
+        }
+    }
+
+    return TRUE;
+}
+
+/* commitchanges() writes the new headers back to the original file
+ * and sets the file to its new size.
+ */
+static int commitchanges(int fd, Elf_Ehdr const *ehdr, Elf_Phdr *phdrs,
+                         unsigned long newsize)
+{
+    size_t      n;
+
+    /* Save the changes to the ELF header, if any.
+     */
+    if (lseek(fd, 0, SEEK_SET))
+        return ferr("could not rewind file");
+    errno = 0;
+    if (write(fd, ehdr, sizeof *ehdr) != sizeof *ehdr)
+        return err("could not modify file");
+
+    /* Save the changes to the program segment header table, if any.
+     */
+    if (lseek(fd, ehdr->e_phoff, SEEK_SET) == (off_t)-1) {
+        err("could not seek in file.");
+        goto warning;
+    }
+    n = ehdr->e_phnum * sizeof *phdrs;
+    if (write(fd, phdrs, n) != (ssize_t)n) {
+        err("could not write to file");
+        goto warning;
+    }
+
+    /* Eleventh-hour sanity check: don't truncate before the end of
+     * the program segment header table.
+     */
+    if (newsize < ehdr->e_phoff + n)
+        newsize = ehdr->e_phoff + n;
+
+    /* Chop off the end of the file.
+     */
+    if (ftruncate(fd, newsize)) {
+        err("could not resize file");
+        goto warning;
+    }
+
+    return TRUE;
+
+  warning:
+    return err("ELF file may have been corrupted!");
+}
+
+/* main() loops over the cmdline arguments, leaving all the real work
+ * to the other functions.
+ */
+int main(int argc, char *argv[])
+{
+    int                 fd;
+    Elf_Ehdr            ehdr;
+    Elf_Phdr           *phdrs;
+    unsigned long       newsize;
+    char              **arg;
+    int                 failures = 0;
+
+    if (argc < 2 || argv[1][0] == '-') {
+        printf("Usage: sstrip FILE...\n"
+               "sstrip discards all nonessential bytes from an executable.\n\n"
+               "Version 2.0 Copyright (C) 2000,2001 Brian Raiter.\n"
+               "This program is free software, licensed under the GNU\n"
+               "General Public License. There is absolutely no warranty.\n");
+        return EXIT_SUCCESS;
+    }
+
+    progname = argv[0];
+
+    for (arg = argv + 1 ; *arg != NULL ; ++arg) {
+        filename = *arg;
+
+        fd = open(*arg, O_RDWR);
+        if (fd < 0) {
+            ferr("can't open");
+            ++failures;
+            continue;
+        }
+
+        if (!(readelfheader(fd, &ehdr)                  &&
+              readphdrtable(fd, &ehdr, &phdrs)          &&
+              getmemorysize(&ehdr, phdrs, &newsize)     &&
+              truncatezeros(fd, &newsize)               &&
+              modifyheaders(&ehdr, phdrs, newsize)      &&
+              commitchanges(fd, &ehdr, phdrs, newsize)))
+            ++failures;
+
+        close(fd);
+    }
+
+    return failures ? EXIT_FAILURE : EXIT_SUCCESS;
+}