addEvent(window, 'load', init, false);

// wnm code above^^^^ everything below is original until the "volatile section"

/* This notice must be untouched at all times.

wz_dragdrop.js	v. 4.85
The latest version is available at
http://www.walterzorn.com
or http://www.devira.com
or http://www.walterzorn.de

Copyright (c) 2002-2003 Walter Zorn. All rights reserved.
Created 26. 8. 2002 by Walter Zorn (Web: http://www.walterzorn.com )
Last modified: 3. 7. 2006

This DHTML & Drag&Drop Library adds Drag&Drop functionality
to the following types of html-elements:
- images, even if not positioned via layers,
  nor via stylesheets or any other kind of "hard-coding"
- relatively and absolutely positioned layers (DIV elements).
Moreover, it provides extended DHTML abilities.

LICENSE: LGPL

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License (LGPL) as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

For more details on the GNU Lesser General Public License,
see http://www.gnu.org/copyleft/lesser.html
*/

/* all main routines are original, but extended scripting routines have been 
modified. additional routines (functions) have also been added 
in the volatile section. 20061022 wnm */

// PATH TO THE TRANSPARENT 1*1 PX IMAGE (required by NS 4 as spacer)
var spacer = 'transparentpixel.gif';




//window.onerror = new Function('return true;');


// Optional commands passed to SET_DHTML() on the html-page (g: may be applied globally, i: individually)
var CLONE			= 'C10nE';   // i  img	  clone image
var COPY			 = 'C0pY';	// i  img	  create copies
var DETACH_CHILDREN  = 'd37aCH';  // i  lyr	  detach images
var HORIZONTAL	   = 'H0r1Z';   // i  img,lyr  horizontally draggable only
var MAXHEIGHT		= 'm7x8I';   // i  img,lyr  maximum height limit, "
var MAXOFFBOTTOM	 = 'm7xd0wN'; // i  img,lyr  downward offset limit
var MAXOFFLEFT	   = 'm7x23Ft'; // i  img,lyr  leftward offset limit
var MAXOFFRIGHT	  = 'm7x0Ff8'; // i  img,lyr  rightward offset limit
var MAXOFFTOP		= 'm7xu9';   // i  img,lyr  upward offset limit
var MAXWIDTH		 = 'm7xW1';   // i  img,lyr  maximum width limit, use with resizable or scalable
var MINWIDTH		 = 'm1nw1';   // i  img,lyr  minimum width limit, "
var MINHEIGHT		= 'm1n8I';   // i  img,lyr  minimum height limit, "
var NO_ALT		   = 'no81T';   // gi img	  disable alt and title attributes
var NO_DRAG		  = 'N0d4Ag';  // i  img,lyr  disable draggability
var RESET_Z		  = 'r35E7z';  // gi img,lyr  reset z-index when dropped
var RESIZABLE		= 'r5IZbl';  // gi img,lyr  resizable if <ctrl> or <shift> pressed
var SCALABLE		 = 'SCLbl';   // gi img,lyr  scalable		   "
var SCROLL		   = 'sC8lL';   // gi img,lyr  enable auto scroll functionality
var TRANSPARENT	  = 'dIApHAn'; // gi img,lyr  translucent while dragged
var VERTICAL		 = 'V3Rt1C';  // i  img,lyr  vertically draggable only
var dd_cursors = new Array(
	'c:default',
	'c:crosshair',
	'c:e-resize',
	'c:hand',
	'c:help',
	'c:move',
	'c:n-resize',
	'c:ne-resize',
	'c:nw-resize',
	'c:s-resize',
	'c:se-resize',
	'c:sw-resize',
	'c:text',
	'c:w-resize',
	'c:wait'
);
var dd_i = dd_cursors.length; while(dd_i--)
	eval('var CURSOR_' + (dd_cursors[dd_i].substring(2).toUpperCase().replace('-', '_')) + ' = "' + dd_cursors[dd_i] + '";');
var dd_u = "undefined";
function WZDD()
{
	this.elements = new Array(0);
	this.obj = null;
	this.n = navigator.userAgent.toLowerCase();
	this.db = (document.compatMode && document.compatMode.toLowerCase() != "backcompat")?
		document.documentElement
		: (document.body || null);
	this.op = !!(window.opera && document.getElementById);
	if(this.op) document.onmousedown = new Function('e',
		'if(((e = e || window.event).target || e.srcElement).tagName == "IMAGE") return false;');
	this.ie = !!(this.n.indexOf("msie") >= 0 && document.all && this.db && !this.op);
	this.iemac = !!(this.ie && this.n.indexOf("mac") >= 0);
	this.ie4 = !!(this.ie && !document.getElementById);
	this.n4 = !!(document.layers && typeof document.classes != dd_u);
	this.n6 = !!(typeof window.getComputedStyle != dd_u && typeof document.createRange != dd_u);
	this.w3c = !!(!this.op && !this.ie && !this.n6 && document.getElementById);
	this.ce = !!(document.captureEvents && document.releaseEvents);
	this.px = this.n4? '' : 'px';
	this.tiv = this.w3c? 40 : 10;
}
var dd = new WZDD();

dd.Int = function(d_x, d_y)
{
	return isNaN(d_y = parseInt(d_x))? 0 : d_y;
};
dd.getWndW = function()
{
	return dd.Int(
		(dd.db && !dd.op && !dd.w3c && dd.db.clientWidth)? dd.db.clientWidth
		: (window.innerWidth || 0)
	);
};
dd.getWndH = function()
{
	return dd.Int(
		(dd.db && !dd.op && !dd.w3c && dd.db.clientHeight)? dd.db.clientHeight
		: (window.innerHeight || 0)
	);
};
dd.getScrollX = function()
{
	return dd.Int(window.pageXOffset || (dd.db? dd.db.scrollLeft : 0));
};
dd.getScrollY = function()
{
	return dd.Int(window.pageYOffset || (dd.db? dd.db.scrollTop : 0));
};
dd.getPageXY = function(d_o)
{
	if(dd.n4 && d_o)
	{
		dd.x = d_o.pageX || 0;
		dd.y = d_o.pageY || 0;
	}
	else
	{
		dd.x = dd.y = 0; //global helper vars
		while(d_o)
		{
			dd.x += dd.Int(d_o.offsetLeft);
			dd.y += dd.Int(d_o.offsetTop);
			d_o = d_o.offsetParent || null;
		}
	}
};
dd.getCssXY = function(d_o)
{
	if(d_o.div)
	{
		if(dd.n4)
		{
			d_o.cssx = d_o.div.x;
			d_o.cssy = d_o.div.y;
		}
		else if(dd.ie4)
		{
			d_o.cssx = d_o.css.pixelLeft;
			d_o.cssy = d_o.css.pixelTop;
		}
		else
		{
			d_o.css.left = d_o.css.top = 0 + dd.px;
			dd.getPageXY(d_o.div);
			d_o.cssx = d_o.x - dd.x;
			d_o.cssy = d_o.y - dd.y;
			d_o.css.left = d_o.cssx + dd.px;
			d_o.css.top = d_o.cssy + dd.px;
		}
	}
	else
	{
		d_o.cssx = 0;
		d_o.cssy = 0;
	}
};
dd.getImgW = function(d_o)
{
	return d_o? dd.Int(d_o.width) : 0;
};
dd.getImgH = function(d_o)
{
	return d_o? dd.Int(d_o.height) : 0;
};
dd.getDivW = function(d_o)
{
	return dd.Int(
		dd.n4? (d_o.div? d_o.div.clip.width : 0)
		: d_o.div? (d_o.div.offsetWidth || d_o.css.pixelWidth || d_o.css.width || 0)
		: 0
	);
};
dd.getDivH = function(d_o)
{
	return dd.Int(
		dd.n4? (d_o.div? d_o.div.clip.height : 0)
		: d_o.div? (d_o.div.offsetHeight || d_o.css.pixelHeight || d_o.css.height || 0)
		: 0
	);
};
dd.getWH = function(d_o)
{
	d_o.w = dd.getDivW(d_o);
	d_o.h = dd.getDivH(d_o);
	if(d_o.css)
	{
		d_o.css.width = d_o.w + dd.px;
		d_o.css.height = d_o.h + dd.px;
		d_o.dw = dd.getDivW(d_o)-d_o.w;
		d_o.dh = dd.getDivH(d_o)-d_o.h;
		d_o.css.width = (d_o.w-d_o.dw) + dd.px;
		d_o.css.height = (d_o.h-d_o.dh) + dd.px;
	}
	else d_o.dw = d_o.dh = 0;
};
dd.getCssProp = function(d_o, d_pn6, d_pstyle, d_pn4)
{
	if(d_o && dd.n6) return ''+window.getComputedStyle(d_o, null).getPropertyValue(d_pn6);
	if(d_o && d_o.currentStyle) return ''+eval('d_o.currentStyle.'+d_pstyle);
	if(d_o && d_o.style) return ''+eval('d_o.style.'+d_pstyle);
	if(d_o && dd.n4) return ''+eval('d_o.'+d_pn4);
	return '';
};
dd.getDiv = function(d_x, d_d)
{
	d_d = d_d || document;
	if(dd.n4)
	{
		if(d_d.layers[d_x]) return d_d.layers[d_x];
		for(var d_i = d_d.layers.length; d_i--;)
		{
			var d_y = dd.getDiv(d_x, d_d.layers[d_i].document);
			if(d_y) return d_y;
		}
	}
	if(dd.ie) return d_d.all[d_x] || null;
	if(d_d.getElementById) return d_d.getElementById(d_x) || null;
	return null;
};
dd.getImg = function(d_o, d_nm, d_xy, d_w)
{
	d_w = d_w || window;
	var d_img;
	if(document.images && (d_img = d_w.document.images[d_nm]))
	{
		if(d_xy)
		{
			if(dd.n4)
			{
				dd.getPageXY(d_w);
				d_o.defx = d_img.x + dd.x;
				d_o.defy = d_img.y + dd.y;
			}
			else
			{
				dd.getPageXY(d_img);
				d_o.defx = dd.x;
				d_o.defy = dd.y;
			}
		}
		return d_img;
	}
	if(dd.n4) for(var d_i = d_w.document.layers.length; d_i--;)
	{
		var d_y = dd.getImg(d_o, d_nm, d_xy, d_w.document.layers[d_i]);
		if(d_y) return d_y;
	}
	return null;
};
dd.getParent = function(d_o, d_p)
{
	if(dd.n4)
	{
		for(d_p, d_i = dd.elements.length; d_i--;)
		{
			if(!((d_p = dd.elements[d_i]).is_image) && d_p.div && (d_p.div.document.layers[d_o.name] || d_o.oimg && d_p.div.document.images[d_o.oimg.name]))
				d_p.addChild(d_o, d_p.detach, 1);
		}
	}
	else
	{
		d_p = d_o.is_image? dd.getImg(d_o, d_o.oimg.name) : (d_o.div || null);
		while(d_p && !!(d_p = d_p.offsetParent || d_p.parentNode || null))
		{
			if(d_p.ddObj)
			{
				d_p.ddObj.addChild(d_o, d_p.ddObj.detach, 1);
				break;
			}
		}
	}
};
dd.getCmd = function(d_o, d_cmd, d_cmdStr)
{
	var d_i = d_o.id.indexOf(d_cmd), d_j,
	d_y = (d_i >= 0)*1;
	if(d_y)
	{
		d_j = d_i+d_cmd.length;
		if(d_cmdStr) d_o.cmd += d_o.id.substring(d_i, d_j);
		d_o.id = d_o.id.substring(0, d_i) + d_o.id.substring(d_j);
	}
	return d_y;
};
dd.getCmdVal = function(d_o, d_cmd, d_cmdStr, int0)
{
	var d_i = d_o.id.indexOf(d_cmd), d_j,
	d_y = (d_o.id.indexOf(d_cmd) >= 0)? dd.Int(d_o.id.substring(d_o.id.indexOf(d_cmd)+d_cmd.length)) : int0? -1 : 0;
	if(!int0 && d_y || int0 && d_y >= 0)
	{
		d_j = d_i+d_cmd.length+(""+d_y).length;
		if(d_cmdStr) d_o.cmd += d_o.id.substring(d_i, d_j);
		d_o.id = d_o.id.substring(0, d_i) + d_o.id.substring(d_j);
	}
	return d_y;
};
dd.addElt = function(d_o, d_p)
{
	dd.elements[d_o.name] = dd.elements[d_o.index = dd.elements.length] = d_o;
	if(d_p) d_p.copies[d_o.name] = d_p.copies[d_p.copies.length] = d_o;
};
dd.mkWzDom = function()
{
	var d_o, d_i = dd.elements.length; while(d_i--) dd.getParent(dd.elements[d_i]);
	d_i = dd.elements.length; while(d_i--)
	{
		d_o = dd.elements[d_i];
		if(d_o.children && !d_o.parent)
		{
			var d_j = d_o.children.length; while(d_j--)
				d_o.children[d_j].setZ(d_o.z+d_o.children[d_j].z, 1);
		}
	}
};
dd.addProps = function(d_o)
{
	var d_i, d_c;
	if(d_o.is_image)
	{
		d_o.div = dd.getDiv(d_o.id);
		d_o.css = (d_o.div && typeof d_o.div.style != dd_u)? d_o.div.style : null;
		d_o.nimg = (dd.n4 && d_o.div)? d_o.div.document.images[0] : (document.images[d_o.id+"NI1m6G"] || null);
		if(!d_o.noalt && !dd.noalt && d_o.nimg && d_o.oimg)
		{
			d_o.nimg.alt = d_o.oimg.alt || '';
			if(d_o.oimg.title) d_o.nimg.title = d_o.oimg.title;
		}
		d_o.bgColor = '';
	}
	else
	{
		d_o.bgColor = dd.getCssProp(d_o.div, 'background-color','backgroundColor','bgColor').toLowerCase();
		if(dd.n6 && d_o.div)
		{
			if((d_c = d_o.bgColor).indexOf('rgb') >= 0)
			{
				d_c = d_c.substring(4, d_c.length-1).split(',');
				d_o.bgColor = '#';
				for(d_i = 0; d_i < d_c.length; d_i++) d_o.bgColor += parseInt(d_c[d_i]).toString(0x10);
			}
			else d_o.bgColor = d_c;
		}
	}
	if(dd.scalable) d_o.scalable = d_o.resizable^1;
	else if(dd.resizable) d_o.resizable = d_o.scalable^1;
	d_o.setZ(d_o.defz);
	d_o.cursor = d_o.cursor || dd.cursor || 'auto';
	d_o._setCrs(d_o.nodrag? 'auto' : d_o.cursor);
	d_o.diaphan = d_o.diaphan || dd.diaphan || 0;
	d_o.opacity = 1.0;
	d_o.visible = true;
};
dd.initz = function()
{
	if(!(dd && (dd.n4 || dd.n6 || dd.ie || dd.op || dd.w3c))) return;
	else if(dd.n6 || dd.ie || dd.op || dd.w3c) dd.recalc(1);
	var d_drag = (document.onmousemove == DRAG),
	d_resize = (document.onmousemove == RESIZE);
	if(dd.loadFunc) dd.loadFunc();
	if(d_drag) dd.setMovHdl(DRAG);
	else if(d_resize) dd.setMovHdl(RESIZE);
	if(d_drag || d_resize) dd.setUpHdl(DROP);
	dd.setDwnHdl(PICK);
};
dd.finlz = function()
{
	if(dd.ie && dd.elements)
	{
		var d_i = dd.elements.length; while(d_i--)
			dd.elements[d_i].del();
	}
	if(dd.uloadFunc) dd.uloadFunc();
};
dd.setCe = function(d_e, d_fnc)
{
	d_fnc? document.captureEvents(d_e) : document.releaseEvents(d_e);
};
dd.setDwnHdl = function(d_x)
{
	if(document.onmousedown != d_x)
	{
		dd.downFunc = document.onmousedown;
		document.onmousedown = d_x;
		if(dd.ce) dd.setCe(Event.MOUSEDOWN, d_x);
	}
};
dd.setMovHdl = function(d_x)
{
	if(document.onmousemove != d_x)
	{
		dd.moveFunc = document.onmousemove;
		document.onmousemove = d_x;
		if(dd.ce) dd.setCe(Event.MOUSEMOVE, d_x);
	}
};
dd.setUpHdl = function(d_x)
{
	if(document.onmouseup != d_x)
	{
		dd.upFunc = document.onmouseup;
		document.onmouseup = d_x;
		if(dd.ce) dd.setCe(Event.MOUSEUP, d_x);
	}
};
dd.evt = function(d_e)
{
	this.but = (this.e = d_e || window.event).which || this.e.button || 0;
	this.button = (this.e.type == 'mousedown')? this.but
		: (dd.e && dd.e.button)? dd.e.button
		: 0;
	this.src = this.e.target || this.e.srcElement || null;
	this.src.tag = ("" + (this.src.tagName || this.src)).toLowerCase();
	this.x = dd.Int(this.e.pageX || this.e.clientX || 0);
	this.y = dd.Int(this.e.pageY || this.e.clientY || 0);
	if(dd.ie)
	{
		this.x += dd.getScrollX() - (dd.ie && !dd.iemac)*1;
		this.y += dd.getScrollY() - (dd.ie && !dd.iemac)*1;
	}
	this.modifKey = this.e.modifiers? this.e.modifiers&Event.SHIFT_MASK : (this.e.shiftKey || false);
};
dd.getEventTarget = function(d_e, d_s, d_n)
{
	d_e = d_e || window.event;
	if(d_e && (d_s = d_e.target || d_e.srcElement || null) != null)
	{
		if(null != (d_n = d_s.id || d_s.name || null))
		{
			if(d_n.indexOf("dIi15vNI1m6G") == d_n.length-12)
				return dd.elements[d_n.substring(0, d_n.length-12)] || null;
			if(d_n.indexOf("dIi15v") == d_n.length-6)
				return dd.elements[d_n.substring(0, d_n.length-6)] || null;
			return dd.elements[d_n] || null;
		}
	}
	return null;
};
dd.recalc = function(d_x)
{
	var d_o, d_i = dd.elements.length; while(d_i--)
	{
		if(!(d_o = dd.elements[d_i]).is_image && d_o.div)
		{
			dd.getWH(d_o);
			if(d_o.div.pos_rel)
			{
				dd.getPageXY(d_o.div);
				var d_dx = dd.x - d_o.x, d_dy = dd.y - d_o.y;
				d_o.defx += d_dx;
				d_o.x += d_dx;
				d_o.defy += d_dy;
				d_o.y += d_dy;
				var d_p, d_j = d_o.children.length; while(d_j--)
				{
					if(!(d_p = d_o.children[d_j]).detached && (d_o != d_p.defparent || !(d_p.is_image && dd.getImg(d_p, d_p.oimg.name, 1))))
					{
						d_p.defx += d_dx;
						d_p.defy += d_dy;
						d_p.moveBy(d_dx, d_dy);
					}
				}
			}
		}
		else if(d_o.is_image && !dd.n4)
		{
			if(dd.n6 && d_x && !d_o.defw) d_o.resizeTo(d_o.defw = dd.getImgW(d_o.oimg), d_o.defh = dd.getImgH(d_o.oimg));
			var d_defx = d_o.defx, d_defy = d_o.defy;
			if(!(d_o.parent && d_o.parent != d_o.defparent) && (d_x || !d_o.detached || d_o.horizontal || d_o.vertical) && dd.getImg(d_o, d_o.oimg.name, 1))
				d_o.moveBy(d_o.defx-d_defx, d_o.defy-d_defy);
		}
	}
};
function WINSZ(d_x)
{
	if(d_x)
	{
		if(dd.n4)
		{
			dd.iW = innerWidth;
			dd.iH = innerHeight;
		}
		window.onresize = new Function('WINSZ();');
	}
	else if(dd.n4 && (innerWidth != dd.iW || innerHeight != dd.iH)) location.reload();
	else if(!dd.n4) setTimeout('dd.recalc()', 0xa);
}
WINSZ(1);

function DDObj(d_o, d_i)
{
	this.id = d_o;
	this.cmd = '';
	this.cpy_n = dd.getCmdVal(this, COPY);
	this.maxoffb = dd.getCmdVal(this, MAXOFFBOTTOM, 0, 1);
	this.maxoffl = dd.getCmdVal(this, MAXOFFLEFT, 0, 1);
	this.maxoffr = dd.getCmdVal(this, MAXOFFRIGHT, 0, 1);
	this.maxofft = dd.getCmdVal(this, MAXOFFTOP, 0, 1);
	var d_j = dd_cursors.length; while(d_j--)
		if(dd.getCmd(this, dd_cursors[d_j], 1)) this.cursor = dd_cursors[d_j].substring(2);
	this.clone = dd.getCmd(this, CLONE, 1);
	this.detach = dd.getCmd(this, DETACH_CHILDREN);
	this.scalable = dd.getCmd(this, SCALABLE, 1);
	this.horizontal = dd.getCmd(this, HORIZONTAL);
	this.noalt = dd.getCmd(this, NO_ALT, 1);
	this.nodrag = dd.getCmd(this, NO_DRAG);
	this.scroll = dd.getCmd(this, SCROLL, 1);
	this.resizable = dd.getCmd(this, RESIZABLE, 1);
	this.re_z = dd.getCmd(this, RESET_Z, 1);
	this.diaphan = dd.getCmd(this, TRANSPARENT, 1);
	this.vertical = dd.getCmd(this, VERTICAL);
	this.maxw = dd.getCmdVal(this, MAXWIDTH, 1, 1);
	this.minw = Math.abs(dd.getCmdVal(this, MINWIDTH, 1, 1));
	this.maxh = dd.getCmdVal(this, MAXHEIGHT, 1, 1);
	this.minh = Math.abs(dd.getCmdVal(this, MINHEIGHT, 1, 1));
	this.pickFunc = this.dragFunc = this.resizeFunc = this.dropFunc = null;

	this.name = this.id + (d_i || '');
	this.oimg = dd.getImg(this, this.id, 1);
	this.is_image = !!this.oimg;
	this.copies = new Array();
	this.children = new Array();
	this.parent = this.original = null;
	if(this.oimg)
	{
		this.id = this.name + "dIi15v";
		this.w = dd.getImgW(this.oimg);
		this.h = dd.getImgH(this.oimg);
		this.dw = this.dh = 0;
		this.defz = dd.Int(dd.getCssProp(this.oimg, 'z-index','zIndex','zIndex')) || 1;
		this.defsrc = this.src = this.oimg.src;
		this.htm = '<img name="' + this.id + 'NI1m6G"'+
			' src="' + this.oimg.src + '" '+
			'width="' + this.w + '" height="' + this.h + '">';
		this.t_htm = '<div id="' + this.id +
			'" style="position:absolute;'+
			'left:' + (this.cssx = this.x = this.defx) + 'px;'+
			'top:' + (this.cssy = this.y = this.defy) + 'px;'+
			'width:' + this.w + 'px;'+
			'height:' + this.h + 'px;">'+
			this.htm + '</div>';
	}
	else
	{
		if(!!(this.div = dd.getDiv(this.id)) && typeof this.div.style != dd_u) this.css = this.div.style;
		dd.getWH(this);
		if(this.div)
		{
			this.div.ddObj = this;
			this.div.pos_rel = ("" + (this.div.parentNode? this.div.parentNode.tagName : this.div.parentElement? this.div.parentElement.tagName : '').toLowerCase().indexOf('body') < 0);
		}
		dd.getPageXY(this.div);
		this.defx = this.x = dd.x;
		this.defy = this.y = dd.y;
		dd.getCssXY(this);
		this.defz = dd.Int(dd.getCssProp(this.div, 'z-index','zIndex','zIndex'));
	}
	this.defw = this.w || 0;
	this.defh = this.h || 0;
}
DDObj.prototype.setPickFunc = function(d_x)
{
	this.pickFunc = d_x;
};
DDObj.prototype.setDragFunc = function(d_x)
{
	this.dragFunc = d_x;
};
DDObj.prototype.setResizeFunc = function(d_x)
{
	this.resizeFunc = d_x;
};
DDObj.prototype.setDropFunc = function(d_x)
{
	this.dropFunc = d_x;
};
DDObj.prototype.moveBy = function(d_x, d_y, d_kds, d_o)
{
	if(!this.div) return;
	this.x += (d_x = dd.Int(d_x));
	this.y += (d_y = dd.Int(d_y));
	if(!d_kds || this.is_image || this.parent != this.defparent)
	{
		(d_o = this.css || this.div).left = (this.cssx += d_x) + dd.px;
		d_o.top = (this.cssy += d_y) + dd.px;
	}
	var d_i = this.children.length; while(d_i--)
	{
		if(!(d_o = this.children[d_i]).detached) d_o.moveBy(d_x, d_y, 1);
		d_o.defx += d_x;
		d_o.defy += d_y;
	}
};

