function addLoadListener(fn){
  if (typeof window.addEventListener != 'undefined'){
    window.addEventListener('load', fn, false);
  } else if (typeof document.addEventListener != 'undefined'){
    document.addEventListener('load', fn, false);
  } else if (typeof window.attachEvent != 'undefined'){
    window.attachEvent('onload', fn);
  } else {
    var oldfn = window.onload;
    if (typeof window.onload != 'function'){
      window.onload = fn;
    } else {
      window.onload = function(){
        oldfn();
        fn();
      };
    }
  }
}

function attachEventListener(target, eventType, functionRef, capture){
  if (typeof target.addEventListener != "undefined"){
    target.addEventListener(eventType, functionRef, capture);
  } else if (typeof target.attachEvent != "undefined"){
    target.attachEvent("on" + eventType, functionRef);
  } else {
    eventType = "on" + eventType;
    if (typeof target[eventType] == "function"){
      var oldListener = target[eventType];
      target[eventType] = function(){
        oldListener();
        return  functionRef();
      }
    } else {
      target[eventType] = functionRef;
    }
  }
  return true; 
}
function detachEventListener(target, eventType, functionRef, capture){
  if (typeof target.removeEventListener != "undefined"){
    target.removeEventListener(eventType, functionRef, capture);
  } else if (typeof target.detachEvent != "undefined"){
    var functionString = eventType + functionRef;
    target.detachEvent("on" + eventType, target[functionString]);
    target["e" + functionString] = null;
    target[functionString] = null;
  }else{
    target["on" + eventType] = null;
  }
  return true;
}

var conH = 0;

function getViewportSize(){
  var size = [0, 0];
  if (typeof window.innerWidth != 'undefined'){
    size = [ window.innerWidth, window.innerHeight ];
  }
  else if (typeof document.documentElement != 'undefined'
      && typeof document.documentElement.clientWidth != 'undefined'
      && document.documentElement.clientWidth != 0){
    size = [ document.documentElement.clientWidth, document.documentElement.clientHeight ];
  } else {
    size = [ document.getElementsByTagName('body')[0].clientWidth, document.getElementsByTagName('body')[0].clientHeight
    ];
  }
  return size;
}



function getInternetExplorerVersion()
// Returns the version of Internet Explorer or a -1
// (indicating the use of another browser).
{
  var rv = -1; // Return value assumes failure.
  if (navigator.appName == 'Microsoft Internet Explorer')
  {
    var ua = navigator.userAgent;
    var re  = new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})");
    if (re.exec(ua) != null)
      rv = parseFloat( RegExp.$1 );
  }
  return rv;
}

function applyStyles(){
var sizee = getViewportSize();//Get screen height
if(typeof document.styleSheets != "undefined"){//applying styles here
	var printStyleSheet = document.styleSheets[0];
	var printRules = null;
		if(typeof printStyleSheet.rules != "undefined"){
			printRules = printStyleSheet.rules;
		}else{
			printRules = printStyleSheet.cssRules;
		}
		for(var i=0;i<printRules.length;i++){
				if(printRules[i].selectorText.toLowerCase() == "body"){
					printRules[i].style.backgroundPosition = "center " + ((0.509*sizee[1])-250) + "px";
					break;
				}
			}
		for(var i=0;i<printRules.length;i++){
			if (navigator.appVersion.indexOf("MSIE") == -1){
				if(printRules[i].selectorText.toLowerCase() == "#middle"){
					printRules[i].style.display = "table-cell";
					break;
				}
			}
			}
		for(var i=0;i<printRules.length;i++){
			if(printRules[i].selectorText.toLowerCase() == "html > body"){
				printRules[i].style.height = sizee[1] + "px";
				printRules[i].style.backgroundPosition = "center " + ((0.503*sizee[1])-250) + "px";
				if (navigator.appVersion.indexOf("KHTML") != -1){
					//printRules[i].style.backgroundPosition = "center top";
				}
				break;
			}
		}
	}
	addLoadListener(navPos);
}

applyStyles();

attachEventListener(window, "resize", applyStyles, false);
attachEventListener(window, "resize", navPos, false);

function navPos(){
var sizee = getViewportSize();//Get screen height
if(typeof document.styleSheets != "undefined"){//applying styles here
	var printStyleSheet = document.styleSheets[0];
	var printRules = null;
		if(typeof printStyleSheet.rules != "undefined"){
			printRules = printStyleSheet.rules;
		}else{
			printRules = printStyleSheet.cssRules;
		}	
		for(var i=0;i<printRules.length;i++){ //NOTE - need to adjust top margin of h1 and height of insie
				if(printRules[i].selectorText.toLowerCase() == "#inner"){
				if(sizee[1]>520){
					moveNavOut();
					printRules[i].style.marginTop = -85 + "px";
				}else{
					moveNavIn()
					printRules[i].style.marginTop = 0 + "px";
				}
					break;
			}
		}
	var printStyleSheet = document.styleSheets[1];
	printRules = null;
		if(typeof printStyleSheet.rules != "undefined"){
			printRules = printStyleSheet.rules;
		}else{
			printRules = printStyleSheet.cssRules;
		}	
		for(var i=0;i<printRules.length;i++){ 
				if(printRules[i].selectorText.toLowerCase() == "#nav"){
					printRules[i].style.visibility = "visible";
					break;
				}
		}
}
}

function moveNavOut(){
	var nvv;
	if(nvv = document.getElementById("nav")){
	var parent = nvv.parentNode;
	var removedChild = parent.removeChild(nvv);
	var newLoc = document.getElementById("outer");
	var parentB = newLoc.parentNode;
	var newNav = parentB.insertBefore(removedChild, newLoc);
	}
}

function moveNavIn(){
	var nvv;
	if(nvv = document.getElementById("nav")){
	var parent = nvv.parentNode;
	var removedChild = parent.removeChild(nvv);
	var newLoc = document.getElementById("content");
	var parentB = newLoc.parentNode;
	var newNav = parentB.insertBefore(removedChild, newLoc);
	}
}

function sortNumber(a,b)
{
return a - b;
}

var els = new Array(////name//id-class/opacity lower limit/sensitivity of mouse
					new Array("nav","id",0.005,3), new Array("lnks","name",0.8,1), new Array("scrollbar","id",0.05,4)
					);

function elsfades(event){
	fadeingmouse(event,els);
}
	
