/* Prototype JavaScript framework, version 1.6.0.3
 * (c) 2005-2008 Sam Stephenson
 *
 * Prototype is freely distributable under the terms of an MIT-style license.
 * For details, see the Prototype web site: http://www.prototypejs.org/
 *
 *--------------------------------------------------------------------------*/

var Prototype = {
 Version: '1.6.0.3',

 Browser: {
 IE: !!(window.attachEvent &&
 navigator.userAgent.indexOf('Opera') === -1),
 Opera: navigator.userAgent.indexOf('Opera') > -1,
 WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
 Gecko: navigator.userAgent.indexOf('Gecko') > -1 &&
 navigator.userAgent.indexOf('KHTML') === -1,
 MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
 },

 BrowserFeatures: {
 XPath: !!document.evaluate,
 SelectorsAPI: !!document.querySelector,
 ElementExtensions: !!window.HTMLElement,
 SpecificElementExtensions:
 document.createElement('div')['__proto__'] &&
 document.createElement('div')['__proto__'] !==
 document.createElement('form')['__proto__']
 },

 ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
 JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

 emptyFunction: function() { },
 K: function(x) { return x }
};

if (Prototype.Browser.MobileSafari)
 Prototype.BrowserFeatures.SpecificElementExtensions = false;


/* Based on Alex Arnell's inheritance implementation. */
var Class = {
 create: function() {
 var parent = null, properties = $A(arguments);
 if (Object.isFunction(properties[0]))
 parent = properties.shift();

 function klass() {
 this.initialize.apply(this, arguments);
 }

 Object.extend(klass, Class.Methods);
 klass.superclass = parent;
 klass.subclasses = [];

 if (parent) {
 var subclass = function() { };
 subclass.prototype = parent.prototype;
 klass.prototype = new subclass;
 parent.subclasses.push(klass);
 }

 for (var i = 0; i < properties.length; i++)
 klass.addMethods(properties[i]);

 if (!klass.prototype.initialize)
 klass.prototype.initialize = Prototype.emptyFunction;

 klass.prototype.constructor = klass;

 return klass;
 }
};

Class.Methods = {
 addMethods: function(source) {
 var ancestor = this.superclass && this.superclass.prototype;
 var properties = Object.keys(source);

 if (!Object.keys({ toString: true }).length)
 properties.push("toString", "valueOf");

 for (var i = 0, length = properties.length; i < length; i++) {
 var property = properties[i], value = source[property];
 if (ancestor && Object.isFunction(value) &&
 value.argumentNames().first() == "$super") {
 var method = value;
 value = (function(m) {
 return function() { return ancestor[m].apply(this, arguments) };
 })(property).wrap(method);

 value.valueOf = method.valueOf.bind(method);
 value.toString = method.toString.bind(method);
 }
 this.prototype[property] = value;
 }

 return this;
 }
};

var Abstract = { };

Object.extend = function(destination, source) {
 for (var property in source)
 destination[property] = source[property];
 return destination;
};

Object.extend(Object, {
 inspect: function(object) {
 try {
 if (Object.isUndefined(object)) return 'undefined';
 if (object === null) return 'null';
 return object.inspect ? object.inspect() : String(object);
 } catch (e) {
 if (e instanceof RangeError) return '...';
 throw e;
 }
 },

 toJSON: function(object) {
 var type = typeof object;
 switch (type) {
 case 'undefined':
 case 'function':
 case 'unknown': return;
 case 'boolean': return object.toString();
 }

 if (object === null) return 'null';
 if (object.toJSON) return object.toJSON();
 if (Object.isElement(object)) return;

 var results = [];
 for (var property in object) {
 var value = Object.toJSON(object[property]);
 if (!Object.isUndefined(value))
 results.push(property.toJSON() + ': ' + value);
 }

 return '{' + results.join(', ') + '}';
 },

 toQueryString: function(object) {
 return $H(object).toQueryString();
 },

 toHTML: function(object) {
 return object && object.toHTML ? object.toHTML() : String.interpret(object);
 },

 keys: function(object) {
 var keys = [];
 for (var property in object)
 keys.push(property);
 return keys;
 },

 values: function(object) {
 var values = [];
 for (var property in object)
 values.push(object[property]);
 return values;
 },

 clone: function(object) {
 return Object.extend({ }, object);
 },

 isElement: function(object) {
 return !!(object && object.nodeType == 1);
 },

 isArray: function(object) {
 return object != null && typeof object == "object" &&
 'splice' in object && 'join' in object;
 },

 isHash: function(object) {
 return object instanceof Hash;
 },

 isFunction: function(object) {
 return typeof object == "function";
 },

 isString: function(object) {
 return typeof object == "string";
 },

 isNumber: function(object) {
 return typeof object == "number";
 },

 isUndefined: function(object) {
 return typeof object == "undefined";
 }
});

Object.extend(Function.prototype, {
 argumentNames: function() {
 var names = this.toString().match(/^[\s\(]*function[^(]*\(([^\)]*)\)/)[1]
 .replace(/\s+/g, '').split(',');
 return names.length == 1 && !names[0] ? [] : names;
 },

 bind: function() {
 if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
 var __method = this, args = $A(arguments), object = args.shift();
 return function() {
 return __method.apply(object, args.concat($A(arguments)));
 }
 },

 bindAsEventListener: function() {
 var __method = this, args = $A(arguments), object = args.shift();
 return function(event) {
 return __method.apply(object, [event || window.event].concat(args));
 }
 },

 curry: function() {
 if (!arguments.length) return this;
 var __method = this, args = $A(arguments);
 return function() {
 return __method.apply(this, args.concat($A(arguments)));
 }
 },

 delay: function() {
 var __method = this, args = $A(arguments), timeout = args.shift() * 1000;
 return window.setTimeout(function() {
 return __method.apply(__method, args);
 }, timeout);
 },

 defer: function() {
 var args = [0.01].concat($A(arguments));
 return this.delay.apply(this, args);
 },

 wrap: function(wrapper) {
 var __method = this;
 return function() {
 return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
 }
 },

 methodize: function() {
 if (this._methodized) return this._methodized;
 var __method = this;
 return this._methodized = function() {
 return __method.apply(null, [this].concat($A(arguments)));
 };
 }
});

Date.prototype.toJSON = function() {
 return '"' + this.getUTCFullYear() + '-' +
 (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
 this.getUTCDate().toPaddedString(2) + 'T' +
 this.getUTCHours().toPaddedString(2) + ':' +
 this.getUTCMinutes().toPaddedString(2) + ':' +
 this.getUTCSeconds().toPaddedString(2) + 'Z"';
};

var Try = {
 these: function() {
 var returnValue;

 for (var i = 0, length = arguments.length; i < length; i++) {
 var lambda = arguments[i];
 try {
 returnValue = lambda();
 break;
 } catch (e) { }
 }

 return returnValue;
 }
};

RegExp.prototype.match = RegExp.prototype.test;

RegExp.escape = function(str) {
 return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};

/*--------------------------------------------------------------------------*/

var PeriodicalExecuter = Class.create({
 initialize: function(callback, frequency) {
 this.callback = callback;
 this.frequency = frequency;
 this.currentlyExecuting = false;

 this.registerCallback();
 },

 registerCallback: function() {
 this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
 },

 execute: function() {
 this.callback(this);
 },

 stop: function() {
 if (!this.timer) return;
 clearInterval(this.timer);
 this.timer = null;
 },

 onTimerEvent: function() {
 if (!this.currentlyExecuting) {
 try {
 this.currentlyExecuting = true;
 this.execute();
 } finally {
 this.currentlyExecuting = false;
 }
 }
 }
});
Object.extend(String, {
 interpret: function(value) {
 return value == null ? '' : String(value);
 },
 specialChar: {
 '\b': '\\b',
 '\t': '\\t',
 '\n': '\\n',
 '\f': '\\f',
 '\r': '\\r',
 '\\': '\\\\'
 }
});

Object.extend(String.prototype, {
 gsub: function(pattern, replacement) {
 var result = '', source = this, match;
 replacement = arguments.callee.prepareReplacement(replacement);

 while (source.length > 0) {
 if (match = source.match(pattern)) {
 result += source.slice(0, match.index);
 result += String.interpret(replacement(match));
 source = source.slice(match.index + match[0].length);
 } else {
 result += source, source = '';
 }
 }
 return result;
 },

 sub: function(pattern, replacement, count) {
 replacement = this.gsub.prepareReplacement(replacement);
 count = Object.isUndefined(count) ? 1 : count;

 return this.gsub(pattern, function(match) {
 if (--count < 0) return match[0];
 return replacement(match);
 });
 },

 scan: function(pattern, iterator) {
 this.gsub(pattern, iterator);
 return String(this);
 },

 truncate: function(length, truncation) {
 length = length || 30;
 truncation = Object.isUndefined(truncation) ? '...' : truncation;
 return this.length > length ?
 this.slice(0, length - truncation.length) + truncation : String(this);
 },

 strip: function() {
 return this.replace(/^\s+/, '').replace(/\s+$/, '');
 },

 stripTags: function() {
 return this.replace(/<\/?[^>]+>/gi, '');
 },

 stripScripts: function() {
 return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
 },

 extractScripts: function() {
 var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
 var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
 return (this.match(matchAll) || []).map(function(scriptTag) {
 return (scriptTag.match(matchOne) || ['', ''])[1];
 });
 },

 evalScripts: function() {
 return this.extractScripts().map(function(script) { return eval(script) });
 },

 escapeHTML: function() {
 var self = arguments.callee;
 self.text.data = this;
 return self.div.innerHTML;
 },

 unescapeHTML: function() {
 var div = new Element('div');
 div.innerHTML = this.stripTags();
 return div.childNodes[0] ? (div.childNodes.length > 1 ?
 $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
 div.childNodes[0].nodeValue) : '';
 },

 toQueryParams: function(separator) {
 var match = this.strip().match(/([^?#]*)(#.*)?$/);
 if (!match) return { };

 return match[1].split(separator || '&').inject({ }, function(hash, pair) {
 if ((pair = pair.split('='))[0]) {
 var key = decodeURIComponent(pair.shift());
 var value = pair.length > 1 ? pair.join('=') : pair[0];
 if (value != undefined) value = decodeURIComponent(value);

 if (key in hash) {
 if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
 hash[key].push(value);
 }
 else hash[key] = value;
 }
 return hash;
 });
 },

 toArray: function() {
 return this.split('');
 },

 succ: function() {
 return this.slice(0, this.length - 1) +
 String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
 },

 times: function(count) {
 return count < 1 ? '' : new Array(count + 1).join(this);
 },

 camelize: function() {
 var parts = this.split('-'), len = parts.length;
 if (len == 1) return parts[0];

 var camelized = this.charAt(0) == '-'
 ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
 : parts[0];

 for (var i = 1; i < len; i++)
 camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);

 return camelized;
 },

 capitalize: function() {
 return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
 },

 underscore: function() {
 return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
 },

 dasherize: function() {
 return this.gsub(/_/,'-');
 },

 inspect: function(useDoubleQuotes) {
 var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
 var character = String.specialChar[match[0]];
 return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
 });
 if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
 return "'" + escapedString.replace(/'/g, '\\\'') + "'";
 },

 toJSON: function() {
 return this.inspect(true);
 },

 unfilterJSON: function(filter) {
 return this.sub(filter || Prototype.JSONFilter, '#{1}');
 },

 isJSON: function() {
 var str = this;
 if (str.blank()) return false;
 str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
 return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
 },

 evalJSON: function(sanitize) {
 var json = this.unfilterJSON();
 try {
 if (!sanitize || json.isJSON()) return eval('(' + json + ')');
 } catch (e) { }
 throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
 },

 include: function(pattern) {
 return this.indexOf(pattern) > -1;
 },

 startsWith: function(pattern) {
 return this.indexOf(pattern) === 0;
 },

 endsWith: function(pattern) {
 var d = this.length - pattern.length;
 return d >= 0 && this.lastIndexOf(pattern) === d;
 },

 empty: function() {
 return this == '';
 },

 blank: function() {
 return /^\s*$/.test(this);
 },

 interpolate: function(object, pattern) {
 return new Template(this, pattern).evaluate(object);
 }
});

if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
 escapeHTML: function() {
 return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
 },
 unescapeHTML: function() {
 return this.stripTags().replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
 }
});

String.prototype.gsub.prepareReplacement = function(replacement) {
 if (Object.isFunction(replacement)) return replacement;
 var template = new Template(replacement);
 return function(match) { return template.evaluate(match) };
};

String.prototype.parseQuery = String.prototype.toQueryParams;

Object.extend(String.prototype.escapeHTML, {
 div: document.createElement('div'),
 text: document.createTextNode('')
});

String.prototype.escapeHTML.div.appendChild(String.prototype.escapeHTML.text);

var Template = Class.create({
 initialize: function(template, pattern) {
 this.template = template.toString();
 this.pattern = pattern || Template.Pattern;
 },

 evaluate: function(object) {
 if (Object.isFunction(object.toTemplateReplacements))
 object = object.toTemplateReplacements();

 return this.template.gsub(this.pattern, function(match) {
 if (object == null) return '';

 var before = match[1] || '';
 if (before == '\\') return match[2];

 var ctx = object, expr = match[3];
 var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
 match = pattern.exec(expr);
 if (match == null) return before;

 while (match != null) {
 var comp = match[1].startsWith('[') ? match[2].gsub('\\\\]', ']') : match[1];
 ctx = ctx[comp];
 if (null == ctx || '' == match[3]) break;
 expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
 match = pattern.exec(expr);
 }

 return before + String.interpret(ctx);
 });
 }
});
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

var $break = { };

var Enumerable = {
 each: function(iterator, context) {
 var index = 0;
 try {
 this._each(function(value) {
 iterator.call(context, value, index++);
 });
 } catch (e) {
 if (e != $break) throw e;
 }
 return this;
 },

 eachSlice: function(number, iterator, context) {
 var index = -number, slices = [], array = this.toArray();
 if (number < 1) return array;
 while ((index += number) < array.length)
 slices.push(array.slice(index, index+number));
 return slices.collect(iterator, context);
 },

 all: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var result = true;
 this.each(function(value, index) {
 result = result && !!iterator.call(context, value, index);
 if (!result) throw $break;
 });
 return result;
 },

 any: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var result = false;
 this.each(function(value, index) {
 if (result = !!iterator.call(context, value, index))
 throw $break;
 });
 return result;
 },

 collect: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var results = [];
 this.each(function(value, index) {
 results.push(iterator.call(context, value, index));
 });
 return results;
 },

 detect: function(iterator, context) {
 var result;
 this.each(function(value, index) {
 if (iterator.call(context, value, index)) {
 result = value;
 throw $break;
 }
 });
 return result;
 },

 findAll: function(iterator, context) {
 var results = [];
 this.each(function(value, index) {
 if (iterator.call(context, value, index))
 results.push(value);
 });
 return results;
 },

 grep: function(filter, iterator, context) {
 iterator = iterator || Prototype.K;
 var results = [];

 if (Object.isString(filter))
 filter = new RegExp(filter);

 this.each(function(value, index) {
 if (filter.match(value))
 results.push(iterator.call(context, value, index));
 });
 return results;
 },

 include: function(object) {
 if (Object.isFunction(this.indexOf))
 if (this.indexOf(object) != -1) return true;

 var found = false;
 this.each(function(value) {
 if (value == object) {
 found = true;
 throw $break;
 }
 });
 return found;
 },

 inGroupsOf: function(number, fillWith) {
 fillWith = Object.isUndefined(fillWith) ? null : fillWith;
 return this.eachSlice(number, function(slice) {
 while(slice.length < number) slice.push(fillWith);
 return slice;
 });
 },

 inject: function(memo, iterator, context) {
 this.each(function(value, index) {
 memo = iterator.call(context, memo, value, index);
 });
 return memo;
 },

 invoke: function(method) {
 var args = $A(arguments).slice(1);
 return this.map(function(value) {
 return value[method].apply(value, args);
 });
 },

 max: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var result;
 this.each(function(value, index) {
 value = iterator.call(context, value, index);
 if (result == null || value >= result)
 result = value;
 });
 return result;
 },

 min: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var result;
 this.each(function(value, index) {
 value = iterator.call(context, value, index);
 if (result == null || value < result)
 result = value;
 });
 return result;
 },

 partition: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var trues = [], falses = [];
 this.each(function(value, index) {
 (iterator.call(context, value, index) ?
 trues : falses).push(value);
 });
 return [trues, falses];
 },

 pluck: function(property) {
 var results = [];
 this.each(function(value) {
 results.push(value[property]);
 });
 return results;
 },

 reject: function(iterator, context) {
 var results = [];
 this.each(function(value, index) {
 if (!iterator.call(context, value, index))
 results.push(value);
 });
 return results;
 },

 sortBy: function(iterator, context) {
 return this.map(function(value, index) {
 return {
 value: value,
 criteria: iterator.call(context, value, index)
 };
 }).sort(function(left, right) {
 var a = left.criteria, b = right.criteria;
 return a < b ? -1 : a > b ? 1 : 0;
 }).pluck('value');
 },

 toArray: function() {
 return this.map();
 },

 zip: function() {
 var iterator = Prototype.K, args = $A(arguments);
 if (Object.isFunction(args.last()))
 iterator = args.pop();

 var collections = [this].concat(args).map($A);
 return this.map(function(value, index) {
 return iterator(collections.pluck(index));
 });
 },

 size: function() {
 return this.toArray().length;
 },

 inspect: function() {
 return '#<Enumerable:' + this.toArray().inspect() + '>';
 }
};

Object.extend(Enumerable, {
 map: Enumerable.collect,
 find: Enumerable.detect,
 select: Enumerable.findAll,
 filter: Enumerable.findAll,
 member: Enumerable.include,
 entries: Enumerable.toArray,
 every: Enumerable.all,
 some: Enumerable.any
});
function $A(iterable) {
 if (!iterable) return [];
 if (iterable.toArray) return iterable.toArray();
 var length = iterable.length || 0, results = new Array(length);
 while (length--) results[length] = iterable[length];
 return results;
}

if (Prototype.Browser.WebKit) {
 $A = function(iterable) {
 if (!iterable) return [];
 // In Safari, only use the `toArray` method if it's not a NodeList.
 // A NodeList is a function, has an function `item` property, and a numeric
 // `length` property. Adapted from Google Doctype.
 if (!(typeof iterable === 'function' && typeof iterable.length ===
 'number' && typeof iterable.item === 'function') && iterable.toArray)
 return iterable.toArray();
 var length = iterable.length || 0, results = new Array(length);
 while (length--) results[length] = iterable[length];
 return results;
 };
}

Array.from = $A;

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse) Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
 _each: function(iterator) {
 for (var i = 0, length = this.length; i < length; i++)
 iterator(this[i]);
 },

 clear: function() {
 this.length = 0;
 return this;
 },

 first: function() {
 return this[0];
 },

 last: function() {
 return this[this.length - 1];
 },

 compact: function() {
 return this.select(function(value) {
 return value != null;
 });
 },

 flatten: function() {
 return this.inject([], function(array, value) {
 return array.concat(Object.isArray(value) ?
 value.flatten() : [value]);
 });
 },

 without: function() {
 var values = $A(arguments);
 return this.select(function(value) {
 return !values.include(value);
 });
 },

 reverse: function(inline) {
 return (inline !== false ? this : this.toArray())._reverse();
 },

 reduce: function() {
 return this.length > 1 ? this : this[0];
 },

 uniq: function(sorted) {
 return this.inject([], function(array, value, index) {
 if (0 == index || (sorted ? array.last() != value : !array.include(value)))
 array.push(value);
 return array;
 });
 },

 intersect: function(array) {
 return this.uniq().findAll(function(item) {
 return array.detect(function(value) { return item === value });
 });
 },

 clone: function() {
 return [].concat(this);
 },

 size: function() {
 return this.length;
 },

 inspect: function() {
 return '[' + this.map(Object.inspect).join(', ') + ']';
 },

 toJSON: function() {
 var results = [];
 this.each(function(object) {
 var value = Object.toJSON(object);
 if (!Object.isUndefined(value)) results.push(value);
 });
 return '[' + results.join(', ') + ']';
 }
});

// use native browser JS 1.6 implementation if available
if (Object.isFunction(Array.prototype.forEach))
 Array.prototype._each = Array.prototype.forEach;

if (!Array.prototype.indexOf) Array.prototype.indexOf = function(item, i) {
 i || (i = 0);
 var length = this.length;
 if (i < 0) i = length + i;
 for (; i < length; i++)
 if (this[i] === item) return i;
 return -1;
};

if (!Array.prototype.lastIndexOf) Array.prototype.lastIndexOf = function(item, i) {
 i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
 var n = this.slice(0, i).reverse().indexOf(item);
 return (n < 0) ? n : i - n - 1;
};

Array.prototype.toArray = Array.prototype.clone;

function $w(string) {
 if (!Object.isString(string)) return [];
 string = string.strip();
 return string ? string.split(/\s+/) : [];
}

if (Prototype.Browser.Opera){
 Array.prototype.concat = function() {
 var array = [];
 for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
 for (var i = 0, length = arguments.length; i < length; i++) {
 if (Object.isArray(arguments[i])) {
 for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
 array.push(arguments[i][j]);
 } else {
 array.push(arguments[i]);
 }
 }
 return array;
 };
}
Object.extend(Number.prototype, {
 toColorPart: function() {
 return this.toPaddedString(2, 16);
 },

 succ: function() {
 return this + 1;
 },

 times: function(iterator, context) {
 $R(0, this, true).each(iterator, context);
 return this;
 },

 toPaddedString: function(length, radix) {
 var string = this.toString(radix || 10);
 return '0'.times(length - string.length) + string;
 },

 toJSON: function() {
 return isFinite(this) ? this.toString() : 'null';
 }
});

$w('abs round ceil floor').each(function(method){
 Number.prototype[method] = Math[method].methodize();
});
function $H(object) {
 return new Hash(object);
};

var Hash = Class.create(Enumerable, (function() {

 function toQueryPair(key, value) {
 if (Object.isUndefined(value)) return key;
 return key + '=' + encodeURIComponent(String.interpret(value));
 }

 return {
 initialize: function(object) {
 this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
 },

 _each: function(iterator) {
 for (var key in this._object) {
 var value = this._object[key], pair = [key, value];
 pair.key = key;
 pair.value = value;
 iterator(pair);
 }
 },

 set: function(key, value) {
 return this._object[key] = value;
 },

 get: function(key) {
 // simulating poorly supported hasOwnProperty
 if (this._object[key] !== Object.prototype[key])
 return this._object[key];
 },

 unset: function(key) {
 var value = this._object[key];
 delete this._object[key];
 return value;
 },

 toObject: function() {
 return Object.clone(this._object);
 },

 keys: function() {
 return this.pluck('key');
 },

 values: function() {
 return this.pluck('value');
 },

 index: function(value) {
 var match = this.detect(function(pair) {
 return pair.value === value;
 });
 return match && match.key;
 },

 merge: function(object) {
 return this.clone().update(object);
 },

 update: function(object) {
 return new Hash(object).inject(this, function(result, pair) {
 result.set(pair.key, pair.value);
 return result;
 });
 },

 toQueryString: function() {
 return this.inject([], function(results, pair) {
 var key = encodeURIComponent(pair.key), values = pair.value;

 if (values && typeof values == 'object') {
 if (Object.isArray(values))
 return results.concat(values.map(toQueryPair.curry(key)));
 } else results.push(toQueryPair(key, values));
 return results;
 }).join('&');
 },

 inspect: function() {
 return '#<Hash:{' + this.map(function(pair) {
 return pair.map(Object.inspect).join(': ');
 }).join(', ') + '}>';
 },

 toJSON: function() {
 return Object.toJSON(this.toObject());
 },

 clone: function() {
 return new Hash(this);
 }
 }
})());

Hash.prototype.toTemplateReplacements = Hash.prototype.toObject;
Hash.from = $H;
var ObjectRange = Class.create(Enumerable, {
 initialize: function(start, end, exclusive) {
 this.start = start;
 this.end = end;
 this.exclusive = exclusive;
 },

 _each: function(iterator) {
 var value = this.start;
 while (this.include(value)) {
 iterator(value);
 value = value.succ();
 }
 },

 include: function(value) {
 if (value < this.start)
 return false;
 if (this.exclusive)
 return value < this.end;
 return value <= this.end;
 }
});

var $R = function(start, end, exclusive) {
 return new ObjectRange(start, end, exclusive);
};

var Ajax = {
 getTransport: function() {
 return Try.these(
 function() {return new XMLHttpRequest()},
 function() {return new ActiveXObject('Msxml2.XMLHTTP')},
 function() {return new ActiveXObject('Microsoft.XMLHTTP')}
 ) || false;
 },

 activeRequestCount: 0
};

Ajax.Responders = {
 responders: [],

 _each: function(iterator) {
 this.responders._each(iterator);
 },

 register: function(responder) {
 if (!this.include(responder))
 this.responders.push(responder);
 },

 unregister: function(responder) {
 this.responders = this.responders.without(responder);
 },

 dispatch: function(callback, request, transport, json) {
 this.each(function(responder) {
 if (Object.isFunction(responder[callback])) {
 try {
 responder[callback].apply(responder, [request, transport, json]);
 } catch (e) { }
 }
 });
 }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
 onCreate: function() { Ajax.activeRequestCount++ },
 onComplete: function() { Ajax.activeRequestCount-- }
});

Ajax.Base = Class.create({
 initialize: function(options) {
 this.options = {
 method: 'post',
 asynchronous: true,
 contentType: 'application/x-www-form-urlencoded',
 encoding: 'UTF-8',
 parameters: '',
 evalJSON: true,
 evalJS: true
 };
 Object.extend(this.options, options || { });

 this.options.method = this.options.method.toLowerCase();

 if (Object.isString(this.options.parameters))
 this.options.parameters = this.options.parameters.toQueryParams();
 else if (Object.isHash(this.options.parameters))
 this.options.parameters = this.options.parameters.toObject();
 }
});

Ajax.Request = Class.create(Ajax.Base, {
 _complete: false,

 initialize: function($super, url, options) {
 $super(options);
 this.transport = Ajax.getTransport();
 this.request(url);
 },

 request: function(url) {
 this.url = url;
 this.method = this.options.method;
 var params = Object.clone(this.options.parameters);

 if (!['get', 'post'].include(this.method)) {
 // simulate other verbs over post
 params['_method'] = this.method;
 this.method = 'post';
 }

 this.parameters = params;

 if (params = Object.toQueryString(params)) {
 // when GET, append parameters to URL
 if (this.method == 'get')
 this.url += (this.url.include('?') ? '&' : '?') + params;
 else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
 params += '&_=';
 }

 try {
 var response = new Ajax.Response(this);
 if (this.options.onCreate) this.options.onCreate(response);
 Ajax.Responders.dispatch('onCreate', this, response);

 this.transport.open(this.method.toUpperCase(), this.url,
 this.options.asynchronous);

 if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);

 this.transport.onreadystatechange = this.onStateChange.bind(this);
 this.setRequestHeaders();

 this.body = this.method == 'post' ? (this.options.postBody || params) : null;
 this.transport.send(this.body);

 /* Force Firefox to handle ready state 4 for synchronous requests */
 if (!this.options.asynchronous && this.transport.overrideMimeType)
 this.onStateChange();

 }
 catch (e) {
 this.dispatchException(e);
 }
 },

 onStateChange: function() {
 var readyState = this.transport.readyState;
 if (readyState > 1 && !((readyState == 4) && this._complete))
 this.respondToReadyState(this.transport.readyState);
 },

 setRequestHeaders: function() {
 var headers = {
 'X-Requested-With': 'XMLHttpRequest',
 'X-Prototype-Version': Prototype.Version,
 'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
 };

 if (this.method == 'post') {
 headers['Content-type'] = this.options.contentType +
 (this.options.encoding ? '; charset=' + this.options.encoding : '');

 /* Force "Connection: close" for older Mozilla browsers to work
 * around a bug where XMLHttpRequest sends an incorrect
 * Content-length header. See Mozilla Bugzilla #246651.
 */
 if (this.transport.overrideMimeType &&
 (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
 headers['Connection'] = 'close';
 }

 // user-defined headers
 if (typeof this.options.requestHeaders == 'object') {
 var extras = this.options.requestHeaders;

 if (Object.isFunction(extras.push))
 for (var i = 0, length = extras.length; i < length; i += 2)
 headers[extras[i]] = extras[i+1];
 else
 $H(extras).each(function(pair) { headers[pair.key] = pair.value });
 }

 for (var name in headers)
 this.transport.setRequestHeader(name, headers[name]);
 },

 success: function() {
 var status = this.getStatus();
 return !status || (status >= 200 && status < 300);
 },

 getStatus: function() {
 try {
 return this.transport.status || 0;
 } catch (e) { return 0 }
 },

 respondToReadyState: function(readyState) {
 var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);

 if (state == 'Complete') {
 try {
 this._complete = true;
 (this.options['on' + response.status]
 || this.options['on' + (this.success() ? 'Success' : 'Failure')]
 || Prototype.emptyFunction)(response, response.headerJSON);
 } catch (e) {
 this.dispatchException(e);
 }

 var contentType = response.getHeader('Content-type');
 if (this.options.evalJS == 'force'
 || (this.options.evalJS && this.isSameOrigin() && contentType
 && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
 this.evalResponse();
 }

 try {
 (this.options['on' + state] || Prototype.emptyFunction)(response, response.headerJSON);
 Ajax.Responders.dispatch('on' + state, this, response, response.headerJSON);
 } catch (e) {
 this.dispatchException(e);
 }

 if (state == 'Complete') {
 // avoid memory leak in MSIE: clean up
 this.transport.onreadystatechange = Prototype.emptyFunction;
 }
 },

 isSameOrigin: function() {
 var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
 return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
 protocol: location.protocol,
 domain: document.domain,
 port: location.port ? ':' + location.port : ''
 }));
 },

 getHeader: function(name) {
 try {
 return this.transport.getResponseHeader(name) || null;
 } catch (e) { return null }
 },

 evalResponse: function() {
 try {
 return eval((this.transport.responseText || '').unfilterJSON());
 } catch (e) {
 this.dispatchException(e);
 }
 },

 dispatchException: function(exception) {
 (this.options.onException || Prototype.emptyFunction)(this, exception);
 Ajax.Responders.dispatch('onException', this, exception);
 }
});

Ajax.Request.Events =
 ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Response = Class.create({
 initialize: function(request){
 this.request = request;
 var transport = this.transport = request.transport,
 readyState = this.readyState = transport.readyState;

 if((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
 this.status = this.getStatus();
 this.statusText = this.getStatusText();
 this.responseText = String.interpret(transport.responseText);
 this.headerJSON = this._getHeaderJSON();
 }

 if(readyState == 4) {
 var xml = transport.responseXML;
 this.responseXML = Object.isUndefined(xml) ? null : xml;
 this.responseJSON = this._getResponseJSON();
 }
 },

 status: 0,
 statusText: '',

 getStatus: Ajax.Request.prototype.getStatus,

 getStatusText: function() {
 try {
 return this.transport.statusText || '';
 } catch (e) { return '' }
 },

 getHeader: Ajax.Request.prototype.getHeader,

 getAllHeaders: function() {
 try {
 return this.getAllResponseHeaders();
 } catch (e) { return null }
 },

 getResponseHeader: function(name) {
 return this.transport.getResponseHeader(name);
 },

 getAllResponseHeaders: function() {
 return this.transport.getAllResponseHeaders();
 },

 _getHeaderJSON: function() {
 var json = this.getHeader('X-JSON');
 if (!json) return null;
 json = decodeURIComponent(escape(json));
 try {
 return json.evalJSON(this.request.options.sanitizeJSON ||
 !this.request.isSameOrigin());
 } catch (e) {
 this.request.dispatchException(e);
 }
 },

 _getResponseJSON: function() {
 var options = this.request.options;
 if (!options.evalJSON || (options.evalJSON != 'force' &&
 !(this.getHeader('Content-type') || '').include('application/json')) ||
 this.responseText.blank())
 return null;
 try {
 return this.responseText.evalJSON(options.sanitizeJSON ||
 !this.request.isSameOrigin());
 } catch (e) {
 this.request.dispatchException(e);
 }
 }
});

Ajax.Updater = Class.create(Ajax.Request, {
 initialize: function($super, container, url, options) {
 this.container = {
 success: (container.success || container),
 failure: (container.failure || (container.success ? null : container))
 };

 options = Object.clone(options);
 var onComplete = options.onComplete;
 options.onComplete = (function(response, json) {
 this.updateContent(response.responseText);
 if (Object.isFunction(onComplete)) onComplete(response, json);
 }).bind(this);

 $super(url, options);
 },

 updateContent: function(responseText) {
 var receiver = this.container[this.success() ? 'success' : 'failure'],
 options = this.options;

 if (!options.evalScripts) responseText = responseText.stripScripts();

 if (receiver = $(receiver)) {
 if (options.insertion) {
 if (Object.isString(options.insertion)) {
 var insertion = { }; insertion[options.insertion] = responseText;
 receiver.insert(insertion);
 }
 else options.insertion(receiver, responseText);
 }
 else receiver.update(responseText);
 }
 }
});

Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
 initialize: function($super, container, url, options) {
 $super(options);
 this.onComplete = this.options.onComplete;

 this.frequency = (this.options.frequency || 2);
 this.decay = (this.options.decay || 1);

 this.updater = { };
 this.container = container;
 this.url = url;

 this.start();
 },

 start: function() {
 this.options.onComplete = this.updateComplete.bind(this);
 this.onTimerEvent();
 },

 stop: function() {
 this.updater.options.onComplete = undefined;
 clearTimeout(this.timer);
 (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
 },

 updateComplete: function(response) {
 if (this.options.decay) {
 this.decay = (response.responseText == this.lastText ?
 this.decay * this.options.decay : 1);

 this.lastText = response.responseText;
 }
 this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
 },

 onTimerEvent: function() {
 this.updater = new Ajax.Updater(this.container, this.url, this.options);
 }
});
function $(element) {
 if (arguments.length > 1) {
 for (var i = 0, elements = [], length = arguments.length; i < length; i++)
 elements.push($(arguments[i]));
 return elements;
 }
 if (Object.isString(element))
 element = document.getElementById(element);
 return Element.extend(element);
}

if (Prototype.BrowserFeatures.XPath) {
 document._getElementsByXPath = function(expression, parentElement) {
 var results = [];
 var query = document.evaluate(expression, $(parentElement) || document,
 null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
 for (var i = 0, length = query.snapshotLength; i < length; i++)
 results.push(Element.extend(query.snapshotItem(i)));
 return results;
 };
}

/*--------------------------------------------------------------------------*/

if (!window.Node) var Node = { };

if (!Node.ELEMENT_NODE) {
 // DOM level 2 ECMAScript Language Binding
 Object.extend(Node, {
 ELEMENT_NODE: 1,
 ATTRIBUTE_NODE: 2,
 TEXT_NODE: 3,
 CDATA_SECTION_NODE: 4,
 ENTITY_REFERENCE_NODE: 5,
 ENTITY_NODE: 6,
 PROCESSING_INSTRUCTION_NODE: 7,
 COMMENT_NODE: 8,
 DOCUMENT_NODE: 9,
 DOCUMENT_TYPE_NODE: 10,
 DOCUMENT_FRAGMENT_NODE: 11,
 NOTATION_NODE: 12
 });
}

(function() {
 var element = this.Element;
 this.Element = function(tagName, attributes) {
 attributes = attributes || { };
 tagName = tagName.toLowerCase();
 var cache = Element.cache;
 if (Prototype.Browser.IE && attributes.name) {
 tagName = '<' + tagName + ' name="' + attributes.name + '">';
 delete attributes.name;
 return Element.writeAttribute(document.createElement(tagName), attributes);
 }
 if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
 return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
 };
 Object.extend(this.Element, element || { });
 if (element) this.Element.prototype = element.prototype;
}).call(window);

Element.cache = { };

Element.Methods = {
 visible: function(element) {
 return $(element).style.display != 'none';
 },

 toggle: function(element) {
 element = $(element);
 Element[Element.visible(element) ? 'hide' : 'show'](element);
 return element;
 },

 hide: function(element) {
 element = $(element);
 element.style.display = 'none';
 return element;
 },

 show: function(element) {
 element = $(element);
 element.style.display = '';
 return element;
 },

 remove: function(element) {
 element = $(element);
 element.parentNode.removeChild(element);
 return element;
 },

 update: function(element, content) {
 element = $(element);
 if (content && content.toElement) content = content.toElement();
 if (Object.isElement(content)) return element.update().insert(content);
 content = Object.toHTML(content);
 element.innerHTML = content.stripScripts();
 content.evalScripts.bind(content).defer();
 return element;
 },

 replace: function(element, content) {
 element = $(element);
 if (content && content.toElement) content = content.toElement();
 else if (!Object.isElement(content)) {
 content = Object.toHTML(content);
 var range = element.ownerDocument.createRange();
 range.selectNode(element);
 content.evalScripts.bind(content).defer();
 content = range.createContextualFragment(content.stripScripts());
 }
 element.parentNode.replaceChild(content, element);
 return element;
 },

 insert: function(element, insertions) {
 element = $(element);

 if (Object.isString(insertions) || Object.isNumber(insertions) ||
 Object.isElement(insertions) || (insertions && (insertions.toElement || insertions.toHTML)))
 insertions = {bottom:insertions};

 var content, insert, tagName, childNodes;

 for (var position in insertions) {
 content = insertions[position];
 position = position.toLowerCase();
 insert = Element._insertionTranslations[position];

 if (content && content.toElement) content = content.toElement();
 if (Object.isElement(content)) {
 insert(element, content);
 continue;
 }

 content = Object.toHTML(content);

 tagName = ((position == 'before' || position == 'after')
 ? element.parentNode : element).tagName.toUpperCase();

 childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());

 if (position == 'top' || position == 'after') childNodes.reverse();
 childNodes.each(insert.curry(element));

 content.evalScripts.bind(content).defer();
 }

 return element;
 },

 wrap: function(element, wrapper, attributes) {
 element = $(element);
 if (Object.isElement(wrapper))
 $(wrapper).writeAttribute(attributes || { });
 else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
 else wrapper = new Element('div', wrapper);
 if (element.parentNode)
 element.parentNode.replaceChild(wrapper, element);
 wrapper.appendChild(element);
 return wrapper;
 },

 inspect: function(element) {
 element = $(element);
 var result = '<' + element.tagName.toLowerCase();
 $H({'id': 'id', 'className': 'class'}).each(function(pair) {
 var property = pair.first(), attribute = pair.last();
 var value = (element[property] || '').toString();
 if (value) result += ' ' + attribute + '=' + value.inspect(true);
 });
 return result + '>';
 },

 recursivelyCollect: function(element, property) {
 element = $(element);
 var elements = [];
 while (element = element[property])
 if (element.nodeType == 1)
 elements.push(Element.extend(element));
 return elements;
 },

 ancestors: function(element) {
 return $(element).recursivelyCollect('parentNode');
 },

 descendants: function(element) {
 return $(element).select("*");
 },

 firstDescendant: function(element) {
 element = $(element).firstChild;
 while (element && element.nodeType != 1) element = element.nextSibling;
 return $(element);
 },

 immediateDescendants: function(element) {
 if (!(element = $(element).firstChild)) return [];
 while (element && element.nodeType != 1) element = element.nextSibling;
 if (element) return [element].concat($(element).nextSiblings());
 return [];
 },

 previousSiblings: function(element) {
 return $(element).recursivelyCollect('previousSibling');
 },

 nextSiblings: function(element) {
 return $(element).recursivelyCollect('nextSibling');
 },

 siblings: function(element) {
 element = $(element);
 return element.previousSiblings().reverse().concat(element.nextSiblings());
 },

 match: function(element, selector) {
 if (Object.isString(selector))
 selector = new Selector(selector);
 return selector.match($(element));
 },

 up: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return $(element.parentNode);
 var ancestors = element.ancestors();
 return Object.isNumber(expression) ? ancestors[expression] :
 Selector.findElement(ancestors, expression, index);
 },

 down: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return element.firstDescendant();
 return Object.isNumber(expression) ? element.descendants()[expression] :
 Element.select(element, expression)[index || 0];
 },

 previous: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
 var previousSiblings = element.previousSiblings();
 return Object.isNumber(expression) ? previousSiblings[expression] :
 Selector.findElement(previousSiblings, expression, index);
 },

 next: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
 var nextSiblings = element.nextSiblings();
 return Object.isNumber(expression) ? nextSiblings[expression] :
 Selector.findElement(nextSiblings, expression, index);
 },

 select: function() {
 var args = $A(arguments), element = $(args.shift());
 return Selector.findChildElements(element, args);
 },

 adjacent: function() {
 var args = $A(arguments), element = $(args.shift());
 return Selector.findChildElements(element.parentNode, args).without(element);
 },

 identify: function(element) {
 element = $(element);
 var id = element.readAttribute('id'), self = arguments.callee;
 if (id) return id;
 do { id = 'anonymous_element_' + self.counter++ } while ($(id));
 element.writeAttribute('id', id);
 return id;
 },

 readAttribute: function(element, name) {
 element = $(element);
 if (Prototype.Browser.IE) {
 var t = Element._attributeTranslations.read;
 if (t.values[name]) return t.values[name](element, name);
 if (t.names[name]) name = t.names[name];
 if (name.include(':')) {
 return (!element.attributes || !element.attributes[name]) ? null :
 element.attributes[name].value;
 }
 }
 return element.getAttribute(name);
 },

 writeAttribute: function(element, name, value) {
 element = $(element);
 var attributes = { }, t = Element._attributeTranslations.write;

 if (typeof name == 'object') attributes = name;
 else attributes[name] = Object.isUndefined(value) ? true : value;

 for (var attr in attributes) {
 name = t.names[attr] || attr;
 value = attributes[attr];
 if (t.values[attr]) name = t.values[attr](element, value);
 if (value === false || value === null)
 element.removeAttribute(name);
 else if (value === true)
 element.setAttribute(name, name);
 else element.setAttribute(name, value);
 }
 return element;
 },

 getHeight: function(element) {
 return $(element).getDimensions().height;
 },

 getWidth: function(element) {
 return $(element).getDimensions().width;
 },

 classNames: function(element) {
 return new Element.ClassNames(element);
 },

 hasClassName: function(element, className) {
 if (!(element = $(element))) return;
 var elementClassName = element.className;
 return (elementClassName.length > 0 && (elementClassName == className ||
 new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
 },

 addClassName: function(element, className) {
 if (!(element = $(element))) return;
 if (!element.hasClassName(className))
 element.className += (element.className ? ' ' : '') + className;
 return element;
 },

 removeClassName: function(element, className) {
 if (!(element = $(element))) return;
 element.className = element.className.replace(
 new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
 return element;
 },

 toggleClassName: function(element, className) {
 if (!(element = $(element))) return;
 return element[element.hasClassName(className) ?
 'removeClassName' : 'addClassName'](className);
 },

 // removes whitespace-only text node children
 cleanWhitespace: function(element) {
 element = $(element);
 var node = element.firstChild;
 while (node) {
 var nextNode = node.nextSibling;
 if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
 element.removeChild(node);
 node = nextNode;
 }
 return element;
 },

 empty: function(element) {
 return $(element).innerHTML.blank();
 },

 descendantOf: function(element, ancestor) {
 element = $(element), ancestor = $(ancestor);

 if (element.compareDocumentPosition)
 return (element.compareDocumentPosition(ancestor) & 8) === 8;

 if (ancestor.contains)
 return ancestor.contains(element) && ancestor !== element;

 while (element = element.parentNode)
 if (element == ancestor) return true;

 return false;
 },

 scrollTo: function(element) {
 element = $(element);
 var pos = element.cumulativeOffset();
 window.scrollTo(pos[0], pos[1]);
 return element;
 },

 getStyle: function(element, style) {
 element = $(element);
 style = style == 'float' ? 'cssFloat' : style.camelize();
 var value = element.style[style];
 if (!value || value == 'auto') {
 var css = document.defaultView.getComputedStyle(element, null);
 value = css ? css[style] : null;
 }
 if (style == 'opacity') return value ? parseFloat(value) : 1.0;
 return value == 'auto' ? null : value;
 },

 getOpacity: function(element) {
 return $(element).getStyle('opacity');
 },

 setStyle: function(element, styles) {
 element = $(element);
 var elementStyle = element.style, match;
 if (Object.isString(styles)) {
 element.style.cssText += ';' + styles;
 return styles.include('opacity') ?
 element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
 }
 for (var property in styles)
 if (property == 'opacity') element.setOpacity(styles[property]);
 else
 elementStyle[(property == 'float' || property == 'cssFloat') ?
 (Object.isUndefined(elementStyle.styleFloat) ? 'cssFloat' : 'styleFloat') :
 property] = styles[property];

 return element;
 },

 setOpacity: function(element, value) {
 element = $(element);
 element.style.opacity = (value == 1 || value === '') ? '' :
 (value < 0.00001) ? 0 : value;
 return element;
 },

 getDimensions: function(element) {
 element = $(element);
 var display = element.getStyle('display');
 if (display != 'none' && display != null) // Safari bug
 return {width: element.offsetWidth, height: element.offsetHeight};

 // All *Width and *Height properties give 0 on elements with display none,
 // so enable the element temporarily
 var els = element.style;
 var originalVisibility = els.visibility;
 var originalPosition = els.position;
 var originalDisplay = els.display;
 els.visibility = 'hidden';
 els.position = 'absolute';
 els.display = 'block';
 var originalWidth = element.clientWidth;
 var originalHeight = element.clientHeight;
 els.display = originalDisplay;
 els.position = originalPosition;
 els.visibility = originalVisibility;
 return {width: originalWidth, height: originalHeight};
 },

 makePositioned: function(element) {
 element = $(element);
 var pos = Element.getStyle(element, 'position');
 if (pos == 'static' || !pos) {
 element._madePositioned = true;
 element.style.position = 'relative';
 // Opera returns the offset relative to the positioning context, when an
 // element is position relative but top and left have not been defined
 if (Prototype.Browser.Opera) {
 element.style.top = 0;
 element.style.left = 0;
 }
 }
 return element;
 },

 undoPositioned: function(element) {
 element = $(element);
 if (element._madePositioned) {
 element._madePositioned = undefined;
 element.style.position =
 element.style.top =
 element.style.left =
 element.style.bottom =
 element.style.right = '';
 }
 return element;
 },

 makeClipping: function(element) {
 element = $(element);
 if (element._overflow) return element;
 element._overflow = Element.getStyle(element, 'overflow') || 'auto';
 if (element._overflow !== 'hidden')
 element.style.overflow = 'hidden';
 return element;
 },

 undoClipping: function(element) {
 element = $(element);
 if (!element._overflow) return element;
 element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
 element._overflow = null;
 return element;
 },

 cumulativeOffset: function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 element = element.offsetParent;
 } while (element);
 return Element._returnOffset(valueL, valueT);
 },

 positionedOffset: function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 element = element.offsetParent;
 if (element) {
 if (element.tagName.toUpperCase() == 'BODY') break;
 var p = Element.getStyle(element, 'position');
 if (p !== 'static') break;
 }
 } while (element);
 return Element._returnOffset(valueL, valueT);
 },

 absolutize: function(element) {
 element = $(element);
 if (element.getStyle('position') == 'absolute') return element;
 // Position.prepare(); // To be done manually by Scripty when it needs it.

 var offsets = element.positionedOffset();
 var top = offsets[1];
 var left = offsets[0];
 var width = element.clientWidth;
 var height = element.clientHeight;

 element._originalLeft = left - parseFloat(element.style.left || 0);
 element._originalTop = top - parseFloat(element.style.top || 0);
 element._originalWidth = element.style.width;
 element._originalHeight = element.style.height;

 element.style.position = 'absolute';
 element.style.top = top + 'px';
 element.style.left = left + 'px';
 element.style.width = width + 'px';
 element.style.height = height + 'px';
 return element;
 },

 relativize: function(element) {
 element = $(element);
 if (element.getStyle('position') == 'relative') return element;
 // Position.prepare(); // To be done manually by Scripty when it needs it.

 element.style.position = 'relative';
 var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);
 var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);

 element.style.top = top + 'px';
 element.style.left = left + 'px';
 element.style.height = element._originalHeight;
 element.style.width = element._originalWidth;
 return element;
 },

 cumulativeScrollOffset: function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.scrollTop || 0;
 valueL += element.scrollLeft || 0;
 element = element.parentNode;
 } while (element);
 return Element._returnOffset(valueL, valueT);
 },

 getOffsetParent: function(element) {
 if (element.offsetParent) return $(element.offsetParent);
 if (element == document.body) return $(element);

 while ((element = element.parentNode) && element != document.body)
 if (Element.getStyle(element, 'position') != 'static')
 return $(element);

 return $(document.body);
 },

 viewportOffset: function(forElement) {
 var valueT = 0, valueL = 0;

 var element = forElement;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;

 // Safari fix
 if (element.offsetParent == document.body &&
 Element.getStyle(element, 'position') == 'absolute') break;

 } while (element = element.offsetParent);

 element = forElement;
 do {
 if (!Prototype.Browser.Opera || (element.tagName && (element.tagName.toUpperCase() == 'BODY'))) {
 valueT -= element.scrollTop || 0;
 valueL -= element.scrollLeft || 0;
 }
 } while (element = element.parentNode);

 return Element._returnOffset(valueL, valueT);
 },

 clonePosition: function(element, source) {
 var options = Object.extend({
 setLeft: true,
 setTop: true,
 setWidth: true,
 setHeight: true,
 offsetTop: 0,
 offsetLeft: 0
 }, arguments[2] || { });

 // find page position of source
 source = $(source);
 var p = source.viewportOffset();

 // find coordinate system to use
 element = $(element);
 var delta = [0, 0];
 var parent = null;
 // delta [0,0] will do fine with position: fixed elements,
 // position:absolute needs offsetParent deltas
 if (Element.getStyle(element, 'position') == 'absolute') {
 parent = element.getOffsetParent();
 delta = parent.viewportOffset();
 }

 // correct by body offsets (fixes Safari)
 if (parent == document.body) {
 delta[0] -= document.body.offsetLeft;
 delta[1] -= document.body.offsetTop;
 }

 // set position
 if (options.setLeft) element.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
 if (options.setTop) element.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
 if (options.setWidth) element.style.width = source.offsetWidth + 'px';
 if (options.setHeight) element.style.height = source.offsetHeight + 'px';
 return element;
 }
};

Element.Methods.identify.counter = 1;

Object.extend(Element.Methods, {
 getElementsBySelector: Element.Methods.select,
 childElements: Element.Methods.immediateDescendants
});

Element._attributeTranslations = {
 write: {
 names: {
 className: 'class',
 htmlFor: 'for'
 },
 values: { }
 }
};

if (Prototype.Browser.Opera) {
 Element.Methods.getStyle = Element.Methods.getStyle.wrap(
 function(proceed, element, style) {
 switch (style) {
 case 'left': case 'top': case 'right': case 'bottom':
 if (proceed(element, 'position') === 'static') return null;
 case 'height': case 'width':
 // returns '0px' for hidden elements; we want it to return null
 if (!Element.visible(element)) return null;

 // returns the border-box dimensions rather than the content-box
 // dimensions, so we subtract padding and borders from the value
 var dim = parseInt(proceed(element, style), 10);

 if (dim !== element['offset' + style.capitalize()])
 return dim + 'px';

 var properties;
 if (style === 'height') {
 properties = ['border-top-width', 'padding-top',
 'padding-bottom', 'border-bottom-width'];
 }
 else {
 properties = ['border-left-width', 'padding-left',
 'padding-right', 'border-right-width'];
 }
 return properties.inject(dim, function(memo, property) {
 var val = proceed(element, property);
 return val === null ? memo : memo - parseInt(val, 10);
 }) + 'px';
 default: return proceed(element, style);
 }
 }
 );

 Element.Methods.readAttribute = Element.Methods.readAttribute.wrap(
 function(proceed, element, attribute) {
 if (attribute === 'title') return element.title;
 return proceed(element, attribute);
 }
 );
}

else if (Prototype.Browser.IE) {
 // IE doesn't report offsets correctly for static elements, so we change them
 // to "relative" to get the values, then change them back.
 Element.Methods.getOffsetParent = Element.Methods.getOffsetParent.wrap(
 function(proceed, element) {
 element = $(element);
 // IE throws an error if element is not in document
 try { element.offsetParent }
 catch(e) { return $(document.body) }
 var position = element.getStyle('position');
 if (position !== 'static') return proceed(element);
 element.setStyle({ position: 'relative' });
 var value = proceed(element);
 element.setStyle({ position: position });
 return value;
 }
 );

 $w('positionedOffset viewportOffset').each(function(method) {
 Element.Methods[method] = Element.Methods[method].wrap(
 function(proceed, element) {
 element = $(element);
 try { element.offsetParent }
 catch(e) { return Element._returnOffset(0,0) }
 var position = element.getStyle('position');
 if (position !== 'static') return proceed(element);
 // Trigger hasLayout on the offset parent so that IE6 reports
 // accurate offsetTop and offsetLeft values for position: fixed.
 var offsetParent = element.getOffsetParent();
 if (offsetParent && offsetParent.getStyle('position') === 'fixed')
 offsetParent.setStyle({ zoom: 1 });
 element.setStyle({ position: 'relative' });
 var value = proceed(element);
 element.setStyle({ position: position });
 return value;
 }
 );
 });

 Element.Methods.cumulativeOffset = Element.Methods.cumulativeOffset.wrap(
 function(proceed, element) {
 try { element.offsetParent }
 catch(e) { return Element._returnOffset(0,0) }
 return proceed(element);
 }
 );

 Element.Methods.getStyle = function(element, style) {
 element = $(element);
 style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
 var value = element.style[style];
 if (!value && element.currentStyle) value = element.currentStyle[style];

 if (style == 'opacity') {
 if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
 if (value[1]) return parseFloat(value[1]) / 100;
 return 1.0;
 }

 if (value == 'auto') {
 if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
 return element['offset' + style.capitalize()] + 'px';
 return null;
 }
 return value;
 };

 Element.Methods.setOpacity = function(element, value) {
 function stripAlpha(filter){
 return filter.replace(/alpha\([^\)]*\)/gi,'');
 }
 element = $(element);
 var currentStyle = element.currentStyle;
 if ((currentStyle && !currentStyle.hasLayout) ||
 (!currentStyle && element.style.zoom == 'normal'))
 element.style.zoom = 1;

 var filter = element.getStyle('filter'), style = element.style;
 if (value == 1 || value === '') {
 (filter = stripAlpha(filter)) ?
 style.filter = filter : style.removeAttribute('filter');
 return element;
 } else if (value < 0.00001) value = 0;
 style.filter = stripAlpha(filter) +
 'alpha(opacity=' + (value * 100) + ')';
 return element;
 };

 Element._attributeTranslations = {
 read: {
 names: {
 'class': 'className',
 'for': 'htmlFor'
 },
 values: {
 _getAttr: function(element, attribute) {
 return element.getAttribute(attribute, 2);
 },
 _getAttrNode: function(element, attribute) {
 var node = element.getAttributeNode(attribute);
 return node ? node.value : "";
 },
 _getEv: function(element, attribute) {
 attribute = element.getAttribute(attribute);
 return attribute ? attribute.toString().slice(23, -2) : null;
 },
 _flag: function(element, attribute) {
 return $(element).hasAttribute(attribute) ? attribute : null;
 },
 style: function(element) {
 return element.style.cssText.toLowerCase();
 },
 title: function(element) {
 return element.title;
 }
 }
 }
 };

 Element._attributeTranslations.write = {
 names: Object.extend({
 cellpadding: 'cellPadding',
 cellspacing: 'cellSpacing'
 }, Element._attributeTranslations.read.names),
 values: {
 checked: function(element, value) {
 element.checked = !!value;
 },

 style: function(element, value) {
 element.style.cssText = value ? value : '';
 }
 }
 };

 Element._attributeTranslations.has = {};

 $w('colSpan rowSpan vAlign dateTime accessKey tabIndex ' +
 'encType maxLength readOnly longDesc frameBorder').each(function(attr) {
 Element._attributeTranslations.write.names[attr.toLowerCase()] = attr;
 Element._attributeTranslations.has[attr.toLowerCase()] = attr;
 });

 (function(v) {
 Object.extend(v, {
 href: v._getAttr,
 src: v._getAttr,
 type: v._getAttr,
 action: v._getAttrNode,
 disabled: v._flag,
 checked: v._flag,
 readonly: v._flag,
 multiple: v._flag,
 onload: v._getEv,
 onunload: v._getEv,
 onclick: v._getEv,
 ondblclick: v._getEv,
 onmousedown: v._getEv,
 onmouseup: v._getEv,
 onmouseover: v._getEv,
 onmousemove: v._getEv,
 onmouseout: v._getEv,
 onfocus: v._getEv,
 onblur: v._getEv,
 onkeypress: v._getEv,
 onkeydown: v._getEv,
 onkeyup: v._getEv,
 onsubmit: v._getEv,
 onreset: v._getEv,
 onselect: v._getEv,
 onchange: v._getEv
 });
 })(Element._attributeTranslations.read.values);
}

else if (Prototype.Browser.Gecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
 Element.Methods.setOpacity = function(element, value) {
 element = $(element);
 element.style.opacity = (value == 1) ? 0.999999 :
 (value === '') ? '' : (value < 0.00001) ? 0 : value;
 return element;
 };
}

else if (Prototype.Browser.WebKit) {
 Element.Methods.setOpacity = function(element, value) {
 element = $(element);
 element.style.opacity = (value == 1 || value === '') ? '' :
 (value < 0.00001) ? 0 : value;

 if (value == 1)
 if(element.tagName.toUpperCase() == 'IMG' && element.width) {
 element.width++; element.width--;
 } else try {
 var n = document.createTextNode(' ');
 element.appendChild(n);
 element.removeChild(n);
 } catch (e) { }

 return element;
 };

 // Safari returns margins on body which is incorrect if the child is absolutely
 // positioned. For performance reasons, redefine Element#cumulativeOffset for
 // KHTML/WebKit only.
 Element.Methods.cumulativeOffset = function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 if (element.offsetParent == document.body)
 if (Element.getStyle(element, 'position') == 'absolute') break;

 element = element.offsetParent;
 } while (element);

 return Element._returnOffset(valueL, valueT);
 };
}

if (Prototype.Browser.IE || Prototype.Browser.Opera) {
 // IE and Opera are missing .innerHTML support for TABLE-related and SELECT elements
 Element.Methods.update = function(element, content) {
 element = $(element);

 if (content && content.toElement) content = content.toElement();
 if (Object.isElement(content)) return element.update().insert(content);

 content = Object.toHTML(content);
 var tagName = element.tagName.toUpperCase();

 if (tagName in Element._insertionTranslations.tags) {
 $A(element.childNodes).each(function(node) { element.removeChild(node) });
 Element._getContentFromAnonymousElement(tagName, content.stripScripts())
 .each(function(node) { element.appendChild(node) });
 }
 else element.innerHTML = content.stripScripts();

 content.evalScripts.bind(content).defer();
 return element;
 };
}

if ('outerHTML' in document.createElement('div')) {
 Element.Methods.replace = function(element, content) {
 element = $(element);

 if (content && content.toElement) content = content.toElement();
 if (Object.isElement(content)) {
 element.parentNode.replaceChild(content, element);
 return element;
 }

 content = Object.toHTML(content);
 var parent = element.parentNode, tagName = parent.tagName.toUpperCase();

 if (Element._insertionTranslations.tags[tagName]) {
 var nextSibling = element.next();
 var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
 parent.removeChild(element);
 if (nextSibling)
 fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
 else
 fragments.each(function(node) { parent.appendChild(node) });
 }
 else element.outerHTML = content.stripScripts();

 content.evalScripts.bind(content).defer();
 return element;
 };
}

Element._returnOffset = function(l, t) {
 var result = [l, t];
 result.left = l;
 result.top = t;
 return result;
};

Element._getContentFromAnonymousElement = function(tagName, html) {
 var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
 if (t) {
 div.innerHTML = t[0] + html + t[1];
 t[2].times(function() { div = div.firstChild });
 } else div.innerHTML = html;
 return $A(div.childNodes);
};

Element._insertionTranslations = {
 before: function(element, node) {
 element.parentNode.insertBefore(node, element);
 },
 top: function(element, node) {
 element.insertBefore(node, element.firstChild);
 },
 bottom: function(element, node) {
 element.appendChild(node);
 },
 after: function(element, node) {
 element.parentNode.insertBefore(node, element.nextSibling);
 },
 tags: {
 TABLE: ['<table>', '</table>', 1],
 TBODY: ['<table><tbody>', '</tbody></table>', 2],
 TR: ['<table><tbody><tr>', '</tr></tbody></table>', 3],
 TD: ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
 SELECT: ['<select>', '</select>', 1]
 }
};

(function() {
 Object.extend(this.tags, {
 THEAD: this.tags.TBODY,
 TFOOT: this.tags.TBODY,
 TH: this.tags.TD
 });
}).call(Element._insertionTranslations);

Element.Methods.Simulated = {
 hasAttribute: function(element, attribute) {
 attribute = Element._attributeTranslations.has[attribute] || attribute;
 var node = $(element).getAttributeNode(attribute);
 return !!(node && node.specified);
 }
};

Element.Methods.ByTag = { };

Object.extend(Element, Element.Methods);

if (!Prototype.BrowserFeatures.ElementExtensions &&
 document.createElement('div')['__proto__']) {
 window.HTMLElement = { };
 window.HTMLElement.prototype = document.createElement('div')['__proto__'];
 Prototype.BrowserFeatures.ElementExtensions = true;
}

Element.extend = (function() {
 if (Prototype.BrowserFeatures.SpecificElementExtensions)
 return Prototype.K;

 var Methods = { }, ByTag = Element.Methods.ByTag;

 var extend = Object.extend(function(element) {
 if (!element || element._extendedByPrototype ||
 element.nodeType != 1 || element == window) return element;

 var methods = Object.clone(Methods),
 tagName = element.tagName.toUpperCase(), property, value;

 // extend methods for specific tags
 if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);

 for (property in methods) {
 value = methods[property];
 if (Object.isFunction(value) && !(property in element))
 element[property] = value.methodize();
 }

 element._extendedByPrototype = Prototype.emptyFunction;
 return element;

 }, {
 refresh: function() {
 // extend methods for all tags (Safari doesn't need this)
 if (!Prototype.BrowserFeatures.ElementExtensions) {
 Object.extend(Methods, Element.Methods);
 Object.extend(Methods, Element.Methods.Simulated);
 }
 }
 });

 extend.refresh();
 return extend;
})();

Element.hasAttribute = function(element, attribute) {
 if (element.hasAttribute) return element.hasAttribute(attribute);
 return Element.Methods.Simulated.hasAttribute(element, attribute);
};

Element.addMethods = function(methods) {
 var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;

 if (!methods) {
 Object.extend(Form, Form.Methods);
 Object.extend(Form.Element, Form.Element.Methods);
 Object.extend(Element.Methods.ByTag, {
 "FORM": Object.clone(Form.Methods),
 "INPUT": Object.clone(Form.Element.Methods),
 "SELECT": Object.clone(Form.Element.Methods),
 "TEXTAREA": Object.clone(Form.Element.Methods)
 });
 }

 if (arguments.length == 2) {
 var tagName = methods;
 methods = arguments[1];
 }

 if (!tagName) Object.extend(Element.Methods, methods || { });
 else {
 if (Object.isArray(tagName)) tagName.each(extend);
 else extend(tagName);
 }

 function extend(tagName) {
 tagName = tagName.toUpperCase();
 if (!Element.Methods.ByTag[tagName])
 Element.Methods.ByTag[tagName] = { };
 Object.extend(Element.Methods.ByTag[tagName], methods);
 }

 function copy(methods, destination, onlyIfAbsent) {
 onlyIfAbsent = onlyIfAbsent || false;
 for (var property in methods) {
 var value = methods[property];
 if (!Object.isFunction(value)) continue;
 if (!onlyIfAbsent || !(property in destination))
 destination[property] = value.methodize();
 }
 }

 function findDOMClass(tagName) {
 var klass;
 var trans = {
 "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
 "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
 "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
 "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
 "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
 "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
 "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
 "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
 "FrameSet", "IFRAME": "IFrame"
 };
 if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
 if (window[klass]) return window[klass];
 klass = 'HTML' + tagName + 'Element';
 if (window[klass]) return window[klass];
 klass = 'HTML' + tagName.capitalize() + 'Element';
 if (window[klass]) return window[klass];

 window[klass] = { };
 window[klass].prototype = document.createElement(tagName)['__proto__'];
 return window[klass];
 }

 if (F.ElementExtensions) {
 copy(Element.Methods, HTMLElement.prototype);
 copy(Element.Methods.Simulated, HTMLElement.prototype, true);
 }

 if (F.SpecificElementExtensions) {
 for (var tag in Element.Methods.ByTag) {
 var klass = findDOMClass(tag);
 if (Object.isUndefined(klass)) continue;
 copy(T[tag], klass.prototype);
 }
 }

 Object.extend(Element, Element.Methods);
 delete Element.ByTag;

 if (Element.extend.refresh) Element.extend.refresh();
 Element.cache = { };
};

document.viewport = {
 getDimensions: function() {
 var dimensions = { }, B = Prototype.Browser;
 $w('width height').each(function(d) {
 var D = d.capitalize();
 if (B.WebKit && !document.evaluate) {
 // Safari <3.0 needs self.innerWidth/Height
 dimensions[d] = self['inner' + D];
 } else if (B.Opera && parseFloat(window.opera.version()) < 9.5) {
 // Opera <9.5 needs document.body.clientWidth/Height
 dimensions[d] = document.body['client' + D]
 } else {
 dimensions[d] = document.documentElement['client' + D];
 }
 });
 return dimensions;
 },

 getWidth: function() {
 return this.getDimensions().width;
 },

 getHeight: function() {
 return this.getDimensions().height;
 },

 getScrollOffsets: function() {
 return Element._returnOffset(
 window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
 window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop);
 }
};
/* Portions of the Selector class are derived from Jack Slocum's DomQuery,
 * part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
 * license. Please see http://www.yui-ext.com/ for more information. */

var Selector = Class.create({
 initialize: function(expression) {
 this.expression = expression.strip();

 if (this.shouldUseSelectorsAPI()) {
 this.mode = 'selectorsAPI';
 } else if (this.shouldUseXPath()) {
 this.mode = 'xpath';
 this.compileXPathMatcher();
 } else {
 this.mode = "normal";
 this.compileMatcher();
 }

 },

 shouldUseXPath: function() {
 if (!Prototype.BrowserFeatures.XPath) return false;

 var e = this.expression;

 // Safari 3 chokes on :*-of-type and :empty
 if (Prototype.Browser.WebKit &&
 (e.include("-of-type") || e.include(":empty")))
 return false;

 // XPath can't do namespaced attributes, nor can it read
 // the "checked" property from DOM nodes
 if ((/(\[[\w-]*?:|:checked)/).test(e))
 return false;

 return true;
 },

 shouldUseSelectorsAPI: function() {
 if (!Prototype.BrowserFeatures.SelectorsAPI) return false;

 if (!Selector._div) Selector._div = new Element('div');

 // Make sure the browser treats the selector as valid. Test on an
 // isolated element to minimize cost of this check.
 try {
 Selector._div.querySelector(this.expression);
 } catch(e) {
 return false;
 }

 return true;
 },

 compileMatcher: function() {
 var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
 c = Selector.criteria, le, p, m;

 if (Selector._cache[e]) {
 this.matcher = Selector._cache[e];
 return;
 }

 this.matcher = ["this.matcher = function(root) {",
 "var r = root, h = Selector.handlers, c = false, n;"];

 while (e && le != e && (/\S/).test(e)) {
 le = e;
 for (var i in ps) {
 p = ps[i];
 if (m = e.match(p)) {
 this.matcher.push(Object.isFunction(c[i]) ? c[i](m) :
 new Template(c[i]).evaluate(m));
 e = e.replace(m[0], '');
 break;
 }
 }
 }

 this.matcher.push("return h.unique(n);\n}");
 eval(this.matcher.join('\n'));
 Selector._cache[this.expression] = this.matcher;
 },

 compileXPathMatcher: function() {
 var e = this.expression, ps = Selector.patterns,
 x = Selector.xpath, le, m;

 if (Selector._cache[e]) {
 this.xpath = Selector._cache[e]; return;
 }

 this.matcher = ['.//*'];
 while (e && le != e && (/\S/).test(e)) {
 le = e;
 for (var i in ps) {
 if (m = e.match(ps[i])) {
 this.matcher.push(Object.isFunction(x[i]) ? x[i](m) :
 new Template(x[i]).evaluate(m));
 e = e.replace(m[0], '');
 break;
 }
 }
 }

 this.xpath = this.matcher.join('');
 Selector._cache[this.expression] = this.xpath;
 },

 findElements: function(root) {
 root = root || document;
 var e = this.expression, results;

 switch (this.mode) {
 case 'selectorsAPI':
 // querySelectorAll queries document-wide, then filters to descendants
 // of the context element. That's not what we want.
 // Add an explicit context to the selector if necessary.
 if (root !== document) {
 var oldId = root.id, id = $(root).identify();
 e = "#" + id + " " + e;
 }

 results = $A(root.querySelectorAll(e)).map(Element.extend);
 root.id = oldId;

 return results;
 case 'xpath':
 return document._getElementsByXPath(this.xpath, root);
 default:
 return this.matcher(root);
 }
 },

 match: function(element) {
 this.tokens = [];

 var e = this.expression, ps = Selector.patterns, as = Selector.assertions;
 var le, p, m;

 while (e && le !== e && (/\S/).test(e)) {
 le = e;
 for (var i in ps) {
 p = ps[i];
 if (m = e.match(p)) {
 // use the Selector.assertions methods unless the selector
 // is too complex.
 if (as[i]) {
 this.tokens.push([i, Object.clone(m)]);
 e = e.replace(m[0], '');
 } else {
 // reluctantly do a document-wide search
 // and look for a match in the array
 return this.findElements(document).include(element);
 }
 }
 }
 }

 var match = true, name, matches;
 for (var i = 0, token; token = this.tokens[i]; i++) {
 name = token[0], matches = token[1];
 if (!Selector.assertions[name](element, matches)) {
 match = false; break;
 }
 }

 return match;
 },

 toString: function() {
 return this.expression;
 },

 inspect: function() {
 return "#<Selector:" + this.expression.inspect() + ">";
 }
});

Object.extend(Selector, {
 _cache: { },

 xpath: {
 descendant: "//*",
 child: "/*",
 adjacent: "/following-sibling::*[1]",
 laterSibling: '/following-sibling::*',
 tagName: function(m) {
 if (m[1] == '*') return '';
 return "[local-name()='" + m[1].toLowerCase() +
 "' or local-name()='" + m[1].toUpperCase() + "']";
 },
 className: "[contains(concat(' ', @class, ' '), ' #{1} ')]",
 id: "[@id='#{1}']",
 attrPresence: function(m) {
 m[1] = m[1].toLowerCase();
 return new Template("[@#{1}]").evaluate(m);
 },
 attr: function(m) {
 m[1] = m[1].toLowerCase();
 m[3] = m[5] || m[6];
 return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
 },
 pseudo: function(m) {
 var h = Selector.xpath.pseudos[m[1]];
 if (!h) return '';
 if (Object.isFunction(h)) return h(m);
 return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
 },
 operators: {
 '=': "[@#{1}='#{3}']",
 '!=': "[@#{1}!='#{3}']",
 '^=': "[starts-with(@#{1}, '#{3}')]",
 '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
 '*=': "[contains(@#{1}, '#{3}')]",
 '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
 '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
 },
 pseudos: {
 'first-child': '[not(preceding-sibling::*)]',
 'last-child': '[not(following-sibling::*)]',
 'only-child': '[not(preceding-sibling::* or following-sibling::*)]',
 'empty': "[count(*) = 0 and (count(text()) = 0)]",
 'checked': "[@checked]",
 'disabled': "[(@disabled) and (@type!='hidden')]",
 'enabled': "[not(@disabled) and (@type!='hidden')]",
 'not': function(m) {
 var e = m[6], p = Selector.patterns,
 x = Selector.xpath, le, v;

 var exclusion = [];
 while (e && le != e && (/\S/).test(e)) {
 le = e;
 for (var i in p) {
 if (m = e.match(p[i])) {
 v = Object.isFunction(x[i]) ? x[i](m) : new Template(x[i]).evaluate(m);
 exclusion.push("(" + v.substring(1, v.length - 1) + ")");
 e = e.replace(m[0], '');
 break;
 }
 }
 }
 return "[not(" + exclusion.join(" and ") + ")]";
 },
 'nth-child': function(m) {
 return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
 },
 'nth-last-child': function(m) {
 return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
 },
 'nth-of-type': function(m) {
 return Selector.xpath.pseudos.nth("position() ", m);
 },
 'nth-last-of-type': function(m) {
 return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
 },
 'first-of-type': function(m) {
 m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
 },
 'last-of-type': function(m) {
 m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
 },
 'only-of-type': function(m) {
 var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
 },
 nth: function(fragment, m) {
 var mm, formula = m[6], predicate;
 if (formula == 'even') formula = '2n+0';
 if (formula == 'odd') formula = '2n+1';
 if (mm = formula.match(/^(\d+)$/)) // digit only
 return '[' + fragment + "= " + mm[1] + ']';
 if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
 if (mm[1] == "-") mm[1] = -1;
 var a = mm[1] ? Number(mm[1]) : 1;
 var b = mm[2] ? Number(mm[2]) : 0;
 predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
 "((#{fragment} - #{b}) div #{a} >= 0)]";
 return new Template(predicate).evaluate({
 fragment: fragment, a: a, b: b });
 }
 }
 }
 },

 criteria: {
 tagName: 'n = h.tagName(n, r, "#{1}", c); c = false;',
 className: 'n = h.className(n, r, "#{1}", c); c = false;',
 id: 'n = h.id(n, r, "#{1}", c); c = false;',
 attrPresence: 'n = h.attrPresence(n, r, "#{1}", c); c = false;',
 attr: function(m) {
 m[3] = (m[5] || m[6]);
 return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}", c); c = false;').evaluate(m);
 },
 pseudo: function(m) {
 if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
 return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
 },
 descendant: 'c = "descendant";',
 child: 'c = "child";',
 adjacent: 'c = "adjacent";',
 laterSibling: 'c = "laterSibling";'
 },

 patterns: {
 // combinators must be listed first
 // (and descendant needs to be last combinator)
 laterSibling: /^\s*~\s*/,
 child: /^\s*>\s*/,
 adjacent: /^\s*\+\s*/,
 descendant: /^\s/,

 // selectors follow
 tagName: /^\s*(\*|[\w\-]+)(\b|$)?/,
 id: /^#([\w\-\*]+)(\b|$)/,
 className: /^\.([\w\-\*]+)(\b|$)/,
 pseudo:
/^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/,
 attrPresence: /^\[((?:[\w]+:)?[\w]+)\]/,
 attr: /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/
 },

 // for Selector.match and Element#match
 assertions: {
 tagName: function(element, matches) {
 return matches[1].toUpperCase() == element.tagName.toUpperCase();
 },

 className: function(element, matches) {
 return Element.hasClassName(element, matches[1]);
 },

 id: function(element, matches) {
 return element.id === matches[1];
 },

 attrPresence: function(element, matches) {
 return Element.hasAttribute(element, matches[1]);
 },

 attr: function(element, matches) {
 var nodeValue = Element.readAttribute(element, matches[1]);
 return nodeValue && Selector.operators[matches[2]](nodeValue, matches[5] || matches[6]);
 }
 },

 handlers: {
 // UTILITY FUNCTIONS
 // joins two collections
 concat: function(a, b) {
 for (var i = 0, node; node = b[i]; i++)
 a.push(node);
 return a;
 },

 // marks an array of nodes for counting
 mark: function(nodes) {
 var _true = Prototype.emptyFunction;
 for (var i = 0, node; node = nodes[i]; i++)
 node._countedByPrototype = _true;
 return nodes;
 },

 unmark: function(nodes) {
 for (var i = 0, node; node = nodes[i]; i++)
 node._countedByPrototype = undefined;
 return nodes;
 },

 // mark each child node with its position (for nth calls)
 // "ofType" flag indicates whether we're indexing for nth-of-type
 // rather than nth-child
 index: function(parentNode, reverse, ofType) {
 parentNode._countedByPrototype = Prototype.emptyFunction;
 if (reverse) {
 for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
 var node = nodes[i];
 if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
 }
 } else {
 for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
 if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
 }
 },

 // filters out duplicates and extends all nodes
 unique: function(nodes) {
 if (nodes.length == 0) return nodes;
 var results = [], n;
 for (var i = 0, l = nodes.length; i < l; i++)
 if (!(n = nodes[i])._countedByPrototype) {
 n._countedByPrototype = Prototype.emptyFunction;
 results.push(Element.extend(n));
 }
 return Selector.handlers.unmark(results);
 },

 // COMBINATOR FUNCTIONS
 descendant: function(nodes) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 h.concat(results, node.getElementsByTagName('*'));
 return results;
 },

 child: function(nodes) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 for (var j = 0, child; child = node.childNodes[j]; j++)
 if (child.nodeType == 1 && child.tagName != '!') results.push(child);
 }
 return results;
 },

 adjacent: function(nodes) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 var next = this.nextElementSibling(node);
 if (next) results.push(next);
 }
 return results;
 },

 laterSibling: function(nodes) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 h.concat(results, Element.nextSiblings(node));
 return results;
 },

 nextElementSibling: function(node) {
 while (node = node.nextSibling)
 if (node.nodeType == 1) return node;
 return null;
 },

 previousElementSibling: function(node) {
 while (node = node.previousSibling)
 if (node.nodeType == 1) return node;
 return null;
 },

 // TOKEN FUNCTIONS
 tagName: function(nodes, root, tagName, combinator) {
 var uTagName = tagName.toUpperCase();
 var results = [], h = Selector.handlers;
 if (nodes) {
 if (combinator) {
 // fastlane for ordinary descendant combinators
 if (combinator == "descendant") {
 for (var i = 0, node; node = nodes[i]; i++)
 h.concat(results, node.getElementsByTagName(tagName));
 return results;
 } else nodes = this[combinator](nodes);
 if (tagName == "*") return nodes;
 }
 for (var i = 0, node; node = nodes[i]; i++)
 if (node.tagName.toUpperCase() === uTagName) results.push(node);
 return results;
 } else return root.getElementsByTagName(tagName);
 },

 id: function(nodes, root, id, combinator) {
 var targetNode = $(id), h = Selector.handlers;
 if (!targetNode) return [];
 if (!nodes && root == document) return [targetNode];
 if (nodes) {
 if (combinator) {
 if (combinator == 'child') {
 for (var i = 0, node; node = nodes[i]; i++)
 if (targetNode.parentNode == node) return [targetNode];
 } else if (combinator == 'descendant') {
 for (var i = 0, node; node = nodes[i]; i++)
 if (Element.descendantOf(targetNode, node)) return [targetNode];
 } else if (combinator == 'adjacent') {
 for (var i = 0, node; node = nodes[i]; i++)
 if (Selector.handlers.previousElementSibling(targetNode) == node)
 return [targetNode];
 } else nodes = h[combinator](nodes);
 }
 for (var i = 0, node; node = nodes[i]; i++)
 if (node == targetNode) return [targetNode];
 return [];
 }
 return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
 },

 className: function(nodes, root, className, combinator) {
 if (nodes && combinator) nodes = this[combinator](nodes);
 return Selector.handlers.byClassName(nodes, root, className);
 },

 byClassName: function(nodes, root, className) {
 if (!nodes) nodes = Selector.handlers.descendant([root]);
 var needle = ' ' + className + ' ';
 for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
 nodeClassName = node.className;
 if (nodeClassName.length == 0) continue;
 if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
 results.push(node);
 }
 return results;
 },

 attrPresence: function(nodes, root, attr, combinator) {
 if (!nodes) nodes = root.getElementsByTagName("*");
 if (nodes && combinator) nodes = this[combinator](nodes);
 var results = [];
 for (var i = 0, node; node = nodes[i]; i++)
 if (Element.hasAttribute(node, attr)) results.push(node);
 return results;
 },

 attr: function(nodes, root, attr, value, operator, combinator) {
 if (!nodes) nodes = root.getElementsByTagName("*");
 if (nodes && combinator) nodes = this[combinator](nodes);
 var handler = Selector.operators[operator], results = [];
 for (var i = 0, node; node = nodes[i]; i++) {
 var nodeValue = Element.readAttribute(node, attr);
 if (nodeValue === null) continue;
 if (handler(nodeValue, value)) results.push(node);
 }
 return results;
 },

 pseudo: function(nodes, name, value, root, combinator) {
 if (nodes && combinator) nodes = this[combinator](nodes);
 if (!nodes) nodes = root.getElementsByTagName("*");
 return Selector.pseudos[name](nodes, value, root);
 }
 },

 pseudos: {
 'first-child': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 if (Selector.handlers.previousElementSibling(node)) continue;
 results.push(node);
 }
 return results;
 },
 'last-child': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 if (Selector.handlers.nextElementSibling(node)) continue;
 results.push(node);
 }
 return results;
 },
 'only-child': function(nodes, value, root) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
 results.push(node);
 return results;
 },
 'nth-child': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root);
 },
 'nth-last-child': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root, true);
 },
 'nth-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root, false, true);
 },
 'nth-last-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root, true, true);
 },
 'first-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, "1", root, false, true);
 },
 'last-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, "1", root, true, true);
 },
 'only-of-type': function(nodes, formula, root) {
 var p = Selector.pseudos;
 return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
 },

 // handles the an+b logic
 getIndices: function(a, b, total) {
 if (a == 0) return b > 0 ? [b] : [];
 return $R(1, total).inject([], function(memo, i) {
 if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
 return memo;
 });
 },

 // handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
 nth: function(nodes, formula, root, reverse, ofType) {
 if (nodes.length == 0) return [];
 if (formula == 'even') formula = '2n+0';
 if (formula == 'odd') formula = '2n+1';
 var h = Selector.handlers, results = [], indexed = [], m;
 h.mark(nodes);
 for (var i = 0, node; node = nodes[i]; i++) {
 if (!node.parentNode._countedByPrototype) {
 h.index(node.parentNode, reverse, ofType);
 indexed.push(node.parentNode);
 }
 }
 if (formula.match(/^\d+$/)) { // just a number
 formula = Number(formula);
 for (var i = 0, node; node = nodes[i]; i++)
 if (node.nodeIndex == formula) results.push(node);
 } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
 if (m[1] == "-") m[1] = -1;
 var a = m[1] ? Number(m[1]) : 1;
 var b = m[2] ? Number(m[2]) : 0;
 var indices = Selector.pseudos.getIndices(a, b, nodes.length);
 for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
 for (var j = 0; j < l; j++)
 if (node.nodeIndex == indices[j]) results.push(node);
 }
 }
 h.unmark(nodes);
 h.unmark(indexed);
 return results;
 },

 'empty': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 // IE treats comments as element nodes
 if (node.tagName == '!' || node.firstChild) continue;
 results.push(node);
 }
 return results;
 },

 'not': function(nodes, selector, root) {
 var h = Selector.handlers, selectorType, m;
 var exclusions = new Selector(selector).findElements(root);
 h.mark(exclusions);
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (!node._countedByPrototype) results.push(node);
 h.unmark(exclusions);
 return results;
 },

 'enabled': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (!node.disabled && (!node.type || node.type !== 'hidden'))
 results.push(node);
 return results;
 },

 'disabled': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (node.disabled) results.push(node);
 return results;
 },

 'checked': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (node.checked) results.push(node);
 return results;
 }
 },

 operators: {
 '=': function(nv, v) { return nv == v; },
 '!=': function(nv, v) { return nv != v; },
 '^=': function(nv, v) { return nv == v || nv && nv.startsWith(v); },
 '$=': function(nv, v) { return nv == v || nv && nv.endsWith(v); },
 '*=': function(nv, v) { return nv == v || nv && nv.include(v); },
 '$=': function(nv, v) { return nv.endsWith(v); },
 '*=': function(nv, v) { return nv.include(v); },
 '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
 '|=': function(nv, v) { return ('-' + (nv || "").toUpperCase() +
 '-').include('-' + (v || "").toUpperCase() + '-'); }
 },

 split: function(expression) {
 var expressions = [];
 expression.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
 expressions.push(m[1].strip());
 });
 return expressions;
 },

 matchElements: function(elements, expression) {
 var matches = $$(expression), h = Selector.handlers;
 h.mark(matches);
 for (var i = 0, results = [], element; element = elements[i]; i++)
 if (element._countedByPrototype) results.push(element);
 h.unmark(matches);
 return results;
 },

 findElement: function(elements, expression, index) {
 if (Object.isNumber(expression)) {
 index = expression; expression = false;
 }
 return Selector.matchElements(elements, expression || '*')[index || 0];
 },

 findChildElements: function(element, expressions) {
 expressions = Selector.split(expressions.join(','));
 var results = [], h = Selector.handlers;
 for (var i = 0, l = expressions.length, selector; i < l; i++) {
 selector = new Selector(expressions[i].strip());
 h.concat(results, selector.findElements(element));
 }
 return (l > 1) ? h.unique(results) : results;
 }
});

if (Prototype.Browser.IE) {
 Object.extend(Selector.handlers, {
 // IE returns comment nodes on getElementsByTagName("*").
 // Filter them out.
 concat: function(a, b) {
 for (var i = 0, node; node = b[i]; i++)
 if (node.tagName !== "!") a.push(node);
 return a;
 },

 // IE improperly serializes _countedByPrototype in (inner|outer)HTML.
 unmark: function(nodes) {
 for (var i = 0, node; node = nodes[i]; i++)
 node.removeAttribute('_countedByPrototype');
 return nodes;
 }
 });
}

function $$() {
 return Selector.findChildElements(document, $A(arguments));
}
var Form = {
 reset: function(form) {
 $(form).reset();
 return form;
 },

 serializeElements: function(elements, options) {
 if (typeof options != 'object') options = { hash: !!options };
 else if (Object.isUndefined(options.hash)) options.hash = true;
 var key, value, submitted = false, submit = options.submit;

 var data = elements.inject({ }, function(result, element) {
 if (!element.disabled && element.name) {
 key = element.name; value = $(element).getValue();
 if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
 submit !== false && (!submit || key == submit) && (submitted = true)))) {
 if (key in result) {
 // a key is already present; construct an array of values
 if (!Object.isArray(result[key])) result[key] = [result[key]];
 result[key].push(value);
 }
 else result[key] = value;
 }
 }
 return result;
 });

 return options.hash ? data : Object.toQueryString(data);
 }
};

Form.Methods = {
 serialize: function(form, options) {
 return Form.serializeElements(Form.getElements(form), options);
 },

 getElements: function(form) {
 return $A($(form).getElementsByTagName('*')).inject([],
 function(elements, child) {
 if (Form.Element.Serializers[child.tagName.toLowerCase()])
 elements.push(Element.extend(child));
 return elements;
 }
 );
 },

 getInputs: function(form, typeName, name) {
 form = $(form);
 var inputs = form.getElementsByTagName('input');

 if (!typeName && !name) return $A(inputs).map(Element.extend);

 for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
 var input = inputs[i];
 if ((typeName && input.type != typeName) || (name && input.name != name))
 continue;
 matchingInputs.push(Element.extend(input));
 }

 return matchingInputs;
 },

 disable: function(form) {
 form = $(form);
 Form.getElements(form).invoke('disable');
 return form;
 },

 enable: function(form) {
 form = $(form);
 Form.getElements(form).invoke('enable');
 return form;
 },

 findFirstElement: function(form) {
 var elements = $(form).getElements().findAll(function(element) {
 return 'hidden' != element.type && !element.disabled;
 });
 var firstByIndex = elements.findAll(function(element) {
 return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
 }).sortBy(function(element) { return element.tabIndex }).first();

 return firstByIndex ? firstByIndex : elements.find(function(element) {
 return ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
 });
 },

 focusFirstElement: function(form) {
 form = $(form);
 form.findFirstElement().activate();
 return form;
 },

 request: function(form, options) {
 form = $(form), options = Object.clone(options || { });

 var params = options.parameters, action = form.readAttribute('action') || '';
 if (action.blank()) action = window.location.href;
 options.parameters = form.serialize(true);

 if (params) {
 if (Object.isString(params)) params = params.toQueryParams();
 Object.extend(options.parameters, params);
 }

 if (form.hasAttribute('method') && !options.method)
 options.method = form.method;

 return new Ajax.Request(action, options);
 }
};

/*--------------------------------------------------------------------------*/

Form.Element = {
 focus: function(element) {
 $(element).focus();
 return element;
 },

 select: function(element) {
 $(element).select();
 return element;
 }
};

Form.Element.Methods = {
 serialize: function(element) {
 element = $(element);
 if (!element.disabled && element.name) {
 var value = element.getValue();
 if (value != undefined) {
 var pair = { };
 pair[element.name] = value;
 return Object.toQueryString(pair);
 }
 }
 return '';
 },

 getValue: function(element) {
 element = $(element);
 var method = element.tagName.toLowerCase();
 return Form.Element.Serializers[method](element);
 },

 setValue: function(element, value) {
 element = $(element);
 var method = element.tagName.toLowerCase();
 Form.Element.Serializers[method](element, value);
 return element;
 },

 clear: function(element) {
 $(element).value = '';
 return element;
 },

 present: function(element) {
 return $(element).value != '';
 },

 activate: function(element) {
 element = $(element);
 try {
 element.focus();
 if (element.select && (element.tagName.toLowerCase() != 'input' ||
 !['button', 'reset', 'submit'].include(element.type)))
 element.select();
 } catch (e) { }
 return element;
 },

 disable: function(element) {
 element = $(element);
 element.disabled = true;
 return element;
 },

 enable: function(element) {
 element = $(element);
 element.disabled = false;
 return element;
 }
};

/*--------------------------------------------------------------------------*/

var Field = Form.Element;
var $F = Form.Element.Methods.getValue;

/*--------------------------------------------------------------------------*/

Form.Element.Serializers = {
 input: function(element, value) {
 switch (element.type.toLowerCase()) {
 case 'checkbox':
 case 'radio':
 return Form.Element.Serializers.inputSelector(element, value);
 default:
 return Form.Element.Serializers.textarea(element, value);
 }
 },

 inputSelector: function(element, value) {
 if (Object.isUndefined(value)) return element.checked ? element.value : null;
 else element.checked = !!value;
 },

 textarea: function(element, value) {
 if (Object.isUndefined(value)) return element.value;
 else element.value = value;
 },

 select: function(element, value) {
 if (Object.isUndefined(value))
 return this[element.type == 'select-one' ?
 'selectOne' : 'selectMany'](element);
 else {
 var opt, currentValue, single = !Object.isArray(value);
 for (var i = 0, length = element.length; i < length; i++) {
 opt = element.options[i];
 currentValue = this.optionValue(opt);
 if (single) {
 if (currentValue == value) {
 opt.selected = true;
 return;
 }
 }
 else opt.selected = value.include(currentValue);
 }
 }
 },

 selectOne: function(element) {
 var index = element.selectedIndex;
 return index >= 0 ? this.optionValue(element.options[index]) : null;
 },

 selectMany: function(element) {
 var values, length = element.length;
 if (!length) return null;

 for (var i = 0, values = []; i < length; i++) {
 var opt = element.options[i];
 if (opt.selected) values.push(this.optionValue(opt));
 }
 return values;
 },

 optionValue: function(opt) {
 // extend element because hasAttribute may not be native
 return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
 }
};

/*--------------------------------------------------------------------------*/

Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
 initialize: function($super, element, frequency, callback) {
 $super(callback, frequency);
 this.element = $(element);
 this.lastValue = this.getValue();
 },

 execute: function() {
 var value = this.getValue();
 if (Object.isString(this.lastValue) && Object.isString(value) ?
 this.lastValue != value : String(this.lastValue) != String(value)) {
 this.callback(this.element, value);
 this.lastValue = value;
 }
 }
});

Form.Element.Observer = Class.create(Abstract.TimedObserver, {
 getValue: function() {
 return Form.Element.getValue(this.element);
 }
});

Form.Observer = Class.create(Abstract.TimedObserver, {
 getValue: function() {
 return Form.serialize(this.element);
 }
});

/*--------------------------------------------------------------------------*/

Abstract.EventObserver = Class.create({
 initialize: function(element, callback) {
 this.element = $(element);
 this.callback = callback;

 this.lastValue = this.getValue();
 if (this.element.tagName.toLowerCase() == 'form')
 this.registerFormCallbacks();
 else
 this.registerCallback(this.element);
 },

 onElementEvent: function() {
 var value = this.getValue();
 if (this.lastValue != value) {
 this.callback(this.element, value);
 this.lastValue = value;
 }
 },

 registerFormCallbacks: function() {
 Form.getElements(this.element).each(this.registerCallback, this);
 },

 registerCallback: function(element) {
 if (element.type) {
 switch (element.type.toLowerCase()) {
 case 'checkbox':
 case 'radio':
 Event.observe(element, 'click', this.onElementEvent.bind(this));
 break;
 default:
 Event.observe(element, 'change', this.onElementEvent.bind(this));
 break;
 }
 }
 }
});

Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
 getValue: function() {
 return Form.Element.getValue(this.element);
 }
});

Form.EventObserver = Class.create(Abstract.EventObserver, {
 getValue: function() {
 return Form.serialize(this.element);
 }
});
if (!window.Event) var Event = { };

Object.extend(Event, {
 KEY_BACKSPACE: 8,
 KEY_TAB: 9,
 KEY_RETURN: 13,
 KEY_ESC: 27,
 KEY_LEFT: 37,
 KEY_UP: 38,
 KEY_RIGHT: 39,
 KEY_DOWN: 40,
 KEY_DELETE: 46,
 KEY_HOME: 36,
 KEY_END: 35,
 KEY_PAGEUP: 33,
 KEY_PAGEDOWN: 34,
 KEY_INSERT: 45,

 cache: { },

 relatedTarget: function(event) {
 var element;
 switch(event.type) {
 case 'mouseover': element = event.fromElement; break;
 case 'mouseout': element = event.toElement; break;
 default: return null;
 }
 return Element.extend(element);
 }
});

Event.Methods = (function() {
 var isButton;

 if (Prototype.Browser.IE) {
 var buttonMap = { 0: 1, 1: 4, 2: 2 };
 isButton = function(event, code) {
 return event.button == buttonMap[code];
 };

 } else if (Prototype.Browser.WebKit) {
 isButton = function(event, code) {
 switch (code) {
 case 0: return event.which == 1 && !event.metaKey;
 case 1: return event.which == 1 && event.metaKey;
 default: return false;
 }
 };

 } else {
 isButton = function(event, code) {
 return event.which ? (event.which === code + 1) : (event.button === code);
 };
 }

 return {
 isLeftClick: function(event) { return isButton(event, 0) },
 isMiddleClick: function(event) { return isButton(event, 1) },
 isRightClick: function(event) { return isButton(event, 2) },

 element: function(event) {
 event = Event.extend(event);

 var node = event.target,
 type = event.type,
 currentTarget = event.currentTarget;

 if (currentTarget && currentTarget.tagName) {
 // Firefox screws up the "click" event when moving between radio buttons
 // via arrow keys. It also screws up the "load" and "error" events on images,
 // reporting the document as the target instead of the original image.
 if (type === 'load' || type === 'error' ||
 (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
 && currentTarget.type === 'radio'))
 node = currentTarget;
 }
 if (node) {
 if (node.nodeType == Node.TEXT_NODE) node = node.parentNode;
 return Element.extend(node);
 } else return false;
 },

 findElement: function(event, expression) {
 var element = Event.element(event);
 if (!expression) return element;
 var elements = [element].concat(element.ancestors());
 return Selector.findElement(elements, expression, 0);
 },

 pointer: function(event) {
 var docElement = document.documentElement,
 body = document.body || { scrollLeft: 0, scrollTop: 0 };
 return {
 x: event.pageX || (event.clientX +
 (docElement.scrollLeft || body.scrollLeft) -
 (docElement.clientLeft || 0)),
 y: event.pageY || (event.clientY +
 (docElement.scrollTop || body.scrollTop) -
 (docElement.clientTop || 0))
 };
 },

 pointerX: function(event) { return Event.pointer(event).x },
 pointerY: function(event) { return Event.pointer(event).y },

 stop: function(event) {
 Event.extend(event);
 event.preventDefault();
 event.stopPropagation();
 event.stopped = true;
 }
 };
})();

Event.extend = (function() {
 var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
 m[name] = Event.Methods[name].methodize();
 return m;
 });

 if (Prototype.Browser.IE) {
 Object.extend(methods, {
 stopPropagation: function() { this.cancelBubble = true },
 preventDefault: function() { this.returnValue = false },
 inspect: function() { return "[object Event]" }
 });

 return function(event) {
 if (!event) return false;
 if (event._extendedByPrototype) return event;

 event._extendedByPrototype = Prototype.emptyFunction;
 var pointer = Event.pointer(event);
 Object.extend(event, {
 target: event.srcElement,
 relatedTarget: Event.relatedTarget(event),
 pageX: pointer.x,
 pageY: pointer.y
 });
 return Object.extend(event, methods);
 };

 } else {
 Event.prototype = Event.prototype || document.createEvent("HTMLEvents")['__proto__'];
 Object.extend(Event.prototype, methods);
 return Prototype.K;
 }
})();

Object.extend(Event, (function() {
 var cache = Event.cache;

 function getEventID(element) {
 try {
 if (element._prototypeEventID) return element._prototypeEventID[0];
 arguments.callee.id = arguments.callee.id || 1;
 return element._prototypeEventID = [++arguments.callee.id];
 } catch (error) {
 return false;
 }
 }

 function getDOMEventName(eventName) {
 if (eventName && eventName.include(':')) return "dataavailable";
 return eventName;
 }

 function getCacheForID(id) {
 return cache[id] = cache[id] || { };
 }

 function getWrappersForEventName(id, eventName) {
 var c = getCacheForID(id);
 return c[eventName] = c[eventName] || [];
 }

 function createWrapper(element, eventName, handler) {
 var id = getEventID(element);
 var c = getWrappersForEventName(id, eventName);
 if (c.pluck("handler").include(handler)) return false;

 var wrapper = function(event) {
 if (!Event || !Event.extend ||
 (event.eventName && event.eventName != eventName))
 return false;

 Event.extend(event);
 handler.call(element, event);
 };

 wrapper.handler = handler;
 c.push(wrapper);
 return wrapper;
 }

 function findWrapper(id, eventName, handler) {
 var c = getWrappersForEventName(id, eventName);
 return c.find(function(wrapper) { return wrapper.handler == handler });
 }

 function destroyWrapper(id, eventName, handler) {
 var c = getCacheForID(id);
 if (!c[eventName]) return false;
 c[eventName] = c[eventName].without(findWrapper(id, eventName, handler));
 }

 function destroyCache() {
 for (var id in cache)
 for (var eventName in cache[id])
 cache[id][eventName] = null;
 }


 // Internet Explorer needs to remove event handlers on page unload
 // in order to avoid memory leaks.
 if (window.attachEvent) {
 window.attachEvent("onunload", destroyCache);
 }

 // Safari has a dummy event handler on page unload so that it won't
 // use its bfcache. Safari <= 3.1 has an issue with restoring the "document"
 // object when page is returned to via the back button using its bfcache.
 if (Prototype.Browser.WebKit) {
 window.addEventListener('unload', Prototype.emptyFunction, false);
 }

 return {
 observe: function(element, eventName, handler) {
 element = $(element);
 var name = getDOMEventName(eventName);

 var wrapper = createWrapper(element, eventName, handler);
 if (!wrapper) return element;

 if (element.addEventListener) {
 element.addEventListener(name, wrapper, false);
 } else {
 element.attachEvent("on" + name, wrapper);
 }

 return element;
 },

 stopObserving: function(element, eventName, handler) {
 element = $(element);
 var id = getEventID(element), name = getDOMEventName(eventName);

 if (!handler && eventName) {
 getWrappersForEventName(id, eventName).each(function(wrapper) {
 element.stopObserving(eventName, wrapper.handler);
 });
 return element;

 } else if (!eventName) {
 Object.keys(getCacheForID(id)).each(function(eventName) {
 element.stopObserving(eventName);
 });
 return element;
 }

 var wrapper = findWrapper(id, eventName, handler);
 if (!wrapper) return element;

 if (element.removeEventListener) {
 element.removeEventListener(name, wrapper, false);
 } else {
 element.detachEvent("on" + name, wrapper);
 }

 destroyWrapper(id, eventName, handler);

 return element;
 },

 fire: function(element, eventName, memo) {
 element = $(element);
 if (element == document && document.createEvent && !element.dispatchEvent)
 element = document.documentElement;

 var event;
 if (document.createEvent) {
 event = document.createEvent("HTMLEvents");
 event.initEvent("dataavailable", true, true);
 } else {
 event = document.createEventObject();
 event.eventType = "ondataavailable";
 }

 event.eventName = eventName;
 event.memo = memo || { };

 if (document.createEvent) {
 element.dispatchEvent(event);
 } else {
 element.fireEvent(event.eventType, event);
 }

 return Event.extend(event);
 }
 };
})());

Object.extend(Event, Event.Methods);

Element.addMethods({
 fire: Event.fire,
 observe: Event.observe,
 stopObserving: Event.stopObserving
});

Object.extend(document, {
 fire: Element.Methods.fire.methodize(),
 observe: Element.Methods.observe.methodize(),
 stopObserving: Element.Methods.stopObserving.methodize(),
 loaded: false
});

(function() {
 /* Support for the DOMContentLoaded event is based on work by Dan Webb,
 Matthias Miller, Dean Edwards and John Resig. */

 var timer;

 function fireContentLoadedEvent() {
 if (document.loaded) return;
 if (timer) window.clearInterval(timer);
 document.fire("dom:loaded");
 document.loaded = true;
 }

 if (document.addEventListener) {
 if (Prototype.Browser.WebKit) {
 timer = window.setInterval(function() {
 if (/loaded|complete/.test(document.readyState))
 fireContentLoadedEvent();
 }, 0);

 Event.observe(window, "load", fireContentLoadedEvent);

 } else {
 document.addEventListener("DOMContentLoaded",
 fireContentLoadedEvent, false);
 }

 } else {
 document.write("<script id=__onDOMContentLoaded defer src=//:><\/script>");
 $("__onDOMContentLoaded").onreadystatechange = function() {
 if (this.readyState == "complete") {
 this.onreadystatechange = null;
 fireContentLoadedEvent();
 }
 };
 }
})();
/*------------------------------- DEPRECATED -------------------------------*/

Hash.toQueryString = Object.toQueryString;

var Toggle = { display: Element.toggle };

Element.Methods.childOf = Element.Methods.descendantOf;

var Insertion = {
 Before: function(element, content) {
 return Element.insert(element, {before:content});
 },

 Top: function(element, content) {
 return Element.insert(element, {top:content});
 },

 Bottom: function(element, content) {
 return Element.insert(element, {bottom:content});
 },

 After: function(element, content) {
 return Element.insert(element, {after:content});
 }
};

var $continue = new Error('"throw $continue" is deprecated, use "return" instead');

// This should be moved to script.aculo.us; notice the deprecated methods
// further below, that map to the newer Element methods.
var Position = {
 // set to true if needed, warning: firefox performance problems
 // NOT neeeded for page scrolling, only if draggable contained in
 // scrollable elements
 includeScrollOffsets: false,

 // must be called before calling withinIncludingScrolloffset, every time the
 // page is scrolled
 prepare: function() {
 this.deltaX = window.pageXOffset
 || document.documentElement.scrollLeft
 || document.body.scrollLeft
 || 0;
 this.deltaY = window.pageYOffset
 || document.documentElement.scrollTop
 || document.body.scrollTop
 || 0;
 },

 // caches x/y coordinate pair to use with overlap
 within: function(element, x, y) {
 if (this.includeScrollOffsets)
 return this.withinIncludingScrolloffsets(element, x, y);
 this.xcomp = x;
 this.ycomp = y;
 this.offset = Element.cumulativeOffset(element);

 return (y >= this.offset[1] &&
 y < this.offset[1] + element.offsetHeight &&
 x >= this.offset[0] &&
 x < this.offset[0] + element.offsetWidth);
 },

 withinIncludingScrolloffsets: function(element, x, y) {
 var offsetcache = Element.cumulativeScrollOffset(element);

 this.xcomp = x + offsetcache[0] - this.deltaX;
 this.ycomp = y + offsetcache[1] - this.deltaY;
 this.offset = Element.cumulativeOffset(element);

 return (this.ycomp >= this.offset[1] &&
 this.ycomp < this.offset[1] + element.offsetHeight &&
 this.xcomp >= this.offset[0] &&
 this.xcomp < this.offset[0] + element.offsetWidth);
 },

 // within must be called directly before
 overlap: function(mode, element) {
 if (!mode) return 0;
 if (mode == 'vertical')
 return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
 element.offsetHeight;
 if (mode == 'horizontal')
 return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
 element.offsetWidth;
 },

 // Deprecation layer -- use newer Element methods now (1.5.2).

 cumulativeOffset: Element.Methods.cumulativeOffset,

 positionedOffset: Element.Methods.positionedOffset,

 absolutize: function(element) {
 Position.prepare();
 return Element.absolutize(element);
 },

 relativize: function(element) {
 Position.prepare();
 return Element.relativize(element);
 },

 realOffset: Element.Methods.cumulativeScrollOffset,

 offsetParent: Element.Methods.getOffsetParent,

 page: Element.Methods.viewportOffset,

 clone: function(source, target, options) {
 options = options || { };
 return Element.clonePosition(target, source, options);
 }
};

/*--------------------------------------------------------------------------*/

if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
 function iter(name) {
 return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
 }

 instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
 function(element, className) {
 className = className.toString().strip();
 var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
 return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
 } : function(element, className) {
 className = className.toString().strip();
 var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
 if (!classNames && !className) return elements;

 var nodes = $(element).getElementsByTagName('*');
 className = ' ' + className + ' ';

 for (var i = 0, child, cn; child = nodes[i]; i++) {
 if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
 (classNames && classNames.all(function(name) {
 return !name.toString().blank() && cn.include(' ' + name + ' ');
 }))))
 elements.push(Element.extend(child));
 }
 return elements;
 };

 return function(className, parentElement) {
 return $(parentElement || document.body).getElementsByClassName(className);
 };
}(Element.Methods);

/*--------------------------------------------------------------------------*/

Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
 initialize: function(element) {
 this.element = $(element);
 },

 _each: function(iterator) {
 this.element.className.split(/\s+/).select(function(name) {
 return name.length > 0;
 })._each(iterator);
 },

 set: function(className) {
 this.element.className = className;
 },

 add: function(classNameToAdd) {
 if (this.include(classNameToAdd)) return;
 this.set($A(this).concat(classNameToAdd).join(' '));
 },

 remove: function(classNameToRemove) {
 if (!this.include(classNameToRemove)) return;
 this.set($A(this).without(classNameToRemove).join(' '));
 },

 toString: function() {
 return $A(this).join(' ');
 }
};

Object.extend(Element.ClassNames.prototype, Enumerable);

/*--------------------------------------------------------------------------*/

Element.addMethods();
/*
* Really easy field validation with Prototype
* http://tetlaw.id.au/view/javascript/really-easy-field-validation
* Andrew Tetlaw
* Version 1.5.4.1 (2007-01-05)
*
* Copyright (c) 2007 Andrew Tetlaw
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
var Validator = Class.create();

Validator.prototype = {
 initialize : function(className, error, test, options) {
 if(typeof test == 'function'){
 this.options = $H(options);
 this._test = test;
 } else {
 this.options = $H(test);
 this._test = function(){return true};
 }
 this.error = error || 'Validation failed.';
 this.className = className;
 },
 test : function(v, elm) {
 return (this._test(v,elm) && this.options.all(function(p){
 return Validator.methods[p.key] ? Validator.methods[p.key](v,elm,p.value) : true;
 }));
 }
}
Validator.methods = {
 pattern : function(v,elm,opt) {return Validation.get('IsEmpty').test(v) || opt.test(v)},
 minLength : function(v,elm,opt) {return v.length >= opt},
 maxLength : function(v,elm,opt) {return v.length <= opt},
 min : function(v,elm,opt) {return v >= parseFloat(opt)},
 max : function(v,elm,opt) {return v <= parseFloat(opt)},
 notOneOf : function(v,elm,opt) {return $A(opt).all(function(value) {
 return v != value;
 })},
 oneOf : function(v,elm,opt) {return $A(opt).any(function(value) {
 return v == value;
 })},
 is : function(v,elm,opt) {return v == opt},
 isNot : function(v,elm,opt) {return v != opt},
 equalToField : function(v,elm,opt) {return v == $F(opt)},
 notEqualToField : function(v,elm,opt) {return v != $F(opt)},
 include : function(v,elm,opt) {return $A(opt).all(function(value) {
 return Validation.get(value).test(v,elm);
 })}
}

var Validation = Class.create();
Validation.defaultOptions = {
 onSubmit : true,
 stopOnFirst : false,
 immediate : false,
 focusOnError : true,
 useTitles : false,
 addClassNameToContainer: false,
 containerClassName: '.input-box',
 onFormValidate : function(result, form) {},
 onElementValidate : function(result, elm) {}
};

Validation.prototype = {
 initialize : function(form, options){
 this.form = $(form);
 if (!this.form) {
 return;
 }
 this.options = Object.extend({
 onSubmit : Validation.defaultOptions.onSubmit,
 stopOnFirst : Validation.defaultOptions.stopOnFirst,
 immediate : Validation.defaultOptions.immediate,
 focusOnError : Validation.defaultOptions.focusOnError,
 useTitles : Validation.defaultOptions.useTitles,
 onFormValidate : Validation.defaultOptions.onFormValidate,
 onElementValidate : Validation.defaultOptions.onElementValidate
 }, options || {});
 if(this.options.onSubmit) Event.observe(this.form,'submit',this.onSubmit.bind(this),false);
 if(this.options.immediate) {
 Form.getElements(this.form).each(function(input) { // Thanks Mike! 
 if (input.tagName.toLowerCase() == 'select') {
 Event.observe(input, 'blur', this.onChange.bindAsEventListener(this));
 }
 Event.observe(input, 'change', this.onChange.bindAsEventListener(this));
 }, this);
 }
 },
 onChange : function (ev) {
 Validation.isOnChange = true;
 Validation.validate(Event.element(ev),{
 useTitle : this.options.useTitles, 
 onElementValidate : this.options.onElementValidate
 });
 Validation.isOnChange = false; 
 },
 onSubmit : function(ev){
 if(!this.validate()) Event.stop(ev);
 },
 validate : function() {
 var result = false;
 var useTitles = this.options.useTitles;
 var callback = this.options.onElementValidate;
 try {
 if(this.options.stopOnFirst) {
 result = Form.getElements(this.form).all(function(elm) { return Validation.validate(elm,{useTitle : useTitles, onElementValidate : callback}); });
 } else {
 result = Form.getElements(this.form).collect(function(elm) { return Validation.validate(elm,{useTitle : useTitles, onElementValidate : callback}); }).all();
 }
 } catch (e) {

 }
 if(!result && this.options.focusOnError) {
 try{
 Form.getElements(this.form).findAll(function(elm){return $(elm).hasClassName('validation-failed')}).first().focus()
 }
 catch(e){

 }
 }
 this.options.onFormValidate(result, this.form);
 return result;
 },
 reset : function() {
 Form.getElements(this.form).each(Validation.reset);
 }
}

Object.extend(Validation, {
 validate : function(elm, options){
 options = Object.extend({
 useTitle : false,
 onElementValidate : function(result, elm) {}
 }, options || {});
 elm = $(elm);

 var cn = $w(elm.className);
 return result = cn.all(function(value) {
 var test = Validation.test(value,elm,options.useTitle);
 options.onElementValidate(test, elm);
 return test;
 });
 },
 insertAdvice : function(elm, advice){
 var container = $(elm).up('.field-row');
 if(container){
 Element.insert(container, {after: advice});
 } else if (elm.up('td.value')) {
 elm.up('td.value').insert({bottom: advice});
 } else if (elm.advaiceContainer && $(elm.advaiceContainer)) {
 $(elm.advaiceContainer).update(advice);
 }
 else {
 switch (elm.type.toLowerCase()) {
 case 'checkbox':
 case 'radio':
 var p = elm.parentNode;
 if(p) {
 Element.insert(p, {'bottom': advice});
 } else {
 Element.insert(elm, {'after': advice});
 }
 break;
 default:
 Element.insert(elm, {'after': advice});
 }
 }
 },
 showAdvice : function(elm, advice, adviceName){
 if(!elm.advices){
 elm.advices = new Hash();
 }
 else{
 elm.advices.each(function(pair){
 this.hideAdvice(elm, pair.value);
 }.bind(this));
 }
 elm.advices.set(adviceName, advice);
 if(typeof Effect == 'undefined') {
 advice.style.display = 'block';
 } else {
 if(!advice._adviceAbsolutize) {
 new Effect.Appear(advice, {duration : 1 });
 } else {
 Position.absolutize(advice);
 advice.show();
 advice.setStyle({
 'top':advice._adviceTop,
 'left': advice._adviceLeft,
 'width': advice._adviceWidth,
 'z-index': 1000
 });
 advice.addClassName('advice-absolute');
 }
 }
 },
 hideAdvice : function(elm, advice){
 if(advice != null) advice.hide();
 },
 updateCallback : function(elm, status) {
 if (typeof elm.callbackFunction != 'undefined') {
 eval(elm.callbackFunction+'(\''+elm.id+'\',\''+status+'\')');
 }
 },
 ajaxError : function(elm, errorMsg) {
 var name = 'validate-ajax';
 var advice = Validation.getAdvice(name, elm);
 if (advice == null) {
 advice = this.createAdvice(name, elm, false, errorMsg);
 }
 this.showAdvice(elm, advice, 'validate-ajax');
 this.updateCallback(elm, 'failed');

 elm.addClassName('validation-failed');
 elm.addClassName('validate-ajax');
 if (Validation.defaultOptions.addClassNameToContainer && Validation.defaultOptions.containerClassName != '') {
 var container = elm.up(Validation.defaultOptions.containerClassName);
 if (container && this.allowContainerClassName(elm)) {
 container.removeClassName('validation-passed');
 container.addClassName('validation-error');
 }
 }
 },
 allowContainerClassName: function (elm) {
 if (elm.type == 'radio' || elm.type == 'checkbox') {
 return elm.hasClassName('change-container-classname');
 }
 
 return true;
 },
 test : function(name, elm, useTitle) {
 var v = Validation.get(name);
 var prop = '__advice'+name.camelize();
 try {
 if(Validation.isVisible(elm) && !v.test($F(elm), elm)) {
 //if(!elm[prop]) {
 var advice = Validation.getAdvice(name, elm);
 if (advice == null) {
 advice = this.createAdvice(name, elm, useTitle);
 }
 this.showAdvice(elm, advice, name);
 this.updateCallback(elm, 'failed');
 //}
 elm[prop] = 1;
 if (!elm.advaiceContainer) {
 elm.removeClassName('validation-passed');
 elm.addClassName('validation-failed');
 } 
 
 if (Validation.defaultOptions.addClassNameToContainer && Validation.defaultOptions.containerClassName != '') {
 var container = elm.up(Validation.defaultOptions.containerClassName);
 if (container && this.allowContainerClassName(elm)) {
 container.removeClassName('validation-passed');
 container.addClassName('validation-error');
 }
 }
 return false;
 } else {
 var advice = Validation.getAdvice(name, elm);
 this.hideAdvice(elm, advice);
 this.updateCallback(elm, 'passed');
 elm[prop] = '';
 elm.removeClassName('validation-failed');
 elm.addClassName('validation-passed');
 if (Validation.defaultOptions.addClassNameToContainer && Validation.defaultOptions.containerClassName != '') {
 var container = elm.up(Validation.defaultOptions.containerClassName);
 if (container && !container.down('.validation-failed') && this.allowContainerClassName(elm)) {
 if (!Validation.get('IsEmpty').test(elm.value) || !this.isVisible(elm)) { 
 container.addClassName('validation-passed');
 } else {
 container.removeClassName('validation-passed');
 }
 container.removeClassName('validation-error');
 }
 }
 return true;
 }
 } catch(e) {
 throw(e)
 }
 },
 isVisible : function(elm) {
 while(elm.tagName != 'BODY') {
 if(!$(elm).visible()) return false;
 elm = elm.parentNode;
 }
 return true;
 },
 getAdvice : function(name, elm) {
 return $('advice-' + name + '-' + Validation.getElmID(elm)) || $('advice-' + Validation.getElmID(elm));
 },
 createAdvice : function(name, elm, useTitle, customError) {
 var v = Validation.get(name);
 var errorMsg = useTitle ? ((elm && elm.title) ? elm.title : v.error) : v.error;
 if (customError) {
 errorMsg = customError;
 }
 try {
 if (Translator){
 errorMsg = Translator.translate(errorMsg);
 }
 }
 catch(e){}

 advice = '<div class="validation-advice" id="advice-' + name + '-' + Validation.getElmID(elm) +'" style="display:none">' + errorMsg + '</div>'


 Validation.insertAdvice(elm, advice);
 advice = Validation.getAdvice(name, elm);
 if($(elm).hasClassName('absolute-advice')) {
 var dimensions = $(elm).getDimensions();
 var originalPosition = Position.cumulativeOffset(elm);

 advice._adviceTop = (originalPosition[1] + dimensions.height) + 'px';
 advice._adviceLeft = (originalPosition[0]) + 'px';
 advice._adviceWidth = (dimensions.width) + 'px';
 advice._adviceAbsolutize = true;
 }
 return advice;
 },
 getElmID : function(elm) {
 return elm.id ? elm.id : elm.name;
 },
 reset : function(elm) {
 elm = $(elm);
 var cn = $w(elm.className);
 cn.each(function(value) {
 var prop = '__advice'+value.camelize();
 if(elm[prop]) {
 var advice = Validation.getAdvice(value, elm);
 if (advice) {
 advice.hide();
 }
 elm[prop] = '';
 }
 elm.removeClassName('validation-failed');
 elm.removeClassName('validation-passed');
 if (Validation.defaultOptions.addClassNameToContainer && Validation.defaultOptions.containerClassName != '') {
 var container = elm.up(Validation.defaultOptions.containerClassName);
 if (container) {
 container.removeClassName('validation-passed');
 container.removeClassName('validation-error');
 }
 }
 });
 },
 add : function(className, error, test, options) {
 var nv = {};
 nv[className] = new Validator(className, error, test, options);
 Object.extend(Validation.methods, nv);
 },
 addAllThese : function(validators) {
 var nv = {};
 $A(validators).each(function(value) {
 nv[value[0]] = new Validator(value[0], value[1], value[2], (value.length > 3 ? value[3] : {}));
 });
 Object.extend(Validation.methods, nv);
 },
 get : function(name) {
 return Validation.methods[name] ? Validation.methods[name] : Validation.methods['_LikeNoIDIEverSaw_'];
 },
 methods : {
 '_LikeNoIDIEverSaw_' : new Validator('_LikeNoIDIEverSaw_','',{})
 }
});

Validation.add('IsEmpty', '', function(v) {
 return (v == '' || (v == null) || (v.length == 0) || /^\s+$/.test(v)); // || /^\s+$/.test(v));
});

Validation.addAllThese([
 ['validate-select', 'Please select an option.', function(v) {
 return ((v != "none") && (v != null) && (v.length != 0));
 }],
 ['required-entry', 'This is a required field.', function(v) {
 return !Validation.get('IsEmpty').test(v);
 }],
 ['validate-number', 'Please enter a valid number in this field.', function(v) {
 return Validation.get('IsEmpty').test(v) || (!isNaN(parseNumber(v)) && !/^\s+$/.test(parseNumber(v)));
 }],
 ['validate-digits', 'Please use numbers only in this field. please avoid spaces or other characters such as dots or commas.', function(v) {
 return Validation.get('IsEmpty').test(v) || !/[^\d]/.test(v);
 }],
 ['validate-alpha', 'Please use letters only (a-z or A-Z) in this field.', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[a-zA-Z]+$/.test(v)
 }],
 ['validate-code', 'Please use only letters (a-z), numbers (0-9) or underscore(_) in this field, first character should be a letter.', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[a-z]+[a-z0-9_]+$/.test(v)
 }],
 ['validate-alphanum', 'Please use only letters (a-z or A-Z) or numbers (0-9) only in this field. No spaces or other characters are allowed.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^[a-zA-Z0-9]+$/.test(v) /*!/\W/.test(v)*/
 }],
 ['validate-street', 'Please use only letters (a-z or A-Z) or numbers (0-9) or spaces and # only in this field.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^[ \w]{3,}([A-Za-z]\.)?([ \w]*\#\d+)?(\r\n| )[ \w]{3,}/.test(v)
 }],
 ['validate-phoneStrict', 'Please enter a valid phone number. For example (123) 456-7890 or 123-456-7890.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^(\()?\d{3}(\))?(-|\s)?\d{3}(-|\s)\d{4}$/.test(v);
 }],
 ['validate-phoneLax', 'Please enter a valid phone number. For example (123) 456-7890 or 123-456-7890.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^((\d[-. ]?)?((\(\d{3}\))|\d{3}))?[-. ]?\d{3}[-. ]?\d{4}$/.test(v);
 }],
 ['validate-fax', 'Please enter a valid fax number. For example (123) 456-7890 or 123-456-7890.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^(\()?\d{3}(\))?(-|\s)?\d{3}(-|\s)\d{4}$/.test(v);
 }],
 ['validate-date', 'Please enter a valid date.', function(v) {
 var test = new Date(v);
 return Validation.get('IsEmpty').test(v) || !isNaN(test);
 }],
 ['validate-email', 'Please enter a valid email address. For example johndoe@domain.com.', function (v) {
 //return Validation.get('IsEmpty').test(v) || /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,3}$/.test(v)
 //return Validation.get('IsEmpty').test(v) || /^[\!\#$%\*/?|\^\{\}`~&\'\+\-=_a-z0-9][\!\#$%\*/?|\^\{\}`~&\'\+\-=_a-z0-9\.]{1,30}[\!\#$%\*/?|\^\{\}`~&\'\+\-=_a-z0-9]@([a-z0-9_-]{1,30}\.){1,5}[a-z]{2,4}$/i.test(v)
 return Validation.get('IsEmpty').test(v) || /^[a-z0-9,!\#\$%&'\*\+/=\?\^_`\{\|}~-]+(\.[a-z0-9,!#\$%&'\*\+/=\?\^_`\{\|}~-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*\.([a-z]{2,})/i.test(v)
 }],
 ['validate-emailSender', 'Please use only letters (a-z or A-Z), numbers (0-9) , underscore(_) or spaces in this field.', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[a-zA-Z0-9_\s]+$/.test(v)
 }],
 ['validate-password', 'Please enter 6 or more characters. Leading or trailing spaces will be ignored.', function(v) {
 var pass=v.strip(); /*strip leading and trailing spaces*/
 return !(pass.length>0 && pass.length < 6);
 }],
 ['validate-admin-password', 'Please enter 7 or more characters. Password should contain both numeric and alphabetic characters.', function(v) {
 var pass=v.strip();
 if (0 == pass.length) {
 return true;
 }
 if (!(/[a-z]/i.test(v)) || !(/[0-9]/.test(v))) {
 return false;
 }
 return !(pass.length < 7);
 }],
 ['validate-cpassword', 'Please make sure your passwords match.', function(v) {
 if ($('password')) {
 var pass = $('password');
 }
 else {
 var pass = $$('.validate-password').length ? $$('.validate-password')[0] : $$('.validate-admin-password')[0];
 }
 var conf = $('confirmation') ? $('confirmation') : $$('.validate-cpassword')[0];
 return (pass.value == conf.value);
 }],
 ['validate-url', 'Please enter a valid URL. http:// is required', function (v) {
 return Validation.get('IsEmpty').test(v) || /^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+)(:(\d+))?\/?/i.test(v)
 }],
 ['validate-clean-url', 'Please enter a valid URL. For example http://www.example.com or www.example.com', function (v) {
 return Validation.get('IsEmpty').test(v) || /^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+.(com|org|net|dk|at|us|tv|info|uk|co.uk|biz|se)$)(:(\d+))?\/?/i.test(v) || /^(www)((\.[A-Z0-9][A-Z0-9_-]*)+.(com|org|net|dk|at|us|tv|info|uk|co.uk|biz|se)$)(:(\d+))?\/?/i.test(v)
 }],
 ['validate-identifier', 'Please enter a valid Identifier. For example example-page, example-page.html or anotherlevel/example-page', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[A-Z0-9][A-Z0-9_\/-]+(\.[A-Z0-9_-]+)*$/i.test(v)
 }],
 ['validate-xml-identifier', 'Please enter a valid XML-identifier. For example something_1, block5, id-4', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[A-Z][A-Z0-9_\/-]*$/i.test(v)
 }],
 ['validate-ssn', 'Please enter a valid social security number. For example 123-45-6789.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^\d{3}-?\d{2}-?\d{4}$/.test(v);
 }],
 ['validate-zip', 'Please enter a valid zip code. For example 90602 or 90602-1234.', function(v) {
 return Validation.get('IsEmpty').test(v) || /(^\d{5}$)|(^\d{5}-\d{4}$)/.test(v);
 }],
 ['validate-zip-international', 'Please enter a valid zip code.', function(v) {
 //return Validation.get('IsEmpty').test(v) || /(^[A-z0-9]{2,10}([\s]{0,1}|[\-]{0,1})[A-z0-9]{2,10}$)/.test(v);
 return true;
 }],
 ['validate-date-au', 'Please use this date format: dd/mm/yyyy. For example 17/03/2006 for the 17th of March, 2006.', function(v) {
 if(Validation.get('IsEmpty').test(v)) return true;
 var regex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
 if(!regex.test(v)) return false;
 var d = new Date(v.replace(regex, '$2/$1/$3'));
 return ( parseInt(RegExp.$2, 10) == (1+d.getMonth()) ) &&
 (parseInt(RegExp.$1, 10) == d.getDate()) &&
 (parseInt(RegExp.$3, 10) == d.getFullYear() );
 }],
 ['validate-currency-dollar', 'Please enter a valid $ amount. For example $100.00.', function(v) {
 // [$]1[##][,###]+[.##]
 // [$]1###+[.##]
 // [$]0.##
 // [$].##
 return Validation.get('IsEmpty').test(v) || /^\$?\-?([1-9]{1}[0-9]{0,2}(\,[0-9]{3})*(\.[0-9]{0,2})?|[1-9]{1}\d*(\.[0-9]{0,2})?|0(\.[0-9]{0,2})?|(\.[0-9]{1,2})?)$/.test(v)
 }],
 ['validate-one-required', 'Please select one of the above options.', function (v,elm) {
 var p = elm.parentNode;
 var options = p.getElementsByTagName('INPUT');
 return $A(options).any(function(elm) {
 return $F(elm);
 });
 }],
 ['validate-one-required-by-name', 'Please select one of the options.', function (v,elm) {
 var inputs = $$('input[name="' + elm.name.replace(/([\\"])/g, '\\$1') + '"]');
 
 var error = 1;
 for(var i=0;i<inputs.length;i++) {
 if((inputs[i].type == 'checkbox' || inputs[i].type == 'radio') && inputs[i].checked == true) {
 error = 0;
 }
 
 if(Validation.isOnChange && (inputs[i].type == 'checkbox' || inputs[i].type == 'radio')) {
 Validation.reset(inputs[i]);
 }
 }

 if( error == 0 ) {
 return true;
 } else {
 return false;
 }
 }],
 ['validate-not-negative-number', 'Please enter a valid number in this field.', function(v) {
 v = parseNumber(v);
 return (!isNaN(v) && v>=0);
 }],
 ['validate-state', 'Please select State/Province.', function(v) {
 return (v!=0 || v == '');
 }],

 ['validate-new-password', 'Please enter 6 or more characters. Leading or trailing spaces will be ignored.', function(v) {
 if (!Validation.get('validate-password').test(v)) return false;
 if (Validation.get('IsEmpty').test(v) && v != '') return false;
 return true;
 }],
 ['validate-greater-than-zero', 'Please enter a number greater than 0 in this field.', function(v) {
 if(v.length)
 return parseFloat(v) > 0;
 else
 return true;
 }],
 ['validate-zero-or-greater', 'Please enter a number 0 or greater in this field.', function(v) {
 if(v.length)
 return parseFloat(v) >= 0;
 else
 return true;
 }],
 ['validate-cc-number', 'Please enter a valid credit card number.', function(v, elm) {
 // remove non-numerics
 var ccTypeContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_number')) + '_cc_type');
 if (ccTypeContainer && typeof Validation.creditCartTypes.get(ccTypeContainer.value) != 'undefined'
 && Validation.creditCartTypes.get(ccTypeContainer.value)[2] == false) {
 if (!Validation.get('IsEmpty').test(v) && Validation.get('validate-digits').test(v)) {
 return true;
 } else {
 return false;
 }
 }
 return validateCreditCard(v);
 }],
 ['validate-cc-type', 'Credit card number doesn\'t match credit card type', function(v, elm) {
 // remove credit card number delimiters such as "-" and space
 elm.value = removeDelimiters(elm.value);
 v = removeDelimiters(v);

 var ccTypeContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_number')) + '_cc_type');
 if (!ccTypeContainer) {
 return true;
 }
 var ccType = ccTypeContainer.value;

 if (typeof Validation.creditCartTypes.get(ccType) == 'undefined') {
 return false;
 }

 // Other card type or switch or solo card
 if (Validation.creditCartTypes.get(ccType)[0]==false) {
 return true;
 }

 // Matched credit card type
 var ccMatchedType = '';

 Validation.creditCartTypes.each(function (pair) {
 if (pair.value[0] && v.match(pair.value[0])) {
 ccMatchedType = pair.key;
 throw $break;
 }
 });

 if(ccMatchedType != ccType) {
 return false;
 }
 
 if (ccTypeContainer.hasClassName('validation-failed') && Validation.isOnChange) {
 Validation.validate(ccTypeContainer);
 }

 return true;
 }],
 ['validate-cc-type-select', 'Card type doesn\'t match credit card number', function(v, elm) {
 var ccNumberContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_type')) + '_cc_number');
 if (Validation.isOnChange && Validation.get('IsEmpty').test(ccNumberContainer.value)) {
 return true;
 }
 if (Validation.get('validate-cc-type').test(ccNumberContainer.value, ccNumberContainer)) {
 Validation.validate(ccNumberContainer);
 }
 return Validation.get('validate-cc-type').test(ccNumberContainer.value, ccNumberContainer);
 }],
 ['validate-cc-exp', 'Incorrect credit card expiration date', function(v, elm) {
 var ccExpMonth = v;
 var ccExpYear = $('ccsave_expiration_yr').value;
 var currentTime = new Date();
 var currentMonth = currentTime.getMonth() + 1;
 var currentYear = currentTime.getFullYear();
 if (ccExpMonth < currentMonth && ccExpYear == currentYear) {
 return false;
 }
 return true;
 }],
 ['validate-cc-cvn', 'Please enter a valid credit card verification number.', function(v, elm) {
 var ccTypeContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_cid')) + '_cc_type');
 if (!ccTypeContainer) {
 return true;
 }
 var ccType = ccTypeContainer.value;

 if (typeof Validation.creditCartTypes.get(ccType) == 'undefined') {
 return false;
 }

 var re = Validation.creditCartTypes.get(ccType)[1];

 if (v.match(re)) {
 return true;
 }

 return false;
 }],
 ['validate-ajax', '', function(v, elm) { return true; }],
 ['validate-data', 'Please use only letters (a-z or A-Z), numbers (0-9) or underscore(_) in this field, first character should be a letter.', function (v) {
 if(v != '' && v) {
 return /^[A-Za-z]+[A-Za-z0-9_]+$/.test(v);
 }
 return true;
 }],
 ['validate-css-length', 'Please input a valid CSS-length. For example 100px or 77pt or 20em or .5ex or 50%', function (v) {
 if (v != '' && v) {
 return /^[0-9\.]+(px|pt|em|ex|%)?$/.test(v) && (!(/\..*\./.test(v))) && !(/\.$/.test(v));
 }
 return true;
 }],
 ['validate-length', 'Maximum length exceeded.', function (v, elm) {
 var re = new RegExp(/^maximum-length-[0-9]+$/);
 var result = true;
 $w(elm.className).each(function(name, index) {
 if (name.match(re) && result) {
 var length = name.split('-')[2];
 result = (v.length <= length);
 }
 });
 return result;
 }]
]);


// Credit Card Validation Javascript
// copyright 12th May 2003, by Stephen Chapman, Felgall Pty Ltd

// You have permission to copy and use this javascript provided that
// the content of the script is not changed in any way.

function validateCreditCard(s) {
 // remove non-numerics
 var v = "0123456789";
 var w = "";
 for (i=0; i < s.length; i++) {
 x = s.charAt(i);
 if (v.indexOf(x,0) != -1)
 w += x;
 }
 // validate number
 j = w.length / 2;
 k = Math.floor(j);
 m = Math.ceil(j) - k;
 c = 0;
 for (i=0; i<k; i++) {
 a = w.charAt(i*2+m) * 2;
 c += a > 9 ? Math.floor(a/10 + a%10) : a;
 }
 for (i=0; i<k+m; i++) c += w.charAt(i*2+1-m) * 1;
 return (c%10 == 0);
}

function removeDelimiters (v) {
 v = v.replace(/\s/g, '');
 v = v.replace(/\-/g, '');
 return v;
}

function parseNumber(v)
{
 if (typeof v != 'string') {
 return parseFloat(v);
 }

 var isDot = v.indexOf('.');
 var isComa = v.indexOf(',');

 if (isDot != -1 && isComa != -1) {
 if (isComa > isDot) {
 v = v.replace('.', '').replace(',', '.');
 }
 else {
 v = v.replace(',', '');
 }
 }
 else if (isComa != -1) {
 v = v.replace(',', '.');
 }

 return parseFloat(v);
}

/**
 * Hash with credit card types wich can be simply extended in payment modules
 * 0 - regexp for card number
 * 1 - regexp for cvn
 * 2 - check or not credit card number trough Luhn algorithm by
 * function validateCreditCard wich you can find above in this file
 */
Validation.creditCartTypes = $H({
 'VI': [new RegExp('^4[0-9]{12}([0-9]{3})?$'), new RegExp('^[0-9]{3}$'), true],
 'MC': [new RegExp('^5[1-5][0-9]{14}$'), new RegExp('^[0-9]{3}$'), true],
 'AE': [new RegExp('^3[47][0-9]{13}$'), new RegExp('^[0-9]{4}$'), true],
 'DI': [new RegExp('^6011[0-9]{12}$'), new RegExp('^[0-9]{3}$'), true],
 'SS': [new RegExp('^((6759[0-9]{12})|(49[013][1356][0-9]{13})|(633[34][0-9]{12})|(633110[0-9]{10})|(564182[0-9]{10}))([0-9]{2,3})?$'), new RegExp('^([0-9]{3}|[0-9]{4})?$'), true],
 'OT': [false, new RegExp('^([0-9]{3}|[0-9]{4})?$'), false]
});

// script.aculo.us builder.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

var Builder = {
 NODEMAP: {
 AREA: 'map',
 CAPTION: 'table',
 COL: 'table',
 COLGROUP: 'table',
 LEGEND: 'fieldset',
 OPTGROUP: 'select',
 OPTION: 'select',
 PARAM: 'object',
 TBODY: 'table',
 TD: 'table',
 TFOOT: 'table',
 TH: 'table',
 THEAD: 'table',
 TR: 'table'
 },
 // note: For Firefox < 1.5, OPTION and OPTGROUP tags are currently broken,
 // due to a Firefox bug
 node: function(elementName) {
 elementName = elementName.toUpperCase();
 
 // try innerHTML approach
 var parentTag = this.NODEMAP[elementName] || 'div';
 var parentElement = document.createElement(parentTag);
 try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
 parentElement.innerHTML = "<" + elementName + "></" + elementName + ">";
 } catch(e) {}
 var element = parentElement.firstChild || null;
 
 // see if browser added wrapping tags
 if(element && (element.tagName.toUpperCase() != elementName))
 element = element.getElementsByTagName(elementName)[0];
 
 // fallback to createElement approach
 if(!element) element = document.createElement(elementName);
 
 // abort if nothing could be created
 if(!element) return;

 // attributes (or text)
 if(arguments[1])
 if(this._isStringOrNumber(arguments[1]) ||
 (arguments[1] instanceof Array) ||
 arguments[1].tagName) {
 this._children(element, arguments[1]);
 } else {
 var attrs = this._attributes(arguments[1]);
 if(attrs.length) {
 try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
 parentElement.innerHTML = "<" +elementName + " " +
 attrs + "></" + elementName + ">";
 } catch(e) {}
 element = parentElement.firstChild || null;
 // workaround firefox 1.0.X bug
 if(!element) {
 element = document.createElement(elementName);
 for(attr in arguments[1]) 
 element[attr == 'class' ? 'className' : attr] = arguments[1][attr];
 }
 if(element.tagName.toUpperCase() != elementName)
 element = parentElement.getElementsByTagName(elementName)[0];
 }
 } 

 // text, or array of children
 if(arguments[2])
 this._children(element, arguments[2]);

 return element;
 },
 _text: function(text) {
 return document.createTextNode(text);
 },

 ATTR_MAP: {
 'className': 'class',
 'htmlFor': 'for'
 },

 _attributes: function(attributes) {
 var attrs = [];
 for(attribute in attributes)
 attrs.push((attribute in this.ATTR_MAP ? this.ATTR_MAP[attribute] : attribute) +
 '="' + attributes[attribute].toString().escapeHTML().gsub(/"/,'&quot;') + '"');
 return attrs.join(" ");
 },
 _children: function(element, children) {
 if(children.tagName) {
 element.appendChild(children);
 return;
 }
 if(typeof children=='object') { // array can hold nodes and text
 children.flatten().each( function(e) {
 if(typeof e=='object')
 element.appendChild(e)
 else
 if(Builder._isStringOrNumber(e))
 element.appendChild(Builder._text(e));
 });
 } else
 if(Builder._isStringOrNumber(children))
 element.appendChild(Builder._text(children));
 },
 _isStringOrNumber: function(param) {
 return(typeof param=='string' || typeof param=='number');
 },
 build: function(html) {
 var element = this.node('div');
 $(element).update(html.strip());
 return element.down();
 },
 dump: function(scope) { 
 if(typeof scope != 'object' && typeof scope != 'function') scope = window; //global scope 
 
 var tags = ("A ABBR ACRONYM ADDRESS APPLET AREA B BASE BASEFONT BDO BIG BLOCKQUOTE BODY " +
 "BR BUTTON CAPTION CENTER CITE CODE COL COLGROUP DD DEL DFN DIR DIV DL DT EM FIELDSET " +
 "FONT FORM FRAME FRAMESET H1 H2 H3 H4 H5 H6 HEAD HR HTML I IFRAME IMG INPUT INS ISINDEX "+
 "KBD LABEL LEGEND LI LINK MAP MENU META NOFRAMES NOSCRIPT OBJECT OL OPTGROUP OPTION P "+
 "PARAM PRE Q S SAMP SCRIPT SELECT SMALL SPAN STRIKE STRONG STYLE SUB SUP TABLE TBODY TD "+
 "TEXTAREA TFOOT TH THEAD TITLE TR TT U UL VAR").split(/\s+/);
 
 tags.each( function(tag){ 
 scope[tag] = function() { 
 return Builder.node.apply(Builder, [tag].concat($A(arguments))); 
 } 
 });
 }
}

String.prototype.parseColor=function(){var color="#";if(this.slice(0,4)=="rgb("){var cols=this.slice(4,this.length-1).split(",");var i=0;do{color+=parseInt(cols[i]).toColorPart();}while(++i<3);}else{if(this.slice(0,1)=="#"){if(this.length==4){for(var i=1;i<4;i++){color+=(this.charAt(i)+this.charAt(i)).toLowerCase();}}if(this.length==7){color=this.toLowerCase();}}}return(color.length==7?color:(arguments[0]||this));};Element.collectTextNodes=function(element){return $A($(element).childNodes).collect(function(node){return(node.nodeType==3?node.nodeValue:(node.hasChildNodes()?Element.collectTextNodes(node):""));}).flatten().join("");};Element.collectTextNodesIgnoreClass=function(element,className){return $A($(element).childNodes).collect(function(node){return(node.nodeType==3?node.nodeValue:((node.hasChildNodes()&&!Element.hasClassName(node,className))?Element.collectTextNodesIgnoreClass(node,className):""));}).flatten().join("");};Element.setContentZoom=function(element,percent){element=$(element);element.setStyle({fontSize:(percent/100)+"em"});if(Prototype.Browser.WebKit){window.scrollBy(0,0);}return element;};Element.getInlineOpacity=function(element){return $(element).style.opacity||"";};Element.forceRerendering=function(element){try{element=$(element);var n=document.createTextNode(" ");element.appendChild(n);element.removeChild(n);}catch(e){}};var Effect={_elementDoesNotExistError:{name:"ElementDoesNotExistError",message:"The specified DOM element does not exist, but is required for this effect to operate"},Transitions:{linear:Prototype.K,sinoidal:function(pos){return(-Math.cos(pos*Math.PI)/2)+0.5;},reverse:function(pos){return 1-pos;},flicker:function(pos){var pos=((-Math.cos(pos*Math.PI)/4)+0.75)+Math.random()/4;return pos>1?1:pos;},wobble:function(pos){return(-Math.cos(pos*Math.PI*(9*pos))/2)+0.5;},pulse:function(pos,pulses){return(-Math.cos((pos*((pulses||5)-0.5)*2)*Math.PI)/2)+0.5;},spring:function(pos){return 1-(Math.cos(pos*4.5*Math.PI)*Math.exp(-pos*6));},none:function(pos){return 0;},full:function(pos){return 1;}},DefaultOptions:{duration:1,fps:100,sync:false,from:0,to:1,delay:0,queue:"parallel"},tagifyText:function(element){var tagifyStyle="position:relative";if(Prototype.Browser.IE){tagifyStyle+=";zoom:1";}element=$(element);$A(element.childNodes).each(function(child){if(child.nodeType==3){child.nodeValue.toArray().each(function(character){element.insertBefore(new Element("span",{style:tagifyStyle}).update(character==" "?String.fromCharCode(160):character),child);});Element.remove(child);}});},multiple:function(element,effect){var elements;if(((typeof element=="object")||Object.isFunction(element))&&(element.length)){elements=element;}else{elements=$(element).childNodes;}var options=Object.extend({speed:0.1,delay:0},arguments[2]||{});var masterDelay=options.delay;$A(elements).each(function(element,index){new effect(element,Object.extend(options,{delay:index*options.speed+masterDelay}));});},PAIRS:{slide:["SlideDown","SlideUp"],blind:["BlindDown","BlindUp"],appear:["Appear","Fade"]},toggle:function(element,effect){element=$(element);effect=(effect||"appear").toLowerCase();var options=Object.extend({queue:{position:"end",scope:(element.id||"global"),limit:1}},arguments[2]||{});Effect[element.visible()?Effect.PAIRS[effect][1]:Effect.PAIRS[effect][0]](element,options);}};Effect.DefaultOptions.transition=Effect.Transitions.sinoidal;Effect.ScopedQueue=Class.create(Enumerable,{initialize:function(){this.effects=[];this.interval=null;},_each:function(iterator){this.effects._each(iterator);},add:function(effect){var timestamp=new Date().getTime();var position=Object.isString(effect.options.queue)?effect.options.queue:effect.options.queue.position;switch(position){case"front":this.effects.findAll(function(e){return e.state=="idle";}).each(function(e){e.startOn+=effect.finishOn;e.finishOn+=effect.finishOn;});break;case"with-last":timestamp=this.effects.pluck("startOn").max()||timestamp;break;case"end":timestamp=this.effects.pluck("finishOn").max()||timestamp;break;}effect.startOn+=timestamp;effect.finishOn+=timestamp;if(!effect.options.queue.limit||(this.effects.length<effect.options.queue.limit)){this.effects.push(effect);}if(!this.interval){this.interval=setInterval(this.loop.bind(this),15);}},remove:function(effect){this.effects=this.effects.reject(function(e){return e==effect;});if(this.effects.length==0){clearInterval(this.interval);this.interval=null;}},loop:function(){var timePos=new Date().getTime();for(var i=0,len=this.effects.length;i<len;i++){this.effects[i]&&this.effects[i].loop(timePos);}}});Effect.Queues={instances:$H(),get:function(queueName){if(!Object.isString(queueName)){return queueName;}return this.instances.get(queueName)||this.instances.set(queueName,new Effect.ScopedQueue());}};Effect.Queue=Effect.Queues.get("global");Effect.Base=Class.create({position:null,start:function(options){function codeForEvent(options,eventName){return((options[eventName+"Internal"]?"this.options."+eventName+"Internal(this);":"")+(options[eventName]?"this.options."+eventName+"(this);":""));}if(options&&options.transition===false){options.transition=Effect.Transitions.linear;}this.options=Object.extend(Object.extend({},Effect.DefaultOptions),options||{});this.currentFrame=0;this.state="idle";this.startOn=this.options.delay*1000;this.finishOn=this.startOn+(this.options.duration*1000);this.fromToDelta=this.options.to-this.options.from;this.totalTime=this.finishOn-this.startOn;this.totalFrames=this.options.fps*this.options.duration;this.render=(function(){function dispatch(effect,eventName){if(effect.options[eventName+"Internal"]){effect.options[eventName+"Internal"](effect);}if(effect.options[eventName]){effect.options[eventName](effect);}}return function(pos){if(this.state==="idle"){this.state="running";dispatch(this,"beforeSetup");if(this.setup){this.setup();}dispatch(this,"afterSetup");}if(this.state==="running"){pos=(this.options.transition(pos)*this.fromToDelta)+this.options.from;this.position=pos;dispatch(this,"beforeUpdate");if(this.update){this.update(pos);}dispatch(this,"afterUpdate");}};})();this.event("beforeStart");if(!this.options.sync){Effect.Queues.get(Object.isString(this.options.queue)?"global":this.options.queue.scope).add(this);}},loop:function(timePos){if(timePos>=this.startOn){if(timePos>=this.finishOn){this.render(1);this.cancel();this.event("beforeFinish");if(this.finish){this.finish();}this.event("afterFinish");return;}var pos=(timePos-this.startOn)/this.totalTime,frame=(pos*this.totalFrames).round();if(frame>this.currentFrame){this.render(pos);this.currentFrame=frame;}}},cancel:function(){if(!this.options.sync){Effect.Queues.get(Object.isString(this.options.queue)?"global":this.options.queue.scope).remove(this);}this.state="finished";},event:function(eventName){if(this.options[eventName+"Internal"]){this.options[eventName+"Internal"](this);}if(this.options[eventName]){this.options[eventName](this);}},inspect:function(){var data=$H();for(property in this){if(!Object.isFunction(this[property])){data.set(property,this[property]);}}return"#<Effect:"+data.inspect()+",options:"+$H(this.options).inspect()+">";}});Effect.Parallel=Class.create(Effect.Base,{initialize:function(effects){this.effects=effects||[];this.start(arguments[1]);},update:function(position){this.effects.invoke("render",position);},finish:function(position){this.effects.each(function(effect){effect.render(1);effect.cancel();effect.event("beforeFinish");if(effect.finish){effect.finish(position);}effect.event("afterFinish");});}});Effect.Tween=Class.create(Effect.Base,{initialize:function(object,from,to){object=Object.isString(object)?$(object):object;var args=$A(arguments),method=args.last(),options=args.length==5?args[3]:null;this.method=Object.isFunction(method)?method.bind(object):Object.isFunction(object[method])?object[method].bind(object):function(value){object[method]=value;};this.start(Object.extend({from:from,to:to},options||{}));},update:function(position){this.method(position);}});Effect.Event=Class.create(Effect.Base,{initialize:function(){this.start(Object.extend({duration:0},arguments[0]||{}));},update:Prototype.emptyFunction});Effect.Opacity=Class.create(Effect.Base,{initialize:function(element){this.element=$(element);if(!this.element){throw (Effect._elementDoesNotExistError);}if(Prototype.Browser.IE&&(!this.element.currentStyle.hasLayout)){this.element.setStyle({zoom:1});}var options=Object.extend({from:this.element.getOpacity()||0,to:1},arguments[1]||{});this.start(options);},update:function(position){this.element.setOpacity(position);}});Effect.Move=Class.create(Effect.Base,{initialize:function(element){this.element=$(element);if(!this.element){throw (Effect._elementDoesNotExistError);}var options=Object.extend({x:0,y:0,mode:"relative"},arguments[1]||{});this.start(options);},setup:function(){this.element.makePositioned();this.originalLeft=parseFloat(this.element.getStyle("left")||"0");this.originalTop=parseFloat(this.element.getStyle("top")||"0");if(this.options.mode=="absolute"){this.options.x=this.options.x-this.originalLeft;this.options.y=this.options.y-this.originalTop;}},update:function(position){this.element.setStyle({left:(this.options.x*position+this.originalLeft).round()+"px",top:(this.options.y*position+this.originalTop).round()+"px"});}});Effect.MoveBy=function(element,toTop,toLeft){return new Effect.Move(element,Object.extend({x:toLeft,y:toTop},arguments[3]||{}));};Effect.Scale=Class.create(Effect.Base,{initialize:function(element,percent){this.element=$(element);if(!this.element){throw (Effect._elementDoesNotExistError);}var options=Object.extend({scaleX:true,scaleY:true,scaleContent:true,scaleFromCenter:false,scaleMode:"box",scaleFrom:100,scaleTo:percent},arguments[2]||{});this.start(options);},setup:function(){this.restoreAfterFinish=this.options.restoreAfterFinish||false;this.elementPositioning=this.element.getStyle("position");this.originalStyle={};["top","left","width","height","fontSize"].each(function(k){this.originalStyle[k]=this.element.style[k];}.bind(this));this.originalTop=this.element.offsetTop;this.originalLeft=this.element.offsetLeft;var fontSize=this.element.getStyle("font-size")||"100%";["em","px","%","pt"].each(function(fontSizeType){if(fontSize.indexOf(fontSizeType)>0){this.fontSize=parseFloat(fontSize);this.fontSizeType=fontSizeType;}}.bind(this));this.factor=(this.options.scaleTo-this.options.scaleFrom)/100;this.dims=null;if(this.options.scaleMode=="box"){this.dims=[this.element.offsetHeight,this.element.offsetWidth];}if(/^content/.test(this.options.scaleMode)){this.dims=[this.element.scrollHeight,this.element.scrollWidth];}if(!this.dims){this.dims=[this.options.scaleMode.originalHeight,this.options.scaleMode.originalWidth];}},update:function(position){var currentScale=(this.options.scaleFrom/100)+(this.factor*position);if(this.options.scaleContent&&this.fontSize){this.element.setStyle({fontSize:this.fontSize*currentScale+this.fontSizeType});}this.setDimensions(this.dims[0]*currentScale,this.dims[1]*currentScale);},finish:function(position){if(this.restoreAfterFinish){this.element.setStyle(this.originalStyle);}},setDimensions:function(height,width){var d={};if(this.options.scaleX){d.width=width.round()+"px";}if(this.options.scaleY){d.height=height.round()+"px";}if(this.options.scaleFromCenter){var topd=(height-this.dims[0])/2;var leftd=(width-this.dims[1])/2;if(this.elementPositioning=="absolute"){if(this.options.scaleY){d.top=this.originalTop-topd+"px";}if(this.options.scaleX){d.left=this.originalLeft-leftd+"px";}}else{if(this.options.scaleY){d.top=-topd+"px";}if(this.options.scaleX){d.left=-leftd+"px";}}}this.element.setStyle(d);}});Effect.Highlight=Class.create(Effect.Base,{initialize:function(element){this.element=$(element);if(!this.element){throw (Effect._elementDoesNotExistError);}var options=Object.extend({startcolor:"#ffff99"},arguments[1]||{});this.start(options);},setup:function(){if(this.element.getStyle("display")=="none"){this.cancel();return;}this.oldStyle={};if(!this.options.keepBackgroundImage){this.oldStyle.backgroundImage=this.element.getStyle("background-image");this.element.setStyle({backgroundImage:"none"});}if(!this.options.endcolor){this.options.endcolor=this.element.getStyle("background-color").parseColor("#ffffff");}if(!this.options.restorecolor){this.options.restorecolor=this.element.getStyle("background-color");}this._base=$R(0,2).map(function(i){return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16);}.bind(this));this._delta=$R(0,2).map(function(i){return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i];}.bind(this));},update:function(position){this.element.setStyle({backgroundColor:$R(0,2).inject("#",function(m,v,i){return m+((this._base[i]+(this._delta[i]*position)).round().toColorPart());}.bind(this))});},finish:function(){this.element.setStyle(Object.extend(this.oldStyle,{backgroundColor:this.options.restorecolor}));}});Effect.ScrollTo=function(element){var options=arguments[1]||{},scrollOffsets=document.viewport.getScrollOffsets(),elementOffsets=$(element).cumulativeOffset();if(options.offset){elementOffsets[1]+=options.offset;}return new Effect.Tween(null,scrollOffsets.top,elementOffsets[1],options,function(p){scrollTo(scrollOffsets.left,p.round());});};Effect.Fade=function(element){element=$(element);var oldOpacity=element.getInlineOpacity();var options=Object.extend({from:element.getOpacity()||1,to:0,afterFinishInternal:function(effect){if(effect.options.to!=0){return;}effect.element.hide().setStyle({opacity:oldOpacity});}},arguments[1]||{});return new Effect.Opacity(element,options);};Effect.Appear=function(element){element=$(element);var options=Object.extend({from:(element.getStyle("display")=="none"?0:element.getOpacity()||0),to:1,afterFinishInternal:function(effect){effect.element.forceRerendering();},beforeSetup:function(effect){effect.element.setOpacity(effect.options.from).show();}},arguments[1]||{});return new Effect.Opacity(element,options);};Effect.Puff=function(element){element=$(element);var oldStyle={opacity:element.getInlineOpacity(),position:element.getStyle("position"),top:element.style.top,left:element.style.left,width:element.style.width,height:element.style.height};return new Effect.Parallel([new Effect.Scale(element,200,{sync:true,scaleFromCenter:true,scaleContent:true,restoreAfterFinish:true}),new Effect.Opacity(element,{sync:true,to:0})],Object.extend({duration:1,beforeSetupInternal:function(effect){Position.absolutize(effect.effects[0].element);},afterFinishInternal:function(effect){effect.effects[0].element.hide().setStyle(oldStyle);}},arguments[1]||{}));};Effect.BlindUp=function(element){element=$(element);element.makeClipping();return new Effect.Scale(element,0,Object.extend({scaleContent:false,scaleX:false,restoreAfterFinish:true,afterFinishInternal:function(effect){effect.element.hide().undoClipping();}},arguments[1]||{}));};Effect.BlindDown=function(element){element=$(element);var elementDimensions=element.getDimensions();return new Effect.Scale(element,100,Object.extend({scaleContent:false,scaleX:false,scaleFrom:0,scaleMode:{originalHeight:elementDimensions.height,originalWidth:elementDimensions.width},restoreAfterFinish:true,afterSetup:function(effect){effect.element.makeClipping().setStyle({height:"0px"}).show();},afterFinishInternal:function(effect){effect.element.undoClipping();}},arguments[1]||{}));};Effect.SwitchOff=function(element){element=$(element);var oldOpacity=element.getInlineOpacity();return new Effect.Appear(element,Object.extend({duration:0.4,from:0,transition:Effect.Transitions.flicker,afterFinishInternal:function(effect){new Effect.Scale(effect.element,1,{duration:0.3,scaleFromCenter:true,scaleX:false,scaleContent:false,restoreAfterFinish:true,beforeSetup:function(effect){effect.element.makePositioned().makeClipping();},afterFinishInternal:function(effect){effect.element.hide().undoClipping().undoPositioned().setStyle({opacity:oldOpacity});}});}},arguments[1]||{}));};Effect.DropOut=function(element){element=$(element);var oldStyle={top:element.getStyle("top"),left:element.getStyle("left"),opacity:element.getInlineOpacity()};return new Effect.Parallel([new Effect.Move(element,{x:0,y:100,sync:true}),new Effect.Opacity(element,{sync:true,to:0})],Object.extend({duration:0.5,beforeSetup:function(effect){effect.effects[0].element.makePositioned();},afterFinishInternal:function(effect){effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);}},arguments[1]||{}));};Effect.Shake=function(element){element=$(element);var options=Object.extend({distance:20,duration:0.5},arguments[1]||{});var distance=parseFloat(options.distance);var split=parseFloat(options.duration)/10;var oldStyle={top:element.getStyle("top"),left:element.getStyle("left")};return new Effect.Move(element,{x:distance,y:0,duration:split,afterFinishInternal:function(effect){new Effect.Move(effect.element,{x:-distance*2,y:0,duration:split*2,afterFinishInternal:function(effect){new Effect.Move(effect.element,{x:distance*2,y:0,duration:split*2,afterFinishInternal:function(effect){new Effect.Move(effect.element,{x:-distance*2,y:0,duration:split*2,afterFinishInternal:function(effect){new Effect.Move(effect.element,{x:distance*2,y:0,duration:split*2,afterFinishInternal:function(effect){new Effect.Move(effect.element,{x:-distance,y:0,duration:split,afterFinishInternal:function(effect){effect.element.undoPositioned().setStyle(oldStyle);}});}});}});}});}});}});};Effect.SlideDown=function(element){element=$(element).cleanWhitespace();var oldInnerBottom=element.down().getStyle("bottom");var elementDimensions=element.getDimensions();return new Effect.Scale(element,100,Object.extend({scaleContent:false,scaleX:false,scaleFrom:window.opera?0:1,scaleMode:{originalHeight:elementDimensions.height,originalWidth:elementDimensions.width},restoreAfterFinish:true,afterSetup:function(effect){effect.element.makePositioned();effect.element.down().makePositioned();if(window.opera){effect.element.setStyle({top:""});}effect.element.makeClipping().setStyle({height:"0px"}).show();},afterUpdateInternal:function(effect){effect.element.down().setStyle({bottom:(effect.dims[0]-effect.element.clientHeight)+"px"});},afterFinishInternal:function(effect){effect.element.undoClipping().undoPositioned();effect.element.down().undoPositioned().setStyle({bottom:oldInnerBottom});}},arguments[1]||{}));};Effect.SlideUp=function(element){element=$(element).cleanWhitespace();var oldInnerBottom=element.down().getStyle("bottom");var elementDimensions=element.getDimensions();return new Effect.Scale(element,window.opera?0:1,Object.extend({scaleContent:false,scaleX:false,scaleMode:"box",scaleFrom:100,scaleMode:{originalHeight:elementDimensions.height,originalWidth:elementDimensions.width},restoreAfterFinish:true,afterSetup:function(effect){effect.element.makePositioned();effect.element.down().makePositioned();if(window.opera){effect.element.setStyle({top:""});}effect.element.makeClipping().show();},afterUpdateInternal:function(effect){effect.element.down().setStyle({bottom:(effect.dims[0]-effect.element.clientHeight)+"px"});},afterFinishInternal:function(effect){effect.element.hide().undoClipping().undoPositioned();effect.element.down().undoPositioned().setStyle({bottom:oldInnerBottom});}},arguments[1]||{}));};Effect.Squish=function(element){return new Effect.Scale(element,window.opera?1:0,{restoreAfterFinish:true,beforeSetup:function(effect){effect.element.makeClipping();},afterFinishInternal:function(effect){effect.element.hide().undoClipping();}});};Effect.Grow=function(element){element=$(element);var options=Object.extend({direction:"center",moveTransition:Effect.Transitions.sinoidal,scaleTransition:Effect.Transitions.sinoidal,opacityTransition:Effect.Transitions.full},arguments[1]||{});var oldStyle={top:element.style.top,left:element.style.left,height:element.style.height,width:element.style.width,opacity:element.getInlineOpacity()};var dims=element.getDimensions();var initialMoveX,initialMoveY;var moveX,moveY;switch(options.direction){case"top-left":initialMoveX=initialMoveY=moveX=moveY=0;break;case"top-right":initialMoveX=dims.width;initialMoveY=moveY=0;moveX=-dims.width;break;case"bottom-left":initialMoveX=moveX=0;initialMoveY=dims.height;moveY=-dims.height;break;case"bottom-right":initialMoveX=dims.width;initialMoveY=dims.height;moveX=-dims.width;moveY=-dims.height;break;case"center":initialMoveX=dims.width/2;initialMoveY=dims.height/2;moveX=-dims.width/2;moveY=-dims.height/2;break;}return new Effect.Move(element,{x:initialMoveX,y:initialMoveY,duration:0.01,beforeSetup:function(effect){effect.element.hide().makeClipping().makePositioned();},afterFinishInternal:function(effect){new Effect.Parallel([new Effect.Opacity(effect.element,{sync:true,to:1,from:0,transition:options.opacityTransition}),new Effect.Move(effect.element,{x:moveX,y:moveY,sync:true,transition:options.moveTransition}),new Effect.Scale(effect.element,100,{scaleMode:{originalHeight:dims.height,originalWidth:dims.width},sync:true,scaleFrom:window.opera?1:0,transition:options.scaleTransition,restoreAfterFinish:true})],Object.extend({beforeSetup:function(effect){effect.effects[0].element.setStyle({height:"0px"}).show();},afterFinishInternal:function(effect){effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle);}},options));}});};Effect.Shrink=function(element){element=$(element);var options=Object.extend({direction:"center",moveTransition:Effect.Transitions.sinoidal,scaleTransition:Effect.Transitions.sinoidal,opacityTransition:Effect.Transitions.none},arguments[1]||{});var oldStyle={top:element.style.top,left:element.style.left,height:element.style.height,width:element.style.width,opacity:element.getInlineOpacity()};var dims=element.getDimensions();var moveX,moveY;switch(options.direction){case"top-left":moveX=moveY=0;break;case"top-right":moveX=dims.width;moveY=0;break;case"bottom-left":moveX=0;moveY=dims.height;break;case"bottom-right":moveX=dims.width;moveY=dims.height;break;case"center":moveX=dims.width/2;moveY=dims.height/2;break;}return new Effect.Parallel([new Effect.Opacity(element,{sync:true,to:0,from:1,transition:options.opacityTransition}),new Effect.Scale(element,window.opera?1:0,{sync:true,transition:options.scaleTransition,restoreAfterFinish:true}),new Effect.Move(element,{x:moveX,y:moveY,sync:true,transition:options.moveTransition})],Object.extend({beforeStartInternal:function(effect){effect.effects[0].element.makePositioned().makeClipping();},afterFinishInternal:function(effect){effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle);}},options));};Effect.Pulsate=function(element){element=$(element);var options=arguments[1]||{},oldOpacity=element.getInlineOpacity(),transition=options.transition||Effect.Transitions.linear,reverser=function(pos){return 1-transition((-Math.cos((pos*(options.pulses||5)*2)*Math.PI)/2)+0.5);};return new Effect.Opacity(element,Object.extend(Object.extend({duration:2,from:0,afterFinishInternal:function(effect){effect.element.setStyle({opacity:oldOpacity});}},options),{transition:reverser}));};Effect.Fold=function(element){element=$(element);var oldStyle={top:element.style.top,left:element.style.left,width:element.style.width,height:element.style.height};element.makeClipping();return new Effect.Scale(element,5,Object.extend({scaleContent:false,scaleX:false,afterFinishInternal:function(effect){new Effect.Scale(element,1,{scaleContent:false,scaleY:false,afterFinishInternal:function(effect){effect.element.hide().undoClipping().setStyle(oldStyle);}});}},arguments[1]||{}));};Effect.Morph=Class.create(Effect.Base,{initialize:function(element){this.element=$(element);if(!this.element){throw (Effect._elementDoesNotExistError);}var options=Object.extend({style:{}},arguments[1]||{});if(!Object.isString(options.style)){this.style=$H(options.style);}else{if(options.style.include(":")){this.style=options.style.parseStyle();}else{this.element.addClassName(options.style);this.style=$H(this.element.getStyles());this.element.removeClassName(options.style);var css=this.element.getStyles();this.style=this.style.reject(function(style){return style.value==css[style.key];});options.afterFinishInternal=function(effect){effect.element.addClassName(effect.options.style);effect.transforms.each(function(transform){effect.element.style[transform.style]="";});};}}this.start(options);},setup:function(){function parseColor(color){if(!color||["rgba(0, 0, 0, 0)","transparent"].include(color)){color="#ffffff";}color=color.parseColor();return $R(0,2).map(function(i){return parseInt(color.slice(i*2+1,i*2+3),16);});}this.transforms=this.style.map(function(pair){var property=pair[0],value=pair[1],unit=null;if(value.parseColor("#zzzzzz")!="#zzzzzz"){value=value.parseColor();unit="color";}else{if(property=="opacity"){value=parseFloat(value);if(Prototype.Browser.IE&&(!this.element.currentStyle.hasLayout)){this.element.setStyle({zoom:1});}}else{if(Element.CSS_LENGTH.test(value)){var components=value.match(/^([\+\-]?[0-9\.]+)(.*)$/);value=parseFloat(components[1]);unit=(components.length==3)?components[2]:null;}}}var originalValue=this.element.getStyle(property);return{style:property.camelize(),originalValue:unit=="color"?parseColor(originalValue):parseFloat(originalValue||0),targetValue:unit=="color"?parseColor(value):value,unit:unit};}.bind(this)).reject(function(transform){return((transform.originalValue==transform.targetValue)||(transform.unit!="color"&&(isNaN(transform.originalValue)||isNaN(transform.targetValue))));});},update:function(position){var style={},transform,i=this.transforms.length;while(i--){style[(transform=this.transforms[i]).style]=transform.unit=="color"?"#"+(Math.round(transform.originalValue[0]+(transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart()+(Math.round(transform.originalValue[1]+(transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart()+(Math.round(transform.originalValue[2]+(transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart():(transform.originalValue+(transform.targetValue-transform.originalValue)*position).toFixed(3)+(transform.unit===null?"":transform.unit);}this.element.setStyle(style,true);}});Effect.Transform=Class.create({initialize:function(tracks){this.tracks=[];this.options=arguments[1]||{};this.addTracks(tracks);},addTracks:function(tracks){tracks.each(function(track){track=$H(track);var data=track.values().first();this.tracks.push($H({ids:track.keys().first(),effect:Effect.Morph,options:{style:data}}));}.bind(this));return this;},play:function(){return new Effect.Parallel(this.tracks.map(function(track){var ids=track.get("ids"),effect=track.get("effect"),options=track.get("options");var elements=[$(ids)||$$(ids)].flatten();return elements.map(function(e){return new effect(e,Object.extend({sync:true},options));});}).flatten(),this.options);}});Element.CSS_PROPERTIES=$w("backgroundColor backgroundPosition borderBottomColor borderBottomStyle borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth borderRightColor borderRightStyle borderRightWidth borderSpacing borderTopColor borderTopStyle borderTopWidth bottom clip color fontSize fontWeight height left letterSpacing lineHeight marginBottom marginLeft marginRight marginTop markerOffset maxHeight maxWidth minHeight minWidth opacity outlineColor outlineOffset outlineWidth paddingBottom paddingLeft paddingRight paddingTop right textIndent top width wordSpacing zIndex");Element.CSS_LENGTH=/^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;String.__parseStyleElement=document.createElement("div");String.prototype.parseStyle=function(){var style,styleRules=$H();if(Prototype.Browser.WebKit){style=new Element("div",{style:this}).style;}else{String.__parseStyleElement.innerHTML='<div style="'+this+'"></div>';style=String.__parseStyleElement.childNodes[0].style;}Element.CSS_PROPERTIES.each(function(property){if(style[property]){styleRules.set(property,style[property]);}});if(Prototype.Browser.IE&&this.include("opacity")){styleRules.set("opacity",this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);}return styleRules;};if(document.defaultView&&document.defaultView.getComputedStyle){Element.getStyles=function(element){var css=document.defaultView.getComputedStyle($(element),null);return Element.CSS_PROPERTIES.inject({},function(styles,property){styles[property]=css[property];return styles;});};}else{Element.getStyles=function(element){element=$(element);var css=element.currentStyle,styles;styles=Element.CSS_PROPERTIES.inject({},function(results,property){results[property]=css[property];return results;});if(!styles.opacity){styles.opacity=element.getOpacity();}return styles;};}Effect.Methods={morph:function(element,style){element=$(element);new Effect.Morph(element,Object.extend({style:style},arguments[2]||{}));return element;},visualEffect:function(element,effect,options){element=$(element);var s=effect.dasherize().camelize(),klass=s.charAt(0).toUpperCase()+s.substring(1);new Effect[klass](element,options);return element;},highlight:function(element,options){element=$(element);new Effect.Highlight(element,options);return element;}};$w("fade appear grow shrink fold blindUp blindDown slideUp slideDown pulsate shake puff squish switchOff dropOut").each(function(effect){Effect.Methods[effect]=function(element,options){element=$(element);Effect[effect.charAt(0).toUpperCase()+effect.substring(1)](element,options);return element;};});$w("getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles").each(function(f){Effect.Methods[f]=Element[f];});Element.addMethods(Effect.Methods);
// script.aculo.us dragdrop.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005-2007 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

if(typeof Effect == 'undefined')
 throw("dragdrop.js requires including script.aculo.us' effects.js library");

var Droppables = {
 drops: [],

 remove: function(element) {
 this.drops = this.drops.reject(function(d) { return d.element==$(element) });
 },

 add: function(element) {
 element = $(element);
 var options = Object.extend({
 greedy: true,
 hoverclass: null,
 tree: false
 }, arguments[1] || {});

 // cache containers
 if(options.containment) {
 options._containers = [];
 var containment = options.containment;
 if((typeof containment == 'object') &&
 (containment.constructor == Array)) {
 containment.each( function(c) { options._containers.push($(c)) });
 } else {
 options._containers.push($(containment));
 }
 }

 if(options.accept) options.accept = [options.accept].flatten();

 Element.makePositioned(element); // fix IE
 options.element = element;

 this.drops.push(options);
 },

 findDeepestChild: function(drops) {
 deepest = drops[0];

 for (i = 1; i < drops.length; ++i)
 if (Element.isParent(drops[i].element, deepest.element))
 deepest = drops[i];

 return deepest;
 },

 isContained: function(element, drop) {
 var containmentNode;
 if(drop.tree) {
 containmentNode = element.treeNode;
 } else {
 containmentNode = element.parentNode;
 }
 return drop._containers.detect(function(c) { return containmentNode == c });
 },

 isAffected: function(point, element, drop) {
 return (
 (drop.element!=element) &&
 ((!drop._containers) ||
 this.isContained(element, drop)) &&
 ((!drop.accept) ||
 (Element.classNames(element).detect(
 function(v) { return drop.accept.include(v) } ) )) &&
 Position.within(drop.element, point[0], point[1]) );
 },

 deactivate: function(drop) {
 if(drop.hoverclass)
 Element.removeClassName(drop.element, drop.hoverclass);
 this.last_active = null;
 },

 activate: function(drop) {
 if(drop.hoverclass)
 Element.addClassName(drop.element, drop.hoverclass);
 this.last_active = drop;
 },

 show: function(point, element) {
 if(!this.drops.length) return;
 var affected = [];

 if(this.last_active) this.deactivate(this.last_active);
 this.drops.each( function(drop) {
 if(Droppables.isAffected(point, element, drop))
 affected.push(drop);
 });

 if(affected.length>0) {
 drop = Droppables.findDeepestChild(affected);
 Position.within(drop.element, point[0], point[1]);
 if(drop.onHover)
 drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));

 Droppables.activate(drop);
 }
 },

 fire: function(event, element) {
 if(!this.last_active) return;
 Position.prepare();

 if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
 if (this.last_active.onDrop) {
 this.last_active.onDrop(element, this.last_active.element, event);
 return true;
 }
 },

 reset: function() {
 if(this.last_active)
 this.deactivate(this.last_active);
 }
}

var Draggables = {
 drags: [],
 observers: [],

 register: function(draggable) {
 if(this.drags.length == 0) {
 this.eventMouseUp = this.endDrag.bindAsEventListener(this);
 this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
 this.eventKeypress = this.keyPress.bindAsEventListener(this);

 Event.observe(document, "mouseup", this.eventMouseUp);
 Event.observe(draggable.element, "mousemove", this.eventMouseMove);
 Event.observe(document, "keypress", this.eventKeypress);
 }
 this.drags.push(draggable);
 },

 unregister: function(draggable) {
 this.drags = this.drags.reject(function(d) { return d==draggable });
 if(this.drags.length == 0) {
 Event.stopObserving(document, "mouseup", this.eventMouseUp);
 Event.stopObserving(draggable.element, "mousemove", this.eventMouseMove);
 Event.stopObserving(document, "keypress", this.eventKeypress);
 }
 },

 activate: function(draggable) {
 if(draggable.options.delay) {
 this._timeout = setTimeout(function() {
 Draggables._timeout = null;
 window.focus();
 Draggables.activeDraggable = draggable;
 }.bind(this), draggable.options.delay);
 } else {
 window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
 this.activeDraggable = draggable;
 }
 },

 deactivate: function() {
 this.activeDraggable = null;
 },

 updateDrag: function(event) {
 if(!this.activeDraggable) return;
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 // Mozilla-based browsers fire successive mousemove events with
 // the same coordinates, prevent needless redrawing (moz bug?)
 if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
 this._lastPointer = pointer;

 this.activeDraggable.updateDrag(event, pointer);
 },

 endDrag: function(event) {
 if(this._timeout) {
 clearTimeout(this._timeout);
 this._timeout = null;
 }
 if(!this.activeDraggable) return;
 this._lastPointer = null;
 this.activeDraggable.endDrag(event);
 this.activeDraggable = null;
 },

 keyPress: function(event) {
 if(this.activeDraggable)
 this.activeDraggable.keyPress(event);
 },

 addObserver: function(observer) {
 this.observers.push(observer);
 this._cacheObserverCallbacks();
 },

 removeObserver: function(element) { // element instead of observer fixes mem leaks
 this.observers = this.observers.reject( function(o) { return o.element==element });
 this._cacheObserverCallbacks();
 },

 notify: function(eventName, draggable, event) { // 'onStart', 'onEnd', 'onDrag'
 if(this[eventName+'Count'] > 0)
 this.observers.each( function(o) {
 if(o[eventName]) o[eventName](eventName, draggable, event);
 });
 if(draggable.options[eventName]) draggable.options[eventName](draggable, event);
 },

 _cacheObserverCallbacks: function() {
 ['onStart','onEnd','onDrag'].each( function(eventName) {
 Draggables[eventName+'Count'] = Draggables.observers.select(
 function(o) { return o[eventName]; }
 ).length;
 });
 }
}

/*--------------------------------------------------------------------------*/

var Draggable = Class.create();
Draggable._dragging = {};

Draggable.prototype = {
 initialize: function(element) {
 var defaults = {
 handle: false,
 reverteffect: function(element, top_offset, left_offset) {
 var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
 new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
 queue: {scope:'_draggable', position:'end'}
 });
 },
 endeffect: function(element) {
 var toOpacity = typeof element._opacity == 'number' ? element._opacity : 1.0;
 new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity,
 queue: {scope:'_draggable', position:'end'},
 afterFinish: function(){
 Draggable._dragging[element] = false
 }
 });
 },
 zindex: 1000,
 revert: false,
 quiet: false,
 scroll: false,
 scrollSensitivity: 20,
 scrollSpeed: 15,
 snap: false, // false, or xy or [x,y] or function(x,y){ return [x,y] }
 delay: 0
 };

 if(!arguments[1] || typeof arguments[1].endeffect == 'undefined')
 Object.extend(defaults, {
 starteffect: function(element) {
 element._opacity = Element.getOpacity(element);
 Draggable._dragging[element] = true;
 new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7});
 }
 });

 var options = Object.extend(defaults, arguments[1] || {});

 this.element = $(element);

 if(options.handle && (typeof options.handle == 'string'))
 this.handle = this.element.down('.'+options.handle, 0);

 if(!this.handle) this.handle = $(options.handle);
 if(!this.handle) this.handle = this.element;

 if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
 options.scroll = $(options.scroll);
 this._isScrollChild = Element.childOf(this.element, options.scroll);
 }

 Element.makePositioned(this.element); // fix IE

 this.delta = this.currentDelta();
 this.options = options;
 this.dragging = false;

 this.eventMouseDown = this.initDrag.bindAsEventListener(this);
 Event.observe(this.handle, "mousedown", this.eventMouseDown);

 Draggables.register(this);
 },

 destroy: function() {
 Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
 Draggables.unregister(this);
 },

 currentDelta: function() {
 return([
 parseInt(Element.getStyle(this.element,'left') || '0'),
 parseInt(Element.getStyle(this.element,'top') || '0')]);
 },

 initDrag: function(event) {
 if(typeof Draggable._dragging[this.element] != 'undefined' &&
 Draggable._dragging[this.element]) return;
 if(Event.isLeftClick(event)) {
 // abort on form elements, fixes a Firefox issue
 var src = Event.element(event);
 if((tag_name = src.tagName.toUpperCase()) && (
 tag_name=='INPUT' ||
 tag_name=='SELECT' ||
 tag_name=='OPTION' ||
 tag_name=='BUTTON' ||
 tag_name=='TEXTAREA')) return;

 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var pos = Position.cumulativeOffset(this.element);
 this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });

 Draggables.activate(this);
 Event.stop(event);
 }
 },

 startDrag: function(event) {
 this.dragging = true;

 if(this.options.zindex) {
 this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
 this.element.style.zIndex = this.options.zindex;
 }

 if(this.options.ghosting) {
 this._clone = this.element.cloneNode(true);
 Position.absolutize(this.element);
 this.element.parentNode.insertBefore(this._clone, this.element);
 }

 if(this.options.scroll) {
 if (this.options.scroll == window) {
 var where = this._getWindowScroll(this.options.scroll);
 this.originalScrollLeft = where.left;
 this.originalScrollTop = where.top;
 } else {
 this.originalScrollLeft = this.options.scroll.scrollLeft;
 this.originalScrollTop = this.options.scroll.scrollTop;
 }
 }

 Draggables.notify('onStart', this, event);

 if(this.options.starteffect) this.options.starteffect(this.element);
 },

 updateDrag: function(event, pointer) {
 if(!this.dragging) this.startDrag(event);

 if(!this.options.quiet){
 Position.prepare();
 Droppables.show(pointer, this.element);
 }

 Draggables.notify('onDrag', this, event);

 this.draw(pointer);
 if(this.options.change) this.options.change(this);

 if(this.options.scroll) {
 this.stopScrolling();

 var p;
 if (this.options.scroll == window) {
 with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
 } else {
 p = Position.page(this.options.scroll);
 p[0] += this.options.scroll.scrollLeft + Position.deltaX;
 p[1] += this.options.scroll.scrollTop + Position.deltaY;
 p.push(p[0]+this.options.scroll.offsetWidth);
 p.push(p[1]+this.options.scroll.offsetHeight);
 }
 var speed = [0,0];
 if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
 if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
 if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
 if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
 this.startScrolling(speed);
 }

 // fix AppleWebKit rendering
 if(Prototype.Browser.WebKit) window.scrollBy(0,0);

 Event.stop(event);
 },

 finishDrag: function(event, success) {
 this.dragging = false;

 if(this.options.quiet){
 Position.prepare();
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 Droppables.show(pointer, this.element);
 }

 if(this.options.ghosting) {
 Position.relativize(this.element);
 Element.remove(this._clone);
 this._clone = null;
 }

 var dropped = false;
 if(success) {
 dropped = Droppables.fire(event, this.element);
 if (!dropped) dropped = false;
 }
 if(dropped && this.options.onDropped) this.options.onDropped(this.element);
 Draggables.notify('onEnd', this, event);

 var revert = this.options.revert;
 if(revert && typeof revert == 'function') revert = revert(this.element);

 var d = this.currentDelta();
 if(revert && this.options.reverteffect) {
 if (dropped == 0 || revert != 'failure')
 this.options.reverteffect(this.element,
 d[1]-this.delta[1], d[0]-this.delta[0]);
 } else {
 this.delta = d;
 }

 if(this.options.zindex)
 this.element.style.zIndex = this.originalZ;

 if(this.options.endeffect)
 this.options.endeffect(this.element);

 Draggables.deactivate(this);
 Droppables.reset();
 },

 keyPress: function(event) {
 if(event.keyCode!=Event.KEY_ESC) return;
 this.finishDrag(event, false);
 Event.stop(event);
 },

 endDrag: function(event) {
 if(!this.dragging) return;
 this.stopScrolling();
 this.finishDrag(event, true);
 Event.stop(event);
 },

 draw: function(point) {
 var pos = Position.cumulativeOffset(this.element);
 if(this.options.ghosting) {
 var r = Position.realOffset(this.element);
 pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
 }

 var d = this.currentDelta();
 pos[0] -= d[0]; pos[1] -= d[1];

 if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
 pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
 pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
 }

 var p = [0,1].map(function(i){
 return (point[i]-pos[i]-this.offset[i])
 }.bind(this));

 if(this.options.snap) {
 if(typeof this.options.snap == 'function') {
 p = this.options.snap(p[0],p[1],this);
 } else {
 if(this.options.snap instanceof Array) {
 p = p.map( function(v, i) {
 return Math.round(v/this.options.snap[i])*this.options.snap[i] }.bind(this))
 } else {
 p = p.map( function(v) {
 return Math.round(v/this.options.snap)*this.options.snap }.bind(this))
 }
 }}

 var style = this.element.style;
 if((!this.options.constraint) || (this.options.constraint=='horizontal'))
 style.left = p[0] + "px";
 if((!this.options.constraint) || (this.options.constraint=='vertical'))
 style.top = p[1] + "px";

 if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
 },

 stopScrolling: function() {
 if(this.scrollInterval) {
 clearInterval(this.scrollInterval);
 this.scrollInterval = null;
 Draggables._lastScrollPointer = null;
 }
 },

 startScrolling: function(speed) {
 if(!(speed[0] || speed[1])) return;
 this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
 this.lastScrolled = new Date();
 this.scrollInterval = setInterval(this.scroll.bind(this), 10);
 },

 scroll: function() {
 var current = new Date();
 var delta = current - this.lastScrolled;
 this.lastScrolled = current;
 if(this.options.scroll == window) {
 with (this._getWindowScroll(this.options.scroll)) {
 if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
 var d = delta / 1000;
 this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
 }
 }
 } else {
 this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
 this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
 }

 Position.prepare();
 Droppables.show(Draggables._lastPointer, this.element);
 Draggables.notify('onDrag', this);
 if (this._isScrollChild) {
 Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
 Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
 Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
 if (Draggables._lastScrollPointer[0] < 0)
 Draggables._lastScrollPointer[0] = 0;
 if (Draggables._lastScrollPointer[1] < 0)
 Draggables._lastScrollPointer[1] = 0;
 this.draw(Draggables._lastScrollPointer);
 }

 if(this.options.change) this.options.change(this);
 },

 _getWindowScroll: function(w) {
 var T, L, W, H;
 with (w.document) {
 if (w.document.documentElement && documentElement.scrollTop) {
 T = documentElement.scrollTop;
 L = documentElement.scrollLeft;
 } else if (w.document.body) {
 T = body.scrollTop;
 L = body.scrollLeft;
 }
 if (w.innerWidth) {
 W = w.innerWidth;
 H = w.innerHeight;
 } else if (w.document.documentElement && documentElement.clientWidth) {
 W = documentElement.clientWidth;
 H = documentElement.clientHeight;
 } else {
 W = body.offsetWidth;
 H = body.offsetHeight
 }
 }
 return { top: T, left: L, width: W, height: H };
 }
}

/*--------------------------------------------------------------------------*/

var SortableObserver = Class.create();
SortableObserver.prototype = {
 initialize: function(element, observer) {
 this.element = $(element);
 this.observer = observer;
 this.lastValue = Sortable.serialize(this.element);
 },

 onStart: function() {
 this.lastValue = Sortable.serialize(this.element);
 },

 onEnd: function() {
 Sortable.unmark();
 if(this.lastValue != Sortable.serialize(this.element))
 this.observer(this.element)
 }
}

var Sortable = {
 SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,

 sortables: {},

 _findRootElement: function(element) {
 while (element.tagName.toUpperCase() != "BODY") {
 if(element.id && Sortable.sortables[element.id]) return element;
 element = element.parentNode;
 }
 },

 options: function(element) {
 element = Sortable._findRootElement($(element));
 if(!element) return;
 return Sortable.sortables[element.id];
 },

 destroy: function(element){
 var s = Sortable.options(element);

 if(s) {
 Draggables.removeObserver(s.element);
 s.droppables.each(function(d){ Droppables.remove(d) });
 s.draggables.invoke('destroy');

 delete Sortable.sortables[s.element.id];
 }
 },

 create: function(element) {
 element = $(element);
 var options = Object.extend({
 element: element,
 tag: 'li', // assumes li children, override with tag: 'tagname'
 dropOnEmpty: false,
 tree: false,
 treeTag: 'ul',
 overlap: 'vertical', // one of 'vertical', 'horizontal'
 constraint: 'vertical', // one of 'vertical', 'horizontal', false
 containment: element, // also takes array of elements (or id's); or false
 handle: false, // or a CSS class
 only: false,
 delay: 0,
 hoverclass: null,
 ghosting: false,
 quiet: false,
 scroll: false,
 scrollSensitivity: 20,
 scrollSpeed: 15,
 format: this.SERIALIZE_RULE,

 // these take arrays of elements or ids and can be
 // used for better initialization performance
 elements: false,
 handles: false,

 onChange: Prototype.emptyFunction,
 onUpdate: Prototype.emptyFunction
 }, arguments[1] || {});

 // clear any old sortable with same element
 this.destroy(element);

 // build options for the draggables
 var options_for_draggable = {
 revert: true,
 quiet: options.quiet,
 scroll: options.scroll,
 scrollSpeed: options.scrollSpeed,
 scrollSensitivity: options.scrollSensitivity,
 delay: options.delay,
 ghosting: options.ghosting,
 constraint: options.constraint,
 handle: options.handle };

 if(options.starteffect)
 options_for_draggable.starteffect = options.starteffect;

 if(options.reverteffect)
 options_for_draggable.reverteffect = options.reverteffect;
 else
 if(options.ghosting) options_for_draggable.reverteffect = function(element) {
 element.style.top = 0;
 element.style.left = 0;
 };

 if(options.endeffect)
 options_for_draggable.endeffect = options.endeffect;

 if(options.zindex)
 options_for_draggable.zindex = options.zindex;

 // build options for the droppables
 var options_for_droppable = {
 overlap: options.overlap,
 containment: options.containment,
 tree: options.tree,
 hoverclass: options.hoverclass,
 onHover: Sortable.onHover
 }

 var options_for_tree = {
 onHover: Sortable.onEmptyHover,
 overlap: options.overlap,
 containment: options.containment,
 hoverclass: options.hoverclass
 }

 // fix for gecko engine
 Element.cleanWhitespace(element);

 options.draggables = [];
 options.droppables = [];

 // drop on empty handling
 if(options.dropOnEmpty || options.tree) {
 Droppables.add(element, options_for_tree);
 options.droppables.push(element);
 }

 (options.elements || this.findElements(element, options) || []).each( function(e,i) {
 var handle = options.handles ? $(options.handles[i]) :
 (options.handle ? $(e).getElementsByClassName(options.handle)[0] : e);
 options.draggables.push(
 new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
 Droppables.add(e, options_for_droppable);
 if(options.tree) e.treeNode = element;
 options.droppables.push(e);
 });

 if(options.tree) {
 (Sortable.findTreeElements(element, options) || []).each( function(e) {
 Droppables.add(e, options_for_tree);
 e.treeNode = element;
 options.droppables.push(e);
 });
 }

 // keep reference
 this.sortables[element.id] = options;

 // for onupdate
 Draggables.addObserver(new SortableObserver(element, options.onUpdate));

 },

 // return all suitable-for-sortable elements in a guaranteed order
 findElements: function(element, options) {
 return Element.findChildren(
 element, options.only, options.tree ? true : false, options.tag);
 },

 findTreeElements: function(element, options) {
 return Element.findChildren(
 element, options.only, options.tree ? true : false, options.treeTag);
 },

 onHover: function(element, dropon, overlap) {
 if(Element.isParent(dropon, element)) return;

 if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
 return;
 } else if(overlap>0.5) {
 Sortable.mark(dropon, 'before');
 if(dropon.previousSibling != element) {
 var oldParentNode = element.parentNode;
 element.style.visibility = "hidden"; // fix gecko rendering
 dropon.parentNode.insertBefore(element, dropon);
 if(dropon.parentNode!=oldParentNode)
 Sortable.options(oldParentNode).onChange(element);
 Sortable.options(dropon.parentNode).onChange(element);
 }
 } else {
 Sortable.mark(dropon, 'after');
 var nextElement = dropon.nextSibling || null;
 if(nextElement != element) {
 var oldParentNode = element.parentNode;
 element.style.visibility = "hidden"; // fix gecko rendering
 dropon.parentNode.insertBefore(element, nextElement);
 if(dropon.parentNode!=oldParentNode)
 Sortable.options(oldParentNode).onChange(element);
 Sortable.options(dropon.parentNode).onChange(element);
 }
 }
 },

 onEmptyHover: function(element, dropon, overlap) {
 var oldParentNode = element.parentNode;
 var droponOptions = Sortable.options(dropon);

 if(!Element.isParent(dropon, element)) {
 var index;

 var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
 var child = null;

 if(children) {
 var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);

 for (index = 0; index < children.length; index += 1) {
 if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
 offset -= Element.offsetSize (children[index], droponOptions.overlap);
 } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
 child = index + 1 < children.length ? children[index + 1] : null;
 break;
 } else {
 child = children[index];
 break;
 }
 }
 }

 dropon.insertBefore(element, child);

 Sortable.options(oldParentNode).onChange(element);
 droponOptions.onChange(element);
 }
 },

 unmark: function() {
 if(Sortable._marker) Sortable._marker.hide();
 },

 mark: function(dropon, position) {
 // mark on ghosting only
 var sortable = Sortable.options(dropon.parentNode);
 if(sortable && !sortable.ghosting) return;

 if(!Sortable._marker) {
 Sortable._marker =
 ($('dropmarker') || Element.extend(document.createElement('DIV'))).
 hide().addClassName('dropmarker').setStyle({position:'absolute'});
 document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
 }
 var offsets = Position.cumulativeOffset(dropon);
 Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});

 if(position=='after')
 if(sortable.overlap == 'horizontal')
 Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
 else
 Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});

 Sortable._marker.show();
 },

 _tree: function(element, options, parent) {
 var children = Sortable.findElements(element, options) || [];

 for (var i = 0; i < children.length; ++i) {
 var match = children[i].id.match(options.format);

 if (!match) continue;

 var child = {
 id: encodeURIComponent(match ? match[1] : null),
 element: element,
 parent: parent,
 children: [],
 position: parent.children.length,
 container: $(children[i]).down(options.treeTag)
 }

 /* Get the element containing the children and recurse over it */
 if (child.container)
 this._tree(child.container, options, child)

 parent.children.push (child);
 }

 return parent;
 },

 tree: function(element) {
 element = $(element);
 var sortableOptions = this.options(element);
 var options = Object.extend({
 tag: sortableOptions.tag,
 treeTag: sortableOptions.treeTag,
 only: sortableOptions.only,
 name: element.id,
 format: sortableOptions.format
 }, arguments[1] || {});

 var root = {
 id: null,
 parent: null,
 children: [],
 container: element,
 position: 0
 }

 return Sortable._tree(element, options, root);
 },

 /* Construct a [i] index for a particular node */
 _constructIndex: function(node) {
 var index = '';
 do {
 if (node.id) index = '[' + node.position + ']' + index;
 } while ((node = node.parent) != null);
 return index;
 },

 sequence: function(element) {
 element = $(element);
 var options = Object.extend(this.options(element), arguments[1] || {});

 return $(this.findElements(element, options) || []).map( function(item) {
 return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
 });
 },

 setSequence: function(element, new_sequence) {
 element = $(element);
 var options = Object.extend(this.options(element), arguments[2] || {});

 var nodeMap = {};
 this.findElements(element, options).each( function(n) {
 if (n.id.match(options.format))
 nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
 n.parentNode.removeChild(n);
 });

 new_sequence.each(function(ident) {
 var n = nodeMap[ident];
 if (n) {
 n[1].appendChild(n[0]);
 delete nodeMap[ident];
 }
 });
 },

 serialize: function(element) {
 element = $(element);
 var options = Object.extend(Sortable.options(element), arguments[1] || {});
 var name = encodeURIComponent(
 (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);

 if (options.tree) {
 return Sortable.tree(element, arguments[1]).children.map( function (item) {
 return [name + Sortable._constructIndex(item) + "[id]=" +
 encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
 }).flatten().join('&');
 } else {
 return Sortable.sequence(element, arguments[1]).map( function(item) {
 return name + "[]=" + encodeURIComponent(item);
 }).join('&');
 }
 }
}

// Returns true if child is contained within element
Element.isParent = function(child, element) {
 if (!child.parentNode || child == element) return false;
 if (child.parentNode == element) return true;
 return Element.isParent(child.parentNode, element);
}

Element.findChildren = function(element, only, recursive, tagName) {
 if(!element.hasChildNodes()) return null;
 tagName = tagName.toUpperCase();
 if(only) only = [only].flatten();
 var elements = [];
 $A(element.childNodes).each( function(e) {
 if(e.tagName && e.tagName.toUpperCase()==tagName &&
 (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
 elements.push(e);
 if(recursive) {
 var grandchildren = Element.findChildren(e, only, recursive, tagName);
 if(grandchildren) elements.push(grandchildren);
 }
 });

 return (elements.length>0 ? elements.flatten() : []);
}

Element.offsetSize = function (element, type) {
 return element['offset' + ((type=='vertical' || type=='height') ? 'Height' : 'Width')];
}

// script.aculo.us controls.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005-2007 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
// (c) 2005-2007 Jon Tirsen (http://www.tirsen.com)
// Contributors:
// Richard Livsey
// Rahul Bhargava
// Rob Wills
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

// Autocompleter.Base handles all the autocompletion functionality 
// that's independent of the data source for autocompletion. This
// includes drawing the autocompletion menu, observing keyboard
// and mouse events, and similar.
//
// Specific autocompleters need to provide, at the very least, 
// a getUpdatedChoices function that will be invoked every time
// the text inside the monitored textbox changes. This method 
// should get the text for which to provide autocompletion by
// invoking this.getToken(), NOT by directly accessing
// this.element.value. This is to allow incremental tokenized
// autocompletion. Specific auto-completion logic (AJAX, etc)
// belongs in getUpdatedChoices.
//
// Tokenized incremental autocompletion is enabled automatically
// when an autocompleter is instantiated with the 'tokens' option
// in the options parameter, e.g.:
// new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
// will incrementally autocomplete with a comma as the token.
// Additionally, ',' in the above example can be replaced with
// a token array, e.g. { tokens: [',', '\n'] } which
// enables autocompletion on multiple tokens. This is most 
// useful when one of the tokens is \n (a newline), as it 
// allows smart autocompletion after linebreaks.

if(typeof Effect == 'undefined')
 throw("controls.js requires including script.aculo.us' effects.js library");

var Autocompleter = {}
Autocompleter.Base = function() {};
Autocompleter.Base.prototype = {
 baseInitialize: function(element, update, options) {
 element = $(element)
 this.element = element; 
 this.update = $(update); 
 this.hasFocus = false; 
 this.changed = false; 
 this.active = false; 
 this.index = 0; 
 this.entryCount = 0;

 if(this.setOptions)
 this.setOptions(options);
 else
 this.options = options || {};

 this.options.paramName = this.options.paramName || this.element.name;
 this.options.tokens = this.options.tokens || [];
 this.options.frequency = this.options.frequency || 0.4;
 this.options.minChars = this.options.minChars || 1;
 this.options.onShow = this.options.onShow || 
 function(element, update){ 
 if(!update.style.position || update.style.position=='absolute') {
 update.style.position = 'absolute';
 Position.clone(element, update, {
 setHeight: false, 
 offsetTop: element.offsetHeight
 });
 }
 Effect.Appear(update,{duration:0.15});
 };
 this.options.onHide = this.options.onHide || 
 function(element, update){ new Effect.Fade(update,{duration:0.15}) };

 if(typeof(this.options.tokens) == 'string') 
 this.options.tokens = new Array(this.options.tokens);

 this.observer = null;
 
 this.element.setAttribute('autocomplete','off');

 Element.hide(this.update);

 Event.observe(this.element, 'blur', this.onBlur.bindAsEventListener(this));
 Event.observe(this.element, 'keypress', this.onKeyPress.bindAsEventListener(this));

 // Turn autocomplete back on when the user leaves the page, so that the
 // field's value will be remembered on Mozilla-based browsers.
 Event.observe(window, 'beforeunload', function(){ 
 element.setAttribute('autocomplete', 'on'); 
 });
 },

 show: function() {
 if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
 if(!this.iefix && 
 (Prototype.Browser.IE) &&
 (Element.getStyle(this.update, 'position')=='absolute')) {
 new Insertion.After(this.update, 
 '<iframe id="' + this.update.id + '_iefix" '+
 'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
 'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
 this.iefix = $(this.update.id+'_iefix');
 }
 if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);
 },
 
 fixIEOverlapping: function() {
 Position.clone(this.update, this.iefix, {setTop:(!this.update.style.height)});
 this.iefix.style.zIndex = 1;
 this.update.style.zIndex = 2;
 Element.show(this.iefix);
 },

 hide: function() {
 this.stopIndicator();
 if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);
 if(this.iefix) Element.hide(this.iefix);
 },

 startIndicator: function() {
 if(this.options.indicator) Element.show(this.options.indicator);
 },

 stopIndicator: function() {
 if(this.options.indicator) Element.hide(this.options.indicator);
 },

 onKeyPress: function(event) {
 if(this.active)
 switch(event.keyCode) {
 case Event.KEY_TAB:
 case Event.KEY_RETURN:
 this.selectEntry();
 Event.stop(event);
 case Event.KEY_ESC:
 this.hide();
 this.active = false;
 Event.stop(event);
 return;
 case Event.KEY_LEFT:
 case Event.KEY_RIGHT:
 return;
 case Event.KEY_UP:
 this.markPrevious();
 this.render();
 if(Prototype.Browser.WebKit) Event.stop(event);
 return;
 case Event.KEY_DOWN:
 this.markNext();
 this.render();
 if(Prototype.Browser.WebKit) Event.stop(event);
 return;
 }
 else 
 if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN || 
 (Prototype.Browser.WebKit > 0 && event.keyCode == 0)) return;

 this.changed = true;
 this.hasFocus = true;

 if(this.observer) clearTimeout(this.observer);
 this.observer = 
 setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
 },

 activate: function() {
 this.changed = false;
 this.hasFocus = true;
 this.getUpdatedChoices();
 },

 onHover: function(event) {
 var element = Event.findElement(event, 'LI');
 if(this.index != element.autocompleteIndex) 
 {
 this.index = element.autocompleteIndex;
 this.render();
 }
 Event.stop(event);
 },
 
 onClick: function(event) {
 var element = Event.findElement(event, 'LI');
 this.index = element.autocompleteIndex;
 this.selectEntry();
 this.hide();
 },
 
 onBlur: function(event) {
 // needed to make click events working
 setTimeout(this.hide.bind(this), 250);
 this.hasFocus = false;
 this.active = false; 
 }, 
 
 render: function() {
 if(this.entryCount > 0) {
 for (var i = 0; i < this.entryCount; i++)
 this.index==i ? 
 Element.addClassName(this.getEntry(i),"selected") : 
 Element.removeClassName(this.getEntry(i),"selected");
 if(this.hasFocus) { 
 this.show();
 this.active = true;
 }
 } else {
 this.active = false;
 this.hide();
 }
 },
 
 markPrevious: function() {
 if(this.index > 0) this.index--
 else this.index = this.entryCount-1;
 this.getEntry(this.index).scrollIntoView(true);
 },
 
 markNext: function() {
 if(this.index < this.entryCount-1) this.index++
 else this.index = 0;
 this.getEntry(this.index).scrollIntoView(false);
 },
 
 getEntry: function(index) {
 return this.update.firstChild.childNodes[index];
 },
 
 getCurrentEntry: function() {
 return this.getEntry(this.index);
 },
 
 selectEntry: function() {
 this.active = false;
 this.updateElement(this.getCurrentEntry());
 },

 updateElement: function(selectedElement) {
 if (this.options.updateElement) {
 this.options.updateElement(selectedElement);
 return;
 }
 var value = '';
 if (this.options.select) {
 var nodes = document.getElementsByClassName(this.options.select, selectedElement) || [];
 if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
 } else
 value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
 
 var lastTokenPos = this.findLastToken();
 if (lastTokenPos != -1) {
 var newValue = this.element.value.substr(0, lastTokenPos + 1);
 var whitespace = this.element.value.substr(lastTokenPos + 1).match(/^\s+/);
 if (whitespace)
 newValue += whitespace[0];
 this.element.value = newValue + value;
 } else {
 this.element.value = value;
 }
 this.element.focus();
 
 if (this.options.afterUpdateElement)
 this.options.afterUpdateElement(this.element, selectedElement);
 },

 updateChoices: function(choices) {
 if(!this.changed && this.hasFocus) {
 this.update.innerHTML = choices;
 Element.cleanWhitespace(this.update);
 Element.cleanWhitespace(this.update.down());

 if(this.update.firstChild && this.update.down().childNodes) {
 this.entryCount = 
 this.update.down().childNodes.length;
 for (var i = 0; i < this.entryCount; i++) {
 var entry = this.getEntry(i);
 entry.autocompleteIndex = i;
 this.addObservers(entry);
 }
 } else { 
 this.entryCount = 0;
 }

 this.stopIndicator();
 this.index = 0;
 
 if(this.entryCount==1 && this.options.autoSelect) {
 this.selectEntry();
 this.hide();
 } else {
 this.render();
 }
 }
 },

 addObservers: function(element) {
 Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
 Event.observe(element, "click", this.onClick.bindAsEventListener(this));
 },

 onObserverEvent: function() {
 this.changed = false; 
 if(this.getToken().length>=this.options.minChars) {
 this.getUpdatedChoices();
 } else {
 this.active = false;
 this.hide();
 }
 },

 getToken: function() {
 var tokenPos = this.findLastToken();
 if (tokenPos != -1)
 var ret = this.element.value.substr(tokenPos + 1).replace(/^\s+/,'').replace(/\s+$/,'');
 else
 var ret = this.element.value;

 return /\n/.test(ret) ? '' : ret;
 },

 findLastToken: function() {
 var lastTokenPos = -1;

 for (var i=0; i<this.options.tokens.length; i++) {
 var thisTokenPos = this.element.value.lastIndexOf(this.options.tokens[i]);
 if (thisTokenPos > lastTokenPos)
 lastTokenPos = thisTokenPos;
 }
 return lastTokenPos;
 }
}

Ajax.Autocompleter = Class.create();
Object.extend(Object.extend(Ajax.Autocompleter.prototype, Autocompleter.Base.prototype), {
 initialize: function(element, update, url, options) {
 this.baseInitialize(element, update, options);
 this.options.asynchronous = true;
 this.options.onComplete = this.onComplete.bind(this);
 this.options.defaultParams = this.options.parameters || null;
 this.url = url;
 },

 getUpdatedChoices: function() {
 this.startIndicator();
 
 var entry = encodeURIComponent(this.options.paramName) + '=' + 
 encodeURIComponent(this.getToken());

 this.options.parameters = this.options.callback ?
 this.options.callback(this.element, entry) : entry;

 if(this.options.defaultParams) 
 this.options.parameters += '&' + this.options.defaultParams;
 
 new Ajax.Request(this.url, this.options);
 },

 onComplete: function(request) {
 this.updateChoices(request.responseText);
 }

});

// The local array autocompleter. Used when you'd prefer to
// inject an array of autocompletion options into the page, rather
// than sending out Ajax queries, which can be quite slow sometimes.
//
// The constructor takes four parameters. The first two are, as usual,
// the id of the monitored textbox, and id of the autocompletion menu.
// The third is the array you want to autocomplete from, and the fourth
// is the options block.
//
// Extra local autocompletion options:
// - choices - How many autocompletion choices to offer
//
// - partialSearch - If false, the autocompleter will match entered
// text only at the beginning of strings in the 
// autocomplete array. Defaults to true, which will
// match text at the beginning of any *word* in the
// strings in the autocomplete array. If you want to
// search anywhere in the string, additionally set
// the option fullSearch to true (default: off).
//
// - fullSsearch - Search anywhere in autocomplete array strings.
//
// - partialChars - How many characters to enter before triggering
// a partial match (unlike minChars, which defines
// how many characters are required to do any match
// at all). Defaults to 2.
//
// - ignoreCase - Whether to ignore case when autocompleting.
// Defaults to true.
//
// It's possible to pass in a custom function as the 'selector' 
// option, if you prefer to write your own autocompletion logic.
// In that case, the other options above will not apply unless
// you support them.

Autocompleter.Local = Class.create();
Autocompleter.Local.prototype = Object.extend(new Autocompleter.Base(), {
 initialize: function(element, update, array, options) {
 this.baseInitialize(element, update, options);
 this.options.array = array;
 },

 getUpdatedChoices: function() {
 this.updateChoices(this.options.selector(this));
 },

 setOptions: function(options) {
 this.options = Object.extend({
 choices: 10,
 partialSearch: true,
 partialChars: 2,
 ignoreCase: true,
 fullSearch: false,
 selector: function(instance) {
 var ret = []; // Beginning matches
 var partial = []; // Inside matches
 var entry = instance.getToken();
 var count = 0;

 for (var i = 0; i < instance.options.array.length && 
 ret.length < instance.options.choices ; i++) { 

 var elem = instance.options.array[i];
 var foundPos = instance.options.ignoreCase ? 
 elem.toLowerCase().indexOf(entry.toLowerCase()) : 
 elem.indexOf(entry);

 while (foundPos != -1) {
 if (foundPos == 0 && elem.length != entry.length) { 
 ret.push("<li><strong>" + elem.substr(0, entry.length) + "</strong>" + 
 elem.substr(entry.length) + "</li>");
 break;
 } else if (entry.length >= instance.options.partialChars && 
 instance.options.partialSearch && foundPos != -1) {
 if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos-1,1))) {
 partial.push("<li>" + elem.substr(0, foundPos) + "<strong>" +
 elem.substr(foundPos, entry.length) + "</strong>" + elem.substr(
 foundPos + entry.length) + "</li>");
 break;
 }
 }

 foundPos = instance.options.ignoreCase ? 
 elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) : 
 elem.indexOf(entry, foundPos + 1);

 }
 }
 if (partial.length)
 ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
 return "<ul>" + ret.join('') + "</ul>";
 }
 }, options || {});
 }
});

// AJAX in-place editor
//
// see documentation on http://wiki.script.aculo.us/scriptaculous/show/Ajax.InPlaceEditor

// Use this if you notice weird scrolling problems on some browsers,
// the DOM might be a bit confused when this gets called so do this
// waits 1 ms (with setTimeout) until it does the activation
Field.scrollFreeActivate = function(field) {
 setTimeout(function() {
 Field.activate(field);
 }, 1);
}

Ajax.InPlaceEditor = Class.create();
Ajax.InPlaceEditor.defaultHighlightColor = "#FFFF99";
Ajax.InPlaceEditor.prototype = {
 initialize: function(element, url, options) {
 this.url = url;
 this.element = $(element);

 this.options = Object.extend({
 paramName: "value",
 okButton: true,
 okLink: false,
 okText: "ok",
 cancelButton: false,
 cancelLink: true,
 cancelText: "cancel",
 textBeforeControls: '',
 textBetweenControls: '',
 textAfterControls: '',
 savingText: "Saving...",
 clickToEditText: "Click to edit",
 okText: "ok",
 rows: 1,
 onComplete: function(transport, element) {
 new Effect.Highlight(element, {startcolor: this.options.highlightcolor});
 },
 onFailure: function(transport) {
 alert("Error communicating with the server: " + transport.responseText.stripTags());
 },
 callback: function(form) {
 return Form.serialize(form);
 },
 handleLineBreaks: true,
 loadingText: 'Loading...',
 savingClassName: 'inplaceeditor-saving',
 loadingClassName: 'inplaceeditor-loading',
 formClassName: 'inplaceeditor-form',
 highlightcolor: Ajax.InPlaceEditor.defaultHighlightColor,
 highlightendcolor: "#FFFFFF",
 externalControl: null,
 submitOnBlur: false,
 ajaxOptions: {},
 evalScripts: false
 }, options || {});

 if(!this.options.formId && this.element.id) {
 this.options.formId = this.element.id + "-inplaceeditor";
 if ($(this.options.formId)) {
 // there's already a form with that name, don't specify an id
 this.options.formId = null;
 }
 }
 
 if (this.options.externalControl) {
 this.options.externalControl = $(this.options.externalControl);
 }
 
 this.originalBackground = Element.getStyle(this.element, 'background-color');
 if (!this.originalBackground) {
 this.originalBackground = "transparent";
 }
 
 this.element.title = this.options.clickToEditText;
 
 this.onclickListener = this.enterEditMode.bindAsEventListener(this);
 this.mouseoverListener = this.enterHover.bindAsEventListener(this);
 this.mouseoutListener = this.leaveHover.bindAsEventListener(this);
 Event.observe(this.element, 'click', this.onclickListener);
 Event.observe(this.element, 'mouseover', this.mouseoverListener);
 Event.observe(this.element, 'mouseout', this.mouseoutListener);
 if (this.options.externalControl) {
 Event.observe(this.options.externalControl, 'click', this.onclickListener);
 Event.observe(this.options.externalControl, 'mouseover', this.mouseoverListener);
 Event.observe(this.options.externalControl, 'mouseout', this.mouseoutListener);
 }
 },
 enterEditMode: function(evt) {
 if (this.saving) return;
 if (this.editing) return;
 this.editing = true;
 this.onEnterEditMode();
 if (this.options.externalControl) {
 Element.hide(this.options.externalControl);
 }
 Element.hide(this.element);
 this.createForm();
 this.element.parentNode.insertBefore(this.form, this.element);
 if (!this.options.loadTextURL) Field.scrollFreeActivate(this.editField);
 // stop the event to avoid a page refresh in Safari
 if (evt) {
 Event.stop(evt);
 }
 return false;
 },
 createForm: function() {
 this.form = document.createElement("form");
 this.form.id = this.options.formId;
 Element.addClassName(this.form, this.options.formClassName)
 this.form.onsubmit = this.onSubmit.bind(this);

 this.createEditField();

 if (this.options.textarea) {
 var br = document.createElement("br");
 this.form.appendChild(br);
 }
 
 if (this.options.textBeforeControls)
 this.form.appendChild(document.createTextNode(this.options.textBeforeControls));

 if (this.options.okButton) {
 var okButton = document.createElement("input");
 okButton.type = "submit";
 okButton.value = this.options.okText;
 okButton.className = 'editor_ok_button';
 this.form.appendChild(okButton);
 }
 
 if (this.options.okLink) {
 var okLink = document.createElement("a");
 okLink.href = "#";
 okLink.appendChild(document.createTextNode(this.options.okText));
 okLink.onclick = this.onSubmit.bind(this);
 okLink.className = 'editor_ok_link';
 this.form.appendChild(okLink);
 }
 
 if (this.options.textBetweenControls && 
 (this.options.okLink || this.options.okButton) && 
 (this.options.cancelLink || this.options.cancelButton))
 this.form.appendChild(document.createTextNode(this.options.textBetweenControls));
 
 if (this.options.cancelButton) {
 var cancelButton = document.createElement("input");
 cancelButton.type = "submit";
 cancelButton.value = this.options.cancelText;
 cancelButton.onclick = this.onclickCancel.bind(this);
 cancelButton.className = 'editor_cancel_button';
 this.form.appendChild(cancelButton);
 }

 if (this.options.cancelLink) {
 var cancelLink = document.createElement("a");
 cancelLink.href = "#";
 cancelLink.appendChild(document.createTextNode(this.options.cancelText));
 cancelLink.onclick = this.onclickCancel.bind(this);
 cancelLink.className = 'editor_cancel editor_cancel_link'; 
 this.form.appendChild(cancelLink);
 }
 
 if (this.options.textAfterControls)
 this.form.appendChild(document.createTextNode(this.options.textAfterControls));
 },
 hasHTMLLineBreaks: function(string) {
 if (!this.options.handleLineBreaks) return false;
 return string.match(/<br/i) || string.match(/<p>/i);
 },
 convertHTMLLineBreaks: function(string) {
 return string.replace(/<br>/gi, "\n").replace(/<br\/>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<p>/gi, "");
 },
 createEditField: function() {
 var text;
 if(this.options.loadTextURL) {
 text = this.options.loadingText;
 } else {
 text = this.getText();
 }

 var obj = this;
 
 if (this.options.rows == 1 && !this.hasHTMLLineBreaks(text)) {
 this.options.textarea = false;
 var textField = document.createElement("input");
 textField.obj = this;
 textField.type = "text";
 textField.name = this.options.paramName;
 textField.value = text;
 textField.style.backgroundColor = this.options.highlightcolor;
 textField.className = 'editor_field';
 var size = this.options.size || this.options.cols || 0;
 if (size != 0) textField.size = size;
 if (this.options.submitOnBlur)
 textField.onblur = this.onSubmit.bind(this);
 this.editField = textField;
 } else {
 this.options.textarea = true;
 var textArea = document.createElement("textarea");
 textArea.obj = this;
 textArea.name = this.options.paramName;
 textArea.value = this.convertHTMLLineBreaks(text);
 textArea.rows = this.options.rows;
 textArea.cols = this.options.cols || 40;
 textArea.className = 'editor_field'; 
 if (this.options.submitOnBlur)
 textArea.onblur = this.onSubmit.bind(this);
 this.editField = textArea;
 }
 
 if(this.options.loadTextURL) {
 this.loadExternalText();
 }
 this.form.appendChild(this.editField);
 },
 getText: function() {
 return this.element.innerHTML;
 },
 loadExternalText: function() {
 Element.addClassName(this.form, this.options.loadingClassName);
 this.editField.disabled = true;
 new Ajax.Request(
 this.options.loadTextURL,
 Object.extend({
 asynchronous: true,
 onComplete: this.onLoadedExternalText.bind(this)
 }, this.options.ajaxOptions)
 );
 },
 onLoadedExternalText: function(transport) {
 Element.removeClassName(this.form, this.options.loadingClassName);
 this.editField.disabled = false;
 this.editField.value = transport.responseText.stripTags();
 Field.scrollFreeActivate(this.editField);
 },
 onclickCancel: function() {
 this.onComplete();
 this.leaveEditMode();
 return false;
 },
 onFailure: function(transport) {
 this.options.onFailure(transport);
 if (this.oldInnerHTML) {
 this.element.innerHTML = this.oldInnerHTML;
 this.oldInnerHTML = null;
 }
 return false;
 },
 onSubmit: function() {
 // onLoading resets these so we need to save them away for the Ajax call
 var form = this.form;
 var value = this.editField.value;
 
 // do this first, sometimes the ajax call returns before we get a chance to switch on Saving...
 // which means this will actually switch on Saving... *after* we've left edit mode causing Saving...
 // to be displayed indefinitely
 this.onLoading();
 
 if (this.options.evalScripts) {
 new Ajax.Request(
 this.url, Object.extend({
 parameters: this.options.callback(form, value),
 onComplete: this.onComplete.bind(this),
 onFailure: this.onFailure.bind(this),
 asynchronous:true, 
 evalScripts:true
 }, this.options.ajaxOptions));
 } else {
 new Ajax.Updater(
 { success: this.element,
 // don't update on failure (this could be an option)
 failure: null }, 
 this.url, Object.extend({
 parameters: this.options.callback(form, value),
 onComplete: this.onComplete.bind(this),
 onFailure: this.onFailure.bind(this)
 }, this.options.ajaxOptions));
 }
 // stop the event to avoid a page refresh in Safari
 if (arguments.length > 1) {
 Event.stop(arguments[0]);
 }
 return false;
 },
 onLoading: function() {
 this.saving = true;
 this.removeForm();
 this.leaveHover();
 this.showSaving();
 },
 showSaving: function() {
 this.oldInnerHTML = this.element.innerHTML;
 this.element.innerHTML = this.options.savingText;
 Element.addClassName(this.element, this.options.savingClassName);
 this.element.style.backgroundColor = this.originalBackground;
 Element.show(this.element);
 },
 removeForm: function() {
 if(this.form) {
 if (this.form.parentNode) Element.remove(this.form);
 this.form = null;
 }
 },
 enterHover: function() {
 if (this.saving) return;
 this.element.style.backgroundColor = this.options.highlightcolor;
 if (this.effect) {
 this.effect.cancel();
 }
 Element.addClassName(this.element, this.options.hoverClassName)
 },
 leaveHover: function() {
 if (this.options.backgroundColor) {
 this.element.style.backgroundColor = this.oldBackground;
 }
 Element.removeClassName(this.element, this.options.hoverClassName)
 if (this.saving) return;
 this.effect = new Effect.Highlight(this.element, {
 startcolor: this.options.highlightcolor,
 endcolor: this.options.highlightendcolor,
 restorecolor: this.originalBackground
 });
 },
 leaveEditMode: function() {
 Element.removeClassName(this.element, this.options.savingClassName);
 this.removeForm();
 this.leaveHover();
 this.element.style.backgroundColor = this.originalBackground;
 Element.show(this.element);
 if (this.options.externalControl) {
 Element.show(this.options.externalControl);
 }
 this.editing = false;
 this.saving = false;
 this.oldInnerHTML = null;
 this.onLeaveEditMode();
 },
 onComplete: function(transport) {
 this.leaveEditMode();
 this.options.onComplete.bind(this)(transport, this.element);
 },
 onEnterEditMode: function() {},
 onLeaveEditMode: function() {},
 dispose: function() {
 if (this.oldInnerHTML) {
 this.element.innerHTML = this.oldInnerHTML;
 }
 this.leaveEditMode();
 Event.stopObserving(this.element, 'click', this.onclickListener);
 Event.stopObserving(this.element, 'mouseover', this.mouseoverListener);
 Event.stopObserving(this.element, 'mouseout', this.mouseoutListener);
 if (this.options.externalControl) {
 Event.stopObserving(this.options.externalControl, 'click', this.onclickListener);
 Event.stopObserving(this.options.externalControl, 'mouseover', this.mouseoverListener);
 Event.stopObserving(this.options.externalControl, 'mouseout', this.mouseoutListener);
 }
 }
};

Ajax.InPlaceCollectionEditor = Class.create();
Object.extend(Ajax.InPlaceCollectionEditor.prototype, Ajax.InPlaceEditor.prototype);
Object.extend(Ajax.InPlaceCollectionEditor.prototype, {
 createEditField: function() {
 if (!this.cached_selectTag) {
 var selectTag = document.createElement("select");
 var collection = this.options.collection || [];
 var optionTag;
 collection.each(function(e,i) {
 optionTag = document.createElement("option");
 optionTag.value = (e instanceof Array) ? e[0] : e;
 if((typeof this.options.value == 'undefined') && 
 ((e instanceof Array) ? this.element.innerHTML == e[1] : e == optionTag.value)) optionTag.selected = true;
 if(this.options.value==optionTag.value) optionTag.selected = true;
 optionTag.appendChild(document.createTextNode((e instanceof Array) ? e[1] : e));
 selectTag.appendChild(optionTag);
 }.bind(this));
 this.cached_selectTag = selectTag;
 }

 this.editField = this.cached_selectTag;
 if(this.options.loadTextURL) this.loadExternalText();
 this.form.appendChild(this.editField);
 this.options.callback = function(form, value) {
 return "value=" + encodeURIComponent(value);
 }
 }
});

// Delayed observer, like Form.Element.Observer, 
// but waits for delay after last key input
// Ideal for live-search fields

Form.Element.DelayedObserver = Class.create();
Form.Element.DelayedObserver.prototype = {
 initialize: function(element, delay, callback) {
 this.delay = delay || 0.5;
 this.element = $(element);
 this.callback = callback;
 this.timer = null;
 this.lastValue = $F(this.element); 
 Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
 },
 delayedListener: function(event) {
 if(this.lastValue == $F(this.element)) return;
 if(this.timer) clearTimeout(this.timer);
 this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
 this.lastValue = $F(this.element);
 },
 onTimerEvent: function() {
 this.timer = null;
 this.callback(this.element, $F(this.element));
 }
};

// script.aculo.us slider.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Marty Haught, Thomas Fuchs
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

if(!Control) var Control = {};
Control.Slider = Class.create();

// options:
// axis: 'vertical', or 'horizontal' (default)
//
// callbacks:
// onChange(value)
// onSlide(value)
Control.Slider.prototype = {
 initialize: function(handle, track, options) {
 var slider = this;

 if(handle instanceof Array) {
 this.handles = handle.collect( function(e) { return $(e) });
 } else {
 this.handles = [$(handle)];
 }

 this.track = $(track);
 this.options = options || {};

 this.axis = this.options.axis || 'horizontal';
 this.increment = this.options.increment || 1;
 this.step = parseInt(this.options.step || '1');
 this.range = this.options.range || $R(0,1);

 this.value = 0; // assure backwards compat
 this.values = this.handles.map( function() { return 0 });
 this.spans = this.options.spans ? this.options.spans.map(function(s){ return $(s) }) : false;
 this.options.startSpan = $(this.options.startSpan || null);
 this.options.endSpan = $(this.options.endSpan || null);

 this.restricted = this.options.restricted || false;

 this.maximum = this.options.maximum || this.range.end;
 this.minimum = this.options.minimum || this.range.start;

 // Will be used to align the handle onto the track, if necessary
 this.alignX = parseInt(this.options.alignX || '0');
 this.alignY = parseInt(this.options.alignY || '0');

 this.trackLength = this.maximumOffset() - this.minimumOffset();

 this.handleLength = this.isVertical() ?
 (this.handles[0].offsetHeight != 0 ?
 this.handles[0].offsetHeight : this.handles[0].style.height.replace(/px$/,"")) :
 (this.handles[0].offsetWidth != 0 ? this.handles[0].offsetWidth :
 this.handles[0].style.width.replace(/px$/,""));

 this.active = false;
 this.dragging = false;
 this.disabled = false;

 if(this.options.disabled) this.setDisabled();

 // Allowed values array
 this.allowedValues = this.options.values ? this.options.values.sortBy(Prototype.K) : false;
 if(this.allowedValues) {
 this.minimum = this.allowedValues.min();
 this.maximum = this.allowedValues.max();
 }

 this.eventMouseDown = this.startDrag.bindAsEventListener(this);
 this.eventMouseUp = this.endDrag.bindAsEventListener(this);
 this.eventMouseMove = this.update.bindAsEventListener(this);

 // Initialize handles in reverse (make sure first handle is active)
 this.handles.each( function(h,i) {
 i = slider.handles.length-1-i;
 slider.setValue(parseFloat(
 (slider.options.sliderValue instanceof Array ?
 slider.options.sliderValue[i] : slider.options.sliderValue) ||
 slider.range.start), i);
 Element.makePositioned(h); // fix IE
 Event.observe(h, "mousedown", slider.eventMouseDown);
 });

 Event.observe(this.track, "mousedown", this.eventMouseDown);
 Event.observe(document, "mouseup", this.eventMouseUp);
 Event.observe(this.track.parentNode.parentNode, "mousemove", this.eventMouseMove);

 this.initialized = true;
 },
 dispose: function() {
 var slider = this;
 Event.stopObserving(this.track, "mousedown", this.eventMouseDown);
 Event.stopObserving(document, "mouseup", this.eventMouseUp);
 Event.stopObserving(this.track.parentNode.parentNode, "mousemove", this.eventMouseMove);
 this.handles.each( function(h) {
 Event.stopObserving(h, "mousedown", slider.eventMouseDown);
 });
 },
 setDisabled: function(){
 this.disabled = true;
 },
 setEnabled: function(){
 this.disabled = false;
 },
 getNearestValue: function(value){
 if(this.allowedValues){
 if(value >= this.allowedValues.max()) return(this.allowedValues.max());
 if(value <= this.allowedValues.min()) return(this.allowedValues.min());

 var offset = Math.abs(this.allowedValues[0] - value);
 var newValue = this.allowedValues[0];
 this.allowedValues.each( function(v) {
 var currentOffset = Math.abs(v - value);
 if(currentOffset <= offset){
 newValue = v;
 offset = currentOffset;
 }
 });
 return newValue;
 }
 if(value > this.range.end) return this.range.end;
 if(value < this.range.start) return this.range.start;
 return value;
 },
 setValue: function(sliderValue, handleIdx){
 if(!this.active) {
 this.activeHandleIdx = handleIdx || 0;
 this.activeHandle = this.handles[this.activeHandleIdx];
 this.updateStyles();
 }
 handleIdx = handleIdx || this.activeHandleIdx || 0;
 if(this.initialized && this.restricted) {
 if((handleIdx>0) && (sliderValue<this.values[handleIdx-1]))
 sliderValue = this.values[handleIdx-1];
 if((handleIdx < (this.handles.length-1)) && (sliderValue>this.values[handleIdx+1]))
 sliderValue = this.values[handleIdx+1];
 }
 sliderValue = this.getNearestValue(sliderValue);
 this.values[handleIdx] = sliderValue;
 this.value = this.values[0]; // assure backwards compat

 this.handles[handleIdx].style[this.isVertical() ? 'top' : 'left'] =
 this.translateToPx(sliderValue);

 this.drawSpans();
 if(!this.dragging || !this.event) this.updateFinished();
 },
 setValueBy: function(delta, handleIdx) {
 this.setValue(this.values[handleIdx || this.activeHandleIdx || 0] + delta,
 handleIdx || this.activeHandleIdx || 0);
 },
 translateToPx: function(value) {
 return Math.round(
 ((this.trackLength-this.handleLength)/(this.range.end-this.range.start)) *
 (value - this.range.start)) + "px";
 },
 translateToValue: function(offset) {
 return ((offset/(this.trackLength-this.handleLength) *
 (this.range.end-this.range.start)) + this.range.start);
 },
 getRange: function(range) {
 var v = this.values.sortBy(Prototype.K);
 range = range || 0;
 return $R(v[range],v[range+1]);
 },
 minimumOffset: function(){
 return(this.isVertical() ? this.alignY : this.alignX);
 },
 maximumOffset: function(){
 return(this.isVertical() ?
 (this.track.offsetHeight != 0 ? this.track.offsetHeight :
 this.track.style.height.replace(/px$/,"")) - this.alignY :
 (this.track.offsetWidth != 0 ? this.track.offsetWidth :
 this.track.style.width.replace(/px$/,"")) - this.alignY);
 },
 isVertical: function(){
 return (this.axis == 'vertical');
 },
 drawSpans: function() {
 var slider = this;
 if(this.spans)
 $R(0, this.spans.length-1).each(function(r) { slider.setSpan(slider.spans[r], slider.getRange(r)) });
 if(this.options.startSpan)
 this.setSpan(this.options.startSpan,
 $R(0, this.values.length>1 ? this.getRange(0).min() : this.value ));
 if(this.options.endSpan)
 this.setSpan(this.options.endSpan,
 $R(this.values.length>1 ? this.getRange(this.spans.length-1).max() : this.value, this.maximum));
 },
 setSpan: function(span, range) {
 if(this.isVertical()) {
 span.style.top = this.translateToPx(range.start);
 span.style.height = this.translateToPx(range.end - range.start + this.range.start);
 } else {
 span.style.left = this.translateToPx(range.start);
 span.style.width = this.translateToPx(range.end - range.start + this.range.start);
 }
 },
 updateStyles: function() {
 this.handles.each( function(h){ Element.removeClassName(h, 'selected') });
 Element.addClassName(this.activeHandle, 'selected');
 },
 startDrag: function(event) {
 if(Event.isLeftClick(event)) {
 if(!this.disabled){
 this.active = true;

 var handle = Event.element(event);
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var track = handle;
 if(track==this.track) {
 var offsets = Position.cumulativeOffset(this.track);
 this.event = event;
 this.setValue(this.translateToValue(
 (this.isVertical() ? pointer[1]-offsets[1] : pointer[0]-offsets[0])-(this.handleLength/2)
 ));
 var offsets = Position.cumulativeOffset(this.activeHandle);
 this.offsetX = (pointer[0] - offsets[0]);
 this.offsetY = (pointer[1] - offsets[1]);
 } else {
 // find the handle (prevents issues with Safari)
 while((this.handles.indexOf(handle) == -1) && handle.parentNode)
 handle = handle.parentNode;

 if(this.handles.indexOf(handle)!=-1) {
 this.activeHandle = handle;
 this.activeHandleIdx = this.handles.indexOf(this.activeHandle);
 this.updateStyles();

 var offsets = Position.cumulativeOffset(this.activeHandle);
 this.offsetX = (pointer[0] - offsets[0]);
 this.offsetY = (pointer[1] - offsets[1]);
 }
 }
 }
 Event.stop(event);
 }
 },
 update: function(event) {
 if(this.active) {
 if(!this.dragging) this.dragging = true;
 this.draw(event);
 if(Prototype.Browser.WebKit) window.scrollBy(0,0);
 Event.stop(event);
 }
 },
 draw: function(event) {
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var offsets = Position.cumulativeOffset(this.track);
 pointer[0] -= this.offsetX + offsets[0];
 pointer[1] -= this.offsetY + offsets[1];
 this.event = event;
 this.setValue(this.translateToValue( this.isVertical() ? pointer[1] : pointer[0] ));
 if(this.initialized && this.options.onSlide)
 this.options.onSlide(this.values.length>1 ? this.values : this.value, this);
 },
 endDrag: function(event) {
 if(this.active && this.dragging) {
 this.finishDrag(event, true);
 Event.stop(event);
 }
 this.active = false;
 this.dragging = false;
 },
 finishDrag: function(event, success) {
 this.active = false;
 this.dragging = false;
 this.updateFinished();
 },
 updateFinished: function() {
 if(this.initialized && this.options.onChange)
 this.options.onChange(this.values.length>1 ? this.values : this.value, this);
 this.event = null;
 }
}
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */
function popWin(url,win,para) {
 var win = window.open(url,win,para);
 win.focus();
}

function setLocation(url){
 window.location.href = url;
}

function setPLocation(url, setFocus){
 if( setFocus ) {
 window.opener.focus();
 }
 window.opener.location.href = url;
}

function setLanguageCode(code, fromCode){
 //TODO: javascript cookies have different domain and path than php cookies
 var href = window.location.href;
 var after = '', dash;
 if (dash = href.match(/\#(.*)$/)) {
 href = href.replace(/\#(.*)$/, '');
 after = dash[0];
 }

 if (href.match(/[?]/)) {
 var re = /([?&]store=)[a-z0-9_]*/;
 if (href.match(re)) {
 href = href.replace(re, '$1'+code);
 } else {
 href += '&store='+code;
 }

 var re = /([?&]from_store=)[a-z0-9_]*/;
 if (href.match(re)) {
 href = href.replace(re, '');
 }
 } else {
 href += '?store='+code;
 }
 if (typeof(fromCode) != 'undefined') {
 href += '&from_store='+fromCode;
 }
 href += after;

 setLocation(href);
}

/**
 * Add classes to specified elements.
 * Supported classes are: 'odd', 'even', 'first', 'last'
 *
 * @param elements - array of elements to be decorated
 * [@param decorateParams] - array of classes to be set. If omitted, all available will be used
 */
function decorateGeneric(elements, decorateParams)
{
 var allSupportedParams = ['odd', 'even', 'first', 'last'];
 var _decorateParams = {};
 var total = elements.length;

 if (total) {
 // determine params called
 if (typeof(decorateParams) == 'undefined') {
 decorateParams = allSupportedParams;
 }
 if (!decorateParams.length) {
 return;
 }
 for (var k in allSupportedParams) {
 _decorateParams[allSupportedParams[k]] = false;
 }
 for (var k in decorateParams) {
 _decorateParams[decorateParams[k]] = true;
 }

 // decorate elements
 // elements[0].addClassName('first'); // will cause bug in IE (#5587)
 if (_decorateParams.first) {
 Element.addClassName(elements[0], 'first');
 }
 if (_decorateParams.last) {
 Element.addClassName(elements[total-1], 'last');
 }
 for (var i = 0; i < total; i++) {
 if ((i + 1) % 2 == 0) {
 if (_decorateParams.even) {
 Element.addClassName(elements[i], 'even');
 }
 }
 else {
 if (_decorateParams.odd) {
 Element.addClassName(elements[i], 'odd');
 }
 }
 }
 }
}

/**
 * Decorate table rows and cells, tbody etc
 * @see decorateGeneric()
 */
function decorateTable(table, options) {
 var table = $(table);
 if (table) {
 // set default options
 var _options = {
 'tbody' : false,
 'tbody tr' : ['odd', 'even', 'first', 'last'],
 'thead tr' : ['first', 'last'],
 'tfoot tr' : ['first', 'last'],
 'tr td' : ['last']
 };
 // overload options
 if (typeof(options) != 'undefined') {
 for (var k in options) {
 _options[k] = options[k];
 }
 }
 // decorate
 if (_options['tbody']) {
 decorateGeneric(table.select('tbody'), _options['tbody']);
 }
 if (_options['tbody tr']) {
 decorateGeneric(table.select('tbody tr'), _options['tbody tr']);
 }
 if (_options['thead tr']) {
 decorateGeneric(table.select('thead tr'), _options['thead tr']);
 }
 if (_options['tfoot tr']) {
 decorateGeneric(table.select('tfoot tr'), _options['tfoot tr']);
 }
 if (_options['tr td']) {
 var allRows = table.select('tr');
 if (allRows.length) {
 for (var i = 0; i < allRows.length; i++) {
 decorateGeneric(allRows[i].getElementsByTagName('TD'), _options['tr td']);
 }
 }
 }
 }
}

/**
 * Set "odd", "even" and "last" CSS classes for list items
 * @see decorateGeneric()
 */
function decorateList(list, nonRecursive) {
 if ($(list)) {
 if (typeof(nonRecursive) == 'undefined') {
 var items = $(list).select('li')
 }
 else {
 var items = $(list).childElements();
 }
 decorateGeneric(items, ['odd', 'even', 'last']);
 }
}

/**
 * Set "odd", "even" and "last" CSS classes for list items
 * @see decorateGeneric()
 */
function decorateDataList(list) {
 list = $(list);
 if (list) {
 decorateGeneric(list.select('dt'), ['odd', 'even', 'last']);
 decorateGeneric(list.select('dd'), ['odd', 'even', 'last']);
 }
}

/**
 * Formats currency using patern
 * format - JSON (pattern, decimal, decimalsDelimeter, groupsDelimeter)
 * showPlus - true (always show '+'or '-'),
 * false (never show '-' even if number is negative)
 * null (show '-' if number is negative)
 */

function formatCurrency(price, format, showPlus){
 precision = isNaN(format.precision = Math.abs(format.precision)) ? 2 : format.precision;
 requiredPrecision = isNaN(format.requiredPrecision = Math.abs(format.requiredPrecision)) ? 2 : format.requiredPrecision;

 //precision = (precision > requiredPrecision) ? precision : requiredPrecision;
 //for now we don't need this difference so precision is requiredPrecision
 precision = requiredPrecision;

 integerRequired = isNaN(format.integerRequired = Math.abs(format.integerRequired)) ? 1 : format.integerRequired;

 decimalSymbol = format.decimalSymbol == undefined ? "," : format.decimalSymbol;
 groupSymbol = format.groupSymbol == undefined ? "." : format.groupSymbol;
 groupLength = format.groupLength == undefined ? 3 : format.groupLength;

 if (showPlus == undefined || showPlus == true) {
 s = price < 0 ? "-" : ( showPlus ? "+" : "");
 } else if (showPlus == false) {
 s = '';
 }

 i = parseInt(price = Math.abs(+price || 0).toFixed(precision)) + "";
 pad = (i.length < integerRequired) ? (integerRequired - i.length) : 0;
 while (pad) { i = '0' + i; pad--; }

 j = (j = i.length) > groupLength ? j % groupLength : 0;
 re = new RegExp("(\\d{" + groupLength + "})(?=\\d)", "g");

 /**
 * replace(/-/, 0) is only for fixing Safari bug which appears
 * when Math.abs(0).toFixed() executed on "0" number.
 * Result is "0.-0" :(
 */
 r = (j ? i.substr(0, j) + groupSymbol : "") + i.substr(j).replace(re, "$1" + groupSymbol) + (precision ? decimalSymbol + Math.abs(price - i).toFixed(precision).replace(/-/, 0).slice(2) : "")

 if (format.pattern.indexOf('{sign}') == -1) {
 pattern = s + format.pattern;
 } else {
 pattern = format.pattern.replace('{sign}', s);
 }

 return pattern.replace('%s', r).replace(/^\s\s*/, '').replace(/\s\s*$/, '');
};

function expandDetails(el, childClass) {
 if (Element.hasClassName(el,'show-details')) {
 $$(childClass).each(function(item){item.hide()});
 Element.removeClassName(el,'show-details');
 }
 else {
 $$(childClass).each(function(item){item.show()});
 Element.addClassName(el,'show-details');
 }
}

// Version 1.0
var isIE = navigator.appVersion.match(/MSIE/) == "MSIE";

if (!window.Varien)
 var Varien = new Object();

Varien.showLoading = function(){
 Element.show('loading-process');
}
Varien.hideLoading = function(){
 Element.hide('loading-process');
}
Varien.GlobalHandlers = {
 onCreate: function() {
 Varien.showLoading();
 },

 onComplete: function() {
 if(Ajax.activeRequestCount == 0) {
 Varien.hideLoading();
 }
 }
};

Ajax.Responders.register(Varien.GlobalHandlers);

/**
 * Quick Search form client model
 */
Varien.searchForm = Class.create();
Varien.searchForm.prototype = {
 initialize : function(form, field, emptyText){
 this.form = $(form);
 this.field = $(field);
 this.emptyText = emptyText;

 Event.observe(this.form, 'submit', this.submit.bind(this));
 Event.observe(this.field, 'focus', this.focus.bind(this));
 Event.observe(this.field, 'blur', this.blur.bind(this));
 this.blur();
 },

 submit : function(event){
 if (this.field.value == this.emptyText || this.field.value == ''){
 Event.stop(event);
 return false;
 }
 return true;
 },

 focus : function(event){
 if(this.field.value==this.emptyText){
 this.field.value='';
 }

 },

 blur : function(event){
 if(this.field.value==''){
 this.field.value=this.emptyText;
 }
 },

 initAutocomplete : function(url, destinationElement){
 new Ajax.Autocompleter(
 this.field,
 destinationElement,
 url,
 {
 paramName: this.field.name,
 minChars: 2,
 updateElement: this._selectAutocompleteItem.bind(this),
 onShow : function(element, update) { 
 if(!update.style.position || update.style.position=='absolute') {
 update.style.position = 'absolute';
 Position.clone(element, update, {
 setHeight: false, 
 offsetTop: element.offsetHeight
 });
 }
 Effect.Appear(update,{duration:0});
 }

 }
 );
 },

 _selectAutocompleteItem : function(element){
 if(element.title){
 this.field.value = element.title;
 }
 this.form.submit();
 }
}

Varien.Tabs = Class.create();
Varien.Tabs.prototype = {
 initialize: function(selector) {
 var self=this;
 $$(selector+' a').each(this.initTab.bind(this));
 },

 initTab: function(el) {
 el.href = 'javascript:void(0)';
 if ($(el.parentNode).hasClassName('active')) {
 this.showContent(el);
 }
 el.observe('click', this.showContent.bind(this, el));
 },

 showContent: function(a) {
 var li = $(a.parentNode), ul = $(li.parentNode);
 ul.getElementsBySelector('li', 'ol').each(function(el){
 var contents = $(el.id+'_contents');
 if (el==li) {
 el.addClassName('active');
 contents.show();
 } else {
 el.removeClassName('active');
 contents.hide();
 }
 });
 }
}

Varien.DOB = Class.create();
Varien.DOB.prototype = {
 initialize: function(selector, required, format) {
 var el = $$(selector)[0];
 this.day = Element.select($(el), '.dob-day input')[0];
 this.month = Element.select($(el), '.dob-month input')[0];
 this.year = Element.select($(el), '.dob-year input')[0];
 this.dob = Element.select($(el), '.dob-full input')[0];
 this.advice = Element.select($(el), '.validation-advice')[0];
 this.required = required;
 this.format = format;

 this.day.validate = this.validate.bind(this);
 this.month.validate = this.validate.bind(this);
 this.year.validate = this.validate.bind(this);

 this.advice.hide();
 },

 validate: function() {
 var error = false;

 if (this.day.value=='' && this.month.value=='' && this.year.value=='') {
 if (this.required) {
 error = 'This date is a required value.';
 } else {
 this.dob.value = '';
 }
 } else if (this.day.value=='' || this.month.value=='' || this.year.value=='') {
 error = 'Please enter a valid full date.';
 } else {
 var date = new Date();
 if (this.day.value<1 || this.day.value>31) {
 error = 'Please enter a valid day (1-31).';
 } else if (this.month.value<1 || this.month.value>12) {
 error = 'Please enter a valid month (1-12).';
 } else if (this.year.value<1900 || this.year.value>date.getFullYear()) {
 error = 'Please enter a valid year (1900-'+date.getFullYear()+').';
 } else {
 this.dob.value = this.format.replace(/(%m|%b)/i, this.month.value).replace(/(%d|%e)/i, this.day.value).replace(/%y/i, this.year.value);
 var testDOB = this.month.value + '/' + this.day.value + '/'+ this.year.value;
 var test = new Date(testDOB);
 if (isNaN(test)) {
 error = 'Please enter a valid date.';
 }
 }
 }

 if (error !== false) {
 try {
 this.advice.innerHTML = Translator.translate(error);
 }
 catch (e) {
 this.advice.innerHTML = error;
 }
 this.advice.show();
 return false;
 }

 this.advice.hide();
 return true;
 }
}

Validation.addAllThese([
 ['validate-custom', ' ', function(v,elm) {
 return elm.validate();
 }]
]);

function truncateOptions() {
 $$('.truncated').each(function(element){
 Event.observe(element, 'mouseover', function(){
 if (element.down('div.truncated_full_value')) {
 element.down('div.truncated_full_value').addClassName('show')
 }
 });
 Event.observe(element, 'mouseout', function(){
 if (element.down('div.truncated_full_value')) {
 element.down('div.truncated_full_value').removeClassName('show')
 }
 });

 });
}
Event.observe(window, 'load', function(){
 truncateOptions();
});
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */
VarienForm = Class.create();
VarienForm.prototype = {
 initialize: function(formId, firstFieldFocus){
 this.form = $(formId);
 if (!this.form) {
 return;
 }
 this.cache = $A();
 this.currLoader = false;
 this.currDataIndex = false;
 this.validator = new Validation(this.form);
 this.elementFocus = this.elementOnFocus.bindAsEventListener(this);
 this.elementBlur = this.elementOnBlur.bindAsEventListener(this);
 this.childLoader = this.onChangeChildLoad.bindAsEventListener(this);
 this.highlightClass = 'highlight';
 this.extraChildParams = '';
 this.firstFieldFocus= firstFieldFocus || false;
 this.bindElements();
 if(this.firstFieldFocus){
 try{
 Form.Element.focus(Form.findFirstElement(this.form))
 }
 catch(e){}
 }
 },

 submit : function(url){
 if(this.validator && this.validator.validate()){
 this.form.submit();
 }
 return false;
 },

 bindElements:function (){
 var elements = Form.getElements(this.form);
 for (var row in elements) {
 if (elements[row].id) {
 Event.observe(elements[row],'focus',this.elementFocus);
 Event.observe(elements[row],'blur',this.elementBlur);
 }
 }
 },

 elementOnFocus: function(event){
 var element = Event.findElement(event, 'fieldset');
 if(element){
 Element.addClassName(element, this.highlightClass);
 }
 },

 elementOnBlur: function(event){
 var element = Event.findElement(event, 'fieldset');
 if(element){
 Element.removeClassName(element, this.highlightClass);
 }
 },

 setElementsRelation: function(parent, child, dataUrl, first){
 if (parent=$(parent)) {
 // TODO: array of relation and caching
 if (!this.cache[parent.id]){
 this.cache[parent.id] = $A();
 this.cache[parent.id]['child'] = child;
 this.cache[parent.id]['dataUrl'] = dataUrl;
 this.cache[parent.id]['data'] = $A();
 this.cache[parent.id]['first'] = first || false;
 }
 Event.observe(parent,'change',this.childLoader);
 }
 },

 onChangeChildLoad: function(event){
 element = Event.element(event);
 this.elementChildLoad(element);
 },

 elementChildLoad: function(element, callback){
 this.callback = callback || false;
 if (element.value) {
 this.currLoader = element.id;
 this.currDataIndex = element.value;
 if (this.cache[element.id]['data'][element.value]) {
 this.setDataToChild(this.cache[element.id]['data'][element.value]);
 }
 else{
 new Ajax.Request(this.cache[this.currLoader]['dataUrl'],{
 method: 'post',
 parameters: {"parent":element.value},
 onComplete: this.reloadChildren.bind(this)
 });
 }
 }
 },

 reloadChildren: function(transport){
 var data = eval('(' + transport.responseText + ')');
 this.cache[this.currLoader]['data'][this.currDataIndex] = data;
 this.setDataToChild(data);
 },

 setDataToChild: function(data){
 if (data.length) {
 var child = $(this.cache[this.currLoader]['child']);
 if (child){
 var html = '<select name="'+child.name+'" id="'+child.id+'" class="'+child.className+'" title="'+child.title+'" '+this.extraChildParams+'>';
 if(this.cache[this.currLoader]['first']){
 html+= '<option value="">'+this.cache[this.currLoader]['first']+'</option>';
 }
 for (var i in data){
 if(data[i].value) {
 html+= '<option value="'+data[i].value+'"';
 if(child.value && (child.value == data[i].value || child.value == data[i].label)){
 html+= ' selected';
 }
 html+='>'+data[i].label+'</option>';
 }
 }
 html+= '</select>';
 Element.insert(child, {before: html});
 Element.remove(child);
 }
 }
 else{
 var child = $(this.cache[this.currLoader]['child']);
 if (child){
 var html = '<input type="text" name="'+child.name+'" id="'+child.id+'" class="'+child.className+'" title="'+child.title+'" '+this.extraChildParams+'>';
 Element.insert(child, {before: html});
 Element.remove(child);
 }
 }

 this.bindElements();
 if (this.callback) {
 this.callback();
 }
 }
}

RegionUpdater = Class.create();
RegionUpdater.prototype = {
 initialize: function (countryEl, regionTextEl, regionSelectEl, regions, disableAction)
 {
 this.countryEl = $(countryEl);
 this.regionTextEl = $(regionTextEl);
 this.regionSelectEl = $(regionSelectEl);
 this.regions = regions;

 this.disableAction = (typeof disableAction=='undefined') ? 'hide' : disableAction;

 if (this.regionSelectEl.options.length<=1) {
 this.update();
 }

 Event.observe(this.countryEl, 'change', this.update.bind(this));
 },

 update: function()
 {
 if (this.regions[this.countryEl.value]) {
 var i, option, region, def;

 if (this.regionTextEl) {
 def = this.regionTextEl.value.toLowerCase();
 this.regionTextEl.value = '';
 }
 if (!def) {
 def = this.regionSelectEl.getAttribute('defaultValue');
 }

 this.regionSelectEl.options.length = 1;
 for (regionId in this.regions[this.countryEl.value]) {
 region = this.regions[this.countryEl.value][regionId];

 option = document.createElement('OPTION');
 option.value = regionId;
 option.text = region.name;

 if (this.regionSelectEl.options.add) {
 this.regionSelectEl.options.add(option);
 } else {
 this.regionSelectEl.appendChild(option);
 }

 if (regionId==def || region.name.toLowerCase()==def || region.code.toLowerCase()==def) {
 this.regionSelectEl.value = regionId;
 }
 }

 if (this.disableAction=='hide') {
 if (this.regionTextEl) {
 this.regionTextEl.style.display = 'none';
 }

 this.regionSelectEl.style.display = '';
 } else if (this.disableAction=='disable') {
 if (this.regionTextEl) {
 this.regionTextEl.disabled = true;
 }
 this.regionSelectEl.disabled = false;
 }
 this.setMarkDisplay(this.regionSelectEl, true);
 } else {
 if (this.disableAction=='hide') {
 if (this.regionTextEl) {
 this.regionTextEl.style.display = '';
 }
 this.regionSelectEl.style.display = 'none';
 Validation.reset(this.regionSelectEl);
 } else if (this.disableAction=='disable') {
 if (this.regionTextEl) {
 this.regionTextEl.disabled = false;
 }
 this.regionSelectEl.disabled = true;
 } else if (this.disableAction=='nullify') {
 this.regionSelectEl.options.length = 1;
 this.regionSelectEl.value = '';
 this.regionSelectEl.selectedIndex = 0;
 this.lastCountryId = '';
 }
 this.setMarkDisplay(this.regionSelectEl, false);
 }
 },

 setMarkDisplay: function(elem, display){
 elem = $(elem);
 var labelElement = elem.up(1).down('label > span.required') || 
 elem.up(2).down('label > span.required') ||
 elem.up(1).down('label.required > em') ||
 elem.up(2).down('label.required > em');
 if(labelElement) {
 display ? labelElement.show() : labelElement.hide();
 }
 }
}
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */
function toggleMenu(el, over)
{
 if (over) {
 Element.addClassName(el, 'over');
 }
 else {
 Element.removeClassName(el, 'over');
 }
}

/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @category Mage
 * @package Js
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */

var Translate = Class.create();
Translate.prototype = {
 initialize: function(data){
 this.data = $H(data);
 },

 translate : function(){
 var args = arguments;
 var text = arguments[0];

 if(this.data.get(text)){
 return this.data.get(text);
 }
 return text;
 },
 add : function() {
 if (arguments.length > 1) {
 this.data.set(arguments[0], arguments[1]);
 } else if (typeof arguments[0] =='object') {
 $H(arguments[0]).each(function (pair){
 this.data.set(pair.key, pair.value);
 }.bind(this));
 }
 }
}
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */
// old school cookie functions grabbed off the web

if (!window.Mage) var Mage = {};

Mage.Cookies = {};
Mage.Cookies.set = function(name, value){
 var argv = arguments;
 var argc = arguments.length;
 var expires = (argc > 2) ? argv[2] : null;
 var path = (argc > 3) ? argv[3] : '/';
 var domain = (argc > 4) ? argv[4] : null;
 var secure = (argc > 5) ? argv[5] : false;
 document.cookie = name + "=" + escape (value) +
 ((expires == null) ? "" : ("; expires=" + expires.toGMTString())) +
 ((path == null) ? "" : ("; path=" + path)) +
 ((domain == null) ? "" : ("; domain=" + domain)) +
 ((secure == true) ? "; secure" : "");
};

Mage.Cookies.get = function(name){
 var arg = name + "=";
 var alen = arg.length;
 var clen = document.cookie.length;
 var i = 0;
 var j = 0;
 while(i < clen){
 j = i + alen;
 if (document.cookie.substring(i, j) == arg)
 return Mage.Cookies.getCookieVal(j);
 i = document.cookie.indexOf(" ", i) + 1;
 if(i == 0)
 break;
 }
 return null;
};

Mage.Cookies.clear = function(name) {
 if(Mage.Cookies.get(name)){
 document.cookie = name + "=" +
 "; expires=Thu, 01-Jan-70 00:00:01 GMT";
 }
};

Mage.Cookies.getCookieVal = function(offset){
 var endstr = document.cookie.indexOf(";", offset);
 if(endstr == -1){
 endstr = document.cookie.length;
 }
 return unescape(document.cookie.substring(offset, endstr));
};
(function(){
/*
 * jQuery 1.2.6 - New Wave Javascript
 *
 * Copyright (c) 2008 John Resig (jquery.com)
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.
 *
 * $Date: 2008-05-24 14:22:17 -0400 (Sat, 24 May 2008) $
 * $Rev: 5685 $
 */

// Map over jQuery in case of overwrite
var _jQuery = window.jQuery,
// Map over the $ in case of overwrite
 _$ = window.$;

var jQuery = window.jQuery = window.$ = function( selector, context ) {
 // The jQuery object is actually just the init constructor 'enhanced'
 return new jQuery.fn.init( selector, context );
};

// A simple way to check for HTML strings or ID strings
// (both of which we optimize for)
var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/,

// Is it a simple selector
 isSimple = /^.[^:#\[\.]*$/,

// Will speed up references to undefined, and allows munging its name.
 undefined;

jQuery.fn = jQuery.prototype = {
 init: function( selector, context ) {
 // Make sure that a selection was provided
 selector = selector || document;

 // Handle $(DOMElement)
 if ( selector.nodeType ) {
 this[0] = selector;
 this.length = 1;
 return this;
 }
 // Handle HTML strings
 if ( typeof selector == "string" ) {
 // Are we dealing with HTML string or an ID?
 var match = quickExpr.exec( selector );

 // Verify a match, and that no context was specified for #id
 if ( match && (match[1] || !context) ) {

 // HANDLE: $(html) -> $(array)
 if ( match[1] )
 selector = jQuery.clean( [ match[1] ], context );

 // HANDLE: $("#id")
 else {
 var elem = document.getElementById( match[3] );

 // Make sure an element was located
 if ( elem ){
 // Handle the case where IE and Opera return items
 // by name instead of ID
 if ( elem.id != match[3] )
 return jQuery().find( selector );

 // Otherwise, we inject the element directly into the jQuery object
 return jQuery( elem );
 }
 selector = [];
 }

 // HANDLE: $(expr, [context])
 // (which is just equivalent to: $(content).find(expr)
 } else
 return jQuery( context ).find( selector );

 // HANDLE: $(function)
 // Shortcut for document ready
 } else if ( jQuery.isFunction( selector ) )
 return jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );

 return this.setArray(jQuery.makeArray(selector));
 },

 // The current version of jQuery being used
 jquery: "1.2.6",

 // The number of elements contained in the matched element set
 size: function() {
 return this.length;
 },

 // The number of elements contained in the matched element set
 length: 0,

 // Get the Nth element in the matched element set OR
 // Get the whole matched element set as a clean array
 get: function( num ) {
 return num == undefined ?

 // Return a 'clean' array
 jQuery.makeArray( this ) :

 // Return just the object
 this[ num ];
 },

 // Take an array of elements and push it onto the stack
 // (returning the new matched element set)
 pushStack: function( elems ) {
 // Build a new jQuery matched element set
 var ret = jQuery( elems );

 // Add the old object onto the stack (as a reference)
 ret.prevObject = this;

 // Return the newly-formed element set
 return ret;
 },

 // Force the current matched set of elements to become
 // the specified array of elements (destroying the stack in the process)
 // You should use pushStack() in order to do this, but maintain the stack
 setArray: function( elems ) {
 // Resetting the length to 0, then using the native Array push
 // is a super-fast way to populate an object with array-like properties
 this.length = 0;
 Array.prototype.push.apply( this, elems );

 return this;
 },

 // Execute a callback for every element in the matched set.
 // (You can seed the arguments with an array of args, but this is
 // only used internally.)
 each: function( callback, args ) {
 return jQuery.each( this, callback, args );
 },

 // Determine the position of an element within
 // the matched set of elements
 index: function( elem ) {
 var ret = -1;

 // Locate the position of the desired element
 return jQuery.inArray(
 // If it receives a jQuery object, the first element is used
 elem && elem.jquery ? elem[0] : elem
 , this );
 },

 attr: function( name, value, type ) {
 var options = name;

 // Look for the case where we're accessing a style value
 if ( name.constructor == String )
 if ( value === undefined )
 return this[0] && jQuery[ type || "attr" ]( this[0], name );

 else {
 options = {};
 options[ name ] = value;
 }

 // Check to see if we're setting style values
 return this.each(function(i){
 // Set all the styles
 for ( name in options )
 jQuery.attr(
 type ?
 this.style :
 this,
 name, jQuery.prop( this, options[ name ], type, i, name )
 );
 });
 },

 css: function( key, value ) {
 // ignore negative width and height values
 if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
 value = undefined;
 return this.attr( key, value, "curCSS" );
 },

 text: function( text ) {
 if ( typeof text != "object" && text != null )
 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );

 var ret = "";

 jQuery.each( text || this, function(){
 jQuery.each( this.childNodes, function(){
 if ( this.nodeType != 8 )
 ret += this.nodeType != 1 ?
 this.nodeValue :
 jQuery.fn.text( [ this ] );
 });
 });

 return ret;
 },

 wrapAll: function( html ) {
 if ( this[0] )
 // The elements to wrap the target around
 jQuery( html, this[0].ownerDocument )
 .clone()
 .insertBefore( this[0] )
 .map(function(){
 var elem = this;

 while ( elem.firstChild )
 elem = elem.firstChild;

 return elem;
 })
 .append(this);

 return this;
 },

 wrapInner: function( html ) {
 return this.each(function(){
 jQuery( this ).contents().wrapAll( html );
 });
 },

 wrap: function( html ) {
 return this.each(function(){
 jQuery( this ).wrapAll( html );
 });
 },

 append: function() {
 return this.domManip(arguments, true, false, function(elem){
 if (this.nodeType == 1)
 this.appendChild( elem );
 });
 },

 prepend: function() {
 return this.domManip(arguments, true, true, function(elem){
 if (this.nodeType == 1)
 this.insertBefore( elem, this.firstChild );
 });
 },

 before: function() {
 return this.domManip(arguments, false, false, function(elem){
 this.parentNode.insertBefore( elem, this );
 });
 },

 after: function() {
 return this.domManip(arguments, false, true, function(elem){
 this.parentNode.insertBefore( elem, this.nextSibling );
 });
 },

 end: function() {
 return this.prevObject || jQuery( [] );
 },

 find: function( selector ) {
 var elems = jQuery.map(this, function(elem){
 return jQuery.find( selector, elem );
 });

 return this.pushStack( /[^+>] [^+>]/.test( selector ) || selector.indexOf("..") > -1 ?
 jQuery.unique( elems ) :
 elems );
 },

 clone: function( events ) {
 // Do the clone
 var ret = this.map(function(){
 if ( jQuery.browser.msie && !jQuery.isXMLDoc(this) ) {
 // IE copies events bound via attachEvent when
 // using cloneNode. Calling detachEvent on the
 // clone will also remove the events from the orignal
 // In order to get around this, we use innerHTML.
 // Unfortunately, this means some modifications to
 // attributes in IE that are actually only stored
 // as properties will not be copied (such as the
 // the name attribute on an input).
 var clone = this.cloneNode(true),
 container = document.createElement("div");
 container.appendChild(clone);
 return jQuery.clean([container.innerHTML])[0];
 } else
 return this.cloneNode(true);
 });

 // Need to set the expando to null on the cloned set if it exists
 // removeData doesn't work here, IE removes it from the original as well
 // this is primarily for IE but the data expando shouldn't be copied over in any browser
 var clone = ret.find("*").andSelf().each(function(){
 if ( this[ expando ] != undefined )
 this[ expando ] = null;
 });

 // Copy the events from the original to the clone
 if ( events === true )
 this.find("*").andSelf().each(function(i){
 if (this.nodeType == 3)
 return;
 var events = jQuery.data( this, "events" );

 for ( var type in events )
 for ( var handler in events[ type ] )
 jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
 });

 // Return the cloned set
 return ret;
 },

 filter: function( selector ) {
 return this.pushStack(
 jQuery.isFunction( selector ) &&
 jQuery.grep(this, function(elem, i){
 return selector.call( elem, i );
 }) ||

 jQuery.multiFilter( selector, this ) );
 },

 not: function( selector ) {
 if ( selector.constructor == String )
 // test special case where just one selector is passed in
 if ( isSimple.test( selector ) )
 return this.pushStack( jQuery.multiFilter( selector, this, true ) );
 else
 selector = jQuery.multiFilter( selector, this );

 var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
 return this.filter(function() {
 return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
 });
 },

 add: function( selector ) {
 return this.pushStack( jQuery.unique( jQuery.merge(
 this.get(),
 typeof selector == 'string' ?
 jQuery( selector ) :
 jQuery.makeArray( selector )
 )));
 },

 is: function( selector ) {
 return !!selector && jQuery.multiFilter( selector, this ).length > 0;
 },

 hasClass: function( selector ) {
 return this.is( "." + selector );
 },

 val: function( value ) {
 if ( value == undefined ) {

 if ( this.length ) {
 var elem = this[0];

 // We need to handle select boxes special
 if ( jQuery.nodeName( elem, "select" ) ) {
 var index = elem.selectedIndex,
 values = [],
 options = elem.options,
 one = elem.type == "select-one";

 // Nothing was selected
 if ( index < 0 )
 return null;

 // Loop through all the selected options
 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
 var option = options[ i ];

 if ( option.selected ) {
 // Get the specifc value for the option
 value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;

 // We don't need an array for one selects
 if ( one )
 return value;

 // Multi-Selects return an array
 values.push( value );
 }
 }

 return values;

 // Everything else, we just grab the value
 } else
 return (this[0].value || "").replace(/\r/g, "");

 }

 return undefined;
 }

 if( value.constructor == Number )
 value += '';

 return this.each(function(){
 if ( this.nodeType != 1 )
 return;

 if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
 this.checked = (jQuery.inArray(this.value, value) >= 0 ||
 jQuery.inArray(this.name, value) >= 0);

 else if ( jQuery.nodeName( this, "select" ) ) {
 var values = jQuery.makeArray(value);

 jQuery( "option", this ).each(function(){
 this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
 jQuery.inArray( this.text, values ) >= 0);
 });

 if ( !values.length )
 this.selectedIndex = -1;

 } else
 this.value = value;
 });
 },

 html: function( value ) {
 return value == undefined ?
 (this[0] ?
 this[0].innerHTML :
 null) :
 this.empty().append( value );
 },

 replaceWith: function( value ) {
 return this.after( value ).remove();
 },

 eq: function( i ) {
 return this.slice( i, i + 1 );
 },

 slice: function() {
 return this.pushStack( Array.prototype.slice.apply( this, arguments ) );
 },

 map: function( callback ) {
 return this.pushStack( jQuery.map(this, function(elem, i){
 return callback.call( elem, i, elem );
 }));
 },

 andSelf: function() {
 return this.add( this.prevObject );
 },

 data: function( key, value ){
 var parts = key.split(".");
 parts[1] = parts[1] ? "." + parts[1] : "";

 if ( value === undefined ) {
 var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);

 if ( data === undefined && this.length )
 data = jQuery.data( this[0], key );

 return data === undefined && parts[1] ?
 this.data( parts[0] ) :
 data;
 } else
 return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
 jQuery.data( this, key, value );
 });
 },

 removeData: function( key ){
 return this.each(function(){
 jQuery.removeData( this, key );
 });
 },

 domManip: function( args, table, reverse, callback ) {
 var clone = this.length > 1, elems;

 return this.each(function(){
 if ( !elems ) {
 elems = jQuery.clean( args, this.ownerDocument );

 if ( reverse )
 elems.reverse();
 }

 var obj = this;

 if ( table && jQuery.nodeName( this, "table" ) && jQuery.nodeName( elems[0], "tr" ) )
 obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );

 var scripts = jQuery( [] );

 jQuery.each(elems, function(){
 var elem = clone ?
 jQuery( this ).clone( true )[0] :
 this;

 // execute all scripts after the elements have been injected
 if ( jQuery.nodeName( elem, "script" ) )
 scripts = scripts.add( elem );
 else {
 // Remove any inner scripts for later evaluation
 if ( elem.nodeType == 1 )
 scripts = scripts.add( jQuery( "script", elem ).remove() );

 // Inject the elements into the document
 callback.call( obj, elem );
 }
 });

 scripts.each( evalScript );
 });
 }
};

// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;

function evalScript( i, elem ) {
 if ( elem.src )
 jQuery.ajax({
 url: elem.src,
 async: false,
 dataType: "script"
 });

 else
 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );

 if ( elem.parentNode )
 elem.parentNode.removeChild( elem );
}

function now(){
 return +new Date;
}

jQuery.extend = jQuery.fn.extend = function() {
 // copy reference to target object
 var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;

 // Handle a deep copy situation
 if ( target.constructor == Boolean ) {
 deep = target;
 target = arguments[1] || {};
 // skip the boolean and the target
 i = 2;
 }

 // Handle case when target is a string or something (possible in deep copy)
 if ( typeof target != "object" && typeof target != "function" )
 target = {};

 // extend jQuery itself if only one argument is passed
 if ( length == i ) {
 target = this;
 --i;
 }

 for ( ; i < length; i++ )
 // Only deal with non-null/undefined values
 if ( (options = arguments[ i ]) != null )
 // Extend the base object
 for ( var name in options ) {
 var src = target[ name ], copy = options[ name ];

 // Prevent never-ending loop
 if ( target === copy )
 continue;

 // Recurse if we're merging object values
 if ( deep && copy && typeof copy == "object" && !copy.nodeType )
 target[ name ] = jQuery.extend( deep, 
 // Never move original objects, clone them
 src || ( copy.length != null ? [ ] : { } )
 , copy );

 // Don't bring in undefined values
 else if ( copy !== undefined )
 target[ name ] = copy;

 }

 // Return the modified object
 return target;
};

var expando = "jQuery" + now(), uuid = 0, windowData = {},
 // exclude the following css properties to add px
 exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
 // cache defaultView
 defaultView = document.defaultView || {};

jQuery.extend({
 noConflict: function( deep ) {
 window.$ = _$;

 if ( deep )
 window.jQuery = _jQuery;

 return jQuery;
 },

 // See test/unit/core.js for details concerning this function.
 isFunction: function( fn ) {
 return !!fn && typeof fn != "string" && !fn.nodeName &&
 fn.constructor != Array && /^[\s[]?function/.test( fn + "" );
 },

 // check if an element is in a (or is an) XML document
 isXMLDoc: function( elem ) {
 return elem.documentElement && !elem.body ||
 elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
 },

 // Evalulates a script in a global context
 globalEval: function( data ) {
 data = jQuery.trim( data );

 if ( data ) {
 // Inspired by code by Andrea Giammarchi
 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
 var head = document.getElementsByTagName("head")[0] || document.documentElement,
 script = document.createElement("script");

 script.type = "text/javascript";
 if ( jQuery.browser.msie )
 script.text = data;
 else
 script.appendChild( document.createTextNode( data ) );

 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
 // This arises when a base node is used (#2709).
 head.insertBefore( script, head.firstChild );
 head.removeChild( script );
 }
 },

 nodeName: function( elem, name ) {
 return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
 },

 cache: {},

 data: function( elem, name, data ) {
 elem = elem == window ?
 windowData :
 elem;

 var id = elem[ expando ];

 // Compute a unique ID for the element
 if ( !id )
 id = elem[ expando ] = ++uuid;

 // Only generate the data cache if we're
 // trying to access or manipulate it
 if ( name && !jQuery.cache[ id ] )
 jQuery.cache[ id ] = {};

 // Prevent overriding the named cache with undefined values
 if ( data !== undefined )
 jQuery.cache[ id ][ name ] = data;

 // Return the named cache data, or the ID for the element
 return name ?
 jQuery.cache[ id ][ name ] :
 id;
 },

 removeData: function( elem, name ) {
 elem = elem == window ?
 windowData :
 elem;

 var id = elem[ expando ];

 // If we want to remove a specific section of the element's data
 if ( name ) {
 if ( jQuery.cache[ id ] ) {
 // Remove the section of cache data
 delete jQuery.cache[ id ][ name ];

 // If we've removed all the data, remove the element's cache
 name = "";

 for ( name in jQuery.cache[ id ] )
 break;

 if ( !name )
 jQuery.removeData( elem );
 }

 // Otherwise, we want to remove all of the element's data
 } else {
 // Clean up the element expando
 try {
 delete elem[ expando ];
 } catch(e){
 // IE has trouble directly removing the expando
 // but it's ok with using removeAttribute
 if ( elem.removeAttribute )
 elem.removeAttribute( expando );
 }

 // Completely remove the data cache
 delete jQuery.cache[ id ];
 }
 },

 // args is for internal usage only
 each: function( object, callback, args ) {
 var name, i = 0, length = object.length;

 if ( args ) {
 if ( length == undefined ) {
 for ( name in object )
 if ( callback.apply( object[ name ], args ) === false )
 break;
 } else
 for ( ; i < length; )
 if ( callback.apply( object[ i++ ], args ) === false )
 break;

 // A special, fast, case for the most common use of each
 } else {
 if ( length == undefined ) {
 for ( name in object )
 if ( callback.call( object[ name ], name, object[ name ] ) === false )
 break;
 } else
 for ( var value = object[0];
 i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
 }

 return object;
 },

 prop: function( elem, value, type, i, name ) {
 // Handle executable functions
 if ( jQuery.isFunction( value ) )
 value = value.call( elem, i );

 // Handle passing in a number to a CSS property
 return value && value.constructor == Number && type == "curCSS" && !exclude.test( name ) ?
 value + "px" :
 value;
 },

 className: {
 // internal only, use addClass("class")
 add: function( elem, classNames ) {
 jQuery.each((classNames || "").split(/\s+/), function(i, className){
 if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
 elem.className += (elem.className ? " " : "") + className;
 });
 },

 // internal only, use removeClass("class")
 remove: function( elem, classNames ) {
 if (elem.nodeType == 1)
 elem.className = classNames != undefined ?
 jQuery.grep(elem.className.split(/\s+/), function(className){
 return !jQuery.className.has( classNames, className );
 }).join(" ") :
 "";
 },

 // internal only, use hasClass("class")
 has: function( elem, className ) {
 return jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
 }
 },

 // A method for quickly swapping in/out CSS properties to get correct calculations
 swap: function( elem, options, callback ) {
 var old = {};
 // Remember the old values, and insert the new ones
 for ( var name in options ) {
 old[ name ] = elem.style[ name ];
 elem.style[ name ] = options[ name ];
 }

 callback.call( elem );

 // Revert the old values
 for ( var name in options )
 elem.style[ name ] = old[ name ];
 },

 css: function( elem, name, force ) {
 if ( name == "width" || name == "height" ) {
 var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];

 function getWH() {
 val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
 var padding = 0, border = 0;
 jQuery.each( which, function() {
 padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
 border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
 });
 val -= Math.round(padding + border);
 }

 if ( jQuery(elem).is(":visible") )
 getWH();
 else
 jQuery.swap( elem, props, getWH );

 return Math.max(0, val);
 }

 return jQuery.curCSS( elem, name, force );
 },

 curCSS: function( elem, name, force ) {
 var ret, style = elem.style;

 // A helper method for determining if an element's values are broken
 function color( elem ) {
 if ( !jQuery.browser.safari )
 return false;

 // defaultView is cached
 var ret = defaultView.getComputedStyle( elem, null );
 return !ret || ret.getPropertyValue("color") == "";
 }

 // We need to handle opacity special in IE
 if ( name == "opacity" && jQuery.browser.msie ) {
 ret = jQuery.attr( style, "opacity" );

 return ret == "" ?
 "1" :
 ret;
 }
 // Opera sometimes will give the wrong display answer, this fixes it, see #2037
 if ( jQuery.browser.opera && name == "display" ) {
 var save = style.outline;
 style.outline = "0 solid black";
 style.outline = save;
 }

 // Make sure we're using the right name for getting the float value
 if ( name.match( /float/i ) )
 name = styleFloat;

 if ( !force && style && style[ name ] )
 ret = style[ name ];

 else if ( defaultView.getComputedStyle ) {

 // Only "float" is needed here
 if ( name.match( /float/i ) )
 name = "float";

 name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();

 var computedStyle = defaultView.getComputedStyle( elem, null );

 if ( computedStyle && !color( elem ) )
 ret = computedStyle.getPropertyValue( name );

 // If the element isn't reporting its values properly in Safari
 // then some display: none elements are involved
 else {
 var swap = [], stack = [], a = elem, i = 0;

 // Locate all of the parent display: none elements
 for ( ; a && color(a); a = a.parentNode )
 stack.unshift(a);

 // Go through and make them visible, but in reverse
 // (It would be better if we knew the exact display type that they had)
 for ( ; i < stack.length; i++ )
 if ( color( stack[ i ] ) ) {
 swap[ i ] = stack[ i ].style.display;
 stack[ i ].style.display = "block";
 }

 // Since we flip the display style, we have to handle that
 // one special, otherwise get the value
 ret = name == "display" && swap[ stack.length - 1 ] != null ?
 "none" :
 ( computedStyle && computedStyle.getPropertyValue( name ) ) || "";

 // Finally, revert the display styles back
 for ( i = 0; i < swap.length; i++ )
 if ( swap[ i ] != null )
 stack[ i ].style.display = swap[ i ];
 }

 // We should always get a number back from opacity
 if ( name == "opacity" && ret == "" )
 ret = "1";

 } else if ( elem.currentStyle ) {
 var camelCase = name.replace(/\-(\w)/g, function(all, letter){
 return letter.toUpperCase();
 });

 ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];

 // From the awesome hack by Dean Edwards
 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291

 // If we're not dealing with a regular pixel number
 // but a number that has a weird ending, we need to convert it to pixels
 if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
 // Remember the original values
 var left = style.left, rsLeft = elem.runtimeStyle.left;

 // Put in the new values to get a computed value out
 elem.runtimeStyle.left = elem.currentStyle.left;
 style.left = ret || 0;
 ret = style.pixelLeft + "px";

 // Revert the changed values
 style.left = left;
 elem.runtimeStyle.left = rsLeft;
 }
 }

 return ret;
 },

 clean: function( elems, context ) {
 var ret = [];
 context = context || document;
 // !context.createElement fails in IE with an error but returns typeof 'object'
 if (typeof context.createElement == 'undefined')
 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;

 jQuery.each(elems, function(i, elem){
 if ( !elem )
 return;

 if ( elem.constructor == Number )
 elem += '';

 // Convert html string into DOM nodes
 if ( typeof elem == "string" ) {
 // Fix "XHTML"-style tags in all browsers
 elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
 return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
 all :
 front + "></" + tag + ">";
 });

 // Trim whitespace, otherwise indexOf won't work as expected
 var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");

 var wrap =
 // option or optgroup
 !tags.indexOf("<opt") &&
 [ 1, "<select multiple='multiple'>", "</select>" ] ||

 !tags.indexOf("<leg") &&
 [ 1, "<fieldset>", "</fieldset>" ] ||

 tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
 [ 1, "<table>", "</table>" ] ||

 !tags.indexOf("<tr") &&
 [ 2, "<table><tbody>", "</tbody></table>" ] ||

 // <thead> matched above
 (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
 [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||

 !tags.indexOf("<col") &&
 [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||

 // IE can't serialize <link> and <script> tags normally
 jQuery.browser.msie &&
 [ 1, "div<div>", "</div>" ] ||

 [ 0, "", "" ];

 // Go to html and back, then peel off extra wrappers
 div.innerHTML = wrap[1] + elem + wrap[2];

 // Move to the right depth
 while ( wrap[0]-- )
 div = div.lastChild;

 // Remove IE's autoinserted <tbody> from table fragments
 if ( jQuery.browser.msie ) {

 // String was a <table>, *may* have spurious <tbody>
 var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
 div.firstChild && div.firstChild.childNodes :

 // String was a bare <thead> or <tfoot>
 wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
 div.childNodes :
 [];

 for ( var j = tbody.length - 1; j >= 0 ; --j )
 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
 tbody[ j ].parentNode.removeChild( tbody[ j ] );

 // IE completely kills leading whitespace when innerHTML is used
 if ( /^\s/.test( elem ) )
 div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );

 }

 elem = jQuery.makeArray( div.childNodes );
 }

 if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
 return;

 if ( elem[0] == undefined || jQuery.nodeName( elem, "form" ) || elem.options )
 ret.push( elem );

 else
 ret = jQuery.merge( ret, elem );

 });

 return ret;
 },

 attr: function( elem, name, value ) {
 // don't set attributes on text and comment nodes
 if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
 return undefined;

 var notxml = !jQuery.isXMLDoc( elem ),
 // Whether we are setting (or getting)
 set = value !== undefined,
 msie = jQuery.browser.msie;

 // Try to normalize/fix the name
 name = notxml && jQuery.props[ name ] || name;

 // Only do all the following if this is a node (faster for style)
 // IE elem.getAttribute passes even for style
 if ( elem.tagName ) {

 // These attributes require special treatment
 var special = /href|src|style/.test( name );

 // Safari mis-reports the default selected property of a hidden option
 // Accessing the parent's selectedIndex property fixes it
 if ( name == "selected" && jQuery.browser.safari )
 elem.parentNode.selectedIndex;

 // If applicable, access the attribute via the DOM 0 way
 if ( name in elem && notxml && !special ) {
 if ( set ){
 // We can't allow the type property to be changed (since it causes problems in IE)
 if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
 throw "type property can't be changed";

 elem[ name ] = value;
 }

 // browsers index elements by id/name on forms, give priority to attributes.
 if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
 return elem.getAttributeNode( name ).nodeValue;

 return elem[ name ];
 }

 if ( msie && notxml && name == "style" )
 return jQuery.attr( elem.style, "cssText", value );

 if ( set )
 // convert the value to a string (all browsers do this but IE) see #1070
 elem.setAttribute( name, "" + value );

 var attr = msie && notxml && special
 // Some attributes require a special call on IE
 ? elem.getAttribute( name, 2 )
 : elem.getAttribute( name );

 // Non-existent attributes return null, we normalize to undefined
 return attr === null ? undefined : attr;
 }

 // elem is actually elem.style ... set the style

 // IE uses filters for opacity
 if ( msie && name == "opacity" ) {
 if ( set ) {
 // IE has trouble with opacity if it does not have layout
 // Force it by setting the zoom level
 elem.zoom = 1;

 // Set the alpha filter to set the opacity
 elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
 (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
 }

 return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
 (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
 "";
 }

 name = name.replace(/-([a-z])/ig, function(all, letter){
 return letter.toUpperCase();
 });

 if ( set )
 elem[ name ] = value;

 return elem[ name ];
 },

 trim: function( text ) {
 return (text || "").replace( /^\s+|\s+$/g, "" );
 },

 makeArray: function( array ) {
 var ret = [];

 if( array != null ){
 var i = array.length;
 //the window, strings and functions also have 'length'
 if( i == null || array.split || array.setInterval || array.call )
 ret[0] = array;
 else
 while( i )
 ret[--i] = array[i];
 }

 return ret;
 },

 inArray: function( elem, array ) {
 for ( var i = 0, length = array.length; i < length; i++ )
 // Use === because on IE, window == document
 if ( array[ i ] === elem )
 return i;

 return -1;
 },

 merge: function( first, second ) {
 // We have to loop this way because IE & Opera overwrite the length
 // expando of getElementsByTagName
 var i = 0, elem, pos = first.length;
 // Also, we need to make sure that the correct elements are being returned
 // (IE returns comment nodes in a '*' query)
 if ( jQuery.browser.msie ) {
 while ( elem = second[ i++ ] )
 if ( elem.nodeType != 8 )
 first[ pos++ ] = elem;

 } else
 while ( elem = second[ i++ ] )
 first[ pos++ ] = elem;

 return first;
 },

 unique: function( array ) {
 var ret = [], done = {};

 try {

 for ( var i = 0, length = array.length; i < length; i++ ) {
 var id = jQuery.data( array[ i ] );

 if ( !done[ id ] ) {
 done[ id ] = true;
 ret.push( array[ i ] );
 }
 }

 } catch( e ) {
 ret = array;
 }

 return ret;
 },

 grep: function( elems, callback, inv ) {
 var ret = [];

 // Go through the array, only saving the items
 // that pass the validator function
 for ( var i = 0, length = elems.length; i < length; i++ )
 if ( !inv != !callback( elems[ i ], i ) )
 ret.push( elems[ i ] );

 return ret;
 },

 map: function( elems, callback ) {
 var ret = [];

 // Go through the array, translating each of the items to their
 // new value (or values).
 for ( var i = 0, length = elems.length; i < length; i++ ) {
 var value = callback( elems[ i ], i );

 if ( value != null )
 ret[ ret.length ] = value;
 }

 return ret.concat.apply( [], ret );
 }
});

var userAgent = navigator.userAgent.toLowerCase();

// Figure out what browser is being used
jQuery.browser = {
 version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
 safari: /webkit/.test( userAgent ),
 opera: /opera/.test( userAgent ),
 msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
 mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
};

var styleFloat = jQuery.browser.msie ?
 "styleFloat" :
 "cssFloat";

jQuery.extend({
 // Check to see if the W3C box model is being used
 boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",

 props: {
 "for": "htmlFor",
 "class": "className",
 "float": styleFloat,
 cssFloat: styleFloat,
 styleFloat: styleFloat,
 readonly: "readOnly",
 maxlength: "maxLength",
 cellspacing: "cellSpacing"
 }
});

jQuery.each({
 parent: function(elem){return elem.parentNode;},
 parents: function(elem){return jQuery.dir(elem,"parentNode");},
 next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
 prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
 nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
 prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
 siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
 children: function(elem){return jQuery.sibling(elem.firstChild);},
 contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
}, function(name, fn){
 jQuery.fn[ name ] = function( selector ) {
 var ret = jQuery.map( this, fn );

 if ( selector && typeof selector == "string" )
 ret = jQuery.multiFilter( selector, ret );

 return this.pushStack( jQuery.unique( ret ) );
 };
});

jQuery.each({
 appendTo: "append",
 prependTo: "prepend",
 insertBefore: "before",
 insertAfter: "after",
 replaceAll: "replaceWith"
}, function(name, original){
 jQuery.fn[ name ] = function() {
 var args = arguments;

 return this.each(function(){
 for ( var i = 0, length = args.length; i < length; i++ )
 jQuery( args[ i ] )[ original ]( this );
 });
 };
});

jQuery.each({
 removeAttr: function( name ) {
 jQuery.attr( this, name, "" );
 if (this.nodeType == 1)
 this.removeAttribute( name );
 },

 addClass: function( classNames ) {
 jQuery.className.add( this, classNames );
 },

 removeClass: function( classNames ) {
 jQuery.className.remove( this, classNames );
 },

 toggleClass: function( classNames ) {
 jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
 },

 remove: function( selector ) {
 if ( !selector || jQuery.filter( selector, [ this ] ).r.length ) {
 // Prevent memory leaks
 jQuery( "*", this ).add(this).each(function(){
 jQuery.event.remove(this);
 jQuery.removeData(this);
 });
 if (this.parentNode)
 this.parentNode.removeChild( this );
 }
 },

 empty: function() {
 // Remove element nodes and prevent memory leaks
 jQuery( ">*", this ).remove();

 // Remove any remaining nodes
 while ( this.firstChild )
 this.removeChild( this.firstChild );
 }
}, function(name, fn){
 jQuery.fn[ name ] = function(){
 return this.each( fn, arguments );
 };
});

jQuery.each([ "Height", "Width" ], function(i, name){
 var type = name.toLowerCase();

 jQuery.fn[ type ] = function( size ) {
 // Get window width or height
 return this[0] == window ?
 // Opera reports document.body.client[Width/Height] properly in both quirks and standards
 jQuery.browser.opera && document.body[ "client" + name ] ||

 // Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
 jQuery.browser.safari && window[ "inner" + name ] ||

 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
 document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :

 // Get document width or height
 this[0] == document ?
 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
 Math.max(
 Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]),
 Math.max(document.body["offset" + name], document.documentElement["offset" + name])
 ) :

 // Get or set width or height on the element
 size == undefined ?
 // Get width or height on the element
 (this.length ? jQuery.css( this[0], type ) : null) :

 // Set the width or height on the element (default to pixels if value is unitless)
 this.css( type, size.constructor == String ? size : size + "px" );
 };
});

// Helper function used by the dimensions and offset modules
function num(elem, prop) {
 return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
}var chars = jQuery.browser.safari && parseInt(jQuery.browser.version) < 417 ?
 "(?:[\\w*_-]|\\\\.)" :
 "(?:[\\w\u0128-\uFFFF*_-]|\\\\.)",
 quickChild = new RegExp("^>\\s*(" + chars + "+)"),
 quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)"),
 quickClass = new RegExp("^([#.]?)(" + chars + "*)");

jQuery.extend({
 expr: {
 "": function(a,i,m){return m[2]=="*"||jQuery.nodeName(a,m[2]);},
 "#": function(a,i,m){return a.getAttribute("id")==m[2];},
 ":": {
 // Position Checks
 lt: function(a,i,m){return i<m[3]-0;},
 gt: function(a,i,m){return i>m[3]-0;},
 nth: function(a,i,m){return m[3]-0==i;},
 eq: function(a,i,m){return m[3]-0==i;},
 first: function(a,i){return i==0;},
 last: function(a,i,m,r){return i==r.length-1;},
 even: function(a,i){return i%2==0;},
 odd: function(a,i){return i%2;},

 // Child Checks
 "first-child": function(a){return a.parentNode.getElementsByTagName("*")[0]==a;},
 "last-child": function(a){return jQuery.nth(a.parentNode.lastChild,1,"previousSibling")==a;},
 "only-child": function(a){return !jQuery.nth(a.parentNode.lastChild,2,"previousSibling");},

 // Parent Checks
 parent: function(a){return a.firstChild;},
 empty: function(a){return !a.firstChild;},

 // Text Check
 contains: function(a,i,m){return (a.textContent||a.innerText||jQuery(a).text()||"").indexOf(m[3])>=0;},

 // Visibility
 visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
 hidden: function(a){return "hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden";},

 // Form attributes
 enabled: function(a){return !a.disabled;},
 disabled: function(a){return a.disabled;},
 checked: function(a){return a.checked;},
 selected: function(a){return a.selected||jQuery.attr(a,"selected");},

 // Form elements
 text: function(a){return "text"==a.type;},
 radio: function(a){return "radio"==a.type;},
 checkbox: function(a){return "checkbox"==a.type;},
 file: function(a){return "file"==a.type;},
 password: function(a){return "password"==a.type;},
 submit: function(a){return "submit"==a.type;},
 image: function(a){return "image"==a.type;},
 reset: function(a){return "reset"==a.type;},
 button: function(a){return "button"==a.type||jQuery.nodeName(a,"button");},
 input: function(a){return /input|select|textarea|button/i.test(a.nodeName);},

 // :has()
 has: function(a,i,m){return jQuery.find(m[3],a).length;},

 // :header
 header: function(a){return /h\d/i.test(a.nodeName);},

 // :animated
 animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
 }
 },

 // The regular expressions that power the parsing engine
 parse: [
 // Match: [@value='test'], [@foo]
 /^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,

 // Match: :contains('foo')
 /^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,

 // Match: :even, :last-child, #id, .class
 new RegExp("^([:.#]*)(" + chars + "+)")
 ],

 multiFilter: function( expr, elems, not ) {
 var old, cur = [];

 while ( expr && expr != old ) {
 old = expr;
 var f = jQuery.filter( expr, elems, not );
 expr = f.t.replace(/^\s*,\s*/, "" );
 cur = not ? elems = f.r : jQuery.merge( cur, f.r );
 }

 return cur;
 },

 find: function( t, context ) {
 // Quickly handle non-string expressions
 if ( typeof t != "string" )
 return [ t ];

 // check to make sure context is a DOM element or a document
 if ( context && context.nodeType != 1 && context.nodeType != 9)
 return [ ];

 // Set the correct context (if none is provided)
 context = context || document;

 // Initialize the search
 var ret = [context], done = [], last, nodeName;

 // Continue while a selector expression exists, and while
 // we're no longer looping upon ourselves
 while ( t && last != t ) {
 var r = [];
 last = t;

 t = jQuery.trim(t);

 var foundToken = false,

 // An attempt at speeding up child selectors that
 // point to a specific element tag
 re = quickChild,

 m = re.exec(t);

 if ( m ) {
 nodeName = m[1].toUpperCase();

 // Perform our own iteration and filter
 for ( var i = 0; ret[i]; i++ )
 for ( var c = ret[i].firstChild; c; c = c.nextSibling )
 if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName) )
 r.push( c );

 ret = r;
 t = t.replace( re, "" );
 if ( t.indexOf(" ") == 0 ) continue;
 foundToken = true;
 } else {
 re = /^([>+~])\s*(\w*)/i;

 if ( (m = re.exec(t)) != null ) {
 r = [];

 var merge = {};
 nodeName = m[2].toUpperCase();
 m = m[1];

 for ( var j = 0, rl = ret.length; j < rl; j++ ) {
 var n = m == "~" || m == "+" ? ret[j].nextSibling : ret[j].firstChild;
 for ( ; n; n = n.nextSibling )
 if ( n.nodeType == 1 ) {
 var id = jQuery.data(n);

 if ( m == "~" && merge[id] ) break;

 if (!nodeName || n.nodeName.toUpperCase() == nodeName ) {
 if ( m == "~" ) merge[id] = true;
 r.push( n );
 }

 if ( m == "+" ) break;
 }
 }

 ret = r;

 // And remove the token
 t = jQuery.trim( t.replace( re, "" ) );
 foundToken = true;
 }
 }

 // See if there's still an expression, and that we haven't already
 // matched a token
 if ( t && !foundToken ) {
 // Handle multiple expressions
 if ( !t.indexOf(",") ) {
 // Clean the result set
 if ( context == ret[0] ) ret.shift();

 // Merge the result sets
 done = jQuery.merge( done, ret );

 // Reset the context
 r = ret = [context];

 // Touch up the selector string
 t = " " + t.substr(1,t.length);

 } else {
 // Optimize for the case nodeName#idName
 var re2 = quickID;
 var m = re2.exec(t);

 // Re-organize the results, so that they're consistent
 if ( m ) {
 m = [ 0, m[2], m[3], m[1] ];

 } else {
 // Otherwise, do a traditional filter check for
 // ID, class, and element selectors
 re2 = quickClass;
 m = re2.exec(t);
 }

 m[2] = m[2].replace(/\\/g, "");

 var elem = ret[ret.length-1];

 // Try to do a global search by ID, where we can
 if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) {
 // Optimization for HTML document case
 var oid = elem.getElementById(m[2]);

 // Do a quick check for the existence of the actual ID attribute
 // to avoid selecting by the name attribute in IE
 // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
 if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
 oid = jQuery('[@id="'+m[2]+'"]', elem)[0];

 // Do a quick check for node name (where applicable) so
 // that div#foo searches will be really fast
 ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];
 } else {
 // We need to find all descendant elements
 for ( var i = 0; ret[i]; i++ ) {
 // Grab the tag name being searched for
 var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" || m[0] == "" ? "*" : m[2];

 // Handle IE7 being really dumb about <object>s
 if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
 tag = "param";

 r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
 }

 // It's faster to filter by class and be done with it
 if ( m[1] == "." )
 r = jQuery.classFilter( r, m[2] );

 // Same with ID filtering
 if ( m[1] == "#" ) {
 var tmp = [];

 // Try to find the element with the ID
 for ( var i = 0; r[i]; i++ )
 if ( r[i].getAttribute("id") == m[2] ) {
 tmp = [ r[i] ];
 break;
 }

 r = tmp;
 }

 ret = r;
 }

 t = t.replace( re2, "" );
 }

 }

 // If a selector string still exists
 if ( t ) {
 // Attempt to filter it
 var val = jQuery.filter(t,r);
 ret = r = val.r;
 t = jQuery.trim(val.t);
 }
 }

 // An error occurred with the selector;
 // just return an empty set instead
 if ( t )
 ret = [];

 // Remove the root context
 if ( ret && context == ret[0] )
 ret.shift();

 // And combine the results
 done = jQuery.merge( done, ret );

 return done;
 },

 classFilter: function(r,m,not){
 m = " " + m + " ";
 var tmp = [];
 for ( var i = 0; r[i]; i++ ) {
 var pass = (" " + r[i].className + " ").indexOf( m ) >= 0;
 if ( !not && pass || not && !pass )
 tmp.push( r[i] );
 }
 return tmp;
 },

 filter: function(t,r,not) {
 var last;

 // Look for common filter expressions
 while ( t && t != last ) {
 last = t;

 var p = jQuery.parse, m;

 for ( var i = 0; p[i]; i++ ) {
 m = p[i].exec( t );

 if ( m ) {
 // Remove what we just matched
 t = t.substring( m[0].length );

 m[2] = m[2].replace(/\\/g, "");
 break;
 }
 }

 if ( !m )
 break;

 // :not() is a special case that can be optimized by
 // keeping it out of the expression list
 if ( m[1] == ":" && m[2] == "not" )
 // optimize if only one selector found (most common case)
 r = isSimple.test( m[3] ) ?
 jQuery.filter(m[3], r, true).r :
 jQuery( r ).not( m[3] );

 // We can get a big speed boost by filtering by class here
 else if ( m[1] == "." )
 r = jQuery.classFilter(r, m[2], not);

 else if ( m[1] == "[" ) {
 var tmp = [], type = m[3];

 for ( var i = 0, rl = r.length; i < rl; i++ ) {
 var a = r[i], z = a[ jQuery.props[m[2]] || m[2] ];

 if ( z == null || /href|src|selected/.test(m[2]) )
 z = jQuery.attr(a,m[2]) || '';

 if ( (type == "" && !!z ||
 type == "=" && z == m[5] ||
 type == "!=" && z != m[5] ||
 type == "^=" && z && !z.indexOf(m[5]) ||
 type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
 (type == "*=" || type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
 tmp.push( a );
 }

 r = tmp;

 // We can get a speed boost by handling nth-child here
 } else if ( m[1] == ":" && m[2] == "nth-child" ) {
 var merge = {}, tmp = [],
 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
 test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
 m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
 !/\D/.test(m[3]) && "0n+" + m[3] || m[3]),
 // calculate the numbers (first)n+(last) including if they are negative
 first = (test[1] + (test[2] || 1)) - 0, last = test[3] - 0;

 // loop through all the elements left in the jQuery object
 for ( var i = 0, rl = r.length; i < rl; i++ ) {
 var node = r[i], parentNode = node.parentNode, id = jQuery.data(parentNode);

 if ( !merge[id] ) {
 var c = 1;

 for ( var n = parentNode.firstChild; n; n = n.nextSibling )
 if ( n.nodeType == 1 )
 n.nodeIndex = c++;

 merge[id] = true;
 }

 var add = false;

 if ( first == 0 ) {
 if ( node.nodeIndex == last )
 add = true;
 } else if ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
 add = true;

 if ( add ^ not )
 tmp.push( node );
 }

 r = tmp;

 // Otherwise, find the expression to execute
 } else {
 var fn = jQuery.expr[ m[1] ];
 if ( typeof fn == "object" )
 fn = fn[ m[2] ];

 if ( typeof fn == "string" )
 fn = eval("false||function(a,i){return " + fn + ";}");

 // Execute it against the current filter
 r = jQuery.grep( r, function(elem, i){
 return fn(elem, i, m, r);
 }, not );
 }
 }

 // Return an array of filtered elements (r)
 // and the modified expression string (t)
 return { r: r, t: t };
 },

 dir: function( elem, dir ){
 var matched = [],
 cur = elem[dir];
 while ( cur && cur != document ) {
 if ( cur.nodeType == 1 )
 matched.push( cur );
 cur = cur[dir];
 }
 return matched;
 },

 nth: function(cur,result,dir,elem){
 result = result || 1;
 var num = 0;

 for ( ; cur; cur = cur[dir] )
 if ( cur.nodeType == 1 && ++num == result )
 break;

 return cur;
 },

 sibling: function( n, elem ) {
 var r = [];

 for ( ; n; n = n.nextSibling ) {
 if ( n.nodeType == 1 && n != elem )
 r.push( n );
 }

 return r;
 }
});
/*
 * A number of helper functions used for managing events.
 * Many of the ideas behind this code orignated from
 * Dean Edwards' addEvent library.
 */
jQuery.event = {

 // Bind an event to an element
 // Original by Dean Edwards
 add: function(elem, types, handler, data) {
 if ( elem.nodeType == 3 || elem.nodeType == 8 )
 return;

 // For whatever reason, IE has trouble passing the window object
 // around, causing it to be cloned in the process
 if ( jQuery.browser.msie && elem.setInterval )
 elem = window;

 // Make sure that the function being executed has a unique ID
 if ( !handler.guid )
 handler.guid = this.guid++;

 // if data is passed, bind to handler
 if( data != undefined ) {
 // Create temporary function pointer to original handler
 var fn = handler;

 // Create unique handler function, wrapped around original handler
 handler = this.proxy( fn, function() {
 // Pass arguments and context to original handler
 return fn.apply(this, arguments);
 });

 // Store data in unique handler
 handler.data = data;
 }

 // Init the element's event structure
 var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
 handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
 // Handle the second event of a trigger and when
 // an event is called after a page has unloaded
 if ( typeof jQuery != "undefined" && !jQuery.event.triggered )
 return jQuery.event.handle.apply(arguments.callee.elem, arguments);
 });
 // Add elem as a property of the handle function
 // This is to prevent a memory leak with non-native
 // event in IE.
 handle.elem = elem;

 // Handle multiple events separated by a space
 // jQuery(...).bind("mouseover mouseout", fn);
 jQuery.each(types.split(/\s+/), function(index, type) {
 // Namespaced event handlers
 var parts = type.split(".");
 type = parts[0];
 handler.type = parts[1];

 // Get the current list of functions bound to this event
 var handlers = events[type];

 // Init the event handler queue
 if (!handlers) {
 handlers = events[type] = {};

 // Check for a special event handler
 // Only use addEventListener/attachEvent if the special
 // events handler returns false
 if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem) === false ) {
 // Bind the global event handler to the element
 if (elem.addEventListener)
 elem.addEventListener(type, handle, false);
 else if (elem.attachEvent)
 elem.attachEvent("on" + type, handle);
 }
 }

 // Add the function to the element's handler list
 handlers[handler.guid] = handler;

 // Keep track of which events have been used, for global triggering
 jQuery.event.global[type] = true;
 });

 // Nullify elem to prevent memory leaks in IE
 elem = null;
 },

 guid: 1,
 global: {},

 // Detach an event or set of events from an element
 remove: function(elem, types, handler) {
 // don't do events on text and comment nodes
 if ( elem.nodeType == 3 || elem.nodeType == 8 )
 return;

 var events = jQuery.data(elem, "events"), ret, index;

 if ( events ) {
 // Unbind all events for the element
 if ( types == undefined || (typeof types == "string" && types.charAt(0) == ".") )
 for ( var type in events )
 this.remove( elem, type + (types || "") );
 else {
 // types is actually an event object here
 if ( types.type ) {
 handler = types.handler;
 types = types.type;
 }

 // Handle multiple events seperated by a space
 // jQuery(...).unbind("mouseover mouseout", fn);
 jQuery.each(types.split(/\s+/), function(index, type){
 // Namespaced event handlers
 var parts = type.split(".");
 type = parts[0];

 if ( events[type] ) {
 // remove the given handler for the given type
 if ( handler )
 delete events[type][handler.guid];

 // remove all handlers for the given type
 else
 for ( handler in events[type] )
 // Handle the removal of namespaced events
 if ( !parts[1] || events[type][handler].type == parts[1] )
 delete events[type][handler];

 // remove generic event handler if no more handlers exist
 for ( ret in events[type] ) break;
 if ( !ret ) {
 if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
 if (elem.removeEventListener)
 elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
 else if (elem.detachEvent)
 elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
 }
 ret = null;
 delete events[type];
 }
 }
 });
 }

 // Remove the expando if it's no longer used
 for ( ret in events ) break;
 if ( !ret ) {
 var handle = jQuery.data( elem, "handle" );
 if ( handle ) handle.elem = null;
 jQuery.removeData( elem, "events" );
 jQuery.removeData( elem, "handle" );
 }
 }
 },

 trigger: function(type, data, elem, donative, extra) {
 // Clone the incoming data, if any
 data = jQuery.makeArray(data);

 if ( type.indexOf("!") >= 0 ) {
 type = type.slice(0, -1);
 var exclusive = true;
 }

 // Handle a global trigger
 if ( !elem ) {
 // Only trigger if we've ever bound an event for it
 if ( this.global[type] )
 jQuery("*").add([window, document]).trigger(type, data);

 // Handle triggering a single element
 } else {
 // don't do events on text and comment nodes
 if ( elem.nodeType == 3 || elem.nodeType == 8 )
 return undefined;

 var val, ret, fn = jQuery.isFunction( elem[ type ] || null ),
 // Check to see if we need to provide a fake event, or not
 event = !data[0] || !data[0].preventDefault;

 // Pass along a fake event
 if ( event ) {
 data.unshift({
 type: type,
 target: elem,
 preventDefault: function(){},
 stopPropagation: function(){},
 timeStamp: now()
 });
 data[0][expando] = true; // no need to fix fake event
 }

 // Enforce the right trigger type
 data[0].type = type;
 if ( exclusive )
 data[0].exclusive = true;

 // Trigger the event, it is assumed that "handle" is a function
 var handle = jQuery.data(elem, "handle");
 if ( handle )
 val = handle.apply( elem, data );

 // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
 if ( (!fn || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
 val = false;

 // Extra functions don't get the custom event object
 if ( event )
 data.shift();

 // Handle triggering of extra function
 if ( extra && jQuery.isFunction( extra ) ) {
 // call the extra function and tack the current return value on the end for possible inspection
 ret = extra.apply( elem, val == null ? data : data.concat( val ) );
 // if anything is returned, give it precedence and have it overwrite the previous value
 if (ret !== undefined)
 val = ret;
 }

 // Trigger the native events (except for clicks on links)
 if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
 this.triggered = true;
 try {
 elem[ type ]();
 // prevent IE from throwing an error for some hidden elements
 } catch (e) {}
 }

 this.triggered = false;
 }

 return val;
 },

 handle: function(event) {
 // returned undefined or false
 var val, ret, namespace, all, handlers;

 event = arguments[0] = jQuery.event.fix( event || window.event );

 // Namespaced event handlers
 namespace = event.type.split(".");
 event.type = namespace[0];
 namespace = namespace[1];
 // Cache this now, all = true means, any handler
 all = !namespace && !event.exclusive;

 handlers = ( jQuery.data(this, "events") || {} )[event.type];

 for ( var j in handlers ) {
 var handler = handlers[j];

 // Filter the functions by class
 if ( all || handler.type == namespace ) {
 // Pass in a reference to the handler function itself
 // So that we can later remove it
 event.handler = handler;
 event.data = handler.data;

 ret = handler.apply( this, arguments );

 if ( val !== false )
 val = ret;

 if ( ret === false ) {
 event.preventDefault();
 event.stopPropagation();
 }
 }
 }

 return val;
 },

 fix: function(event) {
 if ( event[expando] == true )
 return event;

 // store a copy of the original event object
 // and "clone" to set read-only properties
 var originalEvent = event;
 event = { originalEvent: originalEvent };
 var props = "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target timeStamp toElement type view wheelDelta which".split(" ");
 for ( var i=props.length; i; i-- )
 event[ props[i] ] = originalEvent[ props[i] ];

 // Mark it as fixed
 event[expando] = true;

 // add preventDefault and stopPropagation since
 // they will not work on the clone
 event.preventDefault = function() {
 // if preventDefault exists run it on the original event
 if (originalEvent.preventDefault)
 originalEvent.preventDefault();
 // otherwise set the returnValue property of the original event to false (IE)
 originalEvent.returnValue = false;
 };
 event.stopPropagation = function() {
 // if stopPropagation exists run it on the original event
 if (originalEvent.stopPropagation)
 originalEvent.stopPropagation();
 // otherwise set the cancelBubble property of the original event to true (IE)
 originalEvent.cancelBubble = true;
 };

 // Fix timeStamp
 event.timeStamp = event.timeStamp || now();

 // Fix target property, if necessary
 if ( !event.target )
 event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either

 // check if target is a textnode (safari)
 if ( event.target.nodeType == 3 )
 event.target = event.target.parentNode;

 // Add relatedTarget, if necessary
 if ( !event.relatedTarget && event.fromElement )
 event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;

 // Calculate pageX/Y if missing and clientX/Y available
 if ( event.pageX == null && event.clientX != null ) {
 var doc = document.documentElement, body = document.body;
 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
 }

 // Add which for key events
 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
 event.which = event.charCode || event.keyCode;

 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
 if ( !event.metaKey && event.ctrlKey )
 event.metaKey = event.ctrlKey;

 // Add which for click: 1 == left; 2 == middle; 3 == right
 // Note: button is not normalized, so don't use it
 if ( !event.which && event.button )
 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));

 return event;
 },

 proxy: function( fn, proxy ){
 // Set the guid of unique handler to the same of original handler, so it can be removed
 proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
 // So proxy can be declared as an argument
 return proxy;
 },

 special: {
 ready: {
 setup: function() {
 // Make sure the ready event is setup
 bindReady();
 return;
 },

 teardown: function() { return; }
 },

 mouseenter: {
 setup: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
 return true;
 },

 teardown: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).unbind("mouseover", jQuery.event.special.mouseenter.handler);
 return true;
 },

 handler: function(event) {
 // If we actually just moused on to a sub-element, ignore it
 if ( withinElement(event, this) ) return true;
 // Execute the right handlers by setting the event type to mouseenter
 event.type = "mouseenter";
 return jQuery.event.handle.apply(this, arguments);
 }
 },

 mouseleave: {
 setup: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
 return true;
 },

 teardown: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).unbind("mouseout", jQuery.event.special.mouseleave.handler);
 return true;
 },

 handler: function(event) {
 // If we actually just moused on to a sub-element, ignore it
 if ( withinElement(event, this) ) return true;
 // Execute the right handlers by setting the event type to mouseleave
 event.type = "mouseleave";
 return jQuery.event.handle.apply(this, arguments);
 }
 }
 }
};

jQuery.fn.extend({
 bind: function( type, data, fn ) {
 return type == "unload" ? this.one(type, data, fn) : this.each(function(){
 jQuery.event.add( this, type, fn || data, fn && data );
 });
 },

 one: function( type, data, fn ) {
 var one = jQuery.event.proxy( fn || data, function(event) {
 jQuery(this).unbind(event, one);
 return (fn || data).apply( this, arguments );
 });
 return this.each(function(){
 jQuery.event.add( this, type, one, fn && data);
 });
 },

 unbind: function( type, fn ) {
 return this.each(function(){
 jQuery.event.remove( this, type, fn );
 });
 },

 trigger: function( type, data, fn ) {
 return this.each(function(){
 jQuery.event.trigger( type, data, this, true, fn );
 });
 },

 triggerHandler: function( type, data, fn ) {
 return this[0] && jQuery.event.trigger( type, data, this[0], false, fn );
 },

 toggle: function( fn ) {
 // Save reference to arguments for access in closure
 var args = arguments, i = 1;

 // link all the functions, so any of them can unbind this click handler
 while( i < args.length )
 jQuery.event.proxy( fn, args[i++] );

 return this.click( jQuery.event.proxy( fn, function(event) {
 // Figure out which function to execute
 this.lastToggle = ( this.lastToggle || 0 ) % i;

 // Make sure that clicks stop
 event.preventDefault();

 // and execute the function
 return args[ this.lastToggle++ ].apply( this, arguments ) || false;
 }));
 },

 hover: function(fnOver, fnOut) {
 return this.bind('mouseenter', fnOver).bind('mouseleave', fnOut);
 },

 ready: function(fn) {
 // Attach the listeners
 bindReady();

 // If the DOM is already ready
 if ( jQuery.isReady )
 // Execute the function immediately
 fn.call( document, jQuery );

 // Otherwise, remember the function for later
 else
 // Add the function to the wait list
 jQuery.readyList.push( function() { return fn.call(this, jQuery); } );

 return this;
 }
});

jQuery.extend({
 isReady: false,
 readyList: [],
 // Handle when the DOM is ready
 ready: function() {
 // Make sure that the DOM is not already loaded
 if ( !jQuery.isReady ) {
 // Remember that the DOM is ready
 jQuery.isReady = true;

 // If there are functions bound, to execute
 if ( jQuery.readyList ) {
 // Execute all of them
 jQuery.each( jQuery.readyList, function(){
 this.call( document );
 });

 // Reset the list of functions
 jQuery.readyList = null;
 }

 // Trigger any bound ready events
 jQuery(document).triggerHandler("ready");
 }
 }
});

var readyBound = false;

function bindReady(){
 if ( readyBound ) return;
 readyBound = true;

 // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
 if ( document.addEventListener && !jQuery.browser.opera)
 // Use the handy event callback
 document.addEventListener( "DOMContentLoaded", jQuery.ready, false );

 // If IE is used and is not in a frame
 // Continually check to see if the document is ready
 if ( jQuery.browser.msie && window == top ) (function(){
 if (jQuery.isReady) return;
 try {
 // If IE is used, use the trick by Diego Perini
 // http://javascript.nwbox.com/IEContentLoaded/
 document.documentElement.doScroll("left");
 } catch( error ) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 // and execute any waiting functions
 jQuery.ready();
 })();

 if ( jQuery.browser.opera )
 document.addEventListener( "DOMContentLoaded", function () {
 if (jQuery.isReady) return;
 for (var i = 0; i < document.styleSheets.length; i++)
 if (document.styleSheets[i].disabled) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 // and execute any waiting functions
 jQuery.ready();
 }, false);

 if ( jQuery.browser.safari ) {
 var numStyles;
 (function(){
 if (jQuery.isReady) return;
 if ( document.readyState != "loaded" && document.readyState != "complete" ) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 if ( numStyles === undefined )
 numStyles = jQuery("style, link[rel=stylesheet]").length;
 if ( document.styleSheets.length != numStyles ) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 // and execute any waiting functions
 jQuery.ready();
 })();
 }

 // A fallback to window.onload, that will always work
 jQuery.event.add( window, "load", jQuery.ready );
}

jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
 "mousedown,mouseup,mousemove,mouseover,mouseout,change,select," +
 "submit,keydown,keypress,keyup,error").split(","), function(i, name){

 // Handle event binding
 jQuery.fn[name] = function(fn){
 return fn ? this.bind(name, fn) : this.trigger(name);
 };
});

// Checks if an event happened on an element within another element
// Used in jQuery.event.special.mouseenter and mouseleave handlers
var withinElement = function(event, elem) {
 // Check if mouse(over|out) are still within the same parent element
 var parent = event.relatedTarget;
 // Traverse up the tree
 while ( parent && parent != elem ) try { parent = parent.parentNode; } catch(error) { parent = elem; }
 // Return true if we actually just moused on to a sub-element
 return parent == elem;
};

// Prevent memory leaks in IE
// And prevent errors on refresh with events like mouseover in other browsers
// Window isn't included so as not to unbind existing unload events
jQuery(window).bind("unload", function() {
 jQuery("*").add(document).unbind();
});
jQuery.fn.extend({
 // Keep a copy of the old load
 _load: jQuery.fn.load,

 load: function( url, params, callback ) {
 if ( typeof url != 'string' )
 return this._load( url );

 var off = url.indexOf(" ");
 if ( off >= 0 ) {
 var selector = url.slice(off, url.length);
 url = url.slice(0, off);
 }

 callback = callback || function(){};

 // Default to a GET request
 var type = "GET";

 // If the second parameter was provided
 if ( params )
 // If it's a function
 if ( jQuery.isFunction( params ) ) {
 // We assume that it's the callback
 callback = params;
 params = null;

 // Otherwise, build a param string
 } else {
 params = jQuery.param( params );
 type = "POST";
 }

 var self = this;

 // Request the remote document
 jQuery.ajax({
 url: url,
 type: type,
 dataType: "html",
 data: params,
 complete: function(res, status){
 // If successful, inject the HTML into all the matched elements
 if ( status == "success" || status == "notmodified" )
 // See if a selector was specified
 self.html( selector ?
 // Create a dummy div to hold the results
 jQuery("<div/>")
 // inject the contents of the document in, removing the scripts
 // to avoid any 'Permission Denied' errors in IE
 .append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))

 // Locate the specified elements
 .find(selector) :

 // If not, just inject the full result
 res.responseText );

 self.each( callback, [res.responseText, status, res] );
 }
 });
 return this;
 },

 serialize: function() {
 return jQuery.param(this.serializeArray());
 },
 serializeArray: function() {
 return this.map(function(){
 return jQuery.nodeName(this, "form") ?
 jQuery.makeArray(this.elements) : this;
 })
 .filter(function(){
 return this.name && !this.disabled &&
 (this.checked || /select|textarea/i.test(this.nodeName) ||
 /text|hidden|password/i.test(this.type));
 })
 .map(function(i, elem){
 var val = jQuery(this).val();
 return val == null ? null :
 val.constructor == Array ?
 jQuery.map( val, function(val, i){
 return {name: elem.name, value: val};
 }) :
 {name: elem.name, value: val};
 }).get();
 }
});

// Attach a bunch of functions for handling common AJAX events
jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
 jQuery.fn[o] = function(f){
 return this.bind(o, f);
 };
});

var jsc = now();

jQuery.extend({
 get: function( url, data, callback, type ) {
 // shift arguments if data argument was ommited
 if ( jQuery.isFunction( data ) ) {
 callback = data;
 data = null;
 }

 return jQuery.ajax({
 type: "GET",
 url: url,
 data: data,
 success: callback,
 dataType: type
 });
 },

 getScript: function( url, callback ) {
 return jQuery.get(url, null, callback, "script");
 },

 getJSON: function( url, data, callback ) {
 return jQuery.get(url, data, callback, "json");
 },

 post: function( url, data, callback, type ) {
 if ( jQuery.isFunction( data ) ) {
 callback = data;
 data = {};
 }

 return jQuery.ajax({
 type: "POST",
 url: url,
 data: data,
 success: callback,
 dataType: type
 });
 },

 ajaxSetup: function( settings ) {
 jQuery.extend( jQuery.ajaxSettings, settings );
 },

 ajaxSettings: {
 url: location.href,
 global: true,
 type: "GET",
 timeout: 0,
 contentType: "application/x-www-form-urlencoded",
 processData: true,
 async: true,
 data: null,
 username: null,
 password: null,
 accepts: {
 xml: "application/xml, text/xml",
 html: "text/html",
 script: "text/javascript, application/javascript",
 json: "application/json, text/javascript",
 text: "text/plain",
 _default: "*/*"
 }
 },

 // Last-Modified header cache for next request
 lastModified: {},

 ajax: function( s ) {
 // Extend the settings, but re-extend 's' so that it can be
 // checked again later (in the test suite, specifically)
 s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));

 var jsonp, jsre = /=\?(&|$)/g, status, data,
 type = s.type.toUpperCase();

 // convert data if not already a string
 if ( s.data && s.processData && typeof s.data != "string" )
 s.data = jQuery.param(s.data);

 // Handle JSONP Parameter Callbacks
 if ( s.dataType == "jsonp" ) {
 if ( type == "GET" ) {
 if ( !s.url.match(jsre) )
 s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
 } else if ( !s.data || !s.data.match(jsre) )
 s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
 s.dataType = "json";
 }

 // Build temporary JSONP function
 if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
 jsonp = "jsonp" + jsc++;

 // Replace the =? sequence both in the query string and the data
 if ( s.data )
 s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
 s.url = s.url.replace(jsre, "=" + jsonp + "$1");

 // We need to make sure
 // that a JSONP style response is executed properly
 s.dataType = "script";

 // Handle JSONP-style loading
 window[ jsonp ] = function(tmp){
 data = tmp;
 success();
 complete();
 // Garbage collect
 window[ jsonp ] = undefined;
 try{ delete window[ jsonp ]; } catch(e){}
 if ( head )
 head.removeChild( script );
 };
 }

 if ( s.dataType == "script" && s.cache == null )
 s.cache = false;

 if ( s.cache === false && type == "GET" ) {
 var ts = now();
 // try replacing _= if it is there
 var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
 // if nothing was replaced, add timestamp to the end
 s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
 }

 // If data is available, append data to url for get requests
 if ( s.data && type == "GET" ) {
 s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;

 // IE likes to send both get and post data, prevent this
 s.data = null;
 }

 // Watch for a new set of requests
 if ( s.global && ! jQuery.active++ )
 jQuery.event.trigger( "ajaxStart" );

 // Matches an absolute URL, and saves the domain
 var remote = /^(?:\w+:)?\/\/([^\/?#]+)/;

 // If we're requesting a remote document
 // and trying to load JSON or Script with a GET
 if ( s.dataType == "script" && type == "GET"
 && remote.test(s.url) && remote.exec(s.url)[1] != location.host ){
 var head = document.getElementsByTagName("head")[0];
 var script = document.createElement("script");
 script.src = s.url;
 if (s.scriptCharset)
 script.charset = s.scriptCharset;

 // Handle Script loading
 if ( !jsonp ) {
 var done = false;

 // Attach handlers for all browsers
 script.onload = script.onreadystatechange = function(){
 if ( !done && (!this.readyState ||
 this.readyState == "loaded" || this.readyState == "complete") ) {
 done = true;
 success();
 complete();
 head.removeChild( script );
 }
 };
 }

 head.appendChild(script);

 // We handle everything using the script element injection
 return undefined;
 }

 var requestDone = false;

 // Create the request object; Microsoft failed to properly
 // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
 var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();

 // Open the socket
 // Passing null username, generates a login popup on Opera (#2865)
 if( s.username )
 xhr.open(type, s.url, s.async, s.username, s.password);
 else
 xhr.open(type, s.url, s.async);

 // Need an extra try/catch for cross domain requests in Firefox 3
 try {
 // Set the correct header, if data is being sent
 if ( s.data )
 xhr.setRequestHeader("Content-Type", s.contentType);

 // Set the If-Modified-Since header, if ifModified mode.
 if ( s.ifModified )
 xhr.setRequestHeader("If-Modified-Since",
 jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );

 // Set header so the called script knows that it's an XMLHttpRequest
 xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");

 // Set the Accepts header for the server, depending on the dataType
 xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
 s.accepts[ s.dataType ] + ", */*" :
 s.accepts._default );
 } catch(e){}

 // Allow custom headers/mimetypes
 if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
 // cleanup active request counter
 s.global && jQuery.active--;
 // close opended socket
 xhr.abort();
 return false;
 }

 if ( s.global )
 jQuery.event.trigger("ajaxSend", [xhr, s]);

 // Wait for a response to come back
 var onreadystatechange = function(isTimeout){
 // The transfer is complete and the data is available, or the request timed out
 if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
 requestDone = true;

 // clear poll interval
 if (ival) {
 clearInterval(ival);
 ival = null;
 }

 status = isTimeout == "timeout" && "timeout" ||
 !jQuery.httpSuccess( xhr ) && "error" ||
 s.ifModified && jQuery.httpNotModified( xhr, s.url ) && "notmodified" ||
 "success";

 if ( status == "success" ) {
 // Watch for, and catch, XML document parse errors
 try {
 // process the data (runs the xml through httpData regardless of callback)
 data = jQuery.httpData( xhr, s.dataType, s.dataFilter );
 } catch(e) {
 status = "parsererror";
 }
 }

 // Make sure that the request was successful or notmodified
 if ( status == "success" ) {
 // Cache Last-Modified header, if ifModified mode.
 var modRes;
 try {
 modRes = xhr.getResponseHeader("Last-Modified");
 } catch(e) {} // swallow exception thrown by FF if header is not available

 if ( s.ifModified && modRes )
 jQuery.lastModified[s.url] = modRes;

 // JSONP handles its own success callback
 if ( !jsonp )
 success();
 } else
 jQuery.handleError(s, xhr, status);

 // Fire the complete handlers
 complete();

 // Stop memory leaks
 if ( s.async )
 xhr = null;
 }
 };

 if ( s.async ) {
 // don't attach the handler to the request, just poll it instead
 var ival = setInterval(onreadystatechange, 13);

 // Timeout checker
 if ( s.timeout > 0 )
 setTimeout(function(){
 // Check to see if the request is still happening
 if ( xhr ) {
 // Cancel the request
 xhr.abort();

 if( !requestDone )
 onreadystatechange( "timeout" );
 }
 }, s.timeout);
 }

 // Send the data
 try {
 xhr.send(s.data);
 } catch(e) {
 jQuery.handleError(s, xhr, null, e);
 }

 // firefox 1.5 doesn't fire statechange for sync requests
 if ( !s.async )
 onreadystatechange();

 function success(){
 // If a local callback was specified, fire it and pass it the data
 if ( s.success )
 s.success( data, status );

 // Fire the global callback
 if ( s.global )
 jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
 }

 function complete(){
 // Process result
 if ( s.complete )
 s.complete(xhr, status);

 // The request was completed
 if ( s.global )
 jQuery.event.trigger( "ajaxComplete", [xhr, s] );

 // Handle the global AJAX counter
 if ( s.global && ! --jQuery.active )
 jQuery.event.trigger( "ajaxStop" );
 }

 // return XMLHttpRequest to allow aborting the request etc.
 return xhr;
 },

 handleError: function( s, xhr, status, e ) {
 // If a local callback was specified, fire it
 if ( s.error ) s.error( xhr, status, e );

 // Fire the global callback
 if ( s.global )
 jQuery.event.trigger( "ajaxError", [xhr, s, e] );
 },

 // Counter for holding the number of active queries
 active: 0,

 // Determines if an XMLHttpRequest was successful or not
 httpSuccess: function( xhr ) {
 try {
 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
 return !xhr.status && location.protocol == "file:" ||
 ( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223 ||
 jQuery.browser.safari && xhr.status == undefined;
 } catch(e){}
 return false;
 },

 // Determines if an XMLHttpRequest returns NotModified
 httpNotModified: function( xhr, url ) {
 try {
 var xhrRes = xhr.getResponseHeader("Last-Modified");

 // Firefox always returns 200. check Last-Modified date
 return xhr.status == 304 || xhrRes == jQuery.lastModified[url] ||
 jQuery.browser.safari && xhr.status == undefined;
 } catch(e){}
 return false;
 },

 httpData: function( xhr, type, filter ) {
 var ct = xhr.getResponseHeader("content-type"),
 xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
 data = xml ? xhr.responseXML : xhr.responseText;

 if ( xml && data.documentElement.tagName == "parsererror" )
 throw "parsererror";
 
 // Allow a pre-filtering function to sanitize the response
 if( filter )
 data = filter( data, type );

 // If the type is "script", eval it in global context
 if ( type == "script" )
 jQuery.globalEval( data );

 // Get the JavaScript object, if JSON is used.
 if ( type == "json" )
 data = eval("(" + data + ")");

 return data;
 },

 // Serialize an array of form elements or a set of
 // key/values into a query string
 param: function( a ) {
 var s = [];

 // If an array was passed in, assume that it is an array
 // of form elements
 if ( a.constructor == Array || a.jquery )
 // Serialize the form elements
 jQuery.each( a, function(){
 s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );
 });

 // Otherwise, assume that it's an object of key/value pairs
 else
 // Serialize the key/values
 for ( var j in a )
 // If the value is an array then the key names need to be repeated
 if ( a[j] && a[j].constructor == Array )
 jQuery.each( a[j], function(){
 s.push( encodeURIComponent(j) + "=" + encodeURIComponent( this ) );
 });
 else
 s.push( encodeURIComponent(j) + "=" + encodeURIComponent( jQuery.isFunction(a[j]) ? a[j]() : a[j] ) );

 // Return the resulting serialization
 return s.join("&").replace(/%20/g, "+");
 }

});
jQuery.fn.extend({
 show: function(speed,callback){
 return speed ?
 this.animate({
 height: "show", width: "show", opacity: "show"
 }, speed, callback) :

 this.filter(":hidden").each(function(){
 this.style.display = this.oldblock || "";
 if ( jQuery.css(this,"display") == "none" ) {
 var elem = jQuery("<" + this.tagName + " />").appendTo("body");
 this.style.display = elem.css("display");
 // handle an edge condition where css is - div { display:none; } or similar
 if (this.style.display == "none")
 this.style.display = "block";
 elem.remove();
 }
 }).end();
 },

 hide: function(speed,callback){
 return speed ?
 this.animate({
 height: "hide", width: "hide", opacity: "hide"
 }, speed, callback) :

 this.filter(":visible").each(function(){
 this.oldblock = this.oldblock || jQuery.css(this,"display");
 this.style.display = "none";
 }).end();
 },

 // Save the old toggle function
 _toggle: jQuery.fn.toggle,

 toggle: function( fn, fn2 ){
 return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
 this._toggle.apply( this, arguments ) :
 fn ?
 this.animate({
 height: "toggle", width: "toggle", opacity: "toggle"
 }, fn, fn2) :
 this.each(function(){
 jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
 });
 },

 slideDown: function(speed,callback){
 return this.animate({height: "show"}, speed, callback);
 },

 slideUp: function(speed,callback){
 return this.animate({height: "hide"}, speed, callback);
 },

 slideToggle: function(speed, callback){
 return this.animate({height: "toggle"}, speed, callback);
 },

 fadeIn: function(speed, callback){
 return this.animate({opacity: "show"}, speed, callback);
 },

 fadeOut: function(speed, callback){
 return this.animate({opacity: "hide"}, speed, callback);
 },

 fadeTo: function(speed,to,callback){
 return this.animate({opacity: to}, speed, callback);
 },

 animate: function( prop, speed, easing, callback ) {
 var optall = jQuery.speed(speed, easing, callback);

 return this[ optall.queue === false ? "each" : "queue" ](function(){
 if ( this.nodeType != 1)
 return false;

 var opt = jQuery.extend({}, optall), p,
 hidden = jQuery(this).is(":hidden"), self = this;

 for ( p in prop ) {
 if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
 return opt.complete.call(this);

 if ( p == "height" || p == "width" ) {
 // Store display property
 opt.display = jQuery.css(this, "display");

 // Make sure that nothing sneaks out
 opt.overflow = this.style.overflow;
 }
 }

 if ( opt.overflow != null )
 this.style.overflow = "hidden";

 opt.curAnim = jQuery.extend({}, prop);

 jQuery.each( prop, function(name, val){
 var e = new jQuery.fx( self, opt, name );

 if ( /toggle|show|hide/.test(val) )
 e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
 else {
 var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
 start = e.cur(true) || 0;

 if ( parts ) {
 var end = parseFloat(parts[2]),
 unit = parts[3] || "px";

 // We need to compute starting value
 if ( unit != "px" ) {
 self.style[ name ] = (end || 1) + unit;
 start = ((end || 1) / e.cur(true)) * start;
 self.style[ name ] = start + unit;
 }

 // If a +=/-= token was provided, we're doing a relative animation
 if ( parts[1] )
 end = ((parts[1] == "-=" ? -1 : 1) * end) + start;

 e.custom( start, end, unit );
 } else
 e.custom( start, val, "" );
 }
 });

 // For JS strict compliance
 return true;
 });
 },

 queue: function(type, fn){
 if ( jQuery.isFunction(type) || ( type && type.constructor == Array )) {
 fn = type;
 type = "fx";
 }

 if ( !type || (typeof type == "string" && !fn) )
 return queue( this[0], type );

 return this.each(function(){
 if ( fn.constructor == Array )
 queue(this, type, fn);
 else {
 queue(this, type).push( fn );

 if ( queue(this, type).length == 1 )
 fn.call(this);
 }
 });
 },

 stop: function(clearQueue, gotoEnd){
 var timers = jQuery.timers;

 if (clearQueue)
 this.queue([]);

 this.each(function(){
 // go in reverse order so anything added to the queue during the loop is ignored
 for ( var i = timers.length - 1; i >= 0; i-- )
 if ( timers[i].elem == this ) {
 if (gotoEnd)
 // force the next step to be the last
 timers[i](true);
 timers.splice(i, 1);
 }
 });

 // start the next in the queue if the last step wasn't forced
 if (!gotoEnd)
 this.dequeue();

 return this;
 }

});

var queue = function( elem, type, array ) {
 if ( elem ){

 type = type || "fx";

 var q = jQuery.data( elem, type + "queue" );

 if ( !q || array )
 q = jQuery.data( elem, type + "queue", jQuery.makeArray(array) );

 }
 return q;
};

jQuery.fn.dequeue = function(type){
 type = type || "fx";

 return this.each(function(){
 var q = queue(this, type);

 q.shift();

 if ( q.length )
 q[0].call( this );
 });
};

jQuery.extend({

 speed: function(speed, easing, fn) {
 var opt = speed && speed.constructor == Object ? speed : {
 complete: fn || !fn && easing ||
 jQuery.isFunction( speed ) && speed,
 duration: speed,
 easing: fn && easing || easing && easing.constructor != Function && easing
 };

 opt.duration = (opt.duration && opt.duration.constructor == Number ?
 opt.duration :
 jQuery.fx.speeds[opt.duration]) || jQuery.fx.speeds.def;

 // Queueing
 opt.old = opt.complete;
 opt.complete = function(){
 if ( opt.queue !== false )
 jQuery(this).dequeue();
 if ( jQuery.isFunction( opt.old ) )
 opt.old.call( this );
 };

 return opt;
 },

 easing: {
 linear: function( p, n, firstNum, diff ) {
 return firstNum + diff * p;
 },
 swing: function( p, n, firstNum, diff ) {
 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
 }
 },

 timers: [],
 timerId: null,

 fx: function( elem, options, prop ){
 this.options = options;
 this.elem = elem;
 this.prop = prop;

 if ( !options.orig )
 options.orig = {};
 }

});

jQuery.fx.prototype = {

 // Simple function for setting a style value
 update: function(){
 if ( this.options.step )
 this.options.step.call( this.elem, this.now, this );

 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );

 // Set display property to block for height/width animations
 if ( this.prop == "height" || this.prop == "width" )
 this.elem.style.display = "block";
 },

 // Get the current size
 cur: function(force){
 if ( this.elem[this.prop] != null && this.elem.style[this.prop] == null )
 return this.elem[ this.prop ];

 var r = parseFloat(jQuery.css(this.elem, this.prop, force));
 return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
 },

 // Start an animation from one number to another
 custom: function(from, to, unit){
 this.startTime = now();
 this.start = from;
 this.end = to;
 this.unit = unit || this.unit || "px";
 this.now = this.start;
 this.pos = this.state = 0;
 this.update();

 var self = this;
 function t(gotoEnd){
 return self.step(gotoEnd);
 }

 t.elem = this.elem;

 jQuery.timers.push(t);

 if ( jQuery.timerId == null ) {
 jQuery.timerId = setInterval(function(){
 var timers = jQuery.timers;

 for ( var i = 0; i < timers.length; i++ )
 if ( !timers[i]() )
 timers.splice(i--, 1);

 if ( !timers.length ) {
 clearInterval( jQuery.timerId );
 jQuery.timerId = null;
 }
 }, 13);
 }
 },

 // Simple 'show' function
 show: function(){
 // Remember where we started, so that we can go back to it later
 this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
 this.options.show = true;

 // Begin the animation
 this.custom(0, this.cur());

 // Make sure that we start at a small width/height to avoid any
 // flash of content
 if ( this.prop == "width" || this.prop == "height" )
 this.elem.style[this.prop] = "1px";

 // Start by showing the element
 jQuery(this.elem).show();
 },

 // Simple 'hide' function
 hide: function(){
 // Remember where we started, so that we can go back to it later
 this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
 this.options.hide = true;

 // Begin the animation
 this.custom(this.cur(), 0);
 },

 // Each step of an animation
 step: function(gotoEnd){
 var t = now();

 if ( gotoEnd || t > this.options.duration + this.startTime ) {
 this.now = this.end;
 this.pos = this.state = 1;
 this.update();

 this.options.curAnim[ this.prop ] = true;

 var done = true;
 for ( var i in this.options.curAnim )
 if ( this.options.curAnim[i] !== true )
 done = false;

 if ( done ) {
 if ( this.options.display != null ) {
 // Reset the overflow
 this.elem.style.overflow = this.options.overflow;

 // Reset the display
 this.elem.style.display = this.options.display;
 if ( jQuery.css(this.elem, "display") == "none" )
 this.elem.style.display = "block";
 }

 // Hide the element if the "hide" operation was done
 if ( this.options.hide )
 this.elem.style.display = "none";

 // Reset the properties, if the item has been hidden or shown
 if ( this.options.hide || this.options.show )
 for ( var p in this.options.curAnim )
 jQuery.attr(this.elem.style, p, this.options.orig[p]);
 }

 if ( done )
 // Execute the complete function
 this.options.complete.call( this.elem );

 return false;
 } else {
 var n = t - this.startTime;
 this.state = n / this.options.duration;

 // Perform the easing function, defaults to swing
 this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
 this.now = this.start + ((this.end - this.start) * this.pos);

 // Perform the next step of the animation
 this.update();
 }

 return true;
 }

};

jQuery.extend( jQuery.fx, {
 speeds:{
 slow: 600,
 fast: 200,
 // Default speed
 def: 400
 },
 step: {
 scrollLeft: function(fx){
 fx.elem.scrollLeft = fx.now;
 },

 scrollTop: function(fx){
 fx.elem.scrollTop = fx.now;
 },

 opacity: function(fx){
 jQuery.attr(fx.elem.style, "opacity", fx.now);
 },

 _default: function(fx){
 fx.elem.style[ fx.prop ] = fx.now + fx.unit;
 }
 }
});
// The Offset Method
// Originally By Brandon Aaron, part of the Dimension Plugin
// http://jquery.com/plugins/project/dimensions
jQuery.fn.offset = function() {
 var left = 0, top = 0, elem = this[0], results;

 if ( elem ) with ( jQuery.browser ) {
 var parent = elem.parentNode,
 offsetChild = elem,
 offsetParent = elem.offsetParent,
 doc = elem.ownerDocument,
 safari2 = safari && parseInt(version) < 522 && !/adobeair/i.test(userAgent),
 css = jQuery.curCSS,
 fixed = css(elem, "position") == "fixed";

 // Use getBoundingClientRect if available
 if ( elem.getBoundingClientRect ) {
 var box = elem.getBoundingClientRect();

 // Add the document scroll offsets
 add(box.left + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
 box.top + Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));

 // IE adds the HTML element's border, by default it is medium which is 2px
 // IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
 // IE 7 standards mode, the border is always 2px
 // This border/offset is typically represented by the clientLeft and clientTop properties
 // However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
 // Therefore this method will be off by 2px in IE while in quirksmode
 add( -doc.documentElement.clientLeft, -doc.documentElement.clientTop );

 // Otherwise loop through the offsetParents and parentNodes
 } else {

 // Initial element offsets
 add( elem.offsetLeft, elem.offsetTop );

 // Get parent offsets
 while ( offsetParent ) {
 // Add offsetParent offsets
 add( offsetParent.offsetLeft, offsetParent.offsetTop );

 // Mozilla and Safari > 2 does not include the border on offset parents
 // However Mozilla adds the border for table or table cells
 if ( mozilla && !/^t(able|d|h)$/i.test(offsetParent.tagName) || safari && !safari2 )
 border( offsetParent );

 // Add the document scroll offsets if position is fixed on any offsetParent
 if ( !fixed && css(offsetParent, "position") == "fixed" )
 fixed = true;

 // Set offsetChild to previous offsetParent unless it is the body element
 offsetChild = /^body$/i.test(offsetParent.tagName) ? offsetChild : offsetParent;
 // Get next offsetParent
 offsetParent = offsetParent.offsetParent;
 }

 // Get parent scroll offsets
 while ( parent && parent.tagName && !/^body|html$/i.test(parent.tagName) ) {
 // Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
 if ( !/^inline|table.*$/i.test(css(parent, "display")) )
 // Subtract parent scroll offsets
 add( -parent.scrollLeft, -parent.scrollTop );

 // Mozilla does not add the border for a parent that has overflow != visible
 if ( mozilla && css(parent, "overflow") != "visible" )
 border( parent );

 // Get next parent
 parent = parent.parentNode;
 }

 // Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
 // Mozilla doubles body offsets with a non-absolutely positioned offsetChild
 if ( (safari2 && (fixed || css(offsetChild, "position") == "absolute")) ||
 (mozilla && css(offsetChild, "position") != "absolute") )
 add( -doc.body.offsetLeft, -doc.body.offsetTop );

 // Add the document scroll offsets if position is fixed
 if ( fixed )
 add(Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
 Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
 }

 // Return an object with top and left properties
 results = { top: top, left: left };
 }

 function border(elem) {
 add( jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true) );
 }

 function add(l, t) {
 left += parseInt(l, 10) || 0;
 top += parseInt(t, 10) || 0;
 }

 return results;
};


jQuery.fn.extend({
 position: function() {
 var left = 0, top = 0, results;

 if ( this[0] ) {
 // Get *real* offsetParent
 var offsetParent = this.offsetParent(),

 // Get correct offsets
 offset = this.offset(),
 parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();

 // Subtract element margins
 // note: when an element has margin: auto the offsetLeft and marginLeft 
 // are the same in Safari causing offset.left to incorrectly be 0
 offset.top -= num( this, 'marginTop' );
 offset.left -= num( this, 'marginLeft' );

 // Add offsetParent borders
 parentOffset.top += num( offsetParent, 'borderTopWidth' );
 parentOffset.left += num( offsetParent, 'borderLeftWidth' );

 // Subtract the two offsets
 results = {
 top: offset.top - parentOffset.top,
 left: offset.left - parentOffset.left
 };
 }

 return results;
 },

 offsetParent: function() {
 var offsetParent = this[0].offsetParent;
 while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
 offsetParent = offsetParent.offsetParent;
 return jQuery(offsetParent);
 }
});


// Create scrollLeft and scrollTop methods
jQuery.each( ['Left', 'Top'], function(i, name) {
 var method = 'scroll' + name;
 
 jQuery.fn[ method ] = function(val) {
 if (!this[0]) return;

 return val != undefined ?

 // Set the scroll offset
 this.each(function() {
 this == window || this == document ?
 window.scrollTo(
 !i ? val : jQuery(window).scrollLeft(),
 i ? val : jQuery(window).scrollTop()
 ) :
 this[ method ] = val;
 }) :

 // Return the scroll offset
 this[0] == window || this[0] == document ?
 self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
 jQuery.boxModel && document.documentElement[ method ] ||
 document.body[ method ] :
 this[0][ method ];
 };
});
// Create innerHeight, innerWidth, outerHeight and outerWidth methods
jQuery.each([ "Height", "Width" ], function(i, name){

 var tl = i ? "Left" : "Top", // top or left
 br = i ? "Right" : "Bottom"; // bottom or right

 // innerHeight and innerWidth
 jQuery.fn["inner" + name] = function(){
 return this[ name.toLowerCase() ]() +
 num(this, "padding" + tl) +
 num(this, "padding" + br);
 };

 // outerHeight and outerWidth
 jQuery.fn["outer" + name] = function(margin) {
 return this["inner" + name]() +
 num(this, "border" + tl + "Width") +
 num(this, "border" + br + "Width") +
 (margin ?
 num(this, "margin" + tl) + num(this, "margin" + br) : 0);
 };

});})();

jQuery.noConflict();
/*
 * jQuery UI 1.5.3
 *
 * Copyright (c) 2008 Paul Bakaus (ui.jquery.com)
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.
 *
 * http://docs.jquery.com/UI
 */

;(function($) {

$.ui = {
 plugin: {
 add: function(module, option, set) {
 var proto = $.ui[module].prototype;
 for(var i in set) {
 proto.plugins[i] = proto.plugins[i] || [];
 proto.plugins[i].push([option, set[i]]);
 }
 },
 call: function(instance, name, args) {
 var set = instance.plugins[name];
 if(!set) { return; }
 
 for (var i = 0; i < set.length; i++) {
 if (instance.options[set[i][0]]) {
 set[i][1].apply(instance.element, args);
 }
 }
 } 
 },
 cssCache: {},
 css: function(name) {
 if ($.ui.cssCache[name]) { return $.ui.cssCache[name]; }
 var tmp = $('<div class="ui-gen">').addClass(name).css({position:'absolute', top:'-5000px', left:'-5000px', display:'block'}).appendTo('body');
 
 //if (!$.browser.safari)
 //tmp.appendTo('body'); 
 
 //Opera and Safari set width and height to 0px instead of auto
 //Safari returns rgba(0,0,0,0) when bgcolor is not set
 $.ui.cssCache[name] = !!(
 (!(/auto|default/).test(tmp.css('cursor')) || (/^[1-9]/).test(tmp.css('height')) || (/^[1-9]/).test(tmp.css('width')) || 
 !(/none/).test(tmp.css('backgroundImage')) || !(/transparent|rgba\(0, 0, 0, 0\)/).test(tmp.css('backgroundColor')))
 );
 try { $('body').get(0).removeChild(tmp.get(0)); } catch(e){}
 return $.ui.cssCache[name];
 },
 disableSelection: function(el) {
 $(el).attr('unselectable', 'on').css('MozUserSelect', 'none');
 },
 enableSelection: function(el) {
 $(el).attr('unselectable', 'off').css('MozUserSelect', '');
 },
 hasScroll: function(e, a) {
 var scroll = /top/.test(a||"top") ? 'scrollTop' : 'scrollLeft', has = false;
 if (e[scroll] > 0) return true; e[scroll] = 1;
 has = e[scroll] > 0 ? true : false; e[scroll] = 0;
 return has;
 }
};


/** jQuery core modifications and additions **/

var _remove = $.fn.remove;
$.fn.remove = function() {
 $("*", this).add(this).triggerHandler("remove");
 return _remove.apply(this, arguments );
};

// $.widget is a factory to create jQuery plugins
// taking some boilerplate code out of the plugin code
// created by Scott González and Jörn Zaefferer
function getter(namespace, plugin, method) {
 var methods = $[namespace][plugin].getter || [];
 methods = (typeof methods == "string" ? methods.split(/,?\s+/) : methods);
 return ($.inArray(method, methods) != -1);
}

$.widget = function(name, prototype) {
 var namespace = name.split(".")[0];
 name = name.split(".")[1];
 
 // create plugin method
 $.fn[name] = function(options) {
 var isMethodCall = (typeof options == 'string'),
 args = Array.prototype.slice.call(arguments, 1);
 
 if (isMethodCall && getter(namespace, name, options)) {
 var instance = $.data(this[0], name);
 return (instance ? instance[options].apply(instance, args)
 : undefined);
 }
 
 return this.each(function() {
 var instance = $.data(this, name);
 if (isMethodCall && instance && $.isFunction(instance[options])) {
 instance[options].apply(instance, args);
 } else if (!isMethodCall) {
 $.data(this, name, new $[namespace][name](this, options));
 }
 });
 };
 
 // create widget constructor
 $[namespace][name] = function(element, options) {
 var self = this;
 
 this.widgetName = name;
 this.widgetBaseClass = namespace + '-' + name;
 
 this.options = $.extend({}, $.widget.defaults, $[namespace][name].defaults, options);
 this.element = $(element)
 .bind('setData.' + name, function(e, key, value) {
 return self.setData(key, value);
 })
 .bind('getData.' + name, function(e, key) {
 return self.getData(key);
 })
 .bind('remove', function() {
 return self.destroy();
 });
 this.init();
 };
 
 // add widget prototype
 $[namespace][name].prototype = $.extend({}, $.widget.prototype, prototype);
};

$.widget.prototype = {
 init: function() {},
 destroy: function() {
 this.element.removeData(this.widgetName);
 },
 
 getData: function(key) {
 return this.options[key];
 },
 setData: function(key, value) {
 this.options[key] = value;
 
 if (key == 'disabled') {
 this.element[value ? 'addClass' : 'removeClass'](
 this.widgetBaseClass + '-disabled');
 }
 },
 
 enable: function() {
 this.setData('disabled', false);
 },
 disable: function() {
 this.setData('disabled', true);
 }
};

$.widget.defaults = {
 disabled: false
};


/** Mouse Interaction Plugin **/

$.ui.mouse = {
 mouseInit: function() {
 var self = this;
 
 this.element.bind('mousedown.'+this.widgetName, function(e) {
 return self.mouseDown(e);
 });
 
 // Prevent text selection in IE
 if ($.browser.msie) {
 this._mouseUnselectable = this.element.attr('unselectable');
 this.element.attr('unselectable', 'on');
 }
 
 this.started = false;
 },
 
 // TODO: make sure destroying one instance of mouse doesn't mess with
 // other instances of mouse
 mouseDestroy: function() {
 this.element.unbind('.'+this.widgetName);
 
 // Restore text selection in IE
 ($.browser.msie
 && this.element.attr('unselectable', this._mouseUnselectable));
 },
 
 mouseDown: function(e) {
 // we may have missed mouseup (out of window)
 (this._mouseStarted && this.mouseUp(e));
 
 this._mouseDownEvent = e;
 
 var self = this,
 btnIsLeft = (e.which == 1),
 elIsCancel = (typeof this.options.cancel == "string" ? $(e.target).parents().add(e.target).filter(this.options.cancel).length : false);
 if (!btnIsLeft || elIsCancel || !this.mouseCapture(e)) {
 return true;
 }
 
 this._mouseDelayMet = !this.options.delay;
 if (!this._mouseDelayMet) {
 this._mouseDelayTimer = setTimeout(function() {
 self._mouseDelayMet = true;
 }, this.options.delay);
 }
 
 if (this.mouseDistanceMet(e) && this.mouseDelayMet(e)) {
 this._mouseStarted = (this.mouseStart(e) !== false);
 if (!this._mouseStarted) {
 e.preventDefault();
 return true;
 }
 }
 
 // these delegates are required to keep context
 this._mouseMoveDelegate = function(e) {
 return self.mouseMove(e);
 };
 this._mouseUpDelegate = function(e) {
 return self.mouseUp(e);
 };
 $(document)
 .bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
 .bind('mouseup.'+this.widgetName, this._mouseUpDelegate);
 
 return false;
 },
 
 mouseMove: function(e) {
 // IE mouseup check - mouseup happened when mouse was out of window
 if ($.browser.msie && !e.button) {
 return this.mouseUp(e);
 }
 
 if (this._mouseStarted) {
 this.mouseDrag(e);
 return false;
 }
 
 if (this.mouseDistanceMet(e) && this.mouseDelayMet(e)) {
 this._mouseStarted =
 (this.mouseStart(this._mouseDownEvent, e) !== false);
 (this._mouseStarted ? this.mouseDrag(e) : this.mouseUp(e));
 }
 
 return !this._mouseStarted;
 },
 
 mouseUp: function(e) {
 $(document)
 .unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
 .unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
 
 if (this._mouseStarted) {
 this._mouseStarted = false;
 this.mouseStop(e);
 }
 
 return false;
 },
 
 mouseDistanceMet: function(e) {
 return (Math.max(
 Math.abs(this._mouseDownEvent.pageX - e.pageX),
 Math.abs(this._mouseDownEvent.pageY - e.pageY)
 ) >= this.options.distance
 );
 },
 
 mouseDelayMet: function(e) {
 return this._mouseDelayMet;
 },
 
 // These are placeholder methods, to be overriden by extending plugin
 mouseStart: function(e) {},
 mouseDrag: function(e) {},
 mouseStop: function(e) {},
 mouseCapture: function(e) { return true; }
};

$.ui.mouse.defaults = {
 cancel: null,
 distance: 1,
 delay: 0
};

})(jQuery);
/*
 * jQuery UI Tabs
 *
 * Copyright (c) 2007, 2008 Klaus Hartl (stilbuero.de)
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.
 *
 * http://docs.jquery.com/UI/Tabs
 *
 * Depends:
 * ui.core.js
 */
(function($) {

$.widget("ui.tabs", {
 init: function() {
 this.options.event += '.tabs'; // namespace event
 
 // create tabs
 this.tabify(true);
 },
 setData: function(key, value) {
 if ((/^selected/).test(key))
 this.select(value);
 else {
 this.options[key] = value;
 this.tabify();
 }
 },
 length: function() {
 return this.$tabs.length;
 },
 tabId: function(a) {
 return a.title && a.title.replace(/\s/g, '_').replace(/[^A-Za-z0-9\-_:\.]/g, '')
 || this.options.idPrefix + $.data(a);
 },
 ui: function(tab, panel) {
 return {
 options: this.options,
 tab: tab,
 panel: panel,
 index: this.$tabs.index(tab)
 };
 },
 tabify: function(init) {

 this.$lis = $('li:has(a[href])', this.element);
 this.$tabs = this.$lis.map(function() { return $('a', this)[0]; });
 this.$panels = $([]);

 var self = this, o = this.options;

 this.$tabs.each(function(i, a) {
 // inline tab
 if (a.hash && a.hash.replace('#', '')) // Safari 2 reports '#' for an empty hash
 self.$panels = self.$panels.add(a.hash);
 // remote tab
 else if ($(a).attr('href') != '#') { // prevent loading the page itself if href is just "#"
 $.data(a, 'href.tabs', a.href); // required for restore on destroy
 $.data(a, 'load.tabs', a.href); // mutable
 var id = self.tabId(a);
 a.href = '#' + id;
 var $panel = $('#' + id);
 if (!$panel.length) {
 $panel = $(o.panelTemplate).attr('id', id).addClass(o.panelClass)
 .insertAfter( self.$panels[i - 1] || self.element );
 $panel.data('destroy.tabs', true);
 }
 self.$panels = self.$panels.add( $panel );
 }
 // invalid tab href
 else
 o.disabled.push(i + 1);
 });

 if (init) {

 // attach necessary classes for styling if not present
 this.element.addClass(o.navClass);
 this.$panels.each(function() {
 var $this = $(this);
 $this.addClass(o.panelClass);
 });

 // Selected tab
 // use "selected" option or try to retrieve:
 // 1. from fragment identifier in url
 // 2. from cookie
 // 3. from selected class attribute on <li>
 if (o.selected === undefined) {
 if (location.hash) {
 this.$tabs.each(function(i, a) {
 if (a.hash == location.hash) {
 o.selected = i;
 // prevent page scroll to fragment
 if ($.browser.msie || $.browser.opera) { // && !o.remote
 var $toShow = $(location.hash), toShowId = $toShow.attr('id');
 $toShow.attr('id', '');
 setTimeout(function() {
 $toShow.attr('id', toShowId); // restore id
 }, 500);
 }
 scrollTo(0, 0);
 return false; // break
 }
 });
 }
 else if (o.cookie) {
 var index = parseInt($.cookie('ui-tabs' + $.data(self.element)),10);
 if (index && self.$tabs[index])
 o.selected = index;
 }
 else if (self.$lis.filter('.' + o.selectedClass).length)
 o.selected = self.$lis.index( self.$lis.filter('.' + o.selectedClass)[0] );
 }
 o.selected = o.selected === null || o.selected !== undefined ? o.selected : 0; // first tab selected by default

 // Take disabling tabs via class attribute from HTML
 // into account and update option properly.
 // A selected tab cannot become disabled.
 o.disabled = $.unique(o.disabled.concat(
 $.map(this.$lis.filter('.' + o.disabledClass),
 function(n, i) { return self.$lis.index(n); } )
 )).sort();
 if ($.inArray(o.selected, o.disabled) != -1)
 o.disabled.splice($.inArray(o.selected, o.disabled), 1);
 
 // highlight selected tab
 this.$panels.addClass(o.hideClass);
 this.$lis.removeClass(o.selectedClass);
 if (o.selected !== null) {
 this.$panels.eq(o.selected).show().removeClass(o.hideClass); // use show and remove class to show in any case no matter how it has been hidden before
 this.$lis.eq(o.selected).addClass(o.selectedClass);
 
 // seems to be expected behavior that the show callback is fired
 var onShow = function() {
 $(self.element).triggerHandler('tabsshow',
 [self.fakeEvent('tabsshow'), self.ui(self.$tabs[o.selected], self.$panels[o.selected])], o.show);
 }; 

 // load if remote tab
 if ($.data(this.$tabs[o.selected], 'load.tabs'))
 this.load(o.selected, onShow);
 // just trigger show event
 else
 onShow();
 
 }
 
 // clean up to avoid memory leaks in certain versions of IE 6
 $(window).bind('unload', function() {
 self.$tabs.unbind('.tabs');
 self.$lis = self.$tabs = self.$panels = null;
 });

 }

 // disable tabs
 for (var i = 0, li; li = this.$lis[i]; i++)
 $(li)[$.inArray(i, o.disabled) != -1 && !$(li).hasClass(o.selectedClass) ? 'addClass' : 'removeClass'](o.disabledClass);

 // reset cache if switching from cached to not cached
 if (o.cache === false)
 this.$tabs.removeData('cache.tabs');
 
 // set up animations
 var hideFx, showFx, baseFx = { 'min-width': 0, duration: 1 }, baseDuration = 'normal';
 if (o.fx && o.fx.constructor == Array)
 hideFx = o.fx[0] || baseFx, showFx = o.fx[1] || baseFx;
 else
 hideFx = showFx = o.fx || baseFx;

 // reset some styles to maintain print style sheets etc.
 var resetCSS = { display: '', overflow: '', height: '' };
 if (!$.browser.msie) // not in IE to prevent ClearType font issue
 resetCSS.opacity = '';

 // Hide a tab, animation prevents browser scrolling to fragment,
 // $show is optional.
 function hideTab(clicked, $hide, $show) {
 $hide.animate(hideFx, hideFx.duration || baseDuration, function() { //
 $hide.addClass(o.hideClass).css(resetCSS); // maintain flexible height and accessibility in print etc.
 if ($.browser.msie && hideFx.opacity)
 $hide[0].style.filter = '';
 if ($show)
 showTab(clicked, $show, $hide);
 });
 }

 // Show a tab, animation prevents browser scrolling to fragment,
 // $hide is optional.
 function showTab(clicked, $show, $hide) {
 if (showFx === baseFx)
 $show.css('display', 'block'); // prevent occasionally occuring flicker in Firefox cause by gap between showing and hiding the tab panels
 $show.animate(showFx, showFx.duration || baseDuration, function() {
 $show.removeClass(o.hideClass).css(resetCSS); // maintain flexible height and accessibility in print etc.
 if ($.browser.msie && showFx.opacity)
 $show[0].style.filter = '';

 // callback
 $(self.element).triggerHandler('tabsshow',
 [self.fakeEvent('tabsshow'), self.ui(clicked, $show[0])], o.show);

 });
 }

 // switch a tab
 function switchTab(clicked, $li, $hide, $show) {
 /*if (o.bookmarkable && trueClick) { // add to history only if true click occured, not a triggered click
 $.ajaxHistory.update(clicked.hash);
 }*/
 $li.addClass(o.selectedClass)
 .siblings().removeClass(o.selectedClass);
 hideTab(clicked, $hide, $show);
 }

 // attach tab event handler, unbind to avoid duplicates from former tabifying...
 this.$tabs.unbind('.tabs').bind(o.event, function() {

 //var trueClick = e.clientX; // add to history only if true click occured, not a triggered click
 var $li = $(this).parents('li:eq(0)'),
 $hide = self.$panels.filter(':visible'),
 $show = $(this.hash);

 // If tab is already selected and not unselectable or tab disabled or 
 // or is already loading or click callback returns false stop here.
 // Check if click handler returns false last so that it is not executed
 // for a disabled or loading tab!
 if (($li.hasClass(o.selectedClass) && !o.unselect)
 || $li.hasClass(o.disabledClass) 
 || $(this).hasClass(o.loadingClass)
 || $(self.element).triggerHandler('tabsselect', [self.fakeEvent('tabsselect'), self.ui(this, $show[0])], o.select) === false
 ) {
 this.blur();
 return false;
 }

 self.options.selected = self.$tabs.index(this);

 // if tab may be closed
 if (o.unselect) {
 if ($li.hasClass(o.selectedClass)) {
 self.options.selected = null;
 $li.removeClass(o.selectedClass);
 self.$panels.stop();
 hideTab(this, $hide);
 this.blur();
 return false;
 } else if (!$hide.length) {
 self.$panels.stop();
 var a = this;
 self.load(self.$tabs.index(this), function() {
 $li.addClass(o.selectedClass).addClass(o.unselectClass);
 showTab(a, $show);
 });
 this.blur();
 return false;
 }
 }

 if (o.cookie)
 $.cookie('ui-tabs' + $.data(self.element), self.options.selected, o.cookie);

 // stop possibly running animations
 self.$panels.stop();

 // show new tab
 if ($show.length) {

 // prevent scrollbar scrolling to 0 and than back in IE7, happens only if bookmarking/history is enabled
 /*if ($.browser.msie && o.bookmarkable) {
 var showId = this.hash.replace('#', '');
 $show.attr('id', '');
 setTimeout(function() {
 $show.attr('id', showId); // restore id
 }, 0);
 }*/

 var a = this;
 self.load(self.$tabs.index(this), $hide.length ? 
 function() {
 switchTab(a, $li, $hide, $show);
 } :
 function() {
 $li.addClass(o.selectedClass);
 showTab(a, $show);
 }
 );

 // Set scrollbar to saved position - need to use timeout with 0 to prevent browser scroll to target of hash
 /*var scrollX = window.pageXOffset || document.documentElement && document.documentElement.scrollLeft || document.body.scrollLeft || 0;
 var scrollY = window.pageYOffset || document.documentElement && document.documentElement.scrollTop || document.body.scrollTop || 0;
 setTimeout(function() {
 scrollTo(scrollX, scrollY);
 }, 0);*/

 } else
 throw 'jQuery UI Tabs: Mismatching fragment identifier.';

 // Prevent IE from keeping other link focussed when using the back button
 // and remove dotted border from clicked link. This is controlled in modern
 // browsers via CSS, also blur removes focus from address bar in Firefox
 // which can become a usability and annoying problem with tabsRotate.
 if ($.browser.msie)
 this.blur();

 //return o.bookmarkable && !!trueClick; // convert trueClick == undefined to Boolean required in IE
 return false;

 });

 // disable click if event is configured to something else
 if (!(/^click/).test(o.event))
 this.$tabs.bind('click.tabs', function() { return false; });

 },
 add: function(url, label, index) {
 if (index == undefined) 
 index = this.$tabs.length; // append by default

 var o = this.options;
 var $li = $(o.tabTemplate.replace(/#\{href\}/g, url).replace(/#\{label\}/g, label));
 $li.data('destroy.tabs', true);

 var id = url.indexOf('#') == 0 ? url.replace('#', '') : this.tabId( $('a:first-child', $li)[0] );

 // try to find an existing element before creating a new one
 var $panel = $('#' + id);
 if (!$panel.length) {
 $panel = $(o.panelTemplate).attr('id', id)
 .addClass(o.hideClass)
 .data('destroy.tabs', true);
 }
 $panel.addClass(o.panelClass);
 if (index >= this.$lis.length) {
 $li.appendTo(this.element);
 $panel.appendTo(this.element[0].parentNode);
 } else {
 $li.insertBefore(this.$lis[index]);
 $panel.insertBefore(this.$panels[index]);
 }
 
 o.disabled = $.map(o.disabled,
 function(n, i) { return n >= index ? ++n : n });
 
 this.tabify();

 if (this.$tabs.length == 1) {
 $li.addClass(o.selectedClass);
 $panel.removeClass(o.hideClass);
 var href = $.data(this.$tabs[0], 'load.tabs');
 if (href)
 this.load(index, href);
 }

 // callback
 this.element.triggerHandler('tabsadd',
 [this.fakeEvent('tabsadd'), this.ui(this.$tabs[index], this.$panels[index])], o.add
 );
 },
 remove: function(index) {
 var o = this.options, $li = this.$lis.eq(index).remove(),
 $panel = this.$panels.eq(index).remove();

 // If selected tab was removed focus tab to the right or
 // in case the last tab was removed the tab to the left.
 if ($li.hasClass(o.selectedClass) && this.$tabs.length > 1)
 this.select(index + (index + 1 < this.$tabs.length ? 1 : -1));

 o.disabled = $.map($.grep(o.disabled, function(n, i) { return n != index; }),
 function(n, i) { return n >= index ? --n : n });

 this.tabify();

 // callback
 this.element.triggerHandler('tabsremove',
 [this.fakeEvent('tabsremove'), this.ui($li.find('a')[0], $panel[0])], o.remove
 );
 },
 enable: function(index) {
 var o = this.options;
 if ($.inArray(index, o.disabled) == -1)
 return;
 
 var $li = this.$lis.eq(index).removeClass(o.disabledClass);
 if ($.browser.safari) { // fix disappearing tab (that used opacity indicating disabling) after enabling in Safari 2...
 $li.css('display', 'inline-block');
 setTimeout(function() {
 $li.css('display', 'block');
 }, 0);
 }

 o.disabled = $.grep(o.disabled, function(n, i) { return n != index; });

 // callback
 this.element.triggerHandler('tabsenable',
 [this.fakeEvent('tabsenable'), this.ui(this.$tabs[index], this.$panels[index])], o.enable
 );

 },
 disable: function(index) {
 var self = this, o = this.options;
 if (index != o.selected) { // cannot disable already selected tab
 this.$lis.eq(index).addClass(o.disabledClass);

 o.disabled.push(index);
 o.disabled.sort();

 // callback
 this.element.triggerHandler('tabsdisable',
 [this.fakeEvent('tabsdisable'), this.ui(this.$tabs[index], this.$panels[index])], o.disable
 );
 }
 },
 select: function(index) {
 if (typeof index == 'string')
 index = this.$tabs.index( this.$tabs.filter('[href$=' + index + ']')[0] );
 this.$tabs.eq(index).trigger(this.options.event);
 },
 load: function(index, callback) { // callback is for internal usage only
 
 var self = this, o = this.options, $a = this.$tabs.eq(index), a = $a[0],
 bypassCache = callback == undefined || callback === false, url = $a.data('load.tabs');

 callback = callback || function() {};
 
 // no remote or from cache - just finish with callback
 if (!url || !bypassCache && $.data(a, 'cache.tabs')) {
 callback();
 return;
 }

 // load remote from here on
 
 var inner = function(parent) {
 var $parent = $(parent), $inner = $parent.find('*:last');
 return $inner.length && $inner.is(':not(img)') && $inner || $parent;
 };
 var cleanup = function() {
 self.$tabs.filter('.' + o.loadingClass).removeClass(o.loadingClass)
 .each(function() {
 if (o.spinner)
 inner(this).parent().html(inner(this).data('label.tabs'));
 });
 self.xhr = null;
 };
 
 if (o.spinner) {
 var label = inner(a).html();
 inner(a).wrapInner('<em></em>')
 .find('em').data('label.tabs', label).html(o.spinner);
 }

 var ajaxOptions = $.extend({}, o.ajaxOptions, {
 url: url,
 success: function(r, s) {
 $(a.hash).html(r);
 cleanup();
 
 if (o.cache)
 $.data(a, 'cache.tabs', true); // if loaded once do not load them again

 // callbacks
 $(self.element).triggerHandler('tabsload',
 [self.fakeEvent('tabsload'), self.ui(self.$tabs[index], self.$panels[index])], o.load
 );
 o.ajaxOptions.success && o.ajaxOptions.success(r, s);
 
 // This callback is required because the switch has to take
 // place after loading has completed. Call last in order to 
 // fire load before show callback...
 callback();
 }
 });
 if (this.xhr) {
 // terminate pending requests from other tabs and restore tab label
 this.xhr.abort();
 cleanup();
 }
 $a.addClass(o.loadingClass);
 setTimeout(function() { // timeout is again required in IE, "wait" for id being restored
 self.xhr = $.ajax(ajaxOptions);
 }, 0);

 },
 url: function(index, url) {
 this.$tabs.eq(index).removeData('cache.tabs').data('load.tabs', url);
 },
 destroy: function() {
 var o = this.options;
 this.element.unbind('.tabs')
 .removeClass(o.navClass).removeData('tabs');
 this.$tabs.each(function() {
 var href = $.data(this, 'href.tabs');
 if (href)
 this.href = href;
 var $this = $(this).unbind('.tabs');
 $.each(['href', 'load', 'cache'], function(i, prefix) {
 $this.removeData(prefix + '.tabs');
 });
 });
 this.$lis.add(this.$panels).each(function() {
 if ($.data(this, 'destroy.tabs'))
 $(this).remove();
 else
 $(this).removeClass([o.selectedClass, o.unselectClass,
 o.disabledClass, o.panelClass, o.hideClass].join(' '));
 });
 },
 fakeEvent: function(type) {
 return $.event.fix({
 type: type,
 target: this.element[0]
 });
 }
});

$.ui.tabs.defaults = {
 // basic setup
 unselect: false,
 event: 'click',
 disabled: [],
 cookie: null, // e.g. { expires: 7, path: '/', domain: 'jquery.com', secure: true }
 // TODO history: false,

 // Ajax
 spinner: 'Loading&#8230;',
 cache: false,
 idPrefix: 'ui-tabs-',
 ajaxOptions: {},

 // animations
 fx: null, // e.g. { height: 'toggle', opacity: 'toggle', duration: 200 }

 // templates
 tabTemplate: '<li><a href="#{href}"><span>#{label}</span></a></li>',
 panelTemplate: '<div></div>',

 // CSS classes
 navClass: 'ui-tabs-nav',
 selectedClass: 'ui-tabs-selected',
 unselectClass: 'ui-tabs-unselect',
 disabledClass: 'ui-tabs-disabled',
 panelClass: 'ui-tabs-panel',
 hideClass: 'ui-tabs-hide',
 loadingClass: 'ui-tabs-loading'
};

$.ui.tabs.getter = "length";

/*
 * Tabs Extensions
 */

/*
 * Rotate
 */
$.extend($.ui.tabs.prototype, {
 rotation: null,
 rotate: function(ms, continuing) {
 
 continuing = continuing || false;
 
 var self = this, t = this.options.selected;
 
 function start() {
 self.rotation = setInterval(function() {
 t = ++t < self.$tabs.length ? t : 0;
 self.select(t);
 }, ms); 
 }
 
 function stop(e) {
 if (!e || e.clientX) { // only in case of a true click
 clearInterval(self.rotation);
 }
 }
 
 // start interval
 if (ms) {
 start();
 if (!continuing)
 this.$tabs.bind(this.options.event, stop);
 else
 this.$tabs.bind(this.options.event, function() {
 stop();
 t = self.options.selected;
 start();
 });
 }
 // stop interval
 else {
 stop();
 this.$tabs.unbind(this.options.event, stop);
 }
 }
});

})(jQuery);



// $(document).ready(function(){
// $("#content_tabs > ul").tabs();
// // $("#slide_tabs > ul").tabs();
// 
// var tabs = $("#slide_tabs > li").length - 2;
// var cur_tab = 1;
// $("#slide_tabs > li").click(function(){
// // $("#slide_tabs > li:eq("+cur_tab+") :first-child").removeClass("hide_it");
// var tab_key = $("#slide_tabs > li").index(this);
// var panels_left = -((tab_key - 1) * 618);
// // alert(panels_left);
// if((tab_key != 0) && (tab_key != (tabs + 1))) {
// $("#drop_tab").remove();
// // this.$("span").attr("id", "tab_selected");
// // this.span.css("visibility","hidden");
// $(this).children("span").addClass("hide_it");
// $(this).append("<div id='drop_tab'><a href='javascript: void(0)' class='drop_tab_l'><span class='drop_tab_r'>"+$(this).text()+"</span></a></div>");
// 
// cur_tab = tab_key;
// $("#drop_tab").animate({"top": "+=52px"}, 100, function(){$("#slide_tabs > li:eq("+cur_tab+") :first-child").removeClass("hide_it")});
// $(".panels").animate({"left": panels_left}, "slow");
// return false;
// }
// });
// $("#panel_left").click(function(){
// // alert(cur_tab);
// 
// tab_key = ((cur_tab == 1) ? tabs : (cur_tab -1));
// // $("#slide_tabs > li:eq("+tab_key+")").children("span").addClass("hide_it");
// $("#slide_tabs > li:eq("+tab_key+")").trigger("click");
// 
// });
// $("#panel_right").click(function(){
// tab_key = ((cur_tab == tabs) ? 1 : (cur_tab +1));
// $("#slide_tabs > li:eq("+tab_key+")").trigger("click"); 
// });
// 
// $("#slide_tabs>li:eq(1)").trigger("click");
// });
// jQuery(document).ready(function($){
// $("#content_tabs > ul").tabs();
// });
//Step Carousel Viewer: By Dynamic Drive, at http://www.dynamicdrive.com
//** Created: March 19th, 08'
//** Aug 16th, 08'- Updated to v 1.4:
 //1) Adds ability to set speed/duration of panel animation (in milliseconds)
 //2) Adds persistence support, so the last viewed panel is recalled when viewer returns within same browser session
 //3) Adds ability to specify whether panels should stop at the very last and first panel, or wrap around and start all over again
 //4) Adds option to specify two navigational image links positioned to the left and right of the Carousel Viewer to move the panels back and forth

//** Aug 27th, 08'- Nav buttons (if enabled) also repositions themselves now if window is resized

//** Sept 23rd, 08'- Updated to v 1.6:
 //1) Carousel now stops at the very last visible panel, instead of the last panel itself. In other words, no more white space at the end.
 //2) Adds ability for Carousel to auto rotate dictated by the new parameter: autostep: {enable:true, moveby:1, pause:3000}
 //2i) During Auto Rotate, Carousel pauses onMouseover, resumes onMouseout. Clicking Carousel halts auto rotate.

//** Oct 22nd, 08'- Updated to v 1.6.1, which fixes functions stepBy() and stepTo() not stopping auto stepping of Carousel when called.

var stepcarousel={
 ajaxloadingmsg: '<div style="margin: 1em; font-weight: bold"><img src="ajaxloadr.gif" style="vertical-align: middle" /> Fetching Content. Please wait...</div>', //customize HTML to show while fetching Ajax content
 defaultbuttonsfade: 0.4, //Fade degree for disabled nav buttons (0=completely transparent, 1=completely opaque)
 configholder: {},

 getCSSValue:function(val){ //Returns either 0 (if val contains 'auto') or val as an integer
 return (val=="auto")? 0 : parseInt(val)
 },

 getremotepanels:function($, config){ //function to fetch external page containing the panel DIVs
 config.$belt.html(this.ajaxloadingmsg)
 $.ajax({
 url: config.contenttype[1], //path to external content
 async: true,
 error:function(ajaxrequest){
 config.$belt.html('Error fetching content.<br />Server Response: '+ajaxrequest.responseText)
 },
 success:function(content){
 config.$belt.html(content)
 config.$panels=config.$gallery.find('.'+config.panelclass)
 stepcarousel.alignpanels($, config)
 }
 })
 },

 getoffset:function(what, offsettype){
 return (what.offsetParent)? what[offsettype]+this.getoffset(what.offsetParent, offsettype) : what[offsettype]
 },

 getCookie:function(Name){ 
 var re=new RegExp(Name+"=[^;]+", "i"); //construct RE to search for target name/value pair
 if (document.cookie.match(re)) //if cookie found
 return document.cookie.match(re)[0].split("=")[1] //return its value
 return null
 },

 setCookie:function(name, value){
 document.cookie = name+"="+value
 },

 fadebuttons:function(config, currentpanel){
 config.$leftnavbutton.fadeTo('fast', currentpanel==0? this.defaultbuttonsfade : 1)
 config.$rightnavbutton.fadeTo('fast', currentpanel==config.lastvisiblepanel? this.defaultbuttonsfade : 1)
 },

 addnavbuttons:function(config, currentpanel){
 jQuery(document).ready(function($){
 config.$leftnavbutton=$('<img src="'+config.defaultbuttons.leftnav[0]+'">').css({zIndex:50, position:'absolute', left:config.offsets.left+config.defaultbuttons.leftnav[1]+'px', top:config.offsets.top+config.defaultbuttons.leftnav[2]+'px', cursor:'hand', cursor:'pointer'}).attr({title:'Back '+config.defaultbuttons.moveby+' panels'}).appendTo('body')
 config.$rightnavbutton=$('<img src="'+config.defaultbuttons.rightnav[0]+'">').css({zIndex:50, position:'absolute', left:config.offsets.left+config.$gallery.get(0).offsetWidth+config.defaultbuttons.rightnav[1]+'px', top:config.offsets.top+config.defaultbuttons.rightnav[2]+'px', cursor:'hand', cursor:'pointer'}).attr({title:'Forward '+config.defaultbuttons.moveby+' panels'}).appendTo('body')
 });
 config.$leftnavbutton.bind('click', function(){ //assign nav button event handlers
 stepcarousel.stepBy(config.galleryid, -config.defaultbuttons.moveby)
 })
 config.$rightnavbutton.bind('click', function(){ //assign nav button event handlers
 stepcarousel.stepBy(config.galleryid, config.defaultbuttons.moveby)
 })
 if (config.panelbehavior.wraparound==false){ //if carousel viewer should stop at first or last panel (instead of wrap back or forth)
 this.fadebuttons(config, currentpanel)
 }
 return config.$leftnavbutton.add(config.$rightnavbutton)
 
 },

 stopautostep:function(config){
 clearTimeout(config.steptimer)
 clearTimeout(config.resumeautostep)
 },

 alignpanels:function($, config){
 var paneloffset=0
 config.paneloffsets=[paneloffset] //array to store upper left offset of each panel (1st element=0)
 config.panelwidths=[] //array to store widths of each panel
 config.$panels.each(function(index){ //loop through panels
 var $currentpanel=$(this)
 $currentpanel.css({float: 'none', position: 'absolute', left: paneloffset+'px'}) //position panel
 $currentpanel.bind('click', function(e){return config.onpanelclick(e.target)}) //bind onpanelclick() to onclick event
 paneloffset+=stepcarousel.getCSSValue($currentpanel.css('marginRight')) + parseInt($currentpanel.get(0).offsetWidth || $currentpanel.css('width')) //calculate next panel offset
 config.paneloffsets.push(paneloffset) //remember this offset
 config.panelwidths.push(paneloffset-config.paneloffsets[config.paneloffsets.length-2]) //remember panel width
 })
 config.paneloffsets.pop() //delete last offset (redundant)
 var addpanelwidths=0
 var lastpanelindex=config.$panels.length-1
 config.lastvisiblepanel=lastpanelindex
 for (var i=config.$panels.length-1; i>=0; i--){
 addpanelwidths+=(i==lastpanelindex? config.panelwidths[lastpanelindex] : config.paneloffsets[i+1]-config.paneloffsets[i])
 if (config.gallerywidth>addpanelwidths){
 config.lastvisiblepanel=i //calculate index of panel that when in 1st position reveals the very last panel all at once based on gallery width
 }
 }
 config.$belt.css({width: paneloffset+'px'}) //Set Belt DIV to total panels' widths
 config.currentpanel=(config.panelbehavior.persist)? parseInt(this.getCookie(window[config.galleryid+"persist"])) : 0 //determine 1st panel to show by default
 config.currentpanel=(typeof config.currentpanel=="number" && config.currentpanel<config.$panels.length)? config.currentpanel : 0
 if (config.currentpanel!=0){
 var endpoint=config.paneloffsets[config.currentpanel]+(config.currentpanel==0? 0 : config.beltoffset)
 config.$belt.css({left: -endpoint+'px'})
 }
 if (config.defaultbuttons.enable==true){ //if enable default back/forth nav buttons
 var $navbuttons=this.addnavbuttons(config, config.currentpanel)
 $(window).bind("load resize", function(){ //refresh position of nav buttons when page loads/resizes, in case offsets weren't available document.oncontentload
 config.offsets={left:stepcarousel.getoffset(config.$gallery.get(0), "offsetLeft"), top:stepcarousel.getoffset(config.$gallery.get(0), "offsetTop")}
 config.$leftnavbutton.css({left:config.offsets.left+config.defaultbuttons.leftnav[1]+'px', top:config.offsets.top+config.defaultbuttons.leftnav[2]+'px'})
 config.$rightnavbutton.css({left:config.offsets.left+config.$gallery.get(0).offsetWidth+config.defaultbuttons.rightnav[1]+'px', top:config.offsets.top+config.defaultbuttons.rightnav[2]+'px'})
 })
 }
 if (config.autostep && config.autostep.enable){ //enable auto stepping of Carousel? 
 var $carouselparts=config.$gallery.add(typeof $navbuttons!="undefined"? $navbuttons : null)
 $carouselparts.bind('click', function(){
 stepcarousel.stopautostep(config)
 config.autostep.status="stopped"
 })
 $carouselparts.hover(function(){ //onMouseover
 stepcarousel.stopautostep(config)
 config.autostep.hoverstate="over"
 }, function(){ //onMouseout
 if (config.steptimer && config.autostep.hoverstate=="over" && config.autostep.status!="stopped"){
 config.resumeautostep=setTimeout(function(){
 stepcarousel.autorotate(config.galleryid)
 config.autostep.hoverstate="out"
 }, 500)
 }
 })
 config.steptimer=setTimeout(function(){stepcarousel.autorotate(config.galleryid)}, config.autostep.pause) //automatically rotate Carousel Viewer
 } //end enable auto stepping check
 this.statusreport(config.galleryid)
 config.oninit()
 config.onslideaction(this)
 },

 stepTo:function(galleryid, pindex){ /*User entered pindex starts at 1 for intuitiveness. Internally pindex still starts at 0 */
 var config=stepcarousel.configholder[galleryid]
 if (typeof config=="undefined"){
 alert("There's an error with your set up of Carousel Viewer \""+galleryid+ "\"!")
 return
 }
 stepcarousel.stopautostep(config)
 var pindex=Math.min(pindex-1, config.paneloffsets.length-1)
 var endpoint=config.paneloffsets[pindex]+(pindex==0? 0 : config.beltoffset)
 if (config.panelbehavior.wraparound==false && config.defaultbuttons.enable==true){ //if carousel viewer should stop at first or last panel (instead of wrap back or forth)
 this.fadebuttons(config, pindex)
 }
 config.$belt.animate({left: -endpoint+'px'}, config.panelbehavior.speed, function(){config.onslideaction(this)})
 config.currentpanel=pindex
 this.statusreport(galleryid)
 },

 stepBy:function(galleryid, steps){ //isauto if defined indicates stepBy() is being called automatically
 var config=stepcarousel.configholder[galleryid]
 if (typeof config=="undefined"){
 alert("There's an error with your set up of Carousel Viewer \""+galleryid+ "\"!")
 return
 }
 stepcarousel.stopautostep(config)
 var direction=(steps>0)? 'forward' : 'back' //If "steps" is negative, that means backwards
 var pindex=config.currentpanel+steps //index of panel to stop at
 if (config.panelbehavior.wraparound==false){ //if carousel viewer should stop at first or last panel (instead of wrap back or forth)
 pindex=(direction=="back" && pindex<=0)? 0 : (direction=="forward")? Math.min(pindex, config.lastvisiblepanel) : pindex
 if (config.defaultbuttons.enable==true){ //if default nav buttons are enabled, fade them in and out depending on if at start or end of carousel
 stepcarousel.fadebuttons(config, pindex)
 } 
 }
 else{ //else, for normal stepBy behavior
 if (pindex>config.lastvisiblepanel && direction=="forward"){
 //if destination pindex is greater than last visible panel, yet we're currently not at the end of the carousel yet
 pindex=(config.currentpanel<config.lastvisiblepanel)? config.lastvisiblepanel : 0
 }
 else if (pindex<0 && direction=="back"){
 //if destination pindex is less than 0, yet we're currently not at the beginning of the carousel yet
 pindex=(config.currentpanel>0)? 0 : config.lastvisiblepanel /*wrap around left*/
 }
 }
 var endpoint=config.paneloffsets[pindex]+(pindex==0? 0 : config.beltoffset) //left distance for Belt DIV to travel to
 if (pindex==0 && direction=='forward' || config.currentpanel==0 && direction=='back' && config.panelbehavior.wraparound==true){ //decide whether to apply "push pull" effect
 config.$belt.animate({left: -config.paneloffsets[config.currentpanel]-(direction=='forward'? 100 : -30)+'px'}, 'normal', function(){
 config.$belt.animate({left: -endpoint+'px'}, config.panelbehavior.speed, function(){config.onslideaction(this)})
 })
 }
 else
 config.$belt.animate({left: -endpoint+'px'}, config.panelbehavior.speed, function(){config.onslideaction(this)})
 config.currentpanel=pindex
 this.statusreport(galleryid)
 },

 autorotate:function(galleryid){
 var config=stepcarousel.configholder[galleryid]
 if (config.$gallery.attr('_ismouseover')!="yes"){
 this.stepBy(galleryid, config.autostep.moveby)
 }
 config.steptimer=setTimeout(function(){stepcarousel.autorotate(galleryid)}, config.autostep.pause)
 },

 statusreport:function(galleryid){
 var config=stepcarousel.configholder[galleryid]
 var startpoint=config.currentpanel //index of first visible panel 
 var visiblewidth=0
 for (var endpoint=startpoint; endpoint<config.paneloffsets.length; endpoint++){ //index (endpoint) of last visible panel
 visiblewidth+=config.panelwidths[endpoint]
 if (visiblewidth>config.gallerywidth){
 break
 }
 }
 startpoint+=1 //format startpoint for user friendiness
 endpoint=(endpoint+1==startpoint)? startpoint : endpoint //If only one image visible on the screen and partially hidden, set endpoint to startpoint
 var valuearray=[startpoint, endpoint, config.panelwidths.length]
 for (var i=0; i<config.statusvars.length; i++){
 window[config.statusvars[i]]=valuearray[i] //Define variable (with user specified name) and set to one of the status values
 config.$statusobjs[i].text(valuearray[i]+" ") //Populate element on page with ID="user specified name" with one of the status values
 }
 },

 setup:function(config){
 //Disable Step Gallery scrollbars ASAP dynamically (enabled for sake of users with JS disabled)
 document.write('<style type="text/css">\n#'+config.galleryid+'{overflow: hidden;}\n</style>')
 jQuery(document).ready(function($){
 config.$gallery=$('#'+config.galleryid)
 config.gallerywidth=config.$gallery.width()
 config.offsets={left:stepcarousel.getoffset(config.$gallery.get(0), "offsetLeft"), top:stepcarousel.getoffset(config.$gallery.get(0), "offsetTop")}
 config.$belt=config.$gallery.find('.'+config.beltclass) //Find Belt DIV that contains all the panels
 config.$panels=config.$gallery.find('.'+config.panelclass) //Find Panel DIVs that each contain a slide
 config.panelbehavior.wraparound=(config.autostep && config.autostep.enable)? true : config.panelbehavior.wraparound //if auto step enabled, set "wraparound" to true
 config.onpanelclick=(typeof config.onpanelclick=="undefined")? function(target){} : config.onpanelclick //attach custom "onpanelclick" event handler
 config.onslideaction=(typeof config.onslide=="undefined")? function(){} : function(beltobj){$(beltobj).stop(); config.onslide()} //attach custom "onslide" event handler
 config.oninit=(typeof config.oninit=="undefined")? function(){} : config.oninit //attach custom "oninit" event handler
 config.beltoffset=stepcarousel.getCSSValue(config.$belt.css('marginLeft')) //Find length of Belt DIV's left margin
 config.statusvars=config.statusvars || [] //get variable names that will hold "start", "end", and "total" slides info
 config.$statusobjs=[$('#'+config.statusvars[0]), $('#'+config.statusvars[1]), $('#'+config.statusvars[2])]
 config.currentpanel=0
 stepcarousel.configholder[config.galleryid]=config //store config parameter as a variable
 if (config.contenttype[0]=="ajax" && typeof config.contenttype[1]!="undefined") //fetch ajax content?
 stepcarousel.getremotepanels($, config)
 else
 stepcarousel.alignpanels($, config) //align panels and initialize gallery
 }) //end document.ready
 jQuery(window).bind('unload', function(){ //clean up
 if (config.panelbehavior.persist){
 stepcarousel.setCookie(window[config.galleryid+"persist"], config.currentpanel)
 }
 jQuery.each(config, function(ai, oi){
 oi=null
 })
 config=null
 })
 }
}



jQuery(document).ready(function($){

 var tabs = $("#slide_tabs > li").length - 2;
 var cur_tab = 1;
 $("#slide_tabs > li").click(function(){
 // $("#slide_tabs > li:eq("+cur_tab+") :first-child").removeClass("hide_it");
 var tab_key = $("#slide_tabs > li").index(this);
 var panels_left = -((tab_key - 1) * 618);
 // alert(panels_left);
 // $("#slide_tabs > li:eq("+cur_tab+")").removeClass("no_border")
 // $(this).addClass("no_border");
 if((tab_key != 0) && (tab_key != (tabs + 1))) {
 $("#drop_tab").remove();
 
 $(this).children("span").addClass("hide_it");
 $(this).append("<div id='drop_tab' style='position: absolute; overflow: hidden; left: 0px; top: -52px; height: 58px;'><a href='javascript: void(0)'><span>"+$(this).text()+"</span></a></div>");
 
 cur_tab = tab_key;
 $("#drop_tab").animate({"top": "+=52px"}, 150, function(){$("#slide_tabs > li:eq("+cur_tab+") :first-child").removeClass("hide_it")});
 $(".panels").animate({"left": panels_left}, "slow");
 return false;
 } 
 });
 $("#panel_left").click(function(){
 
 tab_key = ((cur_tab == 1) ? tabs : (cur_tab -1));
 $("#slide_tabs > li:eq("+tab_key+")").trigger("click");
 
 });
 $("#panel_right").click(function(){
 tab_key = ((cur_tab == tabs) ? 1 : (cur_tab +1));
 $("#slide_tabs > li:eq("+tab_key+")").trigger("click"); 
 });

 $("#slide_tabs>li:eq(1)").trigger("click");
 
 $("#help_me").change(function () {
 setLocation($(this).val()); 
 })
 $(".tabs>.tabs-inner> ul").tabs();
});

/* Copyright (c) 2007 Paul Bakaus (paul.bakaus@googlemail.com) and Brandon Aaron (brandon.aaron@gmail.com || http://brandonaaron.net)
 * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
 * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
 *
 * $LastChangedDate: 2007-09-29 01:08:25 +0100 (Sat, 29 Sep 2007) $
 * $Rev: 3493 $
 *
 * Version: @VERSION
 *
 * Requires: jQuery 1.2+
 */

(function($){
 
$.dimensions = {
 version: '@VERSION'
};

// Create innerHeight, innerWidth, outerHeight and outerWidth methods
$.each( [ 'Height', 'Width' ], function(i, name){
 
 // innerHeight and innerWidth
 $.fn[ 'inner' + name ] = function() {
 if (!this[0]) return;
 
 var torl = name == 'Height' ? 'Top' : 'Left', // top or left
 borr = name == 'Height' ? 'Bottom' : 'Right'; // bottom or right

 return num(this, name.toLowerCase()) + num(this, 'padding' + torl) + num(this, 'padding' + borr);
 };
 
 // outerHeight and outerWidth
 $.fn[ 'outer' + name ] = function(options) {
 if (!this[0]) return;
 
 var torl = name == 'Height' ? 'Top' : 'Left', // top or left
 borr = name == 'Height' ? 'Bottom' : 'Right'; // bottom or right
 
 options = $.extend({ margin: false }, options || {});
 
 return num(this, name.toLowerCase())
 + num(this, 'border' + torl + 'Width') + num(this, 'border' + borr + 'Width')
 + num(this, 'padding' + torl) + num(this, 'padding' + borr)
 + (options.margin ? (num(this, 'margin' + torl) + num(this, 'margin' + borr)) : 0);
 };
});

// Create scrollLeft and scrollTop methods
$.each( ['Left', 'Top'], function(i, name) {
 $.fn[ 'scroll' + name ] = function(val) {
 if (!this[0]) return;
 
 return val != undefined ?
 
 // Set the scroll offset
 this.each(function() {
 this == window || this == document ?
 window.scrollTo( 
 name == 'Left' ? val : $(window)[ 'scrollLeft' ](),
 name == 'Top' ? val : $(window)[ 'scrollTop' ]()
 ) :
 this[ 'scroll' + name ] = val;
 }) :
 
 // Return the scroll offset
 this[0] == window || this[0] == document ?
 self[ (name == 'Left' ? 'pageXOffset' : 'pageYOffset') ] ||
 $.boxModel && document.documentElement[ 'scroll' + name ] ||
 document.body[ 'scroll' + name ] :
 this[0][ 'scroll' + name ];
 };
});

$.fn.extend({
 position: function() {
 var left = 0, top = 0, elem = this[0], offset, parentOffset, offsetParent, results;
 
 if (elem) {
 // Get *real* offsetParent
 offsetParent = this.offsetParent();
 
 // Get correct offsets
 offset = this.offset();
 parentOffset = offsetParent.offset();
 
 // Subtract element margins
 offset.top -= num(elem, 'marginTop');
 offset.left -= num(elem, 'marginLeft');
 
 // Add offsetParent borders
 parentOffset.top += num(offsetParent, 'borderTopWidth');
 parentOffset.left += num(offsetParent, 'borderLeftWidth');
 
 // Subtract the two offsets
 results = {
 top: offset.top - parentOffset.top,
 left: offset.left - parentOffset.left
 };
 }
 
 return results;
 },
 
 offsetParent: function() {
 var offsetParent = this[0].offsetParent;
 while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && $.css(offsetParent, 'position') == 'static') )
 offsetParent = offsetParent.offsetParent;
 return $(offsetParent);
 }
});

function num(el, prop) {
 return parseInt($.css(el.jquery?el[0]:el,prop))||0;
};

})(jQuery);
/**
 * @projectDescription Monitor Font Size Changes with jQuery
 *
 * @version 1.0
 * @author Dave Cardwell
 *
 * jQuery-Em - $Revision: 24 $ ($Date: 2007-08-19 11:24:56 +0100 (Sun, 19 Aug 2007) $)
 * http://davecardwell.co.uk/javascript/jquery/plugins/jquery-em/
 *
 * Copyright ©2007 Dave Cardwell <http://davecardwell.co.uk/>
 *
 * Released under the MIT licence:
 * http://www.opensource.org/licenses/mit-license.php
 */

// Upon $(document).ready()…
jQuery(function($) {
 // Configuration…
 var eventName = 'emchange';
 
 
 // Set up default options.
 $.em = $.extend({
 /**
 * The jQuery-Em version string.
 *
 * @example $.em.version;
 * @desc '1.0a'
 *
 * @property
 * @name version
 * @type String
 * @cat Plugins/Em
 */
 version: '1.0',
 
 /**
 * The number of milliseconds to wait when polling for changes to the
 * font size.
 *
 * @example $.em.delay = 400;
 * @desc Defaults to 200.
 *
 * @property
 * @name delay
 * @type Number
 * @cat Plugins/Em
 */
 delay: 200,
 
 /**
 * The element used to detect changes to the font size.
 *
 * @example $.em.element = $('<div />')[0];
 * @desc Default is an empty, absolutely positioned, 100em-wide <div>.
 *
 * @private
 * @property
 * @name element
 * @type Element
 * @cat Plugins/Em
 */
 element: $('<div />').css({ left: '-100em',
 position: 'absolute',
 width: '100em' })
 .prependTo('body')[0],
 
 /**
 * The action to perform when a change in the font size is detected.
 *
 * @example $.em.action = function() { ... }
 * @desc The default action is to trigger a global “emchange” event.
 * You probably shouldn’t change this behaviour as other plugins may
 * rely on it, but the option is here for completion.
 *
 * @example $(document).bind('emchange', function(e, cur, prev) {...})
 * @desc Any functions triggered on this event are passed the current
 * font size, and last known font size as additional parameters.
 *
 * @private
 * @property
 * @name action
 * @type Function
 * @cat Plugins/Em
 * @see current
 * @see previous
 */
 action: function() {
 var currentWidth = $.em.element.offsetWidth / 100;
 
 // If the font size has changed since we last checked…
 if ( currentWidth != $.em.current ) {
 /**
 * The previous pixel value of the user agent’s font size. See
 * $.em.current for caveats. Will initially be undefined until
 * the “emchange” event is triggered.
 *
 * @example $.em.previous;
 * @result 16
 *
 * @property
 * @name previous
 * @type Number
 * @cat Plugins/Em
 * @see current
 */
 $.em.previous = $.em.current;
 
 /**
 * The current pixel value of the user agent’s font size. As
 * with $.em.previous, this value *may* be subject to minor
 * browser rounding errors that mean you might not want to
 * rely upon it as an absolute value.
 *
 * @example $.em.current;
 * @result 14
 *
 * @property
 * @name current
 * @type Number
 * @cat Plugins/Em
 * @see previous
 */
 $.em.current = currentWidth;
 
 $.event.trigger(eventName, [$.em.current, $.em.previous]);
 }
 }
 }, $.em );
 
 
 /**
 * Bind a function to the emchange event of each matched element.
 *
 * @example $("p").emchange( function() { alert("Hello"); } );
 *
 * @name emchange
 * @type jQuery
 * @param Function fn A function to bind to the emchange event.
 * @cat Plugins/Em
 */

 /**
 * Trigger the emchange event of each matched element.
 *
 * @example $("p").emchange()
 *
 * @name emchange
 * @type jQuery
 * @cat Plugins/Em
 */
 $.fn[eventName] = function(fn) { return fn ? this.bind(eventName, fn)
 : this.trigger(eventName); };
 
 
 // Store the initial pixel value of the user agent’s font size.
 $.em.current = $.em.element.offsetWidth / 100;
 
 /**
 * While polling for font-size changes, $.em.iid stores the intervalID in
 * case you should want to cancel with clearInterval().
 *
 * @example window.clearInterval( $.em.iid );
 * 
 * @property
 * @name iid
 * @type Number
 * @cat Plugins/Em
 */
 $.em.iid = setInterval( $.em.action, $.em.delay );
});

/* Copyright (c) 2006 Brandon Aaron (brandon.aaron@gmail.com || http://brandonaaron.net)
 * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
 * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
 * Thanks to: http://adomas.org/javascript-mouse-wheel/ for some pointers.
 * Thanks to: Mathias Bank(http://www.mathias-bank.de) for a scope bug fix.
 *
 * $LastChangedDate: 2007-06-20 16:25:35 -0500 (Wed, 20 Jun 2007) $
 * $Rev: 2125 $
 *
 * Version: 2.2
 */
(function($){$.fn.extend({mousewheel:function(f){if(!f.guid)f.guid=$.event.guid++;if(!$.event._mwCache)$.event._mwCache=[];return this.each(function(){if(this._mwHandlers)return this._mwHandlers.push(f);else this._mwHandlers=[];this._mwHandlers.push(f);var s=this;this._mwHandler=function(e){e=$.event.fix(e||window.event);$.extend(e,this._mwCursorPos||{});var delta=0,returnValue=true;if(e.wheelDelta)delta=e.wheelDelta/120;if(e.detail)delta=-e.detail/3;if(window.opera)delta=-e.wheelDelta;for(var i=0;i<s._mwHandlers.length;i++)if(s._mwHandlers[i])if(s._mwHandlers[i].call(s,e,delta)===false){returnValue=false;e.preventDefault();e.stopPropagation();}return returnValue;};if($.browser.mozilla&&!this._mwFixCursorPos){this._mwFixCursorPos=function(e){this._mwCursorPos={pageX:e.pageX,pageY:e.pageY,clientX:e.clientX,clientY:e.clientY};};$(this).bind('mousemove',this._mwFixCursorPos);}if(this.addEventListener)if($.browser.mozilla)this.addEventListener('DOMMouseScroll',this._mwHandler,false);else this.addEventListener('mousewheel',this._mwHandler,false);else
this.onmousewheel=this._mwHandler;$.event._mwCache.push($(this));});},unmousewheel:function(f){return this.each(function(){if(f&&this._mwHandlers){for(var i=0;i<this._mwHandlers.length;i++)if(this._mwHandlers[i]&&this._mwHandlers[i].guid==f.guid)delete this._mwHandlers[i];}else{if($.browser.mozilla&&!this._mwFixCursorPos)$(this).unbind('mousemove',this._mwFixCursorPos);if(this.addEventListener)if($.browser.mozilla)this.removeEventListener('DOMMouseScroll',this._mwHandler,false);else this.removeEventListener('mousewheel',this._mwHandler,false);else
this.onmousewheel=null;this._mwHandlers=this._mwHandler=this._mwFixCursorPos=this._mwCursorPos=null;}});}});$(window).one('unload',function(){var els=$.event._mwCache||[];for(var i=0;i<els.length;i++)els[i].unmousewheel();});})(jQuery);