DDObj.prototype.moveTo = function(d_x, d_y)
{
	this.moveBy(dd.Int(d_x)-this.x, dd.Int(d_y)-this.y);
};
DDObj.prototype.hide = function(d_m, d_o, d_p)
{
	if(this.div && this.visible)
	{
		d_p = this.css || this.div;
		if(d_m && !dd.n4)
		{
			this.display = dd.getCssProp(this.div, "display", "display", "display");
			if(this.oimg)
			{
				this.oimg.display = dd.getCssProp(this.oimg, "display", "display", "display");
				this.oimg.style.display = "none";
			}
			d_p.display = "none";
			dd.recalc();
		}
		else d_p.visibility = "hidden";
	}
	this.visible = false;
	var d_i = this.children.length; while(d_i--)
		if(!(d_o = this.children[d_i]).detached) d_o.hide(d_m);
};
DDObj.prototype.show = function(d_o, d_p)
{
	if(this.div)
	{
		d_p = this.css || this.div;
		if(d_p.display && d_p.display == "none")
		{
			d_p.display = this.display || "block";
			if(this.oimg) this.oimg.style.display = this.oimg.display || "inline";
			dd.recalc();
		}
		else d_p.visibility = "visible";
	}
	this.visible = true;
	var d_i = this.children.length; while(d_i--)
		if(!(d_o = this.children[d_i]).detached) d_o.show();
};
DDObj.prototype.resizeTo = function(d_w, d_h, d_o)
{
	if(!this.div) return;
	d_w = (this.w = dd.Int(d_w))-this.dw;
	d_h = (this.h = dd.Int(d_h))-this.dh;
	if(dd.n4)
	{
		this.div.resizeTo(d_w, d_h);
		if(this.is_image)
		{
			this.write('<img src="' + this.src + '" width="' + d_w + '" height="' + d_h + '">');
			(this.nimg = this.div.document.images[0]).src = this.src;
		}
	}
	else if(typeof this.css.pixelWidth != dd_u)
	{
		this.css.pixelWidth = d_w;
		this.css.pixelHeight = d_h;
		if(this.is_image)
		{
			(d_o = this.nimg.style).pixelWidth = d_w;
			d_o.pixelHeight = d_h;
		}
	}
	else
	{
		this.css.width = d_w + dd.px;
		this.css.height = d_h + dd.px;
		if(this.is_image)
		{
			(d_o = this.nimg).width = d_w;
			d_o.height = d_h;
			if(!d_o.complete) d_o.src = this.src;
		}
	}
};
DDObj.prototype.resizeBy = function(d_dw, d_dh)
{
	this.resizeTo(this.w+dd.Int(d_dw), this.h+dd.Int(d_dh));
};
DDObj.prototype.swapImage = function(d_x, d_cp)
{
	if(!this.nimg) return;
	this.nimg.src = d_x;
	this.src = this.nimg.src;
	if(d_cp)
	{
		var d_i = this.copies.length; while(d_i--)
			this.copies[d_i].src = this.copies[d_i].nimg.src = this.nimg.src;
	}
};
DDObj.prototype.setBgColor = function(d_x)
{
	if(dd.n4 && this.div) this.div.bgColor = d_x;
	else if(this.css) this.css.background = d_x;
	this.bgColor = d_x;
};
DDObj.prototype.write = function(d_x, d_o)
{
	this.text = d_x;
	if(!this.div) return;
	if(dd.n4)
	{
		(d_o = this.div.document).open();
		d_o.write(d_x);
		d_o.close();
		dd.getWH(this);
	}
	else
	{
		this.css.height = 'auto';
		this.div.innerHTML = d_x;
		if(!dd.ie4) dd.recalc();
		if(dd.ie4 || dd.n6) setTimeout('dd.recalc();', 0); // n6.0: recalc twice
	}
};
DDObj.prototype.copy = function(d_n, d_p, d_b)
{
	if(!this.oimg) return;
	d_b = (dd.ie && document.all.tags('body'))? document.all.tags('body')[0] : document.getElementsByTagName? (document.getElementsByTagName('body')[0] || dd.db) : dd.db;
	d_n = d_n || 1;
	while(d_n--)
	{
		var d_l = this.copies.length,
		d_o = new DDObj(this.name+this.cmd, d_l+1);
		if(dd.n4)
		{
			d_o.id = (d_p = new Layer(d_o.w)).name;
			d_p.clip.height = d_o.h;
			d_p.visibility = 'show';
			(d_p = d_p.document).open();
			d_p.write(d_o.htm);
			d_p.close();
		}
		else if(d_b && d_b.insertAdjacentHTML) d_b.insertAdjacentHTML("AfterBegin", d_o.t_htm);
		else if(document.createElement && d_b && d_b.appendChild)
		{
			d_b.appendChild(d_p = document.createElement("dIi15v"));
			d_p.innerHTML = d_o.htm;
			d_p.id = d_o.id;
			d_p.style.position = 'absolute';
			d_p.style.width = d_o.w + 'px';
			d_p.style.height = d_o.h + 'px';
		}
		else if(d_b && d_b.innerHTML) d_b.innerHTML += d_o.t_htm;
		d_o.defz = this.defz+1+d_l;
		dd.addProps(d_o);
		d_o.original = this;
		dd.addElt(d_o, this);
		if(this.parent)
		{
			this.parent.addChild(d_o, this.detached);
			d_o.defparent = this.defparent;
		}
		d_o.moveTo(d_o.defx = this.defx, d_o.defy = this.defy);
		if(dd.n4) d_o.defsrc = d_o.src = this.defsrc;
		d_o.swapImage(this.src);
	}
};
DDObj.prototype.addChild = function(d_kd, detach, defp)
{
	if(typeof d_kd != "object") d_kd = dd.elements[d_kd];
	if(d_kd.parent && d_kd.parent == this || d_kd == this || !d_kd.is_image && d_kd.defparent && !defp) return;

	this.children[this.children.length] = this.children[d_kd.name] = d_kd;
	d_kd.detached = detach || 0;
	if(defp) d_kd.defparent = this;
	else if(this == d_kd.defparent && d_kd.is_image) dd.getImg(this, d_kd.oimg.name, 1);
	if(!d_kd.defparent || this != d_kd.defparent)
	{
		d_kd.defx = d_kd.x;
		d_kd.defy = d_kd.y;
	}
	if(!detach)
	{
		d_kd.defz = d_kd.defz+this.defz-(d_kd.parent? d_kd.parent.defz : 0)+(!d_kd.is_image*1);
		d_kd.setZ(d_kd.z+this.z-(d_kd.parent? d_kd.parent.z : 0)+(!d_kd.is_image*1), 1);
	}
	if(d_kd.parent) d_kd.parent._removeChild(d_kd, 1);
	d_kd.parent = this;
};
DDObj.prototype._removeChild = function(d_kd, d_newp)
{
	if(typeof d_kd != "object") d_kd = this.children[d_kd];
	var d_oc = this.children, d_nc = new Array();
	for(var d_i = 0; d_i < d_oc.length; d_i++)
		if(d_oc[d_i] != d_kd) d_nc[d_nc.length] = d_oc[d_i];
	this.children = d_nc;
	d_kd.parent = null;
	if(!d_newp)
	{
		d_kd.detached = d_kd.defp = 0;
		if(d_kd.is_image) dd.getImg(d_kd, d_kd.oimg.name, 1);
	}
};
DDObj.prototype.attachChild = function(d_kd)
{
	(d_kd = (typeof d_kd != "object")? this.children[d_kd]: d_kd).detached = 0;
	d_kd.setZ(d_kd.defz + this.z-this.defz, 1);
};
DDObj.prototype.detachChild = function(d_kd)
{
	(d_kd = (typeof d_kd != "object")? this.children[d_kd]: d_kd).detached = 1;
};
DDObj.prototype.setZ = function(d_x, d_kds, d_o)
{
	if(d_kds)
	{
		var d_dz = d_x-this.z,
		d_i = this.children.length; while(d_i--)
			if(!(d_o = this.children[d_i]).detached) d_o.setZ(d_o.z+d_dz, 1);
	}
	dd.z = Math.max(dd.z, this.z = this.div? ((this.css || this.div).zIndex = d_x) : 0);
};
DDObj.prototype.maximizeZ = function()
{
	this.setZ(dd.z+1, 1);
};
DDObj.prototype._resetZ = function(d_o)
{
	if(this.re_z || dd.re_z)
	{
		this.setZ(this.defz);
		var d_i = this.children.length; while(d_i--)
			if(!(d_o = this.children[d_i]).detached) d_o.setZ(d_o.defz);
	}
};
DDObj.prototype.setOpacity = function(d_x)
{
	this.opacity = d_x;
	this._setOpaRel(1.0, 1);
};
DDObj.prototype._setOpaRel = function(d_x, d_kd, d_y, d_o)
{
	if(this.css && (this.diaphan || d_kd))
	{
		d_y = this.opacity*d_x;
		if(typeof this.css.MozOpacity != dd_u) this.css.MozOpacity = d_y;
		else if(typeof this.css.filter != dd_u)
			this.css.filter = "Alpha(opacity="+parseInt(100*d_y)+")";
		else this.css.opacity = d_y;
		var d_i = this.children.length; while(d_i--)
			if(!(d_o = this.children[d_i]).detached) d_o._setOpaRel(d_x, 1);
	}
};
DDObj.prototype.setCursor = function(d_x)
{
	this._setCrs(this.cursor = (d_x.indexOf('c:')+1)? d_x.substring(2) : d_x);
};
DDObj.prototype._setCrs = function(d_x)
{
	if(this.css) this.css.cursor = ((!dd.ie || dd.iemac) && d_x == 'hand')? 'pointer' : d_x;
};
DDObj.prototype.setDraggable = function(d_x)
{
	this.nodrag = !d_x*1;
	this._setCrs(d_x? this.cursor : 'auto');
};
DDObj.prototype.setResizable = function(d_x)
{
	this.resizable = d_x*1;
	if(d_x) this.scalable = 0;
};
DDObj.prototype.setScalable = function(d_x)
{
	this.scalable = d_x*1;
	if(d_x) this.resizable = 0;
};
DDObj.prototype.getEltBelow = function(d_ret, d_x, d_y)
{
	var d_o, d_cmp = -1, d_i = dd.elements.length; while(d_i--)
	{
		d_o = dd.elements[d_i];
		d_x = d_o.x-this.w/2;
		d_y = d_o.y-this.h/2;
		if(d_o.visible && d_o.z < this.z && this.x >= d_x && this.x <= d_x+d_o.w && this.y >= d_y && this.y <= d_y+d_o.h)
		{
			if(d_o.z > d_cmp)
			{
				d_cmp = d_o.z;
				d_ret = d_o;
			}
		}
	}
	return d_ret;
};
DDObj.prototype.del = function(d_os, d_o)
{
	var d_i;
	if(this.parent && this.parent._removeChild) this.parent._removeChild(this);
	if(this.original)
	{
		this.hide();
		if(this.original.copies)
		{
			d_os = new Array();
			for(d_i = 0; d_i < this.original.copies.length; d_i++)
				if((d_o = this.original.copies[d_i]) != this) d_os[d_o.name] = d_os[d_os.length] = d_o;
			this.original.copies = d_os;
		}
	}
	else if(this.is_image)
	{
		this.hide();
		if(this.oimg)
		{
		  if(dd.n4) this.oimg.src = this.defsrc;
		  else this.oimg.style.visibility = 'visible';
		}
	}
	else if(this.moveTo)
	{
		if(this.css) this.css.cursor = 'default';
		this.moveTo(this.defx, this.defy);
		this.resizeTo(this.defw, this.defh);
	}
	d_os = new Array();
	for(d_i = 0; d_i < dd.elements.length; d_i++)
	{
		if((d_o = dd.elements[d_i]) != this) d_os[d_o.name] = d_os[d_o.index = d_os.length] = d_o;
		else d_o._free();
	}
	dd.elements = d_os;
	if(!dd.n4) dd.recalc();
};
DDObj.prototype._free = function()
{
	for(var d_i in this)
		this[d_i] = null;
	dd.elements[this.name] = null;
};
dd.n4RectVis = function(vis)
{
	for(var d_i = 4; d_i--;)
	{
		dd.rectI[d_i].visibility = dd.rectA[d_i].visibility = vis? 'show' : 'hide';
		if(vis) dd.rectI[d_i].zIndex = dd.rectA[d_i].zIndex = dd.z+2;
	}
};
dd.n4RectPos = function(d_o, d_x, d_y, d_w, d_h)
{
	d_o.x = d_x;
	d_o.y = d_y;
	d_o.clip.width = d_w;
	d_o.clip.height = d_h;
};
// NN4: Draw img sizing rect
dd.n4Rect = function(d_w, d_h)
{
	var d_i;
	if(!dd.rectI)
	{
		dd.rectI = new Array();
		dd.rectA = new Array();
	}
	if(!dd.rectI[0])
	{
		for(d_i = 4; d_i--;)
		{
			(dd.rectI[d_i] = new Layer(1)).bgColor = '#000000';
			(dd.rectA[d_i] = new Layer(1)).bgColor = '#ffffff';
		}
	}
	if(!dd.rectI[0].visibility || dd.rectI[0].visibility == 'hide') dd.n4RectVis(1);
	dd.obj.w = d_w;
	dd.obj.h = d_h;
	for(d_i = 4; d_i--;)
	{
		dd.n4RectPos(dd.rectI[d_i], dd.obj.x + (!(d_i-1)? (dd.obj.w-1) : 0), dd.obj.y + (!(d_i-2)? (dd.obj.h-1) : 0), d_i&1 || dd.obj.w, !(d_i&1) || dd.obj.h);
		dd.n4RectPos(dd.rectA[d_i], !(d_i-1)? dd.rectI[1].x+1 : (dd.obj.x-1), !(d_i-2)? dd.rectI[2].y+1 : (dd.obj.y-1), d_i&1 || dd.obj.w+2, !(d_i&1) || dd.obj.h+2);
	}
};
dd.reszTo = function(d_w, d_h)
{
	if(dd.n4 && dd.obj.is_image) dd.n4Rect(d_w, d_h);
	else dd.obj.resizeTo(d_w, d_h);
};
dd.embedVis = function(d_vis)
{
	var d_o = new Array('iframe', 'applet', 'embed', 'object');
	var d_i = d_o.length; while(d_i--)
	{
		var d_p = dd.ie? document.all.tags(d_o[d_i]) : document.getElementsByTagName? document.getElementsByTagName(d_o[d_i]) : null;
		if(d_p)
		{
			var d_j = d_p.length; while(d_j--)
			{
				var d_q = d_p[d_j];
				while(d_q.offsetParent || d_q.parentNode)
				{
					if((d_q = d_q.parentNode || d_q.offsetParent || null) == dd.obj.div)
					{
						d_p[d_j].style.visibility = d_vis;
						break;
					}
				}
			}
		}
	}
};

dd.maxOffX = function(d_x, d_y)
{
	return(
		(dd.obj.maxoffl+1 && (d_y = dd.obj.defx-dd.obj.maxoffl)-d_x > 0
		|| dd.obj.maxoffr+1 && (d_y = dd.obj.defx+dd.obj.maxoffr)-d_x < 0)? d_y
		: d_x
	);
};
dd.maxOffY = function(d_x, d_y)
{
	return(
		(dd.obj.maxofft+1 && (d_y = dd.obj.defy-dd.obj.maxofft)-d_x > 0
		|| dd.obj.maxoffb+1 && (d_y = dd.obj.defy+dd.obj.maxoffb)-d_x < 0)? d_y
		: d_x
	);
};
dd.inWndW = function(d_x, d_y)
{
	var d_wx = dd.getScrollX(),
	d_ww = dd.getWndW();
	return(
		((d_y = d_wx+2)-d_x > 0) || ((d_y = d_wx+d_ww+dd.obj.w-2)-d_x < 0)? d_y
		: d_x
	);
};
dd.inWndH = function(d_x, d_y)
{
	var d_wy = dd.getScrollY(),
	d_wh = dd.getWndH();
	return(
		((d_y = d_wy+2)-d_x > 0) || ((d_y = d_wy+d_wh+dd.obj.h-2)-d_x < 0)? d_y
		: d_x
	);
};
// These two funcs limit the size of element when mouseresized.
// Implemented 22.5.2003 by Gregor Ltolf, modified by Walter Zorn
dd.limW = function(d_w)
{
	return(
		(dd.obj.minw-d_w > 0)? dd.obj.minw
		: (dd.obj.maxw > 0 && dd.obj.maxw-d_w < 0)? dd.obj.maxw
		: d_w
	);
};
dd.limH = function(d_h)
{
	return(
		(dd.obj.minh-d_h > 0)? dd.obj.minh
		: (dd.obj.maxh > 0 && dd.obj.maxh-d_h < 0)? dd.obj.maxh
		: d_h
	);
};
// Optional autoscroll-page functionality. Courtesy Cedric Savarese.
// Modified by Walter Zorn.
function DDScroll()
{
	if(!dd.obj || !dd.obj.scroll && !dd.scroll || dd.ie4 || dd.whratio)
	{
		dd.scrx = dd.scry = 0;
		return;
	}
	var d_bnd = 0x1c,
	d_wx = dd.getScrollX(), d_wy = dd.getScrollY();
	if(dd.msmoved)
	{
		var d_ww = dd.getWndW(), d_wh = dd.getWndH(), d_y;
		dd.scrx = ((d_y = dd.e.x-d_ww-d_wx+d_bnd) > 0)? (d_y>>=2)*d_y
			: ((d_y = d_wx+d_bnd-dd.e.x) > 0)? -(d_y>>=2)*d_y
			: 0;
		dd.scry = ((d_y = dd.e.y-d_wh-d_wy+d_bnd) > 0)? (d_y>>=2)*d_y
			: ((d_y = d_wy+d_bnd-dd.e.y) > 0)? -(d_y>>=2)*d_y
			: 0;
	}
	if(dd.scrx || dd.scry)
	{
		window.scrollTo(
			d_wx + (dd.scrx = dd.obj.is_resized? dd.limW(dd.obj.w+dd.scrx)-dd.obj.w : dd.obj.vertical? 0 : (dd.maxOffX(dd.obj.x+dd.scrx)-dd.obj.x)),
			d_wy + (dd.scry = dd.obj.is_resized? dd.limH(dd.obj.h+dd.scry)-dd.obj.h : dd.obj.horizontal? 0 : (dd.maxOffY(dd.obj.y+dd.scry)-dd.obj.y))
		);
		dd.obj.is_dragged? dd.obj.moveTo(dd.obj.x+dd.getScrollX()-d_wx, dd.obj.y+dd.getScrollY()-d_wy)
			: dd.reszTo(dd.obj.w+dd.getScrollX()-d_wx, dd.obj.h+dd.getScrollY()-d_wy);
	}
	dd.msmoved = 0;
	window.setTimeout('DDScroll()', 0x33);
}
function PICK(d_ev)
{
	dd.e = new dd.evt(d_ev);
	if(dd.e.x >= dd.getWndW()+dd.getScrollX() || dd.e.y >= dd.getWndH()+dd.getScrollY()) return true; // on scrollbar
	var d_o, d_t, d_cmp = -1, d_i = dd.elements.length; while(d_i--)
	{
		d_o = dd.elements[d_i];
		if(dd.n4 && dd.e.but > 1 && dd.e.src == d_o.oimg && !d_o.clone) return false;
		if(d_o.visible && dd.e.but <= 1 && dd.e.x >= d_o.x && dd.e.x <= d_o.x+d_o.w && dd.e.y >= d_o.y && dd.e.y <= d_o.y+d_o.h)
		{
			if(d_o.z > d_cmp && (d_t = dd.e.src.tag).indexOf('inpu') < 0 && d_t.indexOf('texta') < 0 && d_t.indexOf('sele') < 0 && d_t.indexOf('opti') < 0 && d_t.indexOf('scrol') < 0)
			{
				d_cmp = d_o.z;
				dd.obj = d_o;
			}
		}
	}
	if(dd.obj)
	{
		if(dd.obj.nodrag) dd.obj = null;
		else
		{
			dd.e.e.cancelBubble = true;
			var d_rsz = dd.e.modifKey && (dd.obj.resizable || dd.obj.scalable);
			if(dd.op)
			{
				(d_o = document.getElementById('OpBlUr')).style.pixelLeft = dd.e.x;
				d_o.style.pixelTop = dd.e.y;
				(d_o = d_o.children[0].children[0]).focus();
				d_o.blur();
			}
			else if(dd.ie && !dd.ie4)
			{
				if(document.selection && document.selection.empty) document.selection.empty();
				dd.db.onselectstart = function()
				{
					event.returnValue = false;
				};
			}
			if(d_rsz)
			{
				dd.obj._setCrs('se-resize');
				dd.obj.is_resized = 1;
				dd.whratio = dd.obj.scalable? dd.obj.defw/dd.obj.defh : 0;
				if(dd.ie)
				{
					if(dd.ie4)
					{
						window.dd_x = dd.getScrollX();
						window.dd_y = dd.getScrollY();
					}
					setTimeout(
						'if(dd.obj && document.selection && document.selection.empty)'+
						'{'+
							'document.selection.empty();'+
							'if(dd.ie4) window.scrollTo(window.dd_x, window.dd_y);'+
						'}'
					,0);
				}
				dd.setMovHdl(RESIZE);
				dd.reszTo(dd.obj.w, dd.obj.h);
			}
			else
			{
				dd.obj.is_dragged = 1;
				dd.setMovHdl(DRAG);
			}
			dd.setUpHdl(DROP);
			dd.embedVis('hidden');
			dd.obj._setOpaRel(0.7);
			dd.obj.maximizeZ();
			dd.ofx = dd.obj.x+dd.obj.w-dd.e.x;
			dd.ofy = dd.obj.y+dd.obj.h-dd.e.y;
			if(window.my_PickFunc) my_PickFunc();
			if(dd.obj.pickFunc) dd.obj.pickFunc();
			DDScroll();
			return !(
				dd.obj.is_resized
				|| dd.n4 && dd.obj.is_image
				|| dd.n6 || dd.w3c
			);
		}
	}
	if(dd.downFunc) return dd.downFunc(d_ev);
	return true;
}
function DRAG(d_ev)
{
	if(!dd.obj || !dd.obj.visible) return true;
	if(dd.ie4 || dd.w3c || dd.n6 || dd.obj.children.length > 0xf)
	{
		if(dd.wait) return false;
		dd.wait = 1;
		setTimeout('dd.wait = 0;', dd.tiv);
	}
	dd.e = new dd.evt(d_ev);
	if(dd.ie && !dd.e.but)
	{
		DROP(d_ev);
		return true;
	}
	dd.msmoved = 1;
	dd.obj.moveTo(
		dd.obj.vertical? dd.obj.x : dd.maxOffX(dd.inWndW(dd.ofx+dd.e.x)-dd.obj.w),
		dd.obj.horizontal? dd.obj.y : dd.maxOffY(dd.inWndH(dd.ofy+dd.e.y)-dd.obj.h)
	);

	if(window.my_DragFunc) my_DragFunc();
	if(dd.obj.dragFunc) dd.obj.dragFunc();
	if(dd.moveFunc) return dd.moveFunc(d_ev);
	return false;
}
function RESIZE(d_ev)
{
	if(!dd.obj || !dd.obj.visible) return true;
	if(dd.wait) return false;
	dd.wait = 1;
	setTimeout('dd.wait = 0;', dd.tiv);
	dd.e = new dd.evt(d_ev);
	if(dd.ie && !dd.e.but)
	{
		DROP(d_ev);
		return true;
	}
	dd.msmoved = 1;
	var d_w = dd.limW(dd.inWndW(dd.ofx+dd.e.x)-dd.obj.x), d_h;
	if(!dd.whratio) d_h = dd.limH(dd.inWndH(dd.ofy+dd.e.y)-dd.obj.y);
	else
	{
		d_h = dd.limH(dd.inWndH(Math.round(d_w/dd.whratio)+dd.obj.y)-dd.obj.y);
		d_w = Math.round(d_h*dd.whratio);
	}
	dd.reszTo(d_w, d_h);
	if(window.my_ResizeFunc) my_ResizeFunc();
	if(dd.obj.resizeFunc) dd.obj.resizeFunc();
	if(dd.moveFunc) return dd.moveFunc(d_ev);
	return false;
}
function DROP(d_ev)
{
	if(dd.obj)
	{
		if(dd.obj.is_dragged)
		{
			if(!dd.obj.is_image) dd.getWH(dd.obj);
		}
		else if(dd.n4)
		{
			if(dd.obj.is_image)
			{
				dd.n4RectVis(0);
				dd.obj.resizeTo(dd.obj.w, dd.obj.h);
			}
		}
		if(!dd.n4 || !dd.obj.is_image) dd.recalc();
		dd.setMovHdl(dd.moveFunc);
		dd.setUpHdl(dd.upFunc);
		if(dd.db) dd.db.onselectstart = null;
		dd.obj._setOpaRel(1.0);
		dd.obj._setCrs(dd.obj.cursor);
		dd.embedVis('visible');
		dd.obj._resetZ();
		dd.e = new dd.evt(d_ev);
		if(window.my_DropFunc) my_DropFunc();
		if(dd.obj.dropFunc) dd.obj.dropFunc();
		dd.msmoved = dd.obj.is_dragged = dd.obj.is_resized = dd.whratio = 0;
		dd.obj = null;
	}
	dd.setDwnHdl(PICK);
}
function SET_DHTML()
{
	var d_a = arguments, d_ai, d_htm = '', d_o, d_i = d_a.length; while(d_i--)
	{
		if(!(d_ai = d_a[d_i]).indexOf('c:')) dd.cursor = d_ai.substring(2);
		else if(d_ai == NO_ALT) dd.noalt = 1;
		else if(d_ai == SCROLL) dd.scroll = 1;
		else if(d_ai == RESET_Z) dd.re_z = 1;
		else if(d_ai == RESIZABLE) dd.resizable = 1;
		else if(d_ai == SCALABLE) dd.scalable = 1;
		else if(d_ai == TRANSPARENT) dd.diaphan = 1;
		else
		{
			d_o = new DDObj(d_ai);
			dd.addElt(d_o);
			d_htm += d_o.t_htm || '';
			if(d_o.oimg && d_o.cpy_n)
			{
				var d_j = 0; while(d_j < d_o.cpy_n)
				{
					var d_p = new DDObj(d_o.name+d_o.cmd, ++d_j);
					dd.addElt(d_p, d_o);
					d_p.defz = d_o.defz+d_j;
					d_p.original = d_o;
					d_htm += d_p.t_htm;
				}
			}
		}
	}
	if (dd.n4 || dd.n6 || dd.ie || dd.op || dd.w3c) document.write(
		(dd.n4? '<div style="position:absolute;"><\/div>\n'
		: (dd.op && !dd.op6)? '<div id="OpBlUr" style="position:absolute;visibility:hidden;width:0px;height:0px;"><form><input type="text" style="width:0px;height:0px;"><\/form><\/div>'
		: '') + d_htm
	);
	dd.z = 0x33;
	d_i = dd.elements.length; while(d_i--)
	{
		dd.addProps(d_o = dd.elements[d_i]);
		if(d_o.is_image && !d_o.original && !d_o.clone)
			dd.n4? d_o.oimg.src = spacer : d_o.oimg.style.visibility = 'hidden';
	}
	dd.mkWzDom();
	if(window.onload) dd.loadFunc = window.onload;
	if(window.onunload) dd.uloadFunc = window.onunload;
	window.onload = dd.initz;
	window.onunload = dd.finlz;
	dd.setDwnHdl(PICK);
}
function ADD_DHTML(d_o) // layers only!
{
	d_o = new DDObj(d_o);
	dd.addElt(d_o);
	dd.addProps(d_o);
	dd.mkWzDom();
}