function fadeingmouse(event,arr){	
	var op=0;
	var sp=0;
	for(var i=0;i<arr.length;i++){		
		 op = arr[i][2];
		 sp = arr[i][3];
	if(arr[i][1]=="id"){
		 var theEl = new Array(document.getElementById(arr[i][0]));
	}else{
		if(arr[i][1]=="name"){
		 var theEl = document.getElementsByName(arr[i][0]);
		}
	}
if(theEl[0]!=null){
	for(var k=0; k<theEl.length; k++){
	var mini = 0;
	  if (typeof event == "undefined"){event = window.event;}
  var scrollingPosition = getScrollingPosition();
  var cursorPosition = [0, 0];
  if (typeof event.pageX != "undefined" && typeof event.x != "undefined"){
    cursorPosition[0] = event.pageX;
    cursorPosition[1] = event.pageY;
  }else{
    cursorPosition[0] = event.clientX + scrollingPosition[0];
    cursorPosition[1] = event.clientY + scrollingPosition[1];
  }
	var curposX = cursorPosition[0];
	var curposY = cursorPosition[1];
			var pos = getPosition(theEl[k]); 
			var Ypos = pos[1]*1;//positionY
			var Xpos = pos[0]*1;
			var p = new Array(4);//the four corners of each element
			 p[0] = [Xpos,Ypos];
			 p[1] = [Xpos+theEl[k].offsetWidth,Ypos];
			 p[2] = [Xpos, Ypos + theEl[k].offsetHeight];
			 p[3] = [Xpos+theEl[k].offsetWidth, Ypos + theEl[k].offsetHeight];
			var dist = new Array(4); //Array of distances
			var mn = new Array(4);
if(curposX  >p[0][0] && curposX <p[1][0]){
	if(curposY >p[0][1] &&  curposY <p[2][1]){//if mouseover element
		mini = 0;
	}else{//if mouse vertically below or above element
		mini = Math.min(Math.abs(p[0][1]-curposY),Math.abs(p[3][1]-curposY));
	}
}else{//if mouse either side of element
	if(curposY >p[0][1] &&  curposY <p[2][1]){//if horizontally centred
		mini = Math.min(Math.abs(p[0][0]-curposX),Math.abs(p[1][0]-curposX));
	}else{//get min distance to nearest point
		for(var j=0;j<p.length;j++){
					dist[j] = Math.sqrt(Math.pow(p[j][0] - curposX, 2) + Math.pow(p[j][1] - curposY, 2));
		}//find nearest point - ie minimum distance - end of for loop
		mn = dist.sort(sortNumber);
		mini = mn[0];
	}
}//end of conditionals
		var opacit = 100/(100+(mini*sp));
		if(opacit<op){opacit=op;}
		var ot = fademouse(theEl[k]);
		setfade(theEl[k],opacit,ot);
		}
	}
	}
	return true;			
}

function getScrollingPosition(){
  var position = [0, 0];
  if(typeof window.pageYOffset != 'undefined'){
    position = [ window.pageXOffset, window.pageYOffset ];
  }
  if(typeof document.documentElement.scrollTop != 'undefined' && document.documentElement.scrollTop > 0){
    position = [ document.documentElement.scrollLeft, document.documentElement.scrollTop ];
  } else if(typeof document.body.scrollTop != 'undefined'){
    position = [ document.body.scrollLeft, document.body.scrollTop ];
  }
  return position;
}

addLoadListener(initfocus);

function initfocus(){
	attachEventListener(document, "click", setafocus, true);	
}

function setafocus(){
	if(document.getElementById("toplink")){
		var toplk = document.getElementById("toplink");
		 toplk.focus();
		var cont = document.getElementById("content");
		attachEventListener(cont, "click", setafocus, true);
		if(gll=document.getElementById("gallery_wrap")!='undefined'){
			attachEventListener(gll, "click", setafocus, true);
			//attachEventListener(document, "click", setafocus, true);	
		}
	}
}

function initMouse(){
	  		attachEventListener(document, "mousemove", elsfades, true);
}

function getPosition(theElement){
  var positionX = 0;
  var positionY = 0;
  while (theElement != null){
    positionX += theElement.offsetLeft;
    positionY += theElement.offsetTop;
    theElement = theElement.offsetParent;
  }
  return [positionX, positionY];
}

var fps = 20;

function fade(img, time, dir){
  if(img = document.getElementById(img)){
  var steps = time * fps;
  if(time<0.5){
	  steps=1;
  }
  if (typeof img.style.opacity != 'undefined'){
    var otype = 'w3c';
  }else if (typeof img.style.MozOpacity != 'undefined'){
    otype = 'moz';
  } else if (typeof img.style.KhtmlOpacity != 'undefined'){
    otype = 'khtml';
  } else if (typeof img.filters == 'object'){
    otype = (img.filters.length > 0
        && typeof img.filters.alpha == 'object'
        && typeof img.filters.alpha.opacity == 'number')
        ? 'ie' : 'none';
  } else { otype = 'none'; }
  if (otype != 'none'){
    if (dir == 'out') { 
	dofade(steps, img, 1, false, otype); 
	} else { 
	dofade(steps, img, 0, true, otype); 
	}
  }
}
}

function fademouse(img){
  if (typeof img.style.opacity != 'undefined'){
    var otype = 'w3c';
  } else if (typeof img.style.MozOpacity != 'undefined'){
    otype = 'moz';
  } else if (typeof img.style.KhtmlOpacity != 'undefined'){
    otype = 'khtml';
  } else if (typeof img.filters == 'object'){
    otype = (img.filters.length > 0
        && typeof img.filters.alpha == 'object'
        && typeof img.filters.alpha.opacity == 'number')
        ? 'ie' : 'none';
  }else { otype = 'none'; }
  if (otype != 'none'){
	return otype;
  }
}

function dofade(steps, img, value, targetvisibility, otype){
  value += (targetvisibility ? 1 : -1) / steps;
  if (targetvisibility ? value > 1 : value < 0)
      value = targetvisibility ? 1 : 0;
  setfade(img, value, otype);
  if (targetvisibility ? value < 1 : value > 0){
    setTimeout(function(){dofade(steps, img, value, targetvisibility, otype);}, 1000 / fps);
  }
}

function setfade(img, value, otype){
  switch(otype){
    case 'ie':
      img.filters.alpha.opacity = value * 100;
      break;
    case 'khtml':
      img.style.KhtmlOpacity = value;
      break;
    case 'moz':
      img.style.MozOpacity = (value == 1 ? 0.9999999 : value);
      break;
    default:
      img.style.opacity = (value == 1 ? 0.9999999 : value);
  }
}

