var MooTools = {
	version: '1.11'
};
function $merge(){
	var mix = {};
	for (var i = 0; i < arguments.length; i++){
		for (var property in arguments[i]){
			var ap = arguments[i][property];
			var mp = mix[property];
			if (mp && $type(ap) == 'object' && $type(mp) == 'object') mix[property] = $merge(mp, ap);
			else mix[property] = ap;
		}
	}
	return mix;
};
var $extend = function(){
	var args = arguments;
	if (!args[1]) args = [this, args[0]];
	for (var property in args[1]) args[0][property] = args[1][property];
	return args[0];
};
var $native = function(){
	for (var i = 0, l = arguments.length; i < l; i++){
		arguments[i].extend = function(props){
			for (var prop in props){
				if (!this.prototype[prop]) this.prototype[prop] = props[prop];
				if (!this[prop]) this[prop] = $native.generic(prop);
			}
		};
	}
};
$native.generic = function(prop){
	return function(bind){
		return this.prototype[prop].apply(bind, Array.prototype.slice.call(arguments, 1));
	};
};
$native(Function, Array, String, Number);
function $chk(obj){
	return !!(obj || obj === 0);
};
function $pick(obj, picked){
	return obj!=undefined ? obj : picked;
};
var Abstract = function(obj){
	obj = obj || {};
	obj.extend = $extend;
	return obj;
};
var Window = new Abstract(window);
var Document = new Abstract(document);
window.xpath = !!(document.evaluate);
if (window.ActiveXObject) window.ie = window[window.XMLHttpRequest ? 'ie7' : 'ie6'] = true;
else if (document.childNodes && !document.all && !navigator.taintEnabled) window.webkit = window[window.xpath ? 'webkit420' : 'webkit419'] = true;
else if (document.getBoxObjectFor != null) window.gecko = true;
window.khtml = window.webkit;
Object.extend = $extend;
if (typeof HTMLElement == 'undefined'){
	var HTMLElement = function(){};
	if (window.webkit) document.createElement("iframe"); //fixes safari
	HTMLElement.prototype = (window.webkit) ? window["[[DOMElement.prototype]]"] : {};
}
HTMLElement.prototype.htmlElement = function(){};
if (window.ie6) try {document.execCommand("BackgroundImageCache", false, true);} catch(e){};
var Class = function(properties){
	var klass = function(){
		return (arguments[0] !== null && this.initialize && $type(this.initialize) == 'function') ? this.initialize.apply(this, arguments) : this;
	};
	$extend(klass, this);
	klass.prototype = properties;
	klass.constructor = Class;
	return klass;
};
Class.empty = function(){};
Class.prototype = {
	extend: function(properties){
		var proto = new this(null);
		for (var property in properties){
			var pp = proto[property];
			proto[property] = Class.Merge(pp, properties[property]);
		}
		return new Class(proto);
	},
	implement: function(){
		for (var i = 0, l = arguments.length; i < l; i++) $extend(this.prototype, arguments[i]);
	}
};
Class.Merge = function(previous, current){
	if (previous && previous != current){
		var type = $type(current);
		if (type != $type(previous)) return current;
		switch(type){
			case 'function':
				var merged = function(){
					this.parent = arguments.callee.parent;
					return current.apply(this, arguments);
				};
				merged.parent = previous;
				return merged;
			case 'object': return $merge(previous, current);
		}
	}
	return current;
};
var Chain = new Class({
	chain: function(fn){
		this.chains = this.chains || [];
		this.chains.push(fn);
		return this;
	},
	callChain: function(){
		if (this.chains && this.chains.length) this.chains.shift().delay(10, this);
	},
	clearChain: function(){
		this.chains = [];
	}
});
var Events = new Class({
	addEvent: function(type, fn){
		if (fn != Class.empty){
			this.$events = this.$events || {};
			this.$events[type] = this.$events[type] || [];
			this.$events[type].include(fn);
		}
		return this;
	},
	fireEvent: function(type, args, delay){
		if (this.$events && this.$events[type]){
			this.$events[type].each(function(fn){
				fn.create({'bind': this, 'delay': delay, 'arguments': args})();
			}, this);
		}
		return this;
	},
	removeEvent: function(type, fn){
		if (this.$events && this.$events[type]) this.$events[type].remove(fn);
		return this;
	}
});
var Options = new Class({
	setOptions: function(){
		this.options = $merge.apply(null, [this.options].extend(arguments));
		if (this.addEvent){
			for (var option in this.options){
				if ($type(this.options[option] == 'function') && (/^on[A-Z]/).test(option)) this.addEvent(option, this.options[option]);
			}
		}
		return this;
	}
});
Array.extend({
	forEach: function(fn, bind){
		for (var i = 0, j = this.length; i < j; i++) fn.call(bind, this[i], i, this);
	},
	filter: function(fn, bind){
		var results = [];
		for (var i = 0, j = this.length; i < j; i++){
			if (fn.call(bind, this[i], i, this)) results.push(this[i]);
		}
		return results;
	},
	map: function(fn, bind){
		var results = [];
		for (var i = 0, j = this.length; i < j; i++) results[i] = fn.call(bind, this[i], i, this);
		return results;
	},
	every: function(fn, bind){
		for (var i = 0, j = this.length; i < j; i++){
			if (!fn.call(bind, this[i], i, this)) return false;
		}
		return true;
	},
	some: function(fn, bind){
		for (var i = 0, j = this.length; i < j; i++){
			if (fn.call(bind, this[i], i, this)) return true;
		}
		return false;
	},
	indexOf: function(item, from){
		var len = this.length;
		for (var i = (from < 0) ? Math.max(0, len + from) : from || 0; i < len; i++){
			if (this[i] === item) return i;
		}
		return -1;
	},
	copy: function(start, length){
		start = start || 0;
		if (start < 0) start = this.length + start;
		length = length || (this.length - start);
		var newArray = [];
		for (var i = 0; i < length; i++) newArray[i] = this[start++];
		return newArray;
	},
	remove: function(item){
		var i = 0;
		var len = this.length;
		while (i < len){
			if (this[i] === item){
				this.splice(i, 1);
				len--;
			} else {
				i++;
			}
		}
		return this;
	},
	contains: function(item, from){
		return this.indexOf(item, from) != -1;
	},
	associate: function(keys){
		var obj = {}, length = Math.min(this.length, keys.length);
		for (var i = 0; i < length; i++) obj[keys[i]] = this[i];
		return obj;
	},
	extend: function(array){
		for (var i = 0, j = array.length; i < j; i++) this.push(array[i]);
		return this;
	},
	merge: function(array){
		for (var i = 0, l = array.length; i < l; i++) this.include(array[i]);
		return this;
	},
	include: function(item){
		if (!this.contains(item)) this.push(item);
		return this;
	},
	getRandom: function(){
	return Math.floor(Math.random() * (max - min + 1) + min);
		return this[Math.floor(Math.random() * (this.length - 1 + 1))] || null;
	},
	getLast: function(){
		return this[this.length - 1] || null;
	}
});
Array.prototype.each = Array.prototype.forEach;
Array.each = Array.forEach;
function $A(array){
	return Array.copy(array);
};
function $each(iterable, fn, bind){
	if (iterable && typeof iterable.length == 'number' && $type(iterable) != 'object'){
		Array.forEach(iterable, fn, bind);
	} else {
		 for (var name in iterable) fn.call(bind || iterable, iterable[name], name);
	}
};
Array.prototype.test = Array.prototype.contains;
String.extend({
	test: function(regex, params){
		return (($type(regex) == 'string') ? new RegExp(regex, params) : regex).test(this);
	},
	toInt: function(){
		return parseInt(this, 10);
	},
	toFloat: function(){
		return parseFloat(this);
	},
	camelCase: function(){
		return this.replace(/-\D/g, function(match){
			return match.charAt(1).toUpperCase();
		});
	},
	hyphenate: function(){
		return this.replace(/\w[A-Z]/g, function(match){
			return (match.charAt(0) + '-' + match.charAt(1).toLowerCase());
		});
	},
	capitalize: function(){
		return this.replace(/\b[a-z]/g, function(match){
			return match.toUpperCase();
		});
	},
	trim: function(){
		return this.replace(/^\s+|\s+$/g, '');
	},
	clean: function(){
		return this.replace(/\s{2,}/g, ' ').trim();
	},
	rgbToHex: function(array){
		var rgb = this.match(/\d{1,3}/g);
		return (rgb) ? rgb.rgbToHex(array) : false;
	},
	hexToRgb: function(array){
		var hex = this.match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
		return (hex) ? hex.slice(1).hexToRgb(array) : false;
	},
	contains: function(string, s){
		return (s) ? (s + this + s).indexOf(s + string + s) > -1 : this.indexOf(string) > -1;
	},
	escapeRegExp: function(){
		return this.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
	}
});
Array.extend({
	rgbToHex: function(array){
		if (this.length < 3) return false;
		if (this.length == 4 && this[3] == 0 && !array) return 'transparent';
		var hex = [];
		for (var i = 0; i < 3; i++){
			var bit = (this[i] - 0).toString(16);
			hex.push((bit.length == 1) ? '0' + bit : bit);
		}
		return array ? hex : '#' + hex.join('');
	},
	hexToRgb: function(array){
		if (this.length != 3) return false;
		var rgb = [];
		for (var i = 0; i < 3; i++){
			rgb.push(parseInt((this[i].length == 1) ? this[i] + this[i] : this[i], 16));
		}
		return array ? rgb : 'rgb(' + rgb.join(',') + ')';
	}
});
Function.extend({
	create: function(options){
		var fn = this;
		options = $merge({
			'bind': fn,
			'event': false,
			'arguments': null,
			'delay': false,
			'periodical': false,
			'attempt': false
		}, options);
		if ($chk(options.arguments) && $type(options.arguments) != 'array') options.arguments = [options.arguments];
		return function(event){
			var args;
			if (options.event){
				event = event || window.event;
				args = [(options.event === true) ? event : new options.event(event)];
				if (options.arguments) args.extend(options.arguments);
			}
			else args = options.arguments || arguments;
			var returns = function(){
				return fn.apply($pick(options.bind, fn), args);
			};
			if (options.delay) return setTimeout(returns, options.delay);
			if (options.periodical) return setInterval(returns, options.periodical);
			if (options.attempt) try {return returns();} catch(err){return false;};
			return returns();
		};
	},
	pass: function(args, bind){
		return this.create({'arguments': args, 'bind': bind});
	},
	attempt: function(args, bind){
		return this.create({'arguments': args, 'bind': bind, 'attempt': true})();
	},
	bind: function(bind, args){
		return this.create({'bind': bind, 'arguments': args});
	},
	bindAsEventListener: function(bind, args){
		return this.create({'bind': bind, 'event': true, 'arguments': args});
	},
	delay: function(delay, bind, args){
		return this.create({'delay': delay, 'bind': bind, 'arguments': args})();
	},
	periodical: function(interval, bind, args){
		return this.create({'periodical': interval, 'bind': bind, 'arguments': args})();
	}
});
Number.extend({
	toInt: function(){
		return parseInt(this);
	},
	toFloat: function(){
		return parseFloat(this);
	},
	limit: function(min, max){
		return Math.min(max, Math.max(min, this));
	},
	round: function(precision){
		precision = Math.pow(10, precision || 0);
		return Math.round(this * precision) / precision;
	},
	times: function(fn){
		for (var i = 0; i < this; i++) fn(i);
	}
});
var Element = new Class({
	initialize: function(el, props){
		if ($type(el) == 'string'){
			if (window.ie && props && (props.name || props.type)){
				var name = (props.name) ? ' name="' + props.name + '"' : '';
				var type = (props.type) ? ' type="' + props.type + '"' : '';
				delete props.name;
				delete props.type;
				el = '<' + el + name + type + '>';
			}
			el = document.createElement(el);
		}
		el = $M(el);
		return (!props || !el) ? el : el.set(props);
	}
});
var Elements = new Class({
	initialize: function(elements){
		return (elements) ? $extend(elements, this) : this;
	}
});
Elements.extend = function(props){
	for (var prop in props){
		this.prototype[prop] = props[prop];
		this[prop] = $native.generic(prop);
	}
};
function $M(el){
	if (!el) return null;
	if (el.htmlElement) return Garbage.collect(el);
	if ([window, document].contains(el)) return el;
	var type = $type(el);
	if (type == 'string'){
		el = document.getElementById(el);
		type = (el) ? 'element' : false;
	}
	if (type != 'element') return null;
	if (el.htmlElement) return Garbage.collect(el);
	if (['object', 'embed'].contains(el.tagName.toLowerCase())) return el;
	$extend(el, Element.prototype);
	el.htmlElement = function(){};
	return Garbage.collect(el);
};
document.getElementsBySelector = document.getElementsByTagName;
function $$M(){
	var elements = [];
	for (var i = 0, j = arguments.length; i < j; i++){
		var selector = arguments[i];
		switch($type(selector)){
			case 'element': elements.push(selector);
			case 'boolean': break;
			case false: break;
			case 'string': selector = document.getElementsBySelector(selector, true);
			default: elements.extend(selector);
		}
	}
	return $$M.unique(elements);
};
$$M.unique = function(array){
	var elements = [];
	for (var i = 0, l = array.length; i < l; i++){
		if (array[i].$included) continue;
		var element = $M(array[i]);
		if (element && !element.$included){
			element.$included = true;
			elements.push(element);
		}
	}
	for (var n = 0, d = elements.length; n < d; n++) elements[n].$included = null;
	return new Elements(elements);
};
Elements.Multi = function(property){
	return function(){
		var args = arguments;
		var items = [];
		var elements = true;
		for (var i = 0, j = this.length, returns; i < j; i++){
			returns = this[i][property].apply(this[i], args);
			if ($type(returns) != 'element') elements = false;
			items.push(returns);
		};
		return (elements) ? $$M.unique(items) : items;
	};
};
Element.extend = function(properties){
	for (var property in properties){
		HTMLElement.prototype[property] = properties[property];
		Element.prototype[property] = properties[property];
		Element[property] = $native.generic(property);
		var elementsProperty = (Array.prototype[property]) ? property + 'Elements' : property;
		Elements.prototype[elementsProperty] = Elements.Multi(property);
	}
};
Element.extend({
	set: function(props){
		for (var prop in props){
			var val = props[prop];
			switch(prop){
				case 'styles': this.setStyles(val); break;
				case 'events': if (this.addEvents) this.addEvents(val); break;
				default: this.setProperty(prop, val);
			}
		}
		return this;
	},
	inject: function(el, where){
		el = $M(el);
		switch(where){
			case 'before': el.parentNode.insertBefore(this, el); break;
			case 'after':
				var next = el.getNext();
				if (!next) el.parentNode.appendChild(this);
				else el.parentNode.insertBefore(this, next);
				break;
			case 'top':
				var first = el.firstChild;
				if (first){
					el.insertBefore(this, first);
					break;
				}
			default: el.appendChild(this);
		}
		return this;
	},
	adopt: function(){
		var elements = [];
		$each(arguments, function(argument){
			elements = elements.concat(argument);
		});
		$$M(elements).inject(this);
		return this;
	},
	remove: function(){
		return this.parentNode.removeChild(this);
	},
	clone: function(contents){
		var el = $M(this.cloneNode(contents !== false));
		if (!el.$events) return el;
		el.$events = {};
		for (var type in this.$events) el.$events[type] = {
			'keys': $A(this.$events[type].keys),
			'values': $A(this.$events[type].values)
		};
		return el.removeEvents();
	},
	replaceWith: function(el){
		el = $M(el);
		this.parentNode.replaceChild(el, this);
		return el;
	},
	appendText: function(text){
		this.appendChild(document.createTextNode(text));
		return this;
	},
	hasClass: function(className){
		return this.className.contains(className, ' ');
	},
	addClass: function(className){
		if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
		return this;
	},
	removeClass: function(className){
		this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)'), '$1').clean();
		return this;
	},
	setStyle: function(property, value){
		switch(property){
			case 'opacity': return this.setOpacity(parseFloat(value));
			case 'float': property = (window.ie) ? 'styleFloat' : 'cssFloat';
		}
		property = property.camelCase();
		switch($type(value)){
			case 'number': if (!['zIndex', 'zoom'].contains(property)) value += 'px'; break;
			case 'array': value = 'rgb(' + value.join(',') + ')';
		}
		this.style[property] = value;
		return this;
	},
	setStyles: function(source){
		switch($type(source)){
			case 'object': Element.setMany(this, 'setStyle', source); break;
			case 'string': this.style.cssText = source;
		}
		return this;
	},
	setOpacity: function(opacity){
		if (opacity == 0){
			if (this.style.visibility != "hidden") this.style.visibility = "hidden";
		} else {
			if (this.style.visibility != "visible") this.style.visibility = "visible";
		}
		if (!this.currentStyle || !this.currentStyle.hasLayout) this.style.zoom = 1;
		if (window.ie) this.style.filter = (opacity == 1) ? '' : "alpha(opacity=" + opacity * 100 + ")";
if(!this.$tmp)this.$tmp={};
if(!this.$tmp.opacity)this.$tmp.opacity=0;
		this.style.opacity = this.$tmp.opacity = opacity;
		return this;
	},
	getStyle: function(property){
		property = property.camelCase();
		var result = this.style[property];
		if (!$chk(result)){
			if (property == 'opacity') return this.$tmp.opacity;
			result = [];
			for (var style in Element.Styles){
				if (property == style){
					Element.Styles[style].each(function(s){
						var style = this.getStyle(s);
						result.push(parseInt(style) ? style : '0px');
					}, this);
					if (property == 'border'){
						var every = result.every(function(bit){
							return (bit == result[0]);
						});
						return (every) ? result[0] : false;
					}
					return result.join(' ');
				}
			}
			if (property.contains('border')){
				if (Element.Styles.border.contains(property)){
					return ['Width', 'Style', 'Color'].map(function(p){
						return this.getStyle(property + p);
					}, this).join(' ');
				} else if (Element.borderShort.contains(property)){
					return ['Top', 'Right', 'Bottom', 'Left'].map(function(p){
						return this.getStyle('border' + p + property.replace('border', ''));
					}, this).join(' ');
				}
			}
			if (document.defaultView) result = document.defaultView.getComputedStyle(this, null).getPropertyValue(property.hyphenate());
			else if (this.currentStyle) result = this.currentStyle[property];
		}
		if (window.ie) result = Element.fixStyle(property, result, this);
		if (result && property.test(/color/i) && result.contains('rgb')){
			return result.split('rgb').splice(1,4).map(function(color){
				return color.rgbToHex();
			}).join(' ');
		}
		return result;
	},
	walk: function(brother, start){
		brother += 'Sibling';
		var el = (start) ? this[start] : this[brother];
		while (el && $type(el) != 'element') el = el[brother];
		return $M(el);
	},
	getPrevious: function(){
		return this.walk('previous');
	},
	getNext: function(){
		return this.walk('next');
	},
	getFirst: function(){
		return this.walk('next', 'firstChild');
	},
	getLast: function(){
		return this.walk('previous', 'lastChild');
	},
	getParent: function(){
		return $M(this.parentNode);
	},
	getChildren: function(){
		return $$M(this.childNodes);
	},
	hasChild: function(el){
		return !!$A(this.getElementsByTagName('*')).contains(el);
	},
	getProperty: function(property){
		var index = Element.Properties[property];
		if (index) return this[index];
		var flag = Element.PropertiesIFlag[property] || 0;
		if (!window.ie || flag) return this.getAttribute(property, flag);
		var node = this.attributes[property];
		return (node) ? node.nodeValue : null;
	},
	setProperty: function(property, value){
		var index = Element.Properties[property];
		if (index) this[index] = value;
		else this.setAttribute(property, value);
		return this;
	},
	setHTML: function(){
		this.innerHTML = $A(arguments).join('');
		return this;
	},
	setText: function(text){
		var tag = this.getTag();
		if (['style', 'script'].contains(tag)){
			if (window.ie){
				if (tag == 'style') this.styleSheet.cssText = text;
				else if (tag ==  'script') this.setProperty('text', text);
				return this;
			} else {
				this.removeChild(this.firstChild);
				return this.appendText(text);
			}
		}
		this[this.innerText!=undefined ? 'innerText' : 'textContent'] = text;
		return this;
	},
	getText: function(){
		var tag = this.getTag();
		if (['style', 'script'].contains(tag)){
			if (window.ie){
				if (tag == 'style') return this.styleSheet.cssText;
				else if (tag ==  'script') return this.getProperty('text');
			} else {
				return this.innerHTML;
			}
		}
		return ($pick(this.innerText, this.textContent));
	},
	getTag: function(){
		return this.tagName.toLowerCase();
	},
	empty: function(){
		Garbage.trash(this.getElementsByTagName('*'));
		return this.setHTML('');
	}
});
Element.fixStyle = function(property, result, element){
	if ($chk(parseInt(result))) return result;
	if (['height', 'width'].contains(property)){
		var values = (property == 'width') ? ['left', 'right'] : ['top', 'bottom'];
		var size = 0;
		values.each(function(value){
			size += element.getStyle('border-' + value + '-width').toInt() + element.getStyle('padding-' + value).toInt();
		});
		return element['offset' + property.capitalize()] - size + 'px';
	} else if (property.test(/border(.+)Width|margin|padding/)){
		return '0px';
	}
	return result;
};
Element.Styles = {'border': [], 'padding': [], 'margin': []};
['Top', 'Right', 'Bottom', 'Left'].each(function(direction){
	for (var style in Element.Styles) Element.Styles[style].push(style + direction);
});
Element.borderShort = ['borderWidth', 'borderStyle', 'borderColor'];
Element.getMany = function(el, method, keys){
	var result = {};
	$each(keys, function(key){
		result[key] = el[method](key);
	});
	return result;
};
Element.setMany = function(el, method, pairs){
	for (var key in pairs) el[method](key, pairs[key]);
	return el;
};
Element.Properties = new Abstract({
	'class': 'className', 'for': 'htmlFor', 'colspan': 'colSpan', 'rowspan': 'rowSpan',
	'accesskey': 'accessKey', 'tabindex': 'tabIndex', 'maxlength': 'maxLength',
	'readonly': 'readOnly', 'frameborder': 'frameBorder', 'value': 'value',
	'disabled': 'disabled', 'checked': 'checked', 'multiple': 'multiple', 'selected': 'selected'
});
Element.PropertiesIFlag = {
	'href': 2, 'src': 2
};
Element.Methods = {
	Listeners: {
		addListener: function(type, fn){
			if (this.addEventListener) this.addEventListener(type, fn, false);
			else this.attachEvent('on' + type, fn);
			return this;
		},
		removeListener: function(type, fn){
			if (this.removeEventListener) this.removeEventListener(type, fn, false);
			else this.detachEvent('on' + type, fn);
			return this;
		}
	}
};
window.extend(Element.Methods.Listeners);
document.extend(Element.Methods.Listeners);
Element.extend(Element.Methods.Listeners);
var Garbage = {
	elements: [],
	collect: function(el){
		if (!el.$tmp){
			Garbage.elements.push(el);
			el.$tmp = {'opacity': 1};
		}
		return el;
	},
	trash: function(elements){
		for (var i = 0, j = elements.length, el; i < j; i++){
			if (!(el = elements[i]) || !el.$tmp) continue;
			if (el.$events) el.fireEvent('trash').removeEvents();
			for (var p in el.$tmp) el.$tmp[p] = null;
			for (var d in Element.prototype) el[d] = null;
			Garbage.elements[Garbage.elements.indexOf(el)] = null;
			el.htmlElement = el.$tmp = el = null;
		}
		Garbage.elements.remove(null);
	},
	empty: function(){
		Garbage.collect(window);
		Garbage.collect(document);
		Garbage.trash(Garbage.elements);
	}
};
window.addListener('beforeunload', function(){
	window.addListener('unload', Garbage.empty);
	if (window.ie) window.addListener('unload', CollectGarbage);
});
var Event = new Class({
	initialize: function(event){
		if (event && event.$extended) return event;
		this.$extended = true;
		event = event || window.event;
		this.event = event;
		this.type = event.type;
		this.target = event.target || event.srcElement;
		if (this.target.nodeType == 3) this.target = this.target.parentNode;
		this.shift = event.shiftKey;
		this.control = event.ctrlKey;
		this.alt = event.altKey;
		this.meta = event.metaKey;
		if (['DOMMouseScroll', 'mousewheel'].contains(this.type)){
			this.wheel = (event.wheelDelta) ? event.wheelDelta / 120 : -(event.detail || 0) / 3;
		} else if (this.type.contains('key')){
			this.code = event.which || event.keyCode;
			for (var name in Event.keys){
				if (Event.keys[name] == this.code){
					this.key = name;
					break;
				}
			}
			if (this.type == 'keydown'){
				var fKey = this.code - 111;
				if (fKey > 0 && fKey < 13) this.key = 'f' + fKey;
			}
			this.key = this.key || String.fromCharCode(this.code).toLowerCase();
		} else if (this.type.test(/(click|mouse|menu)/)){
			this.page = {
				'x': event.pageX || event.clientX + document.documentElement.scrollLeft,
				'y': event.pageY || event.clientY + document.documentElement.scrollTop
			};
			this.client = {
				'x': event.pageX ? event.pageX - window.pageXOffset : event.clientX,
				'y': event.pageY ? event.pageY - window.pageYOffset : event.clientY
			};
			this.rightClick = (event.which == 3) || (event.button == 2);
			switch(this.type){
				case 'mouseover': this.relatedTarget = event.relatedTarget || event.fromElement; break;
				case 'mouseout': this.relatedTarget = event.relatedTarget || event.toElement;
			}
			this.fixRelatedTarget();
		}
		return this;
	},
	stop: function(){
		return this.stopPropagation().preventDefault();
	},
	stopPropagation: function(){
		if (this.event.stopPropagation) this.event.stopPropagation();
		else this.event.cancelBubble = true;
		return this;
	},
	preventDefault: function(){
		if (this.event.preventDefault) this.event.preventDefault();
		else this.event.returnValue = false;
		return this;
	}
});
Event.fix = {
	relatedTarget: function(){
		if (this.relatedTarget && this.relatedTarget.nodeType == 3) this.relatedTarget = this.relatedTarget.parentNode;
	},
	relatedTargetGecko: function(){
		try {Event.fix.relatedTarget.call(this);} catch(e){this.relatedTarget = this.target;}
	}
};
Event.prototype.fixRelatedTarget = (window.gecko) ? Event.fix.relatedTargetGecko : Event.fix.relatedTarget;
Event.keys = new Abstract({
	'enter': 13,
	'up': 38,
	'down': 40,
	'left': 37,
	'right': 39,
	'esc': 27,
	'space': 32,
	'backspace': 8,
	'tab': 9,
	'delete': 46
});
Element.Methods.Events = {
	addEvent: function(type, fn){
		this.$events = this.$events || {};
		this.$events[type] = this.$events[type] || {'keys': [], 'values': []};
		if (this.$events[type].keys.contains(fn)) return this;
		this.$events[type].keys.push(fn);
		var realType = type;
		var custom = Element.Events[type];
		if (custom){
			if (custom.add) custom.add.call(this, fn);
			if (custom.map) fn = custom.map;
			if (custom.type) realType = custom.type;
		}
		if (!this.addEventListener) fn = fn.create({'bind': this, 'event': true});
		this.$events[type].values.push(fn);
		return (Element.NativeEvents.contains(realType)) ? this.addListener(realType, fn) : this;
	},
	removeEvent: function(type, fn){
		if (!this.$events || !this.$events[type]) return this;
		var pos = this.$events[type].keys.indexOf(fn);
		if (pos == -1) return this;
		var key = this.$events[type].keys.splice(pos,1)[0];
		var value = this.$events[type].values.splice(pos,1)[0];
		var custom = Element.Events[type];
		if (custom){
			if (custom.remove) custom.remove.call(this, fn);
			if (custom.type) type = custom.type;
		}
		return (Element.NativeEvents.contains(type)) ? this.removeListener(type, value) : this;
	},
	addEvents: function(source){
		return Element.setMany(this, 'addEvent', source);
	},
	removeEvents: function(type){
		if (!this.$events) return this;
		if (!type){
			for (var evType in this.$events) this.removeEvents(evType);
			this.$events = null;
		} else if (this.$events[type]){
			this.$events[type].keys.each(function(fn){
				this.removeEvent(type, fn);
			}, this);
			this.$events[type] = null;
		}
		return this;
	},
	fireEvent: function(type, args, delay){
		if (this.$events && this.$events[type]){
			this.$events[type].keys.each(function(fn){
				fn.create({'bind': this, 'delay': delay, 'arguments': args})();
			}, this);
		}
		return this;
	},
	cloneEvents: function(from, type){
		if (!from.$events) return this;
		if (!type){
			for (var evType in from.$events) this.cloneEvents(from, evType);
		} else if (from.$events[type]){
			from.$events[type].keys.each(function(fn){
				this.addEvent(type, fn);
			}, this);
		}
		return this;
	}
};
window.extend(Element.Methods.Events);
document.extend(Element.Methods.Events);
Element.extend(Element.Methods.Events);
Element.Events = new Abstract({
	'mouseenter': {
		type: 'mouseover',
		map: function(event){
			event = new Event(event);
			if (event.relatedTarget != this && !this.hasChild(event.relatedTarget)) this.fireEvent('mouseenter', event);
		}
	},
	'mouseleave': {
		type: 'mouseout',
		map: function(event){
			event = new Event(event);
			if (event.relatedTarget != this && !this.hasChild(event.relatedTarget)) this.fireEvent('mouseleave', event);
		}
	},
	'mousewheel': {
		type: (window.gecko) ? 'DOMMouseScroll' : 'mousewheel'
	}
});
Element.NativeEvents = [
	'click', 'dblclick', 'mouseup', 'mousedown', //mouse buttons
	'mousewheel', 'DOMMouseScroll', //mouse wheel
	'mouseover', 'mouseout', 'mousemove', //mouse movement
	'keydown', 'keypress', 'keyup', //keys
	'load', 'unload', 'beforeunload', 'resize', 'move', //window
	'focus', 'blur', 'change', 'submit', 'reset', 'select', //forms elements
	'error', 'abort', 'contextmenu', 'scroll' //misc
];
Function.extend({
	bindWithEvent: function(bind, args){
		return this.create({'bind': bind, 'arguments': args, 'event': Event});
	}
});
Elements.extend({
	filterByTag: function(tag){
		return new Elements(this.filter(function(el){
			return (Element.getTag(el) == tag);
		}));
	},
	filterByClass: function(className, nocash){
		var elements = this.filter(function(el){
			return (el.className && el.className.contains(className, ' '));
		});
		return (nocash) ? elements : new Elements(elements);
	},
	filterById: function(id, nocash){
		var elements = this.filter(function(el){
			return (el.id == id);
		});
		return (nocash) ? elements : new Elements(elements);
	},
	filterByAttribute: function(name, operator, value, nocash){
		var elements = this.filter(function(el){
			var current = Element.getProperty(el, name);
			if (!current) return false;
			if (!operator) return true;
			switch(operator){
				case '=': return (current == value);
				case '*=': return (current.contains(value));
				case '^=': return (current.substr(0, value.length) == value);
				case '$=': return (current.substr(current.length - value.length) == value);
				case '!=': return (current != value);
				case '~=': return current.contains(value, ' ');
			}
			return false;
		});
		return (nocash) ? elements : new Elements(elements);
	}
});
function $E(selector, filter){
	return ($M(filter) || document).getElement(selector);
};
function $ES(selector, filter){
	return ($M(filter) || document).getElementsBySelector(selector);
};
$$M.shared = {
	'regexp': /^(\w*|\*)(?:#([\w-]+)|\.([\w-]+))?(?:\[(\w+)(?:([!*^$]?=)["']?([^"'\]]*)["']?)?])?$/,
	'xpath': {
		getParam: function(items, context, param, i){
			var temp = [context.namespaceURI ? 'xhtml:' : '', param[1]];
			if (param[2]) temp.push('[@id="', param[2], '"]');
			if (param[3]) temp.push('[contains(concat(" ", @class, " "), " ', param[3], ' ")]');
			if (param[4]){
				if (param[5] && param[6]){
					switch(param[5]){
						case '*=': temp.push('[contains(@', param[4], ', "', param[6], '")]'); break;
						case '^=': temp.push('[starts-with(@', param[4], ', "', param[6], '")]'); break;
						case '$=': temp.push('[substring(@', param[4], ', string-length(@', param[4], ') - ', param[6].length, ' + 1) = "', param[6], '"]'); break;
						case '=': temp.push('[@', param[4], '="', param[6], '"]'); break;
						case '!=': temp.push('[@', param[4], '!="', param[6], '"]');
					}
				} else {
					temp.push('[@', param[4], ']');
				}
			}
			items.push(temp.join(''));
			return items;
		},
		getItems: function(items, context, nocash){
			var elements = [];
			var xpath = document.evaluate('.//' + items.join('//'), context, $$M.shared.resolver, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null);
			for (var i = 0, j = xpath.snapshotLength; i < j; i++) elements.push(xpath.snapshotItem(i));
			return (nocash) ? elements : new Elements(elements.map($));
		}
	},
	'normal': {
		getParam: function(items, context, param, i){
			if (i == 0){
				if (param[2]){
					var el = context.getElementById(param[2]);
					if (!el || ((param[1] != '*') && (Element.getTag(el) != param[1]))) return false;
					items = [el];
				} else {
					items = $A(context.getElementsByTagName(param[1]));
				}
			} else {
				items = $$M.shared.getElementsByTagName(items, param[1]);
				if (param[2]) items = Elements.filterById(items, param[2], true);
			}
			if (param[3]) items = Elements.filterByClass(items, param[3], true);
			if (param[4]) items = Elements.filterByAttribute(items, param[4], param[5], param[6], true);
			return items;
		},
		getItems: function(items, context, nocash){
			return (nocash) ? items : $$M.unique(items);
		}
	},
	resolver: function(prefix){
		return (prefix == 'xhtml') ? 'http://www.w3.org/1999/xhtml' : false;
	},
	getElementsByTagName: function(context, tagName){
		var found = [];
		for (var i = 0, j = context.length; i < j; i++) found.extend(context[i].getElementsByTagName(tagName));
		return found;
	}
};
$$M.shared.method = (window.xpath) ? 'xpath' : 'normal';
Element.Methods.Dom = {
	getElements: function(selector, nocash){
		var items = [];
		selector = selector.trim().split(' ');
		for (var i = 0, j = selector.length; i < j; i++){
			var sel = selector[i];
			var param = sel.match($$M.shared.regexp);
			if (!param) break;
			param[1] = param[1] || '*';
			var temp = $$M.shared[$$M.shared.method].getParam(items, this, param, i);
			if (!temp) break;
			items = temp;
		}
		return $$M.shared[$$M.shared.method].getItems(items, this, nocash);
	},
	getElement: function(selector){
		return $M(this.getElements(selector, true)[0] || false);
	},
	getElementsBySelector: function(selector, nocash){
		var elements = [];
		selector = selector.split(',');
		for (var i = 0, j = selector.length; i < j; i++) elements = elements.concat(this.getElements(selector[i], true));
		return (nocash) ? elements : $$M.unique(elements);
	}
};
Element.extend({
	getElementById: function(id){
		var el = document.getElementById(id);
		if (!el) return false;
		for (var parent = el.parentNode; parent != this; parent = parent.parentNode){
			if (!parent) return false;
		}
		return el;
	}/*compatibility*/,
	getElementsByClassName: function(className){ 
		return this.getElements('.' + className); 
	}
});
document.extend(Element.Methods.Dom);
Element.extend(Element.Methods.Dom);
Element.extend({
	getValue: function(){
		switch(this.getTag()){
			case 'select':
				var values = [];
				$each(this.options, function(option){
					if (option.selected) values.push($pick(option.value, option.text));
				});
				return (this.multiple) ? values : values[0];
			case 'input': if (!(this.checked && ['checkbox', 'radio'].contains(this.type)) && !['hidden', 'text', 'password'].contains(this.type)) break;
			case 'textarea': return this.value;
		}
		return false;
	},
	getFormElements: function(){
		return $$M(this.getElementsByTagName('input'), this.getElementsByTagName('select'), this.getElementsByTagName('textarea'));
	},
	toQueryString: function(){
		var queryString = [];
		this.getFormElements().each(function(el){
			var name = el.name;
			var value = el.getValue();
			if (value === false || !name || el.disabled) return;
			var qs = function(val){
				queryString.push(name + '=' + encodeURIComponent(val));
			};
			if ($type(value) == 'array') value.each(qs);
			else qs(value);
		});
		return queryString.join('&');
	}
});
Element.extend({
	scrollTo: function(x, y){
		this.scrollLeft = x;
		this.scrollTop = y;
	},
	getSize: function(){
		return {
			'scroll': {'x': this.scrollLeft, 'y': this.scrollTop},
			'size': {'x': this.offsetWidth, 'y': this.offsetHeight},
			'scrollSize': {'x': this.scrollWidth, 'y': this.scrollHeight}
		};
	},
	getPosition: function(overflown){
		overflown = overflown || [];
		var el = this, left = 0, top = 0;
		do {
			left += el.offsetLeft || 0;
			top += el.offsetTop || 0;
			el = el.offsetParent;
		} while (el);
		overflown.each(function(element){
			left -= element.scrollLeft || 0;
			top -= element.scrollTop || 0;
		});
		return {'x': left, 'y': top};
	},
	getTop: function(overflown){
		return this.getPosition(overflown).y;
	},
	getLeft: function(overflown){
		return this.getPosition(overflown).x;
	},
	getCoordinates: function(overflown){
		var position = this.getPosition(overflown);
		var obj = {
			'width': this.offsetWidth,
			'height': this.offsetHeight,
			'left': position.x,
			'top': position.y
		};
		obj.right = obj.left + obj.width;
		obj.bottom = obj.top + obj.height;
		return obj;
	}
});
window.extend({
	getWidth: function(){
		if (this.webkit419) return this.innerWidth;
		if (window.ie6 || this.opera) return document.body.clientWidth;
		return document.documentElement.clientWidth;
	},
	getHeight: function(){
		if (this.webkit419) return this.innerHeight;
		if (window.ie6 || this.opera) return document.body.clientHeight;
		return document.documentElement.clientHeight;
	},
	getScrollWidth: function(){
		if (this.ie) return Math.max(document.documentElement.offsetWidth, document.documentElement.scrollWidth);
		if (this.webkit) return document.body.scrollWidth;
		return document.documentElement.scrollWidth;
	},
	getScrollHeight: function(){
		if (this.ie) return Math.max(document.documentElement.offsetHeight, document.documentElement.scrollHeight);
		if (this.webkit) return document.body.scrollHeight;
		return document.documentElement.scrollHeight;
	},
	getScrollLeft: function(){
		return this.pageXOffset || document.documentElement.scrollLeft;
	},
	getScrollTop: function(){
		return this.pageYOffset || document.documentElement.scrollTop;
	},
	getSize: function(){
		return {
			'size': {'x': this.getWidth(), 'y': this.getHeight()},
			'scrollSize': {'x': this.getScrollWidth(), 'y': this.getScrollHeight()},
			'scroll': {'x': this.getScrollLeft(), 'y': this.getScrollTop()}
		};
	},
	getPosition: function(){return {'x': 0, 'y': 0};}
});
var Fx = {};
Fx.Base = new Class({
	options: {
		onStart: Class.empty,
		onComplete: Class.empty,
		onCancel: Class.empty,
		transition: function(p){
			return -(Math.cos(Math.PI * p) - 1) / 2;
		},
		duration: 500,
		unit: 'px',
		wait: true,
		fps: 50
	},
	initialize: function(options){
		this.element = this.element || null;
		this.setOptions(options);
		if (this.options.initialize) this.options.initialize.call(this);
	},
	step: function(){
		var time = new Date().getTime();
		if (time < this.time + this.options.duration){
			this.delta = this.options.transition((time - this.time) / this.options.duration);
			this.setNow();
			this.increase();
		} else {
			this.stop(true);
			this.set(this.to);
			this.fireEvent('onComplete', this.element, 10);
			this.callChain();
		}
	},
	set: function(to){
		this.now = to;
		this.increase();
		return this;
	},
	setNow: function(){
		this.now = this.compute(this.from, this.to);
	},
	compute: function(from, to){
		return (to - from) * this.delta + from;
	},
	start: function(from, to){
		if (!this.options.wait) this.stop();
		else if (this.timer) return this;
		this.from = from;
		this.to = to;
		this.change = this.to - this.from;
		this.time = new Date().getTime();
		this.timer = this.step.periodical(Math.round(1000 / this.options.fps), this);
		this.fireEvent('onStart', this.element);
		return this;
	},
	stop: function(end){
		if (!this.timer) return this;
		clearTimeout(this.timer);
		clearInterval(this.timer);
		this.timer = null;
		if (!end) this.fireEvent('onCancel', this.element);
		return this;
	}/*compatibility*/,
	custom: function(from, to){
		return this.start(from, to);
	},
	clearTimer: function(end){
		return this.stop(end);
	}
});
Fx.Base.implement(new Chain, new Events, new Options);
Fx.CSS = {
	select: function(property, to){
		if (property.test(/color/i)) return this.Color;
		var type = $type(to);
		if ((type == 'array') || (type == 'string' && to.contains(' '))) return this.Multi;
		return this.Single;
	},
	parse: function(el, property, fromTo){
		if (!fromTo.push) fromTo = [fromTo];
		var from = fromTo[0], to = fromTo[1];
		if (!$chk(to)){
			to = from;
			from = el.getStyle(property);
		}
		var css = this.select(property, to);
		return {'from': css.parse(from), 'to': css.parse(to), 'css': css};
	}
};
Fx.CSS.Single = {
	parse: function(value){
		return parseFloat(value);
	},
	getNow: function(from, to, fx){
		return fx.compute(from, to);
	},
	getValue: function(value, unit, property){
		if (unit == 'px' && property != 'opacity') value = Math.round(value);
		return value + unit;
	}
};
Fx.CSS.Multi = {
	parse: function(value){
		return value.push ? value : value.split(' ').map(function(v){
			return parseFloat(v);
		});
	},
	getNow: function(from, to, fx){
		var now = [];
		for (var i = 0; i < from.length; i++) now[i] = fx.compute(from[i], to[i]);
		return now;
	},
	getValue: function(value, unit, property){
		if (unit == 'px' && property != 'opacity') value = value.map(Math.round);
		return value.join(unit + ' ') + unit;
	}
};
Fx.CSS.Color = {
	parse: function(value){
		return value.push ? value : value.hexToRgb(true);
	},
	getNow: function(from, to, fx){
		var now = [];
		for (var i = 0; i < from.length; i++) now[i] = Math.round(fx.compute(from[i], to[i]));
		return now;
	},
	getValue: function(value){
		return 'rgb(' + value.join(',') + ')';
	}
};
Fx.Style = Fx.Base.extend({
	initialize: function(el, property, options){
		this.element = $M(el);
		this.property = property;
		this.parent(options);
	},
	hide: function(){
		return this.set(0);
	},
	setNow: function(){
		this.now = this.css.getNow(this.from, this.to, this);
	},
	set: function(to){
		this.css = Fx.CSS.select(this.property, to);
		return this.parent(this.css.parse(to));
	},
	start: function(from, to){
		if (this.timer && this.options.wait) return this;
		var parsed = Fx.CSS.parse(this.element, this.property, [from, to]);
		this.css = parsed.css;
		return this.parent(parsed.from, parsed.to);
	},
	increase: function(){
		this.element.setStyle(this.property, this.css.getValue(this.now, this.options.unit, this.property));
	}
});
Element.extend({
	effect: function(property, options){
		return new Fx.Style(this, property, options);
	}
});
Fx.Styles = Fx.Base.extend({
	initialize: function(el, options){
		this.element = $M(el);
		this.parent(options);
	},
	setNow: function(){
		for (var p in this.from) this.now[p] = this.css[p].getNow(this.from[p], this.to[p], this);
	},
	set: function(to){
		var parsed = {};
		this.css = {};
		for (var p in to){
			this.css[p] = Fx.CSS.select(p, to[p]);
			parsed[p] = this.css[p].parse(to[p]);
		}
		return this.parent(parsed);
	},
	start: function(obj){
		if (this.timer && this.options.wait) return this;
		this.now = {};
		this.css = {};
		var from = {}, to = {};
		for (var p in obj){
			var parsed = Fx.CSS.parse(this.element, p, obj[p]);
			from[p] = parsed.from;
			to[p] = parsed.to;
			this.css[p] = parsed.css;
		}
		return this.parent(from, to);
	},
	increase: function(){
		for (var p in this.now) this.element.setStyle(p, this.css[p].getValue(this.now[p], this.options.unit, p));
	}
});
Element.extend({
	effects: function(options){
		return new Fx.Styles(this, options);
	}
});
/*
 * jQuery UI Accordion 1.6
 * 
 * Copyright (c) 2007 Jörn Zaefferer
 *
 * http://docs.jquery.com/UI/Accordion
 *
 * Dual licensed under the MIT and GPL licenses:
 *   http://www.opensource.org/licenses/mit-license.php
 *   http://www.gnu.org/licenses/gpl.html
 *
 * Revision: $Id: jquery.accordion.js 4876 2008-03-08 11:49:04Z joern.zaefferer $
 *
 */

;(function($) {
	
// If the UI scope is not available, add it
$.ui = $.ui || {};

$.fn.extend({
	accordion: function(options, data) {
		var args = Array.prototype.slice.call(arguments, 1);

		return this.each(function() {
			if (typeof options == "string") {
				var accordion = $.data(this, "ui-accordion");
				accordion[options].apply(accordion, args);
			// INIT with optional options
			} else if (!$(this).is(".ui-accordion"))
				$.data(this, "ui-accordion", new $.ui.accordion(this, options));
		});
	},
	// deprecated, use accordion("activate", index) instead
	activate: function(index) {
		return this.accordion("activate", index);
	}
});

$.ui.accordion = function(container, options) {
	
	// setup configuration
	this.options = options = $.extend({}, $.ui.accordion.defaults, options);
	this.element = container;
	
	$(container).addClass("ui-accordion");
	
	if ( options.navigation ) {
		var current = $(container).find("a").filter(options.navigationFilter);
		if ( current.length ) {
			if ( current.filter(options.header).length ) {
				options.active = current;
			} else {
				options.active = current.parent().parent().prev();
				current.addClass("current");
			}
		}
	}
	
	// calculate active if not specified, using the first header
	options.headers = $(container).find(options.header);
	options.active = findActive(options.headers, options.active);

	if ( options.fillSpace ) {
		var maxHeight = $(container).parent().height();
		options.headers.each(function() {
			maxHeight -= $(this).outerHeight();
		});
		var maxPadding = 0;
		options.headers.next().each(function() {
			maxPadding = Math.max(maxPadding, $(this).innerHeight() - $(this).height());
		}).height(maxHeight - maxPadding);
	} else if ( options.autoheight ) {
		var maxHeight = 0;
		options.headers.next().each(function() {
			maxHeight = Math.max(maxHeight, $(this).outerHeight());
		}).height(maxHeight);
	}

	options.headers
		.not(options.active || "")
		.next()
		.hide();
	options.active.parent().andSelf().addClass(options.selectedClass);
	
	if (options.event)
		$(container).bind((options.event) + ".ui-accordion", clickHandler);
};

$.ui.accordion.prototype = {
	activate: function(index) {
		// call clickHandler with custom event
		clickHandler.call(this.element, {
			target: findActive( this.options.headers, index )[0]
		});
	},
	
	enable: function() {
		this.options.disabled = false;
	},
	disable: function() {
		this.options.disabled = true;
	},
	destroy: function() {
		this.options.headers.next().css("display", "");
		if ( this.options.fillSpace || this.options.autoheight ) {
			this.options.headers.next().css("height", "");
		}
		$.removeData(this.element, "ui-accordion");
		$(this.element).removeClass("ui-accordion").unbind(".ui-accordion");
	}
}

function scopeCallback(callback, scope) {
	return function() {
		return callback.apply(scope, arguments);
	};
}

function completed(cancel) {
	// if removed while animated data can be empty
	if (!$.data(this, "ui-accordion"))
		return;
	var instance = $.data(this, "ui-accordion");
	var options = instance.options;
	options.running = cancel ? 0 : --options.running;
	if ( options.running )
		return;
	if ( options.clearStyle ) {
		options.toShow.add(options.toHide).css({
			height: "",
			overflow: ""
		});
	}
	$(this).triggerHandler("change.ui-accordion", [options.data], options.change);
}

function toggle(toShow, toHide, data, clickedActive, down) {
	var options = $.data(this, "ui-accordion").options;
	options.toShow = toShow;
	options.toHide = toHide;
	options.data = data;
	var complete = scopeCallback(completed, this);
	
	// count elements to animate
	options.running = toHide.size() == 0 ? toShow.size() : toHide.size();
	
	if ( options.animated ) {
		if ( !options.alwaysOpen && clickedActive ) {
			$.ui.accordion.animations[options.animated]({
				toShow: jQuery([]),
				toHide: toHide,
				complete: complete,
				down: down,
				autoheight: options.autoheight
			});
		} else {
			$.ui.accordion.animations[options.animated]({
				toShow: toShow,
				toHide: toHide,
				complete: complete,
				down: down,
				autoheight: options.autoheight
			});
		}
	} else {
		if ( !options.alwaysOpen && clickedActive ) {
			toShow.toggle();
		} else {
			toHide.hide();
			toShow.show();
		}
		complete(true);
	}
}

function clickHandler(event) {
	var options = $.data(this, "ui-accordion").options;
	if (options.disabled)
		return false;
	
	// called only when using activate(false) to close all parts programmatically
	if ( !event.target && !options.alwaysOpen ) {
		options.active.parent().andSelf().toggleClass(options.selectedClass);
		var toHide = options.active.next(),
			data = {
				instance: this,
				options: options,
				newHeader: jQuery([]),
				oldHeader: options.active,
				newContent: jQuery([]),
				oldContent: toHide
			},
			toShow = options.active = $([]);
		toggle.call(this, toShow, toHide, data );
		return false;
	}
	// get the click target
	var clicked = $(event.target);
	
	// due to the event delegation model, we have to check if one
	// of the parent elements is our actual header, and find that
	if ( clicked.parents(options.header).length )
		while ( !clicked.is(options.header) )
			clicked = clicked.parent();
	
	var clickedActive = clicked[0] == options.active[0];
	
	// if animations are still active, or the active header is the target, ignore click
	if (options.running || (options.alwaysOpen && clickedActive))
		return false;
	if (!clicked.is(options.header))
		return;

	// switch classes
	options.active.parent().andSelf().toggleClass(options.selectedClass);
	if ( !clickedActive ) {
		clicked.parent().andSelf().addClass(options.selectedClass);
	}

	// find elements to show and hide
	var toShow = clicked.next(),
		toHide = options.active.next(),
		//data = [clicked, options.active, toShow, toHide],
		data = {
			instance: this,
			options: options,
			newHeader: clicked,
			oldHeader: options.active,
			newContent: toShow,
			oldContent: toHide
		},
		down = options.headers.index( options.active[0] ) > options.headers.index( clicked[0] );
	
	options.active = clickedActive ? $([]) : clicked;
	toggle.call(this, toShow, toHide, data, clickedActive, down );

	return false;
};

function findActive(headers, selector) {
	return selector != undefined
		? typeof selector == "number"
			? headers.filter(":eq(" + selector + ")")
			: headers.not(headers.not(selector))
		: selector === false
			? $([])
			: headers.filter(":eq(0)");
}

$.extend($.ui.accordion, {
	defaults: {
		selectedClass: "selected",
		alwaysOpen: true,
		animated: 'slide',
		event: "click",
		header: "a",
		autoheight: true,
		running: 0,
		navigationFilter: function() {
			return this.href.toLowerCase() == location.href.toLowerCase();
		}
	},
	animations: {
		slide: function(options, additions) {
			options = $.extend({
				easing: "swing",
				duration: 300
			}, options, additions);
			if ( !options.toHide.size() ) {
				options.toShow.animate({height: "show"}, options);
				return;
			}
			var hideHeight = options.toHide.height(),
				showHeight = options.toShow.height(),
				difference = showHeight / hideHeight;
			options.toShow.css({ height: 0, overflow: 'hidden' }).show();
			options.toHide.filter(":hidden").each(options.complete).end().filter(":visible").animate({height:"hide"},{
				step: function(now) {
					var current = (hideHeight - now) * difference;
					if ($.browser.msie || $.browser.opera) {
						current = Math.ceil(current);
					}
					options.toShow.height( current );
				},
				duration: options.duration,
				easing: options.easing,
				complete: function() {
					if ( !options.autoheight ) {
						options.toShow.css("height", "auto");
					}
					options.complete();
				}
			});
		},
		bounceslide: function(options) {
			this.slide(options, {
				easing: options.down ? "bounceout" : "swing",
				duration: options.down ? 1000 : 200
			});
		},
		easeslide: function(options) {
			this.slide(options, {
				easing: "easeinout",
				duration: 700
			})
		}
	}
});

})(jQuery);
;var Json = {
	toString: function(obj){
		switch($type(obj)){
			case 'string':
				return '"' + obj.replace(/(["\\])/g, '\\$1') + '"';
			case 'array':
				return '[' + obj.map(Json.toString).join(',') + ']';
			case 'object':
				var string = [];
				for (var property in obj) string.push(Json.toString(property) + ':' + Json.toString(obj[property]));
				return '{' + string.join(',') + '}';
			case 'number':
				if (isFinite(obj)) break;
			case false:
				return 'null';
		}
		return String(obj);
	},
	evaluate: function(str, secure){
		return (($type(str) != 'string') || (secure && !str.test(/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/))) ? null : eval('(' + str + ')');
	}
};
var lang=[];
$j=jQuery;
function __(str){
	if(lang[str])str=lang[str];
	return str;
}
function $F(n,v){
	var o=$M(n),i=0;
	if(!o)return v?v:'';
	if(o.type=='checkbox')return o.checked;
	if(o.type!='radio')return o.value;
	var os=getEls('input',o.parentNode.parentNode.parentNode),a=[];
	for(;i<os.length;++i)if(os[i].type=='radio' && os[i].name==n)a.push(os[i]);
	for(i=0;i<a.length;++i)if(a[i].checked)return a[i].value;
	return '';
}
function $type(obj){
	if (obj==undefined) return false;
	if (obj.htmlElement) return 'element';
	var type = typeof obj;
	if (type == 'object' && obj.nodeName){
		switch(obj.nodeType){
			case 1: return 'element';
			case 3: return (/\S/).test(obj.nodeValue) ? 'textnode' : 'whitespace';
		}
	}
	if (type == 'object' || type == 'function'){
		switch(obj.constructor){
			case Array: return 'array';
			case RegExp: return 'regexp';
		}
		if (typeof obj.length == 'number'){
			if (obj.item) return 'collection';
			if (obj.callee) return 'arguments';
		}
	}
	return type;
};
function addClass(o,c){
	setClass(o,getClassName(o)+' '+c);
}
function addEls(p,c){
	if(!p)return;
	if($type(p)=='string')p=document.getElementById(p);
	if(isArray(c))for(var i=0;i<c.length;++i)addEls(p,c[i]);
	else if(c)p.appendChild($type(c)=='string'||(+c)===c?newText(c):c);
	return p;
}
function addCell(a,b,c,d,e){
	var f=a.insertCell(b);
	f.colSpan=c;
	addEls(f,d);
	return setClass(f,e);
}
function addCells(r,c,a){
	for(var i=0;i<a.length;++i)addCell(r,c+parseInt(i),a[i].length>2?a[i][2]:1,a[i][0],(a[i].length>1?a[i][1]:0));
}
function boxdropTracer(f,t){
	var ef=$M(f),et=$M(t);
	if(!ef||!et)return;
	var wf=ef.offsetWidth,hf=ef.offsetHeight;
	var xf=getOffset(ef,'Left')+(wf/2),yf=getOffset(ef,'Top')+(hf/2),xt=getOffset(et,'Left')+(et.offsetWidth/2),yt=getOffset(et,'Top')+(et.offsetHeight);
	var d=Math.sqrt((xf-xt)*(xf-xt)+(yf-yt)*(yf-yt));
	if(d<5)return;
	var i=boxdropTracers.length;
	boxdropTracers[i]={dx:xt,dy:yt,x:xf,y:yf,width:wf,height:hf,opacity:.8};
	setTimeout('boxdropTracerStep('+i+')',100);
}
function boxdropTracerStep(id){
	var el=$M('boxdropTracer'+id);
	if(!el){
		el=newEl('div','boxdropTracer'+id,'boxdroptracer');
		el.setStyles({
			'border':'1px solid red',
			'background':'#ff0',
			'height':0,
			'width':0,
			'position':'absolute',
			'left':0,
			'top':0
		});
		addEls(document.body,el);
	}
	with(boxdropTracers[id]){
		x=dx+(x-dx)*.9;
		y=dy+(y-dy)*.9;
		width*=.9;
		height*=.9;
		opacity*=.9;
		if(width<1&&height<1){
			delEl(el);
			boxdropTracers[id]=null;
			return;
		}
		el.setStyles({
			'opacity':opacity,
			'width':width,
			'height':height,
			'left':parseInt(x-width/2),
			'top':parseInt(y-height/2)
		
		});
	}
	setTimeout("boxdropTracerStep("+id+")",100);
}
function Browser(){
	var ua=navigator.userAgent;
	this.isFirefox=ua.indexOf('Firefox')>=0;
	this.isOpera=ua.indexOf('Opera')>=0;
	this.isIE=ua.indexOf('MSIE')>=0&&!this.isOpera;
	this.isSafari=ua.indexOf('Safari')>=0;
	this.isKonqueror=ua.indexOf('KHTML')>=0&&!this.isSafari;
	this.versionMinor=parseFloat(navigator.appVersion);
	if(this.isIE)this.versionMinor=parseFloat(ua.substring(ua.indexOf('MSIE')+5));
	this.versionMajor=parseInt(this.versionMinor);
}
function date_m2h(d,type){
	if(d=='' || d=='0000-00-00')return '-';
	if(!type)type='date';
	date=d.replace(/([0-9]+)-([0-9]+)-([0-9]+).*/,'$3-$2-$1',d).replace(/-0/g,'-');
	var m=months[date.replace(/.*-([0-9]+)-.*/,'$1')];
	date=date.replace(/-[0-9]+-/,'-'+m+'-');
	if(type=='date')return date;
	var time=d.replace(/.* /,'');
	if(type=='time')return time;
	return time+', '+date;
}
function delEl(o){
	if($type(o)=='array')for(var i=0;i<o.length;++i)delEl(o[i]);
	else{
		if($type(o)=='string')o=document.getElementById(o);
		if(o&&o.parentNode)o.parentNode.removeChild(o);
	}
}
function event_target(e){ // taken from http://www.quirksmode.org/js/events_properties.html
	var targ;
	if (!e) var e = window.event;
	if (e.target) targ = e.target;
	else if (e.srcElement) targ = e.srcElement;
//	if (targ.nodeType == 3) // defeat Safari bug
//		targ = targ.parentNode;
	return targ;
}
function fixed(v,f){
	v=parseFloat(v);
	var l=Math.floor(f),a=v,c='',r=0;
	v=v.toFixed?v.toFixed((f-l)*10):v;
	while(a>=1){
		++r;
		a/=10;
	}
	for(;l>r;++r)c+='0';
	return c+v;
}
function getClassName(el){
	return el&&el.className?el.className:'';
}
function getEvent(e){
	return e?e:(window.event?window.event:"");
}
function getParentWithClass(e,t,c) {
	while(e!=null){
		if(t!=null&&e.tagName==t&&hasClass(e,c))return e;
		e=e.parentNode;
	}
}
function hasClass(o,c){
	return eval('/(^| )'+c+'( |$)/').test(getClassName($M(o)));
}
function initialise(){
	alert('function initialise() no longer needs to be called from the HTML template. please remove it');
}
function initShowHide(vis,objName){
	if(!objName)objName='';
	var els=$ES('div.showhide'),i;
	for(var i=0;i<els.length;++i){
		var thisvis=vis?1:(hasClass(els[i],'show')?1:0);
		var link=newLink('javascript:showhide('+(++showhideNum)+');',thisvis?'[hide'+objName+']':'[show'+objName+']','showhideLink'+showhideNum,'showhideLink');
		els[i].parentNode.insertBefore(link,els[i]);
		els[i].id='showhideDiv'+showhideNum;
		els[i].style.display=thisvis?'block':'none';
		removeClassName(els[i],'showhide');
	}
	return els.length-1;
}
function isArray(o){
	return o instanceof Array||typeof o=='array';
}
function isLoaded(url){
	for(var i=0;i<loadedScripts.length;++i)if(loadedScripts[i]==url)return 1;
}
// { kaejax
function kaejax_create_functions(url,f){
	kaejax_is_loaded=1;
	for(var i=0;i<f.length;++i){
		eval('window.x_'+f[i]+'=function(){kaejax_do_call("'+f[i]+'",arguments)}');
		function_urls[f[i]]=url;
	}
}
function kaejax_do_call(func_name,args){
	var uri=function_urls[func_name];
	if(!window.kaejax_timeouts[uri]){
		window.kaejax_timeouts[uri]={t:setTimeout('kaejax_sendRequests("'+uri+'")',1),c:[],callbacks:[]};
	}
	var l=window.kaejax_timeouts[uri].c.length,v2=[];
	for(var i=0;i<args.length-1;++i){
		v2[v2.length]=args[i];
	}
	window.kaejax_timeouts[uri].c[l]={f:func_name,v:v2};
	window.kaejax_timeouts[uri].callbacks[l]=args[args.length-1];
}
function kaejax_sendRequests(uri){
	var throbber=document.getElementById('throbber');
	if(!throbber){
		var throbber=newEl('div','throbber');
		document.body.appendChild(throbber);
	}
	var t=window.kaejax_timeouts[uri],callbacks=window.kaejax_timeouts[uri].callbacks;
	t.callbacks=null;
	window.kaejax_timeouts[uri]=null;
	var x=new XMLHttpRequest(),post_data="kaejax="+escape(Json.toString(t)).replace(/%([89A-F][A-Z0-9])/g,'%u00$1').replace('+','%2B');
	x.open('POST',uri,true);
	x.setRequestHeader("Method","POST "+uri+" HTTP/1.1");
	x.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
	x.onreadystatechange=function(){
		if(x.readyState!=4)return;
		var v=eval('('+unescape(x.responseText.replace(/%/g,'%25'))+')');
		var f,p;
		for(var i=0;i<t.c.length;++i){
			var f=callbacks[i],p=[];
			p=[];
			if($type(f)=='array'){
				p=f;
				f=f[0];
			}
			if(f)f(v[i],p);
		}
		throbber.style.display='none';
	}
	var w=getWindowSize(),s=getWindowScrollAt();
	throbber.style.display='block';
	throbber.style.position='absolute';
	throbber.style.right=0;
	throbber.style.top=0;
	throbber.style.width='16px';
	throbber.style.height='16px';
	throbber.style.background='url(/i/throbber.gif)';
	throbber.style.zIndex=30;
	x.send(post_data);
}
// }
function lightbox_createFrame(){
	if($M('shader'))return $M('shader').imgSize;
	{ // shader
		var shader=new Element('div',{
			'id':'shader',
			'styles':{
				'position':'fixed',
				'left':0,
				'top':0,
				'width':'100%',
				'height':'100%',
				'background':'#000 url(/i/ajax-loader.gif) no-repeat center center',
				'opacity':.7,
				'z-index':1
			},
			'events':{
				'keyup':lightbox_remove
			}
		});
		$(shader).click(lightbox_remove);
		document.body.appendChild(shader);
	}
	{ // sizes
		var s=window.getSize().size;
		var frameSize={x:parseInt(s.x*.65),y:parseInt(s.y*.95)};
		var imgSize={x:frameSize.x-40,y:frameSize.y-40};
		shader.imgSize=imgSize;
	}
	return imgSize;
}
function lightbox_show(src,caption){
	if(!caption)caption='';
	imgSize=lightbox_createFrame();
	if(/kfmget/.test(src))src+=',width='+imgSize.x+',height='+imgSize.y;
	var lightboxdiv=new Element('div',{
		'id':'lightboxdiv',
		'styles':{
			'position':'fixed',
			'left':0,
			'top':0,
			'width':'100%',
			'height':'100%',
			'z-index':2,
			'background':'url('+src+') no-repeat center center'
		},
		'events':{
			'keyup':lightbox_remove
		}
	});
	$(lightboxdiv).click(lightbox_remove);
	var lightboxcaption=new Element('div',{
		'id':'lightboxcaption',
		'styles':{
			'position':'fixed',
			'left':0,
			'bottom':0,
			'width':'100%',
			'z-index':3,
			'text-align':'center'
		}
	});
	lightboxcaption.appendText(caption);
	document.body.appendChild(lightboxdiv);
	document.body.appendChild(lightboxcaption);
	return false;
}
function lightbox_remove(){
	$M('shader').remove();
	$M('lightboxdiv').remove();
	$M('lightboxcaption').remove();
}
function loadAjaxMenu(){
	var el=$('.ajaxmenu')[0];
	if(!el)return;
	var id=el.id.replace(/ajaxmenu/,'');
	if(id && id=='am_top')return;
	loadScript('/ajax/menu.php?pageid='+pagedata.id+'&search_options='+($(el).hasClass('products')?1:0));
}
function loadArray(k,v){
	var a=[],i;
	k.each(function(val,key){
		a[val]=c[key];
	});
	return a;
}
function loadDateClass(skipload){
	if(skipload){
		if(!window.inputdate_ids)window.inputdate_ids=[];
		var els=$('.inputdate');
		els.each(function(key,el){
			$(el).removeClass('inputdate');
			if(!el.id)el.id='inputdate'+window.inputdate_ids.length;
			window.inputdate_ids.push(el.id);
			$(el).datepicker({dateFormat:'dd/mm/yy'});
		});
	}
	else loadJS('/j/ui.datepicker.js',0,0,'loadDateClass(1)',1);
}
function loadFormValidation(skipload){
	if(skipload){
		if(!window.formvalidation_ids)window.formvalidation_ids=[];
		var els=$('.formvalidation');
		els.each(function(key,el){
			$(el).removeClass('formvalidation');
			if(!el.id)el.id='formvalidation'+window.formvalidation_ids.length;
			window.formvalidation_ids.push(el.id);
			$(el).validate();
		});
	}
	else loadJS('/j/jquery.validate.min.js',0,0,'loadFormValidation(1)',1);
}
function loadJS(url,id,lang,onload,runanyway){
	var i=0;
	for(;i<loadedScripts.length;++i){
		if(loadedScripts[i]==url){
			if(onload && runanyway)return eval(onload);
			return 0;
		}
	}
	loadedScripts.push(url);
	var el=newScript(url);
	if(id){
		el.id=id;
	}
	if(lang){
		el.lang=lang;
	}
	if(onload){
		el.onload_triggered=0;
		el.onload=function(){
			if(!this.onload_triggered++){
				eval(onload);
			}
		};
		el.onreadystatechange=function(){
			if(this.readyState=='loaded'||this.readyState=='complete'){
				if(!this.onload_triggered++){
					eval(onload);
				}
			}
		};
	}
	document.getElementsByTagName('head')[0].appendChild(el);
	return 1;
}
function loadScript(url){
	if(isLoaded(url))return 0;
	loadedScripts.push(url);
	if(kaejax_is_loaded&&/\.php/.test(url))url+=(/\?/.test(url)?'&':'?')+'kaejax_is_loaded';
	var el=newScript(url);
	document.getElementsByTagName('head')[0].appendChild(el);
	return 1;
}
function newScript(url){
	var el;
	if(document.ie)el=document.createElement('<script type="text/javascript" src="'+url+'"></script>');
	else{
		el=newEl('script');
		X(el,{type:"text/javascript",src:url});
	}
	return el;
}
function loadUrl(url){
	document.location=url;
}
function formShow(containedForm,title,actions){
	var form=newEl('div');
	form.className='modal_centre';
	form.appendChild(containedForm);
	var body=document.body,shader=newEl('div','shader'),scrollAt=browser.isIE?getWindowScrollAt():{x:0,y:0},a=getWindowSize(),wx=0,wy=0,pos=browser.isIE?'absolute':'fixed',i;
	{ // shader
		shader.setStyles({
			'background':'#fff',
			'opacity':.5,
			'position':pos,
			'top':scrollAt.y,
			'left':scrollAt.x,
			'z-index':2,
			'width':a.x,
			'height':a.y
		});
		addEls(body,shader);
	}
	{ // wrapper
		var wrapper=newEl('div','formWrapper');
		wrapper.setStyle('visibility','hidden');
		var h2=newEl('h2',0,0,title);
		h2.className='modal_header';
		h2.setStyle('float','left');
		form.setStyles({
			'position':'relative',
			'margin':0,
			'text-align':'left',
			'clear':'left'
		});
		addEls(wrapper,[h2,form]);
		{ // link row
			var row=newEl('div'),buttonStyle={
				'float':'right',
				'border':'1px solid',
				'border-color':'#ccc #666 #666 #ccc',
				'display':'block',
				'background':'#ddd',
				'color':'#000',
				'text-decoration':'none',
				'margin':2
			};
			row.className='modal_links';
			var link=newLink('javascript:formHide()','Close',0,'button');
			link.setStyles(buttonStyle);
			addEls(row,link);
			if(actions&&actions.length)for(var i=0;i<actions.length;++i){
				var v=actions[i];
				if(v[1].toString()===v[1])link=newLink('javascript:'+v[1]+'()',v[0],0,'button');
				else{
					link=newLink('#',v[0],0,'button');
					$(link).click(function(){
						v[1][0][v[1][1]]();
						return false;
					});
				}
				link.setStyles(buttonStyle);
				addEls(row,link);
			}
			addEls(wrapper,row);
		}
		row.setStyles({
			'background':'#eee',
			'border-top':'1px solid #ddd',
			'text-align':'right',
			'padding':2,
			'z-index':3
		})
		addEls(body,wrapper);
		form.setStyle('width',containedForm.offsetWidth+'px');
		wrapper.setStyles({
			'position':'absolute',
			'width':form.offsetWidth
		});
		var w=wrapper.offsetWidth;
		if(w<200||w>a.x*.9){
			w=w<200?200:parseInt(a.x*.9);
			wrapper.setStyle('width',w);
		}
		var h=browser.isIE?wrapper.offsetHeight:h2.offsetHeight+form.offsetHeight+row.offsetHeight,q=browser.isIE?1:0,r=browser.isIE?0:4;
		if(parseFloat(h)>parseFloat(a.y*.9)){
			h=parseInt(a.y*.8);
			var h3=h-row.offsetHeight-h2.offsetHeight-q;
			form.setStyles({
				'margin':'0 auto',
				'overflow':'auto',
				'height':h3,
				'max-height':h3
			});
		}
		else{
			var h3=h-row.offsetHeight-h2.offsetHeight-q;
			form.setStyles({
				'overflow':'auto',
				'width':'100%',
				'max-height':h3
			});
		}
		wrapper.setStyles({
			'position':pos,
			'left':scrollAt.x+a.x/2-w/2,
			'top':scrollAt.y+a.y/2-h/2,
			'background':'#fff',
			'z-index':3,
			'border':'1px solid #000',
			'visibility':'visible'
		});
	}
	if(inAdmin)initFckEditor();
}
// { multiselects
function ms_convert(){
	do{
		var found=0,a=getEls('select');
		for(var b=0;b<a.length,!found;++b){
			var ms=a[b];
			if(ms==null)break;
			var name=ms.name.replace(/\[\]$/,'');
			if(ms&&ms.multiple){
				{ // common variables
					ms_select_defaults[name]=[];
					var found=1,disabled=ms.disabled?1:0,msw=ms.offsetWidth,msh=ms.offsetHeight;
					if(msw<120)msw=120;
					if(msh<60)msh=60;
				}
				{ // set up wrapper
					var wrapper=newEl('div'),k={width:msw+'px',height:msh+'px',position:'relative',border:'2px solid #000',borderColor:'#333 #ccc #ccc #333',font:'10px sans-serif'};
					if(disabled)k.background='#ddd';
					X(wrapper.style,k);
				}
				if(ms_show_toplinks){ /* reset, all, none */
					var c="alert('selection disabled')",d="ms_selectall('"+name+"','",e="javascript:";
					var f=disabled?{a:c,b:c,c:c}:{a:d+"checked');",b:d+"');",c:d+"reset');"};
					addEls(wrapper,[newLink(e+f.a,'all'),', ',newLink(e+f.b,'none'),', ',newLink(e+f.c,'reset')]);
				}
				{ // setup ms
					var newms=newEl('div'),g=browser.isIE?{w:msw-4,h:19}:{w:msw,h:15},h=ms_show_toplinks?{t:'15px',h:msh-g.h}:{t:0,h:msh};
					X(newms.style,{position:'absolute',top:h.t,left:0,overflow:'auto',width:g.w+'px',height:h.h+'px'});
				}
				c=ms.getElementsByTagName('option');
				for(d=0;d<c.length;d++){
					var label=newEl('label'),k={display:'block',border:'1px solid #eee',borderWidth:'1px 0',font:'10px arial',lineHeight:'10px',paddingLeft:'20px'};
					if(browser.isIE){
						checkbox=document.createElement('<input type="checkbox" name="'+ms.name+'" value="'+c[d].innerHTML+'" />');
					}
						else{
						checkbox=newEl('input');
						X(checkbox.style,{marginLeft:'-16px',marginTop:'-2px'});
						X(checkbox,{type:'checkbox',name:ms.name,value:c[d].value});
					}
					if(c[d].selected){
						X(checkbox,{checked:'checked',defaultChecked:true});
						X(k,{background:'blue',color:'#fff'});
					}
					if(c[d].disabled){
						checkbox.disabled='disabled';
						X(k,{background:'#fff',color:'#666'});
					}
					X(label.style,k);
					checkbox.onchange=checkbox.onclick=new Function('ms_updateBackground(this)');
					ms_select_defaults[name][d]=c[d].selected?'checked':'';
					if(disabled)checkbox.disabled="disabled";
					addEls(label,[checkbox,c[d].innerHTML.replace(/\&nbsp;?/g,' ').replace(/\&lt;?/g,'<').replace(/\&gt;?/g,'>')]);
					newms.appendChild(label);
				}
				wrapper.appendChild(newms);
				ms.parentNode.insertBefore(wrapper,ms);
				ms.parentNode.removeChild(ms);
			}
		}
	}while(found);
}
function ms_hasSelected(name){
	var els=document.getElementsByTagName('input');
	for(var i=0;i<els.length;++i)if((els[i].name==name+'[]'||els[i].name==name)&&els[i].checked)return true;
	return false;
}
function ms_selectall(name,val){
	var els=document.getElementsByTagName('input'),found=0;
	for(var i=0;i<els.length;++i)if((els[i].name==name+'[]'||els[i].name==name)&&!els[i].disabled){
		els[i].checked=val=='reset'?ms_select_defaults[name][found++]:val;
		ms_updateBackground(els[i]);
	}
}
function ms_updateBackground(el){
	var p=el.parentNode,c=el.checked?true:false,s=c?{b:'blue',c:'#fff'}:{b:'#fff',c:'#000'};
	X(p.style,{backgroundColor:s.b,color:s.c});
}
// }
function newImg(a,id,title){
	return X(newEl('img'),{'src':a,'id':id,'title':title});
}
function newInput(n,t,v,cl){
	var b;
	if(!t)t='text';
	switch(t){
		case 'checkbox':{
			b=X(newEl('input',n),{type:'checkbox'});
			if(v)b.checked=true;
			b.style.width='auto';
			break;
		}
		case 'date':case 'datetime':{
			{ // break the value into components
				if(v){
					var p=v.split(/[- :]/);
					var year=p[0],month=p[1],day=p[2],hour=p[3],minute=p[4];
				}else{
					var today=new Date();
					var year=today.getFullYear(),month=today.getMonth()+1,day=today.getDate(),hour=today.getHours(),minute=today.getMinutes();
					v=year+'-'+fixed(month,2)+'-'+fixed(day,2)+' '+hour+':'+minute;
				}
			}
			{ // draw the table
				var b=X(newEl('table'),{className:'borderedTable'}),row;
				b.style.width='auto';
				row=addRow(b,0);
				var y=newNumberRange(2000,2030);
				y.unshift('----');
				var d=newNumberRange(1,31,2);
				d.unshift('--');
				addEls(row.insertCell(0),[newSelectbox(n+'_month',newNumberRange(0,12,2),months,month,updateInputVal),newInput(n,'hidden',v)]);
				addCells(row,1,[[newSelectbox(n+'_day',d,0,day,updateInputVal)],[newSelectbox(n+'_year',y,0,year,updateInputVal)]]);
				if(t=='datetime'){ // time
					addCells(row,3,[[newText('-')],[newSelectbox(n+'_hour',newNumberRange(0,23,2),0,hour,updateInputVal)],[newSelectbox(n+'_minute',newNumberRange(0,59,2),0,minute,updateInputVal)]]);
				}
			}
			break;
		}
		case 'radio':{
			b=X(newEl('input',n),{type:'radio',value:v,checked:cl});
			break;
		}
		case 'textarea':{
			b=newEl('textarea',n);
			break;
		}
		default:{
			b=X(newEl('input',n),{type:t});
		}
	}
	if(v){
		if(t=='checkbox')b.checked=b.defaultChecked='checked';
		else if(t!='datetime')b.value=v;
	}
	return setClass(b,cl);
}
function newLink(h,t,id,c){
	return X(newEl('a',id,c,t),{href:h});
}
function newNumberRange(from,to,padding){
	var arr=[],i=0;
	for(;i<to-from+1;++i){
		arr[i]=''+(from+i);
		while(arr[i].length<padding)arr[i]='0'+arr[i];
	}
	return arr;
}
function newSelectbox(name,keys,vals,s,f){
	var el2=newEl('select',name),el3,s2=0,i;
	if(!s)s=0;
	if(!vals)vals=keys;
	for(var i=0;i<vals.length;++i){
		if(!vals[i])vals[i]='';
		var v1=vals[i].toString();
		var v2=v1.length>20?v1.substr(0,27)+'...':v1;
		el3=X(newEl('option',0,0,v2),{value:keys[i],title:v1});
		if(keys[i]==s)s2=i;
		addEls(el2,el3);
	}
	el2.selectedIndex=s2;
	if(f)el2.onchange=f;
	return el2;
}
function newText(a){
	return document.createTextNode(a);
}
function removeChildren(a){
	switch($type(a)){
		case 'array':
			for(var i=0;i<a.length;++i)removeChildren(a[i]);
			return;
		case 'string':
			a=document.getElementById(a);
	}
	if(!a)return;
	a.innerHTML='';
	return a;
}
function removeClassName(el,name){
	return $M(el).removeClass(name);
}
function replaceEl(f,t){
	if(f)f.parentNode.replaceChild(t,f);
}
function removeRowIfEmpty(el){
	if(!el){
		el=$ES('.removeRowIfEmpty');
		el.each(removeRowIfEmpty);
		return;
	}
	if(el.innerHTML!='')return;
	while(el&&el.tagName!='TR')el=$M(el.parentNode);
	if(el)el.remove();
}
function setAttribute(o,n,v){
	if(!n||!o)return;
	if(n=='width'||n=='height')v=v+'px';
	if(n=='class')setClass(o,v);
	else if(n=='style'&&browser.isIE)$M(o).setStyles(v);
	else if(n=='onchange'&&browser.isIE){
		var t=n.replace(/^on/,''),f=new Function(v);
		o.addEvent(t,f);
	}
	else o.setAttribute(n,v);
}
function setClass(o,c){
	if(o&&(c||getClassName(o)))o.className=c?c:'';
	return o;
}
function setPos(a,b,c){
	$M(a).setStyles({
		'left':b,
		'top':c
	});
}
function showhide(id){
	var el=$M('showhideDiv'+id),link=$M('showhideLink'+id);
	var objName=link.innerHTML.replace(/^\[(show|hide)(.*)\]/,'$2');
	var a=el.style.display=='block'?{d:'none',t:'[show'}:{d:'block',t:'[hide'};
	el.style.display=a.d;
	link.replaceChild(newText(a.t+objName+']'),link.childNodes[0]);
}
function text2html(text,nobr){
	if(!window.xhtmlentities){
		var a,b='';
		window.xhtmlentities=$H({'&':'amp',' ':'nbsp','¡':'iexcl','¢':'cent','£':'pound','¤':'curren','¥':'yen','¦':'brvbar','§':'sect','¨':'uml','©':'copy','ª':'ordf','«':'laquo','¬':'not','­':'shy','®':'reg','¯':'macr','°':'deg','±':'plusmn','²':'sup2','³':'sup3','´':'acute','µ':'micro','¶':'para','·':'middot','¸':'cedil','¹':'sup1','º':'ordm','»':'raquo','¼':'frac14','½':'frac12','¾':'frac34','¿':'iquest','×':'times','÷':'divide','"':'quot','<':'lt','>':'gt','ˆ':'circ','˜':'tilde',' ':'ensp',' ':'emsp',' ':'thinsp','–':'ndash','—':'mdash','‘':'lsquo','’':'rsquo','‚':'sbquo','“':'ldquo','”':'rdquo','„':'bdquo','†':'dagger','‡':'Dagger','‰':'permil','‹':'lsaquo','›':'rsaquo','€':'euro'});
		xhtmlentities.each(function(val,key){
			b+=key;
		});
		window.xhtmlentitiesreg=new RegExp('['+b+']');
	}
	text=unescape(text);
	if(xhtmlentitiesreg.test(text))a=1;
	if(text.indexOf('&')!=-1 && /\&amp;([a-z]*);/.test(text))text=text.replace(/\&amp;([a-z]*);/g,'&$1;');
	if(!nobr)text=text.replace(/\n/g,'<br />');
	if(browser.isSafari)text=text.replace(/\r/g,'');
	return text;
}
function toFixed(a,b){
	a=parseFloat(a);
	return a.toFixed?a.toFixed(b):a;
}
function updateInputVal(e){
	var id=(new Event(e)).target.id.replace(/_[^_]*$/,'');
	var y=$F(id+'_year'),m=$F(id+'_month'),d=$F(id+'_day');
	if(y=='----')y='0000';
	if(d=='--')d='00';
	$M(id).value=y+'-'+m+'-'+d+' '+$F(id+'_hour','00')+':'+$F(id+'_minute','00')+':00';
}
function webme_start(){
//	$("img").lazyload({ threshold : 20, effect : "fadeIn" });
	if(getEls('select').length)ms_convert();
	var p=window.plugins_to_load;
	if(p.adblock)            loadScript('/ajax/ads.php?pageid='+pagedata.id);
	if(p.ajaxmenu)           loadAjaxMenu();
	if(p.dbase)              loadScript('/ajax/table.php?pageid='+pagedata.id);
	if(p.eventcalendar)      loadScript('/ajax/events.php?pageid='+pagedata.id);
	if(p.formvalidation)     loadFormValidation();
	if(p.frontend_admin)     loadScript('/ajax/frontend_admin.php?pageid='+pagedata.id);
	if(p.image_gallery)      loadScript('/ajax/image.gallery.php?pageid='+pagedata.id);
	if(p.tabs)               tabs_init();
	if(p.showhide)           initShowHide();
	if(p.fontsize_controls)  loadScript('/j/fonts.js');
	if(p.imagefader)         loadScript('/j/imagefader.js');
	if(p.inputdate)          loadDateClass();
	if(p.os_basket)          loadScript('/ajax/os_basket.php');
	if(p.os_countries)       loadScript('/j/os_countries.js');
	if(p.os_discount_codes)  loadScript('/j/os_discount_codes.js');
	if(p.os_payment_types)   loadScript('/j/os_payment_types.js');
	if(p.os_payment_vouchers)loadScript('/ajax/os_vouchers.php');
	if(p.os_quickfind)       loadScript('/ajax/os_quickfind.php?pageid='+pagedata.id);
	if(p.removeRowIfEmpty)   removeRowIfEmpty();
	if(p.sc_search)          loadScript('/ajax/sc_search.php?pageid='+pagedata.id);
	if(p.scrollingEvents)    loadScript('/j/scrollingEvents.js');
	if(p.scrollingNews)      loadScript('/j/scroller.js');
	if(p.vkfade)             loadJS('/j/jquery.fade.js',0,0,"$('.fademe').vkfade()");

	// the following items have not yet been optimised at the PHP source
  if(p.eventsAdmin)      loadScript('/admin/ajax/events.admin.php?pageid='+pagedata.id);
	if(p.newsAdmin)        loadScript('/admin/ajax/news.admin.php?pageid='+pagedata.id);

	if(document.getElementById('webmeComments'))loadScript('/ajax/comments.php?pageid='+pagedata.id);
}
function X(d,s){
	return $.extend(d,s);
}
{ // variables
	var browser=new Browser(),loadedScripts=[],kaejax_is_loaded=0,inCheckout=0;
	var showhideDivs=[],showhideNum=0,months=['--','Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
	var boxdropTracers=[],function_urls=[],sc_supplements=[];
	var kaejax_timeouts=[],kaejax_xhrinstances=[],ms_select_defaults=[],ms_show_toplinks=true;
	var FCKEDITOR='fckeditor-2.6.3';
}
function html2dom(str,parent){
	var codeprefixes=['SC_'],lastIndex=str.lastIndexOf('<')+1,obj,substr,indentlevel=charat=0,reg=/[ \/\>].*/;
	if(!lastIndex||str.charAt(str.length-1)!='>')lastIndex=str.length;
	while(charat<lastIndex){
		var addAsInnerHtml=0;
		if(str.charAt(charat)=='<'){ // element
			var end=str.indexOf('>',charat+1),nextChar=str.charAt(charat+1);
			substr=str.substring(charat,end+1);
			var slen=substr.length
			if(nextChar=='!'||nextChar=='?')obj=newEl('!');
			else{
				var tName=substr.substring(1,slen).replace(reg,'');
				obj=newEl(tName);
				if(tName.length+3<slen){
					var i=stage=inquotes=0,name=value='',params=substr.substring(tName.length+2,slen-1),setAttribute=window.setAttribute;
					if(params.charAt(params.length-1)=='/')params=params.substring(0,params.length-1);
					var p1=(' '+params+' ').split(/="/);
					for(var p2=1;p2<p1.length;p2++){
						var name=p1[p2-1].substring(p1[p2-1].lastIndexOf(' ')+1,p1[p2-1].length);
						var value=p1[p2].substring(0,p1[p2].lastIndexOf('" '));
						setAttribute(obj,name,value);
					}
				}
				if(str.charAt(end-1)!='/'){ // not self-closing
					indentlevel=1;
					var subelstart=end+1,tracechar=end,subelend=0;
					while(indentlevel){
						subelend=str.indexOf('<',tracechar+1);
						tracechar=end=str.indexOf('>',subelend+1);
						if(str.charAt(subelend+1)=='/')--indentlevel;
						else if(str.charAt(end-1)!='/')++indentlevel;
					}
					html2dom(str.substring(subelstart,subelend),obj);
				}
			}
			charat=end+1;
		}
		else{ // text
			var end=str.indexOf('<',charat+1)-1,i;
			if(end<1)end=str.length-1;
			var isCode=0,text=str.substring(charat,end+1);
			codeprefixes.each(function(pre){
				if(text.indexOf('%'+pre)!=-1)isCode=1;
			});
			if(isCode){
				text=text.replace(/\n/g,'').replace(/^[^%]*|[^%]*$/g,'');
				var name=text.replace(/^%([^{]*)({.*|)%$/,'$1');
				var values=text.replace(/^%[^{]*{?((.*)}|)%$/,'$2');
				obj=sc_buildWidget(name,values);
			}else{
				var text2=text2html(text,1);
				if(text!=text2||text.indexOf('&')!=-1){
					obj=text2;
					addAsInnerHtml=1;
				}
				else obj=newText(text);
			}
			charat=end+1;
		}
		if(addAsInnerHtml)parent.innerHTML+=obj;
		else addEls(parent,obj);
	}
	return parent;
}
$(document).ready(webme_start);
function tabs_show(a,b){
	if(!document.getElementById('tabs_menu_link_'+a+'_'+b))return;
	var f=tabs_functions[a][b];
	if(f)f();
	for(var i=0;document.getElementById('tabs_menu_link_'+a+'_'+i);++i){
		var el=document.getElementById('tabs_menu_link_'+a+'_'+i);
		el.className=el.className.toString().replace(/active/,'');
		el.style.top='-2px';
		document.getElementById('tabs_page_'+a+'_'+i).style.display='none';
	}
	var el=document.getElementById('tabs_menu_link_'+a+'_'+b);
	el.blur();
	el.className+=' active';
	el.style.top='-1px';
	document.getElementById('tabs_page_'+a+'_'+b).style.display='block';
}
function tabs_init(){
	var a=jQuery('div.tabs');
	if(!a||!a.length)return;
	for(var i=a.length-1;i>-1;--i){
		tabs_instances++;
		tabs_functions[tabs_instances]=[];
		var wrapper=a[i];
		wrapper.className='tabs_wrapper';
		var pages=jQuery('div.tabPage',wrapper),menu;
		menu=document.createElement('div');
		menu.id='tabs_menu_'+tabs_instances;
		menu.className='tabs_menu';
		for(var j=0;j<pages.length;++j){
			var page=pages[j],text;
			page.className='tabs_page';
			page.style.border='1px solid #000';
			var e=jQuery('h2',page)[0];
			if(e){
				text=e.innerHTML;
				e.parentNode.removeChild(e);
			}
			else text='Page '+(j+1);
			link=document.createElement('a');
			link.href='javascript:tabs_show('+tabs_instances+','+j+')';
			link.appendChild(document.createTextNode(text));
			link.id='tabs_menu_link_'+tabs_instances+'_'+j;
			link.className='tabs_menu_link'+(j?'':' active');
			link.style.border='1px solid #000';
			link.style.borderBottom=0;
			link.style.padding='2px 5px';
			link.style.background='#fff';
			link.style.position='relative';
			link.style.top='-2px';
			menu.appendChild(link);
			var ontabshow=page.getAttribute('ontabshow');
			if(ontabshow)tabs_functions[tabs_instances][j]=new Function(ontabshow);
			page.id='tabs_page_'+tabs_instances+'_'+j;
			page.style.display='none';
		}
		wrapper.insertBefore(menu,pages[0]);
		tabs_show(tabs_instances,0);
	}
}
var tabs_instances=0,tabs_functions=[];
function addRow(t,p,c){
	return setClass(t.insertRow(p),c);
}
function formHide(msg){
	delEl(['shader','formWrapper']);
	if(msg)alert(msg);
}
function getEls(i,p){
	if(!i)i='*';
	var p=p?p:document,els=p.getElementsByTagName(i);
	return els;
}
function getMouseAt(e){
	e=getEvent(e);
	var m=getWindowScrollAt();
	m.x+=e.clientX;
	m.y+=e.clientY;
	return m;
}
function getOffset(el,s) {
	var n=parseInt(el['offset'+s]),p=el.offsetParent;
	if(p)n+=getOffset(p,s);
	return n;
}
function getWindowScrollAt(){
	return {x:window.pageXOffset,y:window.pageYOffset};
}
function getWindowSize(){
	return {x:window.innerWidth,y:window.innerHeight};
}
window.getSize=function(){
	return {size:getWindowSize()};
}
function newEl(t,id,cn,els){
	var el=document.createElement(t);
	if(t=='iframe')el.src='/i/blank.gif';
	if(id)X(el,{id:id,name:id});
	if(els){
		if($type(els)=='string')el.innerHTML=els;
		else addEls(el,els);
	}
	if(cn)el.className=cn;
	return el;
}
function newForm(action,method,enctype,target){
	return new Element('form',{
		action:action,
		method:method,
		enctype:enctype,
		target:target
	});
}