ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[1.c]ÄÄ

//  Advanced ZCME
//  Permutating Engine Research

//  Copyright (C) 1997, 1998 Z0MBiE/29A
//
//  *** NOT FOR [RE]PUBLISHING/DISASM IN VX-ZINES, EXCEPT 29A ***

//  Internal version: 0.04
//  Last modified: 18-07-98

#include "params.h"

char ZERO_FILL_ARRAY[max_size-0x1300] = {0};

#include "system.h"
#include "crt.h"
#include "fileio.h"
#include "random.h"

#include "disasm.h"
#include "engine.h"

void main(void)
  {
    pchar p;

    #ifdef SKIP_PRINTF
    asm
__1:	lea	di, printf
	mov	al, 0xC3
	stosb
	lea	di, __1
	mov	cx, __2 - __1
	mov	al, 0x90
	rep	stosb
    end;
    #endif

    clrscr(3);
    asm
__2:end;

    printf("Startup code executed\n");

    run_engine();

    printf("Terminating\n");

    exit(0);
  }


ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[1.c]ÄÄ
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[params.h]ÄÄ

/* DEBUG parameters */

#define SKIP_PRINTF
#define SKIP_DEBUGFILES

/* ENGINE parameters */

#define SKIP_JMPS
//#define SKIP_JMPS_BUT_ADD_NOPS

#define RANDOM_JCC
//#define INVERSE_JCC

#define SKIP_NOP
//#define SKIP_INT3

#define SKIP_RANDOM

#define ADD_RANDOM	 30
#define CHANGE_CMD

//#define FILL_UNUSED_CC
#define FILL_UNUSED_RANDOM

#define USE_RANDOM_IP	 20

#define min_left	 20
#define min_right	 40
#define min_right_left	 20

#define KILL_J2J
#define MAKE_SHORT_JMPS





#define max_size 0x3000+0x0100
#define max_cmd  3000
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[params.h]ÄÄ
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[system.h]ÄÄ

#define make_ptr( seg,ofs ) ( (void _seg * )( seg ) +( void near * )( ofs ))
#define ptr_seg( fp )	    ( (unsigned )( void _seg * )( void far * )( fp ))
#define ptr_ofs( fp )	    ( (unsigned )( fp ))

typedef unsigned char	  byte;
typedef unsigned int	  word;
typedef unsigned long	  dword;

#define short		signed char
#define pchar		const far char *

#define MAX(a,b)	a > b ? a : b
#define MIN(a,b)	a < b ? a : b

#define asm		asm {
#define end		}

void exit(byte exitcode);
void fillchar(pchar buf, word bufsize, char filler);
void move(pchar src, pchar dest, word size);
word len(pchar str);

void beep(void)
  {
    asm
	mov	al, 7
	int	29h
    end;
  }

void exit(byte exitcode)
  {
    asm
	mov	al, exitcode
	add	al, '0'
	int	29h
	mov	ah, 4Ch
	mov	al, exitcode
	int	21h
    end;
  }

void fillchar(pchar buf, word bufsize, char filler)
  {
    asm
	mov	cx, bufsize
	or	cx, cx
	jz	__1
	les	di, buf
	mov	al, filler
	cld
	rep	stosb
__1:
    end;
  }

void move(pchar src, pchar dest, word size)
  {
    asm
	mov	cx, size
	or	cx, cx
	jz	__1
	push	ds
	lds	si, src
	les	di, dest
	cld
	rep	movsb
	pop	ds
__1:
    end;
  }

word len(pchar str)
  {
    asm
	les	di, str
	mov	cx, 0ffffh
	xor	al, al
	repnz	scasb
	neg	cx
	dec	cx
	dec	cx
	xchg	cx, ax
    end;
  }

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[system.h]ÄÄ
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[crt.h]ÄÄ

void clrscr(byte mode);

void pascal printf_char(char c);
void pascal printf_dword(dword d);
void printf_word(word w);
void printf_byte(byte b);
void pascal printf_long(long l);
void printf_int(int i);
void printf_short(short s);
void pascal printf_hexchar(byte b);
void pascal printf_hexbyte(byte b);
void pascal printf_hexword(word w);
void pascal printf_hexdword(dword d);
void pascal printf_crlf(void);

void printf(pchar format, ...);



void clrscr(byte mode)
  {
    asm
	xor	ax, ax
	mov	al, mode
	int	10h
    end;
  }

void pascal printf_char(char c)
  {
    asm
	mov	ah, 2
	mov	dl, c
	int	21h
    end;
  }

void pascal printf_crlf(void)
  {
    printf_char(13);
    printf_char(10);
  }

void pascal printf_dword(dword d)
  {
    asm
	mov	eax, d
	call	__1
	jmp	__3
__1:	xor	edx, edx
	mov	ebx, 10
	div	ebx
	push	dx
	or	eax, eax
	jz	__2
	call	__1
__2:	pop	ax
	add	al, '0'
	push	ax
	call	printf_char
	ret
__3:
    end;
  }