//  dw_event.js version date Apr 2008
//  basic event handling file from dyn-web.com

var dw_Event = {
  
    add: function(obj, etype, fp, cap) {
        cap = cap || false;
        if (obj.addEventListener) obj.addEventListener(etype, fp, cap);
        else if (obj.attachEvent) obj.attachEvent("on" + etype, fp);
    }, 

    remove: function(obj, etype, fp, cap) {
        cap = cap || false;
        if (obj.removeEventListener) obj.removeEventListener(etype, fp, cap);
        else if (obj.detachEvent) obj.detachEvent("on" + etype, fp);
    }, 
    
    DOMit: function(e) { 
        e = e? e: window.event; // e IS passed when using attachEvent though ...
        if (!e.target) e.target = e.srcElement;
        if (!e.preventDefault) e.preventDefault = function () { e.returnValue = false; return false; }
        if (!e.stopPropagation) e.stopPropagation = function () { e.cancelBubble = true; }
        return e;
    },
    
    getTarget: function(e) {
        e = dw_Event.DOMit(e); var tgt = e.target; 
        if (tgt.nodeType != 1) tgt = tgt.parentNode; // safari...
        return tgt;
    }
    
}

// Danny Goodman's version (DHTML def ref)
function addLoadEvent(func) {
    var oldQueue = window.onload? window.onload: function() {};
    window.onload = function() {
        oldQueue();
        func();
    }
}

/*************************************************************************
    This code is from Dynamic Web Coding at dyn-web.com
    Copyright 2001-2008 by Sharon Paine 
    See Terms of Use at www.dyn-web.com/business/terms.php
    regarding conditions under which you may use this code.
    This notice must be retained in the code as is!
    
    version date: Feb 2009 (opera mousewheel)
    printEnabled property added Nov 2008
*************************************************************************/

// horizId only needed for horizontal scrolling
function dw_scrollObj(wndoId, lyrId, horizId) {
    var wn = document.getElementById(wndoId);
    this.id = wndoId; dw_scrollObj.col[this.id] = this;
    this.animString = "dw_scrollObj.col." + this.id;
    this.load(lyrId, horizId);
    
    if (wn.addEventListener) {//mzilla
	if(document.forms.length<1){
		wn.addEventListener('keydown',dw_scrollObj.doOnKeyDn,false);
	}
        wn.addEventListener('DOMMouseScroll',dw_scrollObj.doOnMouseWheel,false);
    }else{//
    wn.onmousewheel = dw_scrollObj.doOnMouseWheel;
	if(document.forms.length<1){
	wn.onkeydown = dw_scrollObj.doOnKeyDn;
	}
	}
}

// If set true, position scrolling content div's absolute in style sheet (see documentation)
// set false in download file with position absolute set in .load method due to support issues 
// (Too many people remove the specification and then complain that the code doesn't work!)
dw_scrollObj.printEnabled = false;

dw_scrollObj.defaultSpeed = dw_scrollObj.prototype.speed = 100; // default for mouseover or mousedown scrolling
dw_scrollObj.defaultSlideDur = dw_scrollObj.prototype.slideDur = 500; // default duration of glide onclick

dw_scrollObj.isSupported = function () {
    if ( document.getElementById && document.getElementsByTagName 
         && document.addEventListener || document.attachEvent ) {
        return true;
    }
    return false;
}

dw_scrollObj.col = {}; // collect instances

// custom events 
dw_scrollObj.prototype.on_load = function() {} // when dw_scrollObj initialized or new layer loaded
dw_scrollObj.prototype.on_scroll = function() {}
dw_scrollObj.prototype.on_scroll_start = function() {}
dw_scrollObj.prototype.on_scroll_stop = function() {} // when scrolling has ceased (mouseout/up)
dw_scrollObj.prototype.on_scroll_end = function() {} // reached end
dw_scrollObj.prototype.on_update = function() {} // called in updateDims

dw_scrollObj.prototype.on_glidescroll = function() {}
dw_scrollObj.prototype.on_glidescroll_start = function() {}
dw_scrollObj.prototype.on_glidescroll_stop = function() {} // destination (to/by) reached
dw_scrollObj.prototype.on_glidescroll_end = function() {} // reached end

dw_scrollObj.prototype.load = function(lyrId, horizId) {
    var wndo, lyr;
    if (this.lyrId) { // layer currently loaded?
        lyr = document.getElementById(this.lyrId);
        lyr.style.visibility = "hidden";
    }
    this.lyr = lyr = document.getElementById(lyrId); // hold this.lyr?
    if ( !dw_scrollObj.printEnabled ) {
        this.lyr.style.position = 'absolute'; 
    }
    this.lyrId = lyrId; // hold id of currently visible layer
    this.horizId = horizId || null; // hold horizId for update fn
    wndo = document.getElementById(this.id);
    this.y = 0; this.x = 0; this.shiftTo(0,0);
    this.getDims(wndo, lyr); 
    lyr.style.visibility = "visible";
    this.ready = true; this.on_load(); 
}

dw_scrollObj.prototype.shiftTo = function(x, y) {
    if (this.lyr) {
        this.lyr.style.left = (this.x = x) + "px"; 
        this.lyr.style.top = (this.y = y) + "px";
    }
}

dw_scrollObj.prototype.getX = function() { return this.x; }
dw_scrollObj.prototype.getY = function() { return this.y; }

dw_scrollObj.prototype.getDims = function(wndo, lyr) { 
    this.wd = this.horizId? document.getElementById( this.horizId ).offsetWidth: lyr.offsetWidth;
    this.maxX = (this.wd - wndo.offsetWidth > 0)? this.wd - wndo.offsetWidth: 0;
    this.maxY = (lyr.offsetHeight - wndo.offsetHeight > 0)? lyr.offsetHeight - wndo.offsetHeight: 0;
}

dw_scrollObj.prototype.updateDims = function() {
    var wndo = document.getElementById(this.id);
    var lyr = document.getElementById( this.lyrId );
    this.getDims(wndo, lyr);
    this.on_update();
}