////////////////////////////////////////////////////////////
// If not needed, all code below this line may be removed
//volatile section  BELOW ARE FUNCTIONS WHICH HAVE BEEN FILLED UP WITH WNM CODE:

// For backward compatibility
dd.d = document;			// < v. 2.72
var RESET_ZINDEX = RESET_Z; // < 3.44
var KEYDOWN_RESIZE = RESIZABLE; // < 4.43
var CURSOR_POINTER = CURSOR_HAND; // < 4.44
var NO_SCROLL = '';		 // < v. 4.49




////////////////////////////////////////////////////////////
// FUNCTIONS FOR EXTENDED SCRIPTING
// Use these for your own extensions,
// or to call functions defined elsewhere



/* my_PickFunc IS AUTOMATICALLY CALLED WHEN AN ITEM STARTS TO BE DRAGGED.
The following objects/properties are accessible from here:

- dd.e: current mouse event
- dd.e.property: access to a property of the current mouse event.
  Mostly requested properties:
  - dd.e.x: document-related x co-ordinate
  - dd.e.y: document-related y co-ord
  - dd.e.src: target of mouse event (not identical with the drag drop object itself).
  - dd.e.button: currently pressed mouse button. Left button: dd.e.button <= 1

- dd.obj: reference to currently dragged item.
- dd.obj.property: access to any property of that item.
- dd.obj.method(): for example dd.obj.resizeTo() or dd.obj.swapImage() .
  Mostly requested properties:
	- dd.obj.name: image name or layer ID passed to SET_DHTML();
	- dd.obj.x and dd.obj.y: co-ordinates;
	- dd.obj.w and dd.obj.h: size;
	- dd.obj.is_dragged: 1 while item is dragged, else 0;
	- dd.obj.is_resized: 1 while item is resized, i.e. if <ctrl> or <shift> is pressed, else 0

For more properties and details, visit the API documentation
at http://www.walterzorn.com/dragdrop/api_e.htm (english) or
http://www.walterzorn.de/dragdrop/api.htm (german)	*/




function my_PickFunc()
{

// locate position of piece, displace by 16 to get from image topleft to center
   
   ox = dd.e.x-16;
   oy = dd.e.y-16;

   on = Math.round((ox-xpeggg)/32.);
   om = Math.round((oy-ypeggg)/32.);

  
   permit = 0;

   otruex = xpeggg + on*32;
   otruey = ypeggg + om*32;
tyype=document.promoteselectionform.promoteto.options[document.promoteselectionform.promoteto.options.selectedIndex].value;
//tyype=document.promoteselectionform.promoteto.options[document.promoteselectionform.promoteto.options.selectedIndex].value;
        var aatagget = document.getElementById(convertnmejo(on,om));
        holding = aatagget.src;
}




/* my_DragFunc IS CALLED WHILE AN ITEM IS DRAGGED   here we turn the on square gray (and thus blank
See the description of my_PickFunc above for what's accessible from here. */
function my_DragFunc()
{
	//window.status = 'dd.elements.' + dd.obj.name + '.x  = ' + dd.obj.x + '	 dd.elements.' + dd.obj.name + '.y = ' + dd.obj.y;


        var aatagget = document.getElementById(convertnmejo(on,om));
        aatagget.src = aatagget.src.replace(/(.+)/,'inprog.gif');


}




/* my_ResizeFunc IS CALLED WHILE AN ITEM IS RESIZED
See the description of my_PickFunc above for what's accessible from here. */
function my_ResizeFunc()
{
	//window.status = 'dd.elements.' + dd.obj.name + '.w  = ' + dd.obj.w + '	 dd.elements.' + dd.obj.name + '.h = ' + dd.obj.h;
}


/* THIS ONE IS CALLED ONCE AN ITEM IS DROPPED
See the description of my_PickFunc for what's accessible from here.
Here may be investigated, for example, what's the name (dd.obj.name)
of the dropped item, and where (dd.obj.x, dd.obj.y) it has been dropped... */