void printf_word(word w)
  {
    printf_dword(w);
  }

void printf_byte(byte b)
  {
    printf_dword(b);
  }

void pascal printf_long(long l)
  {
    if (l < 0)
      {
	printf_char('-');
	l = -l;
      }
    printf_dword(l);
  }

void printf_int(int i)
  {
    printf_long(i);
  }

void printf_short(short s)
  {
    printf_long(s);
  }

void pascal printf_hexchar(byte b)
  {
    if (b <= 9)
      printf_char('0'+b);
    else
      printf_char('A'+b-10);
  }

void pascal printf_hexbyte(byte b)
  {
     printf_hexchar(b >> 4);
     printf_hexchar(b & 15);
  }

void pascal printf_hexword(word w)
  {
     printf_hexbyte(w >> 8);
     printf_hexbyte(w & 255);
  }

void pascal printf_hexdword(dword d)
  {
     printf_hexword(d >> 16);
     printf_hexword(d & 65535);
  }

void printf(pchar format, ...)
  {
    int stack_ptr = 0;
    asm
	push	ds
	lds	si, format
	cld

__nextchar:
	lodsb

	or	al, al
	jz	__exit

	cmp	al, '%'
	je	__percent

	cmp	al, 10
	je	__crlf

__putchar:
	push	ax
	call	printf_char

	jmp	__nextchar

__crlf: call	printf_crlf

	jmp	__nextchar

__percent:
	lodsb

	or	al, al
	jz	__exit

	cmp	al, 'c'
	je	__c
	cmp	al, 'i'
	je	__i
	cmp	al, 'l'
	je	__l
	cmp	al, 'b'
	je	__b
	cmp	al, 'w'
	je	__w
	cmp	al, 'd'
	je	__d
	cmp	al, 'B'
	je	__B_
	cmp	al, 'W'
	je	__W_
	cmp	al, 'D'
	je	__D_

	jmp	__putchar

__pop_ax:
	mov	di, stack_ptr
	add	word ptr stack_ptr, 2
	mov	ax, [bp+8+di]
	ret

__pop_eax:
	mov	di, stack_ptr
	add	word ptr stack_ptr, 4
	mov	eax, [bp+8+di]
	ret

__c:	call	__pop_ax
	push	ax
	call	printf_char

	jmp	__nextchar

__s:	call	__pop_ax
	push	ax
	call	printf_short

	jmp	__nextchar

__i:	call	__pop_ax
	push	ax
	call	printf_int

	jmp	__nextchar

__l:	call	__pop_eax
	push	eax
	call	printf_long

	jmp	__nextchar

__b:	call	__pop_ax
	push	ax
	call	printf_byte

	jmp	__nextchar

__w:	call	__pop_ax
	push	ax
	call	printf_word

	jmp	__nextchar

__d:	call	__pop_eax
	push	eax
	call	printf_dword

	jmp	__nextchar

__B_:	call	__pop_ax
	push	ax
	call	printf_hexbyte

	jmp	__nextchar

__W_:	call	__pop_ax
	push	ax
	call	printf_hexword

	jmp	__nextchar

__D_:	call	__pop_eax
	push	eax
	call	printf_hexdword

	jmp	__nextchar


__exit:
	pop	ds
    end;
  }
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[crt.h]ÄÄ
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[fileio.h]ÄÄ

#define handle		word

handle openfile(pchar fname);
handle createfile(pchar fname);
void closefile(handle h);
word readfile(handle h, pchar buf, word bufsize);
word writefile(handle h, pchar buf, word bufsize);
dword filepos(handle h);
dword seekfile(handle h, dword newpos);
dword seekeof(handle h);
dword filesize(handle h);

handle openfile(pchar fname)
  {
    asm
	push	ds
	mov	ax, 3d02h
	lds	dx, fname
	int	21h
	pop	ds
    end;
  }

handle createfile(pchar fname)
  {
    asm
	push	ds
	mov	ah, 3Ch
	xor	cx, cx
	lds	dx, fname
	int	21h
	pop	ds
    end;
  }

void closefile(handle h)
  {
    asm
	mov	ah, 3Eh
	mov	bx, h
	int	21h
    end;
  }

word readfile(handle h, pchar buf, word bufsize)
  {
    asm
	push	ds
	mov	ah, 3Fh
	mov	bx, h
	mov	cx, bufsize
	lds	dx, buf
	int	21h
	pop	ds
    end;
  }

word writefile(handle h, pchar buf, word bufsize)
  {
    asm
	push	ds
	mov	ah, 40h
	mov	bx, h
	mov	cx, bufsize
	lds	dx, buf
	int	21h
	pop	ds
    end;
  }

dword filepos(handle h)
  {
    asm
	mov	ax, 4201h
	mov	bx, h
	int	21h
    end;
  }