// for mouseover/mousedown scrolling
dw_scrollObj.prototype.initScrollVals = function(deg, speed) {
    if (!this.ready) return; 
    if (this.timerId) {
        clearInterval(this.timerId); this.timerId = 0;
    }
    this.speed = speed || dw_scrollObj.defaultSpeed;
    this.fx = (deg == 0)? -1: (deg == 180)? 1: 0;
    this.fy = (deg == 90)? 1: (deg == 270)? -1: 0;
    this.endX = (deg == 90 || deg == 270)? this.x: (deg == 0)? -this.maxX: 0; 
    this.endY = (deg == 0 || deg == 180)? this.y: (deg == 90)? 0: -this.maxY;
    this.lyr = document.getElementById(this.lyrId);
    this.lastTime = new Date().getTime();
    this.on_scroll_start(this.x, this.y);  
    this.timerId = setInterval(this.animString + ".scroll()", 10);    
}

dw_scrollObj.prototype.scroll = function() {
    var now = new Date().getTime();
    var d = (now - this.lastTime)/1000 * this.speed;
    if (d > 0) { 
        var x = this.x + Math.round(this.fx * d); var y = this.y + Math.round(this.fy * d);
        if ( ( this.fx == -1 && x > -this.maxX ) || ( this.fx == 1 && x < 0 ) || 
                ( this.fy == -1 && y > -this.maxY ) || ( this.fy == 1 && y < 0 ) ) 
       {
            this.lastTime = now;
            this.shiftTo(x, y);
            this.on_scroll(x, y);
        } else {
            clearInterval(this.timerId); this.timerId = 0;
            this.shiftTo(this.endX, this.endY);
            this.on_scroll(this.endX, this.endY);
            this.on_scroll_end(this.endX, this.endY);
        }
    }
}

// when scrolling has ceased (mouseout/up)
dw_scrollObj.prototype.ceaseScroll = function() {
    if (!this.ready) return;
    if (this.timerId) {
        clearInterval(this.timerId); this.timerId = 0; 
    }
    this.on_scroll_stop(this.x, this.y); 
}

// glide onclick scrolling
dw_scrollObj.prototype.initScrollByVals = function(dx, dy, dur) {
    if ( !this.ready || this.sliding ) return;
    this.startX = this.x; this.startY = this.y;
    this.destX = this.destY = this.distX = this.distY = 0;
    if (dy < 0) {
        this.distY = (this.startY + dy >= -this.maxY)? dy: -(this.startY  + this.maxY);
    } else if (dy > 0) {
        this.distY = (this.startY + dy <= 0)? dy: -this.startY;
    }
    if (dx < 0) {
        this.distX = (this.startX + dx >= -this.maxX)? dx: -(this.startX + this.maxX);
    } else if (dx > 0) {
        this.distX = (this.startX + dx <= 0)? dx: -this.startX;
    }
    this.destX = this.startX + this.distX; this.destY = this.startY + this.distY;
    this.glideScrollPrep(this.destX, this.destY, dur);
}

dw_scrollObj.prototype.initScrollToVals = function(destX, destY, dur) {
    if ( !this.ready || this.sliding ) return;
    this.startX = this.x; this.startY = this.y;
    this.destX = -Math.max( Math.min(destX, this.maxX), 0);
    this.destY = -Math.max( Math.min(destY, this.maxY), 0);
    this.distY = this.destY - this.startY;
    this.distX = this.destX - this.startX;
    this.glideScrollPrep(this.destX, this.destY, dur);
}

dw_scrollObj.prototype.glideScrollPrep = function(destX, destY, dur) {
    this.slideDur = (typeof dur == 'number')? dur: dw_scrollObj.defaultSlideDur;
    this.per = Math.PI/(2 * this.slideDur); this.sliding = true;
    this.lyr = document.getElementById(this.lyrId); 
    this.startTime = new Date().getTime();
    this.timerId = setInterval(this.animString + ".doGlideScroll()",10);
    this.on_glidescroll_start(this.startX, this.startY);
}

dw_scrollObj.prototype.doGlideScroll = function() {
    var elapsed = new Date().getTime() - this.startTime;
    if (elapsed < this.slideDur) {
        var x = this.startX + Math.round( this.distX * Math.sin(this.per*elapsed) );
        var y = this.startY + Math.round( this.distY * Math.sin(this.per*elapsed) );
        this.shiftTo(x, y); 
        this.on_glidescroll(x, y);
    } else {	// if time's up
        clearInterval(this.timerId); this.timerId = 0; this.sliding = false;
        this.shiftTo(this.destX, this.destY);
        this.on_glidescroll(this.destX, this.destY);
        this.on_glidescroll_stop(this.destX, this.destY);
        // end of axis reached ? 
        if ( this.distX && (this.destX == 0 || this.destX == -this.maxX) 
          || this.distY && (this.destY == 0 || this.destY == -this.maxY) ) { 
            this.on_glidescroll_end(this.destX, this.destY);
        } 
    }
}

//  resource: http://adomas.org/javascript-mouse-wheel/
dw_scrollObj.handleMouseWheel = function(id, delta) {
    var wndo = dw_scrollObj.col[id];
    var x = wndo.x;
    var y = wndo.y;
    wndo.on_scroll_start(x,y);
    var ny;
    ny = 12  * delta + y
    ny = (ny < 0 && ny >= -wndo.maxY)? ny: (ny < -wndo.maxY)? -wndo.maxY: 0;
    wndo.shiftTo(x, ny);
    wndo.on_scroll(x, ny);
}
//referenced at line 829
dw_scrollObj.doOnKeyDn = function(e){//gets keycode and passes to fn that handles this info & 412
	if(!e){
		e = window.event;
	}
	var kC = e.keyCode;
	if(kC!='undefined'){
		dw_scrollObj.handleKeys(this.id, kC);
	}
}

dw_scrollObj.handleKeys = function(id, keyCd) {//if key pressed is supposed to scroll the element
	var wnd = dw_scrollObj.col[id];
	var wH = document.getElementById("inside").offsetHeight;
	var ins = document.getElementById("content").offsetHeight;
	var limitt = wH-ins-45;
	var x = wnd.x;
	var y = wnd.y;
	var updns = 5;
	var keyCD = keyCD;
	wnd.on_scroll_start(x,y);
	switch(keyCd){

	case 38://up arrow - same as mouseover_up
	y=y+updns;
	break;
	
	case 33://pageup key
	if(y+wH >= 0){//if scroll - windowheight
		y=0;
	}else{
		y=y+wH;
	}
	break
	
	case 40://down arrow - same as mouseover_down
	y=y-updns;
	break;
	
	case 34://pagedown key
	if(y-wH<limitt){//if one press gives value less than content heit
		y=limitt+1;
	}else{
		y=y-wH+25; //25px to review last line of previous text in new position
	}
	break;
	
	case 36://home  - same as scrollTo 0
	y=0;
	break;
	
	case 35://end - scrollTo 100%
	y=limitt+1;
	break;
	
	default:
	return true;
	break;
	}
	if(y>limitt && y<=0){
	wnd.shiftTo(x,y);
	wnd.on_scroll(x,y);
	}
}