function my_DropFunc()
{

        var aatagget = document.getElementById(convertnmejo(on,om));
        aatagget.src = aatagget.src.replace(/(.+)/,holding);
//phase zero

//locate nearest n and m solution
   n = Math.round((dd.obj.x-xpeggg)/32.);
   m = Math.round((dd.obj.y-ypeggg)/32.);

        if (!((n<9)&&(m<9)&&(n>0)&&(m>0))){problem = 1; }
if(problem!=1)
        {  
        batagget = document.getElementById(convertnmejo(n,m));
        auld = batagget.alt;
        }


//convert n and m to a center of a square:
truex = xpeggg + n*32;
truey = ypeggg + m*32;
// rezeros
thcapture = 0;
plive=1;
refuse = 0;
falsec = 0;
stuffage = 0;
permit = 1;
promote = 0;
rpawn = 0;
promotrack = 0;
provisiw1=0;
provisib1=0;
provisiw8=0;
provisib8=0;
capture = 0;
vcapture = 0;
testty = 0;
piece = "?";
colorr = "0";
whiich = "x";eprevert = "t";sourcen = -1;sourcem = -1;


// identify the piece in question (by the content of its former square (cxiam defined)) this finds the PIECE has no connection to the image
// each image requires a unique name (whiich) this has a one to one correspondence with the piece (whiich) (but not the source)
  
   tagget = document.getElementById(convertnmejo(on,om));
   ore = tagget.alt;

//endit phase zero


/////////////////////////////////////////////////

//phase one       determine which piece has been selected

// bishop
if (ore == "cb3") 
{
whiich = ore;
piece = "b";
colorr = "b"
}
if (ore == "fb3") 
{
whiich = ore;
piece = "b";
colorr = "b"
}
//
if (ore == "fw3") 
{
whiich = ore;
piece = "b";
colorr = "w"
}
if (ore == "cw3") 
{
whiich = ore;
piece = "b";
colorr = "w"
}
  // endit bishop^

//
//knight
if  (ore == "bb2") 
{
whiich = ore;
piece = "n";
colorr="b"
}
if  (ore == "gb2") 
{
whiich = ore;
piece = "n";
colorr="b"
}
if  (ore == "bw2")
{
whiich = ore;
piece = "n";
colorr="w"
} 
if  (ore == "gw2")
{
whiich = ore;
piece = "n";
colorr="w"
}  
//endit knight

//rook
if  (ore == "ab4") 
{
whiich = ore;
piece = "r";
colorr="b"
}
if  (ore == "hb4") 
{
whiich = ore;
piece = "r";
colorr="b"
}
if  (ore == "aw4") 
{
whiich = ore;
piece = "r";
colorr="w"
} 
if  (ore == "hw4") 
{
whiich = ore;
piece = "r";
colorr="w"
}  
//endit rook

//queen
if  (ore == "db5")  
{
whiich = ore;
piece = "q";
colorr="b"
}
if  (ore == "dw5")
{
whiich = ore;
piece = "q";
colorr="w"
}
//endit queen

//king
if  (ore == "eb6") 
{
whiich = ore;
piece = "k";
colorr="b"
}
if  (ore == "ew6")
{
whiich = ore;
piece = "k";
colorr="w"
} //endit king


////////
//identify all the pawns (ugh)
if  (ore == "ab1")
{
whiich = ore;
if(ab1p==0){piece = "p"}else if(ab1p==2){piece="n"}else if(ab1p==3){piece="b"}else if(ab1p==4){piece="r"}else if(ab1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="b"
}
if  (ore == "bb1")
{
whiich = ore;
if(bb1p==0){piece = "p"}else if(bb1p==2){piece="n"}else if(bb1p==3){piece="b"}else if(bb1p==4){piece="r"}else if(bb1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="b"
}
if  (ore == "cb1")
{
whiich = ore;
if(cb1p==0){piece = "p"}else if(cb1p==2){piece="n"}else if(cb1p==3){piece="b"}else if(cb1p==4){piece="r"}else if(cb1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="b"
}
if  (ore == "db1")
{
whiich = ore;
if(db1p==0){piece = "p"}else if(db1p==2){piece="n"}else if(db1p==3){piece="b"}else if(db1p==4){piece="r"}else if(db1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="b"
}
if  (ore == "eb1")
{
whiich = ore;
if(eb1p==0){piece = "p"}else if(eb1p==2){piece="n"}else if(eb1p==3){piece="b"}else if(eb1p==4){piece="r"}else if(eb1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="b"
}
if  (ore == "fb1")
{
whiich = ore;
if(fb1p==0){piece = "p"}else if(fb1p==2){piece="n"}else if(fb1p==3){piece="b"}else if(fb1p==4){piece="r"}else if(fb1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="b"
}
if  (ore == "gb1")
{
whiich = ore;
if(gb1p==0){piece = "p"}else if(gb1p==2){piece="n"}else if(gb1p==3){piece="b"}else if(gb1p==4){piece="r"}else if(gb1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="b"
}
if  (ore == "hb1")
{
whiich = ore;
if(hb1p==0){piece = "p"}else if(hb1p==2){piece="n"}else if(hb1p==3){piece="b"}else if(hb1p==4){piece="r"}else if(hb1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="b"
}

//identify all the pawns (ugh)
if  (ore == "aw1") 
{
whiich = ore;
if(aw1p==0){piece = "p"}else if(aw1p==2){piece="n"}else if(aw1p==3){piece="b"}else if(aw1p==4){piece="r"}else if(aw1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="w"
}
if  (ore == "bw1")  
{
whiich = ore;
if(bw1p==0){piece = "p"}else if(bw1p==2){piece="n"}else if(bw1p==3){piece="b"}else if(bw1p==4){piece="r"}else if(bw1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="w"
}
if  (ore == "cw1")  
{
whiich = ore;
if(cw1p==0){piece = "p"}else if(cw1p==2){piece="n"}else if(cw1p==3){piece="b"}else if(cw1p==4){piece="r"}else if(cw1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="w"
}
if  (ore == "dw1") 
{
whiich = ore;
if(dw1p==0){piece = "p"}else if(dw1p==2){piece="n"}else if(dw1p==3){piece="b"}else if(dw1p==4){piece="r"}else if(dw1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="w"
}
if  (ore == "ew1")
{
whiich = ore;
if(ew1p==0){piece = "p"}else if(ew1p==2){piece="n"}else if(ew1p==3){piece="b"}else if(ew1p==4){piece="r"}else if(ew1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="w"
}
if  (ore == "fw1")
{

whiich = ore;
if(fw1p==0){piece = "p"}else if(fw1p==2){piece="n"}else if(fw1p==3){piece="b"}else if(fw1p==4){piece="r"}else if(fw1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="w"
}
if  (ore == "gw1")
{
whiich = ore;
if(gw1p==0){piece = "p"}else if(gw1p==2){piece="n"}else if(gw1p==3){piece="b"}else if(gw1p==4){piece="r"}else if(gw1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="w"
}
if  (ore == "hw1")
{

whiich = ore;
if(hw1p==0){piece = "p"}else if(hw1p==2){piece="n"}else if(hw1p==3){piece="b"}else if(hw1p==4){piece="r"}else if(hw1p==5){piece="q"}else{alert("impossible pawn value")}
colorr="w"
}




if ((colorr=="w") && (pturn != 1) ) {refuse = 1; permit = 0;}
if ((colorr=="b") && (pturn != -1)) {refuse = 1; permit = 0;}


// endit piece identified^^^^
if (expiredet ==1) {document.getElementById("alert").innerHTML = 'loss on time ';duckki = undoer(whiich);return}

if(refuse == 1)
{
//alert(stalematet);
if (stalematet ==1) {document.getElementById("alert").innerHTML = 'stalemate ';duckki = undoer(whiich);return}

if (checkmatet ==1) {document.getElementById("alert").innerHTML = 'checkmate ';duckki = undoer(whiich);return}
document.getElementById("alert").innerHTML = 'Alert: other side moves ';


duckki = undoer(whiich);
return;
}

if(problem == 1)
{
duckki = undoer(whiich);
return;
}



//endit phase one



//phase two    determine if the move is PERMITTED (it might or not be legal)


// determine the TYPE of move for the given piece;; po piece- this returns 1 or zero (as permit) for the move input
if (piece == "b")
{

permit = bishoplegal(n,m,on,om,colorr,500);      //default bishop upper limit to a move of 500 squares

}

// soldatoj
if ((piece == "p") && (colorr == "b") )
{
permit = bpawnlegal(n,m,on,om,colorr,3);      //default limit 2

}

if ((piece == "p") && (colorr == "w") )
{
permit = wpawnlegal(n,m,on,om,colorr,3);      //default limit 2 (translates to 3 here)

}
// endit soldatoj^^^ 


if (piece == "n")
{
permit = knightlegal(n,m,on,om,colorr);
}


if (piece == "r")
{
permit = rooklegal(n,m,on,om,colorr,500);  //default upper limit to a move of 500 squares
// disallow castling after an initial rook move
	if (permit == 1)
	{ 
	if  ((on == 1) && (om == 8)) {wcastok1 = 0;provisiw1=1}  //disallow castling per rook after it moves (but if move is not leg .reinstate later per {provisi} 
	if  ((on == 1) && (om == 1)) {bcastok1 = 0;provisib1=1} 
	if  ((on == 8) && (om == 1)) {bcastok8 = 0;provisib8=1} 
	if  ((on == 8) && (om == 8)) {wcastok8 = 0;provisiw8=1} 
	}
}

if (piece == "q")
{
permit = rooklegal(n,m,on,om,colorr,500);  //default upper limit to a move of 500 squares
 if(permit != 1)
 {
 permit = bishoplegal(n,m,on,om,colorr,500);    //default upper limit to a move of 500 squares
 }
}

if (piece == "k") // gonna get messy
{

permit = 1; /// by default allow move

//first deal with castling ..... 4 possible ways to castle
///////// way one black queenside

if(m == 1)
{

	if( (on==5) && (n==3) && (bcastok1 == 1) && (colorr == "b") )
	{

	//perform the special move of black castling queenside (check 3 special squares for check) 
              if(checkcheck(3,1,"b") == 1){permit = 0}
              if(checkcheck(4,1,"b") == 1){permit = 0}
              if(checkcheck(5,1,"b") == 1){permit = 0} 
//verifies as a legal move, now perform the interchange (if and only if intermediate squares are blank and permit <-->1)
              if ( permit == 1 )
              {
//check to see if squares are empty (3 squares queenside)
              permit = emppty(2,1) * emppty(3,1) * emppty(4,1);
//(if empty)  permit <==> emptyness <==> unity (1eco)
                if (permit == 1)
                {
                //perform interchange
        var ktagget = document.getElementById(convertnmejo(5,1));
        ktagget.alt = ktagget.alt.replace(/(.+)/,'0');
        nktagget = document.getElementById(convertnmejo(3,1));
        nktagget.alt = nktagget.alt.replace(/(.+)/,'eb6');
        rtagget = document.getElementById(convertnmejo(1,1));
        rtagget.alt = rtagget.alt.replace(/(.+)/,'0');
        nrtagget = document.getElementById(convertnmejo(4,1));
        nrtagget.alt = nrtagget.alt.replace(/(.+)/,'ab4');

	var ebk = dd.elements.ebk;
	ebk.moveTo(xpeggg+96,ypeggg+32);
	var abr = dd.elements.abr;
	abr.moveTo(xpeggg+128,ypeggg+32);
var ttx1xtt = document.createTextNode('o-o-o ');
document.getElementById("moves").appendChild(ttx1xtt);
document.getElementById("alert").innerHTML = ' ';

              bcastok1 = 0; bcastok8 = 0;bpalacen = n; bpalacem = m;dummy=whstart(); doggy=blstop();pturn = pturn * (-1); return  //disallow b castling after the b king castles and return (since the drop is complete)
                }
              }
              //endit black king qcastle^^
        }
}

///////// way two white queenside
if(m == 8)
{
	if( (on==5) && (n==3) && (wcastok1 == 1) && (colorr == "w")  )
	{
	//perform the special move of white castling queenside (check 3 special squares for check) 
              if(checkcheck(3,8,"w") == 1){ permit = 0}
              if(checkcheck(4,8,"w") == 1){ permit = 0}
              if(checkcheck(5,8,"w") == 1){ permit = 0}
//verifies as a legal move, now perform the interchange (if and only if intermediate squares are blank and permit <-->1)
              if ( permit == 1 )
              {
//check to see if squares are empty (3 squares queenside)
              permit = emppty(2,8) * emppty(3,8) * emppty(4,8);
//(if empty)  permit <==> emptyness
                if (permit == 1)
                {
                //perform interchange
        var ktagget = document.getElementById(convertnmejo(5,8));
        ktagget.alt = ktagget.alt.replace(/(.+)/,'0');
        nktagget = document.getElementById(convertnmejo(3,8));
        nktagget.alt = nktagget.alt.replace(/(.+)/,'ew6');
        rtagget = document.getElementById(convertnmejo(1,8));
        rtagget.alt = rtagget.alt.replace(/(.+)/,'0');
        nrtagget = document.getElementById(convertnmejo(4,8));
        nrtagget.alt = nrtagget.alt.replace(/(.+)/,'aw4');

	var ewk = dd.elements.ewk;
	ewk.moveTo(xpeggg+96,ypeggg+256);
	var awr = dd.elements.awr;
	awr.moveTo(xpeggg+128,ypeggg+256);
var ttx1xtt = document.createTextNode('o-o-o ');
document.getElementById("moves").appendChild(ttx1xtt);
document.getElementById("alert").innerHTML = ' ';

                wcastok1 = 0; wcastok8 = 0; wpalacen = n; wpalacem = m;dummy=blstart(); doggy=whstop();pturn = pturn * (-1); return  //disallow w castling after the w king castles and return (since the drop is complete)
                }
              }
              //endit white king qcastle^^
	}
}
///////// way three black kingside
if(m == 1)
{
	if( (on==5) && (n==7) && (bcastok8 == 1) && (colorr == "b") )
	{
	//perform the special move of black castling kingside (check 3 special squares for check)
              if(checkcheck(7,1,"b") == 1){ permit = 0}
              if(checkcheck(6,1,"b") == 1){ permit = 0}
              if(checkcheck(5,1,"b") == 1){ permit = 0}
//verifies as a legal move, now perform the interchange (if and only if intermediate squares are blank and permit <-->1)
              if ( permit == 1 )
              {
//check to see if squares are empty (2 squares kingside)
              permit = emppty(6,1) * emppty(7,1);
//(if empty)  permit <==> emptyness
                if (permit == 1)
                {
                //perform interchange
        var ktagget = document.getElementById(convertnmejo(5,1));
        ktagget.alt = ktagget.alt.replace(/(.+)/,'0');
        nktagget = document.getElementById(convertnmejo(7,1));
        nktagget.alt = nktagget.alt.replace(/(.+)/,'eb6');
        rtagget = document.getElementById(convertnmejo(8,1));
        rtagget.alt = rtagget.alt.replace(/(.+)/,'0');
        nrtagget = document.getElementById(convertnmejo(6,1));
        nrtagget.alt = nrtagget.alt.replace(/(.+)/,'hb4');


	var ebk = dd.elements.ebk;
	ebk.moveTo(xpeggg+224,ypeggg+32);
	var hbr = dd.elements.hbr;
	hbr.moveTo(xpeggg+192,ypeggg+32);
var ttx1xtt = document.createTextNode('o-o ');
document.getElementById("moves").appendChild(ttx1xtt);
document.getElementById("alert").innerHTML = ' ';

                bcastok1 = 0; bcastok8 = 0; bpalacen = n; bpalacem = m;dummy=whstart(); doggy=blstop();pturn = pturn * (-1);return  //disallow b castling after the b king castles and return (since the drop is complete)
                }
              }
              //endit black king kcastle^^
        }
}
///////// way four white kingside
if(m == 8)
{
        if( (on==5) && (n==7) && (wcastok8 == 1) && (colorr == "w") )
	{
	//perform the special move of white castling kingside (check 3 special squares for check)
              if(checkcheck(7,8,"w") == 1){ permit = 0}
              if(checkcheck(6,8,"w") == 1){ permit = 0}
              if(checkcheck(5,8,"w") == 1){ permit = 0}
//verifies as a legal move, now perform the interchange (if and only if intermediate squares are blank and permit <-->1)
              if ( permit == 1 )
              {
//check to see if squares are empty (2 squares kingnside)
              permit = emppty(6,8) * emppty(7,8);
//(if empty)  permit <==> emptyness 
                if (permit == 1)
                {
                //perform interchange
        var ktagget = document.getElementById(convertnmejo(5,8));
        ktagget.alt = ktagget.alt.replace(/(.+)/,'0');
        nktagget = document.getElementById(convertnmejo(7,8));
        nktagget.alt = nktagget.alt.replace(/(.+)/,'ew6');
        rtagget = document.getElementById(convertnmejo(8,8));
        rtagget.alt = rtagget.alt.replace(/(.+)/,'0');
        nrtagget = document.getElementById(convertnmejo(6,8));
        nrtagget.alt = nrtagget.alt.replace(/(.+)/,'hw4');

	var ewk = dd.elements.ewk;
	ewk.moveTo(xpeggg+224,ypeggg+256);
	var hwr = dd.elements.hwr;
	hwr.moveTo(xpeggg+192,ypeggg+256);
var ttx1xtt = document.createTextNode('o-o ');
document.getElementById("moves").appendChild(ttx1xtt);
document.getElementById("alert").innerHTML = ' ';

                wcastok1 = 0; wcastok8 = 0; wpalacen = n; wpalacem = m;dummy=blstart(); doggy=whstop();pturn = pturn * (-1); return  //disallow w castling after the w king castles and return (since the drop is complete)
                }
              }
              //endit white king kcastle^^
	}
}



// endit deal with castling^^^

//now ordinary king moves:


permit = rooklegal(n,m,on,om,colorr,1);  //limit king to a single square at a time
 if(permit != 1)
 {
 permit = bishoplegal(n,m,on,om,colorr,1);   //limit king to a single square at a time
 }




	if (permit == 1)
	{ // set permit <--> 0 if king can be captured in new place (check)

        	if (checkcheck(n,m,colorr) == 0)
		{
        	permit = 1;
		}
		else
		{undoer(whiich);permit = 0;}
        }


//record position of king for checkchecking
if(permit >0)
{
if(colorr == "w"){wpalacen = n; wpalacem = m}
if(colorr == "b"){bpalacen = n; bpalacem = m} 
}

// endit record position of king for checkcheck^^

if( (permit == 1) && (colorr == "b") && ( (bcastok1==1) || (bcastok8 == 1)) ) {bcastok1 = 0; bcastok8 = 0}  //disallow black castling after the black king moves
if( (permit == 1) && (colorr == "w") && ( (wcastok1==1) || (wcastok8 == 1)) ) {wcastok1 = 0; wcastok8 = 0}  //disallow white castling after the white king moves

}
//endit ordinary king moves^^^
// endit case king ^^


///////////////////////////////// TERMINUS EST                   TERMINUS EST                         TERMINUS EST
// terminus est                       now perform the result of the move.... this will generate a new board position
// WARNING EP PAWN captures AND promotion-captures are already EFFECTED in previous phase per xpawnlegal



//handle the result of a successful bishop move (permit = 1) /////////////////////////////////
// case cb3/cbb
if   ((permit == 1) && (whiich == "cb3")) 
{
// in the case that the move proposed is permissible
	var cbb = dd.elements.cbb;
	cbb.moveTo(truex,truey);                               //move piece icon
        tagget = document.getElementById(convertnmejo(n,m));     //find target square
        tagget.alt = tagget.alt.replace(/(.+)/,'cb3');            //input new descriptor
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');             //rezero old square descriptor
}

//handle the result of a nonsuccessful bishop move (permit =0)
if   ((permit == 0) && (whiich == "cb3"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var cbb = dd.elements.cbb;
	cbb.moveTo(otruex,otruey);
}
//

// case fbb
if   ((permit == 1) && (whiich == "fb3")) 
{
// in the case that the move proposed is permissible
	var fbb = dd.elements.fbb;
	fbb.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'fb3');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

//handle the result of a nonsuccessful bishop move (permit =0)
if   ((permit == 0) && (whiich == "fb3"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var fbb = dd.elements.fbb;
	fbb.moveTo(otruex,otruey);
}
//





// case cw3
if   ((permit == 1) && (whiich == "cw3")) 
{
// in the case that the move proposed is permissible
	var cwb = dd.elements.cwb;
	cwb.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'cw3');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

//handle the result of a nonsuccessful bishop move (permit =0)
if   ((permit == 0) && (whiich == "cw3"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var cwb = dd.elements.cwb;
	cwb.moveTo(otruex,otruey);
}
//

// case fw3
if   ((permit == 1) && (whiich == "fw3")) 
{
// in the case that the move proposed is permissible
	var fwb = dd.elements.fwb;
	fwb.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'fw3');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

//handle the result of a nonsuccessful bishop move (permit =0)
if   ((permit == 0) && (whiich == "fw3"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var fwb = dd.elements.fwb;
	fwb.moveTo(otruex,otruey);
}
//


///// case knight ////////////////////////////////////////////////////////////////////////////////////////

// case bb2 successful move
if   ((permit == 1) && (whiich == "bb2" )) 
{
// in the case that the move proposed is permissible
	var bbn = dd.elements.bbn;
	bbn.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'bb2');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful knight move
if   ((permit == 0) && (whiich == "bb2"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var bbn = dd.elements.bbn;
	bbn.moveTo(otruex,otruey);
}
//

// case gb2 successful move
if   ((permit == 1) && (whiich == "gb2" ) )
{
// in the case that the move proposed is permissible
	var gbn = dd.elements.gbn;
	gbn.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'gb2');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful knight move
if   ((permit == 0) && (whiich == "gb2"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var gbn = dd.elements.gbn;
	gbn.moveTo(otruex,otruey);
}
//



// case bw2 successful move
if   ((permit == 1) && (whiich == "bw2" )) 
{
// in the case that the move proposed is permissible
	var bwn = dd.elements.bwn;
	bwn.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'bw2');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful knight move
if   ((permit == 0) && (whiich == "bw2"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var bwn = dd.elements.bwn;
	bwn.moveTo(otruex,otruey);
}
//

// case gw2 successful move
if   ((permit == 1) && (whiich == "gw2" ) )
{
// in the case that the move proposed is permissible
	var gwn = dd.elements.gwn;
	gwn.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'gw2');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful knight move
if   ((permit == 0) && (whiich == "gw2"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var gwn = dd.elements.gwn;
	gwn.moveTo(otruex,otruey);
}
//


///////////////////////////////////////////////////////////////



// rook
if   ((permit == 1) && (whiich == "ab4") ) 
{
// in the case that the move proposed is permissible
	var abr = dd.elements.abr;
	abr.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'ab4');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful rook move
if      ((permit == 0) && (whiich == "ab4"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var abr = dd.elements.abr;
	abr.moveTo(otruex,otruey);
} // endit rook^^^^

if   ((permit == 1) && (whiich == "hb4") ) 
{
// in the case that the move proposed is permissible
	var hbr = dd.elements.hbr;
	hbr.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'hb4');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful rook move
if      ((permit == 0)  && (whiich == "hb4"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var hbr = dd.elements.hbr;
	hbr.moveTo(otruex,otruey);
} // endit rook^^^^





// rook
if   ((permit == 1) && (whiich == "aw4") ) 
{
// in the case that the move proposed is permissible
	var awr = dd.elements.awr;
	awr.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'aw4');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful rook move
if      ((permit == 0) && (whiich == "aw4"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var awr = dd.elements.awr;
	awr.moveTo(otruex,otruey);
} // endit rook^^^^

if   ((permit == 1)  && (whiich == "hw4") ) 
{
// in the case that the move proposed is permissible
	var hwr = dd.elements.hwr;
	hwr.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'hw4');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful rook move
if      ((permit == 0) && (whiich == "hw4"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var hwr = dd.elements.hwr;
	hwr.moveTo(otruex,otruey);
} // endit rook^^^^


//////////////////////////////////////////////////////////////////////


// queen

if   ((permit == 1) && (whiich == "db5") )
{

// in the case that the move proposed is permissible
	var dbq = dd.elements.dbq;
	dbq.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'db5');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful queen move
if      ((permit == 0)  && (whiich == "db5"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var dbq = dd.elements.dbq;
	dbq.moveTo(otruex,otruey);
} // endit queen^^^^





// queen

if   ((permit == 1) && (whiich == "dw5" ) )
{

// in the case that the move proposed is permissible
	var dwq = dd.elements.dwq;
	dwq.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'dw5');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful queen move
if      ((permit == 0) && (whiich == "dw5"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var dwq = dd.elements.dwq;
	dwq.moveTo(otruex,otruey);
}





 // endit queen^^^^


// pawns too damn many of 'em ......... need generalized info transfer method   global replace procedure 
//pawn ab1
if   ((permit > 0) && (whiich == "ab1")) 
{
// in the case that the move proposed is permissible
	var abp = dd.elements.abp;
	abp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'ab1');

// in passing
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
//in passing

        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "ab1") )   //square is occupied by friendly or forbidden intrinsically


{
// not a legal move, snap back to old position
	var abp = dd.elements.abp;
	abp.moveTo(otruex,otruey);
} // endit pawn abp^^^^




//pawn bb1
if   ((permit > 0) && (whiich == "bb1")) 
{
// in the case that the move proposed is permissible
	var bbp = dd.elements.bbp;
	bbp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'bb1');  // replace descriptor

          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');       
          }

        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) &&  (whiich == "bb1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var bbp = dd.elements.bbp;
	bbp.moveTo(otruex,otruey);
} // endit pawn bb1^^^^

//pawn cb1
if   ((permit > 0) && (whiich == "cb1")) 
{
// in the case that the move proposed is permissible
	var cbp = dd.elements.cbp;
	cbp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'cb1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "cb1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var cbp = dd.elements.cbp;
	cbp.moveTo(otruex,otruey);
} // endit pawn cb1^^^^

//pawn db1
if   ((permit > 0) && (whiich == "db1")) 
{
// in the case that the move proposed is permissible
	var dbp = dd.elements.dbp;
	dbp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'db1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "db1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var dbp = dd.elements.dbp;
	dbp.moveTo(otruex,otruey);
} // endit pawn db1^^^^

//pawn eb1
if   ((permit > 0) && (whiich == "eb1")) 
{
// in the case that the move proposed is permissible
	var ebp = dd.elements.ebp;
	ebp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'eb1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "eb1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var ebp = dd.elements.ebp;
	ebp.moveTo(otruex,otruey);
} // endit pawn eb1^^^^

//pawn fb1
if   ((permit > 0) && (whiich == "fb1")) 
{
// in the case that the move proposed is permissible
	var fbp = dd.elements.fbp;
	fbp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'fb1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "fb1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var fbp = dd.elements.fbp;
	fbp.moveTo(otruex,otruey);
} // endit pawn fb1^^^^

//pawn gb1
if   ((permit > 0) && (whiich == "gb1")) 
{
// in the case that the move proposed is permissible
	var gbp = dd.elements.gbp;
	gbp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'gb1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "gb1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var gbp = dd.elements.gbp;
	gbp.moveTo(otruex,otruey);
} // endit pawn gb1^^^^

//pawn hb1
if   ((permit > 0) && (whiich == "hb1")) 
{
// in the case that the move proposed is permissible
	var hbp = dd.elements.hbp;
	hbp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'hb1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "hb1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var hbp = dd.elements.hbp;
	hbp.moveTo(otruex,otruey);
} // endit pawn hb1^^^^
///////////////////////// endit all the damn black pawns^^^



//pawn aw1
if   ((permit > 0) && (whiich == "aw1")) 
{
// in the case that the move proposed is permissible
	var awp = dd.elements.awp;
	awp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'aw1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "aw1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var awp = dd.elements.awp;
	awp.moveTo(otruex,otruey);
} // endit pawn aw1^^^^

//pawn bw1
if   ((permit > 0) && (whiich == "bw1")) 
{
// in the case that the move proposed is permissible
	var bwp = dd.elements.bwp;
	bwp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'bw1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "bw1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var bwp = dd.elements.bwp;
	bwp.moveTo(otruex,otruey);
} // endit pawn bw1^^^^

//pawn cw1
if   ((permit > 0) && (whiich == "cw1")) 
{
// in the case that the move proposed is permissible
	var cwp = dd.elements.cwp;
	cwp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'cw1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "cw1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var cwp = dd.elements.cwp;
	cwp.moveTo(otruex,otruey);
} // endit pawn cw1^^^^

//pawn dw1
if   ((permit > 0) && (whiich == "dw1")) 
{
// in the case that the move proposed is permissible
	var dwp = dd.elements.dwp;
	dwp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'dw1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "dw1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var dwp = dd.elements.dwp;
	dwp.moveTo(otruex,otruey);
} // endit pawn dw1^^^^

//pawn ew1
if   ((permit > 0)  && (whiich == "ew1")) 
{

// in the case that the move proposed is permissible

	var ewp = dd.elements.ewp;
	ewp.moveTo(truex,truey);

        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'ew1');
 
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0)  && (whiich == "ew1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var ewp = dd.elements.ewp;
	ewp.moveTo(otruex,otruey);
} // endit pawn ew1^^^^

//pawn fw1
if   ((permit > 0) && (whiich == "fw1")) 
{
// in the case that the move proposed is permissible
	var fwp = dd.elements.fwp;
	fwp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'fw1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "fw1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var fwp = dd.elements.fwp;
	fwp.moveTo(otruex,otruey);
} // endit pawn fw1^^^^

//pawn gw1
if   ((permit > 0) && (whiich == "gw1")) 
{
// in the case that the move proposed is permissible
	var gwp = dd.elements.gwp;
	gwp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'gw1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.alt;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "gw1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var gwp = dd.elements.gwp;
	gwp.moveTo(otruex,otruey);
} // endit pawn gw1^^^^

//pawn hw1
if   ((permit > 0) && (whiich == "hw1")) 
{
// in the case that the move proposed is permissible
	var hwp = dd.elements.hwp;
	hwp.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'hw1');
          if (permit > 1)
          {
          stagget = document.getElementById(convertnmejo(n,om));
		eprevert=stagget.al;
          stagget.alt = tagget.alt.replace(/(.+)/,'0');
          }
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful pawn move
if      ((permit == 0) && (whiich == "hw1") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var hwp = dd.elements.hwp;
	hwp.moveTo(otruex,otruey);
} // endit pawn hw1^^^^
///////////////////////// endit all the white black pawns^^^




// king
if   ((permit == 1) && (whiich == "eb6")  ) 
{
// in the case that the move proposed is permissible

	var ebk = dd.elements.ebk;
	ebk.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'eb6');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}

// nonsuccessful king move
if      ((permit == 0) && (whiich == "eb6") )   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var ebk = dd.elements.ebk;
	ebk.moveTo(otruex,otruey);
} // endit king^^^^

// king
if   ((permit == 1) && (whiich == "ew6") )
{
// in the case that the move proposed is permissible
	var ewk = dd.elements.ewk;
	ewk.moveTo(truex,truey);
        tagget = document.getElementById(convertnmejo(n,m));
        tagget.alt = tagget.alt.replace(/(.+)/,'ew6');
        otagget = document.getElementById(convertnmejo(on,om));
        otagget.alt = tagget.alt.replace(/(.+)/,'0');
}
// since we got to HERE, a legal move must have been made^^^^

// nonsuccessful king move
if      ((permit == 0)  && (whiich == "ew6"))   //square is occupied by friendly or forbidden intrinsically
{
// not a legal move, snap back to old position
	var ewk = dd.elements.ewk;
	ewk.moveTo(otruex,otruey);
} // endit king^^^^
///////////////////////////////////////////////////////////////////////////////



// endit phase two

//IF PERMIT <----> 0 BOMBOUT
if (permit == 0){return}


//phase three                     track en passant possibility 

//en passant tracker
if(springe == 1)
{
springe++;
}
else 
{
springe = 0;
}



//endit phase three


//phase four  // this finds discovered check and non capture or blocking moves and reverts them


// this finds discovered check and non capture or blocking moves
if (     ( (colorr == "w") && (checkcheck(wpalacen,wpalacem,colorr) == 1) ) || ( (colorr == "b") && (checkcheck(bpalacen,bpalacem,colorr) == 1) ))
{
		document.getElementById("alert").innerHTML = 'Alert: IN CHECK! ';
//		alert("IN CHECK!"+capture+stuffage+"n"+n+"m"+m);


permit = 0;

//now undo promotion if it leaves a checked king
	if(promote==1)
	{

// now put back whatever was in the terminal square BEFORE everything started
// replace contents of terminal swquare
        var batagget = document.getElementById(convertnmejo(n,m));
        batagget.alt = batagget.alt.replace(/(.+)/,auld);
        rktagget = document.getElementById(convertnmejo(on,om));
//  rezero pawn marker and REVERT IMAGE
         if(rpawn == "ab1,ab1") {dd.elements.abp.swapImage("bb1.gif");dd.elements.abp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'ab1');ab1p = 0}
         if(rpawn == "bb1,bb1") {dd.elements.bbp.swapImage("bb1.gif");dd.elements.bbp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'bb1');bb1p = 0}
         if(rpawn == "cb1,cb1") {dd.elements.cbp.swapImage("bb1.gif");dd.elements.cbp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'cb1');cb1p = 0}
         if(rpawn == "db1,db1") {dd.elements.dbp.swapImage("bb1.gif");dd.elements.dbp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'db1');db1p = 0}
         if(rpawn == "eb1,eb1") {dd.elements.ebp.swapImage("bb1.gif");dd.elements.ebp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'eb1');eb1p = 0}
         if(rpawn == "fb1,fb1") {dd.elements.fbp.swapImage("bb1.gif");dd.elements.fbp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'fb1');fb1p = 0}
         if(rpawn == "gb1,gb1") {dd.elements.gbp.swapImage("bb1.gif");dd.elements.gbp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'gb1');gb1p = 0}
         if(rpawn == "hb1,hb1") {dd.elements.hbp.swapImage("bb1.gif");dd.elements.hbp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'hb1');hb1p = 0}
         if(rpawn == "aw1,aw1") {dd.elements.awp.swapImage("ww1.gif");dd.elements.awp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'aw1');aw1p = 0}
         if(rpawn == "bw1,bw1") {dd.elements.bwp.swapImage("ww1.gif");dd.elements.bwp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'bw1');bw1p = 0}
         if(rpawn == "cw1,cw1") {dd.elements.cwp.swapImage("ww1.gif");dd.elements.cwp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'cw1');cw1p = 0}
         if(rpawn == "dw1,dw1") {dd.elements.dwp.swapImage("ww1.gif");dd.elements.dwp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'dw1');dw1p = 0}
         if(rpawn == "ew1,ew1") {dd.elements.ewp.swapImage("ww1.gif");dd.elements.ewp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'ew1');ew1p = 0}
         if(rpawn == "fw1,fw1") {dd.elements.fwp.swapImage("ww1.gif");dd.elements.fwp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'fw1');fw1p = 0}
         if(rpawn == "gw1,gw1") {dd.elements.gwp.swapImage("ww1.gif");dd.elements.gwp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'gw1');gw1p = 0}
         if(rpawn == "hw1,hw1") {dd.elements.hwp.swapImage("ww1.gif");dd.elements.hwp.moveTo(otruex,otruey);rktagget.alt = rktagget.alt.replace(/(.+)/,'hw1');hw1p = 0}
        duckki = undoer(whiich);return
	}  //endit undo promotion

        else
        {
// simply  undo move:
        duckki = undoer(whiich);
        return
        }
}  //endit undo^^^


//endit phase four

if ((permit > 0) && (problem !=1)) {
if ((colorr=="w") && (pturn == 1) ) {dummy=blstart(); doggy=whstop()}
if ((colorr=="b") && (pturn == -1)) {dummy=whstart(); doggy=blstop()}
pturn = pturn * (-1); gooood = tieco(n,m,on,om); }

//alert("terminus est");
plive=0; // forbid the promo routines to function
// now the thing that checks for checkmate and stalemate
// keep in mind pturn dersever
// first freeze board

duckki = freezer();
bombout = 0;

      // find source, run prise on source, loop thru prise results, if a legal position exists, checkmate does not
      // if source houses 3,4,or 5, ( 3 --\O-- 4 , precisely), run lineal, loop thru lineal result-ejoj with prise, if a legal position exists, checkmate does not
      // calculate nearest 8, iterate thru extants with bishoplegal and rooklegal, if king can move there legally checkmate does not exist

if (pturn =="1")
{
  if(checkcheck(wpalacen,wpalacem,"w") == 1)
  {

   //first the checking piece itself;; can be captured?
   if ((colorr == "b") && (prise(sourcen,sourcem,"b")==1)) //white in check from a black piece at sourcen,sourcem under white threat; prise generates jj lists  
   { 

          //if capture of the black piece is legal, checkmate cannot happen; each potential capture is a jj element
    jj = 0; ypercts = 1;

     while ((jj<jjmax) && (ypercts>-1))
     {

      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy

	ypercts = checkcheck(wpalacen,wpalacem,"w"); // if ypercts >0 this hypot cannot be legal, checkmate still possible

//freezer will have to record palaces and posrevert will have to reestablish them  AND hypot must move palaces if a king is the jj piece
        if (ypercts == 0)
        {
         //it is definitely legal to capture THIS checking piece and so doing has actually removed check  (<--redundant, if cap did not remove check, cap illeg)  
         duckki = posrevert();bombout = 1;
        }else{duckki=posrevert()}
      jj++;
     }

   }
  }
//white king still in check, black piece cannot be captured if bombout still 0
//white check phase ii: below

}



if (pturn =="-1")   //black should now move
{
  if(checkcheck(bpalacen,bpalacem,"b") == 1)   //calling color devas salvata??
  {
   if ((colorr == "w") && (prise(sourcen,sourcem,"w")==1)) //black in check from a white piece at sourcen,sourcem under black threat; prise generates jj lists  
   { 

          //if capture of the white piece is legal, checkmate cannot happen; each potential capture is a jj element
    jj = 0; ypercts = 1;

     while ((jj<jjmax) && (ypercts>-1))
     {
      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
   	ypercts = checkcheck(bpalacen,bpalacem,"b"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        if (ypercts == 0)
        {
         //it is definitely legal to capture THIS checking piece and so doing has actually removed check  (<--redundant, if cap did not remove check, cap illeg)
         duckki = posrevert();bombout = 1;
        }else{duckki=posrevert()}
      jj++;
     }

   }
  }
//b king still in check, w piece cannot be captured if bombout still 0
//b check phase ii: below

}



  //                              ^^^^^^^^^^^^^^^^^^^^^^^^^^
   //cease examination of the checking piece;;checking piece itself;; can be captured?^^^



// now try to interpose upon the checking piece (phase ii

   //intersticiality traceback

   if ((bombout == 0) && (checkcheck(wpalacen,wpalacem,"w") == pturn)) //white must move and is in check
   {
       tagget = document.getElementById(convertnmejo(sourcen,sourcem));
       kingx = wpalacen;kingy = wpalacem;

   re = tagget.alt.match(/(.+)/);gooan=0;
   if  ((RegExp.$1.match(/\wb5/)) || (RegExp.$1.match(/\wb3/))  || (RegExp.$1.match(/\wb4/))) {gooan = 1}
   if  ((RegExp.$1.match(/ab1/)) && (ab1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/bb1/)) && (bb1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/cb1/)) && (cb1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/db1/)) && (db1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/eb1/)) && (eb1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/fb1/)) && (fb1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/gb1/)) && (gb1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/hb1/)) && (hb1p >2)) {gooan = 1}
    // first establish vectortype
     if(   (Math.abs(sourcen-kingx)>1)  && ( gooan == 1 ) && (  (Math.abs(sourcem-kingy))==(Math.abs(sourcen-kingx)) ) )
     {
      //kuriereco vectortype
      inc = Math.abs(sourcen-kingx)-1;
         // try to interpose upon a bishop: standard 4 case method 

		if(  (kingx>sourcen) && (kingy>sourcem) && (inc>0) ) //case doublepos
		{
                while (inc>0)
		{
		intern = sourcen+inc; interm = sourcem+inc;
			if (disprise(intern,interm,"b")==1)  //white in check from a black piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(wpalacen,wpalacem,"w"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if(  (kingx>sourcen) && (kingy<sourcem) && (inc>0) ) //case posneg
		{
                while (inc>0)
		{
		intern = sourcen+inc; interm = sourcem-inc;
			if (disprise(intern,interm,"b")==1)  //white in check from a black piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(wpalacen,wpalacem,"w"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if(  (kingx<sourcen) && (kingy<sourcem) && (inc>0) ) //case negneg
		{
                while (inc>0)
		{
		intern = sourcen-inc; interm = sourcem-inc;
			if (disprise(intern,interm,"b")==1)  //white in check from a black piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(wpalacen,wpalacem,"w"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if(  (kingx<sourcen) && (kingy>sourcem) && (inc>0) ) //case negpos
		{
                while (inc>0)
		{
		intern = sourcen-inc; interm = sourcem+inc;
			if (disprise(intern,interm,"b")==1)  //white in check from a black piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(wpalacen,wpalacem,"w"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
	       } //endit negpos
//
     } //kuriereco  vectortype


     if(  ((Math.abs(sourcen-kingx)>1) || (Math.abs(sourcem-kingy)>1))   && ( gooan == 1 ) && ( (Math.abs(sourcem-kingy) ==0) || (Math.abs(sourcen-kingx)==0) ) )
     {
      //tureco vectortype
      inc = Math.abs(sourcen-kingx)-1;
         // try to interpose upon a rook: standard 4 case method 


		if(  (kingx>sourcen) && (inc>0)  ) //case x-pos
		{
                while (inc>0)
		{
		intern = sourcen+inc; interm = sourcem;
			if (disprise(intern,interm,"b")==1)  //white in check from a black piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(wpalacen,wpalacem,"w"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if(  (kingx<sourcen) && (inc>0) ) //case x-neg
		{
                while (inc>0)
		{
		intern = sourcen-inc; interm = sourcem;
			if (disprise(intern,interm,"b")==1)  //white in check from a black piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(wpalacen,wpalacem,"w"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if( (kingy<sourcem) && (inc>0) ) //case y-neg
		{
                while (inc>0)
		{
		intern = sourcen; interm = sourcem-inc;
			if (disprise(intern,interm,"b")==1)  //white in check from a black piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(wpalacen,wpalacem,"w"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if( (kingy>sourcem) && (inc>0) ) //case y-pos
		{
                while (inc>0)
		{
		intern = sourcen; interm = sourcem+inc;
			if (disprise(intern,interm,"b")==1)  //white in check from a black piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(wpalacen,wpalacem,"w"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
	       } //endit negpos
//
     } //tureco  vectortype




   } //endit case white in check, interstitiality escape


   if ((bombout == 0) && (checkcheck(bpalacen,bpalacem,"b") == -pturn)) //black must move and is in check
   {
//alert("whome")
       tagget = document.getElementById(convertnmejo(sourcen,sourcem));
       kingx = bpalacen;kingy = bpalacem;

   re = tagget.alt.match(/(.+)/);gooan=0;
//alert(re);
   if  ((RegExp.$1.match(/\ww5/)) || (RegExp.$1.match(/\ww3/))  || (RegExp.$1.match(/\ww4/))) {gooan = 1}
   if  ((RegExp.$1.match(/aw1/)) && (aw1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/bw1/)) && (bw1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/cw1/)) && (cw1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/dw1/)) && (dw1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/ew1/)) && (ew1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/fw1/)) && (fw1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/gw1/)) && (gw1p >2)) {gooan = 1}
   if  ((RegExp.$1.match(/hw1/)) && (hw1p >2)) {gooan = 1}
//alert("gooan"+gooan);
    // first establish vectortype
     if(   (Math.abs(sourcen-kingx)>1)  && ( gooan == 1 ) && (  (Math.abs(sourcem-kingy))==(Math.abs(sourcen-kingx)) ) )
     {
      //kuriereco vectortype
//alert("kvect")
      inc = Math.abs(sourcen-kingx)-1;

         // try to interpose upon a bishop: standard 4 case method 


		if(  (kingx>sourcen) && (kingy>sourcem) && (inc>0) ) //case doublepos
		{

                while (inc>0)
		{

		intern = sourcen+inc; interm = sourcem+inc;
//alert(intern+"++"+interm);
			if (disprise(intern,interm,"w")==1)  //black in check from a w piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(bpalacen,bpalacem,"b"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if(  (kingx>sourcen) && (kingy<sourcem) && (inc>0) ) //case posneg
		{

                while (inc>0)
		{
		intern = sourcen+inc; interm = sourcem-inc;
//alert(intern+"+-"+interm);
			if (disprise(intern,interm,"w")==1)  //black in check from a w piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(bpalacen,bpalacem,"b"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if(  (kingx<sourcen) && (kingy<sourcem) && (inc>0) ) //case negneg
		{

                while (inc>0)
		{
		intern = sourcen-inc; interm = sourcem-inc;
//alert(intern+"--"+interm);
			if (disprise(intern,interm,"w")==1)  //black in check from a w piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{

				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(bpalacen,bpalacem,"b"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if(  (kingx<sourcen) && (kingy>sourcem) && (inc>0) ) //case negpos
		{

                while (inc>0)
		{
		intern = sourcen-inc; interm = sourcem+inc;
//alert(intern+"-+"+interm);
			if (disprise(intern,interm,"w")==1)  //b in check from a w piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(bpalacen,bpalacem,"b"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
	       } //endit negpos
//
     } //kuriereco  vectortype


     if(  ((Math.abs(sourcen-kingx)>1) || (Math.abs(sourcem-kingy)>1))   && ( gooan == 1 ) && ( (Math.abs(sourcem-kingy) ==0) || (Math.abs(sourcen-kingx)==0) ) )
     {
      //tureco vectortype
//alert("tvect")
      inc = Math.abs(sourcen-kingx)-1;
         // try to interpose upon a rook: standard 4 case method 


		if(  (kingx>sourcen) && (inc>0)  ) //case x-pos
		{
                while (inc>0)
		{
		intern = sourcen+inc; interm = sourcem;
//alert(intern+"+0"+interm);
			if (disprise(intern,interm,"w")==1)  //b in check from a w piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(bpalacen,bpalacem,"b"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if(  (kingx<sourcen) && (inc>0) ) //case x-neg
		{
                while (inc>0)
		{
		intern = sourcen-inc; interm = sourcem;
//alert(intern+"-0"+interm);
			if (disprise(intern,interm,"w")==1)  //b in check from a w piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(bpalacen,bpalacem,"b"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if( (kingy<sourcem) && (inc>0) ) //case y-neg
		{
                while (inc>0)
		{
		intern = sourcen; interm = sourcem-inc;
//alert(intern+"0-"+interm);
			if (disprise(intern,interm,"w")==1)  //b in check from a w piece at intern,interm under white threat; prise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(bpalacen,bpalacem,"b"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
		}

		if( (kingy>sourcem) && (inc>0) ) //case y-pos
		{
                while (inc>0 )
		{
		intern = sourcen; interm = sourcem+inc;
//alert(intern+"0+"+interm);
			if (disprise(intern,interm,"w")==1)  //b in check from a w piece at intern,interm under white threat; disprise generates jj lists
			{
			    jj = 0; ypercts = 1;

    			 while ((jj<jjmax) && (ypercts>-1))
     				{
				      duckki = hypot(jjn[jj],jjm[jj],sourcen,sourcem);    //capture piece, change boardcopy
			              ypercts = checkcheck(bpalacen,bpalacem,"b"); // if ypercts >0 this hypot cannot be legal, checkmate still possible
        				if (ypercts == 0)
        				{
         				duckki = posrevert();bombout = 1;
        				}else{duckki=posrevert()}
					      jj++;
				}
			 
			}  
		inc--;
		}
	       } //endit negpos
//
     } //tureco  vectortype

   } //endit case black in check, interstitiality escape


//alert("yesyou");

// or move out.....

if ((bombout == 0) && (checkcheck(wpalacen,wpalacem,"w") == pturn)) //white must move and is in check
{
//document.getElementById("alert").innerHTML = 'preone ';
duckki=proximate("w");
if (bombout == 0){blstop();whstop();document.getElementById("alert").innerHTML = 'white checkmated ';checkmatet =1;return}
}
/////

if ((bombout == 0) && (checkcheck(bpalacen,bpalacem,"b") == -pturn)) //b must move and is in check
{
duckki=proximate("b");
if (bombout == 0){whstop();blstop();document.getElementById("alert").innerHTML = 'black checkmated ';checkmatet =1;return} 
}
///////////////////////////////////////////////////// end of checkmate checking
//stalemate time
//black first

if ((pturn == -1) && (checkcheck(bpalacen,bpalacem,"b") == 0)) //b must move and is not in check
{
//alert("b mm nic");
bombout = 0;
duckki=proximate("b");
//alert("postprox"+bombout);
//var ttx1 = document.createTextNode('no legal proximate?');
//document.getElementById("alert").appendChild(ttx1);
var bbbb = document.createTextNode('bombout null');
//if (bombout == 0) {document.getElementById("alert").appendChild(bbbb) ; duckki = fullcycle("b")}
if (bombout == 0) {duckki = fullcycle("b")}
if (bombout != 1){blstop();whstop();stalematet = 1;document.getElementById("alert").innerHTML = 'stalemate ';} 
}

//then white
if ((pturn == 1) && (checkcheck(wpalacen,wpalacem,"w") == 0)) //w must move and is not in check
{
bombout = 0;
duckki=proximate("w");
if (bombout == 0) {duckki = fullcycle("w")}
if (bombout != 1){whstop();blstop();stalematet = 1;document.getElementById("alert").innerHTML = 'stalemate ';} 
}


} //endit drop function^^^^


////////////////////  BELOW HERE ARE STRICTLY NON WZ FUNCTIONS BY W.N. MURRAY


function tieco(n,m,on,om)
{

//print coordinates of square
//n=1 <----> a, n=2 <-------> b ktp
//m=1 <---> 8, 2<--->7 ktp

var arank = 9-m;
var orank = 9-om;
var afile;
var ofile;

if(n == 1)
{
afile = "a"
}
if(n == 2)
{
afile = "b"
}
if(n == 3)
{
afile = "c"
}
if(n == 4)
{
afile = "d"
}
if(n == 5)
{
afile = "e"
}
if(n == 6)
{
afile = "f"
}
if(n == 7)
{
afile = "g"
}
if(n == 8)
{
afile = "h"
}


if(on == 1)
{
ofile = "a"
}
if(on == 2)
{
ofile = "b"
}
if(on == 3)
{
ofile = "c"
}
if(on == 4)
{
ofile = "d"
}
if(on == 5)
{
ofile = "e"
}
if(on == 6)
{
ofile = "f"
}
if(on == 7)
{
ofile = "g"
}
if(on == 8)
{
ofile = "h"
}

  if  (capture > 0)
  {
   var ttxxtt = document.createTextNode(ofile+orank+'X');
  }
  else
  {
   var ttxxtt = document.createTextNode(ofile+orank+'--');
  }
var ttxxtttwo = document.createTextNode(afile+arank+' ');

document.getElementById("moves").appendChild(ttxxtt);
document.getElementById("moves").appendChild(ttxxtttwo);
// note promotion
  if(promote==1)
  {
   if (tyype==5){var ttxxtthree = document.createTextNode(Q);}
   else if (tyype==2){var ttxxtthree = document.createTextNode(N);}
   else if (tyype==3){var ttxxtthree = document.createTextNode(B);}
   else {var ttxxtthree = document.createTextNode(R);}
  document.getElementById("moves").appendChild(ttxxtthree);
  }
document.getElementById("alert").innerHTML = ' ';
return 1;
}



function addEvent(elm, evType, fn, useCapture) {
  if (elm.addEventListener) {
    elm.addEventListener(evType, fn, useCapture);
    return true;
  } else if (elm.attachEvent) {
    var r = elm.attachEvent('on' + evType, fn);
    return r;
  } else {
    elm['on' + evType] = fn;
  }
}


function init() 
{
  if (!document.getElementById)
    return;
//
permit = 1;
stalematet = 0;
checkmatet = 0;
expiredet = 0;
wpalacen = 5;
wpalacem = 8;
problem = 0;
bpalacen = 5;
bpalacem = 1;
pturn = 1;
thcapture = 0;
wcastok1 = 1;
wcastok8 = 1;
bcastok1 = 1;
bcastok8 = 1;
springe = 0;
hotfile = 0;
capmoeg = 0;
vcapture = 0;
wtioma = 0;
btioma = 0;
promote = 0;

bluck = document.getElementById("00");
var duckki = fyyndPos(bluck);
xpeggg = curleft - 32;
ypeggg = curtop - 32;
	var cbb = dd.elements.cbb;
	cbb.moveTo(xpeggg+96,ypeggg+32);
	var bbn = dd.elements.bbn;
	bbn.moveTo(xpeggg+64,ypeggg+32);
	var abr = dd.elements.abr;
	abr.moveTo(xpeggg+32,ypeggg+32);
	var dbq = dd.elements.dbq;
	dbq.moveTo(xpeggg+128,ypeggg+32);
	var ebk = dd.elements.ebk;
	ebk.moveTo(xpeggg+160,ypeggg+32);
//
	var fbb = dd.elements.fbb;
	fbb.moveTo(xpeggg+192,ypeggg+32);
	var gbn = dd.elements.gbn;
	gbn.moveTo(xpeggg+224,ypeggg+32);
	var hbr = dd.elements.hbr;
	hbr.moveTo(xpeggg+256,ypeggg+32);
////
	var cbp = dd.elements.cbp;
	cbp.moveTo(xpeggg+96,ypeggg+64);

	var bbp = dd.elements.bbp;
	bbp.moveTo(xpeggg+64,ypeggg+64);

	var abp = dd.elements.abp;
	abp.moveTo(xpeggg+32,ypeggg+64);

	var dbp = dd.elements.dbp;
	dbp.moveTo(xpeggg+128,ypeggg+64);

	var ebp = dd.elements.ebp;
	ebp.moveTo(xpeggg+160,ypeggg+64);

	var fbp = dd.elements.fbp;
	fbp.moveTo(xpeggg+192,ypeggg+64);

	var gbp = dd.elements.gbp;
	gbp.moveTo(xpeggg+224,ypeggg+64);

	var hbp = dd.elements.hbp;
	hbp.moveTo(xpeggg+256,ypeggg+64);

	var cwb = dd.elements.cwb;
	cwb.moveTo(xpeggg+96,ypeggg+256);
	var bwn = dd.elements.bwn;
	bwn.moveTo(xpeggg+64,ypeggg+256);
	var awr = dd.elements.awr;
	awr.moveTo(xpeggg+32,ypeggg+256);
	var dwq = dd.elements.dwq;
	dwq.moveTo(xpeggg+128,ypeggg+256);
	var ewk = dd.elements.ewk;
	ewk.moveTo(xpeggg+160,ypeggg+256);
//
	var fwb = dd.elements.fwb;
	fwb.moveTo(xpeggg+192,ypeggg+256);
	var gwn = dd.elements.gwn;
	gwn.moveTo(xpeggg+224,ypeggg+256);
	var hwr = dd.elements.hwr;
	hwr.moveTo(xpeggg+256,ypeggg+256);
////
	var cwp = dd.elements.cwp;
	cwp.moveTo(xpeggg+96,ypeggg+224);

	var bwp = dd.elements.bwp;
	bwp.moveTo(xpeggg+64,ypeggg+224);

	var awp = dd.elements.awp;
	awp.moveTo(xpeggg+32,ypeggg+224);

	var dwp = dd.elements.dwp;
	dwp.moveTo(xpeggg+128,ypeggg+224);

	var ewp = dd.elements.ewp;
	ewp.moveTo(xpeggg+160,ypeggg+224);

	var fwp = dd.elements.fwp;
	fwp.moveTo(xpeggg+192,ypeggg+224);

	var gwp = dd.elements.gwp;
	gwp.moveTo(xpeggg+224,ypeggg+224);

	var hwp = dd.elements.hwp;
	hwp.moveTo(xpeggg+256,ypeggg+224);
// set all pawns to pawns
ab1p = 0;bb1p = 0;cb1p = 0;db1p = 0;eb1p = 0;fb1p = 0;gb1p = 0;hb1p = 0;
aw1p = 0;bw1p = 0;cw1p = 0;dw1p = 0;ew1p = 0;fw1p = 0;gw1p = 0;hw1p = 0;
}


function fyyndPos(objyy) {
        curleft = 0;
        curtop = 0;
        if (objyy.offsetParent) {
                curleft = objyy.offsetLeft
                curtop = objyy.offsetTop
                while (objyy = objyy.offsetParent) 
                {
                        curleft += objyy.offsetLeft
                        curtop += objyy.offsetTop
                }
        }

        return [curleft,curtop];
}



function knightlegal(n,m,on,om,colorr)
{

        if (!((n<9)&&(m<9)&&(n>0)&&(m>0))){return 0}   //board restriction condition 
delx = n-on;
dely = m-om;

  if(( Math.abs(delx) + Math.abs(dely) == 3) && (delx !=0) && (dely !=0))
  {
  fs = 1;
  tagget = document.getElementById(convertnmejo(n,m));
      if(boom(tagget,colorr,fs) == 1)
      {
      return 1;
      }
      else
      {
      return 0;
      }
  }
  else  // not 2, 1-like
  {
  return 0;
  }
}


function bishoplegal(n,m,on,om,colorr,limmit)
{
        if (!((n<9)&&(m<9)&&(n>0)&&(m>0))){return 0} //board restriction condition 

var delx = n-on;
var dely = m-om;
// the most generalized chess program ajn requires that rooklegal and bishoplegal be bounded 
if  (Math.abs(delx)>limmit)   {return 0}


  if(( Math.abs(delx) == Math.abs(dely)) && (delx != 0)) //test if move is bishoplike
  {     
    var itera = Math.abs(delx);
    var afirst = 1;

    while(itera > 0)
    {
  	if(bcollis(delx,dely,on,om,itera,colorr,afirst) != 0)
  	{
        var ok = 1;
  	}
  	else // just slammed into an intervening piece, exit with zero
  	{
        return  0;
  	}
    if(ok == 1){itera--; afirst = 0;} //haven't hit an intervening piece yet
    }
 
  return 1; //move is bishoplike and passes all tests
  }
  else // move is not bishoplike at all
  {
  return 0;
  }
} //endit bishoplegal^^^^^^



function rooklegal(n,m,on,om,colorr,limmit)
{
        if (!((n<9)&&(m<9)&&(n>0)&&(m>0))){return 0}    //board restriction condition 
var delx = n-on;
var dely = m-om;

// the most generalized chess program ajn requires that rooklegal and bishoplegal be bounded 
if( (Math.abs(delx)>limmit) || (Math.abs(dely)>limmit) ) {return 0}


  if  (   (((Math.abs(delx) == 0) || (Math.abs(dely)) == 0))  && (Math.abs(dely)+Math.abs(delx)!=0 )   )//test if move is rooklike
  {     
    var itera = Math.abs(delx)+Math.abs(dely);
    var afirst = 1;

    while(itera > 0)
    {
  	if(rcollis(delx,dely,on,om,itera,colorr,afirst) != 0)
  	{
        var ok = 1;
  	}
  	else // just slammed into an intervening piece, exit with zero
  	{
        return  0;
  	}
    if(ok == 1){itera--; afirst = 0;} //haven't hit an intervening piece yet
    }
 

  return 1; //move is rooklike and passes all tests
  }
  else // move is not rooklike at all
  {
  return 0;
  }
} //endit rooklegal^^^^^^




function bpawnlegal(n,m,on,om,colorr,limmit)
{
        if (!((n<9)&&(m<9)&&(n>0)&&(m>0))){return 0}    //board restriction condition 
var dely = m-om;
var delx = n-on;
if  (dely == 0){return 0}



// first define a legal move 
  if ( (delx == 0) && (dely > 0) && (emppty(n,m)== 1)&& (emppty(n,3)== 1) &&(0 < Math.abs(dely)) && (Math.abs(dely) < limmit) && (om == 2))  //double move
  {
//      en passant enablement clause
	if (m == 4){springe=1;hotfile=n;}
  return 1;
  }


  if ( (delx == 0) && (dely == 1)&& (emppty(n,m)== 1)) //regular move
{
// now the whole last rank thing:
if(m==8)    // n,m,on,om
{
var duckki = bpromo(n,m,on,om);
}
//endit the last rank thing^^^      
return 1;
}


//then define a legal capture
// first en passant
//on the same om = 5 if n (of move) havas (5, n) opcolorpawn set capmoeg <==> 1
   tagget = document.getElementById(convertnmejo(n,5));
   re = tagget.alt.match(/(.+)/);
   if  (RegExp.$1.match(/\ww1/)){capmoeg = 1}
    if ((springe > 0) && (om == 5) && (capmoeg == 1) && (dely == 1) && (Math.abs(delx) == 1) && (hotfile == n))   
    {
    ptagget = document.getElementById(convertnmejo(n,om));
    re = ptagget.alt.match(/(.+)/);
//vcapture = 1;
         if(re == "dw1,dw1") {dd.elements.dwp.hide();}
         if(re == "fw1,fw1") {dd.elements.fwp.hide();}
         if(re == "gw1,gw1") {dd.elements.gwp.hide();}
         if(re == "hw1,hw1") {dd.elements.hwp.hide();}
         if(re == "ew1,ew1") {dd.elements.ewp.hide();}
         if(re == "cw1,cw1") {dd.elements.cwp.hide();}
         if(re == "bw1,bw1") {dd.elements.bwp.hide();}
         if(re == "aw1,aw1") {dd.elements.awp.hide();}
     stuffage = re;
    capmoeg = 0;
    capture = 1;
    return 11;
    }


//then standard capture
  if ((Math.abs(delx) == 1)   &&    (dely == 1)) 
  {
if(emppty(n,m) == 1) {return 0} // must needs 
  fs = 1;
  tagget = document.getElementById(convertnmejo(n,m));
      if(boom(tagget,colorr,fs) == 1)
      {
// now the whole last rank thing:
if(m==8) {var duckki = bpromo(n,m,on,om);}
//endit the last rank thing^^^      
      return 1;
      }
      else
      {
      return 0;
      }
  }

return 0;
}


function bmopawnlegal(n,m,on,om,colorr)
{
        if (!((n<9)&&(m<9)&&(n>0)&&(m>0))){return 0}    //board restriction condition 
var dely = m-om;
var delx = n-on;
if ( (dely == 0) || (delx !=0)) {return 0}

// define a legal move 
  if ( (dely > 0) && (emppty(n,6)== 1) && (2 == Math.abs(dely)) &&(m == 7))  //double move
  {
  return 1;
  }


  if ( (delx == 0) && (dely == 1) ) //regular move
{
return 1;
}

return 0;
}

function wpawnlegal(n,m,on,om,colorr,limmit)
{
//alert("n,m,on,om"+"  "+n+"  "+m+"  "+on+"   "+om)
        if (!((n<9)&&(m<9)&&(n>0)&&(m>0))){return 0}    //board restriction condition 
var dely = m-om;
var delx = n-on;
if (dely == 0){return 0}
// first define a legal move 

//case double move
  if ((dely<0) && (delx==0) && (emppty(n,m)== 1)&& (emppty(n,6)== 1) &&  (0 < Math.abs(dely)) &&  (Math.abs(dely)<limmit) && (om==7))
  {
//      en passant enablement clause
	if (m == 5){springe=1;hotfile=n;}
  return 1;
  }

//case single move noncapture
  if ( (delx == 0) && (dely == -1) && (emppty(n,m)== 1) )
{
// now the whole last rank thing:
if(m==1) {var duckki = wpromo(n,m,on,om)}
//endit the last rank thing^^^      
return 1
}

//then define a legal capture
// first en passant
//on the same om = 4 if n (of move) havas (4, n) opcolorpawn set capmoeg <==> 1
  tagget = document.getElementById(convertnmejo(n,4));
  re = tagget.alt.match(/(.+)/);
  if  (RegExp.$1.match(/\wb1/)){capmoeg = 1}
  if ((springe > 0) && (om == 4) && (capmoeg == 1) && (dely == -1) && (Math.abs(delx) == 1) && (hotfile == n))   
  {
    ptagget = document.getElementById(convertnmejo(n,om));
//vcapture =1;
    re = tagget.alt.match(/(.+)/);
         if(re == "db1,db1") {dd.elements.dbp.hide();}
         if(re == "fb1,fb1") {dd.elements.fbp.hide();}
         if(re == "gb1,gb1") {dd.elements.gbp.hide();}
         if(re == "hb1,hb1") {dd.elements.hbp.hide();}
         if(re == "eb1,eb1") {dd.elements.ebp.hide();}
         if(re == "cb1,cb1") {dd.elements.cbp.hide();}
         if(re == "bb1,bb1") {dd.elements.bbp.hide();}
         if(re == "ab1,ab1") {dd.elements.abp.hide();}
    capmoeg = 0;
     stuffage = re;
    capture = 1;
  return 11;
  }

//then standard capture
  if ((Math.abs(delx) == 1)   &&    (dely == -1)) 
  {
if(emppty(n,m) == 1) {return 0;} 
  fs = 1;
  tagget = document.getElementById(convertnmejo(n,m));

      if(boom(tagget,colorr,fs) == 1)
      {

// now the whole last rank thing:
if(m==1)  {var duckki = wpromo(n,m,on,om)}
//endit the last rank thing^^^      

      return 1;
      }
      else
      {
      return 0;
      }
  }

return 0;
}


function wmopawnlegal(n,m,on,om,colorr)
{// white is giving check, can a black pawn block?
        if (!((n<9)&&(m<9)&&(n>0)&&(m>0))){return 0}    //board restriction condition 
var dely = m-om;
var delx = n-on;

if ((dely == 0) || (delx != 0)){return 0}
// define a legal move 
//case double move
  if ((dely<0) && (emppty(n,3)== 1) &&  (2 == Math.abs(dely)) && (m==2))
  {
  return 1;
  }

//case single move 

  if ( (delx == 0) && (dely == -1) )
{
return 1
}

// if get to here:
return 0;
}


function boom(tagget,c,fs)
{
if ((testty !=1) && (fs == 1))   {capture = 0;}

   re = tagget.alt.match(/(.+)/);

if  (RegExp.$1.match(/\wb\d/))   
 {
 // target piece is black
 var tcolor = "b";
 }

else if  (RegExp.$1.match(/\ww\d/)) 
 {  
// target piece is white
 var tcolor = "w";
 }

else
 {
 //target color is not germane, square is empty, move is legal
tcolor = "x";

 return 1;
 }
	if ( (fs == 1) && (tcolor != c)&&(tcolor !="x") && (refuse ==0 ))  //if target square is "first" (i.e. terminal) square AND colors are opposite
	{

if (testty ==1) thcapture = 1;
if (testty !=1) 
{
         stuffage = re;
         capture = 1;

         if(re == "ew6,ew6") {return 0;}
         if(re == "dw5,dw5") {dd.elements.dwq.hide();}
         if(re == "cw3,cw3") {dd.elements.cwb.hide();}
         if(re == "fw3,fw3") {dd.elements.fwb.hide();}

         if(re == "bw2,bw2") {dd.elements.bwn.hide();}
         if(re == "gw2,gw2") {dd.elements.gwn.hide();}
         if(re == "aw4,aw4") {dd.elements.awr.hide();}
         if(re == "hw4,hw4") {dd.elements.hwr.hide();}

         if(re == "dw1,dw1") {dd.elements.dwp.hide();}
         if(re == "fw1,fw1") {dd.elements.fwp.hide();}
         if(re == "gw1,gw1") {dd.elements.gwp.hide();}
         if(re == "hw1,hw1") {dd.elements.hwp.hide();}


         if(re == "ew1,ew1") {dd.elements.ewp.hide();}
         if(re == "cw1,cw1") {dd.elements.cwp.hide();}
         if(re == "bw1,bw1") {dd.elements.bwp.hide();}
         if(re == "aw1,aw1") {dd.elements.awp.hide();}

         if(re == "eb6,eb6") {return 0;}
         if(re == "db5,db5") {dd.elements.dbq.hide();}
         if(re == "cb3,cb3") {dd.elements.cbb.hide();}
         if(re == "fb3,fb3") {dd.elements.fbb.hide();}

         if(re == "bb2,bb2") {dd.elements.bbn.hide();}
         if(re == "gb2,gb2") {dd.elements.gbn.hide();}
         if(re == "ab4,ab4") {dd.elements.abr.hide();}
         if(re == "hb4,hb4") {dd.elements.hbr.hide();}

         if(re == "db1,db1") {dd.elements.dbp.hide();}
         if(re == "fb1,fb1") {dd.elements.fbp.hide();}
         if(re == "gb1,gb1") {dd.elements.gbp.hide();}
         if(re == "hb1,hb1") {dd.elements.hbp.hide();}


         if(re == "eb1,eb1") {dd.elements.ebp.hide();}
         if(re == "cb1,cb1") {dd.elements.cbp.hide();}
         if(re == "bb1,bb1") {dd.elements.bbp.hide();}
         if(re == "ab1,ab1") {dd.elements.abp.hide();}
         }
	return 1;     //this is a capture
	}
	else //this is an illegal situation; cannot capture a piece of the same color
	{

	return 0;
	}

}


function emppty(thenn,themm)
{
        tagget = document.getElementById(convertnmejo(thenn,themm));
        re = tagget.alt.match(/(.+)/);
		if  (RegExp.$1.match(/0/)){return 1}else{return 0}
}

function ally(thenn,themm,k)
{
        tagget = document.getElementById(convertnmejo(thenn,themm));
        re = tagget.alt.match(/(.+)/);
//alert(re);
		if  (RegExp.$1.match(/0/)){holder="x"}
		if  (RegExp.$1.match(/\wb\d/)){holder="b"}
	        if  (RegExp.$1.match(/\ww\d/)){holder="w"}
//alert(holder+k);
  if (holder == k){return 1}
{return 0}
}

function fullcycle(ytint)
{
oppcolo="w";if(ytint == "w"){oppcolo="b"}
uu=1;vv=1;
//alert("oppcolo"+oppcolo+bombout);
//stufffus = emppty(1,1)
//alert(stufffus)
	while((vv<9) && (bombout == 0))
{		
	 while((uu<9) && (bombout == 0))
         {

          if(emppty(uu,vv) == 1)

           {  //this square is empty  --- yet treat it as though occupied by an enemy piece
//alert(uu+"  "+vv);
            cpercts = disprise(uu,vv,oppcolo);
//alert("disprise"+cpercts)
//var cccc = document.createTextNode('this square');
//document.getElementById("alert").appendChild(cccc);
//document.getElementById("alert").appendChild(uu);

             if (cpercts > 0)
             {

               ypercts = 1;jj=0;
    			 while (jj<jjmax)
     				{
				      duckki = hypot(jjn[jj],jjm[jj],uu,vv);    //capture piece, change boardcopy
			            //  ypercts = checkcheck(uu,vv,ytint); // if ypercts >0 this move not legal
                                      if (ytint == "b"){ypercts = checkcheck(bpalacen,bpalacem,"b")}else{ypercts = checkcheck(wpalacen,wpalacem,"w")}
			              // if ypercts >0 this move not legal
//alert(uu+"hh"+ypercts+"qq"+vv+ytint)
        				if (ypercts == 0)
        				{ //this move is legal
         				duckki = posrevert();bombout = 1;
        				}
                                        else
                                        {
                                        duckki=posrevert()
                                        }
					      jj++;
				}
			 
             }

          uu++;
  
           }
          else     //square is occupied
           { 


            sorrt = ally(uu,vv,ytint);
//alert(uu+" "+vv+"sorrt"+sorrt);
              if (sorrt != 1)
              { //this is an enemy piece
                 cpercts = prise(uu,vv,oppcolo);
                 if (cpercts > 0)
                 {

                 ypercts = 1;jj=0;
    			 while (jj<jjmax)  
     				{
				      duckki = hypot(jjn[jj],jjm[jj],uu,vv);    //capture piece, change boardcopy
			              //ypercts = checkcheck(uu,vv,ytint); // if ypercts >0 this hypot cannot be legal, this move not legal
                                      if (ytint == "b"){ypercts = checkcheck(bpalacen,bpalacem,"b")}else{ypercts = checkcheck(wpalacen,wpalacem,"w")}
//alert(uu+"ff"+ypercts+"xx"+vv+ytint)
        				if (ypercts == 0)
        				{ //this move is legal
         				duckki = posrevert();bombout = 1;
        				}
                                        else
                                        {
                                        duckki=posrevert()
                                        }
					      jj++;
				}
			 
                 }          

              }
uu++;

           }
//alert(uu+"kk"+vv)
         }
	uu=1;vv++; 
	}

}

function bcollis(dx,dy,on,om,i,c,fs)
{
// four choices


//choice dn
	if((dx<0) && (dy<0)) // double negative
        {

//examine target square, if target square is "first" (i.e. terminal) square AND colors are opposite
// set capture to one 
  tagget = document.getElementById(convertnmejo(on-i,om-i));

		if(boom(tagget,c,fs) == 1)
		{
		return 1;
		}
		else
		{
		return 0;
		} 

	}


// choice dp
	if((dx>0) && (dy>0)) // double positive
        {

  tagget = document.getElementById(convertnmejo(on+i,om+i));
		if(boom(tagget,c,fs) == 1)
		{
		return 1;
		}
		else
		{
		return 0;
		}  
 
	}


//choice np
	if((dx<0) && (dy>0)) //  negative positive
        {

  tagget = document.getElementById(convertnmejo(on-i,om+i));
		if(boom(tagget,c,fs) == 1)
		{
		return 1;
		}
		else
		{
		return 0;
		}   
	}

//choice pn
	if((dx>0) && (dy<0)) // positive negative
        {

  tagget = document.getElementById(convertnmejo(on+i,om-i));
		if(boom(tagget,c,fs) == 1)
		{
		return 1;
		}
		else
		{
		return 0;
		}
	}
}



function rcollis(dx,dy,on,om,i,c,fs)
{
// four choices


//choice +x
	if (dx>0) // plus x
        {

//examine target square, if target square is "first" (i.e. terminal) square AND colors are opposite... 
  tagget = document.getElementById(convertnmejo(on+i,om));

		if(boom(tagget,c,fs) == 1)
		{

		return 1;
		}
		else
		{
		return 0;
		} 

	}


// choice +y
	if (dy>0) // plus y
        {

  tagget = document.getElementById(convertnmejo(on,om+i));

		if(boom(tagget,c,fs) == 1)
		{

		return 1;
		}
		else
		{
		return 0;
		}  
	}


//choice -x
	if (dx<0)  //  negative x
        {

  tagget = document.getElementById(convertnmejo(on-i,om));
		if(boom(tagget,c,fs) == 1)
		{
		return 1;

		}
		else
		{
		return 0;
		}   
	}

//choice -y
	if (dy<0) // negative y
        {

  tagget = document.getElementById(convertnmejo(on,om-i));
		if(boom(tagget,c,fs) == 1)
		{

		return 1;
		}
		else
		{

		return 0;
		}
	}
}





function convertnmejo(n,m)
{
numberrr = 10*(m-1)+(n-1); // this gets the id, called uxx 
  	if (numberrr<10)
  	{
  	uxx = '0'+numberrr+'';
  	}
  	else
  	{
  	uxx = numberrr+'';
  	}
return uxx;
}

function checkcheck(ln,lm,koloro)
{ 
testty = 1;
var inputc = capture;


// return 1 if king is in check
//part one, consider king as knight, reply check if king can move to an enemy knight position
eblon = new Array(0,0,0,0,0,0,0,0);
eblom = new Array(0,0,0,0,0,0,0,0);
lejo = new Array(0,0,0,0,0,0,0,0);

 eblon[0] = ln + 1;
 eblom[0] = lm + 2; 
 eblon[1] = ln + 1;
 eblom[1] = lm - 2; 

 eblon[2] = ln - 1;
 eblom[2] = lm + 2; 
 eblon[3] = ln - 1;
 eblom[3] = lm - 2;
 
 eblon[4] = ln + 2;
 eblom[4] = lm + 1; 
 eblon[5] = ln + 2;
 eblom[5] = lm - 1; 

 eblon[6] = ln - 2;
 eblom[6] = lm + 1; 
 eblon[7] = ln - 2;
 eblom[7] = lm - 1;

i = 0;

	while (i < 8)
 	{
        lejo[i] = knightlegal(eblon[i],eblom[i],ln,lm,koloro) * thcapture; // <---IMPLIES KNIGHTLEGAL IS PERMITTING SAME COLOR CAPTURE.....?

        	if (lejo[i] == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there NO ALWAY OPP COL!
		{

        	  tagget = document.getElementById(convertnmejo(eblon[i],eblom[i]));
                  re = tagget.alt.match(/(.+)/);

                       if  (RegExp.$1.match(/\w\w2/)){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/a\w1/)) && (aw1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/b\w1/)) && (bw1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/c\w1/)) && (cw1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/d\w1/)) && (dw1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/e\w1/)) && (ew1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/f\w1/)) && (fw1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/g\w1/)) && (gw1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/h\w1/)) && (hw1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/a\w1/)) && (ab1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/b\w1/)) && (bb1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/c\w1/)) && (cb1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/d\w1/)) && (db1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/e\w1/)) && (eb1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/f\w1/)) && (fb1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/g\w1/)) && (gb1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/h\w1/)) && (hb1p==2) ){sourcen=eblon[i];sourcem=eblom[i];return  1} // if this is a p knight, return 1
        	}

        i++;
	}
//endit part 1

// part two, consider king as pawn
if (koloro == "w")
{
       lejop = wpawnlegal(ln+1,lm-1,ln,lm,koloro,2) * thcapture;
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+1,lm-1));
                  re = tagget.alt.match(/(.+)/);
			pawncheck = 1;
		  ure = tagget.alt;
                  if  (RegExp.$1.match(/\w\w1/))
                    { 
                    if( (ure == "ab1") && (ab1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bb1") && (bb1p!=0) ){pawncheck = 0}
                    if( (ure == "cb1") && (cb1p!=0) ){pawncheck = 0}
                    if( (ure == "db1") && (db1p!=0) ){pawncheck = 0}
                    if( (ure == "eb1") && (eb1p!=0) ){pawncheck = 0}
                    if( (ure == "fb1") && (fb1p!=0) ){pawncheck = 0}
                    if( (ure == "gb1") && (gb1p!=0) ){pawncheck = 0}
                    if( (ure == "hb1") && (hb1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){sourcen=ln+1;sourcem=lm-1;return 1}   //but if it's really a pawn return check
                    }
		}
       lejop = wpawnlegal(ln-1,lm-1,ln,lm,koloro,2) * thcapture;
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-1,lm-1));
                  re = tagget.alt.match(/(.+)/);
			pawncheck = 1;
		  ure = tagget.alt;
                  if  (RegExp.$1.match(/\w\w1/))
                    { 
                    if( (ure == "ab1") && (ab1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bb1") && (bb1p!=0) ){pawncheck = 0}
                    if( (ure == "cb1") && (cb1p!=0) ){pawncheck = 0}
                    if( (ure == "db1") && (db1p!=0) ){pawncheck = 0}
                    if( (ure == "eb1") && (eb1p!=0) ){pawncheck = 0}
                    if( (ure == "fb1") && (fb1p!=0) ){pawncheck = 0}
                    if( (ure == "gb1") && (gb1p!=0) ){pawncheck = 0}
                    if( (ure == "hb1") && (hb1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){sourcen=ln-1;sourcem=lm-1;return 1}
                    }
		}
}
if (koloro == "b")
{
       lejop = bpawnlegal(ln+1,lm+1,ln,lm,koloro,2) * thcapture;
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+1,lm+1));
                  re = tagget.alt.match(/(.+)/);
		  ure = tagget.alt;
			pawncheck = 1;
                    if  (RegExp.$1.match(/\w\w1/))
                    { 
                    if( (ure == "aw1") && (aw1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bw1") && (bw1p!=0) ){pawncheck = 0}
                    if( (ure == "cw1") && (cw1p!=0) ){pawncheck = 0}
                    if( (ure == "dw1") && (dw1p!=0) ){pawncheck = 0}
                    if( (ure == "ew1") && (ew1p!=0) ){pawncheck = 0}
                    if( (ure == "fw1") && (fw1p!=0) ){pawncheck = 0}
                    if( (ure == "gw1") && (gw1p!=0) ){pawncheck = 0}
                    if( (ure == "hw1") && (hw1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){sourcen=ln+1;sourcem=lm+1;return 1}
                    }
		}
       lejop = bpawnlegal(ln-1,lm+1,ln,lm,koloro,2) * thcapture;
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-1,lm+1));
                  re = tagget.alt.match(/(.+)/);
		  ure = tagget.alt;
			pawncheck = 1;
                    if  (RegExp.$1.match(/\w\w1/))
                    { 
                    if( (ure == "aw1") && (aw1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bw1") && (bw1p!=0) ){pawncheck = 0}
                    if( (ure == "cw1") && (cw1p!=0) ){pawncheck = 0}
                    if( (ure == "dw1") && (dw1p!=0) ){pawncheck = 0}
                    if( (ure == "ew1") && (ew1p!=0) ){pawncheck = 0}
                    if( (ure == "fw1") && (fw1p!=0) ){pawncheck = 0}
                    if( (ure == "gw1") && (gw1p!=0) ){pawncheck = 0}
                    if( (ure == "hw1") && (hw1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){sourcen=ln-1;sourcem=lm+1;return 1} 
                    }  
		}
}

///// part 3 consider king as bishop
//first consider doublenegative......if meet a same color piece (thud), check is not possible
i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln-i,lm-i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-i,lm-i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){return 1} //king cannot give check, thus no need to trace source
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/))
                      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} // if this is a pro  b or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){sourcen=ln-i;sourcem=lm-i;return  1} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
// if meet an opcolor piece sen threat, return 0, check is not possible       ON THIS LINE 
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic = 0} // estas n,p,r ret 0 
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){sourcen=ln-i;sourcem=lm-i;return  1} // if this is a queen or bishop, return 1
        	}
        i++;
	}