dword seekfile(handle h, dword newpos)
  {
    asm
	mov	ax, 4200h
	mov	bx, h
	mov	cx, word ptr newpos + 2
	mov	dx, word ptr newpos + 0
	int	21h
    end;
  }

dword seekeof(handle h)
  {
    asm
	mov	ax, 4202h
	mov	bx, h
	xor	cx, cx
	cwd
	int	21h
    end;
  }

dword filesize(handle h)
  {
    dword savepos, retvalue;
    savepos = filepos(h);
    retvalue = seekeof(h);
    seekfile(h, savepos);
    return(retvalue);
  }

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[fileio.h]ÄÄ
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[random.h]ÄÄ

int rndword;

word random_word(void);
word rnd_word(word range);
word rnd_word_minmax(word min, word max);

word random_word(void)
  {
    asm
	mov	bx, rndword
	in	al, 40h
	xor	bl, al
	in	al, 40h
	add	bh, al
	in	al, 41h
	sub	bl, al
	in	al, 41h
	xor	bh, al
	in	al, 42h
	add	bl, al
	in	al, 42h
	sub	bh, al
	mov	ax, bx
	rol	ax, 1
	xor	dx, dx
	mov	cx, 10007
	mul	cx
	inc	ax
	rol	ax, 1
	mov	rndword, ax
    end;
  }

word rnd_word(word range)
  {
    if (range == 0)
      return(0);
    else
      return(random_word() % range);
  }

word rnd_word_minmax(word min, word max)
  {
    return(rnd_word(max-min+1) + min);
  }
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[random.h]ÄÄ
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[disasm.h]ÄÄ

#define cf_is66 	0x0001
#define cf_is67 	0x0002
#define cf_isSEG	0x0004
#define cf_isREP	0x0008
#define cf_isLOCK	0x0010
#define cf_is0F 	0x0020
#define cf_isMODRM	0x0040
#define cf_isSIB	0x0080
#define cf_isMEM	0x0100
#define cf_isDATA	0x0200
#define cf_isDATAREL	0x0400

#define ct_UNKNOWN	0
#define ct_JMP		1
#define ct_JCC		2
#define ct_CALL 	3
#define ct_RET		4

typedef union datauion
  {
    word       w[3];
    byte       b[6];
  } dataunion;

typedef struct tcmdrec
  {
    word       flags;		// cf_xxxx
    word       type;		// ct_xxxx
    word       size;		// total cmd. size
    word       base;		// instruction offset (16-bit)
    byte       px_SEG;		// prefix: segment prefix
    byte       px_REP;		// prefix: repz/repnz
    byte       opcode;
    byte       modrm;
    byte       mod;
    byte       reg;
    byte       rm;
    byte       sib;
    word       memsize;
    byte       mem[4];
    word       datasize;

    dataunion	data;

    word       jmpptr;		// jmp/call ABSOLUTE pointer (+base), 16-bit
  } tcmdrec;

void dump(pchar cmd, word size)
  {
    printf("%W ",(word) cmd);
    for (; size>0; size--, cmd++)
      printf(" %B", (byte) (*cmd));
    printf("\n");
  }

#define getbyte(x)    { x = (byte)  (*cmd_ptr++);   };
#define getword(x)    { x = (word)  (*cmd_ptr+=1);  };
#define getdword(x)   { x = (dword) (*cmd_ptr+=2);  };

#define getnextbyte(x) { x = ((byte) (*cmd_ptr)); }

tcmdrec r;
pchar cmd_ptr;
word disasm_base;

void modrm_proc(void)
  {

    getbyte(r.modrm);

    r.mod = r.modrm >> 6;
    r.reg = (r.modrm >> 3) & 7;
    r.rm  = r.modrm  & 7;

    if ((r.flags & cf_is67) == 0)
    {
       // 16-bit MODR/M

      if (((r.mod == 0) && (r.rm == 6)) || (r.mod == 2)) r.memsize = 2;
      if (r.mod == 1) r.memsize = 1;

    }
    else
    {
       // 32-bit MODR/M

      if (((r.mod == 0) && (r.rm == 5)) || (r.mod == 2)) r.memsize = 4;
      if (r.mod == 1) r.memsize = 1;

      if (r.rm == 4)
	{
	  r.flags |= cf_isSIB;
	  getbyte(r.sib);
	};

    };

  }