dw_scrollObj.doOnMouseWheel = function(e) {
    var delta = 0;
    if (!e) e = window.event;
    if (e.wheelDelta) { /* IE/Opera. */
        delta = e.wheelDelta/120;
        //if (window.opera) delta = -delta; // not needed as of v 9.2
    } else if (e.detail) { // Mozilla 
        delta = -e.detail/3;
    }
    if (delta) { // > 0 up, < 0 down
        dw_scrollObj.handleMouseWheel(this.id, delta);
    }
    if (e.preventDefault) e.preventDefault();
    e.returnValue = false;
}

dw_scrollObj.GeckoTableBugFix = function() {} // no longer need old bug fix


// Get position of el within layer (oCont) sOff: 'left' or 'top'
// Assumes el is within oCont
function dw_getLayerOffset(el, oCont, sOff) {
    var off = "offset" + sOff.charAt(0).toUpperCase() + sOff.slice(1);
    var val = el[off];
    while ( (el = el.offsetParent) != oCont ) 
        val += el[off];
    var clientOff = off.replace("offset", "client");
    if ( el[clientOff] ) val += el[clientOff];
    return val;
}

/*************************************************************************
    This code is from Dynamic Web Coding at dyn-web.com
    Copyright 2001-2008 by Sharon Paine 
    See Terms of Use at www.dyn-web.com/business/terms.php
    regarding conditions under which you may use this code.
    This notice must be retained in the code as is!
    
    for use with dw_scroll.js - provides scrollbar functionality
    version date: Aug 2008
        bug fixed in .setBarSize
*************************************************************************/

function dw_Slidebar(barId, trackId, axis, x, y) {
    var bar = document.getElementById(barId);
    var track = document.getElementById(trackId);
    this.barId = barId; this.trackId = trackId;
    this.axis = axis; this.x = x || 0; this.y = y || 0;
    dw_Slidebar.col[this.barId] = this;
    this.bar = bar;  this.shiftTo(x, y);
    
    // hold for setBarSize  
	if(track!=null){
    this.trkHt = track.offsetHeight; 
    this.trkWd = track.offsetWidth; 
	
    if (axis == 'v') {
        this.maxY = this.trkHt - bar.offsetHeight - y; 
        this.maxX = x; this.minX = x; this.minY = y;
    } else {
        this.maxX = this.trkWd - bar.offsetWidth - x; 
        this.minX = x; this.maxY = y; this.minY = y;
    }
    }
    this.on_drag_start =  this.on_drag =   this.on_drag_end = 
    this.on_slide_start = this.on_slide =  this.on_slide_end = function() {}
    if(bar!=null){
    bar.onmousedown = dw_Slidebar.prepDrag; 
    // pass barId to obtain instance from dw_Slidebar.col
    track.onmousedown = function(e) { dw_Slidebar.prepSlide(barId, e); }
	}
    this.bar = bar = null; track = null; 
}

dw_Slidebar.col = {}; // hold instances for global access
dw_Slidebar.current = null; // hold current instance

dw_Slidebar.prototype.slideDur = 500;

// track received onmousedown event
dw_Slidebar.prepSlide = function(barId, e) {
    var _this = dw_Slidebar.col[barId];
    dw_Slidebar.current = _this;
    var bar = _this.bar = document.getElementById(barId);
    
    if ( _this.timer ) { clearInterval(_this.timer); _this.timer = 0; }
    e = e? e: window.event;
    
    e.offX = (typeof e.layerX != "undefined")? e.layerX: e.offsetX;
    e.offY = (typeof e.layerY != "undefined")? e.layerY: e.offsetY;
    _this.startX = parseInt(bar.style.left); _this.startY = parseInt(bar.style.top);

    if (_this.axis == "v") {
        _this.destX = _this.startX;
        _this.destY = (e.offY < _this.startY)? e.offY: e.offY - bar.offsetHeight;
        _this.destY = Math.min( Math.max(_this.destY, _this.minY), _this.maxY );
    } else {
        _this.destX = (e.offX < _this.startX)? e.offX: e.offX - bar.offsetWidth;
        _this.destX = Math.min( Math.max(_this.destX, _this.minX), _this.maxX );
        _this.destY = _this.startY;
    }
    _this.distX = _this.destX - _this.startX; _this.distY = _this.destY - _this.startY;
    _this.per = Math.PI/(2 * _this.slideDur);
    _this.slideStartTime = new Date().getTime();
    _this.on_slide_start(_this.startX, _this.startY);
    _this.timer = setInterval("dw_Slidebar.doSlide()", 10);
}

dw_Slidebar.doSlide = function() {
    var _this = dw_Slidebar.current;
    var elapsed = new Date().getTime() - _this.slideStartTime;
    if (elapsed < _this.slideDur) {
        var x = _this.startX + _this.distX * Math.sin(_this.per*elapsed);
        var y = _this.startY + _this.distY * Math.sin(_this.per*elapsed);
        _this.shiftTo(x,y);
        _this.on_slide(x, y);
    } else {	// if time's up
        clearInterval(_this.timer);
        _this.shiftTo(_this.destX,  _this.destY);
        _this.on_slide(_this.destX,  _this.destY);
        _this.on_slide_end(_this.destX, _this.destY);
        dw_Slidebar.current = null;
    }    
}

dw_Slidebar.prepDrag = function (e) { 
    var bar = this; // bar received onmousedown event
    var barId = this.id; // id of element mousedown event assigned to
    var _this = dw_Slidebar.col[barId]; // Slidebar instance
    dw_Slidebar.current = _this;
    _this.bar = bar;
    e = dw_Event.DOMit(e);
    if ( _this.timer ) { clearInterval(_this.timer); _this.timer = 0; }
    _this.downX = e.clientX; _this.downY = e.clientY;
    _this.startX = parseInt(bar.style.left);
    _this.startY = parseInt(bar.style.top);
    _this.on_drag_start(_this.startX, _this.startY);
    dw_Event.add( document, "mousemove", dw_Slidebar.doDrag, true );
    dw_Event.add( document, "mouseup",   dw_Slidebar.endDrag,  true );
    e.stopPropagation(); e.preventDefault();
}