//next consider  posnegative......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8)&& (perctsic == 1))
 	{
        lejob = thudd(ln+i,lm-i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+i,lm-i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){return 1}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/)) 
                      {
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} // if this is a pro  b or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){sourcen=ln+i;sourcem=lm-i;return  1} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/)) ){perctsic = 0} // if estas n, p or r, return 0
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){sourcen=ln+i;sourcem=lm-i;return  1} // if this is a queen or bishop, return 1

        	}
        i++;
	}

//first consider doublepostive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8)&& (perctsic == 1))
 	{
        lejob = thudd(ln+i,lm+i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{

		  tagget = document.getElementById(convertnmejo(ln+i,lm+i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){return 1}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }
                      if (RegExp.$1.match(/\w\w1/)) 
                      {  
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} // if this is a pro  b or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){sourcen=ln+i;sourcem=lm+i;return  1} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic = 0} // if estas n, p or r, return 0
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){sourcen=ln+i;sourcem=lm+i;return  1} // if this is a queen or bishop, return 1
        	}
        i++;
	}

//first consider negpostive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln-i,lm+i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-i,lm+i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){return 1}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/))
                      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} // if this is a pro  b or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){sourcen=ln-i;sourcem=lm+i;return  1} //
                       else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/))   ){perctsic = 0} // if estas n, p or r, eject
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){sourcen=ln-i;sourcem=lm+i;return  1} // if this is a queen or bishop, return 1
        	}
        i++;
	}