void disasm(pchar cmd, tcmdrec far *rec)
  {
    byte b,nextbyte;
    int i;

    fillchar(&r, sizeof(tcmdrec), 0x00);

    r.base = (word) cmd;
    r.jmpptr = -1;

    cmd += disasm_base;
    cmd_ptr = cmd;

    // begin disasm

prefix:
    getbyte(b);

    if ((b==0x2E) ||
	(b==0x26) ||
	(b==0x3E) ||
	(b==0x36) ||
	(b==0x64) ||
	(b==0x65))
      {
	r.flags |= cf_isSEG;
	r.px_SEG = b;
	goto prefix;
      }

    if ((b==0xF2) ||
	(b==0xF3))
      {
	r.flags |= cf_isREP;
	r.px_REP = b;
	goto prefix;
      }

    switch(b)
      {
	case 0x66: r.flags |= cf_is66;
		   goto prefix;
	case 0x67: r.flags |= cf_is67;
		   goto prefix;
	case 0xF0: r.flags |= cf_isLOCK;
		   goto prefix;
      };

    // prefix analyzed

    r.opcode = b;

    if (b == 0x0F) goto prefix_0F;

    getnextbyte(nextbyte);

    if (b == 0xE9)
      {
	r.type	   = ct_JMP;
	goto	   data_offs_rel;
      }

    if (b == 0xE8)
      {
	r.type	   = ct_CALL;
	goto	   data_offs_rel;
      }

    if ((b & 0xF0) == 0x70)
      {
	r.type	   = ct_JCC;
	goto	   data_byte_rel;
      }

    if (b == 0xEB)
      {
	r.type	   = ct_JMP;
	goto	   data_byte_rel;
      }

    if ((b == 0xC3) || (b == 0xCF))
      {
	r.type	   = ct_RET;
	goto	   okey;
      }

    if (b == 0xC2)
      {
	r.type	   = ct_RET;
	goto	   data_word;
      }

    if (b == 0xC8)
      goto	 data_3xbyte;

    if (
       (b == 0xC9) ||
       (b == 0xFC) ||
       (b == 0xAA) ||
       (b == 0xA4) ||
       (b == 0xAE) ||
       (b == 0x98) ||
       (b == 0x99) ||
       (b == 0xAC) ||
       (b == 0xCC)		// int 3
       )
      goto	 okey;

    if ((b & 0xFC) == 0x88)
      goto modrm;

    if ((b & 0xFE) == 0xC6)
      goto modrm_data_w_66;

    if ((b & 0xF0) == 0xB0)
      goto data_w3_66;


    if ((b & 0xFC) == 0xA0)
      goto data_offs;

    if (
       (b == 0xCD) ||
       (b == 0xE4)
       )
      goto data_byte;

    if ((b & 0xF0) == 0x50)
      goto okey;

    if ((b == 0xFF) &&
       (
       (((nextbyte >> 3) & 7) == 0) || (((nextbyte >> 3) & 7) == 6)
       ))
       goto modrm;

    if ((b & 0xFE) == 0xC4)		   //  gluk !
      goto modrm;

    if ((b & 0xE6) == 0x06)
      goto okey;

    if ((b & 0xC4) == 0x00)
      goto modrm;

    if ((b & 0xFC) == 0x80)
      goto modrm_data_sw_66;

    if ((b & 0xC6) == 0x04)
      goto data_w_66;

    if ( ((b & 0xFE) == 0xF6) && (((nextbyte >> 3) & 6) == 2) )
      goto modrm;

    if ((b & 0xF0) == 0x40)
      goto okey;

    if ( ((b & 0xFE) == 0xFE) && (((nextbyte >> 3) & 6) == 0) )
      goto modrm;

    if ((b & 0xF8) == 0x90)
      goto okey;

    if (b == 0x6A)
      goto data_byte;
    if (b == 0x68)
      goto data_66;

    if ( ((b & 0xFE) == 0xF6) && (((nextbyte >> 3) & 6) == 6) )
      goto modrm;

    if ((b & 0xFC) == 0xD0)
      goto modrm;

    if ((b & 0xFE) == 0xC0)
      goto modrm_data_byte;

    if ((b & 0xFE) == 0x84)
      goto modrm;

    if ( ((b & 0xF6) == 0xF6) && (((nextbyte >> 3) & 7) == 0) )
      goto modrm_data_w_66;

    if ((b & 0xFE) == 0xA8)
      goto data_w_66;

    if ((b & 0xFD) == 0x8C)
      goto modrm;

    if (b == 0x8D)
      goto modrm;

    if (  ((b & 0xFE) == 0xF6) && (((nextbyte >> 3) & 7) == 4)	)
      goto modrm;

    if ((b & 0xFE) == 0x86)
      goto modrm;

error:
    dump(cmd, 10);
    printf("<- unknown command\n");
    exit(1);


prefix_0F:

    r.flags |= cf_is0F;
    getbyte(b);
    r.opcode = b;
    getnextbyte(nextbyte);

    if ((b & 0xF0) == 0x80)
      {
	r.type	   = ct_JCC;
	goto	   data_offs_rel;
      }

    if ((b & 0xF6) == 0xB6)
      goto modrm;




   goto error;



modrm_data_byte:
   modrm_proc();
   goto data_byte;

modrm_data_w_66:
   modrm_proc();
   goto data_w_66;

modrm_data_sw_66:
   modrm_proc();
   goto data_sw_66;

modrm:
   modrm_proc();
   goto okey;

data_w3_66:
   if ((r.opcode & 0x08) != 0)
     goto data_66;
   else
     goto data_byte;

data_sw_66:
   if ((r.opcode & 0x02) != 0)
     goto data_byte;
   goto data_w_66;

data_w_66:
   if ((r.opcode & 0x01) != 0)
     goto data_66;
   else
     goto data_byte;

data_byte:
    r.datasize = 1;
    goto data;

data_66:
    if ((r.flags & cf_is66) == 0)
      goto data_word;
    else
      goto data_dword;

data_dword:
    r.datasize = 4;
    goto data;

data_word:
    r.datasize = 2;
    goto data;

data_3xbyte:
    r.datasize = 3;
    goto data;

data_offs:
    if ((r.flags & cf_is67) == 0)
      r.datasize = 2;
    else
      r.datasize = 4;
    goto data;

data_offs_rel:
    if ((r.flags & cf_is66) == 0)
      r.datasize = 2;
    else
      r.datasize = 4;
    goto data_rel;

data_byte_rel:
    r.datasize = 1;
    goto data_rel;

data_rel:
    r.flags |= cf_isDATAREL;
    goto data;

data:
    r.flags |= cf_isDATA;
    goto okey;

okey:
    if (r.datasize != 0)
      for (i=0; i<r.datasize; i++)
	getbyte(r.data.b[i]);

    if (r.memsize != 0)
      for (i=0; i<r.memsize; i++)
	getbyte(r.mem[i]);

    // end disasm

    r.size = cmd_ptr - cmd;

    if ((r.flags & cf_isDATAREL) != 0)
      {
	r.jmpptr = r.base + r.size;
	if (r.datasize == 1)
	  r.jmpptr += (short) r.data.b[0];
	else
	  if (r.datasize == 2)
	    r.jmpptr += (int) r.data.w[0];
	  else
	    {
	      printf("Disasm error calculating r.jmpptr: r.datasize=%w", r.datasize);
	      exit(0);
	    }
      }

    // dump(cmd, r.size);

    move(&r, rec, sizeof(tcmdrec));
  }

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[disasm.h]ÄÄ
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[engine.h]ÄÄ