dw_Slidebar.doDrag = function(e) {
    if ( !dw_Slidebar.current ) return; // avoid errors in ie if inappropriate selections
    var _this = dw_Slidebar.current;
    var bar = _this.bar;
    e = dw_Event.DOMit(e);
    var nx = _this.startX + e.clientX - _this.downX;
    var ny = _this.startY + e.clientY - _this.downY;
    nx = Math.min( Math.max( _this.minX, nx ), _this.maxX);
    ny = Math.min( Math.max( _this.minY, ny ), _this.maxY);
    _this.shiftTo(nx, ny);
    _this.on_drag(nx, ny);
    e.preventDefault(); e.stopPropagation();
}

dw_Slidebar.endDrag = function() {
    if ( !dw_Slidebar.current ) return; // avoid errors in ie if inappropriate selections
    var _this = dw_Slidebar.current;
    var bar = _this.bar;
    dw_Event.remove( document, "mousemove", dw_Slidebar.doDrag, true );
    dw_Event.remove( document, "mouseup",   dw_Slidebar.endDrag,  true );
    _this.on_drag_end( parseInt(bar.style.left), parseInt(bar.style.top) );
    dw_Slidebar.current = null;
}

dw_Slidebar.prototype.shiftTo = function(x, y) {
    if ( this.bar ) {
        this.bar.style.left = x + "px";
        this.bar.style.top = y + "px";
    }
}

/////////////////////////////////////////////////////////////////////
//  connect slidebar with scrollObj
dw_scrollObj.prototype.setUpScrollbar = function(barId, trkId, axis, offx, offy, bSize) {
    var scrollbar = new dw_Slidebar(barId, trkId, axis, offx, offy);
    if (axis == "v") {
        this.vBarId = barId; 
    } else {
        this.hBarId = barId;
    }
    scrollbar.wndoId = this.id;
    scrollbar.bSizeDragBar = (bSize == false)? false: true; 
    if (scrollbar.bSizeDragBar) {
        dw_Scrollbar_Co.setBarSize(this, scrollbar);
    }
    dw_Scrollbar_Co.setEvents(this, scrollbar);
}
// Coordinates slidebar and scrollObj 
dw_Scrollbar_Co = {
    
    // This function is called for each scrollbar attached to a scroll area (change from previous version)
    setBarSize: function(scrollObj, barObj) {
        var lyr = document.getElementById(scrollObj.lyrId);
        var wn = document.getElementById(scrollObj.id);
        if ( barObj.axis == 'v' ) {
            var bar = document.getElementById(scrollObj.vBarId);
			if(bar!=null){
            bar.style.height = (lyr.offsetHeight > wn.offsetHeight)? 
                barObj.trkHt / ( lyr.offsetHeight / wn.offsetHeight ) + "px":             
                barObj.trkHt - ( 2 * barObj.minY ) + "px";
            barObj.maxY = barObj.trkHt - bar.offsetHeight - barObj.minY; 
			}
        } else if ( barObj.axis == 'h' ) {
            var bar = document.getElementById(scrollObj.hBarId);
			if(bar!=null){
            bar.style.width = (scrollObj.wd > wn.offsetWidth)? 
                barObj.trkWd / ( scrollObj.wd / wn.offsetWidth ) + "px": 
                barObj.trkWd - ( 2 * barObj.minX ) + "px";
            barObj.maxX = barObj.trkWd - bar.offsetWidth - barObj.minX;
			}
        }
    },
    
    // Find bars associated with this scrollObj. if they have bSizeDragBar set true reevaluate size and reset position to top 
    resetBars: function(scrollObj) {
        var barObj, bar;
        if (scrollObj.vBarId) {
            barObj = dw_Slidebar.col[scrollObj.vBarId];
            bar = document.getElementById(scrollObj.vBarId);
            bar.style.left = barObj.minX + "px"; bar.style.top = barObj.minY + "px";
            if (barObj.bSizeDragBar) {
                dw_Scrollbar_Co.setBarSize(scrollObj, barObj);
            }
        }
        if (scrollObj.hBarId) {
            barObj = dw_Slidebar.col[scrollObj.hBarId];
            bar = document.getElementById(scrollObj.hBarId);
            bar.style.left = barObj.minX + "px"; bar.style.top = barObj.minY + "px";
            if (barObj.bSizeDragBar) {
                dw_Scrollbar_Co.setBarSize(scrollObj, barObj);
            }
        }
    },
    
    setEvents: function(scrollObj, barObj) {
        // scrollObj
        this.addEvent(scrollObj, 'on_load', function() { dw_Scrollbar_Co.resetBars(scrollObj); } );
        this.addEvent(scrollObj, 'on_scroll_start', function() { dw_Scrollbar_Co.getBarRefs(scrollObj) } );
        this.addEvent(scrollObj, 'on_glidescroll_start', function() { dw_Scrollbar_Co.getBarRefs(scrollObj) } );
        this.addEvent(scrollObj, 'on_scroll', function(x,y) { dw_Scrollbar_Co.updateScrollbar(scrollObj, x, y) } );
        this.addEvent(scrollObj, 'on_glidescroll', function(x,y) { dw_Scrollbar_Co.updateScrollbar(scrollObj, x, y) } );
        this.addEvent(scrollObj, 'on_scroll_stop', function(x,y) { dw_Scrollbar_Co.updateScrollbar(scrollObj, x, y); } );
        this.addEvent(scrollObj, 'on_glidescroll_stop', function(x,y) { dw_Scrollbar_Co.updateScrollbar(scrollObj, x, y); } );
        this.addEvent(scrollObj, 'on_scroll_end', function(x,y) { dw_Scrollbar_Co.updateScrollbar(scrollObj, x, y); } );
        this.addEvent(scrollObj, 'on_glidescroll_end', function(x,y) { dw_Scrollbar_Co.updateScrollbar(scrollObj, x, y); } );
        // barObj 
        this.addEvent(barObj, 'on_slide_start', function() { dw_Scrollbar_Co.getWndoLyrRef(barObj) } );
        this.addEvent(barObj, 'on_drag_start', function() { dw_Scrollbar_Co.getWndoLyrRef(barObj) } );
        this.addEvent(barObj, 'on_slide', function(x,y) { dw_Scrollbar_Co.updateScrollPosition(barObj, x, y) } );
        this.addEvent(barObj, 'on_drag', function(x,y) { dw_Scrollbar_Co.updateScrollPosition(barObj, x, y) } );
        this.addEvent(barObj, 'on_slide_end', function(x,y) { dw_Scrollbar_Co.updateScrollPosition(barObj, x, y); } );
        this.addEvent(barObj, 'on_drag_end', function(x,y) { dw_Scrollbar_Co.updateScrollPosition(barObj, x, y); } );
    
    },
    
    // Provide means to add functions to be invoked on pseudo events (on_load, on_scroll, etc) 
    // without overwriting any others that may already be set
    // by Mark Wubben (see http://simonwillison.net/2004/May/26/addLoadEvent/)
    addEvent: function(o, ev, fp) {
        var oldEv = o[ev];
        if ( typeof oldEv != 'function' ) {
            //o[ev] = fp;
            // almost all the functions (on_scroll, on_drag, etc.) pass x,y
            o[ev] = function (x,y) { fp(x,y); }
        } else {
            o[ev] = function (x,y) {
                  oldEv(x,y );
                  fp(x,y);
            }
        }
    },

    // Keep position of dragBar in sync with position of layer when scrolled by other means (mouseover, etc.)
    updateScrollbar: function(scrollObj, x, y) { // 
        var nx, ny;
        if ( scrollObj.vBar && scrollObj.maxY ) { 
            var vBar = scrollObj.vBar;
            ny = -( y * ( (vBar.maxY - vBar.minY) / scrollObj.maxY ) - vBar.minY );
            ny = Math.min( Math.max(ny, vBar.minY), vBar.maxY);  
            if (vBar.bar) { // ref to bar el
                nx = parseInt(vBar.bar.style.left);
                vBar.shiftTo(nx, ny);
            }
        }
        if ( scrollObj.hBar && scrollObj.maxX ) {
            var hBar = scrollObj.hBar;
            nx = -( x * ( (hBar.maxX - hBar.minX) / scrollObj.maxX ) - hBar.minX );
            nx = Math.min( Math.max(nx, hBar.minX), hBar.maxX);
            if (hBar.bar) {
                ny = parseInt(hBar.bar.style.top);
                hBar.shiftTo(nx, ny);
            }
        }
    },

    updateScrollPosition: function(barObj, x, y) { // on scrollbar movement
        var nx, ny; var wndo = barObj.wndo; 
        if ( !wndo.lyr ) {
            wndo.lyr = document.getElementById(wndo.lyrId);
        }
        if (barObj.axis == "v") {
            nx = wndo.x; // floating point values for loaded layer's position held in shiftTo method
            ny = -(y - barObj.minY) * ( wndo.maxY / (barObj.maxY - barObj.minY) ) || 0;
        } else {
            ny = wndo.y;
            nx = -(x - barObj.minX) * ( wndo.maxX / (barObj.maxX - barObj.minX) ) || 0;
        }
        wndo.shiftTo(nx, ny);
    },
    
    // Scroll area may have both vertical and horizontal bars 
    getBarRefs: function(scrollObj) { // References to Slidebar instance and dom element 
        if ( scrollObj.vBarId ) {
            scrollObj.vBar = dw_Slidebar.col[scrollObj.vBarId];
            scrollObj.vBar.bar = document.getElementById(scrollObj.vBarId);
        }
        if ( scrollObj.hBarId ) {
            scrollObj.hBar = dw_Slidebar.col[scrollObj.hBarId];
            scrollObj.hBar.bar = document.getElementById(scrollObj.hBarId);
        }
    },
    
    getWndoLyrRef: function(barObj) {
        var wndo = barObj.wndo = dw_scrollObj.col[ barObj.wndoId ];
        if ( wndo && !wndo.lyr ) {
            wndo.lyr = document.getElementById(wndo.lyrId);
        }
    }

}