/// finally consider case rook

//first consider  x negative......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln-i,lm,koloro,i);
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-i,lm));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){return 1}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/)) 
                      {
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} // if this is a pro  r or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){sourcen=ln-i;sourcem=lm;return  1} //
                       else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic = 0} // if estas n, p or b, eject
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){sourcen=ln-i;sourcem=lm;return  1} // if this is a queen or rook, return 1
        	}
        i++;
	}

//next consider  y negative......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln,lm-i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{

		  tagget = document.getElementById(convertnmejo(ln,lm-i));
                  re = tagget.alt.match(/(.+)/);
                  ere = tagget.alt;

// EXEMPLARY NOTE:
//if  (RegExp.$1.match(/\w\w1/)) {alert("hotshitalpha");}
//if  (RegExp.$1.match(/\w\w1/)) {MUST BE VALID JS BUT WILL not FUNCTION BECAUSE THE CONDITIONAL EXPRESSION <-- LEFT WHICH GOES WITH THIS SET IS already ASSIGNED;}

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){return 1}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
	              if  (RegExp.$1.match(/\w\w1/)) 
                      {
                        if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;} // if this is a pro  r or q, return 1
                        else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){sourcen=ln;sourcem=lm-i;return  1;}
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }

                      if( (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/))   ){perctsic = 0;} // if estas n, p or b, eject
//
                      if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){sourcen=ln;sourcem=lm-i;return  1} // if this is a queen or rook , return 1
        	}
        i++;
	}

//first consider x postive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{

        lejob = thudd(ln+i,lm,koloro,i);
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+i,lm));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){return 1}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/))
		      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} // if this is a pro  r or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){sourcen=ln+i;sourcem=lm;return  1} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic=0} // if estas n, p or b, eject this line
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){sourcen=ln+i;sourcem=lm;return  1} // if this is a queen or rook, return 1
        	}
        i++;
	}

//finfine  y postive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln,lm+i,koloro,i); 

        	if (lejob == 1)                                //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln,lm+i));

                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
                        
			if(i==1)
			{
			 return  1;
			}
                        else
			{
			 perctsic = 0;
			}                   // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }
                      if (RegExp.$1.match(/\w\w1/))
		      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} // if this is a pro  r or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){sourcen=ln;sourcem=lm+i;return  1} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
//                  if  (RegExp.$1.match(/\w\w1/))  {perctsic = 0}                        // if estas n, p or b, eject from this line
                  if(  (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/)) ) {perctsic = 0}                         // if estas n, p or b, 
       //           if  )  {perctsic = 0}                        // if estas n, p or b, 
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){sourcen=ln;sourcem=lm+i;return  1}                   // if this is a queen or rook, return 1           
      	 	}
        i++;
	}

//if still nothing
testty = 0;

stuffage = 0;
return 0
}


function thudd(lnn,lmn,koloro,i)
{
//if(i>8){perctsic = 0;return 0}
if  ((lmn<1) || (lmn>8))  {perctsic = 0;i=9;return 0} // this is off the board
if  ((lnn<1) || (lnn>8))  {perctsic = 0;i=9;return 0} // this is off the board

		  tagget = document.getElementById(convertnmejo(lnn,lmn));
                  re = tagget.alt.match(/(.+)/);
if  (RegExp.$1.match(/\wb\d/))   
 {
 // target piece is black

 var tcolor = "b";
 }

else if  (RegExp.$1.match(/\ww\d/)) 
 {  
 //target piece is white

 var tcolor = "w";
 }

else
 {
 //target color is not germane, square is empty, nothing to capture
 return 0;
 }
	if ( tcolor == koloro )  //if target square is occupied by same color piece--> thud, prevent further invocation
        {
        i = 9;
perctsic = 0;
        return 0
        }
	if ( tcolor != koloro )  //if target square is occupied by opposite color piece
        {
        i = 9; // stop invoking thud, either it's a checker or a dud
        return 1
        }
}

function bpromo(n,m,on,om)
{
if(plive==0){return}

    prtagget = document.getElementById(convertnmejo(on,om));
    re = prtagget.alt.match(/(.+)/);
    rpawn = re;
//reassign name-ident here

	if (tyype==5)
        { 
         if(re == "ab1,ab1") {dd.elements.abp.swapimage("bb5.gif");ab1p = 5}
         if(re == "bb1,bb1") {dd.elements.bbp.swapImage("bb5.gif");bb1p = 5}
         if(re == "cb1,cb1") {dd.elements.cbp.swapImage("bb5.gif");cb1p = 5}
         if(re == "db1,db1") {dd.elements.dbp.swapImage("bb5.gif");db1p = 5}
         if(re == "eb1,eb1") {dd.elements.ebp.swapImage("bb5.gif");eb1p = 5}
         if(re == "fb1,fb1") {dd.elements.fbp.swapImage("bb5.gif");fb1p = 5}
         if(re == "gb1,gb1") {dd.elements.gbp.swapImage("bb5.gif");gb1p = 5}
         if(re == "hb1,hb1") {dd.elements.hbp.swapImage("bb5.gif");hb1p = 5}
	}
	if (tyype==4)
        {                 
         if(re == "ab1,ab1") {dd.elements.abp.swapImage("bb4.gif");ab1p = 4}
         if(re == "bb1,bb1") {dd.elements.bbp.swapImage("bb4.gif");bb1p = 4}
         if(re == "cb1,cb1") {dd.elements.cbp.swapImage("bb4.gif");cb1p = 4}
         if(re == "db1,db1") {dd.elements.dbp.swapImage("bb4.gif");db1p = 4}
         if(re == "eb1,eb1") {dd.elements.ebp.swapImage("bb4.gif");eb1p = 4}
         if(re == "fb1,fb1") {dd.elements.fbp.swapImage("bb4.gif");fb1p = 4}
         if(re == "gb1,gb1") {dd.elements.gbp.swapImage("bb4.gif");gb1p = 4}
         if(re == "hb1,hb1") {dd.elements.hbp.swapImage("bb4.gif");hb1p = 4}
	}
	if (tyype==3)
        {                 
         if(re == "ab1,ab1") {dd.elements.abp.swapImage("bb3.gif");ab1p = 3}
         if(re == "bb1,bb1") {dd.elements.bbp.swapImage("bb3.gif");bb1p = 3}
         if(re == "cb1,cb1") {dd.elements.cbp.swapImage("bb3.gif");cb1p = 3}
         if(re == "db1,db1") {dd.elements.dbp.swapImage("bb3.gif");db1p = 3}
         if(re == "eb1,eb1") {dd.elements.ebp.swapImage("bb3.gif");eb1p = 3}
         if(re == "fb1,fb1") {dd.elements.fbp.swapImage("bb3.gif");fb1p = 3}
         if(re == "gb1,gb1") {dd.elements.gbp.swapImage("bb3.gif");gb1p = 3}
         if(re == "hb1,hb1") {dd.elements.hbp.swapImage("bb3.gif");hb1p = 3}
	}
	if (tyype==2)
        {                 
         if(re == "ab1,ab1") {dd.elements.abp.swapImage("bb2.gif");ab1p = 2}
         if(re == "bb1,bb1") {dd.elements.bbp.swapImage("bb2.gif");bb1p = 2}
         if(re == "cb1,cb1") {dd.elements.cbp.swapImage("bb2.gif");cb1p = 2}
         if(re == "db1,db1") {dd.elements.dbp.swapImage("bb2.gif");db1p = 2}
         if(re == "eb1,eb1") {dd.elements.ebp.swapImage("bb2.gif");eb1p = 2}
         if(re == "fb1,fb1") {dd.elements.fbp.swapImage("bb2.gif");fb1p = 2}
         if(re == "gb1,gb1") {dd.elements.gbp.swapImage("bb2.gif");gb1p = 2}
         if(re == "hb1,hb1") {dd.elements.hbp.swapImage("bb2.gif");hb1p = 2}
	}
promote = 1;
}

/*function dcoverridew(rpawn,on,om)
{
//alert(rpawn)
    prtagget = document.getElementById(convertnmejo(on,om));
        prtagget.alt = prtagget.alt.replace(/(.+)/,rpawn); // THIS PUTS BACK THE PIECE DESCRIPTOR OF THE unjustly promoted pawn
         if(rpawn == "aw1,aw1") {dd.elements.awp.swapImage("ww1.gif");aw1p = 0}
         if(rpawn == "bw1,bw1") {dd.elements.bwp.swapImage("ww1.gif");bw1p = 0}
         if(rpawn == "cw1,cw1") {dd.elements.cwp.swapImage("ww1.gif");cw1p = 0}
         if(rpawn == "dw1,dw1") {dd.elements.dwp.swapImage("ww1.gif");dw1p = 0}
         if(rpawn == "ew1,ew1") {dd.elements.ewp.swapImage("ww1.gif");ew1p = 0}
         if(rpawn == "fw1,fw1") {dd.elements.fwp.swapImage("ww1.gif");fw1p = 0}
         if(rpawn == "gw1,gw1") {dd.elements.gwp.swapImage("ww1.gif");gw1p = 0}
         if(rpawn == "hw1,hw1") {dd.elements.hwp.swapImage("ww1.gif");hw1p = 0}
}

function dcoverrideb(rpawn,on,om)
{
//alert(rpawn)
    prtagget = document.getElementById(convertnmejo(on,om));
        prtagget.alt = prtagget.alt.replace(/(.+)/,rpawn); // THIS PUTS BACK THE PIECE DESCRIPTOR OF THE unjustly promoted pawn
         if(rpawn == "ab1,ab1") {dd.elements.abp.swapImage("bb1.gif");ab1p = 0}
         if(rpawn == "bb1,bb1") {dd.elements.bbp.swapImage("bb1.gif");bb1p = 0}
         if(rpawn == "cb1,cb1") {dd.elements.cbp.swapImage("bb1.gif");cb1p = 0}
         if(rpawn == "db1,db1") {dd.elements.dbp.swapImage("bb1.gif");db1p = 0}
         if(rpawn == "eb1,eb1") {dd.elements.ebp.swapImage("bb1.gif");eb1p = 0}
         if(rpawn == "fb1,fb1") {dd.elements.fbp.swapImage("bb1.gif");fb1p = 0}
         if(rpawn == "gb1,gb1") {dd.elements.gbp.swapImage("bb1.gif");gb1p = 0}
         if(rpawn == "hb1,hb1") {dd.elements.hbp.swapImage("bb1.gif");hb1p = 0}
}*/

function wpromo(n,m,on,om)
{
if(plive==0){return}

    prtagget = document.getElementById(convertnmejo(on,om));
    re = prtagget.alt.match(/(.+)/);
    rpawn = re;
//reassign name-ident here

	if (tyype==5)
        {                 
         if(re == "aw1,aw1") {dd.elements.awp.swapImage("ww5.gif");aw1p = 5}
         if(re == "bw1,bw1") {dd.elements.bwp.swapImage("ww5.gif");bw1p = 5}
         if(re == "cw1,cw1") {dd.elements.cwp.swapImage("ww5.gif");cw1p = 5}
         if(re == "dw1,dw1") {dd.elements.dwp.swapImage("ww5.gif");dw1p = 5}
         if(re == "ew1,ew1") {dd.elements.ewp.swapImage("ww5.gif");ew1p = 5}
         if(re == "fw1,fw1") {dd.elements.fwp.swapImage("ww5.gif");fw1p = 5}
         if(re == "gw1,gw1") {dd.elements.gwp.swapImage("ww5.gif");gw1p = 5}
         if(re == "hw1,hw1") {dd.elements.hwp.swapImage("ww5.gif");hw1p = 5}
	}
	if (tyype==4)
        {                 
         if(re == "aw1,aw1") {dd.elements.awp.swapImage("ww4.gif");aw1p = 4}
         if(re == "bw1,bw1") {dd.elements.bwp.swapImage("ww4.gif");bw1p = 4}
         if(re == "cw1,cw1") {dd.elements.cwp.swapImage("ww4.gif");cw1p = 4}
         if(re == "dw1,dw1") {dd.elements.dwp.swapImage("ww4.gif");dw1p = 4}
         if(re == "ew1,ew1") {dd.elements.ewp.swapImage("ww4.gif");ew1p = 4}
         if(re == "fw1,fw1") {dd.elements.fwp.swapImage("ww4.gif");fw1p = 4}
         if(re == "gw1,gw1") {dd.elements.gwp.swapImage("ww4.gif");gw1p = 4}
         if(re == "hw1,hw1") {dd.elements.hwp.swapImage("ww4.gif");hw1p = 4}
	}
	if (tyype==3)
        {                 
         if(re == "aw1,aw1") {dd.elements.awp.swapImage("ww3.gif");aw1p = 3}
         if(re == "bw1,bw1") {dd.elements.bwp.swapImage("ww3.gif");bw1p = 3}
         if(re == "cw1,cw1") {dd.elements.cwp.swapImage("ww3.gif");cw1p = 3}
         if(re == "dw1,dw1") {dd.elements.dwp.swapImage("ww3.gif");dw1p = 3}
         if(re == "ew1,ew1") {dd.elements.ewp.swapImage("ww3.gif");ew1p = 3}
         if(re == "fw1,fw1") {dd.elements.fwp.swapImage("ww3.gif");fw1p = 3}
         if(re == "gw1,gw1") {dd.elements.gwp.swapImage("ww3.gif");gw1p = 3}
         if(re == "hw1,hw1") {dd.elements.hwp.swapImage("ww3.gif");hw1p = 3}
	}
	if (tyype==2)                
        { 
         if(re == "aw1,aw1") {dd.elements.awp.swapImage("ww2.gif");aw1p = 2}
         if(re == "bw1,bw1") {dd.elements.bwp.swapImage("ww2.gif");bw1p = 2}
         if(re == "cw1,cw1") {dd.elements.cwp.swapImage("ww2.gif");cw1p = 2}
         if(re == "dw1,dw1") {dd.elements.dwp.swapImage("ww2.gif");dw1p = 2}
         if(re == "ew1,ew1") {dd.elements.ewp.swapImage("ww2.gif");ew1p = 2}
         if(re == "fw1,fw1") {dd.elements.fwp.swapImage("ww2.gif");fw1p = 2}
         if(re == "gw1,gw1") {dd.elements.gwp.swapImage("ww2.gif");gw1p = 2}
         if(re == "hw1,hw1") {dd.elements.hwp.swapImage("ww2.gif");hw1p = 2}
	} 

promote = 1;
}