#define OUTPUT_FILLER	0xCC

#define UNUSED		'-'
#define MARKED		'x'
#define FORNEXTPASS	'N'

byte output[max_size];
byte buf_mark[max_size];
word link_2[max_cmd];
word link_1[max_cmd];
word link_max;
word out_ip;

void mark_cmd(word ofs, word size, byte marker)
  {
    if (buf_mark[ofs] == MARKED)
      {
	printf("Alredy MARKED\n");
	return;
      }
    for (; size > 0; size--)
      buf_mark[ofs++] = marker;
  }

void store_byte(byte b)
  {
    output[out_ip++] = b;
  }

void store_word(word w)
  {
    store_byte(w & 255);
    store_byte(w >> 8);
  }


void store_link(word old_ip,
		word new_ip)
  {
    if (link_max >= max_cmd)
      {
	printf("Too many links(commands)\n");
	exit(1);
      }
    link_1[link_max] = old_ip;
    link_2[link_max] = new_ip;
    link_max++;

    printf("link #%w: %W <--> %W\n", link_max,old_ip,new_ip);
  }

void store_jmp(word to_ip)
  {
    printf("*** STORE_JMP: offs=%W\n", to_ip);

    store_link(0xFFFE, out_ip);

    store_byte(0xE9);
    store_word(to_ip);
  }

void store_jmp_output(word to_ip)
  {
    word w;
    printf("*** STORE_JMP_OUTPUT: offs=%W\n", to_ip);

    store_link(0xFFFF, out_ip);

    //store_byte(0x90);

    store_byte(0xE9);
    store_word(to_ip - (out_ip+2));

  }

word free_space(word start)
  {
    int i;

    for (i=0; (start+i)<max_size, output[start+i] == OUTPUT_FILLER ; i++) ;

    return(i);
  }

void make_new_ip(void)
  {
     word i;
     word c;

     printf("Executing NEW_IP, searching for IP...\n");

     for (c=0; c<1000; c++)
       {

	 i = rnd_word_minmax(0x100+min_left, max_size-min_right);
	 if ( free_space(i) > (min_left+min_right) )
	   goto found;

       };

     printf("***WARNING***: No free space in output buffer\n");
     return;

found:

     i += min_left;

     printf("New IP found at %W\n", i);

     store_jmp_output(i);
     out_ip = i;

  }

void random_new_ip(void)
  {
    #ifdef USE_RANDOM_IP

    printf("Executing RANDOM_NEW_IP\n");

    if (rnd_word(USE_RANDOM_IP) == 0)
      {
	make_new_ip();
      };

    #endif
  }