/*************************************************************************
    This code is from Dynamic Web Coding at dyn-web.com
    Copyright 2008 by Sharon Paine 
    See Terms of Use at www.dyn-web.com/business/terms.php
    regarding conditions under which you may use this code.
    This notice must be retained in the code as is!

    unobtrusive event handling for use with dw_scroll.js
    version date: Nov 2008
*************************************************************************/

/////////////////////////////////////////////////////////////////////
// two ways to add style sheet for capable browsers

// Nov 2008 revision adds screen as option
// (may want printed copy to appear as on screen?)
dw_writeStyleSheet = function(file, screen) {
    var css = '<link rel="stylesheet" href="' + file + '"';
    if (screen !== false) {
        css += ' media="screen"';
    }
    document.write(css + ' />');
}

// slower, may flash unstyled ?
function dw_addLinkCSS(file, screen) {
    if ( !document.createElement ) return;
    var el = document.createElement("link");
    el.setAttribute("rel", "stylesheet");
    el.setAttribute("type", "text/css");
    if (screen !== false) {
        el.setAttribute("media", "screen");
    }
    el.setAttribute("href", file);
    document.getElementsByTagName('head')[0].appendChild(el);
}
/////////////////////////////////////////////////////////////////////

// Example class names: load_wn_lyr1, load_wn_lyr2_t2
dw_scrollObj.prototype.setUpLoadLinks = function(controlsId) {
    var wndoId = this.id; var el = document.getElementById(controlsId); 
    var links = el.getElementsByTagName('a');
    var cls, parts;
    for (var i=0; links[i]; i++) {
        cls = dw_scrollObj.get_DelimitedClass( links[i].className );
        parts = cls.split('_');
        if ( parts[0] == 'load' && parts[1] == wndoId && parts.length > 2 ) {
            // no checks on lyrId, horizId
            var lyrId = parts[2]; var horizId = parts[3]? parts[3]: null;
            dw_Event.add( links[i], 'click', function (wndoId, lyrId, horizId) {
                return function (e) {
                    dw_scrollObj.col[wndoId].load(lyrId, horizId);
                    if (e && e.preventDefault) e.preventDefault();
                    return false;
                }
            }(wndoId, lyrId, horizId) ); // see Crockford js good parts pg 39
        }
    }
}