function undoer(whiich)
{
	if(eprevert != "t"){stagget = document.getElementById(convertnmejo(n,om));stagget.alt=eprevert}

//if there exists a capture, there will exist something within stuffage
//first undo capture's VISIBLE effects    (pull from el stuffage  THIS REPLACES THE CAPTURED IMAGE
         if(stuffage == "dw5,dw5") {dd.elements.dwq.show();}
         if(stuffage == "cw3,cw3") {dd.elements.cwb.show();}
         if(stuffage == "fw3,fw3") {dd.elements.fwb.show();}

         if(stuffage == "bw2,bw2") {dd.elements.bwn.show();}
         if(stuffage == "gw2,gw2") {dd.elements.gwn.show();}
         if(stuffage == "aw4,aw4") {dd.elements.awr.show();}
         if(stuffage == "hw4,hw4") {dd.elements.hwr.show();}

         if(stuffage == "dw1,dw1") {dd.elements.dwp.show();}
         if(stuffage == "fw1,fw1") {dd.elements.fwp.show();}
         if(stuffage == "gw1,gw1") {dd.elements.gwp.show();}
         if(stuffage == "hw1,hw1") {dd.elements.hwp.show();}


         if(stuffage == "ew1,ew1") {dd.elements.ewp.show();}
         if(stuffage == "cw1,cw1") {dd.elements.cwp.show();}
         if(stuffage == "bw1,bw1") {dd.elements.bwp.show();}
         if(stuffage == "aw1,aw1") {dd.elements.awp.show();}

         if(stuffage == "db5,db5") {dd.elements.dbq.show();}
         if(stuffage == "cb3,cb3") {dd.elements.cbb.show();}
         if(stuffage == "fb3,fb3") {dd.elements.fbb.show();}

         if(stuffage == "bb2,bb2") {dd.elements.bbn.show();}
         if(stuffage == "gb2,gb2") {dd.elements.gbn.show();} 
         if(stuffage == "ab4,ab4") {dd.elements.abr.show();}
         if(stuffage == "hb4,hb4") {dd.elements.hbr.show();}

         if(stuffage == "db1,db1") {dd.elements.dbp.show();}
         if(stuffage == "fb1,fb1") {dd.elements.fbp.show();}
         if(stuffage == "gb1,gb1") {dd.elements.gbp.show();}
         if(stuffage == "hb1,hb1") {dd.elements.hbp.show();}


         if(stuffage == "eb1,eb1") {dd.elements.ebp.show();}
         if(stuffage == "cb1,cb1") {dd.elements.cbp.show();}
         if(stuffage == "bb1,bb1") {dd.elements.bbp.show();}
         if(stuffage == "ab1,ab1") {dd.elements.abp.show();}

capture = 0;       //capture should always be zero after a reversion of anything........


if (promote != 1)
{

// now put back whatever was in the terminal square BEFORE everything started
if(problem!=1)
        {  
        var batagget = document.getElementById(convertnmejo(n,m));
        batagget.alt = batagget.alt.replace(/(.+)/,auld); // THIS PUTS BACK THE PIECE DESCRIPTOR OF THE CAPTURED PIECE
        }
problem = 0;
// NOW PUT THE PIECE BACK WHERE IT BELONGS (and priveliges for unjustly moved roook......{problem}

 if  (whiich == "bb1")    
 {
	var bbp = dd.elements.bbp;
	bbp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'bb1');
 } // endit pawn bb1^^^^

 if  (whiich == "ab1")    
 {
	var abp = dd.elements.abp;
	abp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'ab1');
 } // endit pawn ab1^^^^
 if  (whiich == "cb1")    
 {
	var cbp = dd.elements.cbp;
	cbp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'cb1');
 } // endit pawn cb1^^^^
 if  (whiich == "db1")    
 {
	var dbp = dd.elements.dbp;
	dbp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'db1');
 } // endit pawn db1^^^^
 if  (whiich == "eb1")    
 {
	var ebp = dd.elements.ebp;
	ebp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'eb1');
 } // endit pawn eb1^^^^
 if  (whiich == "fb1")    
 {
	var fbp = dd.elements.fbp;
	fbp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'fb1');
 } // endit pawn fb1^^^^
 if  (whiich == "gb1")    
 {
	var gbp = dd.elements.gbp;
	gbp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'gb1');
 } // endit pawn gb1^^^^
 if  (whiich == "hb1")    
 {
	var hbp = dd.elements.hbp;
	hbp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'hb1');
 } // endit pawn hb1^^^^




//black back line
 if  (whiich == "ab4")    
 {
	var abr = dd.elements.abr;
	abr.moveTo(otruex,otruey);
if(provisib1=1) {bcastok1=1} 
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'ab4');
 } // endit rook ab4^^^^
 if  (whiich == "bb2")    
 {
	var bbn = dd.elements.bbn;
	bbn.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'bb2');
 } // endit knight bb2^^^^
 if  (whiich == "cb3")    
 {
	var cbb = dd.elements.cbb;
	cbb.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'cb3');
 } // endit bishop cb3^^^^
 if  (whiich == "gb2")    
 {
	var gbn = dd.elements.gbn;
	gbn.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'gb2');
 } // endit knight gb2^^^^
 if  (whiich == "fb3")    
 {
	var fbb = dd.elements.fbb;
	fbb.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'fb3');

 } // endit bishop fb3^^^^
 if  (whiich == "hb4")    
 {
	var hbr = dd.elements.hbr;
	hbr.moveTo(otruex,otruey);
if(provisib8=1) {bcastok8=1} 
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'hb4');
 } // endit rook hb4^^^^
 if  (whiich == "eb6")    
 {
	var ebk = dd.elements.ebk;
	ebk.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'eb6');
 } // endit k eb6^^^^
 if  (whiich == "db5")    
 {
	var dbq = dd.elements.dbq;
	dbq.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'db5');
 }


 if  (whiich == "bw1")    
 {
	var bwp = dd.elements.bwp;
	bwp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'bw1');
 } // endit pawn bw1^^^^
 if  (whiich == "aw1")    
 {
	var awp = dd.elements.awp;
	awp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'aw1');
 } // endit pawn aw1^^^^
 if  (whiich == "cw1")    
 {
	var cwp = dd.elements.cwp;
	cwp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'cw1');
 } // endit pawn cw1^^^^
 if  (whiich == "dw1")    
 {
	var dwp = dd.elements.dwp;
	dwp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'dw1');
 } // endit pawn dw1^^^^
 if  (whiich == "ew1")    
 {

	var ewp = dd.elements.ewp;
	ewp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'ew1');
 } // endit pawn ew1^^^^
 if  (whiich == "fw1")    
 {
	var fwp = dd.elements.fwp;
	fwp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'fw1');
 } // endit pawn fw1^^^^
 if  (whiich == "gw1")    
 {
	var gwp = dd.elements.gwp;
	gwp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'gw1');
 } // endit pawn gw1^^^^
 if  (whiich == "hw1")    
 {

	var hwp = dd.elements.hwp;
	hwp.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'hw1');
 } // endit pawn hw1^^^^


//white back line
 if  (whiich == "aw4")    
 {
	var awr = dd.elements.awr;
	awr.moveTo(otruex,otruey);
if(provisiw1=1) {wcastok1=1} 
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'aw4');
 } // endit rook aw4^^^^
 if  (whiich == "bw2")    
 {
	var bwn = dd.elements.bwn;
	bwn.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'bw2');
 } // endit knight bw2^^^^
 if  (whiich == "cw3")    
 {
	var cwb = dd.elements.cwb;
	cwb.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'cw3');
 } // endit bishop cw3^^^^
 if  (whiich == "gw2")    
 {
	var gwn = dd.elements.gwn;
	gwn.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'gw2');
 } // endit knight gw2^^^^
 if  (whiich == "fw3")    
 {
	var fwb = dd.elements.fwb;
	fwb.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'fw3');
 } // endit bishop fw3^^^^
 if  (whiich == "hw4")    
 {
	var hwr = dd.elements.hwr;
	hwr.moveTo(otruex,otruey);   //same as w8
 if(provisiw8=1) {wcastok8=1} 
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'hw4');
 } // endit rook hw4^^^^
 if  (whiich == "ew6")    
 {
	var ewk = dd.elements.ewk;
	ewk.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'ew6');
 } // endit k ew6^^^^
 if  (whiich == "dw5")
 {
	var dwq = dd.elements.dwq;
	dwq.moveTo(otruex,otruey);
        rktagget = document.getElementById(convertnmejo(on,om));
        rktagget.alt = rktagget.alt.replace(/(.+)/,'dw5');
 } // endit q dw5^^^^



}  // promote != 1

}  //undoer



function prise(ln,lm,koloro)
{ 

testty = 1;info = 0
// return 1 if piece at ln,lm is under threat and store jj info of ln,lm,piece
jjn = new Array(0,0,0,0,0,0,0,0,0,0,0,0);
jjm = new Array(0,0,0,0,0,0,0,0,0,0,0,0);
jjp = new Array(0,0,0,0,0,0,0,0,0,0,0,0);
jjmax = 0;
//part one, consider piece as knight, reply 1 if piece can move to an enemy knight position
eblon = new Array(0,0,0,0,0,0,0,0);
eblom = new Array(0,0,0,0,0,0,0,0);
lejo = new Array(0,0,0,0,0,0,0,0);

 eblon[0] = ln + 1;
 eblom[0] = lm + 2; 
 eblon[1] = ln + 1;
 eblom[1] = lm - 2; 

 eblon[2] = ln - 1;
 eblom[2] = lm + 2; 
 eblon[3] = ln - 1;
 eblom[3] = lm - 2;
 
 eblon[4] = ln + 2;
 eblom[4] = lm + 1; 
 eblon[5] = ln + 2;
 eblom[5] = lm - 1; 

 eblon[6] = ln - 2;
 eblom[6] = lm + 1; 
 eblon[7] = ln - 2;
 eblom[7] = lm - 1;

i = 0;
	while (i < 8)
 	{
        lejo[i] = knightlegal(eblon[i],eblom[i],ln,lm,koloro) * thcapture;

        	if (lejo[i] == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{

        	  tagget = document.getElementById(convertnmejo(eblon[i],eblom[i]));
                  re = tagget.alt.match(/(.+)/);

                       if  (RegExp.$1.match(/\w\w2/)){info=1;} // if this is a knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/a\w1/)) && (aw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/b\w1/)) && (bw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/c\w1/)) && (cw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/d\w1/)) && (dw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/e\w1/)) && (ew1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/f\w1/)) && (fw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/g\w1/)) && (gw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/h\w1/)) && (hw1p==2) ){info=1;} // if this is a p knight, return 1
//
                       if( (koloro=="w") && (RegExp.$1.match(/a\w1/)) && (ab1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/b\w1/)) && (bb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/c\w1/)) && (cb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/d\w1/)) && (db1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/e\w1/)) && (eb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/f\w1/)) && (fb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/g\w1/)) && (gb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/h\w1/)) && (hb1p==2) ){info=1;} // if this is a p knight, return 1
        	}
         if (info == 1)

	 {

jjn[jjmax]=eblon[i];

jjm[jjmax]=eblom[i];
jjp[jjmax]="n";

jjmax++;
info=0
	 }
        i++;
	}
//endit part 1

// part two, consider piece as pawn    COLOR PROBLEMS HERE????
if (koloro == "w")
{
       lejop = wpawnlegal(ln+1,lm-1,ln,lm,koloro,2) * thcapture;
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+1,lm-1));
                  re = tagget.alt.match(/(.+)/);
			pawncheck = 1;
		  ure = tagget.alt;
                  if  (RegExp.$1.match(/\wb1/))
                    { 
                    if( (ure == "ab1") && (ab1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bb1") && (bb1p!=0) ){pawncheck = 0}
                    if( (ure == "cb1") && (cb1p!=0) ){pawncheck = 0}
                    if( (ure == "db1") && (db1p!=0) ){pawncheck = 0}
                    if( (ure == "eb1") && (eb1p!=0) ){pawncheck = 0}
                    if( (ure == "fb1") && (fb1p!=0) ){pawncheck = 0}
                    if( (ure == "gb1") && (gb1p!=0) ){pawncheck = 0}
                    if( (ure == "hb1") && (hb1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){jjn[jjmax]=ln+1;jjm[jjmax]=lm-1;jjp[jjmax]="p";jjmax++;}   //but if it's really a pawn return check
                    }
		}
       lejop = wpawnlegal(ln-1,lm-1,ln,lm,koloro,2) * thcapture;
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-1,lm-1));
                  re = tagget.alt.match(/(.+)/);
			pawncheck = 1;
		  ure = tagget.alt;
                  if  (RegExp.$1.match(/\wb1/))
                    { 
                    if( (ure == "ab1") && (ab1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bb1") && (bb1p!=0) ){pawncheck = 0}
                    if( (ure == "cb1") && (cb1p!=0) ){pawncheck = 0}
                    if( (ure == "db1") && (db1p!=0) ){pawncheck = 0}
                    if( (ure == "eb1") && (eb1p!=0) ){pawncheck = 0}
                    if( (ure == "fb1") && (fb1p!=0) ){pawncheck = 0}
                    if( (ure == "gb1") && (gb1p!=0) ){pawncheck = 0}
                    if( (ure == "hb1") && (hb1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){jjn[jjmax]=ln-1;jjm[jjmax]=lm-1;jjp[jjmax]="p";jjmax++;}
                    }
		}
}
if (koloro == "b")
{
       lejop = bpawnlegal(ln+1,lm+1,ln,lm,koloro,2) * thcapture;
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+1,lm+1));
                  re = tagget.alt.match(/(.+)/);
		  ure = tagget.alt;
			pawncheck = 1;
                    if  (RegExp.$1.match(/\ww1/))
                    { 
                    if( (ure == "aw1") && (aw1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bw1") && (bw1p!=0) ){pawncheck = 0}
                    if( (ure == "cw1") && (cw1p!=0) ){pawncheck = 0}
                    if( (ure == "dw1") && (dw1p!=0) ){pawncheck = 0}
                    if( (ure == "ew1") && (ew1p!=0) ){pawncheck = 0}
                    if( (ure == "fw1") && (fw1p!=0) ){pawncheck = 0}
                    if( (ure == "gw1") && (gw1p!=0) ){pawncheck = 0}
                    if( (ure == "hw1") && (hw1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){jjn[jjmax]=ln+1;jjm[jjmax]=lm+1;jjp[jjmax]="p";jjmax++;}
                    }
		}
       lejop = bpawnlegal(ln-1,lm+1,ln,lm,koloro,2) * thcapture;
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-1,lm+1));
                  re = tagget.alt.match(/(.+)/);
		  ure = tagget.alt;
			pawncheck = 1;
                    if  (RegExp.$1.match(/\ww1/))
                    { 
                    if( (ure == "aw1") && (aw1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bw1") && (bw1p!=0) ){pawncheck = 0}
                    if( (ure == "cw1") && (cw1p!=0) ){pawncheck = 0}
                    if( (ure == "dw1") && (dw1p!=0) ){pawncheck = 0}
                    if( (ure == "ew1") && (ew1p!=0) ){pawncheck = 0}
                    if( (ure == "fw1") && (fw1p!=0) ){pawncheck = 0}
                    if( (ure == "gw1") && (gw1p!=0) ){pawncheck = 0}
                    if( (ure == "hw1") && (hw1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){jjn[jjmax]=ln-1;jjm[jjmax]=lm+1;jjp[jjmax]="p";jjmax++;} 
                    }  
		}
}

///// part 3 consider piece as bishop
//first consider doublenegative......if meet a same color piece (thud), check is not possible
i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln-i,lm-i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-i,lm-i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){jjn[jjmax]=ln-1;jjm[jjmax]=lm-1;jjp[jjmax]="k";jjmax++;} 
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/))
                      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="k";jjmax++;} //  a pro  b or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
// if meet an opcolor piece sen threat, return 0, check is not possible       ON THIS LINE 
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic = 0} // estas n,p,r ret 0 
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // if this is a queen or bishop, return 1
        	}
        i++;
	}

//next consider  posnegative......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8)&& (perctsic == 1))
 	{
        lejob = thudd(ln+i,lm-i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+i,lm-i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){jjn[jjmax]=ln+1;jjm[jjmax]=lm-1;jjp[jjmax]="k";jjmax++;}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/)) 
                      {
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //  pro  b or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/)) ){perctsic = 0} // if estas n, p or r, return 0
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //  a q bishop, return 1

        	}
        i++;
	}

//first consider doublepostive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8)&& (perctsic == 1))
 	{
        lejob = thudd(ln+i,lm+i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+i,lm+i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){jjn[jjmax]=ln+1;jjm[jjmax]=lm+1;jjp[jjmax]="k";jjmax++;}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }
                      if (RegExp.$1.match(/\w\w1/)) 
                      {  
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //  pro  b or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic = 0} // if estas n, p or r, return 0
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // qu or bishop, return 1
        	}
        i++;
	}

//first consider negpostive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln-i,lm+i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-i,lm+i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){jjn[jjmax]=ln-1;jjm[jjmax]=lm+1;jjp[jjmax]="k";jjmax++;}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/))
                      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //pro  b or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/))   ){perctsic = 0} // if estas n, p or r, eject
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // a q or bishop, ret 1
        	}
        i++;
	}
/// finally consider case rook

//first consider  x negative......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln-i,lm,koloro,i);
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-i,lm));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){jjn[jjmax]=ln-1;jjm[jjmax]=lm;jjp[jjmax]="k";jjmax++;}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/)) 
                      {
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //  pro  r or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic = 0} // if estas n, p or b, eject
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //  queen or rook, return 1
        	}
        i++;
	}

//next consider  y negative......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln,lm-i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln,lm-i));
                  re = tagget.alt.match(/(.+)/);
                  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="k";jjmax++;}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
	              if  (RegExp.$1.match(/\w\w1/)) 
                      {
                        if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;} // pro  r or q, ret 1
                        else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }

                      if( (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/))   ){perctsic = 0;} // if estas n, p or b, eject
//
                      if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;} //  queen or rook , ret 1
        	}
        i++;
	}

//first consider x postive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{

        lejob = thudd(ln+i,lm,koloro,i);
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+i,lm));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			if(i==1){jjn[jjmax]=ln+1;jjm[jjmax]=lm;jjp[jjmax]="k";jjmax++;}
                        else{perctsic = 0} // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }  
                      if (RegExp.$1.match(/\w\w1/))
		      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //  pro  r or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic=0} // if estas n, p or b, eject this line
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //  queen or rook, return 1
        	}
        i++;
	}

//finfine  y postive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln,lm+i,koloro,i); 

        	if (lejob == 1)                                //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln,lm+i));

                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
                        
			if(i==1)
			{
			 jjn[jjmax]=ln;jjm[jjmax]=lm+1;jjp[jjmax]="k";jjmax++;
			}
                        else
			{
			 perctsic = 0;
			}                   // if this is a king out of range, return 0 (se ekz, a queen behind it....)
                      }
                      if (RegExp.$1.match(/\w\w1/))
		      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} // pro  r or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
//                  if  (RegExp.$1.match(/\w\w1/))  {perctsic = 0}                        // if estas n, p or b, eject from this line
                  if(  (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/)) ) {perctsic = 0}                         // if estas n, p or b, 
       //           if  )  {perctsic = 0}                        // if estas n, p or b, 
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;}    // queen or rook, ret 1  
      	 	}
        i++;
	}

//if still nothing

if (jjmax>>0){

var captex = document.createTextNode(jjmax+"  " +"n: "+jjn[0]+" m: " + jjm[0] + " piece: "+ jjp[0]+"  " +"n: "+jjn[1]+" m: " + jjm[1] + " piece: "+ jjp[1]+"  " +"n: "+jjn[2]+" m: " + jjm[2] + " piece: "+ jjp[2]+"  " +"n: "+jjn[3]+" m: " + jjm[3] + " piece: "+ jjp[3]+"  " +"n: "+jjn[4]+" m: " + jjm[4] + " piece: "+ jjp[5]+"  " +"n: "+jjn[5]+" m: " + jjm[5] + " piece: "+ jjp[6]+"  " +"n: "+jjn[6]+" m: " + jjm[6] + " piece: "+ jjp[7]+"  " +"n: "+jjn[7]+" m: " + jjm[7] + " piece: "+ jjp[7]);


//  document.getElementById("alert").appendChild(captex);
//document.getElementById("alert").innerHTML = captex;

return 1}
testty = 0;
return 0

}


function disprise(ln,lm,koloro)
{ 
//alert("disprise called" + ln+"  "+lm+koloro)
//function to interpose upon interstitial ln,lm
 
testty = 1;info = 0
// return 1 if piece at ln,lm is under threat and store jj info of ln,lm,piece
jjn = new Array(0,0,0,0,0,0,0,0,0,0,0,0);
jjm = new Array(0,0,0,0,0,0,0,0,0,0,0,0);
jjp = new Array(0,0,0,0,0,0,0,0,0,0,0,0);
jjmax = 0;
//part one, consider piece as knight, reply 1 if piece can move to an enemy knight position
eblon = new Array(0,0,0,0,0,0,0,0);
eblom = new Array(0,0,0,0,0,0,0,0);
lejo = new Array(0,0,0,0,0,0,0,0);

 eblon[0] = ln + 1;
 eblom[0] = lm + 2; 
 eblon[1] = ln + 1;
 eblom[1] = lm - 2; 

 eblon[2] = ln - 1;
 eblom[2] = lm + 2; 
 eblon[3] = ln - 1;
 eblom[3] = lm - 2;
 
 eblon[4] = ln + 2;
 eblom[4] = lm + 1; 
 eblon[5] = ln + 2;
 eblom[5] = lm - 1; 

 eblon[6] = ln - 2;
 eblom[6] = lm + 1; 
 eblon[7] = ln - 2;
 eblom[7] = lm - 1;

i = 0;
//alert("prewhile")
	while (i < 8)
 	{
//alert("i am i" +i)
        lejo[i] = knightlegal(eblon[i],eblom[i],ln,lm,koloro) * thcapture;

        	if (lejo[i] == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{

        	  tagget = document.getElementById(convertnmejo(eblon[i],eblom[i]));
                  re = tagget.alt.match(/(.+)/);

                       if  (RegExp.$1.match(/\w\w2/)){info=1;} // if this is a knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/a\w1/)) && (aw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/b\w1/)) && (bw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/c\w1/)) && (cw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/d\w1/)) && (dw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/e\w1/)) && (ew1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/f\w1/)) && (fw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/g\w1/)) && (gw1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="b") && (RegExp.$1.match(/h\w1/)) && (hw1p==2) ){info=1;} // if this is a p knight, return 1
//
                       if( (koloro=="w") && (RegExp.$1.match(/a\w1/)) && (ab1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/b\w1/)) && (bb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/c\w1/)) && (cb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/d\w1/)) && (db1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/e\w1/)) && (eb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/f\w1/)) && (fb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/g\w1/)) && (gb1p==2) ){info=1;} // if this is a p knight, return 1
                       if( (koloro=="w") && (RegExp.$1.match(/h\w1/)) && (hb1p==2) ){info=1;} // if this is a p knight, return 1
        	
         if (info == 1)

	 {

jjn[jjmax]=eblon[i];

jjm[jjmax]=eblom[i];
jjp[jjmax]="n";

jjmax++;
info=0
	 }
 //       i++;
	}
i++;
      }
//alert("postwhile")
//endit part 1