byte store_inversed_jmp;

void store_cmd(word ip, word size)
  {
    pchar p;
    tcmdrec r;
    word i;

    if (free_space(out_ip) < min_right_left)
      make_new_ip();
    else
      random_new_ip();

    printf("*** STORE_CMD: offs=%W size=%W\n", ip, size);

    store_link(ip, out_ip);

    disasm(make_ptr(_CS,ip), &r);

    if ((r.type == ct_JMP) || (r.type == ct_JCC) || (r.type == ct_CALL))
      {

	if (  (store_inversed_jmp == 1) && (r.type == ct_JCC)  )
	  {
	    r.jmpptr = ip-disasm_base + r.size;
	    r.opcode ^= 1;
	  }

	if ((r.opcode & 0xF0) == 0x80)
	  {
	    store_byte(0x0F);
	    store_byte(r.opcode);
	    store_word(r.jmpptr);
	    return;
	  }

	if ((r.opcode & 0xF0) == 0x70)
	  {
	    store_byte(0x0F);
	    store_byte(r.opcode - 0x70 + 0x80);
	    store_word(r.jmpptr);
	    return;
	  }

	if (r.opcode == 0xEB)
	  {
	    store_byte(0xE9);
	    store_word(r.jmpptr);
	    return;
	  }

	if ( (r.opcode == 0xE8) || (r.opcode == 0xE9) )
	  {
	    store_byte(r.opcode);
	    store_word(r.jmpptr);
	    return;
	  }

	printf("ERROR 1, X=%B\n", r.opcode);
	exit(2);
      }

    #ifdef SKIP_NOP
    if (r.opcode == 0x90)
      return;
    #endif

    #ifdef SKIP_INT3
    if (r.opcode == 0xCC)
      return;
    #endif

    #ifdef SKIP_RANDOM

    if (r.size == 2)
    if (
	(
	  ((r.opcode & 0xFE) == 0x86) ||
	  ((r.opcode & 0xFE) == 0x88)
	)
	&&
	(r.mod == 3)
       )
	 return;

    #endif

    #ifdef CHANGE_CMD
    i = r.opcode & 0xFE;
    if (r.size == 2)
    if (r.mod == 3)
    if ( (i == 0x08) ||
	 (i == 0x0A) ||
	 (i == 0x20) ||
	 (i == 0x22) ||
	 (i == 0x84) )
      {
	i = rnd_word(5);
	if (i == 0) i = 0x08;
	if (i == 1) i = 0x0A;
	if (i == 2) i = 0x20;
	if (i == 3) i = 0x22;
	if (i == 4) i = 0x84;
	store_byte(((r.opcode & 0x01) + i));
	store_byte(r.modrm);

	return;
      };
    #endif

    for (; size>0; size--)
      {
	p = make_ptr(_CS,ip++);
	store_byte( (byte) *p );
      }

    #ifdef ADD_RANDOM
    if (rnd_word(ADD_RANDOM) == 0)
      {
	word f;
	store_byte(0x86 + rnd_word(4));
	f = (random_word() & 7);
	store_byte(0xC0 + (f << 3) + f);

      };
    #endif

  }

byte pass_action;