dw_scrollObj.prototype.setUpScrollControls = function(controlsId, autoHide, axis) {
    var wndoId = this.id; var el = document.getElementById(controlsId); 
    if ( autoHide && axis == 'v' || axis == 'h' ) {
        dw_scrollObj.handleControlVis(controlsId, wndoId, axis);
        dw_Scrollbar_Co.addEvent( this, 'on_load', function() { dw_scrollObj.handleControlVis(controlsId, wndoId, axis); } );
        dw_Scrollbar_Co.addEvent( this, 'on_update', function() { dw_scrollObj.handleControlVis(controlsId, wndoId, axis); } );
    }
    if(el!=null){
    var links = el.getElementsByTagName('a'), cls, eType;
    for (var i=0; links[i]; i++) { 
        cls = dw_scrollObj.get_DelimitedClass( links[i].className );
        eType = dw_scrollObj.getEv_FnType( cls.slice(0, cls.indexOf('_') ) );
        switch ( eType ) {
            case 'mouseover' :
            case 'mousedown' :
                dw_scrollObj.handleMouseOverDownLinks(links[i], wndoId, cls);
                break;
            case 'scrollToId': 
                dw_scrollObj.handleScrollToId(links[i], wndoId, cls);
                break;
            case 'scrollTo' :
            case 'scrollBy':
            case 'click': 
                dw_scrollObj.handleClick(links[i], wndoId, cls) ;
                break;
        }
	}
    }
}

dw_scrollObj.handleMouseOverDownLinks = function (linkEl, wndoId, cls) {
    var parts = cls.split('_'); var eType = parts[0];
    var re = /^(mouseover|mousedown)_(up|down|left|right)(_[\d]+)?$/;
                
    if ( re.test(cls) ) { 
        var eAlt = (eType == 'mouseover')? 'mouseout': 'mouseup';
        var dir = parts[1];  var speed = parts[2] || null; 
        var deg = (dir == 'up')? 90: (dir == 'down')? 270: (dir == 'left')? 180: 0;
        
        dw_Event.add(linkEl, eType, function (e) { dw_scrollObj.col[wndoId].initScrollVals(deg, speed); } );
        dw_Event.add(linkEl, eAlt, function (e) { dw_scrollObj.col[wndoId].ceaseScroll(); } );
            
        if ( eType == 'mouseover') {
            dw_Event.add( linkEl, 'mousedown', function (e) { dw_scrollObj.col[wndoId].speed *= 3; } );
            dw_Event.add( linkEl, 'mouseup', function (e) { 
                dw_scrollObj.col[wndoId].speed = dw_scrollObj.prototype.speed; } ); 
        }
        dw_Event.add( linkEl, 'click', function(e) { if (e && e.preventDefault) e.preventDefault(); return false; } );
    }
}


// get info from className (e.g., click_down_by_100)
dw_scrollObj.getClickParts = function(cls) {
    var parts = cls.split('_');
    var re = /^(up|down|left|right)$/;
    var dir, fn = '', dur, ar, val, x = '', y = '';
    
    if ( parts.length >= 4 ) {
        ar = parts[1].match(re);
        dir = ar? ar[1]: null;
            
        re = /^(to|by)$/; 
        ar = parts[2].match(re);
        if (ar) {
            fn = (ar[0] == 'to')? 'scrollTo': 'scrollBy';
        } 
    
        val = parts[3]; // value on x or y axis
        re = /^([\d]+)$/;
        dur = ( parts[4] && re.test(parts[4]) )? parts[4]: null;
    
        switch (fn) {
            case 'scrollBy' :
                if ( !re.test( val ) ) {
                    x = ''; y = ''; break;
                }
                switch (dir) { // 0 for unspecified axis 
                    case 'up' : x = 0; y = val; break;
                    case 'down' : x = 0; y = -val; break;
                    case 'left' : x = val; y = 0; break;
                    case 'right' : x = -val; y = 0;
                 }
                break;
            case 'scrollTo' :
                re = /^(end|[\d]+)$/;
                if ( !re.test( val ) ) {
                    x = ''; y = ''; break;
                }
                switch (dir) { // null for unspecified axis 
                    case 'up' : x = null; y = val; break;
                    case 'down' : x = null; y = (val == 'end')? val: -val; break;
                    case 'left' : x = val; y = null; break;
                    case 'right' : x = (val == 'end')? val: -val; y = null;
                 } 
                break;
         }
    }
    return { fn: fn, x: x, y: y, dur: dur }
}

dw_scrollObj.getEv_FnType = function(str) {
    var re = /^(mouseover|mousedown|scrollBy|scrollTo|scrollToId|click)$/;
    if (re.test(str) ) {
        return str;
    }
    return '';
}

// return class name with underscores in it 
dw_scrollObj.get_DelimitedClass = function(cls) {
    if ( cls.indexOf('_') == -1 ) {
        return '';
    }
    var whitespace = /\s+/;
    if ( !whitespace.test(cls) ) {
        return cls;
    } else {
        var classes = cls.split(whitespace); 
        for(var i = 0; classes[i]; i++) { 
            if ( classes[i].indexOf('_') != -1 ) {
                return classes[i];
            }
        }
    }
}

dw_scrollObj.handleControlVis = function(controlsId, wndoId, axis) {
    var wndo = dw_scrollObj.col[wndoId];
    var el = document.getElementById(controlsId);
	if(el!=null){
    if ( ( axis == 'v' && wndo.maxY > 0 ) || ( axis == 'h' && wndo.maxX > 0 ) ) {
        el.style.visibility = 'visible';
    } else {
        el.style.visibility = 'hidden';
    }
	}
}

function init_dw_Scroll() {
    var wndo = new dw_scrollObj('wn', 'lyr1');
    wndo.setUpScrollbar("dragBar", "track", "v", 1, 1);
    wndo.setUpScrollControls('scrollbar',true,'v');
}

// if code supported, link in the style sheet and call the init function onload
if ( dw_scrollObj.isSupported() ) {
    dw_writeStyleSheet('css/scrollbar_demo.css')
    dw_Event.add( window, 'load', init_dw_Scroll);
}

function validate(){
pos = document.theform.name.value.indexOf(" ");
pas = document.theform.email.value.indexOf("@");
if(pos<1 || document.theform.name.value.length<5){
alert("Please enter your full name.");
document.theform.name.focus();
return false;
}
if(pas<1 || document.theform.email.value.length<5){
alert("Please enter a valid email address.");
document.theform.email.focus();
return false;
}
if(document.theform.message.value.length<3){
alert("Please enter a message.");
document.theform.message.focus();
return false;
}
if(document.theform.captcha_code.value.length!=6){
alert("Please copy the characters in the captcha image.");
document.theform.captcha_code.focus();
return false;
}
return true;
}