// part two, consider piece as noncappawn (mopawn) pawn cannot __capture__ in order to interpose, must move to "capture"
if (koloro == "w")
{
       lejop = wmopawnlegal(ln,lm-1,ln,lm,koloro) 
         	if (lejop == 1) //it is possible to move to that square (square simply exists)      that there is an oppcolor piece there is assumed (actually REQUIRED)
		{

		  tagget = document.getElementById(convertnmejo(ln,lm-1));
                  re = tagget.alt.match(/(.+)/);
			pawncheck = 1;
		  ure = tagget.alt;
                  if  (RegExp.$1.match(/\wb1/))
                    { 
                    if( (ure == "ab1") && (ab1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bb1") && (bb1p!=0) ){pawncheck = 0}
                    if( (ure == "cb1") && (cb1p!=0) ){pawncheck = 0}
                    if( (ure == "db1") && (db1p!=0) ){pawncheck = 0}
                    if( (ure == "eb1") && (eb1p!=0) ){pawncheck = 0}
                    if( (ure == "fb1") && (fb1p!=0) ){pawncheck = 0}
                    if( (ure == "gb1") && (gb1p!=0) ){pawncheck = 0}
                    if( (ure == "hb1") && (hb1p!=0) ){pawncheck = 0}
// nothing to check the pawn's color below???????
                    if(pawncheck!=0){jjn[jjmax]=ln;jjm[jjmax]=lm-1;jjp[jjmax]="p";jjmax++;}   //but if it's really a pawn return "capture"
                    }
		}

       lejop = wmopawnlegal(ln,lm-2,ln,lm,koloro)

         	if (lejop == 1) //it is possible to move to that square (square simply exists)      that there is an oppcolor piece there is assumed (actually REQUIRED)
		{
		  tagget = document.getElementById(convertnmejo(ln,lm-2));
                  re = tagget.alt.match(/(.+)/);
			pawncheck = 1;
		  ure = tagget.alt;
                  if  (RegExp.$1.match(/\wb1/))
                    { 
                    if( (ure == "ab1") && (ab1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bb1") && (bb1p!=0) ){pawncheck = 0}
                    if( (ure == "cb1") && (cb1p!=0) ){pawncheck = 0}
                    if( (ure == "db1") && (db1p!=0) ){pawncheck = 0}
                    if( (ure == "eb1") && (eb1p!=0) ){pawncheck = 0}
                    if( (ure == "fb1") && (fb1p!=0) ){pawncheck = 0}
                    if( (ure == "gb1") && (gb1p!=0) ){pawncheck = 0}
                    if( (ure == "hb1") && (hb1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){jjn[jjmax]=ln;jjm[jjmax]=lm-2;jjp[jjmax]="p";jjmax++;}   //but if it's really a pawn return "capture"
                    }
		}
}
if (koloro == "b")
{
       lejop = bmopawnlegal(ln,lm+1,ln,lm,koloro) 
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln,lm+1));
                  re = tagget.alt.match(/(.+)/);
		  ure = tagget.alt;
			pawncheck = 1;
                    if  (RegExp.$1.match(/\ww1/))
                    { 
                    if( (ure == "aw1") && (aw1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bw1") && (bw1p!=0) ){pawncheck = 0}
                    if( (ure == "cw1") && (cw1p!=0) ){pawncheck = 0}
                    if( (ure == "dw1") && (dw1p!=0) ){pawncheck = 0}
                    if( (ure == "ew1") && (ew1p!=0) ){pawncheck = 0}
                    if( (ure == "fw1") && (fw1p!=0) ){pawncheck = 0}
                    if( (ure == "gw1") && (gw1p!=0) ){pawncheck = 0}
                    if( (ure == "hw1") && (hw1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){jjn[jjmax]=ln;jjm[jjmax]=lm+1;jjp[jjmax]="p";jjmax++;}
                    }
		}

       lejop = bmopawnlegal(ln,lm+2,ln,lm,koloro) 
         	if (lejop == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln,lm+2));
                  re = tagget.alt.match(/(.+)/);
		  ure = tagget.alt;
			pawncheck = 1;
                    if  (RegExp.$1.match(/\ww1/))
                    { 
                    if( (ure == "aw1") && (aw1p!=0) ){pawncheck = 0} //if it's a promoted pawn, don't treat it as a pawn
                    if( (ure == "bw1") && (bw1p!=0) ){pawncheck = 0}
                    if( (ure == "cw1") && (cw1p!=0) ){pawncheck = 0}
                    if( (ure == "dw1") && (dw1p!=0) ){pawncheck = 0}
                    if( (ure == "ew1") && (ew1p!=0) ){pawncheck = 0}
                    if( (ure == "fw1") && (fw1p!=0) ){pawncheck = 0}
                    if( (ure == "gw1") && (gw1p!=0) ){pawncheck = 0}
                    if( (ure == "hw1") && (hw1p!=0) ){pawncheck = 0}
                    if(pawncheck!=0){jjn[jjmax]=ln;jjm[jjmax]=lm+2;jjp[jjmax]="p";jjmax++;}
                    }
		}
}

///// part 3 consider piece as bishop
//first consider doublenegative......if meet a same color piece (thud), check is not possible
i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln-i,lm-i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-i,lm-i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      { perctsic = 0;       //king cannot interpose to prevent check
                      }  
                      if (RegExp.$1.match(/\w\w1/))
                      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="k";jjmax++;} //  a pro  b or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
// if meet an opcolor piece sen threat, return 0, check is not possible       ON THIS LINE 
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic = 0} // estas n,p,r ret 0 
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){jjn[jjmax]=ln-i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // if this is a queen or bishop, return 1
        	}
        i++;
	}

//next consider  posnegative......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8)&& (perctsic == 1))
 	{
        lejob = thudd(ln+i,lm-i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+i,lm-i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      { perctsic = 0;
                      }  
                      if (RegExp.$1.match(/\w\w1/)) 
                      {
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //  pro  b or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/)) ){perctsic = 0} // if estas n, p or r, return 0
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){jjn[jjmax]=ln+i;jjm[jjmax]=lm-i;jjp[jjmax]="b";jjmax++;} //  a q bishop, return 1

        	}
        i++;
	}

//first consider doublepostive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8)&& (perctsic == 1))
 	{
        lejob = thudd(ln+i,lm+i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+i,lm+i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      {
                        perctsic = 0
                      }
                      if (RegExp.$1.match(/\w\w1/)) 
                      {  
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //  pro  b or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic = 0} // if estas n, p or r, return 0
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){jjn[jjmax]=ln+i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // qu or bishop, return 1
        	}
        i++;
	}

//first consider negpostive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln-i,lm+i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-i,lm+i));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
                        perctsic = 0 
                      }  
                      if (RegExp.$1.match(/\w\w1/))
                      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //pro  b or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==3))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} //
                       else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w4/)) || (RegExp.$1.match(/\w\w2/))   ){perctsic = 0} // if estas n, p or r, eject
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w3/))    ){jjn[jjmax]=ln-i;jjm[jjmax]=lm+i;jjp[jjmax]="b";jjmax++;} // a q or bishop, ret 1
        	}
        i++;
	}
/// finally consider case rook

//first consider  x negative......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln-i,lm,koloro,i);
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln-i,lm));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;

                      if (RegExp.$1.match(/\w\w6/)) 
                      {
                        perctsic = 0
                      }  
                      if (RegExp.$1.match(/\w\w1/)) 
                      {
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //  pro  r or q, ret 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic = 0} // if estas n, p or b, eject
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){jjn[jjmax]=ln-i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //  queen or rook, return 1
        	}
        i++;
	}

//next consider  y negative......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln,lm-i,koloro,i); 
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln,lm-i));
                  re = tagget.alt.match(/(.+)/);
                  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      {
                        perctsic = 0
                      }  
	              if  (RegExp.$1.match(/\w\w1/)) 
                      {
                        if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;} // pro  r or q, ret 1
                        else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;}
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }

                      if( (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/))   ){perctsic = 0;} // if estas n, p or b, eject
//
                      if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){jjn[jjmax]=ln;jjm[jjmax]=lm-i;jjp[jjmax]="r";jjmax++;} //  queen or rook , ret 1
        	}
        i++;
	}

//first consider x postive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln+i,lm,koloro,i);
        	if (lejob == 1) //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln+i,lm));
                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      {
                        perctsic = 0
                      }  
                      if (RegExp.$1.match(/\w\w1/))
		      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //  pro  r or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
                  if(  (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/))  ){perctsic=0} // if estas n, p or b, eject this line
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){jjn[jjmax]=ln+i;jjm[jjmax]=lm;jjp[jjmax]="r";jjmax++;} //  queen or rook, return 1
        	}
        i++;
	}

//finfine  y postive......if meet a same color piece (thud), check is not possible
 i = 1;
perctsic = 1;
	while ((i < 8) && (perctsic == 1))
 	{
        lejob = thudd(ln,lm+i,koloro,i); 

        	if (lejob == 1)                                //it is possible to move to that square (square simply exists) and there is an oppcolor piece there
		{
		  tagget = document.getElementById(convertnmejo(ln,lm+i));

                  re = tagget.alt.match(/(.+)/);
		  ere = tagget.alt;
                      if (RegExp.$1.match(/\w\w6/)) 
                      {
			 perctsic = 0;
                      }
                      if (RegExp.$1.match(/\w\w1/))
		      { 
                       if( (koloro=="b") && (ere == "aw1") && ((aw1p==5)||(aw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} // pro  r or q, return 1
                       else if( (koloro=="b") && (ere == "bw1") && ((bw1p==5)||(bw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "cw1") && ((cw1p==5)||(cw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="b") && (ere == "dw1") && ((dw1p==5)||(dw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "ew1") && ((ew1p==5)||(ew1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "fw1") && ((fw1p==5)||(fw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "gw1") && ((gw1p==5)||(gw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="b") && (ere == "hw1") && ((hw1p==5)||(hw1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} // 
                       else if( (koloro=="w") && (ere == "ab1") && ((ab1p==5)||(ab1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "bb1") && ((bb1p==5)||(bb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "cb1") && ((cb1p==5)||(cb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "db1") && ((db1p==5)||(db1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "eb1") && ((eb1p==5)||(eb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "fb1") && ((fb1p==5)||(fb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "gb1") && ((gb1p==5)||(gb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                       else if( (koloro=="w") && (ere == "hb1") && ((hb1p==5)||(hb1p==4))  ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;} //
                        else {perctsic = 0} // if it's REALLY  a pawn or ANOTHER type of promoted beast, eject
                      }
//                  if  (RegExp.$1.match(/\w\w1/))  {perctsic = 0}                        // if estas n, p or b, eject from this line
                  if(  (RegExp.$1.match(/\w\w3/)) || (RegExp.$1.match(/\w\w2/)) ) {perctsic = 0}                         // if estas n, p or b, 
                  if(  (RegExp.$1.match(/\w\w5/)) || (RegExp.$1.match(/\w\w4/))    ){jjn[jjmax]=ln;jjm[jjmax]=lm+i;jjp[jjmax]="r";jjmax++;}    // queen or rook, ret 1  
      	 	}
        i++;
	}

//summary
//alert("jjmax"+jjmax)
if (jjmax>>0){

var captex = document.createTextNode("blocks "+jjmax+"  " +"n: "+jjn[0]+" m: " + jjm[0] + " piece: "+ jjp[0]+"  " +"n: "+jjn[1]+" m: " + jjm[1] + " piece: "+ jjp[1]+"  " +"n: "+jjn[2]+" m: " + jjm[2] + " piece: "+ jjp[2]+"  " +"n: "+jjn[3]+" m: " + jjm[3] + " piece: "+ jjp[3]+"  " +"n: "+jjn[4]+" m: " + jjm[4] + " piece: "+ jjp[5]+"  " +"n: "+jjn[5]+" m: " + jjm[5] + " piece: "+ jjp[6]+"  " +"n: "+jjn[6]+" m: " + jjm[6] + " piece: "+ jjp[7]+"  " +"n: "+jjn[7]+" m: " + jjm[7] + " piece: "+ jjp[7]);

// document.getElementById("moves").appendChild(captex);
//document.getElementById("moves").innerHTML = captex;

return 1}
testty = 0;
return 0

}



function freezer()
{
cj=1;ck=1;cf=0;
thefreeze = new Array(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);

	while(cj<9)
	{		
	 while(ck<9)
       {tagget = document.getElementById(convertnmejo(cj,ck));ck++;thefreeze[cf]=tagget.alt;cf++;}     
	cj++;ck=1; 
	}
holdwn=wpalacen;holdwm=wpalacem;holdbn=bpalacen;holdbm=bpalacem

}



function posrevert()
{
cj=1;ck=1;cf=0;
	while(cj<9)
	{		
	 while(ck<9){tagget = document.getElementById(convertnmejo(cj,ck));ck++;tagget.alt=thefreeze[cf];cf++}
	cj++;ck=1; 
	}
wpalacen=holdwn;wpalacem=holdwm;bpalacen=holdbn;bpalacem=holdbm
}



function hypot(nn,nm,oldn,oldm)
{
//alert("hypothetical position");
prisetagget = document.getElementById(convertnmejo(nn,nm));

sourcetagget = document.getElementById(convertnmejo(oldn,oldm));
//alert("i am"+prisetagget.alt);

if (prisetagget.alt == "ew6"){wpalacen=oldn;wpalacem=oldm}
if (prisetagget.alt == "eb6"){bpalacen=oldn;bpalacem=oldm}

sourcetagget.alt = prisetagget.alt;
prisetagget.alt = prisetagget.alt.replace(/(.+)/,'0');
//alert("i am now"+prisetagget.alt);

}


function proximate(ajntint)
{
if (ajntint == "b"){laejon=bpalacen;laejom=bpalacem}else{laejon=wpalacen;laejom=wpalacem}
//document.getElementById("alert").innerHTML = 'pointone ';
//alert(bombout+ajntint);
nminus=laejon-1;
nplus=laejon+1;
mminus=laejom-1;
mplus=laejom+1;
//alert(nminus+" "+nplus+" "+mminus+" "+mplus);
	if((9 > nminus)&&(nminus > 0))
	{
	  if (ally(nminus,laejom,ajntint) == 0)
  	  {
          duckki = hypot(laejon,laejom,nminus,laejom)  //this will change PALACE variables, not calling variables
          if(ajntint == "b") {ypercts = checkcheck(bpalacen,bpalacem,"b");}else{ypercts = checkcheck(wpalacen,wpalacem,"w");} // if ypercts >0 this hypot cannot be legal, checkmate still possible
             if (ypercts == 0)
              {
              duckki = posrevert();bombout = 1;
              }else{duckki=posrevert()}
  	  }
	}
 
	if((9 > nplus)&&(nplus > 0)) // && (bombout == 0)              ADD ON      ADD ON    ADD  ON       ADD ON     ADD ON        ADD ON        ADD ON
	{
	  if (ally(nplus,laejom,ajntint) == 0)
  	  {
          duckki = hypot(laejon,laejom,nplus,laejom)
	  if(ajntint == "b") {ypercts = checkcheck(bpalacen,bpalacem,"b");}else{ypercts = checkcheck(wpalacen,wpalacem,"w");}
//          ypercts = checkcheck(nplus,laejom,ajntint); 
             if (ypercts == 0)
              {
              duckki = posrevert();bombout = 1;
              }else{duckki=posrevert()}
  	  }
	} 

	if((9 > mminus)&&(mminus > 0))
	{
	  if (ally(laejon,mminus,ajntint) == 0)
  	  {
          duckki = hypot(laejon,laejom,laejon,mminus)
	  if(ajntint == "b") {ypercts = checkcheck(bpalacen,bpalacem,"b");}else{ypercts = checkcheck(wpalacen,wpalacem,"w");}
//          ypercts = checkcheck(laejon,laejom,ajntint);
             if (ypercts == 0)
              {
              duckki = posrevert();bombout = 1;
              }else{duckki=posrevert()}
 	  }
	}
 
	if((9 > mplus)&&(mplus > 0))
	{
//alert("lae:"+laejon+" "+mplus);
	  if (ally(laejon,mplus,ajntint) == 0)
          {
//alert("aye");
          duckki = hypot(laejon,laejom,laejon,mplus)
  //        ypercts = checkcheck(laejon,laejom,ajntint);
	  if(ajntint == "b") {ypercts = checkcheck(bpalacen,bpalacem,"b");}else{ypercts = checkcheck(wpalacen,wpalacem,"w");}
//alert("aye"+ypercts);
             if (ypercts == 0)
              {
              duckki = posrevert();bombout = 1;
              }else{duckki=posrevert()}
  	  }
	} 
//
	if( (9 > nminus)&&(nminus > 0) && (9 > mminus)&&(mminus >0) )
	{
	  if (ally(nminus,mminus,ajntint) == 0)
  	  {
          duckki = hypot(laejon,laejom,nminus,mminus)
	  if(ajntint == "b") {ypercts = checkcheck(bpalacen,bpalacem,"b");}else{ypercts = checkcheck(wpalacen,wpalacem,"w");}
//          ypercts = checkcheck(laejon,laejom,ajntint);
             if (ypercts == 0)
              {
              duckki = posrevert();bombout = 1;
              }else{duckki=posrevert()}
 	  }
	}
 
	if((9 > nplus)&&(nplus > 0) && (9 > mminus)&&(mminus >0) )
	{
	  if (ally(nplus,mminus,ajntint) == 0)
  	  {
          duckki = hypot(laejon,laejom,nplus,mminus)
	  if(ajntint == "b") {ypercts = checkcheck(bpalacen,bpalacem,"b");}else{ypercts = checkcheck(wpalacen,wpalacem,"w");}
 //         ypercts = checkcheck(laejon,laejom,ajntint);
             if (ypercts == 0)
              {
              duckki = posrevert();bombout = 1;
              }else{duckki=posrevert()}
 	  }
	} 

	if((9 > nminus)&&(nminus > 0) && (9 > mplus)&&(mplus >0) )
	{
	  if (ally(nminus,mplus,ajntint) == 0)
          {
          duckki = hypot(laejon,laejom,nminus,mplus)
	  if(ajntint == "b") {ypercts = checkcheck(bpalacen,bpalacem,"b");}else{ypercts = checkcheck(wpalacen,wpalacem,"w");}
//          ypercts = checkcheck(laejon,laejom,ajntint);
             if (ypercts == 0)
              {
              duckki = posrevert();bombout = 1;
              }else{duckki=posrevert()}
          }
	}
 
	if((9 > nplus)&&(nplus > 0)  && (9 > mplus)&&(mplus >0) )
	{
	  if (ally(nplus,mplus,ajntint) == 0)
  	  {
          duckki = hypot(laejon,laejom,nplus,mplus)
	  if(ajntint == "b") {ypercts = checkcheck(bpalacen,bpalacem,"b");}else{ypercts = checkcheck(wpalacen,wpalacem,"w");}
//          ypercts = checkcheck(laejon,laejom,ajntint);
             if (ypercts == 0)
              {
              duckki = posrevert();bombout = 1;
              }else{duckki=posrevert()}
 	  }
	}
//alert("escape?"+bombout);
}

// now the clocks

whinittime=-1;
whstarted = 0;
blinittime=-1;
blstarted = 0;

whinstance =0;
ytimewh = 0;
blinstance =0;
ytimebl = 0;

wseconds = 0;
wminutes = 0;
whours = 0;

bseconds = 0;
bminutes = 0;
bhours = 0;

whaseconds = 0;
whaminutes = 0;
whahours = 0;
deltimewh= 0;
whdseconds = 0;
whdminutes = 0;
whdhours = 0;
whstseconds = 0;
whstminutes = 0;
whsthours = 0;

whddseconds = 0;
whddminutes = 0;
whddhours = 0;

blaseconds = 0;
blaminutes = 0;
blahours = 0;
deltimebl= 0;
bldseconds = 0;
bldminutes = 0;
bldhours = 0;
blstseconds = 0;
blstminutes = 0;
blsthours = 0;

blddseconds = 0;
blddminutes = 0;
blddhours = 0;

noclock = -1;

blonce=0;
whonce=0;

beghourswh=0;
begminuteswh=0;
begsecondswh=0;

beghoursbl=0;
begminutesbl=0;
begsecondsbl=0;


function unclock()
{
   document.getElementById("blclock").innerHTML = "" ;
   document.getElementById("whclock").innerHTML = "" ;
   document.getElementById("noclock").innerHTML = "" ;
   document.getElementById("setclock").innerHTML = "" ;
noclock = 1;
}

function enableclock()
{
selhw = document.shourw.selhourw;
beghourswh = selhw.options[selhw.selectedIndex].value;

selmw = document.sminw.selminw;
begminuteswh = selmw.options[selmw.selectedIndex].value;

selsw = document.ssecw.selsecw;
begsecondswh = selsw.options[selsw.selectedIndex].value;

selhb = document.shourb.selhourb;
beghoursbl = selhb.options[selhb.selectedIndex].value;

selmb = document.sminb.selminb;
begminutesbl = selmb.options[selmb.selectedIndex].value;

selsb = document.ssecb.selsecb;
begsecondsbl = selsb.options[selsb.selectedIndex].value;

   document.getElementById("blclock").innerHTML = "" ;
   document.getElementById("whclock").innerHTML = "" ;
   document.getElementById("noclock").innerHTML = "" ;
   document.getElementById("setclock").innerHTML = "" ;
noclock = 0;
}

function whtimer()
{
if(whinittime < 0){return}
	if(whinstance)
	{ 

	 clearTimeout(whinstance);

	 whinstance = 0;
	}

ytimewh = new Date();

deltimewh = ytimewh - whinittime;

ytimewh.setTime(deltimewh);   //set ytime to epoch+deltime

wseconds = ytimewh.getSeconds();   // (rel epoch)
wminutes = ytimewh.getMinutes();
whours = ytimewh.getHours();
 if(whours>17)
 {whahours=whsthours-18+whours;  // correct for zone -6
 }else
 {whahours=whsthours+whours+6;}
whaminutes=whstminutes+wminutes;
whaseconds=whstseconds+wseconds;
//whahours = whahours;


//whdhours = beghourswh - whahours;
//whdminutes = begminuteswh - whaminutes;
//whdseconds = begsecondswh - whaseconds;

if(whaseconds>59){whaminutes++;whaseconds=0+(whaseconds-60)}
if(whaminutes>59){whahours++;whaminutes=0+(whaminutes-60)}
 
wbghours = parseInt(beghourswh)-whahours;
wbgminutes = parseInt(begminuteswh)-whaminutes;
wbgseconds = parseInt(begsecondswh)-whaseconds;

if (wbgseconds<0){wbgminutes--;wbgseconds=wbgseconds+60;}else{wbgseconds = wbgseconds}
if (wbgminutes<0){wbghours--;wbgminutes=wbgminutes+60;}else{wbgminutes = wbgminutes}

if( (wbghours>0) || (wbgminutes>0) || (wbgseconds>0) )
{
//   document.getElementById("whorlog").innerHTML = whdhours+":"+whddminutes+":"+ whddseconds ;

if ((wbgseconds<10)&& (wbgminutes>10)){ document.getElementById("whorlog").innerHTML =  wbghours+ ":"+wbgminutes+":0"+wbgseconds;}
else if ((wbgminutes<10) && (wbgseconds>9)){ document.getElementById("whorlog").innerHTML =  wbghours+ ":0"+wbgminutes+":"+wbgseconds;}
else if ((wbgminutes<10) && (wbgseconds<10)){ document.getElementById("whorlog").innerHTML =  wbghours+ ":0"+wbgminutes+":0"+wbgseconds;}
else{
 document.getElementById("whorlog").innerHTML =  wbghours+ ":"+wbgminutes+":"+wbgseconds;}


  if(whinittime != 0) 
  {
   whinstance = setTimeout("whtimer()",1000);
  }
}
if( (wbghours==0) && (wbgminutes==0) && (wbgseconds==0) ){document.getElementById("alert").innerHTML = "WHITE TIME expired" ;whreset();expiredet=1}
}




function whstart()
{
//	document.getElementById("whorlog").innerHTML = "warhog";
if (noclock >0){return;}
if (whstarted >0){return;}
	if(whinittime < 0)
	{
//	document.getElementById("whorlog").innerHTML = "00:00:00"

	whsthours=0;
	whstminutes=0;
	whstseconds=0;
	}
whstarted = 1;
whinittime = new Date();

if(blinittime != 0){
whinstance = setTimeout("whtimer()",100);}

}







function whreset()
{
whinittime = new Date();
//if(whinstance){alert("lert");}
document.getElementById("whorlog").innerHTML = "00:00:00"
whsthours=0;
whstminutes=0;
whstseconds=0;
whdhours=0;
whdminutes=0;
whdseconds=0;
whinittime=-1;
whstarted = 0;
}



function whstop()
{
clearTimeout(whinstance);
whinstance=null;
whsthours=whahours;
whstminutes=whaminutes;
whstseconds = whaseconds;
whstarted = 0;
}



function bltimer()
{
if(blinittime < 0){return}
	if(blinstance)
	{ 

	 clearTimeout(blinstance);

	 blinstance = 0;
	}

ytimebl = new Date();

deltimebl = ytimebl - blinittime;

ytimebl.setTime(deltimebl);   //set ytime to epoch+deltime

bseconds = ytimebl.getSeconds();   // (rel epoch)
bminutes = ytimebl.getMinutes();
bhours = ytimebl.getHours();
 if(bhours>17)
 {blahours=blsthours-18+bhours;  // correct for zone -6
 }else
 {blahours=blsthours+bhours+6;}
blaminutes=blstminutes+bminutes;
blaseconds=blstseconds+bseconds;

if(blaseconds>59){blaminutes++;blaseconds=0+(blaseconds-60)}
if(blaminutes>59){blahours++;blaminutes=0+(blaminutes-60)}

blghours = parseInt(beghoursbl) - blahours;
blgminutes = parseInt(begminutesbl) - blaminutes;
blgseconds = parseInt(begsecondsbl) - blaseconds;




if(blgseconds<0){blgminutes--;blgseconds=0+(60+blgseconds)}
if(blgminutes<0){blghours--;blgminutes=0+(60+blgminutes)}


if (blgseconds<0){blgminutes--;blgseconds=blgseconds+60;}else{blgseconds = blgseconds}
if (blgminutes<0){blghours--;blgminutes=blgminutes+60;}else{blgminutes = blgminutes}



if( (blghours>0) || (blgminutes>0) || (blgseconds>0) )
{
//   document.getElementById("bhorlog").innerHTML = bldhours+":"+bldminutes+":"+ bldseconds ;

if ((blgseconds<10)&& (blgminutes>10)){ document.getElementById("bhorlog").innerHTML =  blghours+ ":"+blgminutes+":0"+blgseconds;}
else if ((blgminutes<10) && (blgseconds>9)){ document.getElementById("bhorlog").innerHTML =  blghours+ ":0"+blgminutes+":"+blgseconds;}
else if ((blgminutes<10) && (blgseconds<10)){ document.getElementById("bhorlog").innerHTML =  blghours+ ":0"+blgminutes+":0"+blgseconds;}
else{
 document.getElementById("bhorlog").innerHTML =  blghours+ ":"+blgminutes+":"+blgseconds;}



if(blinittime != 0){

blinstance = setTimeout("bltimer()",1000);}

}
if( (blghours==0) && (blgminutes==0) && (blgseconds==0) ){document.getElementById("alert").innerHTML = "BLACK TIME expired" ;blreset();expiredet=1}
}





function blstart()
{
if (noclock < 0){unclock();}
if (noclock >0){return;}
if (blstarted >0){return;}
	if(blinittime < 0)
	{
	document.getElementById("bhorlog").innerHTML = "00:00:00"
	blsthours=0;
	blstminutes=0;
	blstseconds=0;
	}
blstarted = 1;
blinittime = new Date();
blinstance = setTimeout("bltimer()",100);
}


function blreset()
{
blinittime = new Date();
clearTimeout(blinstance);
document.getElementById("bhorlog").innerHTML = "00:00:00"
blsthours=0;
blstminutes=0;
blstseconds=0;
blinittime=-1;
blstarted = 0;
}



function blstop()
{
clearTimeout(blinstance);
blinstance=null;
blsthours=blahours;
blstminutes=blaminutes;
blstseconds = blaseconds;
blstarted = 0;
}