void process_1(word ip)
  {
    tcmdrec rec;

nextcmd:
     if ((ip <	0x0100) ||
	 (ip >= max_size))
       {
	 printf("IP range check error, exiting\n");
	 return;
       }

     disasm(make_ptr(_CS,ip), &rec);

     printf("Marking: ");
     dump(make_ptr(_CS,ip+disasm_base), rec.size);

     if (pass_action == 2)
       {
	 printf("PASS 2: Saving offset %W to LINK_2[%w]\n", ip, link_max);

	 if (link_max > max_cmd*2)     // *2 becoz using 2 arrays: ..._2 & 1
	   {
	     printf("Too many links!!!");
	     exit(3);
	   };

	 link_2[link_max] = ip;
	 link_max++;
       }

     if (buf_mark[ip] == MARKED)
       {
	 printf("Alredy marked, exiting\n");
	 if (pass_action == 1)
	   store_jmp(ip+disasm_base);
	 return;
       };
     mark_cmd(rec.base, rec.size, MARKED);

     if (rec.type == ct_UNKNOWN)
       {
	 if (pass_action == 1)
	   store_cmd(ip+disasm_base, rec.size);
	 ip += rec.size;
       };

     if (rec.type == ct_RET)
       {
	 if (pass_action == 1)
	   store_cmd(ip+disasm_base, rec.size);
	 printf("[RET]  Exiting\n");
	 return;
       };

     if (rec.type == ct_JMP)
       {

	 if (pass_action == 1)
	   {
	     #ifndef SKIP_JMPS
	       store_cmd(ip+disasm_base, rec.size);
	     #else
	       store_link(ip+disasm_base, out_ip);
	       #ifdef SKIP_JMPS_BUT_ADD_NOPS
	       store_byte(0x90);
	       #endif
	     #endif
	   }

	 printf("[JMP]  Changing IP to %W\n", rec.jmpptr);
	 ip = rec.jmpptr;
       };

     if (rec.type == ct_CALL)
       {
	 if (pass_action == 1)
	   store_cmd(ip+disasm_base, rec.size);
	 ip+=rec.size;
	 printf("[CALL] Marking for next pass: %W\n", rec.jmpptr);
	 mark_cmd(rec.jmpptr, 1, FORNEXTPASS);
       };

     if (rec.type == ct_JCC)
       {

	 #ifdef RANDOM_JCC
	 word rnd = rnd_word(2);
	 #else
	   #ifdef INVERSE_JCC
	   word rnd = 1;
	   #else
	   word rnd = 0;
	   #endif
	 #endif

	 if (rnd == 0)
	   {

	     store_inversed_jmp = 0;

	     if (pass_action == 1)
	       store_cmd(ip+disasm_base, rec.size);

	     ip+=rec.size;

	     printf("[Jcc]  Marking for next pass: %W\n", rec.jmpptr);
	     mark_cmd(rec.jmpptr, 1, FORNEXTPASS);

	   };

	 if (rnd == 1)
	   {

	     store_inversed_jmp = 1;

	     if (pass_action == 1)
	       store_cmd(ip+disasm_base, rec.size);

	     ip+=rec.size;

	     printf("[Jcc] ***INVERSED***  Marking for next pass: %W\n", ip);
	     mark_cmd(ip, 1, FORNEXTPASS);

	     printf("Changing IP to %W\n", rec.jmpptr);
	     ip = rec.jmpptr;

	   };

       };

     goto nextcmd;
  }

void mark_unused(void)
  {
    int i;

    fillchar(buf_mark, max_size, UNUSED);
    link_max = 0;

    printf("Marking entry point(s)\n");

    process_1(0x0100);

cycle:
    printf("Searching for FORNEXTPASS mark(s)\n");

    for (i = 0; i < max_size; i++)
      if (buf_mark[i] == FORNEXTPASS)
	{
	  printf("Found at %W\n", i);
	  process_1(i);
	  goto cycle;
	}

    printf("No FORNEXTPASS-mark(s) found\n");
  }

void run_engine(void)
  {
    handle h;
    word i;
    word j;
    word k;
    word w;
    word q;
    word e;
    pchar p;
    tcmdrec r1;
    tcmdrec r2;
    tcmdrec r3;

    printf("Engine!\n  {\n");

    fillchar(output, max_size, OUTPUT_FILLER);
    out_ip = 0x100;

    disasm_base = 0;
    pass_action = 1;
    printf("Marking UNUSED commands (1)\n");
    mark_unused();

    #ifndef SKIP_DEBUGFILES

    printf("Writing file(s)\n");

    h = createfile("buf_mark.1");
    writefile(h, buf_mark, max_size);
    closefile(h);
    h = createfile("link_1.1");
    writefile(h, link_1, link_max * 2);
    closefile(h);
    h = createfile("link_2.1");
    writefile(h, link_2, link_max * 2);
    closefile(h);

    h = createfile("output.1");
    writefile(h, &output[0x100], max_size-0x100);
    closefile(h);

    #endif

    printf("Updating JMPs...\n");

    fillchar(buf_mark, max_size, UNUSED);

    for (i=0; i<link_max; i++)
      if (link_1[i] != 0xFFFF)
      {
	for (j=0; j<link_max; j++)
	  if (i != j)
	    if (link_2[i] == link_2[j])
	      if (link_1[j] == 0xFFFF)
		goto skip_cycle;

	printf("DEBUG: &out[...]=%W, ...=%W i=%w link_1[i]=%W \n", (word) &output[link_2[i]], link_2[i], i, link_1[i]);

	p = &output[link_2[i]];
	disasm(p, &r);

	if (
	   (r.type == ct_JMP) ||
	   (r.type == ct_JCC) ||
	   (r.type == ct_CALL)
	   )
	 {
	    printf("Command to update found at %W\n", link_2[i]);

	    if (buf_mark[link_2[i]] == MARKED)
	      printf("Alredy updated");
	    else
	    {
		buf_mark[link_2[i]] = MARKED;

		if ( (r.opcode == 0xE9) || (r.opcode == 0xE8) )
		  k=1;
		else
		  k=2;

		printf("k=%w\n",k);

		w = r.data.w[0];

		printf("Points to %W\n",w);

		q = 0;
		for (j=0; j<link_max; j++)
		  if (link_1[j] == w)
		    {
		      printf("Link to (replacing with) %W, j=%w, patch at %W+, link_1[j]=%W\n", link_2[j], j, link_2[i], link_1[j]);

		      e = (int) link_2[j] - (link_2[i] + r.size);

		      output[link_2[i]+k  ] = e & 255;
		      output[link_2[i]+k+1] = ((word) e) >> 8;

		      q++;
		    }

		if (q != 1)
		  {
		    printf("ERROR 2, q=%w\n",q);
		    exit(4);
		  }

	    };

	 };
skip_cycle:
      };

    disasm_base = ((word) &output[0x0100]) - 0x100;
    pass_action = 2;
    printf("Marking UNUSED commands (2)\n");
    mark_unused();

    #ifndef SKIP_DEBUGFILES

    printf("Writing file(s)\n");

    h = createfile("buf_mark.2");
    writefile(h, buf_mark, max_size);
    closefile(h);
    h = createfile("link_1.2");
    writefile(h, link_1, link_max * 2);
    closefile(h);
    h = createfile("link_2.2");
    writefile(h, link_2, link_max * 2);
    closefile(h);

    #endif

    #ifdef KILL_J2J

    printf("Searching for Jxx-JMP, CALL-JMP, CALL-RET situations\n");

    for (i=0; i<link_max; i++)
      {
	disasm(make_ptr(_CS,link_2[i]), &r1);

	if ( (r1.type == ct_CALL) && (r1.opcode == 0xE8) )
	  {
	    disasm(make_ptr(_CS, r1.jmpptr), &r2);

	    if (r2.opcode == 0xC3)
	      {
		printf("CALL-RET found at %W, points to %W\n", r1.base, r1.jmpptr);

		j=r1.base;
		output[j  ] = 0x87; // xchg ax, ax
		output[j+1] = 0xC0;
		output[j+2] = 0x90; // nop
	      };
	  };

	if (
	   (r1.type == ct_JCC ) ||
	   (r1.type == ct_CALL) ||
	   (r1.type == ct_JMP)
	   )
	  {
	    printf("Jxx-JMP or CALL-JMP found at %W, points to %W\n", r1.base, r1.jmpptr);

	    disasm(make_ptr(_CS, r1.jmpptr), &r2);
	    if (r2.type != ct_JMP)
	      printf("Suxx...\n");
	    else
	      {

cycle:		printf("Points to %W\n", r2.jmpptr);

		disasm(make_ptr(_CS, r2.jmpptr), &r3);
		if (r3.type == ct_JMP)
		  {
		    move(&r3, &r2, sizeof(tcmdrec));
		    goto cycle;
		  };

		printf("Updating: cmd at %W, jmpptr=%W -> %W \n", r1.base, r1.jmpptr, r2.jmpptr );

		j=r1.base;
		if ((r1.flags & cf_is0F) != 0) j++;  // 0F
		j++;  // opcode

		w = r2.jmpptr - (j+2);
		output[j  ] = w & 255;
		output[j+1] = w >> 8;

	      };

	  };

      };

    printf("Marking UNUSED commands (3)\n");
    mark_unused();

    #endif

    #ifdef MAKE_SHORT_JMPS

    printf("Searching for Jxx/JMPs\n");

    for (i=0; i<link_max; i++)
      {
	disasm(make_ptr(_CS,link_2[i]), &r1);


	if (r1.type == ct_JCC)
	  {
	    w = r1.jmpptr - (r1.base+2);
	    if ( ((short) (w & 255)) == w)
	      {
		 printf("Changing JCC at %W, r1.data.w[0]=%W\n", r1.base, r1.data.w[0]);

		 output[r1.base+0] = r1.opcode - 0x10;
		 output[r1.base+1] = w & 255;
		 output[r1.base+2] = 0x87;    // xchg ax, ax
		 output[r1.base+3] = 0xC0;    //
	      };
	  };


	if (r1.type == ct_JMP)
	  {
	    w = r1.jmpptr - (r1.base+2);
	    if ( ((short) (w & 255)) == w)
	      {
		 printf("Changing JMP at %W, r1.data.w[0]=%W\n", r1.base, r1.data.w[0]);

		 output[r1.base+0] = 0xEB;
		 output[r1.base+1] = w & 255;
		 buf_mark[r1.base+2] = UNUSED;
	      };
	  };

      };

    #endif

    #ifdef FILL_UNUSED_CC
    printf("Filling UNUSED space with 0xCC\n");
    for (i=0; i<max_size; i++)
      if (buf_mark[i] == UNUSED)
	output[i] = 0xCC;
    #endif

    #ifdef FILL_UNUSED_RANDOM
    printf("Filling UNUSED space with RANDOM bytes\n");
    for (i=0; i<max_size; i++)
      if (buf_mark[i] == UNUSED)
	output[i] = random_word();
    #endif

    printf("Writing 1.COM\n");

    h = openfile("1.com");
    writefile(h, &output[0x100], max_size-0x100);
    closefile(h);

    printf("  }\nEngine terminated.\n");
  }

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ[engine.h]ÄÄ