/*  Prototype JavaScript framework,version 1.7
*  (c) 2005-2010 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.7', Browser: (function () {
        var ua = navigator.userAgent;
        var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]';
        return {
            IE: !!window.attachEvent && !isOpera, Opera: isOpera, WebKit: ua.indexOf('AppleWebKit/') > -1, Gecko: ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1, MobileSafari: /Apple.*Mobile/.test(ua)
        }
    })(), BrowserFeatures: {
        XPath: !!document.evaluate, SelectorsAPI: !!document.querySelector, ElementExtensions: (function () {
            var constructor = window.Element || window.HTMLElement;
            return !!(constructor && constructor.prototype);
        })(), SpecificElementExtensions: (function () {
            if (typeof window.HTMLDivElement !== 'undefined')
                return true;
            var div = document.createElement('div'), form = document.createElement('form'), isSupported = false;
            if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) {
                isSupported = true;
            }
            div = form = null;
            return isSupported;
        })()
    }, 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;
var Abstract = {};
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;
    }
};
/* Based on Alex Arnell's inheritance implementation. */
var Class = (function () {
    var IS_DONTENUM_BUGGY = (function () {
        for (var p in { toString: 1 }) {
            if (p === 'toString') return false;
        }
        return true;
    })();
    function subclass() { };
    function create() {
        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) {
            subclass.prototype = parent.prototype;
            klass.prototype = new subclass;
            parent.subclasses.push(klass);
        }
        for (var i = 0, length = properties.length; i < length; i++)
            klass.addMethods(properties[i]);
        if (!klass.prototype.initialize)
            klass.prototype.initialize = Prototype.emptyFunction;
        klass.prototype.constructor = klass;
        return klass;
    }
    function addMethods(source) {
        var ancestor = this.superclass && this.superclass.prototype, properties = Object.keys(source);
        if (IS_DONTENUM_BUGGY) {
            if (source.toString != Object.prototype.toString)
                properties.push("toString");
            if (source.valueOf != Object.prototype.valueOf)
                properties.push("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()[0] == "$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;
    }
    return {
        create: create, Methods: {
            addMethods: addMethods
        }
    };
})();
(function () {
    var _toString = Object.prototype.toString, NULL_TYPE = 'Null', UNDEFINED_TYPE = 'Undefined', BOOLEAN_TYPE = 'Boolean', NUMBER_TYPE = 'Number', STRING_TYPE = 'String', OBJECT_TYPE = 'Object', FUNCTION_CLASS = '[object Function]', BOOLEAN_CLASS = '[object Boolean]', NUMBER_CLASS = '[object Number]', STRING_CLASS = '[object String]', ARRAY_CLASS = '[object Array]', DATE_CLASS = '[object Date]', NATIVE_JSON_STRINGIFY_SUPPORT = window.JSON &&
typeof JSON.stringify === 'function' &&
JSON.stringify(0) === '0' &&
typeof JSON.stringify(Prototype.K) === 'undefined';
    function Type(o) {
        switch (o) {
            case null: return NULL_TYPE;
            case (void 0): return UNDEFINED_TYPE;
        }
        var type = typeof o;
        switch (type) {
            case 'boolean': return BOOLEAN_TYPE;
            case 'number': return NUMBER_TYPE;
            case 'string': return STRING_TYPE;
        }
        return OBJECT_TYPE;
    }
    function extend(destination, source) {
        for (var property in source)
            destination[property] = source[property];
        return destination;
    }
    function inspect(object) {
        try {
            if (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;
        }
    }
    function toJSON(value) {
        return Str('', { '': value }, []);
    }
    function Str(key, holder, stack) {
        var value = holder[key], type = typeof value;
        if (Type(value) === OBJECT_TYPE && typeof value.toJSON === 'function') {
            value = value.toJSON(key);
        }
        var _class = _toString.call(value);
        switch (_class) {
            case NUMBER_CLASS:
            case BOOLEAN_CLASS:
            case STRING_CLASS:
                value = value.valueOf();
        }
        switch (value) {
            case null: return 'null';
            case true: return 'true';
            case false: return 'false';
        }
        type = typeof value;
        switch (type) {
            case 'string':
                return value.inspect(true);
            case 'number':
                return isFinite(value) ? String(value) : 'null';
            case 'object':
                for (var i = 0, length = stack.length; i < length; i++) {
                    if (stack[i] === value) { throw new TypeError(); }
                }
                stack.push(value);
                var partial = [];
                if (_class === ARRAY_CLASS) {
                    for (var i = 0, length = value.length; i < length; i++) {
                        var str = Str(i, value, stack);
                        partial.push(typeof str === 'undefined' ? 'null' : str);
                    }
                    partial = '[' + partial.join(',') + ']';
                } else {
                    var keys = Object.keys(value);
                    for (var i = 0, length = keys.length; i < length; i++) {
                        var key = keys[i], str = Str(key, value, stack);
                        if (typeof str !== "undefined") {
                            partial.push(key.inspect(true) + ':' + str);
                        }
                    }
                    partial = '{' + partial.join(',') + '}';
                }
                stack.pop();
                return partial;
        }
    }
    function stringify(object) {
        return JSON.stringify(object);
    }
    function toQueryString(object) {
        return $H(object).toQueryString();
    }
    function toHTML(object) {
        return object && object.toHTML ? object.toHTML() : String.interpret(object);
    }
    function keys(object) {
        if (Type(object) !== OBJECT_TYPE) { throw new TypeError(); }
        var results = [];
        for (var property in object) {
            if (object.hasOwnProperty(property)) {
                results.push(property);
            }
        }
        return results;
    }
    function values(object) {
        var results = [];
        for (var property in object)
            results.push(object[property]);
        return results;
    }
    function clone(object) {
        return extend({}, object);
    }
    function isElement(object) {
        return !!(object && object.nodeType == 1);
    }
    function isArray(object) {
        return _toString.call(object) === ARRAY_CLASS;
    }
    var hasNativeIsArray = (typeof Array.isArray == 'function')

&& Array.isArray([]) && !Array.isArray({});
    if (hasNativeIsArray) {
        isArray = Array.isArray;
    }
    function isHash(object) {
        return object instanceof Hash;
    }
    function isFunction(object) {
        return _toString.call(object) === FUNCTION_CLASS;
    }
    function isString(object) {
        return _toString.call(object) === STRING_CLASS;
    }
    function isNumber(object) {
        return _toString.call(object) === NUMBER_CLASS;
    }
    function isDate(object) {
        return _toString.call(object) === DATE_CLASS;
    }
    function isUndefined(object) {
        return typeof object === "undefined";
    }
    extend(Object, {
        extend: extend, inspect: inspect, toJSON: NATIVE_JSON_STRINGIFY_SUPPORT ? stringify : toJSON, toQueryString: toQueryString, toHTML: toHTML, keys: Object.keys || keys, values: values, clone: clone, isElement: isElement, isArray: isArray, isHash: isHash, isFunction: isFunction, isString: isString, isNumber: isNumber, isDate: isDate, isUndefined: isUndefined
    });
})();
Object.extend(Function.prototype, (function () {
    var slice = Array.prototype.slice;
    function update(array, args) {
        var arrayLength = array.length, length = args.length;
        while (length--) array[arrayLength + length] = args[length];
        return array;
    }
    function merge(array, args) {
        array = slice.call(array, 0);
        return update(array, args);
    }
    function argumentNames() {
        var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
.replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
.replace(/\s+/g, '').split(',');
        return names.length == 1 && !names[0] ? [] : names;
    }
    function bind(context) {
        if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
        var __method = this, args = slice.call(arguments, 1);
        return function () {
            var a = merge(args, arguments);
            return __method.apply(context, a);
        }
    }
    function bindAsEventListener(context) {
        var __method = this, args = slice.call(arguments, 1);
        return function (event) {
            var a = update([event || window.event], args);
            return __method.apply(context, a);
        }
    }
    function curry() {
        if (!arguments.length) return this;
        var __method = this, args = slice.call(arguments, 0);
        return function () {
            var a = merge(args, arguments);
            return __method.apply(this, a);
        }
    }
    function delay(timeout) {
        var __method = this, args = slice.call(arguments, 1);
        timeout = timeout * 1000;
        return window.setTimeout(function () {
            return __method.apply(__method, args);
        }, timeout);
    }
    function defer() {
        var args = update([0.01], arguments);
        return this.delay.apply(this, args);
    }
    function wrap(wrapper) {
        var __method = this;
        return function () {
            var a = update([__method.bind(this)], arguments);
            return wrapper.apply(this, a);
        }
    }
    function methodize() {
        if (this._methodized) return this._methodized;
        var __method = this;
        return this._methodized = function () {
            var a = update([this], arguments);
            return __method.apply(null, a);
        };
    }
    return {
        argumentNames: argumentNames, bind: bind, bindAsEventListener: bindAsEventListener, curry: curry, delay: delay, defer: defer, wrap: wrap, methodize: methodize
    }
})());
(function (proto) {
    function toISOString() {
        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';
    }
    function toJSON() {
        return this.toISOString();
    }
    if (!proto.toISOString) proto.toISOString = toISOString;
    if (!proto.toJSON) proto.toJSON = toJSON;
})(Date.prototype);
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();
                this.currentlyExecuting = false;
            } catch (e) {
                this.currentlyExecuting = false;
                throw e;
            }
        }
    }
});
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, (function () {
    var NATIVE_JSON_PARSE_SUPPORT = window.JSON &&
typeof JSON.parse === 'function' &&
JSON.parse('{"test": true}').test;
    function prepareReplacement(replacement) {
        if (Object.isFunction(replacement)) return replacement;
        var template = new Template(replacement);
        return function (match) { return template.evaluate(match) };
    }
    function gsub(pattern, replacement) {
        var result = '', source = this, match;
        replacement = prepareReplacement(replacement);
        if (Object.isString(pattern))
            pattern = RegExp.escape(pattern);
        if (!(pattern.length || pattern.source)) {
            replacement = replacement('');
            return replacement + source.split('').join(replacement) + 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;
    }
    function sub(pattern, replacement, count) {
        replacement = prepareReplacement(replacement);
        count = Object.isUndefined(count) ? 1 : count;
        return this.gsub(pattern, function (match) {
            if (--count < 0) return match[0];
            return replacement(match);
        });
    }
    function scan(pattern, iterator) {
        this.gsub(pattern, iterator);
        return String(this);
    }
    function truncate(length, truncation) {
        length = length || 30;
        truncation = Object.isUndefined(truncation) ? '...' : truncation;
        return this.length > length ?
this.slice(0, length - truncation.length) + truncation : String(this);
    }
    function strip() {
        return this.replace(/^\s+/, '').replace(/\s+$/, '');
    }
    function stripTags() {
        return this.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');
    }
    function stripScripts() {
        return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
    }
    function extractScripts() {
        var matchAll = new RegExp(Prototype.ScriptFragment, 'img'), matchOne = new RegExp(Prototype.ScriptFragment, 'im');
        return (this.match(matchAll) || []).map(function (scriptTag) {
            return (scriptTag.match(matchOne) || ['', ''])[1];
        });
    }
    function evalScripts() {
        return this.extractScripts().map(function (script) { return eval(script) });
    }
    function escapeHTML() {
        return this.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
    }
    function unescapeHTML() {
        return this.stripTags().replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
    }
    function toQueryParams(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()), 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;
        });
    }
    function toArray() {
        return this.split('');
    }
    function succ() {
        return this.slice(0, this.length - 1) +
String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
    }
    function times(count) {
        return count < 1 ? '' : new Array(count + 1).join(this);
    }
    function camelize() {
        return this.replace(/-+(.)?/g, function (match, chr) {
            return chr ? chr.toUpperCase() : '';
        });
    }
    function capitalize() {
        return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
    }
    function underscore() {
        return this.replace(/::/g, '/')
.replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
.replace(/([a-z\d])([A-Z])/g, '$1_$2')
.replace(/-/g, '_')
.toLowerCase();
    }
    function dasherize() {
        return this.replace(/_/g, '-');
    }
    function inspect(useDoubleQuotes) {
        var escapedString = this.replace(/[\x00-\x1f\\]/g, function (character) {
            if (character in String.specialChar) {
                return String.specialChar[character];
            }
            return '\\u00' + character.charCodeAt().toPaddedString(2, 16);
        });
        if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
        return "'" + escapedString.replace(/'/g, '\\\'') + "'";
    }
    function unfilterJSON(filter) {
        return this.replace(filter || Prototype.JSONFilter, '$1');
    }
    function isJSON() {
        var str = this;
        if (str.blank()) return false;
        str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
        str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
        str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
        return (/^[\],:{}\s]*$/).test(str);
    }
    function evalJSON(sanitize) {
        var json = this.unfilterJSON(), cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
        if (cx.test(json)) {
            json = json.replace(cx, function (a) {
                return '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
            });
        }
        try {
            if (!sanitize || json.isJSON()) return eval('(' + json + ')');
        } catch (e) { }
        throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
    }
    function parseJSON() {
        var json = this.unfilterJSON();
        return JSON.parse(json);
    }
    function include(pattern) {
        return this.indexOf(pattern) > -1;
    }
    function startsWith(pattern) {
        return this.lastIndexOf(pattern, 0) === 0;
    }
    function endsWith(pattern) {
        var d = this.length - pattern.length;
        return d >= 0 && this.indexOf(pattern, d) === d;
    }
    function empty() {
        return this == '';
    }
    function blank() {
        return /^\s*$/.test(this);
    }
    function interpolate(object, pattern) {
        return new Template(this, pattern).evaluate(object);
    }
    return {
        gsub: gsub, sub: sub, scan: scan, truncate: truncate, strip: String.prototype.trim || strip, stripTags: stripTags, stripScripts: stripScripts, extractScripts: extractScripts, evalScripts: evalScripts, escapeHTML: escapeHTML, unescapeHTML: unescapeHTML, toQueryParams: toQueryParams, parseQuery: toQueryParams, toArray: toArray, succ: succ, times: times, camelize: camelize, capitalize: capitalize, underscore: underscore, dasherize: dasherize, inspect: inspect, unfilterJSON: unfilterJSON, isJSON: isJSON, evalJSON: NATIVE_JSON_PARSE_SUPPORT ? parseJSON : evalJSON, include: include, startsWith: startsWith, endsWith: endsWith, empty: empty, blank: blank, interpolate: interpolate
    };
})());
var Template = Class.create({
    initialize: function (template, pattern) {
        this.template = template.toString();
        this.pattern = pattern || Template.Pattern;
    }, evaluate: function (object) {
        if (object && Object.isFunction(object.toTemplateReplacements))
            object = object.toTemplateReplacements();
        return this.template.gsub(this.pattern, function (match) {
            if (object == null) return (match[1] + '');
            var before = match[1] || '';
            if (before == '\\') return match[2];
            var ctx = object, expr = match[3], pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
            match = pattern.exec(expr);
            if (match == null) return before;
            while (match != null) {
                var comp = match[1].startsWith('[') ? match[2].replace(/\\\\]/g, ']') : 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 = (function () {
    function each(iterator, context) {
        var index = 0;
        try {
            this._each(function (value) {
                iterator.call(context, value, index++);
            });
        } catch (e) {
            if (e != $break) throw e;
        }
        return this;
    }
    function eachSlice(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);
    }
    function all(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;
    }
    function any(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;
    }
    function collect(iterator, context) {
        iterator = iterator || Prototype.K;
        var results = [];
        this.each(function (value, index) {
            results.push(iterator.call(context, value, index));
        });
        return results;
    }
    function detect(iterator, context) {
        var result;
        this.each(function (value, index) {
            if (iterator.call(context, value, index)) {
                result = value;
                throw $break;
            }
        });
        return result;
    }
    function findAll(iterator, context) {
        var results = [];
        this.each(function (value, index) {
            if (iterator.call(context, value, index))
                results.push(value);
        });
        return results;
    }
    function grep(filter, iterator, context) {
        iterator = iterator || Prototype.K;
        var results = [];
        if (Object.isString(filter))
            filter = new RegExp(RegExp.escape(filter));
        this.each(function (value, index) {
            if (filter.match(value))
                results.push(iterator.call(context, value, index));
        });
        return results;
    }
    function include(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;
    }
    function inGroupsOf(number, fillWith) {
        fillWith = Object.isUndefined(fillWith) ? null : fillWith;
        return this.eachSlice(number, function (slice) {
            while (slice.length < number) slice.push(fillWith);
            return slice;
        });
    }
    function inject(memo, iterator, context) {
        this.each(function (value, index) {
            memo = iterator.call(context, memo, value, index);
        });
        return memo;
    }
    function invoke(method) {
        var args = $A(arguments).slice(1);
        return this.map(function (value) {
            return value[method].apply(value, args);
        });
    }
    function max(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;
    }
    function min(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;
    }
    function partition(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];
    }
    function pluck(property) {
        var results = [];
        this.each(function (value) {
            results.push(value[property]);
        });
        return results;
    }
    function reject(iterator, context) {
        var results = [];
        this.each(function (value, index) {
            if (!iterator.call(context, value, index))
                results.push(value);
        });
        return results;
    }
    function sortBy(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');
    }
    function toArray() {
        return this.map();
    }
    function zip() {
        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));
        });
    }
    function size() {
        return this.toArray().length;
    }
    function inspect() {
        return '#<Enumerable:' + this.toArray().inspect() + '>';
    }
    return {
        each: each, eachSlice: eachSlice, all: all, every: all, any: any, some: any, collect: collect, map: collect, detect: detect, findAll: findAll, select: findAll, filter: findAll, grep: grep, include: include, member: include, inGroupsOf: inGroupsOf, inject: inject, invoke: invoke, max: max, min: min, partition: partition, pluck: pluck, reject: reject, sortBy: sortBy, toArray: toArray, entries: toArray, zip: zip, size: size, inspect: inspect, find: detect
    };
})();
function $A(iterable) {
    if (!iterable) return [];
    if ('toArray' in Object(iterable)) return iterable.toArray();
    var length = iterable.length || 0, results = new Array(length);
    while (length--) results[length] = iterable[length];
    return results;
}
function $w(string) {
    if (!Object.isString(string)) return [];
    string = string.strip();
    return string ? string.split(/\s+/) : [];
}
Array.from = $A;
(function () {
    var arrayProto = Array.prototype, slice = arrayProto.slice, _each = arrayProto.forEach; // use native browser JS 1.6 implementation if available
    function each(iterator, context) {
        for (var i = 0, length = this.length >>> 0; i < length; i++) {
            if (i in this) iterator.call(context, this[i], i, this);
        }
    }
    if (!_each) _each = each;
    function clear() {
        this.length = 0;
        return this;
    }
    function first() {
        return this[0];
    }
    function last() {
        return this[this.length - 1];
    }
    function compact() {
        return this.select(function (value) {
            return value != null;
        });
    }
    function flatten() {
        return this.inject([], function (array, value) {
            if (Object.isArray(value))
                return array.concat(value.flatten());
            array.push(value);
            return array;
        });
    }
    function without() {
        var values = slice.call(arguments, 0);
        return this.select(function (value) {
            return !values.include(value);
        });
    }
    function reverse(inline) {
        return (inline === false ? this.toArray() : this)._reverse();
    }
    function uniq(sorted) {
        return this.inject([], function (array, value, index) {
            if (0 == index || (sorted ? array.last() != value : !array.include(value)))
                array.push(value);
            return array;
        });
    }
    function intersect(array) {
        return this.uniq().findAll(function (item) {
            return array.detect(function (value) { return item === value });
        });
    }
    function clone() {
        return slice.call(this, 0);
    }
    function size() {
        return this.length;
    }
    function inspect() {
        return '[' + this.map(Object.inspect).join(',') + ']';
    }
    function indexOf(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;
    }
    function lastIndexOf(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;
    }
    function concat() {
        var array = slice.call(this, 0), item;
        for (var i = 0, length = arguments.length; i < length; i++) {
            item = arguments[i];
            if (Object.isArray(item) && !('callee' in item)) {
                for (var j = 0, arrayLength = item.length; j < arrayLength; j++)
                    array.push(item[j]);
            } else {
                array.push(item);
            }
        }
        return array;
    }
    Object.extend(arrayProto, Enumerable);
    if (!arrayProto._reverse)
        arrayProto._reverse = arrayProto.reverse;
    Object.extend(arrayProto, {
        _each: _each, clear: clear, first: first, last: last, compact: compact, flatten: flatten, without: without, reverse: reverse, uniq: uniq, intersect: intersect, clone: clone, toArray: clone, size: size, inspect: inspect
    });
    var CONCAT_ARGUMENTS_BUGGY = (function () {
        return [].concat(arguments)[0][0] !== 1;
    })(1, 2)
    if (CONCAT_ARGUMENTS_BUGGY) arrayProto.concat = concat;
    if (!arrayProto.indexOf) arrayProto.indexOf = indexOf;
    if (!arrayProto.lastIndexOf) arrayProto.lastIndexOf = lastIndexOf;
})();
function $H(object) {
    return new Hash(object);
};
var Hash = Class.create(Enumerable, (function () {
    function initialize(object) {
        this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
    }
    function _each(iterator) {
        for (var key in this._object) {
            var value = this._object[key], pair = [key, value];
            pair.key = key;
            pair.value = value;
            iterator(pair);
        }
    }
    function set(key, value) {
        return this._object[key] = value;
    }
    function get(key) {
        if (this._object[key] !== Object.prototype[key])
            return this._object[key];
    }
    function unset(key) {
        var value = this._object[key];
        delete this._object[key];
        return value;
    }
    function toObject() {
        return Object.clone(this._object);
    }
    function keys() {
        return this.pluck('key');
    }
    function values() {
        return this.pluck('value');
    }
    function index(value) {
        var match = this.detect(function (pair) {
            return pair.value === value;
        });
        return match && match.key;
    }
    function merge(object) {
        return this.clone().update(object);
    }
    function update(object) {
        return new Hash(object).inject(this, function (result, pair) {
            result.set(pair.key, pair.value);
            return result;
        });
    }
    function toQueryPair(key, value) {
        if (Object.isUndefined(value)) return key;
        return key + '=' + encodeURIComponent(String.interpret(value));
    }
    function toQueryString() {
        return this.inject([], function (results, pair) {
            var key = encodeURIComponent(pair.key), values = pair.value;
            if (values && typeof values == 'object') {
                if (Object.isArray(values)) {
                    var queryValues = [];
                    for (var i = 0, len = values.length, value; i < len; i++) {
                        value = values[i];
                        queryValues.push(toQueryPair(key, value));
                    }
                    return results.concat(queryValues);
                }
            } else results.push(toQueryPair(key, values));
            return results;
        }).join('&');
    }
    function inspect() {
        return '#<Hash:{' + this.map(function (pair) {
            return pair.map(Object.inspect).join(': ');
        }).join(',') + '}>';
    }
    function clone() {
        return new Hash(this);
    }
    return {
        initialize: initialize, _each: _each, set: set, get: get, unset: unset, toObject: toObject, toTemplateReplacements: toObject, keys: keys, values: values, index: index, merge: merge, update: update, toQueryString: toQueryString, inspect: inspect, toJSON: toObject, clone: clone
    };
})());
Hash.from = $H;
Object.extend(Number.prototype, (function () {
    function toColorPart() {
        return this.toPaddedString(2, 16);
    }
    function succ() {
        return this + 1;
    }
    function times(iterator, context) {
        $R(0, this, true).each(iterator, context);
        return this;
    }
    function toPaddedString(length, radix) {
        var string = this.toString(radix || 10);
        return '0'.times(length - string.length) + string;
    }
    function abs() {
        return Math.abs(this);
    }
    function round() {
        return Math.round(this);
    }
    function ceil() {
        return Math.ceil(this);
    }
    function floor() {
        return Math.floor(this);
    }
    return {
        toColorPart: toColorPart, succ: succ, times: times, toPaddedString: toPaddedString, abs: abs, round: round, ceil: ceil, floor: floor
    };
})());
function $R(start, end, exclusive) {
    return new ObjectRange(start, end, exclusive);
}
var ObjectRange = Class.create(Enumerable, (function () {
    function initialize(start, end, exclusive) {
        this.start = start;
        this.end = end;
        this.exclusive = exclusive;
    }
    function _each(iterator) {
        var value = this.start;
        while (this.include(value)) {
            iterator(value);
            value = value.succ();
        }
    }
    function include(value) {
        if (value < this.start)
            return false;
        if (this.exclusive)
            return value < this.end;
        return value <= this.end;
    }
    return {
        initialize: initialize, _each: _each, include: include
    };
})());
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.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.isString(this.options.parameters) ?
this.options.parameters :
Object.toQueryString(this.options.parameters);
        if (!['get', 'post'].include(this.method)) {
            params += (params ? '&' : '') + "_method=" + this.method;
            this.method = 'post';
        }
        if (params && this.method === 'get') {
            this.url += (this.url.include('?') ? '&' : '?') + params;
        }
        this.parameters = params.toQueryParams();
        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';
        }
        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) || status == 304;
    }, getStatus: function () {
        try {
            if (this.transport.status === 1223) return 204;
            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') {
            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 (!Node) var Node = {};
if (!Node.ELEMENT_NODE) {
    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 (global) {
    function shouldUseCache(tagName, attributes) {
        if (tagName === 'select') return false;
        if ('type' in attributes) return false;
        return true;
    }
    var HAS_EXTENDED_CREATE_ELEMENT_SYNTAX = (function () {
        try {
            var el = document.createElement('<input name="x">');
            return el.tagName.toLowerCase() === 'input' && el.name === 'x';
        }
        catch (err) {
            return false;
        }
    })();
    var element = global.Element;
    global.Element = function (tagName, attributes) {
        attributes = attributes || {};
        tagName = tagName.toLowerCase();
        var cache = Element.cache;
        if (HAS_EXTENDED_CREATE_ELEMENT_SYNTAX && 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));
        var node = shouldUseCache(tagName, attributes) ?
cache[tagName].cloneNode(false) : document.createElement(tagName);
        return Element.writeAttribute(node, attributes);
    };
    Object.extend(global.Element, element || {});
    if (element) global.Element.prototype = element.prototype;
})(this);
Element.idCounter = 1;
Element.cache = {};
Element._purgeElement = function (element) {
    var uid = element._prototypeUID;
    if (uid) {
        Element.stopObserving(element);
        element._prototypeUID = void 0;
        delete Element.Storage[uid];
    }
}
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 () {
        var SELECT_ELEMENT_INNERHTML_BUGGY = (function () {
            var el = document.createElement("select"), isBuggy = true;
            el.innerHTML = "<option value=\"test\">test</option>";
            if (el.options && el.options[0]) {
                isBuggy = el.options[0].nodeName.toUpperCase() !== "OPTION";
            }
            el = null;
            return isBuggy;
        })();
        var TABLE_ELEMENT_INNERHTML_BUGGY = (function () {
            try {
                var el = document.createElement("table");
                if (el && el.tBodies) {
                    el.innerHTML = "<tbody><tr><td>test</td></tr></tbody>";
                    var isBuggy = typeof el.tBodies[0] == "undefined";
                    el = null;
                    return isBuggy;
                }
            } catch (e) {
                return true;
            }
        })();
        var LINK_ELEMENT_INNERHTML_BUGGY = (function () {
            try {
                var el = document.createElement('div');
                el.innerHTML = "<link>";
                var isBuggy = (el.childNodes.length === 0);
                el = null;
                return isBuggy;
            } catch (e) {
                return true;
            }
        })();
        var ANY_INNERHTML_BUGGY = SELECT_ELEMENT_INNERHTML_BUGGY ||
TABLE_ELEMENT_INNERHTML_BUGGY || LINK_ELEMENT_INNERHTML_BUGGY;
        var SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING = (function () {
            var s = document.createElement("script"), isBuggy = false;
            try {
                s.appendChild(document.createTextNode(""));
                isBuggy = !s.firstChild ||
s.firstChild && s.firstChild.nodeType !== 3;
            } catch (e) {
                isBuggy = true;
            }
            s = null;
            return isBuggy;
        })();
        function update(element, content) {
            element = $(element);
            var purgeElement = Element._purgeElement;
            var descendants = element.getElementsByTagName('*'), i = descendants.length;
            while (i--) purgeElement(descendants[i]);
            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 === 'SCRIPT' && SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING) {
                element.text = content;
                return element;
            }
            if (ANY_INNERHTML_BUGGY) {
                if (tagName in Element._insertionTranslations.tags) {
                    while (element.firstChild) {
                        element.removeChild(element.firstChild);
                    }
                    Element._getContentFromAnonymousElement(tagName, content.stripScripts())
.each(function (node) {
    element.appendChild(node)
});
                } else if (LINK_ELEMENT_INNERHTML_BUGGY && Object.isString(content) && content.indexOf('<link') > -1) {
                    while (element.firstChild) {
                        element.removeChild(element.firstChild);
                    }
                    var nodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts(), true);
                    nodes.each(function (node) { element.appendChild(node) });
                }
                else {
                    element.innerHTML = content.stripScripts();
                }
            }
            else {
                element.innerHTML = content.stripScripts();
            }
            content.evalScripts.bind(content).defer();
            return element;
        }
        return update;
    })(), 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(), value = (element[property] || '').toString();
            if (value) result += ' ' + attribute + '=' + value.inspect(true);
        });
        return result + '>';
    }, recursivelyCollect: function (element, property, maximumLength) {
        element = $(element);
        maximumLength = maximumLength || -1;
        var elements = [];
        while (element = element[property]) {
            if (element.nodeType == 1)
                elements.push(Element.extend(element));
            if (elements.length == maximumLength)
                break;
        }
        return elements;
    }, ancestors: function (element) {
        return Element.recursivelyCollect(element, 'parentNode');
    }, descendants: function (element) {
        return Element.select(element, "*");
    }, firstDescendant: function (element) {
        element = $(element).firstChild;
        while (element && element.nodeType != 1) element = element.nextSibling;
        return $(element);
    }, immediateDescendants: function (element) {
        var results = [], child = $(element).firstChild;
        while (child) {
            if (child.nodeType === 1) {
                results.push(Element.extend(child));
            }
            child = child.nextSibling;
        }
        return results;
    }, previousSiblings: function (element, maximumLength) {
        return Element.recursivelyCollect(element, 'previousSibling');
    }, nextSiblings: function (element) {
        return Element.recursivelyCollect(element, 'nextSibling');
    }, siblings: function (element) {
        element = $(element);
        return Element.previousSiblings(element).reverse()
.concat(Element.nextSiblings(element));
    }, match: function (element, selector) {
        element = $(element);
        if (Object.isString(selector))
            return Prototype.Selector.match(element, selector);
        return selector.match(element);
    }, up: function (element, expression, index) {
        element = $(element);
        if (arguments.length == 1) return $(element.parentNode);
        var ancestors = Element.ancestors(element);
        return Object.isNumber(expression) ? ancestors[expression] :
Prototype.Selector.find(ancestors, expression, index);
    }, down: function (element, expression, index) {
        element = $(element);
        if (arguments.length == 1) return Element.firstDescendant(element);
        return Object.isNumber(expression) ? Element.descendants(element)[expression] :
Element.select(element, expression)[index || 0];
    }, previous: function (element, expression, index) {
        element = $(element);
        if (Object.isNumber(expression)) index = expression, expression = false;
        if (!Object.isNumber(index)) index = 0;
        if (expression) {
            return Prototype.Selector.find(element.previousSiblings(), expression, index);
        } else {
            return element.recursivelyCollect("previousSibling", index + 1)[index];
        }
    }, next: function (element, expression, index) {
        element = $(element);
        if (Object.isNumber(expression)) index = expression, expression = false;
        if (!Object.isNumber(index)) index = 0;
        if (expression) {
            return Prototype.Selector.find(element.nextSiblings(), expression, index);
        } else {
            var maximumLength = Object.isNumber(index) ? index + 1 : 1;
            return element.recursivelyCollect("nextSibling", index + 1)[index];
        }
    }, select: function (element) {
        element = $(element);
        var expressions = Array.prototype.slice.call(arguments, 1).join(',');
        return Prototype.Selector.select(expressions, element);
    }, adjacent: function (element) {
        element = $(element);
        var expressions = Array.prototype.slice.call(arguments, 1).join(',');
        return Prototype.Selector.select(expressions, element.parentNode).without(element);
    }, identify: function (element) {
        element = $(element);
        var id = Element.readAttribute(element, 'id');
        if (id) return id;
        do { id = 'anonymous_element_' + Element.idCounter++ } while ($(id));
        Element.writeAttribute(element, '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(element).height;
    }, getWidth: function (element) {
        return Element.getDimensions(element).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(element, 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(element, className) ?
'removeClassName' : 'addClassName'](element, className);
    }, 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(element);
        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;
    }, makePositioned: function (element) {
        element = $(element);
        var pos = Element.getStyle(element, 'position');
        if (pos == 'static' || !pos) {
            element._madePositioned = true;
            element.style.position = 'relative';
            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;
    }, clonePosition: function (element, source) {
        var options = Object.extend({
            setLeft: true, setTop: true, setWidth: true, setHeight: true, offsetTop: 0, offsetLeft: 0
        }, arguments[2] || {});
        source = $(source);
        var p = Element.viewportOffset(source), delta = [0, 0], parent = null;
        element = $(element);
        if (Element.getStyle(element, 'position') == 'absolute') {
            parent = Element.getOffsetParent(element);
            delta = Element.viewportOffset(parent);
        }
        if (parent == document.body) {
            delta[0] -= document.body.offsetLeft;
            delta[1] -= document.body.offsetTop;
        }
        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;
    }
};
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 'height': case 'width':
            if (!Element.visible(element)) return null;
            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) {
    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 = (function () {
        var classProp = 'className', forProp = 'for', el = document.createElement('div');
        el.setAttribute(classProp, 'x');
        if (el.className !== 'x') {
            el.setAttribute('class', 'x');
            if (el.className === 'x') {
                classProp = 'class';
            }
        }
        el = null;
        el = document.createElement('label');
        el.setAttribute(forProp, 'x');
        if (el.htmlFor !== 'x') {
            el.setAttribute('htmlFor', 'x');
            if (el.htmlFor === 'x') {
                forProp = 'htmlFor';
            }
        }
        el = null;
        return {
            read: {
                names: {
                    'class': classProp, 'className': classProp, 'for': forProp, 'htmlFor': forProp
                }, values: {
                    _getAttr: function (element, attribute) {
                        return element.getAttribute(attribute);
                    }, _getAttr2: function (element, attribute) {
                        return element.getAttribute(attribute, 2);
                    }, _getAttrNode: function (element, attribute) {
                        var node = element.getAttributeNode(attribute);
                        return node ? node.value : "";
                    }, _getEv: (function () {
                        var el = document.createElement('div'), f;
                        el.onclick = Prototype.emptyFunction;
                        var value = el.getAttribute('onclick');
                        if (String(value).indexOf('{') > -1) {
                            f = function (element, attribute) {
                                attribute = element.getAttribute(attribute);
                                if (!attribute) return null;
                                attribute = attribute.toString();
                                attribute = attribute.split('{')[1];
                                attribute = attribute.split('}')[0];
                                return attribute.strip();
                            };
                        }
                        else if (value === '') {
                            f = function (element, attribute) {
                                attribute = element.getAttribute(attribute);
                                if (!attribute) return null;
                                return attribute.strip();
                            };
                        }
                        el = null;
                        return f;
                    })(), _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._getAttr2, src: v._getAttr2, 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);
    if (Prototype.BrowserFeatures.ElementExtensions) {
        (function () {
            function _descendants(element) {
                var nodes = element.getElementsByTagName('*'), results = [];
                for (var i = 0, node; node = nodes[i]; i++)
                    if (node.tagName !== "!") // Filter out comment nodes.
                        results.push(node);
                return results;
            }
            Element.Methods.down = function (element, expression, index) {
                element = $(element);
                if (arguments.length == 1) return element.firstDescendant();
                return Object.isNumber(expression) ? _descendants(element)[expression] :
Element.select(element, expression)[index || 0];
            }
        })();
    }
}
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;
    };
}
if ('outerHTML' in document.documentElement) {
    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(), 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, force) {
    var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
    var workaround = false;
    if (t) workaround = true;
    else if (force) {
        workaround = true;
        t = ['', '', 0];
    }
    if (workaround) {
        div.innerHTML = '&nbsp;' + t[0] + html + t[1];
        div.removeChild(div.firstChild);
        for (var i = t[2]; i--; ) {
            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 () {
    var tags = Element._insertionTranslations.tags;
    Object.extend(tags, {
        THEAD: tags.TBODY, TFOOT: tags.TBODY, TH: tags.TD
    });
})();
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);
(function (div) {
    if (!Prototype.BrowserFeatures.ElementExtensions && div['__proto__']) {
        window.HTMLElement = {};
        window.HTMLElement.prototype = div['__proto__'];
        Prototype.BrowserFeatures.ElementExtensions = true;
    }
    div = null;
})(document.createElement('div'));
Element.extend = (function () {
    function checkDeficiency(tagName) {
        if (typeof window.Element != 'undefined') {
            var proto = window.Element.prototype;
            if (proto) {
                var id = '_' + (Math.random() + '').slice(2), el = document.createElement(tagName);
                proto[id] = 'x';
                var isBuggy = (el[id] !== 'x');
                delete proto[id];
                el = null;
                return isBuggy;
            }
        }
        return false;
    }
    function extendElementWith(element, methods) {
        for (var property in methods) {
            var value = methods[property];
            if (Object.isFunction(value) && !(property in element))
                element[property] = value.methodize();
        }
    }
    var HTMLOBJECTELEMENT_PROTOTYPE_BUGGY = checkDeficiency('object');
    if (Prototype.BrowserFeatures.SpecificElementExtensions) {
        if (HTMLOBJECTELEMENT_PROTOTYPE_BUGGY) {
            return function (element) {
                if (element && typeof element._extendedByPrototype == 'undefined') {
                    var t = element.tagName;
                    if (t && (/^(?:object|applet|embed)$/i.test(t))) {
                        extendElementWith(element, Element.Methods);
                        extendElementWith(element, Element.Methods.Simulated);
                        extendElementWith(element, Element.Methods.ByTag[t.toUpperCase()]);
                    }
                }
                return element;
            }
        }
        return Prototype.K;
    }
    var Methods = {}, ByTag = Element.Methods.ByTag;
    var extend = Object.extend(function (element) {
        if (!element || typeof element._extendedByPrototype != 'undefined' ||
element.nodeType != 1 || element == window) return element;
        var methods = Object.clone(Methods), tagName = element.tagName.toUpperCase();
        if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);
        extendElementWith(element, methods);
        element._extendedByPrototype = Prototype.emptyFunction;
        return element;
    }, {
        refresh: function () {
            if (!Prototype.BrowserFeatures.ElementExtensions) {
                Object.extend(Methods, Element.Methods);
                Object.extend(Methods, Element.Methods.Simulated);
            }
        }
    });
    extend.refresh();
    return extend;
})();
if (document.documentElement.hasAttribute) {
    Element.hasAttribute = function (element, attribute) {
        return element.hasAttribute(attribute);
    };
}
else {
    Element.hasAttribute = Element.Methods.Simulated.hasAttribute;
}
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), "BUTTON": 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];
        var element = document.createElement(tagName), proto = element['__proto__'] || element.constructor.prototype;
        element = null;
        return proto;
    }
    var elementPrototype = window.HTMLElement ? HTMLElement.prototype :
Element.prototype;
    if (F.ElementExtensions) {
        copy(Element.Methods, elementPrototype);
        copy(Element.Methods.Simulated, elementPrototype, 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 () {
        return { width: this.getWidth(), height: this.getHeight() };
    }, getScrollOffsets: function () {
        return Element._returnOffset(
window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft, window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop);
    }
};
(function (viewport) {
    var B = Prototype.Browser, doc = document, element, property = {};
    function getRootElement() {
        if (B.WebKit && !doc.evaluate)
            return document;
        if (B.Opera && window.parseFloat(window.opera.version()) < 9.5)
            return document.body;
        return document.documentElement;
    }
    function define(D) {
        if (!element) element = getRootElement();
        property[D] = 'client' + D;
        viewport['get' + D] = function () { return element[property[D]] };
        return viewport['get' + D]();
    }
    viewport.getWidth = define.curry('Width');
    viewport.getHeight = define.curry('Height');
})(document.viewport);
Element.Storage = {
    UID: 1
};
Element.addMethods({
    getStorage: function (element) {
        if (!(element = $(element))) return;
        var uid;
        if (element === window) {
            uid = 0;
        } else {
            if (typeof element._prototypeUID === "undefined")
                element._prototypeUID = Element.Storage.UID++;
            uid = element._prototypeUID;
        }
        if (!Element.Storage[uid])
            Element.Storage[uid] = $H();
        return Element.Storage[uid];
    }, store: function (element, key, value) {
        if (!(element = $(element))) return;
        if (arguments.length === 2) {
            Element.getStorage(element).update(key);
        } else {
            Element.getStorage(element).set(key, value);
        }
        return element;
    }, retrieve: function (element, key, defaultValue) {
        if (!(element = $(element))) return;
        var hash = Element.getStorage(element), value = hash.get(key);
        if (Object.isUndefined(value)) {
            hash.set(key, defaultValue);
            value = defaultValue;
        }
        return value;
    }, clone: function (element, deep) {
        if (!(element = $(element))) return;
        var clone = element.cloneNode(deep);
        clone._prototypeUID = void 0;
        if (deep) {
            var descendants = Element.select(clone, '*'), i = descendants.length;
            while (i--) {
                descendants[i]._prototypeUID = void 0;
            }
        }
        return Element.extend(clone);
    }, purge: function (element) {
        if (!(element = $(element))) return;
        var purgeElement = Element._purgeElement;
        purgeElement(element);
        var descendants = element.getElementsByTagName('*'), i = descendants.length;
        while (i--) purgeElement(descendants[i]);
        return null;
    }
});
(function () {
    function toDecimal(pctString) {
        var match = pctString.match(/^(\d+)%?$/i);
        if (!match) return null;
        return (Number(match[1]) / 100);
    }
    function getPixelValue(value, property, context) {
        var element = null;
        if (Object.isElement(value)) {
            element = value;
            value = element.getStyle(property);
        }
        if (value === null) {
            return null;
        }
        if ((/^(?:-)?\d+(\.\d+)?(px)?$/i).test(value)) {
            return window.parseFloat(value);
        }
        var isPercentage = value.include('%'), isViewport = (context === document.viewport);
        if (/\d/.test(value) && element && element.runtimeStyle && !(isPercentage && isViewport)) {
            var style = element.style.left, rStyle = element.runtimeStyle.left;
            element.runtimeStyle.left = element.currentStyle.left;
            element.style.left = value || 0;
            value = element.style.pixelLeft;
            element.style.left = style;
            element.runtimeStyle.left = rStyle;
            return value;
        }
        if (element && isPercentage) {
            context = context || element.parentNode;
            var decimal = toDecimal(value);
            var whole = null;
            var position = element.getStyle('position');
            var isHorizontal = property.include('left') || property.include('right') ||
property.include('width');
            var isVertical = property.include('top') || property.include('bottom') ||
property.include('height');
            if (context === document.viewport) {
                if (isHorizontal) {
                    whole = document.viewport.getWidth();
                } else if (isVertical) {
                    whole = document.viewport.getHeight();
                }
            } else {
                if (isHorizontal) {
                    whole = $(context).measure('width');
                } else if (isVertical) {
                    whole = $(context).measure('height');
                }
            }
            return (whole === null) ? 0 : whole * decimal;
        }
        return 0;
    }
    function toCSSPixels(number) {
        if (Object.isString(number) && number.endsWith('px')) {
            return number;
        }
        return number + 'px';
    }
    function isDisplayed(element) {
        var originalElement = element;
        while (element && element.parentNode) {
            var display = element.getStyle('display');
            if (display === 'none') {
                return false;
            }
            element = $(element.parentNode);
        }
        return true;
    }
    var hasLayout = Prototype.K;
    if ('currentStyle' in document.documentElement) {
        hasLayout = function (element) {
            if (!element.currentStyle.hasLayout) {
                element.style.zoom = 1;
            }
            return element;
        };
    }
    function cssNameFor(key) {
        if (key.include('border')) key = key + '-width';
        return key.camelize();
    }
    Element.Layout = Class.create(Hash, {
        initialize: function ($super, element, preCompute) {
            $super();
            this.element = $(element);
            Element.Layout.PROPERTIES.each(function (property) {
                this._set(property, null);
            }, this);
            if (preCompute) {
                this._preComputing = true;
                this._begin();
                Element.Layout.PROPERTIES.each(this._compute, this);
                this._end();
                this._preComputing = false;
            }
        }, _set: function (property, value) {
            return Hash.prototype.set.call(this, property, value);
        }, set: function (property, value) {
            throw "Properties of Element.Layout are read-only.";
        }, get: function ($super, property) {
            var value = $super(property);
            return value === null ? this._compute(property) : value;
        }, _begin: function () {
            if (this._prepared) return;
            var element = this.element;
            if (isDisplayed(element)) {
                this._prepared = true;
                return;
            }
            var originalStyles = {
                position: element.style.position || '', width: element.style.width || '', visibility: element.style.visibility || '', display: element.style.display || ''
            };
            element.store('prototype_original_styles', originalStyles);
            var position = element.getStyle('position'), width = element.getStyle('width');
            if (width === "0px" || width === null) {
                element.style.display = 'block';
                width = element.getStyle('width');
            }
            var context = (position === 'fixed') ? document.viewport :
element.parentNode;
            element.setStyle({
                position: 'absolute', visibility: 'hidden', display: 'block'
            });
            var positionedWidth = element.getStyle('width');
            var newWidth;
            if (width && (positionedWidth === width)) {
                newWidth = getPixelValue(element, 'width', context);
            } else if (position === 'absolute' || position === 'fixed') {
                newWidth = getPixelValue(element, 'width', context);
            } else {
                var parent = element.parentNode, pLayout = $(parent).getLayout();
                newWidth = pLayout.get('width') -
this.get('margin-left') -
this.get('border-left') -
this.get('padding-left') -
this.get('padding-right') -
this.get('border-right') -
this.get('margin-right');
            }
            element.setStyle({ width: newWidth + 'px' });
            this._prepared = true;
        }, _end: function () {
            var element = this.element;
            var originalStyles = element.retrieve('prototype_original_styles');
            element.store('prototype_original_styles', null);
            element.setStyle(originalStyles);
            this._prepared = false;
        }, _compute: function (property) {
            var COMPUTATIONS = Element.Layout.COMPUTATIONS;
            if (!(property in COMPUTATIONS)) {
                throw "Property not found.";
            }
            return this._set(property, COMPUTATIONS[property].call(this, this.element));
        }, toObject: function () {
            var args = $A(arguments);
            var keys = (args.length === 0) ? Element.Layout.PROPERTIES :
args.join(' ').split(' ');
            var obj = {};
            keys.each(function (key) {
                if (!Element.Layout.PROPERTIES.include(key)) return;
                var value = this.get(key);
                if (value != null) obj[key] = value;
            }, this);
            return obj;
        }, toHash: function () {
            var obj = this.toObject.apply(this, arguments);
            return new Hash(obj);
        }, toCSS: function () {
            var args = $A(arguments);
            var keys = (args.length === 0) ? Element.Layout.PROPERTIES :
args.join(' ').split(' ');
            var css = {};
            keys.each(function (key) {
                if (!Element.Layout.PROPERTIES.include(key)) return;
                if (Element.Layout.COMPOSITE_PROPERTIES.include(key)) return;
                var value = this.get(key);
                if (value != null) css[cssNameFor(key)] = value + 'px';
            }, this);
            return css;
        }, inspect: function () {
            return "#<Element.Layout>";
        }
    });
    Object.extend(Element.Layout, {
        PROPERTIES: $w('height width top left right bottom border-left border-right border-top border-bottom padding-left padding-right padding-top padding-bottom margin-top margin-bottom margin-left margin-right padding-box-width padding-box-height border-box-width border-box-height margin-box-width margin-box-height'), COMPOSITE_PROPERTIES: $w('padding-box-width padding-box-height margin-box-width margin-box-height border-box-width border-box-height'), COMPUTATIONS: {
            'height': function (element) {
                if (!this._preComputing) this._begin();
                var bHeight = this.get('border-box-height');
                if (bHeight <= 0) {
                    if (!this._preComputing) this._end();
                    return 0;
                }
                var bTop = this.get('border-top'), bBottom = this.get('border-bottom');
                var pTop = this.get('padding-top'), pBottom = this.get('padding-bottom');
                if (!this._preComputing) this._end();
                return bHeight - bTop - bBottom - pTop - pBottom;
            }, 'width': function (element) {
                if (!this._preComputing) this._begin();
                var bWidth = this.get('border-box-width');
                if (bWidth <= 0) {
                    if (!this._preComputing) this._end();
                    return 0;
                }
                var bLeft = this.get('border-left'), bRight = this.get('border-right');
                var pLeft = this.get('padding-left'), pRight = this.get('padding-right');
                if (!this._preComputing) this._end();
                return bWidth - bLeft - bRight - pLeft - pRight;
            }, 'padding-box-height': function (element) {
                var height = this.get('height'), pTop = this.get('padding-top'), pBottom = this.get('padding-bottom');
                return height + pTop + pBottom;
            }, 'padding-box-width': function (element) {
                var width = this.get('width'), pLeft = this.get('padding-left'), pRight = this.get('padding-right');
                return width + pLeft + pRight;
            }, 'border-box-height': function (element) {
                if (!this._preComputing) this._begin();
                var height = element.offsetHeight;
                if (!this._preComputing) this._end();
                return height;
            }, 'border-box-width': function (element) {
                if (!this._preComputing) this._begin();
                var width = element.offsetWidth;
                if (!this._preComputing) this._end();
                return width;
            }, 'margin-box-height': function (element) {
                var bHeight = this.get('border-box-height'), mTop = this.get('margin-top'), mBottom = this.get('margin-bottom');
                if (bHeight <= 0) return 0;
                return bHeight + mTop + mBottom;
            }, 'margin-box-width': function (element) {
                var bWidth = this.get('border-box-width'), mLeft = this.get('margin-left'), mRight = this.get('margin-right');
                if (bWidth <= 0) return 0;
                return bWidth + mLeft + mRight;
            }, 'top': function (element) {
                var offset = element.positionedOffset();
                return offset.top;
            }, 'bottom': function (element) {
                var offset = element.positionedOffset(), parent = element.getOffsetParent(), pHeight = parent.measure('height');
                var mHeight = this.get('border-box-height');
                return pHeight - mHeight - offset.top;
            }, 'left': function (element) {
                var offset = element.positionedOffset();
                return offset.left;
            }, 'right': function (element) {
                var offset = element.positionedOffset(), parent = element.getOffsetParent(), pWidth = parent.measure('width');
                var mWidth = this.get('border-box-width');
                return pWidth - mWidth - offset.left;
            }, 'padding-top': function (element) {
                return getPixelValue(element, 'paddingTop');
            }, 'padding-bottom': function (element) {
                return getPixelValue(element, 'paddingBottom');
            }, 'padding-left': function (element) {
                return getPixelValue(element, 'paddingLeft');
            }, 'padding-right': function (element) {
                return getPixelValue(element, 'paddingRight');
            }, 'border-top': function (element) {
                return getPixelValue(element, 'borderTopWidth');
            }, 'border-bottom': function (element) {
                return getPixelValue(element, 'borderBottomWidth');
            }, 'border-left': function (element) {
                return getPixelValue(element, 'borderLeftWidth');
            }, 'border-right': function (element) {
                return getPixelValue(element, 'borderRightWidth');
            }, 'margin-top': function (element) {
                return getPixelValue(element, 'marginTop');
            }, 'margin-bottom': function (element) {
                return getPixelValue(element, 'marginBottom');
            }, 'margin-left': function (element) {
                return getPixelValue(element, 'marginLeft');
            }, 'margin-right': function (element) {
                return getPixelValue(element, 'marginRight');
            }
        }
    });
    if ('getBoundingClientRect' in document.documentElement) {
        Object.extend(Element.Layout.COMPUTATIONS, {
            'right': function (element) {
                var parent = hasLayout(element.getOffsetParent());
                var rect = element.getBoundingClientRect(), pRect = parent.getBoundingClientRect();
                return (pRect.right - rect.right).round();
            }, 'bottom': function (element) {
                var parent = hasLayout(element.getOffsetParent());
                var rect = element.getBoundingClientRect(), pRect = parent.getBoundingClientRect();
                return (pRect.bottom - rect.bottom).round();
            }
        });
    }
    Element.Offset = Class.create({
        initialize: function (left, top) {
            this.left = left.round();
            this.top = top.round();
            this[0] = this.left;
            this[1] = this.top;
        }, relativeTo: function (offset) {
            return new Element.Offset(
this.left - offset.left, this.top - offset.top
);
        }, inspect: function () {
            return "#<Element.Offset left: #{left} top: #{top}>".interpolate(this);
        }, toString: function () {
            return "[#{left},#{top}]".interpolate(this);
        }, toArray: function () {
            return [this.left, this.top];
        }
    });
    function getLayout(element, preCompute) {
        return new Element.Layout(element, preCompute);
    }
    function measure(element, property) {
        return $(element).getLayout().get(property);
    }
    function getDimensions(element) {
        element = $(element);
        var display = Element.getStyle(element, 'display');
        if (display && display !== 'none') {
            return { width: element.offsetWidth, height: element.offsetHeight };
        }
        var style = element.style;
        var originalStyles = {
            visibility: style.visibility, position: style.position, display: style.display
        };
        var newStyles = {
            visibility: 'hidden', display: 'block'
        };
        if (originalStyles.position !== 'fixed')
            newStyles.position = 'absolute';
        Element.setStyle(element, newStyles);
        var dimensions = {
            width: element.offsetWidth, height: element.offsetHeight
        };
        Element.setStyle(element, originalStyles);
        return dimensions;
    }
    function getOffsetParent(element) {
        element = $(element);
        if (isDocument(element) || isDetached(element) || isBody(element) || isHtml(element))
            return $(document.body);
        var isInline = (Element.getStyle(element, 'display') === 'inline');
        if (!isInline && element.offsetParent) return $(element.offsetParent);
        while ((element = element.parentNode) && element !== document.body) {
            if (Element.getStyle(element, 'position') !== 'static') {
                return isHtml(element) ? $(document.body) : $(element);
            }
        }
        return $(document.body);
    }
    function cumulativeOffset(element) {
        element = $(element);
        var valueT = 0, valueL = 0;
        if (element.parentNode) {
            do {
                valueT += element.offsetTop || 0;
                valueL += element.offsetLeft || 0;
                element = element.offsetParent;
            } while (element);
        }
        return new Element.Offset(valueL, valueT);
    }
    function positionedOffset(element) {
        element = $(element);
        var layout = element.getLayout();
        var valueT = 0, valueL = 0;
        do {
            valueT += element.offsetTop || 0;
            valueL += element.offsetLeft || 0;
            element = element.offsetParent;
            if (element) {
                if (isBody(element)) break;
                var p = Element.getStyle(element, 'position');
                if (p !== 'static') break;
            }
        } while (element);
        valueL -= layout.get('margin-top');
        valueT -= layout.get('margin-left');
        return new Element.Offset(valueL, valueT);
    }
    function cumulativeScrollOffset(element) {
        var valueT = 0, valueL = 0;
        do {
            valueT += element.scrollTop || 0;
            valueL += element.scrollLeft || 0;
            element = element.parentNode;
        } while (element);
        return new Element.Offset(valueL, valueT);
    }
    function viewportOffset(forElement) {
        element = $(element);
        var valueT = 0, valueL = 0, docBody = document.body;
        var element = forElement;
        do {
            valueT += element.offsetTop || 0;
            valueL += element.offsetLeft || 0;
            if (element.offsetParent == docBody &&
Element.getStyle(element, 'position') == 'absolute') break;
        } while (element = element.offsetParent);
        element = forElement;
        do {
            if (element != docBody) {
                valueT -= element.scrollTop || 0;
                valueL -= element.scrollLeft || 0;
            }
        } while (element = element.parentNode);
        return new Element.Offset(valueL, valueT);
    }
    function absolutize(element) {
        element = $(element);
        if (Element.getStyle(element, 'position') === 'absolute') {
            return element;
        }
        var offsetParent = getOffsetParent(element);
        var eOffset = element.viewportOffset(), pOffset = offsetParent.viewportOffset();
        var offset = eOffset.relativeTo(pOffset);
        var layout = element.getLayout();
        element.store('prototype_absolutize_original_styles', {
            left: element.getStyle('left'), top: element.getStyle('top'), width: element.getStyle('width'), height: element.getStyle('height')
        });
        element.setStyle({
            position: 'absolute', top: offset.top + 'px', left: offset.left + 'px', width: layout.get('width') + 'px', height: layout.get('height') + 'px'
        });
        return element;
    }
    function relativize(element) {
        element = $(element);
        if (Element.getStyle(element, 'position') === 'relative') {
            return element;
        }
        var originalStyles =
element.retrieve('prototype_absolutize_original_styles');
        if (originalStyles) element.setStyle(originalStyles);
        return element;
    }
    if (Prototype.Browser.IE) {
        getOffsetParent = getOffsetParent.wrap(
function (proceed, element) {
    element = $(element);
    if (isDocument(element) || isDetached(element) || isBody(element) || isHtml(element))
        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;
}
);
        positionedOffset = positionedOffset.wrap(function (proceed, element) {
            element = $(element);
            if (!element.parentNode) return new Element.Offset(0, 0);
            var position = element.getStyle('position');
            if (position !== 'static') return proceed(element);
            var offsetParent = element.getOffsetParent();
            if (offsetParent && offsetParent.getStyle('position') === 'fixed')
                hasLayout(offsetParent);
            element.setStyle({ position: 'relative' });
            var value = proceed(element);
            element.setStyle({ position: position });
            return value;
        });
    } else if (Prototype.Browser.Webkit) {
        cumulativeOffset = function (element) {
            element = $(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 new Element.Offset(valueL, valueT);
        };
    }
    Element.addMethods({
        getLayout: getLayout, measure: measure, getDimensions: getDimensions, getOffsetParent: getOffsetParent, cumulativeOffset: cumulativeOffset, positionedOffset: positionedOffset, cumulativeScrollOffset: cumulativeScrollOffset, viewportOffset: viewportOffset, absolutize: absolutize, relativize: relativize
    });
    function isBody(element) {
        return element.nodeName.toUpperCase() === 'BODY';
    }
    function isHtml(element) {
        return element.nodeName.toUpperCase() === 'HTML';
    }
    function isDocument(element) {
        return element.nodeType === Node.DOCUMENT_NODE;
    }
    function isDetached(element) {
        return element !== document.body &&
!Element.descendantOf(element, document.body);
    }
    if ('getBoundingClientRect' in document.documentElement) {
        Element.addMethods({
            viewportOffset: function (element) {
                element = $(element);
                if (isDetached(element)) return new Element.Offset(0, 0);
                var rect = element.getBoundingClientRect(), docEl = document.documentElement;
                return new Element.Offset(rect.left - docEl.clientLeft, rect.top - docEl.clientTop);
            }
        });
    }
})();
window.$$ = function () {
    var expression = $A(arguments).join(',');
    return Prototype.Selector.select(expression, document);
};
Prototype.Selector = (function () {
    function select() {
        throw new Error('Method "Prototype.Selector.select" must be defined.');
    }
    function match() {
        throw new Error('Method "Prototype.Selector.match" must be defined.');
    }
    function find(elements, expression, index) {
        index = index || 0;
        var match = Prototype.Selector.match, length = elements.length, matchIndex = 0, i;
        for (i = 0; i < length; i++) {
            if (match(elements[i], expression) && index == matchIndex++) {
                return Element.extend(elements[i]);
            }
        }
    }
    function extendElements(elements) {
        for (var i = 0, length = elements.length; i < length; i++) {
            Element.extend(elements[i]);
        }
        return elements;
    }
    var K = Prototype.K;
    return {
        select: select, match: match, find: find, extendElements: (Element.extend === K) ? K : extendElements, extendElement: Element.extend
    };
})();
Prototype._original_property = window.Sizzle;
/*!
* Sizzle CSS Selector Engine - v1.0
*  Copyright 2009,The Dojo Foundation
*  Released under the MIT,BSD,and GPL Licenses.
*  More information: http://sizzlejs.com/
*/
(function () {
    var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, done = 0, toString = Object.prototype.toString, hasDuplicate = false, baseHasDuplicate = true;
    [0, 0].sort(function () {
        baseHasDuplicate = false;
        return 0;
    });
    var Sizzle = function (selector, context, results, seed) {
        results = results || [];
        var origContext = context = context || document;
        if (context.nodeType !== 1 && context.nodeType !== 9) {
            return [];
        }
        if (!selector || typeof selector !== "string") {
            return results;
        }
        var parts = [], m, set, checkSet, check, mode, extra, prune = true, contextXML = isXML(context), soFar = selector;
        while ((chunker.exec(""), m = chunker.exec(soFar)) !== null) {
            soFar = m[3];
            parts.push(m[1]);
            if (m[2]) {
                extra = m[3];
                break;
            }
        }
        if (parts.length > 1 && origPOS.exec(selector)) {
            if (parts.length === 2 && Expr.relative[parts[0]]) {
                set = posProcess(parts[0] + parts[1], context);
            } else {
                set = Expr.relative[parts[0]] ?
[context] :
Sizzle(parts.shift(), context);
                while (parts.length) {
                    selector = parts.shift();
                    if (Expr.relative[selector])
                        selector += parts.shift();
                    set = posProcess(selector, set);
                }
            }
        } else {
            if (!seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1])) {
                var ret = Sizzle.find(parts.shift(), context, contextXML);
                context = ret.expr ? Sizzle.filter(ret.expr, ret.set)[0] : ret.set[0];
            }
            if (context) {
                var ret = seed ?
{ expr: parts.pop(), set: makeArray(seed)} :
Sizzle.find(parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML);
                set = ret.expr ? Sizzle.filter(ret.expr, ret.set) : ret.set;
                if (parts.length > 0) {
                    checkSet = makeArray(set);
                } else {
                    prune = false;
                }
                while (parts.length) {
                    var cur = parts.pop(), pop = cur;
                    if (!Expr.relative[cur]) {
                        cur = "";
                    } else {
                        pop = parts.pop();
                    }
                    if (pop == null) {
                        pop = context;
                    }
                    Expr.relative[cur](checkSet, pop, contextXML);
                }
            } else {
                checkSet = parts = [];
            }
        }
        if (!checkSet) {
            checkSet = set;
        }
        if (!checkSet) {
            throw "Syntax error,unrecognized expression: " + (cur || selector);
        }
        if (toString.call(checkSet) === "[object Array]") {
            if (!prune) {
                results.push.apply(results, checkSet);
            } else if (context && context.nodeType === 1) {
                for (var i = 0; checkSet[i] != null; i++) {
                    if (checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i]))) {
                        results.push(set[i]);
                    }
                }
            } else {
                for (var i = 0; checkSet[i] != null; i++) {
                    if (checkSet[i] && checkSet[i].nodeType === 1) {
                        results.push(set[i]);
                    }
                }
            }
        } else {
            makeArray(checkSet, results);
        }
        if (extra) {
            Sizzle(extra, origContext, results, seed);
            Sizzle.uniqueSort(results);
        }
        return results;
    };
    Sizzle.uniqueSort = function (results) {
        if (sortOrder) {
            hasDuplicate = baseHasDuplicate;
            results.sort(sortOrder);
            if (hasDuplicate) {
                for (var i = 1; i < results.length; i++) {
                    if (results[i] === results[i - 1]) {
                        results.splice(i--, 1);
                    }
                }
            }
        }
        return results;
    };
    Sizzle.matches = function (expr, set) {
        return Sizzle(expr, null, null, set);
    };
    Sizzle.find = function (expr, context, isXML) {
        var set, match;
        if (!expr) {
            return [];
        }
        for (var i = 0, l = Expr.order.length; i < l; i++) {
            var type = Expr.order[i], match;
            if ((match = Expr.leftMatch[type].exec(expr))) {
                var left = match[1];
                match.splice(1, 1);
                if (left.substr(left.length - 1) !== "\\") {
                    match[1] = (match[1] || "").replace(/\\/g, "");
                    set = Expr.find[type](match, context, isXML);
                    if (set != null) {
                        expr = expr.replace(Expr.match[type], "");
                        break;
                    }
                }
            }
        }
        if (!set) {
            set = context.getElementsByTagName("*");
        }
        return { set: set, expr: expr };
    };
    Sizzle.filter = function (expr, set, inplace, not) {
        var old = expr, result = [], curLoop = set, match, anyFound, isXMLFilter = set && set[0] && isXML(set[0]);
        while (expr && set.length) {
            for (var type in Expr.filter) {
                if ((match = Expr.match[type].exec(expr)) != null) {
                    var filter = Expr.filter[type], found, item;
                    anyFound = false;
                    if (curLoop == result) {
                        result = [];
                    }
                    if (Expr.preFilter[type]) {
                        match = Expr.preFilter[type](match, curLoop, inplace, result, not, isXMLFilter);
                        if (!match) {
                            anyFound = found = true;
                        } else if (match === true) {
                            continue;
                        }
                    }
                    if (match) {
                        for (var i = 0; (item = curLoop[i]) != null; i++) {
                            if (item) {
                                found = filter(item, match, i, curLoop);
                                var pass = not ^ !!found;
                                if (inplace && found != null) {
                                    if (pass) {
                                        anyFound = true;
                                    } else {
                                        curLoop[i] = false;
                                    }
                                } else if (pass) {
                                    result.push(item);
                                    anyFound = true;
                                }
                            }
                        }
                    }
                    if (found !== undefined) {
                        if (!inplace) {
                            curLoop = result;
                        }
                        expr = expr.replace(Expr.match[type], "");
                        if (!anyFound) {
                            return [];
                        }
                        break;
                    }
                }
            }
            if (expr == old) {
                if (anyFound == null) {
                    throw "Syntax error,unrecognized expression: " + expr;
                } else {
                    break;
                }
            }
            old = expr;
        }
        return curLoop;
    };
    var Expr = Sizzle.selectors = {
        order: ["ID", "NAME", "TAG"], match: {
            ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/, CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/, NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/, ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/, TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/, CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/, POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/, PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
        }, leftMatch: {}, attrMap: {
            "class": "className", "for": "htmlFor"
        }, attrHandle: {
            href: function (elem) {
                return elem.getAttribute("href");
            }
        }, relative: {
            "+": function (checkSet, part, isXML) {
                var isPartStr = typeof part === "string", isTag = isPartStr && !/\W/.test(part), isPartStrNotTag = isPartStr && !isTag;
                if (isTag && !isXML) {
                    part = part.toUpperCase();
                }
                for (var i = 0, l = checkSet.length, elem; i < l; i++) {
                    if ((elem = checkSet[i])) {
                        while ((elem = elem.previousSibling) && elem.nodeType !== 1) { }
                        checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
elem || false :
elem === part;
                    }
                }
                if (isPartStrNotTag) {
                    Sizzle.filter(part, checkSet, true);
                }
            }, ">": function (checkSet, part, isXML) {
                var isPartStr = typeof part === "string";
                if (isPartStr && !/\W/.test(part)) {
                    part = isXML ? part : part.toUpperCase();
                    for (var i = 0, l = checkSet.length; i < l; i++) {
                        var elem = checkSet[i];
                        if (elem) {
                            var parent = elem.parentNode;
                            checkSet[i] = parent.nodeName === part ? parent : false;
                        }
                    }
                } else {
                    for (var i = 0, l = checkSet.length; i < l; i++) {
                        var elem = checkSet[i];
                        if (elem) {
                            checkSet[i] = isPartStr ?
elem.parentNode :
elem.parentNode === part;
                        }
                    }
                    if (isPartStr) {
                        Sizzle.filter(part, checkSet, true);
                    }
                }
            }, "": function (checkSet, part, isXML) {
                var doneName = done++, checkFn = dirCheck;
                if (!/\W/.test(part)) {
                    var nodeCheck = part = isXML ? part : part.toUpperCase();
                    checkFn = dirNodeCheck;
                }
                checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
            }, "~": function (checkSet, part, isXML) {
                var doneName = done++, checkFn = dirCheck;
                if (typeof part === "string" && !/\W/.test(part)) {
                    var nodeCheck = part = isXML ? part : part.toUpperCase();
                    checkFn = dirNodeCheck;
                }
                checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
            }
        }, find: {
            ID: function (match, context, isXML) {
                if (typeof context.getElementById !== "undefined" && !isXML) {
                    var m = context.getElementById(match[1]);
                    return m ? [m] : [];
                }
            }, NAME: function (match, context, isXML) {
                if (typeof context.getElementsByName !== "undefined") {
                    var ret = [], results = context.getElementsByName(match[1]);
                    for (var i = 0, l = results.length; i < l; i++) {
                        if (results[i].getAttribute("name") === match[1]) {
                            ret.push(results[i]);
                        }
                    }
                    return ret.length === 0 ? null : ret;
                }
            }, TAG: function (match, context) {
                return context.getElementsByTagName(match[1]);
            }
        }, preFilter: {
            CLASS: function (match, curLoop, inplace, result, not, isXML) {
                match = " " + match[1].replace(/\\/g, "") + " ";
                if (isXML) {
                    return match;
                }
                for (var i = 0, elem; (elem = curLoop[i]) != null; i++) {
                    if (elem) {
                        if (not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0)) {
                            if (!inplace)
                                result.push(elem);
                        } else if (inplace) {
                            curLoop[i] = false;
                        }
                    }
                }
                return false;
            }, ID: function (match) {
                return match[1].replace(/\\/g, "");
            }, TAG: function (match, curLoop) {
                for (var i = 0; curLoop[i] === false; i++) { }
                return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
            }, CHILD: function (match) {
                if (match[1] == "nth") {
                    var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
!/\D/.test(match[2]) && "0n+" + match[2] || match[2]);
                    match[2] = (test[1] + (test[2] || 1)) - 0;
                    match[3] = test[3] - 0;
                }
                match[0] = done++;
                return match;
            }, ATTR: function (match, curLoop, inplace, result, not, isXML) {
                var name = match[1].replace(/\\/g, "");
                if (!isXML && Expr.attrMap[name]) {
                    match[1] = Expr.attrMap[name];
                }
                if (match[2] === "~=") {
                    match[4] = " " + match[4] + " ";
                }
                return match;
            }, PSEUDO: function (match, curLoop, inplace, result, not) {
                if (match[1] === "not") {
                    if ((chunker.exec(match[3]) || "").length > 1 || /^\w/.test(match[3])) {
                        match[3] = Sizzle(match[3], null, null, curLoop);
                    } else {
                        var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
                        if (!inplace) {
                            result.push.apply(result, ret);
                        }
                        return false;
                    }
                } else if (Expr.match.POS.test(match[0]) || Expr.match.CHILD.test(match[0])) {
                    return true;
                }
                return match;
            }, POS: function (match) {
                match.unshift(true);
                return match;
            }
        }, filters: {
            enabled: function (elem) {
                return elem.disabled === false && elem.type !== "hidden";
            }, disabled: function (elem) {
                return elem.disabled === true;
            }, checked: function (elem) {
                return elem.checked === true;
            }, selected: function (elem) {
                elem.parentNode.selectedIndex;
                return elem.selected === true;
            }, parent: function (elem) {
                return !!elem.firstChild;
            }, empty: function (elem) {
                return !elem.firstChild;
            }, has: function (elem, i, match) {
                return !!Sizzle(match[3], elem).length;
            }, header: function (elem) {
                return /h\d/i.test(elem.nodeName);
            }, text: function (elem) {
                return "text" === elem.type;
            }, radio: function (elem) {
                return "radio" === elem.type;
            }, checkbox: function (elem) {
                return "checkbox" === elem.type;
            }, file: function (elem) {
                return "file" === elem.type;
            }, password: function (elem) {
                return "password" === elem.type;
            }, submit: function (elem) {
                return "submit" === elem.type;
            }, image: function (elem) {
                return "image" === elem.type;
            }, reset: function (elem) {
                return "reset" === elem.type;
            }, button: function (elem) {
                return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
            }, input: function (elem) {
                return /input|select|textarea|button/i.test(elem.nodeName);
            }
        }, setFilters: {
            first: function (elem, i) {
                return i === 0;
            }, last: function (elem, i, match, array) {
                return i === array.length - 1;
            }, even: function (elem, i) {
                return i % 2 === 0;
            }, odd: function (elem, i) {
                return i % 2 === 1;
            }, lt: function (elem, i, match) {
                return i < match[3] - 0;
            }, gt: function (elem, i, match) {
                return i > match[3] - 0;
            }, nth: function (elem, i, match) {
                return match[3] - 0 == i;
            }, eq: function (elem, i, match) {
                return match[3] - 0 == i;
            }
        }, filter: {
            PSEUDO: function (elem, match, i, array) {
                var name = match[1], filter = Expr.filters[name];
                if (filter) {
                    return filter(elem, i, match, array);
                } else if (name === "contains") {
                    return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
                } else if (name === "not") {
                    var not = match[3];
                    for (var i = 0, l = not.length; i < l; i++) {
                        if (not[i] === elem) {
                            return false;
                        }
                    }
                    return true;
                }
            }, CHILD: function (elem, match) {
                var type = match[1], node = elem;
                switch (type) {
                    case 'only':
                    case 'first':
                        while ((node = node.previousSibling)) {
                            if (node.nodeType === 1) return false;
                        }
                        if (type == 'first') return true;
                        node = elem;
                    case 'last':
                        while ((node = node.nextSibling)) {
                            if (node.nodeType === 1) return false;
                        }
                        return true;
                    case 'nth':
                        var first = match[2], last = match[3];
                        if (first == 1 && last == 0) {
                            return true;
                        }
                        var doneName = match[0], parent = elem.parentNode;
                        if (parent && (parent.sizcache !== doneName || !elem.nodeIndex)) {
                            var count = 0;
                            for (node = parent.firstChild; node; node = node.nextSibling) {
                                if (node.nodeType === 1) {
                                    node.nodeIndex = ++count;
                                }
                            }
                            parent.sizcache = doneName;
                        }
                        var diff = elem.nodeIndex - last;
                        if (first == 0) {
                            return diff == 0;
                        } else {
                            return (diff % first == 0 && diff / first >= 0);
                        }
                }
            }, ID: function (elem, match) {
                return elem.nodeType === 1 && elem.getAttribute("id") === match;
            }, TAG: function (elem, match) {
                return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
            }, CLASS: function (elem, match) {
                return (" " + (elem.className || elem.getAttribute("class")) + " ")
.indexOf(match) > -1;
            }, ATTR: function (elem, match) {
                var name = match[1], result = Expr.attrHandle[name] ?
Expr.attrHandle[name](elem) :
elem[name] != null ?
elem[name] :
elem.getAttribute(name), value = result + "", type = match[2], check = match[4];
                return result == null ?
type === "!=" :
type === "=" ?
value === check :
type === "*=" ?
value.indexOf(check) >= 0 :
type === "~=" ?
(" " + value + " ").indexOf(check) >= 0 :
!check ?
value && result !== false :
type === "!=" ?
value != check :
type === "^=" ?
value.indexOf(check) === 0 :
type === "$=" ?
value.substr(value.length - check.length) === check :
type === "|=" ?
value === check || value.substr(0, check.length + 1) === check + "-" :
false;
            }, POS: function (elem, match, i, array) {
                var name = match[2], filter = Expr.setFilters[name];
                if (filter) {
                    return filter(elem, i, match, array);
                }
            }
        }
    };
    var origPOS = Expr.match.POS;
    for (var type in Expr.match) {
        Expr.match[type] = new RegExp(Expr.match[type].source + /(?![^\[]*\])(?![^\(]*\))/.source);
        Expr.leftMatch[type] = new RegExp(/(^(?:.|\r|\n)*?)/.source + Expr.match[type].source);
    }
    var makeArray = function (array, results) {
        array = Array.prototype.slice.call(array, 0);
        if (results) {
            results.push.apply(results, array);
            return results;
        }
        return array;
    };
    try {
        Array.prototype.slice.call(document.documentElement.childNodes, 0);
    } catch (e) {
        makeArray = function (array, results) {
            var ret = results || [];
            if (toString.call(array) === "[object Array]") {
                Array.prototype.push.apply(ret, array);
            } else {
                if (typeof array.length === "number") {
                    for (var i = 0, l = array.length; i < l; i++) {
                        ret.push(array[i]);
                    }
                } else {
                    for (var i = 0; array[i]; i++) {
                        ret.push(array[i]);
                    }
                }
            }
            return ret;
        };
    }
    var sortOrder;
    if (document.documentElement.compareDocumentPosition) {
        sortOrder = function (a, b) {
            if (!a.compareDocumentPosition || !b.compareDocumentPosition) {
                if (a == b) {
                    hasDuplicate = true;
                }
                return 0;
            }
            var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
            if (ret === 0) {
                hasDuplicate = true;
            }
            return ret;
        };
    } else if ("sourceIndex" in document.documentElement) {
        sortOrder = function (a, b) {
            if (!a.sourceIndex || !b.sourceIndex) {
                if (a == b) {
                    hasDuplicate = true;
                }
                return 0;
            }
            var ret = a.sourceIndex - b.sourceIndex;
            if (ret === 0) {
                hasDuplicate = true;
            }
            return ret;
        };
    } else if (document.createRange) {
        sortOrder = function (a, b) {
            if (!a.ownerDocument || !b.ownerDocument) {
                if (a == b) {
                    hasDuplicate = true;
                }
                return 0;
            }
            var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
            aRange.setStart(a, 0);
            aRange.setEnd(a, 0);
            bRange.setStart(b, 0);
            bRange.setEnd(b, 0);
            var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
            if (ret === 0) {
                hasDuplicate = true;
            }
            return ret;
        };
    }
    (function () {
        var form = document.createElement("div"), id = "script" + (new Date).getTime();
        form.innerHTML = "<a name='" + id + "'/>";
        var root = document.documentElement;
        root.insertBefore(form, root.firstChild);
        if (!!document.getElementById(id)) {
            Expr.find.ID = function (match, context, isXML) {
                if (typeof context.getElementById !== "undefined" && !isXML) {
                    var m = context.getElementById(match[1]);
                    return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
                }
            };
            Expr.filter.ID = function (elem, match) {
                var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
                return elem.nodeType === 1 && node && node.nodeValue === match;
            };
        }
        root.removeChild(form);
        root = form = null; // release memory in IE
    })();
    (function () {
        var div = document.createElement("div");
        div.appendChild(document.createComment(""));
        if (div.getElementsByTagName("*").length > 0) {
            Expr.find.TAG = function (match, context) {
                var results = context.getElementsByTagName(match[1]);
                if (match[1] === "*") {
                    var tmp = [];
                    for (var i = 0; results[i]; i++) {
                        if (results[i].nodeType === 1) {
                            tmp.push(results[i]);
                        }
                    }
                    results = tmp;
                }
                return results;
            };
        }
        div.innerHTML = "<a href='#'></a>";
        if (div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
div.firstChild.getAttribute("href") !== "#") {
            Expr.attrHandle.href = function (elem) {
                return elem.getAttribute("href", 2);
            };
        }
        div = null; // release memory in IE
    })();
    if (document.querySelectorAll) (function () {
        var oldSizzle = Sizzle, div = document.createElement("div");
        div.innerHTML = "<p class='TEST'></p>";
        if (div.querySelectorAll && div.querySelectorAll(".TEST").length === 0) {
            return;
        }
        Sizzle = function (query, context, extra, seed) {
            context = context || document;
            if (!seed && context.nodeType === 9 && !isXML(context)) {
                try {
                    return makeArray(context.querySelectorAll(query), extra);
                } catch (e) { }
            }
            return oldSizzle(query, context, extra, seed);
        };
        for (var prop in oldSizzle) {
            Sizzle[prop] = oldSizzle[prop];
        }
        div = null; // release memory in IE
    })();
    if (document.getElementsByClassName && document.documentElement.getElementsByClassName) (function () {
        var div = document.createElement("div");
        div.innerHTML = "<div class='test e'></div><div class='test'></div>";
        if (div.getElementsByClassName("e").length === 0)
            return;
        div.lastChild.className = "e";
        if (div.getElementsByClassName("e").length === 1)
            return;
        Expr.order.splice(1, 0, "CLASS");
        Expr.find.CLASS = function (match, context, isXML) {
            if (typeof context.getElementsByClassName !== "undefined" && !isXML) {
                return context.getElementsByClassName(match[1]);
            }
        };
        div = null; // release memory in IE
    })();
    function dirNodeCheck(dir, cur, doneName, checkSet, nodeCheck, isXML) {
        var sibDir = dir == "previousSibling" && !isXML;
        for (var i = 0, l = checkSet.length; i < l; i++) {
            var elem = checkSet[i];
            if (elem) {
                if (sibDir && elem.nodeType === 1) {
                    elem.sizcache = doneName;
                    elem.sizset = i;
                }
                elem = elem[dir];
                var match = false;
                while (elem) {
                    if (elem.sizcache === doneName) {
                        match = checkSet[elem.sizset];
                        break;
                    }
                    if (elem.nodeType === 1 && !isXML) {
                        elem.sizcache = doneName;
                        elem.sizset = i;
                    }
                    if (elem.nodeName === cur) {
                        match = elem;
                        break;
                    }
                    elem = elem[dir];
                }
                checkSet[i] = match;
            }
        }
    }
    function dirCheck(dir, cur, doneName, checkSet, nodeCheck, isXML) {
        var sibDir = dir == "previousSibling" && !isXML;
        for (var i = 0, l = checkSet.length; i < l; i++) {
            var elem = checkSet[i];
            if (elem) {
                if (sibDir && elem.nodeType === 1) {
                    elem.sizcache = doneName;
                    elem.sizset = i;
                }
                elem = elem[dir];
                var match = false;
                while (elem) {
                    if (elem.sizcache === doneName) {
                        match = checkSet[elem.sizset];
                        break;
                    }
                    if (elem.nodeType === 1) {
                        if (!isXML) {
                            elem.sizcache = doneName;
                            elem.sizset = i;
                        }
                        if (typeof cur !== "string") {
                            if (elem === cur) {
                                match = true;
                                break;
                            }
                        } else if (Sizzle.filter(cur, [elem]).length > 0) {
                            match = elem;
                            break;
                        }
                    }
                    elem = elem[dir];
                }
                checkSet[i] = match;
            }
        }
    }
    var contains = document.compareDocumentPosition ? function (a, b) {
        return a.compareDocumentPosition(b) & 16;
    } : function (a, b) {
        return a !== b && (a.contains ? a.contains(b) : true);
    };
    var isXML = function (elem) {
        return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
!!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML";
    };
    var posProcess = function (selector, context) {
        var tmpSet = [], later = "", match, root = context.nodeType ? [context] : context;
        while ((match = Expr.match.PSEUDO.exec(selector))) {
            later += match[0];
            selector = selector.replace(Expr.match.PSEUDO, "");
        }
        selector = Expr.relative[selector] ? selector + "*" : selector;
        for (var i = 0, l = root.length; i < l; i++) {
            Sizzle(selector, root[i], tmpSet);
        }
        return Sizzle.filter(later, tmpSet);
    };
    window.Sizzle = Sizzle;
})();
; (function (engine) {
    var extendElements = Prototype.Selector.extendElements;
    function select(selector, scope) {
        return extendElements(engine(selector, scope || document));
    }
    function match(element, selector) {
        return engine.matches(selector, [element]).length == 1;
    }
    Prototype.Selector.engine = engine;
    Prototype.Selector.select = select;
    Prototype.Selector.match = match;
})(Sizzle);
window.Sizzle = Prototype._original_property;
delete Prototype._original_property;
var Form = {
    reset: function (form) {
        form = $(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, accumulator, initial;
        if (options.hash) {
            initial = {};
            accumulator = function (result, key, value) {
                if (key in result) {
                    if (!Object.isArray(result[key])) result[key] = [result[key]];
                    result[key].push(value);
                } else result[key] = value;
                return result;
            };
        } else {
            initial = '';
            accumulator = function (result, key, value) {
                return result + (result ? '&' : '') + encodeURIComponent(key) + '=' + encodeURIComponent(value);
            }
        }
        return elements.inject(initial, 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)))) {
                    result = accumulator(result, key, value);
                }
            }
            return result;
        });
    }
};
Form.Methods = {
    serialize: function (form, options) {
        return Form.serializeElements(Form.getElements(form), options);
    }, getElements: function (form) {
        var elements = $(form).getElementsByTagName('*'), element, arr = [], serializers = Form.Element.Serializers;
        for (var i = 0; element = elements[i]; i++) {
            arr.push(element);
        }
        return arr.inject([], function (elements, child) {
            if (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)$/i.test(element.tagName);
        });
    }, focusFirstElement: function (form) {
        form = $(form);
        var element = form.findFirstElement();
        if (element) element.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)$/i.test(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 = (function () {
    function input(element, value) {
        switch (element.type.toLowerCase()) {
            case 'checkbox':
            case 'radio':
                return inputSelector(element, value);
            default:
                return valueSelector(element, value);
        }
    }
    function inputSelector(element, value) {
        if (Object.isUndefined(value))
            return element.checked ? element.value : null;
        else element.checked = !!value;
    }
    function valueSelector(element, value) {
        if (Object.isUndefined(value)) return element.value;
        else element.value = value;
    }
    function select(element, value) {
        if (Object.isUndefined(value))
            return (element.type === 'select-one' ? selectOne : selectMany)(element);
        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);
        }
    }
    function selectOne(element) {
        var index = element.selectedIndex;
        return index >= 0 ? optionValue(element.options[index]) : null;
    }
    function selectMany(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(optionValue(opt));
        }
        return values;
    }
    function optionValue(opt) {
        return Element.hasAttribute(opt, 'value') ? opt.value : opt.text;
    }
    return {
        input: input, inputSelector: inputSelector, textarea: valueSelector, select: select, selectOne: selectOne, selectMany: selectMany, optionValue: optionValue, button: valueSelector
    };
})();
/*--------------------------------------------------------------------------*/
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);
    }
});
(function () {
    var 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: {}
    };
    var docEl = document.documentElement;
    var MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED = 'onmouseenter' in docEl

&& 'onmouseleave' in docEl;
    var isIELegacyEvent = function (event) { return false; };
    if (window.attachEvent) {
        if (window.addEventListener) {
            isIELegacyEvent = function (event) {
                return !(event instanceof window.Event);
            };
        } else {
            isIELegacyEvent = function (event) { return true; };
        }
    }
    var _isButton;
    function _isButtonForDOMEvents(event, code) {
        return event.which ? (event.which === code + 1) : (event.button === code);
    }
    var legacyButtonMap = { 0: 1, 1: 4, 2: 2 };
    function _isButtonForLegacyEvents(event, code) {
        return event.button === legacyButtonMap[code];
    }
    function _isButtonForWebKit(event, code) {
        switch (code) {
            case 0: return event.which == 1 && !event.metaKey;
            case 1: return event.which == 2 || (event.which == 1 && event.metaKey);
            case 2: return event.which == 3;
            default: return false;
        }
    }
    if (window.attachEvent) {
        if (!window.addEventListener) {
            _isButton = _isButtonForLegacyEvents;
        } else {
            _isButton = function (event, code) {
                return isIELegacyEvent(event) ? _isButtonForLegacyEvents(event, code) :
_isButtonForDOMEvents(event, code);
            }
        }
    } else if (Prototype.Browser.WebKit) {
        _isButton = _isButtonForWebKit;
    } else {
        _isButton = _isButtonForDOMEvents;
    }
    function isLeftClick(event) { return _isButton(event, 0) }
    function isMiddleClick(event) { return _isButton(event, 1) }
    function isRightClick(event) { return _isButton(event, 2) }
    function element(event) {
        event = Event.extend(event);
        var node = event.target, type = event.type, currentTarget = event.currentTarget;
        if (currentTarget && currentTarget.tagName) {
            if (type === 'load' || type === 'error' ||
(type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
&& currentTarget.type === 'radio'))
                node = currentTarget;
        }
        if (node.nodeType == Node.TEXT_NODE)
            node = node.parentNode;
        return Element.extend(node);
    }
    function findElement(event, expression) {
        var element = Event.element(event);
        if (!expression) return element;
        while (element) {
            if (Object.isElement(element) && Prototype.Selector.match(element, expression)) {
                return Element.extend(element);
            }
            element = element.parentNode;
        }
    }
    function pointer(event) {
        return { x: pointerX(event), y: pointerY(event) };
    }
    function pointerX(event) {
        var docElement = document.documentElement, body = document.body || { scrollLeft: 0 };
        return event.pageX || (event.clientX +
(docElement.scrollLeft || body.scrollLeft) -
(docElement.clientLeft || 0));
    }
    function pointerY(event) {
        var docElement = document.documentElement, body = document.body || { scrollTop: 0 };
        return event.pageY || (event.clientY +
(docElement.scrollTop || body.scrollTop) -
(docElement.clientTop || 0));
    }
    function stop(event) {
        Event.extend(event);
        event.preventDefault();
        event.stopPropagation();
        event.stopped = true;
    }
    Event.Methods = {
        isLeftClick: isLeftClick, isMiddleClick: isMiddleClick, isRightClick: isRightClick, element: element, findElement: findElement, pointer: pointer, pointerX: pointerX, pointerY: pointerY, stop: stop
    };
    var methods = Object.keys(Event.Methods).inject({}, function (m, name) {
        m[name] = Event.Methods[name].methodize();
        return m;
    });
    if (window.attachEvent) {
        function _relatedTarget(event) {
            var element;
            switch (event.type) {
                case 'mouseover':
                case 'mouseenter':
                    element = event.fromElement;
                    break;
                case 'mouseout':
                case 'mouseleave':
                    element = event.toElement;
                    break;
                default:
                    return null;
            }
            return Element.extend(element);
        }
        var additionalMethods = {
            stopPropagation: function () { this.cancelBubble = true }, preventDefault: function () { this.returnValue = false }, inspect: function () { return '[object Event]' }
        };
        Event.extend = function (event, element) {
            if (!event) return false;
            if (!isIELegacyEvent(event)) return event;
            if (event._extendedByPrototype) return event;
            event._extendedByPrototype = Prototype.emptyFunction;
            var pointer = Event.pointer(event);
            Object.extend(event, {
                target: event.srcElement || element, relatedTarget: _relatedTarget(event), pageX: pointer.x, pageY: pointer.y
            });
            Object.extend(event, methods);
            Object.extend(event, additionalMethods);
            return event;
        };
    } else {
        Event.extend = Prototype.K;
    }
    if (window.addEventListener) {
        Event.prototype = window.Event.prototype || document.createEvent('HTMLEvents').__proto__;
        Object.extend(Event.prototype, methods);
    }
    function _createResponder(element, eventName, handler) {
        var registry = Element.retrieve(element, 'prototype_event_registry');
        if (Object.isUndefined(registry)) {
            CACHE.push(element);
            registry = Element.retrieve(element, 'prototype_event_registry', $H());
        }
        var respondersForEvent = registry.get(eventName);
        if (Object.isUndefined(respondersForEvent)) {
            respondersForEvent = [];
            registry.set(eventName, respondersForEvent);
        }
        if (respondersForEvent.pluck('handler').include(handler)) return false;
        var responder;
        if (eventName.include(":")) {
            responder = function (event) {
                if (Object.isUndefined(event.eventName))
                    return false;
                if (event.eventName !== eventName)
                    return false;
                Event.extend(event, element);
                handler.call(element, event);
            };
        } else {
            if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED &&
(eventName === "mouseenter" || eventName === "mouseleave")) {
                if (eventName === "mouseenter" || eventName === "mouseleave") {
                    responder = function (event) {
                        Event.extend(event, element);
                        var parent = event.relatedTarget;
                        while (parent && parent !== element) {
                            try { parent = parent.parentNode; }
                            catch (e) { parent = element; }
                        }
                        if (parent === element) return;
                        handler.call(element, event);
                    };
                }
            } else {
                responder = function (event) {
                    Event.extend(event, element);
                    handler.call(element, event);
                };
            }
        }
        responder.handler = handler;
        respondersForEvent.push(responder);
        return responder;
    }
    function _destroyCache() {
        for (var i = 0, length = CACHE.length; i < length; i++) {
            Event.stopObserving(CACHE[i]);
            CACHE[i] = null;
        }
    }
    var CACHE = [];
    if (Prototype.Browser.IE)
        window.attachEvent('onunload', _destroyCache);
    if (Prototype.Browser.WebKit)
        window.addEventListener('unload', Prototype.emptyFunction, false);
    var _getDOMEventName = Prototype.K, translations = { mouseenter: "mouseover", mouseleave: "mouseout" };
    if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED) {
        _getDOMEventName = function (eventName) {
            return (translations[eventName] || eventName);
        };
    }
    function observe(element, eventName, handler) {
        element = $(element);
        var responder = _createResponder(element, eventName, handler);
        if (!responder) return element;
        if (eventName.include(':')) {
            if (element.addEventListener)
                element.addEventListener("dataavailable", responder, false);
            else {
                element.attachEvent("ondataavailable", responder);
                element.attachEvent("onlosecapture", responder);
            }
        } else {
            var actualEventName = _getDOMEventName(eventName);
            if (element.addEventListener)
                element.addEventListener(actualEventName, responder, false);
            else
                element.attachEvent("on" + actualEventName, responder);
        }
        return element;
    }
    function stopObserving(element, eventName, handler) {
        element = $(element);
        var registry = Element.retrieve(element, 'prototype_event_registry');
        if (!registry) return element;
        if (!eventName) {
            registry.each(function (pair) {
                var eventName = pair.key;
                stopObserving(element, eventName);
            });
            return element;
        }
        var responders = registry.get(eventName);
        if (!responders) return element;
        if (!handler) {
            responders.each(function (r) {
                stopObserving(element, eventName, r.handler);
            });
            return element;
        }
        var i = responders.length, responder;
        while (i--) {
            if (responders[i].handler === handler) {
                responder = responders[i];
                break;
            }
        }
        if (!responder) return element;
        if (eventName.include(':')) {
            if (element.removeEventListener)
                element.removeEventListener("dataavailable", responder, false);
            else {
                element.detachEvent("ondataavailable", responder);
                element.detachEvent("onlosecapture", responder);
            }
        } else {
            var actualEventName = _getDOMEventName(eventName);
            if (element.removeEventListener)
                element.removeEventListener(actualEventName, responder, false);
            else
                element.detachEvent('on' + actualEventName, responder);
        }
        registry.set(eventName, responders.without(responder));
        return element;
    }
    function fire(element, eventName, memo, bubble) {
        element = $(element);
        if (Object.isUndefined(bubble))
            bubble = true;
        if (element == document && document.createEvent && !element.dispatchEvent)
            element = document.documentElement;
        var event;
        if (document.createEvent) {
            event = document.createEvent('HTMLEvents');
            event.initEvent('dataavailable', bubble, true);
        } else {
            event = document.createEventObject();
            event.eventType = bubble ? 'ondataavailable' : 'onlosecapture';
        }
        event.eventName = eventName;
        event.memo = memo || {};
        if (document.createEvent)
            element.dispatchEvent(event);
        else
            element.fireEvent(event.eventType, event);
        return Event.extend(event);
    }
    Event.Handler = Class.create({
        initialize: function (element, eventName, selector, callback) {
            this.element = $(element);
            this.eventName = eventName;
            this.selector = selector;
            this.callback = callback;
            this.handler = this.handleEvent.bind(this);
        }, start: function () {
            Event.observe(this.element, this.eventName, this.handler);
            return this;
        }, stop: function () {
            Event.stopObserving(this.element, this.eventName, this.handler);
            return this;
        }, handleEvent: function (event) {
            var element = Event.findElement(event, this.selector);
            if (element) this.callback.call(this.element, event, element);
        }
    });
    function on(element, eventName, selector, callback) {
        element = $(element);
        if (Object.isFunction(selector) && Object.isUndefined(callback)) {
            callback = selector, selector = null;
        }
        return new Event.Handler(element, eventName, selector, callback).start();
    }
    Object.extend(Event, Event.Methods);
    Object.extend(Event, {
        fire: fire, observe: observe, stopObserving: stopObserving, on: on
    });
    Element.addMethods({
        fire: fire, observe: observe, stopObserving: stopObserving, on: on
    });
    Object.extend(document, {
        fire: fire.methodize(), observe: observe.methodize(), stopObserving: stopObserving.methodize(), on: on.methodize(), loaded: false
    });
    if (window.Event) Object.extend(window.Event, Event);
    else window.Event = Event;
})();
(function () {
    /* Support for the DOMContentLoaded event is based on work by Dan Webb,Matthias Miller,Dean Edwards,John Resig,and Diego Perini. */
    var timer;
    function fireContentLoadedEvent() {
        if (document.loaded) return;
        if (timer) window.clearTimeout(timer);
        document.loaded = true;
        document.fire('dom:loaded');
    }
    function checkReadyState() {
        if (document.readyState === 'complete') {
            document.stopObserving('readystatechange', checkReadyState);
            fireContentLoadedEvent();
        }
    }
    function pollDoScroll() {
        try { document.documentElement.doScroll('left'); }
        catch (e) {
            timer = pollDoScroll.defer();
            return;
        }
        fireContentLoadedEvent();
    }
    if (document.addEventListener) {
        document.addEventListener('DOMContentLoaded', fireContentLoadedEvent, false);
    } else {
        document.observe('readystatechange', checkReadyState);
        if (window == top)
            timer = pollDoScroll.defer();
    }
    Event.observe(window, 'load', fireContentLoadedEvent);
})();
Element.addMethods();
/*------------------------------- 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');
var Position = {
    includeScrollOffsets: false, prepare: function () {
        this.deltaX = window.pageXOffset
|| document.documentElement.scrollLeft
|| document.body.scrollLeft
|| 0;
        this.deltaY = window.pageYOffset
|| document.documentElement.scrollTop
|| document.body.scrollTop
|| 0;
    }, 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);
    }, 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;
    }, 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);
/*--------------------------------------------------------------------------*/
(function () {
    window.Selector = Class.create({
        initialize: function (expression) {
            this.expression = expression.strip();
        }, findElements: function (rootElement) {
            return Prototype.Selector.select(this.expression, rootElement);
        }, match: function (element) {
            return Prototype.Selector.match(element, this.expression);
        }, toString: function () {
            return this.expression;
        }, inspect: function () {
            return "#<Selector: " + this.expression + ">";
        }
    });
    Object.extend(Selector, {
        matchElements: function (elements, expression) {
            var match = Prototype.Selector.match, results = [];
            for (var i = 0, length = elements.length; i < length; i++) {
                var element = elements[i];
                if (match(element, expression)) {
                    results.push(Element.extend(element));
                }
            }
            return results;
        }, findElement: function (elements, expression, index) {
            index = index || 0;
            var matchIndex = 0, element;
            for (var i = 0, length = elements.length; i < length; i++) {
                element = elements[i];
                if (Prototype.Selector.match(element, expression) && index === matchIndex++) {
                    return Element.extend(element);
                }
            }
        }, findChildElements: function (element, expressions) {
            var selector = expressions.toArray().join(',');
            return Prototype.Selector.select(selector, element || document);
        }
    });
})();
// script.aculo.us scriptaculous.js v1.9.0,Thu Dec 23 16:54:48 -0500 2010
// Copyright (c) 2005-2010 Thomas Fuchs (http://script.aculo.us,http://mir.aculo.us)
//
// 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.
//
// For details,see the script.aculo.us web site: http://script.aculo.us/
var Scriptaculous = {
    Version: '1.9.0', require: function (libraryName) {
        try {
            // inserting via DOM fails in Safari 2.0,so brute force approach
            document.write('<script type="text/javascript" src="' + libraryName + '"><\/script>');
        } catch (e) {
            // for xhtml+xml served content,fall back to DOM methods
            var script = document.createElement('script');
            script.type = 'text/javascript';
            script.src = libraryName;
            document.getElementsByTagName('head')[0].appendChild(script);
        }
    }, REQUIRED_PROTOTYPE: '1.6.0.3', load: function () {
        function convertVersionString(versionString) {
            var v = versionString.replace(/_.*|\./g, '');
            v = parseInt(v + '0'.times(4 - v.length));
            return versionString.indexOf('_') > -1 ? v - 1 : v;
        }
        if ((typeof Prototype == 'undefined') ||
(typeof Element == 'undefined') ||
(typeof Element.Methods == 'undefined') ||
(convertVersionString(Prototype.Version) <
convertVersionString(Scriptaculous.REQUIRED_PROTOTYPE)))
            throw ("script.aculo.us requires the Prototype JavaScript framework >= " +
Scriptaculous.REQUIRED_PROTOTYPE);
        var js = /scriptaculous\.js(\?.*)?$/;
        $$('script[src]').findAll(function (s) {
            return s.src.match(js);
        }).each(function (s) {
            var path = s.src.replace(js, ''), includes = s.src.match(/\?.*load=([a-z,]*)/);
            (includes ? includes[1] : 'builder,effects,dragdrop,controls,slider,sound').split(',').each(
function (include) { Scriptaculous.require(path + include + '.js') });
        });
    }
};
Scriptaculous.load();
// script.aculo.us builder.js v1.9.0,Thu Dec 23 16:54:48 -0500 2010
// Copyright (c) 2005-2010 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)));
            };
        });
    }
};
// script.aculo.us effects.js v1.9.0,Thu Dec 23 16:54:48 -0500 2010
// Copyright (c) 2005-2010 Thomas Fuchs (http://script.aculo.us,http://mir.aculo.us)
// Contributors:
//  Justin Palmer (http://encytemedia.com/)
//  Mark Pilgrim (http://diveintomark.org/)
//  Martin Bialasinki
//
// 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/
// converts rgb() and #xxx to #xxxxxx format,// returns self (or first argument) if not convertable
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) + .5;
        }, reverse: function (pos) {
            return 1 - pos;
        }, flicker: function (pos) {
            var pos = ((-Math.cos(pos * Math.PI) / 4) + .75) + Math.random() / 4;
            return pos > 1 ? 1 : pos;
        }, wobble: function (pos) {
            return (-Math.cos(pos * Math.PI * (9 * pos)) / 2) + .5;
        }, pulse: function (pos, pulses) {
            return (-Math.cos((pos * ((pulses || 5) - .5) * 2) * Math.PI) / 2) + .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.0, // seconds
        fps: 100, // 100= assume 66fps max.
        sync: false, // true for combining
        from: 0.0, to: 1.0, delay: 0.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.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, options) {
        element = $(element);
        effect = (effect || 'appear').toLowerCase();
        return Effect[Effect.PAIRS[effect][element.visible() ? 1 : 0]](element, Object.extend({
            queue: { position: 'end', scope: (element.id || 'global'), limit: 1 }
        }, options || {}));
    }
};
Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;
/* ------------- core effects ------------- */
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':
                // move unstarted effects after this effect
                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':
                // start effect after last queued effect has finished
                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) {
        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.0);
                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.0);
            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);
        // make this work on IE on elements without 'layout'
        if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
            this.element.setStyle({ zoom: 1 });
        var options = Object.extend({
            from: this.element.getOpacity() || 0.0, to: 1.0
        }, 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'
        });
    }
});
// for backwards compatibility
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', // 'box' or 'contents' or { } with provided values
            scaleFrom: 100.0, 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.0) + (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 () {
        // Prevent executing on elements not in the layout flow
        if (this.element.getStyle('display') == 'none') { this.cancel(); return; }
        // Disable background image during the effect
        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');
        // init color calculations
        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()); }
);
};
/* ------------- combination effects ------------- */
Effect.Fade = function (element) {
    element = $(element);
    var oldOpacity = element.getInlineOpacity();
    var options = Object.extend({
        from: element.getOpacity() || 1.0, to: 0.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.0 : element.getOpacity() || 0.0), to: 1.0, // force Safari to render floated elements properly
        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.0 })], Object.extend({ duration: 1.0, 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.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.0;
    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();
    // SlideDown need to have the content of the element wrapped in a container element with fixed height!
    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] || {})
);
};
// Bug in opera makes the TD containing this element expand for a instance after finish
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.0, from: 0.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.0, from: 1.0, 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) + .5);
    };
    return new Effect.Opacity(element, Object.extend(Object.extend({ duration: 2.0, 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.9.0,Thu Dec 23 16:54:48 -0500 2010
// Copyright (c) 2005-2010 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/
if (Object.isUndefined(Effect))
    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 (Object.isArray(containment)) {
                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 drop, affected = [];
        this.drops.each(function (drop) {
            if (Droppables.isAffected(point, element, drop))
                affected.push(drop);
        });
        if (affected.length > 0)
            drop = Droppables.findDeepestChild(affected);
        if (this.last_active && this.last_active != drop) this.deactivate(this.last_active);
        if (drop) {
            Position.within(drop.element, point[0], point[1]);
            if (drop.onHover)
                drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
            if (drop != this.last_active) 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(document, "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(document, "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({
    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 = Object.isNumber(element._opacity) ? 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] || Object.isUndefined(arguments[1].endeffect))
            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 && Object.isString(options.handle))
            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.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 (!Object.isUndefined(Draggable._dragging[this.element]) &&
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 = this.element.cumulativeOffset();
            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.delta)
            this.delta = this.currentDelta();
        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);
            this._originallyAbsolute = (this.element.getStyle('position') == 'absolute');
            if (!this._originallyAbsolute)
                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).toArray();
                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) {
            if (!this._originallyAbsolute)
                Position.relativize(this.element);
            delete this._originallyAbsolute;
            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 && Object.isFunction(revert)) 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 = this.element.cumulativeOffset();
        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 (Object.isFunction(this.options.snap)) {
                p = this.options.snap(p[0], p[1], this);
            } else {
                if (Object.isArray(this.options.snap)) {
                    p = p.map(function (v, i) {
                        return (v / this.options.snap[i]).round() * this.options.snap[i]
                    } .bind(this));
                } else {
                    p = p.map(function (v) {
                        return (v / this.options.snap).round() * 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 };
    }
});
Draggable._dragging = {};
/*--------------------------------------------------------------------------*/
var SortableObserver = Class.create({
    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) {
        element = $(element);
        var s = Sortable.sortables[element.id];
        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).select('.' + 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.identify()] = 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 = dropon.cumulativeOffset();
        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.9.0,Thu Dec 23 16:54:48 -0500 2010
// Copyright (c) 2005-2010 Thomas Fuchs (http://script.aculo.us,http://mir.aculo.us)
//           (c) 2005-2010 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
//           (c) 2005-2010 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 = Class.create({
    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;
        this.oldElementValue = this.element.value;
        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);
        // Force carriage returns as token delimiters anyway
        if (!this.options.tokens.include('\n'))
            this.options.tokens.push('\n');
        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, 'keydown', this.onKeyPress.bindAsEventListener(this));
    }, 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();
                Event.stop(event);
                return;
            case Event.KEY_DOWN:
                this.markNext();
                this.render();
                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;
        //----------------------------------
        //Edit by Netbiscuits START
        //this.getEntry(this.index).scrollIntoView(true);
        this.getEntry(this.index).scrollIntoView(false);
        //Edit by Netbiscuits END
        //----------------------------------
    }, 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;
        }
        //----------------------------------
        //Add by Netbiscuits START
        if ($(selectedElement) == null) {
            return;
        }
        //Add by Netbiscuits END
        //----------------------------------
        var value = '';
        if (this.options.select) {
            var nodes = $(selectedElement).select('.' + this.options.select) || [];
            if (nodes.length > 0) value = Element.collectTextNodes(nodes[0], this.options.select);
        }
        else
            value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
        var bounds = this.getTokenBounds();
        if (bounds[0] != -1) {
            var newValue = this.element.value.substr(0, bounds[0]);
            var whitespace = this.element.value.substr(bounds[0]).match(/^\s+/);
            if (whitespace)
                newValue += whitespace[0];
            this.element.value = newValue + value + this.element.value.substr(bounds[1]);
        } else {
            this.element.value = value;
        }
        this.oldElementValue = this.element.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();
            //----------------------------------
            //Edit by Netbiscuits START
            //this.index = 0;
            this.index = -1;
            //Edit by Netbiscuits END
            //----------------------------------
            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;
        this.tokenBounds = null;
        if (this.getToken().length >= this.options.minChars) {
            this.getUpdatedChoices();
        } else {
            this.active = false;
            this.hide();
        }
        this.oldElementValue = this.element.value;
    }, getToken: function () {
        var bounds = this.getTokenBounds();
        return this.element.value.substring(bounds[0], bounds[1]).strip();
    }, getTokenBounds: function () {
        if (null != this.tokenBounds) return this.tokenBounds;
        var value = this.element.value;
        if (value.strip().empty()) return [-1, 0];
        var diff = arguments.callee.getFirstDifferencePos(value, this.oldElementValue);
        var offset = (diff == this.oldElementValue.length ? 1 : 0);
        var prevTokenPos = -1, nextTokenPos = value.length;
        var tp;
        for (var index = 0, l = this.options.tokens.length; index < l; ++index) {
            tp = value.lastIndexOf(this.options.tokens[index], diff + offset - 1);
            if (tp > prevTokenPos) prevTokenPos = tp;
            tp = value.indexOf(this.options.tokens[index], diff + offset);
            if (-1 != tp && tp < nextTokenPos) nextTokenPos = tp;
        }
        return (this.tokenBounds = [prevTokenPos + 1, nextTokenPos]);
    }
});
Autocompleter.Base.prototype.getTokenBounds.getFirstDifferencePos = function (newS, oldS) {
    var boundary = Math.min(newS.length, oldS.length);
    for (var index = 0; index < boundary; ++index)
        if (newS[index] != oldS[index])
            return index;
    return boundary;
};
Ajax.Autocompleter = Class.create(Autocompleter.Base, {
    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.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 and collection editor
// Full rewrite by Christophe Porteneuve <tdd@tddsworld.com> (April 2007).
// 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({
    initialize: function (element, url, options) {
        this.url = url;
        this.element = element = $(element);
        this.prepareOptions();
        this._controls = {};
        arguments.callee.dealWithDeprecatedOptions(options); // DEPRECATION LAYER!!!
        Object.extend(this.options, options || {});
        if (!this.options.formId && this.element.id) {
            this.options.formId = this.element.id + '-inplaceeditor';
            if ($(this.options.formId))
                this.options.formId = '';
        }
        if (this.options.externalControl)
            this.options.externalControl = $(this.options.externalControl);
        if (!this.options.externalControl)
            this.options.externalControlOnly = false;
        this._originalBackground = this.element.getStyle('background-color') || 'transparent';
        this.element.title = this.options.clickToEditText;
        this._boundCancelHandler = this.handleFormCancellation.bind(this);
        this._boundComplete = (this.options.onComplete || Prototype.emptyFunction).bind(this);
        this._boundFailureHandler = this.handleAJAXFailure.bind(this);
        this._boundSubmitHandler = this.handleFormSubmission.bind(this);
        this._boundWrapperHandler = this.wrapUp.bind(this);
        this.registerListeners();
    }, checkForEscapeOrReturn: function (e) {
        if (!this._editing || e.ctrlKey || e.altKey || e.shiftKey) return;
        if (Event.KEY_ESC == e.keyCode)
            this.handleFormCancellation(e);
        else if (Event.KEY_RETURN == e.keyCode)
            this.handleFormSubmission(e);
    }, createControl: function (mode, handler, extraClasses) {
        var control = this.options[mode + 'Control'];
        var text = this.options[mode + 'Text'];
        if ('button' == control) {
            var btn = document.createElement('input');
            btn.type = 'submit';
            btn.value = text;
            btn.className = 'editor_' + mode + '_button';
            if ('cancel' == mode)
                btn.onclick = this._boundCancelHandler;
            this._form.appendChild(btn);
            this._controls[mode] = btn;
        } else if ('link' == control) {
            var link = document.createElement('a');
            link.href = '#';
            link.appendChild(document.createTextNode(text));
            link.onclick = 'cancel' == mode ? this._boundCancelHandler : this._boundSubmitHandler;
            link.className = 'editor_' + mode + '_link';
            if (extraClasses)
                link.className += ' ' + extraClasses;
            this._form.appendChild(link);
            this._controls[mode] = link;
        }
    }, createEditField: function () {
        var text = (this.options.loadTextURL ? this.options.loadingText : this.getText());
        var fld;
        if (1 >= this.options.rows && !/\r|\n/.test(this.getText())) {
            fld = document.createElement('input');
            fld.type = 'text';
            var size = this.options.size || this.options.cols || 0;
            if (0 < size) fld.size = size;
        } else {
            fld = document.createElement('textarea');
            fld.rows = (1 >= this.options.rows ? this.options.autoRows : this.options.rows);
            fld.cols = this.options.cols || 40;
        }
        fld.name = this.options.paramName;
        fld.value = text; // No HTML breaks conversion anymore
        fld.className = 'editor_field';
        if (this.options.submitOnBlur)
            fld.onblur = this._boundSubmitHandler;
        this._controls.editor = fld;
        if (this.options.loadTextURL)
            this.loadExternalText();
        this._form.appendChild(this._controls.editor);
    }, createForm: function () {
        var ipe = this;
        function addText(mode, condition) {
            var text = ipe.options['text' + mode + 'Controls'];
            if (!text || condition === false) return;
            ipe._form.appendChild(document.createTextNode(text));
        };
        this._form = $(document.createElement('form'));
        this._form.id = this.options.formId;
        this._form.addClassName(this.options.formClassName);
        this._form.onsubmit = this._boundSubmitHandler;
        this.createEditField();
        if ('textarea' == this._controls.editor.tagName.toLowerCase())
            this._form.appendChild(document.createElement('br'));
        if (this.options.onFormCustomization)
            this.options.onFormCustomization(this, this._form);
        addText('Before', this.options.okControl || this.options.cancelControl);
        this.createControl('ok', this._boundSubmitHandler);
        addText('Between', this.options.okControl && this.options.cancelControl);
        this.createControl('cancel', this._boundCancelHandler, 'editor_cancel');
        addText('After', this.options.okControl || this.options.cancelControl);
    }, destroy: function () {
        if (this._oldInnerHTML)
            this.element.innerHTML = this._oldInnerHTML;
        this.leaveEditMode();
        this.unregisterListeners();
    }, enterEditMode: function (e) {
        if (this._saving || this._editing) return;
        this._editing = true;
        this.triggerCallback('onEnterEditMode');
        if (this.options.externalControl)
            this.options.externalControl.hide();
        this.element.hide();
        this.createForm();
        this.element.parentNode.insertBefore(this._form, this.element);
        if (!this.options.loadTextURL)
            this.postProcessEditField();
        if (e) Event.stop(e);
    }, enterHover: function (e) {
        if (this.options.hoverClassName)
            this.element.addClassName(this.options.hoverClassName);
        if (this._saving) return;
        this.triggerCallback('onEnterHover');
    }, getText: function () {
        return this.element.innerHTML.unescapeHTML();
    }, handleAJAXFailure: function (transport) {
        this.triggerCallback('onFailure', transport);
        if (this._oldInnerHTML) {
            this.element.innerHTML = this._oldInnerHTML;
            this._oldInnerHTML = null;
        }
    }, handleFormCancellation: function (e) {
        this.wrapUp();
        if (e) Event.stop(e);
    }, handleFormSubmission: function (e) {
        var form = this._form;
        var value = $F(this._controls.editor);
        this.prepareSubmission();
        var params = this.options.callback(form, value) || '';
        if (Object.isString(params))
            params = params.toQueryParams();
        params.editorId = this.element.id;
        if (this.options.htmlResponse) {
            var options = Object.extend({ evalScripts: true }, this.options.ajaxOptions);
            Object.extend(options, {
                parameters: params, onComplete: this._boundWrapperHandler, onFailure: this._boundFailureHandler
            });
            new Ajax.Updater({ success: this.element }, this.url, options);
        } else {
            var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
            Object.extend(options, {
                parameters: params, onComplete: this._boundWrapperHandler, onFailure: this._boundFailureHandler
            });
            new Ajax.Request(this.url, options);
        }
        if (e) Event.stop(e);
    }, leaveEditMode: function () {
        this.element.removeClassName(this.options.savingClassName);
        this.removeForm();
        this.leaveHover();
        this.element.style.backgroundColor = this._originalBackground;
        this.element.show();
        if (this.options.externalControl)
            this.options.externalControl.show();
        this._saving = false;
        this._editing = false;
        this._oldInnerHTML = null;
        this.triggerCallback('onLeaveEditMode');
    }, leaveHover: function (e) {
        if (this.options.hoverClassName)
            this.element.removeClassName(this.options.hoverClassName);
        if (this._saving) return;
        this.triggerCallback('onLeaveHover');
    }, loadExternalText: function () {
        this._form.addClassName(this.options.loadingClassName);
        this._controls.editor.disabled = true;
        var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
        Object.extend(options, {
            parameters: 'editorId=' + encodeURIComponent(this.element.id), onComplete: Prototype.emptyFunction, onSuccess: function (transport) {
                this._form.removeClassName(this.options.loadingClassName);
                var text = transport.responseText;
                if (this.options.stripLoadedTextTags)
                    text = text.stripTags();
                this._controls.editor.value = text;
                this._controls.editor.disabled = false;
                this.postProcessEditField();
            } .bind(this), onFailure: this._boundFailureHandler
        });
        new Ajax.Request(this.options.loadTextURL, options);
    }, postProcessEditField: function () {
        var fpc = this.options.fieldPostCreation;
        if (fpc)
            $(this._controls.editor)['focus' == fpc ? 'focus' : 'activate']();
    }, prepareOptions: function () {
        this.options = Object.clone(Ajax.InPlaceEditor.DefaultOptions);
        Object.extend(this.options, Ajax.InPlaceEditor.DefaultCallbacks);
        [this._extraDefaultOptions].flatten().compact().each(function (defs) {
            Object.extend(this.options, defs);
        } .bind(this));
    }, prepareSubmission: function () {
        this._saving = true;
        this.removeForm();
        this.leaveHover();
        this.showSaving();
    }, registerListeners: function () {
        this._listeners = {};
        var listener;
        $H(Ajax.InPlaceEditor.Listeners).each(function (pair) {
            listener = this[pair.value].bind(this);
            this._listeners[pair.key] = listener;
            if (!this.options.externalControlOnly)
                this.element.observe(pair.key, listener);
            if (this.options.externalControl)
                this.options.externalControl.observe(pair.key, listener);
        } .bind(this));
    }, removeForm: function () {
        if (!this._form) return;
        this._form.remove();
        this._form = null;
        this._controls = {};
    }, showSaving: function () {
        this._oldInnerHTML = this.element.innerHTML;
        this.element.innerHTML = this.options.savingText;
        this.element.addClassName(this.options.savingClassName);
        this.element.style.backgroundColor = this._originalBackground;
        this.element.show();
    }, triggerCallback: function (cbName, arg) {
        if ('function' == typeof this.options[cbName]) {
            this.options[cbName](this, arg);
        }
    }, unregisterListeners: function () {
        $H(this._listeners).each(function (pair) {
            if (!this.options.externalControlOnly)
                this.element.stopObserving(pair.key, pair.value);
            if (this.options.externalControl)
                this.options.externalControl.stopObserving(pair.key, pair.value);
        } .bind(this));
    }, wrapUp: function (transport) {
        this.leaveEditMode();
        // Can't use triggerCallback due to backward compatibility: requires
        // binding + direct element
        this._boundComplete(transport, this.element);
    }
});
Object.extend(Ajax.InPlaceEditor.prototype, {
    dispose: Ajax.InPlaceEditor.prototype.destroy
});
Ajax.InPlaceCollectionEditor = Class.create(Ajax.InPlaceEditor, {
    initialize: function ($super, element, url, options) {
        this._extraDefaultOptions = Ajax.InPlaceCollectionEditor.DefaultOptions;
        $super(element, url, options);
    }, createEditField: function () {
        var list = document.createElement('select');
        list.name = this.options.paramName;
        list.size = 1;
        this._controls.editor = list;
        this._collection = this.options.collection || [];
        if (this.options.loadCollectionURL)
            this.loadCollection();
        else
            this.checkForExternalText();
        this._form.appendChild(this._controls.editor);
    }, loadCollection: function () {
        this._form.addClassName(this.options.loadingClassName);
        this.showLoadingText(this.options.loadingCollectionText);
        var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
        Object.extend(options, {
            parameters: 'editorId=' + encodeURIComponent(this.element.id), onComplete: Prototype.emptyFunction, onSuccess: function (transport) {
                var js = transport.responseText.strip();
                if (!/^\[.*\]$/.test(js)) // TODO: improve sanity check
                    throw ('Server returned an invalid collection representation.');
                this._collection = eval(js);
                this.checkForExternalText();
            } .bind(this), onFailure: this.onFailure
        });
        new Ajax.Request(this.options.loadCollectionURL, options);
    }, showLoadingText: function (text) {
        this._controls.editor.disabled = true;
        var tempOption = this._controls.editor.firstChild;
        if (!tempOption) {
            tempOption = document.createElement('option');
            tempOption.value = '';
            this._controls.editor.appendChild(tempOption);
            tempOption.selected = true;
        }
        tempOption.update((text || '').stripScripts().stripTags());
    }, checkForExternalText: function () {
        this._text = this.getText();
        if (this.options.loadTextURL)
            this.loadExternalText();
        else
            this.buildOptionList();
    }, loadExternalText: function () {
        this.showLoadingText(this.options.loadingText);
        var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
        Object.extend(options, {
            parameters: 'editorId=' + encodeURIComponent(this.element.id), onComplete: Prototype.emptyFunction, onSuccess: function (transport) {
                this._text = transport.responseText.strip();
                this.buildOptionList();
            } .bind(this), onFailure: this.onFailure
        });
        new Ajax.Request(this.options.loadTextURL, options);
    }, buildOptionList: function () {
        this._form.removeClassName(this.options.loadingClassName);
        this._collection = this._collection.map(function (entry) {
            return 2 === entry.length ? entry : [entry, entry].flatten();
        });
        var marker = ('value' in this.options) ? this.options.value : this._text;
        var textFound = this._collection.any(function (entry) {
            return entry[0] == marker;
        } .bind(this));
        this._controls.editor.update('');
        var option;
        this._collection.each(function (entry, index) {
            option = document.createElement('option');
            option.value = entry[0];
            option.selected = textFound ? entry[0] == marker : 0 == index;
            option.appendChild(document.createTextNode(entry[1]));
            this._controls.editor.appendChild(option);
        } .bind(this));
        this._controls.editor.disabled = false;
        Field.scrollFreeActivate(this._controls.editor);
    }
});
//**** DEPRECATION LAYER FOR InPlace[Collection]Editor! ****
//**** This only  exists for a while,in order to  let ****
//**** users adapt to  the new API.  Read up on the new ****
//**** API and convert your code to it ASAP!            ****
Ajax.InPlaceEditor.prototype.initialize.dealWithDeprecatedOptions = function (options) {
    if (!options) return;
    function fallback(name, expr) {
        if (name in options || expr === undefined) return;
        options[name] = expr;
    };
    fallback('cancelControl', (options.cancelLink ? 'link' : (options.cancelButton ? 'button' :
options.cancelLink == options.cancelButton == false ? false : undefined)));
    fallback('okControl', (options.okLink ? 'link' : (options.okButton ? 'button' :
options.okLink == options.okButton == false ? false : undefined)));
    fallback('highlightColor', options.highlightcolor);
    fallback('highlightEndColor', options.highlightendcolor);
};
Object.extend(Ajax.InPlaceEditor, {
    DefaultOptions: {
        ajaxOptions: {}, autoRows: 3, // Use when multi-line w/ rows == 1
        cancelControl: 'link', // 'link'|'button'|false
        cancelText: 'cancel', clickToEditText: 'Click to edit', externalControl: null, // id|elt
        externalControlOnly: false, fieldPostCreation: 'activate', // 'activate'|'focus'|false
        formClassName: 'inplaceeditor-form', formId: null, // id|elt
        highlightColor: '#ffff99', highlightEndColor: '#ffffff', hoverClassName: '', htmlResponse: true, loadingClassName: 'inplaceeditor-loading', loadingText: 'Loading...', okControl: 'button', // 'link'|'button'|false
        okText: 'ok', paramName: 'value', rows: 1, // If 1 and multi-line,uses autoRows
        savingClassName: 'inplaceeditor-saving', savingText: 'Saving...', size: 0, stripLoadedTextTags: false, submitOnBlur: false, textAfterControls: '', textBeforeControls: '', textBetweenControls: ''
    }, DefaultCallbacks: {
        callback: function (form) {
            return Form.serialize(form);
        }, onComplete: function (transport, element) {
            // For backward compatibility,this one is bound to the IPE,and passes
            // the element directly.  It was too often customized,so we don't break it.
            new Effect.Highlight(element, {
                startcolor: this.options.highlightColor, keepBackgroundImage: true
            });
        }, onEnterEditMode: null, onEnterHover: function (ipe) {
            ipe.element.style.backgroundColor = ipe.options.highlightColor;
            if (ipe._effect)
                ipe._effect.cancel();
        }, onFailure: function (transport, ipe) {
            alert('Error communication with the server: ' + transport.responseText.stripTags());
        }, onFormCustomization: null, // Takes the IPE and its generated form,after editor,before controls.
        onLeaveEditMode: null, onLeaveHover: function (ipe) {
            ipe._effect = new Effect.Highlight(ipe.element, {
                startcolor: ipe.options.highlightColor, endcolor: ipe.options.highlightEndColor, restorecolor: ipe._originalBackground, keepBackgroundImage: true
            });
        }
    }, Listeners: {
        click: 'enterEditMode', keydown: 'checkForEscapeOrReturn', mouseover: 'enterHover', mouseout: 'leaveHover'
    }
});
Ajax.InPlaceCollectionEditor.DefaultOptions = {
    loadingCollectionText: 'Loading options...'
};
// Delayed observer,like Form.Element.Observer,// but waits for delay after last key input
// Ideal for live-search fields
Form.Element.DelayedObserver = Class.create({
    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.9.0,Thu Dec 23 16:54:48 -0500 2010
// Copyright (c) 2005-2010 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 = {};
// options:
//  axis: 'vertical',or 'horizontal' (default)
//
// callbacks:
//  onChange(value)
//  onSlide(value)
Control.Slider = Class.create({
    initialize: function (handle, track, options) {
        var slider = this;
        if (Object.isArray(handle)) {
            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(
(Object.isArray(slider.options.sliderValue) ?
slider.options.sliderValue[i] : slider.options.sliderValue) ||
slider.range.start), i);
            h.makePositioned().observe("mousedown", slider.eventMouseDown);
        });
        this.track.observe("mousedown", this.eventMouseDown);
        document.observe("mouseup", this.eventMouseUp);
        document.observe("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(document, "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.alignX);
    }, 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 = this.track.cumulativeOffset();
                    this.event = event;
                    this.setValue(this.translateToValue(
(this.isVertical() ? pointer[1] - offsets[1] : pointer[0] - offsets[0]) - (this.handleLength / 2)
));
                    var offsets = this.activeHandle.cumulativeOffset();
                    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 = this.activeHandle.cumulativeOffset();
                        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 = this.track.cumulativeOffset();
        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;
    }
});
// ---------------------------------------------------------------------------
// Javascript:ShadowBox
// ---------------------------------------------------------------------------
/*
* Shadowbox.js,version 3.0.3
* http://shadowbox-js.com/
* Copyright 2007-2010,Michael J. I. Jackson
* Date: 2010-04-21 09:28:06 +0000
*/
(function (window, undefined) {
    var S = { version: "3.0.3" }; var ua = navigator.userAgent.toLowerCase(); if (ua.indexOf("windows") > -1 || ua.indexOf("win32") > -1) { S.isWindows = true } else { if (ua.indexOf("macintosh") > -1 || ua.indexOf("mac os x") > -1) { S.isMac = true } else { if (ua.indexOf("linux") > -1) { S.isLinux = true } } } S.isIE = ua.indexOf("msie") > -1; S.isIE6 = ua.indexOf("msie 6") > -1; S.isIE7 = ua.indexOf("msie 7") > -1; S.isGecko = ua.indexOf("gecko") > -1 && ua.indexOf("safari") == -1; S.isWebKit = ua.indexOf("applewebkit/") > -1; var inlineId = /#(.+)$/, galleryName = /^(light|shadow)box\[(.*?)\]/i, inlineParam = /\s*([a-z_]*?)\s*=\s*(.+)\s*/, fileExtension = /[0-9a-z]+$/i, scriptPath = /(.+\/)shadowbox\.js/i; var open = false, initialized = false, lastOptions = {}, slideDelay = 0, slideStart, slideTimer; S.current = -1; S.dimensions = null; S.ease = function (state) { return 1 + Math.pow(state - 1, 3) }; S.errorInfo = { fla: { name: "Flash", url: "http://www.adobe.com/products/flashplayer/" }, qt: { name: "QuickTime", url: "http://www.apple.com/quicktime/download/" }, wmp: { name: "Windows Media Player", url: "http://www.microsoft.com/windows/windowsmedia/" }, f4m: { name: "Flip4Mac", url: "http://www.flip4mac.com/wmv_download.htm"} }; S.gallery = []; S.onReady = noop; S.path = null; S.player = null; S.playerId = "sb-player"; S.options = { animate: true, animateFade: true, autoplayMovies: true, continuous: false, enableKeys: true, flashParams: { bgcolor: "#000000", allowfullscreen: true }, flashVars: {}, flashVersion: "9.0.115", handleOversize: "resize", handleUnsupported: "link", onChange: noop, onClose: noop, onFinish: noop, onOpen: noop, showMovieControls: true, skipSetup: false, slideshowDelay: 0, viewportPadding: 20 }; S.getCurrent = function () { return S.current > -1 ? S.gallery[S.current] : null }; S.hasNext = function () { return S.gallery.length > 1 && (S.current != S.gallery.length - 1 || S.options.continuous) }; S.isOpen = function () { return open }; S.isPaused = function () { return slideTimer == "pause" }; S.applyOptions = function (options) { lastOptions = apply({}, S.options); apply(S.options, options) }; S.revertOptions = function () { apply(S.options, lastOptions) }; S.init = function (options, callback) { if (initialized) { return } initialized = true; if (S.skin.options) { apply(S.options, S.skin.options) } if (options) { apply(S.options, options) } if (!S.path) { var path, scripts = document.getElementsByTagName("script"); for (var i = 0, len = scripts.length; i < len; ++i) { path = scriptPath.exec(scripts[i].src); if (path) { S.path = path[1]; break } } } if (callback) { S.onReady = callback } bindLoad() }; S.open = function (obj) { if (open) { return } var gc = S.makeGallery(obj); S.gallery = gc[0]; S.current = gc[1]; obj = S.getCurrent(); if (obj == null) { return } S.applyOptions(obj.options || {}); filterGallery(); if (S.gallery.length) { obj = S.getCurrent(); if (S.options.onOpen(obj) === false) { return } open = true; S.skin.onOpen(obj, load) } }; S.close = function () { if (!open) { return } open = false; if (S.player) { S.player.remove(); S.player = null } if (typeof slideTimer == "number") { clearTimeout(slideTimer); slideTimer = null } slideDelay = 0; listenKeys(false); S.options.onClose(S.getCurrent()); S.skin.onClose(); S.revertOptions() }; S.play = function () { if (!S.hasNext()) { return } if (!slideDelay) { slideDelay = S.options.slideshowDelay * 1000 } if (slideDelay) { slideStart = now(); slideTimer = setTimeout(function () { slideDelay = slideStart = 0; S.next() }, slideDelay); if (S.skin.onPlay) { S.skin.onPlay() } } }; S.pause = function () { if (typeof slideTimer != "number") { return } slideDelay = Math.max(0, slideDelay - (now() - slideStart)); if (slideDelay) { clearTimeout(slideTimer); slideTimer = "pause"; if (S.skin.onPause) { S.skin.onPause() } } }; S.change = function (index) { if (!(index in S.gallery)) { if (S.options.continuous) { index = (index < 0 ? S.gallery.length + index : 0); if (!(index in S.gallery)) { return } } else { return } } S.current = index; if (typeof slideTimer == "number") { clearTimeout(slideTimer); slideTimer = null; slideDelay = slideStart = 0 } S.options.onChange(S.getCurrent()); load(true) }; S.next = function () { S.change(S.current + 1) }; S.previous = function () { S.change(S.current - 1) }; S.setDimensions = function (height, width, maxHeight, maxWidth, topBottom, leftRight, padding, preserveAspect) { var originalHeight = height, originalWidth = width; var extraHeight = 2 * padding + topBottom; if (height + extraHeight > maxHeight) { height = maxHeight - extraHeight } var extraWidth = 2 * padding + leftRight; if (width + extraWidth > maxWidth) { width = maxWidth - extraWidth } var changeHeight = (originalHeight - height) / originalHeight, changeWidth = (originalWidth - width) / originalWidth, oversized = (changeHeight > 0 || changeWidth > 0); if (preserveAspect && oversized) { if (changeHeight > changeWidth) { width = Math.round((originalWidth / originalHeight) * height) } else { if (changeWidth > changeHeight) { height = Math.round((originalHeight / originalWidth) * width) } } } S.dimensions = { height: height + topBottom, width: width + leftRight, innerHeight: height, innerWidth: width, top: Math.floor((maxHeight - (height + extraHeight)) / 2 + padding), left: Math.floor((maxWidth - (width + extraWidth)) / 2 + padding), oversized: oversized }; return S.dimensions }; S.makeGallery = function (obj) { var gallery = [], current = -1; if (typeof obj == "string") { obj = [obj] } if (typeof obj.length == "number") { each(obj, function (i, o) { if (o.content) { gallery[i] = o } else { gallery[i] = { content: o} } }); current = 0 } else { if (obj.tagName) { var cacheObj = S.getCache(obj); obj = cacheObj ? cacheObj : S.makeObject(obj) } if (obj.gallery) { gallery = []; var o; for (var key in S.cache) { o = S.cache[key]; if (o.gallery && o.gallery == obj.gallery) { if (current == -1 && o.content == obj.content) { current = gallery.length } gallery.push(o) } } if (current == -1) { gallery.unshift(obj); current = 0 } } else { gallery = [obj]; current = 0 } } each(gallery, function (i, o) { gallery[i] = apply({}, o) }); return [gallery, current] }; S.makeObject = function (link, options) { var obj = { content: link.href, title: link.getAttribute("title") || "", link: link }; if (options) { options = apply({}, options); each(["player", "title", "height", "width", "gallery"], function (i, o) { if (typeof options[o] != "undefined") { obj[o] = options[o]; delete options[o] } }); obj.options = options } else { obj.options = {} } if (!obj.player) { obj.player = S.getPlayer(obj.content) } var rel = link.getAttribute("rel"); if (rel) { var match = rel.match(galleryName); if (match) { obj.gallery = escape(match[2]) } each(rel.split(";"), function (i, p) { match = p.match(inlineParam); if (match) { obj[match[1]] = match[2] } }) } return obj }; S.getPlayer = function (content) { if (content.indexOf("#") > -1 && content.indexOf(document.location.href) == 0) { return "inline" } var q = content.indexOf("?"); if (q > -1) { content = content.substring(0, q) } var ext, m = content.match(fileExtension); if (m) { ext = m[0].toLowerCase() } if (ext) { if (S.img && S.img.ext.indexOf(ext) > -1) { return "img" } if (S.swf && S.swf.ext.indexOf(ext) > -1) { return "swf" } if (S.flv && S.flv.ext.indexOf(ext) > -1) { return "flv" } if (S.qt && S.qt.ext.indexOf(ext) > -1) { if (S.wmp && S.wmp.ext.indexOf(ext) > -1) { return "qtwmp" } else { return "qt" } } if (S.wmp && S.wmp.ext.indexOf(ext) > -1) { return "wmp" } } return "iframe" }; function filterGallery() { var err = S.errorInfo, plugins = S.plugins, obj, remove, needed, m, format, replace, inlineEl, flashVersion; for (var i = 0; i < S.gallery.length; ++i) { obj = S.gallery[i]; remove = false; needed = null; switch (obj.player) { case "flv": case "swf": if (!plugins.fla) { needed = "fla" } break; case "qt": if (!plugins.qt) { needed = "qt" } break; case "wmp": if (S.isMac) { if (plugins.qt && plugins.f4m) { obj.player = "qt" } else { needed = "qtf4m" } } else { if (!plugins.wmp) { needed = "wmp" } } break; case "qtwmp": if (plugins.qt) { obj.player = "qt" } else { if (plugins.wmp) { obj.player = "wmp" } else { needed = "qtwmp" } } break } if (needed) { if (S.options.handleUnsupported == "link") { switch (needed) { case "qtf4m": format = "shared"; replace = [err.qt.url, err.qt.name, err.f4m.url, err.f4m.name]; break; case "qtwmp": format = "either"; replace = [err.qt.url, err.qt.name, err.wmp.url, err.wmp.name]; break; default: format = "single"; replace = [err[needed].url, err[needed].name] } obj.player = "html"; obj.content = '<div class="sb-message">' + sprintf(S.lang.errors[format], replace) + "</div>" } else { remove = true } } else { if (obj.player == "inline") { m = inlineId.exec(obj.content); if (m) { inlineEl = get(m[1]); if (inlineEl) { obj.content = inlineEl.innerHTML } else { remove = true } } else { remove = true } } else { if (obj.player == "swf" || obj.player == "flv") { flashVersion = (obj.options && obj.options.flashVersion) || S.options.flashVersion; if (S.flash && !S.flash.hasFlashPlayerVersion(flashVersion)) { obj.width = 310; obj.height = 177 } } } } if (remove) { S.gallery.splice(i, 1); if (i < S.current) { --S.current } else { if (i == S.current) { S.current = i > 0 ? i - 1 : i } } --i } } } function listenKeys(on) { if (!S.options.enableKeys) { return } (on ? addEvent : removeEvent)(document, "keydown", handleKey) } function handleKey(e) { if (e.metaKey || e.shiftKey || e.altKey || e.ctrlKey) { return } var code = keyCode(e), handler; switch (code) { case 81: case 88: case 27: handler = S.close; break; case 37: handler = S.previous; break; case 39: handler = S.next; break; case 32: handler = typeof slideTimer == "number" ? S.pause : S.play; break } if (handler) { preventDefault(e); handler() } } function load(changing) { listenKeys(false); var obj = S.getCurrent(); var player = (obj.player == "inline" ? "html" : obj.player); if (typeof S[player] != "function") { throw "unknown player " + player } if (changing) { S.player.remove(); S.revertOptions(); S.applyOptions(obj.options || {}) } S.player = new S[player](obj, S.playerId); if (S.gallery.length > 1) { var next = S.gallery[S.current + 1] || S.gallery[0]; if (next.player == "img") { var a = new Image(); a.src = next.content } var prev = S.gallery[S.current - 1] || S.gallery[S.gallery.length - 1]; if (prev.player == "img") { var b = new Image(); b.src = prev.content } } S.skin.onLoad(changing, waitReady) } function waitReady() { if (!open) { return } if (typeof S.player.ready != "undefined") { var timer = setInterval(function () { if (open) { if (S.player.ready) { clearInterval(timer); timer = null; S.skin.onReady(show) } } else { clearInterval(timer); timer = null } }, 10) } else { S.skin.onReady(show) } } function show() { if (!open) { return } S.player.append(S.skin.body, S.dimensions); S.skin.onShow(finish) } function finish() { if (!open) { return } if (S.player.onLoad) { S.player.onLoad() } S.options.onFinish(S.getCurrent()); if (!S.isPaused()) { S.play() } listenKeys(true) } if (!Array.prototype.indexOf) { Array.prototype.indexOf = function (obj, from) { var len = this.length >>> 0; from = from || 0; if (from < 0) { from += len } for (; from < len; ++from) { if (from in this && this[from] === obj) { return from } } return -1 } } function now() { return (new Date).getTime() } function apply(original, extension) { for (var property in extension) { original[property] = extension[property] } return original } function each(obj, callback) { var i = 0, len = obj.length; for (var value = obj[0]; i < len && callback.call(value, i, value) !== false; value = obj[++i]) { } } function sprintf(str, replace) { return str.replace(/\{(\w+?)\}/g, function (match, i) { return replace[i] }) } function noop() { } function get(id) { return document.getElementById(id) } function remove(el) { el.parentNode.removeChild(el) } var supportsOpacity = true, supportsFixed = true; function checkSupport() { var body = document.body, div = document.createElement("div"); supportsOpacity = typeof div.style.opacity === "string"; div.style.position = "fixed"; div.style.margin = 0; div.style.top = "20px"; body.appendChild(div, body.firstChild); supportsFixed = div.offsetTop == 20; body.removeChild(div) } S.getStyle = (function () { var opacity = /opacity=([^)]*)/, getComputedStyle = document.defaultView && document.defaultView.getComputedStyle; return function (el, style) { var ret; if (!supportsOpacity && style == "opacity" && el.currentStyle) { ret = opacity.test(el.currentStyle.filter || "") ? (parseFloat(RegExp.$1) / 100) + "" : ""; return ret === "" ? "1" : ret } if (getComputedStyle) { var computedStyle = getComputedStyle(el, null); if (computedStyle) { ret = computedStyle[style] } if (style == "opacity" && ret == "") { ret = "1" } } else { ret = el.currentStyle[style] } return ret } })(); S.appendHTML = function (el, html) { if (el.insertAdjacentHTML) { el.insertAdjacentHTML("BeforeEnd", html) } else { if (el.lastChild) { var range = el.ownerDocument.createRange(); range.setStartAfter(el.lastChild); var frag = range.createContextualFragment(html); el.appendChild(frag) } else { el.innerHTML = html } } }; S.getWindowSize = function (dimension) { if (document.compatMode === "CSS1Compat") { return document.documentElement["client" + dimension] } return document.body["client" + dimension] }; S.setOpacity = function (el, opacity) { var style = el.style; if (supportsOpacity) { style.opacity = (opacity == 1 ? "" : opacity) } else { style.zoom = 1; if (opacity == 1) { if (typeof style.filter == "string" && (/alpha/i).test(style.filter)) { style.filter = style.filter.replace(/\s*[\w\.]*alpha\([^\)]*\);?/gi, "") } } else { style.filter = (style.filter || "").replace(/\s*[\w\.]*alpha\([^\)]*\)/gi, "") + " alpha(opacity=" + (opacity * 100) + ")" } } }; S.clearOpacity = function (el) { S.setOpacity(el, 1) }; var E = Event; function getTarget(e) { return E.element(e) } function getPageXY(e) { return [E.pointerX(e), E.pointerY(e)] } function preventDefault(e) { E.stop(e) } function keyCode(e) { return e.keyCode } function addEvent(el, type, handler) { E.observe(el, type, handler) } function removeEvent(el, type, handler) { E.stopObserving(el, type, handler) } var loaded = false, DOMContentLoaded; if (document.addEventListener) { DOMContentLoaded = function () { document.removeEventListener("DOMContentLoaded", DOMContentLoaded, false); S.load() } } else { if (document.attachEvent) { DOMContentLoaded = function () { if (document.readyState === "complete") { document.detachEvent("onreadystatechange", DOMContentLoaded); S.load() } } } } function doScrollCheck() { if (loaded) { return } try { document.documentElement.doScroll("left") } catch (e) { setTimeout(doScrollCheck, 1); return } S.load() } function bindLoad() { if (document.readyState === "complete") { return S.load() } if (document.addEventListener) { document.addEventListener("DOMContentLoaded", DOMContentLoaded, false); window.addEventListener("load", S.load, false) } else { if (document.attachEvent) { document.attachEvent("onreadystatechange", DOMContentLoaded); window.attachEvent("onload", S.load); var topLevel = false; try { topLevel = window.frameElement === null } catch (e) { } if (document.documentElement.doScroll && topLevel) { doScrollCheck() } } } } S.load = function () { if (loaded) { return } if (!document.body) { return setTimeout(S.load, 13) } loaded = true; checkSupport(); S.onReady(); if (!S.options.skipSetup) { S.setup() } S.skin.init() }; S.plugins = {}; if (navigator.plugins && navigator.plugins.length) { var names = []; each(navigator.plugins, function (i, p) { names.push(p.name) }); names = names.join(","); var f4m = names.indexOf("Flip4Mac") > -1; S.plugins = { fla: names.indexOf("Shockwave Flash") > -1, qt: names.indexOf("QuickTime") > -1, wmp: !f4m && names.indexOf("Windows Media") > -1, f4m: f4m} } else { var detectPlugin = function (name) { var axo; try { axo = new ActiveXObject(name) } catch (e) { } return !!axo }; S.plugins = { fla: detectPlugin("ShockwaveFlash.ShockwaveFlash"), qt: detectPlugin("QuickTime.QuickTime"), wmp: detectPlugin("wmplayer.ocx"), f4m: false} } var relAttr = /^(light|shadow)box/i, expando = "shadowboxCacheKey", cacheKey = 1; S.cache = {}; S.select = function (selector) { var links = []; if (!selector) { var rel; each(document.getElementsByTagName("a"), function (i, el) { rel = el.getAttribute("rel"); if (rel && relAttr.test(rel)) { links.push(el) } }) } else { var length = selector.length; if (length) { if (typeof selector == "string") { if (S.find) { links = S.find(selector) } } else { if (length == 2 && typeof selector[0] == "string" && selector[1].nodeType) { if (S.find) { links = S.find(selector[0], selector[1]) } } else { for (var i = 0; i < length; ++i) { links[i] = selector[i] } } } } else { links.push(selector) } } return links }; S.setup = function (selector, options) { each(S.select(selector), function (i, link) { S.addCache(link, options) }) }; S.teardown = function (selector) { each(S.select(selector), function (i, link) { S.removeCache(link) }) }; S.addCache = function (link, options) { var key = link[expando]; if (key == undefined) { key = cacheKey++; link[expando] = key; addEvent(link, "click", handleClick) } S.cache[key] = S.makeObject(link, options) }; S.removeCache = function (link) { removeEvent(link, "click", handleClick); delete S.cache[link[expando]]; link[expando] = null }; S.getCache = function (link) { var key = link[expando]; return (key in S.cache && S.cache[key]) }; S.clearCache = function () { for (var key in S.cache) { S.removeCache(S.cache[key].link) } S.cache = {} }; function handleClick(e) { S.open(this); if (S.gallery.length) { preventDefault(e) } }
    /*
    * SWFObject v2.1 <http://code.google.com/p/swfobject/>
    * Copyright (c) 2007-2008 Geoff Stearns,Michael Williams,and Bobby van der Sluis
    * This software is released under the MIT License <http://www.opensource.org/licenses/mit-license.php>
    * Modified for inclusion in Shadowbox.js
    */
    S.flash = (function () {
        var swfobject = function () {
            var UNDEF = "undefined", OBJECT = "object", SHOCKWAVE_FLASH = "Shockwave Flash", SHOCKWAVE_FLASH_AX = "ShockwaveFlash.ShockwaveFlash", FLASH_MIME_TYPE = "application/x-shockwave-flash", EXPRESS_INSTALL_ID = "SWFObjectExprInst", win = window, doc = document, nav = navigator, domLoadFnArr = [], regObjArr = [], objIdArr = [], listenersArr = [], script, timer = null, storedAltContent = null, storedAltContentId = null, isDomLoaded = false, isExpressInstallActive = false; var ua = function () {
                var w3cdom = typeof doc.getElementById != UNDEF && typeof doc.getElementsByTagName != UNDEF && typeof doc.createElement != UNDEF, playerVersion = [0, 0, 0], d = null; if (typeof nav.plugins != UNDEF && typeof nav.plugins[SHOCKWAVE_FLASH] == OBJECT) { d = nav.plugins[SHOCKWAVE_FLASH].description; if (d && !(typeof nav.mimeTypes != UNDEF && nav.mimeTypes[FLASH_MIME_TYPE] && !nav.mimeTypes[FLASH_MIME_TYPE].enabledPlugin)) { d = d.replace(/^.*\s+(\S+\s+\S+$)/, "$1"); playerVersion[0] = parseInt(d.replace(/^(.*)\..*$/, "$1"), 10); playerVersion[1] = parseInt(d.replace(/^.*\.(.*)\s.*$/, "$1"), 10); playerVersion[2] = /r/.test(d) ? parseInt(d.replace(/^.*r(.*)$/, "$1"), 10) : 0 } } else { if (typeof win.ActiveXObject != UNDEF) { var a = null, fp6Crash = false; try { a = new ActiveXObject(SHOCKWAVE_FLASH_AX + ".7") } catch (e) { try { a = new ActiveXObject(SHOCKWAVE_FLASH_AX + ".6"); playerVersion = [6, 0, 21]; a.AllowScriptAccess = "always" } catch (e) { if (playerVersion[0] == 6) { fp6Crash = true } } if (!fp6Crash) { try { a = new ActiveXObject(SHOCKWAVE_FLASH_AX) } catch (e) { } } } if (!fp6Crash && a) { try { d = a.GetVariable("$version"); if (d) { d = d.split(" ")[1].split(","); playerVersion = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)] } } catch (e) { } } } } var u = nav.userAgent.toLowerCase(), p = nav.platform.toLowerCase(), webkit = /webkit/.test(u) ? parseFloat(u.replace(/^.*webkit\/(\d+(\.\d+)?).*$/, "$1")) : false, ie = false, windows = p ? /win/.test(p) : /win/.test(u), mac = p ? /mac/.test(p) : /mac/.test(u);
                /*@cc_on
                ie = true;
                @if (@_win32)
                windows = true;
                @elif (@_mac)
mac = true;
@end
                @*/
                return { w3cdom: w3cdom, pv: playerVersion, webkit: webkit, ie: ie, win: windows, mac: mac}
            } (); var onDomLoad = function () { if (!ua.w3cdom) { return } addDomLoadEvent(main); if (ua.ie && ua.win) { try { doc.write("<script id=__ie_ondomload defer=true src=//:><\/script>"); script = getElementById("__ie_ondomload"); if (script) { addListener(script, "onreadystatechange", checkReadyState) } } catch (e) { } } if (ua.webkit && typeof doc.readyState != UNDEF) { timer = setInterval(function () { if (/loaded|complete/.test(doc.readyState)) { callDomLoadFunctions() } }, 10) } if (typeof doc.addEventListener != UNDEF) { doc.addEventListener("DOMContentLoaded", callDomLoadFunctions, null) } addLoadEvent(callDomLoadFunctions) } (); function checkReadyState() { if (script.readyState == "complete") { script.parentNode.removeChild(script); callDomLoadFunctions() } } function callDomLoadFunctions() { if (isDomLoaded) { return } if (ua.ie && ua.win) { var s = createElement("span"); try { var t = doc.getElementsByTagName("body")[0].appendChild(s); t.parentNode.removeChild(t) } catch (e) { return } } isDomLoaded = true; if (timer) { clearInterval(timer); timer = null } var dl = domLoadFnArr.length; for (var i = 0; i < dl; i++) { domLoadFnArr[i]() } } function addDomLoadEvent(fn) { if (isDomLoaded) { fn() } else { domLoadFnArr[domLoadFnArr.length] = fn } } function addLoadEvent(fn) { if (typeof win.addEventListener != UNDEF) { win.addEventListener("load", fn, false) } else { if (typeof doc.addEventListener != UNDEF) { doc.addEventListener("load", fn, false) } else { if (typeof win.attachEvent != UNDEF) { addListener(win, "onload", fn) } else { if (typeof win.onload == "function") { var fnOld = win.onload; win.onload = function () { fnOld(); fn() } } else { win.onload = fn } } } } } function main() { var rl = regObjArr.length; for (var i = 0; i < rl; i++) { var id = regObjArr[i].id; if (ua.pv[0] > 0) { var obj = getElementById(id); if (obj) { regObjArr[i].width = obj.getAttribute("width") ? obj.getAttribute("width") : "0"; regObjArr[i].height = obj.getAttribute("height") ? obj.getAttribute("height") : "0"; if (hasPlayerVersion(regObjArr[i].swfVersion)) { if (ua.webkit && ua.webkit < 312) { fixParams(obj) } setVisibility(id, true) } else { if (regObjArr[i].expressInstall && !isExpressInstallActive && hasPlayerVersion("6.0.65") && (ua.win || ua.mac)) { showExpressInstall(regObjArr[i]) } else { displayAltContent(obj) } } } } else { setVisibility(id, true) } } } function fixParams(obj) { var nestedObj = obj.getElementsByTagName(OBJECT)[0]; if (nestedObj) { var e = createElement("embed"), a = nestedObj.attributes; if (a) { var al = a.length; for (var i = 0; i < al; i++) { if (a[i].nodeName == "DATA") { e.setAttribute("src", a[i].nodeValue) } else { e.setAttribute(a[i].nodeName, a[i].nodeValue) } } } var c = nestedObj.childNodes; if (c) { var cl = c.length; for (var j = 0; j < cl; j++) { if (c[j].nodeType == 1 && c[j].nodeName == "PARAM") { e.setAttribute(c[j].getAttribute("name"), c[j].getAttribute("value")) } } } obj.parentNode.replaceChild(e, obj) } } function showExpressInstall(regObj) { isExpressInstallActive = true; var obj = getElementById(regObj.id); if (obj) { if (regObj.altContentId) { var ac = getElementById(regObj.altContentId); if (ac) { storedAltContent = ac; storedAltContentId = regObj.altContentId } } else { storedAltContent = abstractAltContent(obj) } if (!(/%$/.test(regObj.width)) && parseInt(regObj.width, 10) < 310) { regObj.width = "310" } if (!(/%$/.test(regObj.height)) && parseInt(regObj.height, 10) < 137) { regObj.height = "137" } doc.title = doc.title.slice(0, 47) + " - Flash Player Installation"; var pt = ua.ie && ua.win ? "ActiveX" : "PlugIn", dt = doc.title, fv = "MMredirectURL=" + win.location + "&MMplayerType=" + pt + "&MMdoctitle=" + dt, replaceId = regObj.id; if (ua.ie && ua.win && obj.readyState != 4) { var newObj = createElement("div"); replaceId += "SWFObjectNew"; newObj.setAttribute("id", replaceId); obj.parentNode.insertBefore(newObj, obj); obj.style.display = "none"; var fn = function () { obj.parentNode.removeChild(obj) }; addListener(win, "onload", fn) } createSWF({ data: regObj.expressInstall, id: EXPRESS_INSTALL_ID, width: regObj.width, height: regObj.height }, { flashvars: fv }, replaceId) } } function displayAltContent(obj) { if (ua.ie && ua.win && obj.readyState != 4) { var el = createElement("div"); obj.parentNode.insertBefore(el, obj); el.parentNode.replaceChild(abstractAltContent(obj), el); obj.style.display = "none"; var fn = function () { obj.parentNode.removeChild(obj) }; addListener(win, "onload", fn) } else { obj.parentNode.replaceChild(abstractAltContent(obj), obj) } } function abstractAltContent(obj) { var ac = createElement("div"); if (ua.win && ua.ie) { ac.innerHTML = obj.innerHTML } else { var nestedObj = obj.getElementsByTagName(OBJECT)[0]; if (nestedObj) { var c = nestedObj.childNodes; if (c) { var cl = c.length; for (var i = 0; i < cl; i++) { if (!(c[i].nodeType == 1 && c[i].nodeName == "PARAM") && !(c[i].nodeType == 8)) { ac.appendChild(c[i].cloneNode(true)) } } } } } return ac } function createSWF(attObj, parObj, id) { var r, el = getElementById(id); if (el) { if (typeof attObj.id == UNDEF) { attObj.id = id } if (ua.ie && ua.win) { var att = ""; for (var i in attObj) { if (attObj[i] != Object.prototype[i]) { if (i.toLowerCase() == "data") { parObj.movie = attObj[i] } else { if (i.toLowerCase() == "styleclass") { att += ' class="' + attObj[i] + '"' } else { if (i.toLowerCase() != "classid") { att += " " + i + '="' + attObj[i] + '"' } } } } } var par = ""; for (var j in parObj) { if (parObj[j] != Object.prototype[j]) { par += '<param name="' + j + '" value="' + parObj[j] + '" />' } } el.outerHTML = '<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"' + att + ">" + par + "</object>"; objIdArr[objIdArr.length] = attObj.id; r = getElementById(attObj.id) } else { if (ua.webkit && ua.webkit < 312) { var e = createElement("embed"); e.setAttribute("type", FLASH_MIME_TYPE); for (var k in attObj) { if (attObj[k] != Object.prototype[k]) { if (k.toLowerCase() == "data") { e.setAttribute("src", attObj[k]) } else { if (k.toLowerCase() == "styleclass") { e.setAttribute("class", attObj[k]) } else { if (k.toLowerCase() != "classid") { e.setAttribute(k, attObj[k]) } } } } } for (var l in parObj) { if (parObj[l] != Object.prototype[l]) { if (l.toLowerCase() != "movie") { e.setAttribute(l, parObj[l]) } } } el.parentNode.replaceChild(e, el); r = e } else { var o = createElement(OBJECT); o.setAttribute("type", FLASH_MIME_TYPE); for (var m in attObj) { if (attObj[m] != Object.prototype[m]) { if (m.toLowerCase() == "styleclass") { o.setAttribute("class", attObj[m]) } else { if (m.toLowerCase() != "classid") { o.setAttribute(m, attObj[m]) } } } } for (var n in parObj) { if (parObj[n] != Object.prototype[n] && n.toLowerCase() != "movie") { createObjParam(o, n, parObj[n]) } } el.parentNode.replaceChild(o, el); r = o } } } return r } function createObjParam(el, pName, pValue) { var p = createElement("param"); p.setAttribute("name", pName); p.setAttribute("value", pValue); el.appendChild(p) } function removeSWF(id) { var obj = getElementById(id); if (obj && (obj.nodeName == "OBJECT" || obj.nodeName == "EMBED")) { if (ua.ie && ua.win) { if (obj.readyState == 4) { removeObjectInIE(id) } else { win.attachEvent("onload", function () { removeObjectInIE(id) }) } } else { obj.parentNode.removeChild(obj) } } } function removeObjectInIE(id) { var obj = getElementById(id); if (obj) { for (var i in obj) { if (typeof obj[i] == "function") { obj[i] = null } } obj.parentNode.removeChild(obj) } } function getElementById(id) { var el = null; try { el = doc.getElementById(id) } catch (e) { } return el } function createElement(el) { return doc.createElement(el) } function addListener(target, eventType, fn) { target.attachEvent(eventType, fn); listenersArr[listenersArr.length] = [target, eventType, fn] } function hasPlayerVersion(rv) { var pv = ua.pv, v = rv.split("."); v[0] = parseInt(v[0], 10); v[1] = parseInt(v[1], 10) || 0; v[2] = parseInt(v[2], 10) || 0; return (pv[0] > v[0] || (pv[0] == v[0] && pv[1] > v[1]) || (pv[0] == v[0] && pv[1] == v[1] && pv[2] >= v[2])) ? true : false } function createCSS(sel, decl) { if (ua.ie && ua.mac) { return } var h = doc.getElementsByTagName("head")[0], s = createElement("style"); s.setAttribute("type", "text/css"); s.setAttribute("media", "screen"); if (!(ua.ie && ua.win) && typeof doc.createTextNode != UNDEF) { s.appendChild(doc.createTextNode(sel + " {" + decl + "}")) } h.appendChild(s); if (ua.ie && ua.win && typeof doc.styleSheets != UNDEF && doc.styleSheets.length > 0) { var ls = doc.styleSheets[doc.styleSheets.length - 1]; if (typeof ls.addRule == OBJECT) { ls.addRule(sel, decl) } } } function setVisibility(id, isVisible) { var v = isVisible ? "visible" : "hidden"; if (isDomLoaded && getElementById(id)) { getElementById(id).style.visibility = v } else { createCSS("#" + id, "visibility:" + v) } } function urlEncodeIfNecessary(s) { var regex = /[\\\"<>\.;]/; var hasBadChars = regex.exec(s) != null; return hasBadChars ? encodeURIComponent(s) : s } var cleanup = function () { if (ua.ie && ua.win) { window.attachEvent("onunload", function () { var ll = listenersArr.length; for (var i = 0; i < ll; i++) { listenersArr[i][0].detachEvent(listenersArr[i][1], listenersArr[i][2]) } var il = objIdArr.length; for (var j = 0; j < il; j++) { removeSWF(objIdArr[j]) } for (var k in ua) { ua[k] = null } ua = null; for (var l in swfobject) { swfobject[l] = null } swfobject = null }) } } (); return { registerObject: function (objectIdStr, swfVersionStr, xiSwfUrlStr) { if (!ua.w3cdom || !objectIdStr || !swfVersionStr) { return } var regObj = {}; regObj.id = objectIdStr; regObj.swfVersion = swfVersionStr; regObj.expressInstall = xiSwfUrlStr ? xiSwfUrlStr : false; regObjArr[regObjArr.length] = regObj; setVisibility(objectIdStr, false) }, getObjectById: function (objectIdStr) { var r = null; if (ua.w3cdom) { var o = getElementById(objectIdStr); if (o) { var n = o.getElementsByTagName(OBJECT)[0]; if (!n || (n && typeof o.SetVariable != UNDEF)) { r = o } else { if (typeof n.SetVariable != UNDEF) { r = n } } } } return r }, embedSWF: function (swfUrlStr, replaceElemIdStr, widthStr, heightStr, swfVersionStr, xiSwfUrlStr, flashvarsObj, parObj, attObj) { if (!ua.w3cdom || !swfUrlStr || !replaceElemIdStr || !widthStr || !heightStr || !swfVersionStr) { return } widthStr += ""; heightStr += ""; if (hasPlayerVersion(swfVersionStr)) { setVisibility(replaceElemIdStr, false); var att = {}; if (attObj && typeof attObj === OBJECT) { for (var i in attObj) { if (attObj[i] != Object.prototype[i]) { att[i] = attObj[i] } } } att.data = swfUrlStr; att.width = widthStr; att.height = heightStr; var par = {}; if (parObj && typeof parObj === OBJECT) { for (var j in parObj) { if (parObj[j] != Object.prototype[j]) { par[j] = parObj[j] } } } if (flashvarsObj && typeof flashvarsObj === OBJECT) { for (var k in flashvarsObj) { if (flashvarsObj[k] != Object.prototype[k]) { if (typeof par.flashvars != UNDEF) { par.flashvars += "&" + k + "=" + flashvarsObj[k] } else { par.flashvars = k + "=" + flashvarsObj[k] } } } } addDomLoadEvent(function () { createSWF(att, par, replaceElemIdStr); if (att.id == replaceElemIdStr) { setVisibility(replaceElemIdStr, true) } }) } else { if (xiSwfUrlStr && !isExpressInstallActive && hasPlayerVersion("6.0.65") && (ua.win || ua.mac)) { isExpressInstallActive = true; setVisibility(replaceElemIdStr, false); addDomLoadEvent(function () { var regObj = {}; regObj.id = regObj.altContentId = replaceElemIdStr; regObj.width = widthStr; regObj.height = heightStr; regObj.expressInstall = xiSwfUrlStr; showExpressInstall(regObj) }) } } }, getFlashPlayerVersion: function () { return { major: ua.pv[0], minor: ua.pv[1], release: ua.pv[2]} }, hasFlashPlayerVersion: hasPlayerVersion, createSWF: function (attObj, parObj, replaceElemIdStr) { if (ua.w3cdom) { return createSWF(attObj, parObj, replaceElemIdStr) } else { return undefined } }, removeSWF: function (objElemIdStr) { if (ua.w3cdom) { removeSWF(objElemIdStr) } }, createCSS: function (sel, decl) { if (ua.w3cdom) { createCSS(sel, decl) } }, addDomLoadEvent: addDomLoadEvent, addLoadEvent: addLoadEvent, getQueryParamValue: function (param) { var q = doc.location.search || doc.location.hash; if (param == null) { return urlEncodeIfNecessary(q) } if (q) { var pairs = q.substring(1).split("&"); for (var i = 0; i < pairs.length; i++) { if (pairs[i].substring(0, pairs[i].indexOf("=")) == param) { return urlEncodeIfNecessary(pairs[i].substring((pairs[i].indexOf("=") + 1))) } } } return "" }, expressInstallCallback: function () { if (isExpressInstallActive && storedAltContent) { var obj = getElementById(EXPRESS_INSTALL_ID); if (obj) { obj.parentNode.replaceChild(storedAltContent, obj); if (storedAltContentId) { setVisibility(storedAltContentId, true); if (ua.ie && ua.win) { storedAltContent.style.display = "block" } } storedAltContent = null; storedAltContentId = null; isExpressInstallActive = false } } } }
        } (); return swfobject
    })(); S.lang = { code: "de", of: "von", loading: "loading", cancel: "Abbrechen", next: "Nächste", previous: "Vorige", play: "Abspielen", pause: "Pause", close: "Schließen", errors: { single: 'Um den Inhalt anzeigen zu können muss die Browser-Erweiterung <a href="{0}">{1}</a> installiert werden.', shared: 'Um den Inhalt anzeigen zu können müssen die beiden Browser-Erweiterungen <a href="{0}">{1}</a> und <a href="{2}">{3}</a> installiert werden.', either: 'Um den Inhalt anzeigen zu können muss eine der beiden Browser-Erweiterungen <a href="{0}">{1}</a> oder <a href="{2}">{3}</a> installiert werden.'} }; var pre, proxyId = "sb-drag-proxy", dragData, dragProxy, dragTarget; function resetDrag() { dragData = { x: 0, y: 0, startX: null, startY: null} } function updateProxy() { var dims = S.dimensions; apply(dragProxy.style, { height: dims.innerHeight + "px", width: dims.innerWidth + "px" }) } function enableDrag() { resetDrag(); var style = ["position:absolute", "cursor:" + (S.isGecko ? "-moz-grab" : "move"), "background-color:" + (S.isIE ? "#fff;filter:alpha(opacity=0)" : "transparent")].join(";"); S.appendHTML(S.skin.body, '<div id="' + proxyId + '" style="' + style + '"></div>'); dragProxy = get(proxyId); updateProxy(); addEvent(dragProxy, "mousedown", startDrag) } function disableDrag() { if (dragProxy) { removeEvent(dragProxy, "mousedown", startDrag); remove(dragProxy); dragProxy = null } dragTarget = null } function startDrag(e) { preventDefault(e); var xy = getPageXY(e); dragData.startX = xy[0]; dragData.startY = xy[1]; dragTarget = get(S.player.id); addEvent(document, "mousemove", positionDrag); addEvent(document, "mouseup", endDrag); if (S.isGecko) { dragProxy.style.cursor = "-moz-grabbing" } } function positionDrag(e) { var player = S.player, dims = S.dimensions, xy = getPageXY(e); var moveX = xy[0] - dragData.startX; dragData.startX += moveX; dragData.x = Math.max(Math.min(0, dragData.x + moveX), dims.innerWidth - player.width); var moveY = xy[1] - dragData.startY; dragData.startY += moveY; dragData.y = Math.max(Math.min(0, dragData.y + moveY), dims.innerHeight - player.height); apply(dragTarget.style, { left: dragData.x + "px", top: dragData.y + "px" }) } function endDrag() { removeEvent(document, "mousemove", positionDrag); removeEvent(document, "mouseup", endDrag); if (S.isGecko) { dragProxy.style.cursor = "-moz-grab" } } S.img = function (obj, id) { this.obj = obj; this.id = id; this.ready = false; var self = this; pre = new Image(); pre.onload = function () { self.height = obj.height ? parseInt(obj.height, 10) : pre.height; self.width = obj.width ? parseInt(obj.width, 10) : pre.width; self.ready = true; pre.onload = null; pre = null }; pre.src = obj.content }; S.img.ext = ["bmp", "gif", "jpg", "jpeg", "png"]; S.img.prototype = { append: function (body, dims) { var img = document.createElement("img"); img.id = this.id; img.src = this.obj.content; img.style.position = "absolute"; var height, width; if (dims.oversized && S.options.handleOversize == "resize") { height = dims.innerHeight; width = dims.innerWidth } else { height = this.height; width = this.width } img.setAttribute("height", height); img.setAttribute("width", width); body.appendChild(img) }, remove: function () { var el = get(this.id); if (el) { remove(el) } disableDrag(); if (pre) { pre.onload = null; pre = null } }, onLoad: function () { var dims = S.dimensions; if (dims.oversized && S.options.handleOversize == "drag") { enableDrag() } }, onWindowResize: function () { var dims = S.dimensions; switch (S.options.handleOversize) { case "resize": var el = get(this.id); el.height = dims.innerHeight; el.width = dims.innerWidth; break; case "drag": if (dragTarget) { var top = parseInt(S.getStyle(dragTarget, "top")), left = parseInt(S.getStyle(dragTarget, "left")); if (top + this.height < dims.innerHeight) { dragTarget.style.top = dims.innerHeight - this.height + "px" } if (left + this.width < dims.innerWidth) { dragTarget.style.left = dims.innerWidth - this.width + "px" } updateProxy() } break } } }; S.iframe = function (obj, id) { this.obj = obj; this.id = id; var overlay = get("sb-overlay"); this.height = obj.height ? parseInt(obj.height, 10) : overlay.offsetHeight; this.width = obj.width ? parseInt(obj.width, 10) : overlay.offsetWidth }; S.iframe.prototype = { append: function (body, dims) { var html = '<iframe id="' + this.id + '" name="' + this.id + '" height="100%" width="100%" frameborder="0" marginwidth="0" marginheight="0" style="visibility:hidden" onload="this.style.visibility=\'visible\'" scrolling="auto"'; if (S.isIE) { html += ' allowtransparency="true"'; if (S.isIE6) { html += " src=\"javascript:false;document.write('');\"" } } html += "></iframe>"; body.innerHTML = html }, remove: function () { var el = get(this.id); if (el) { remove(el); if (S.isGecko) { delete window.frames[this.id] } } }, onLoad: function () { var win = S.isIE ? get(this.id).contentWindow : window.frames[this.id]; win.location.href = this.obj.content } }; S.html = function (obj, id) { this.obj = obj; this.id = id; this.height = obj.height ? parseInt(obj.height, 10) : 300; this.width = obj.width ? parseInt(obj.width, 10) : 500 }; S.html.prototype = { append: function (body, dims) { var div = document.createElement("div"); div.id = this.id; div.className = "html"; div.innerHTML = this.obj.content; body.appendChild(div) }, remove: function () { var el = get(this.id); if (el) { remove(el) } } }; S.swf = function (obj, id) { this.obj = obj; this.id = id; this.height = obj.height ? parseInt(obj.height, 10) : 300; this.width = obj.width ? parseInt(obj.width, 10) : 300 }; S.swf.ext = ["swf"]; S.swf.prototype = { append: function (body, dims) { var tmp = document.createElement("div"); tmp.id = this.id; body.appendChild(tmp); var height = dims.innerHeight, width = dims.innerWidth, swf = this.obj.content, version = S.options.flashVersion, express = S.path + "expressInstall.swf", flashvars = S.options.flashVars, params = S.options.flashParams; S.flash.embedSWF(swf, this.id, width, height, version, express, flashvars, params) }, remove: function () { S.flash.expressInstallCallback(); S.flash.removeSWF(this.id) }, onWindowResize: function () { var dims = S.dimensions, el = get(this.id); el.height = dims.innerHeight; el.width = dims.innerWidth } }; var jwControllerHeight = 20; S.flv = function (obj, id) { this.obj = obj; this.id = id; this.height = obj.height ? parseInt(obj.height, 10) : 300; if (S.options.showMovieControls) { this.height += jwControllerHeight } this.width = obj.width ? parseInt(obj.width, 10) : 300 }; S.flv.ext = ["flv", "m4v"]; S.flv.prototype = { append: function (body, dims) { var tmp = document.createElement("div"); tmp.id = this.id; body.appendChild(tmp); var height = dims.innerHeight, width = dims.innerWidth, swf = S.path + "player.swf", version = S.options.flashVersion, express = S.path + "expressInstall.swf", flashvars = apply({ file: this.obj.content, height: height, width: width, autostart: (S.options.autoplayMovies ? "true" : "false"), controlbar: (S.options.showMovieControls ? "bottom" : "none"), backcolor: "0x000000", frontcolor: "0xCCCCCC", lightcolor: "0x557722" }, S.options.flashVars), params = S.options.flashParams; S.flash.embedSWF(swf, this.id, width, height, version, express, flashvars, params) }, remove: function () { S.flash.expressInstallCallback(); S.flash.removeSWF(this.id) }, onWindowResize: function () { var dims = S.dimensions, el = get(this.id); el.height = dims.innerHeight; el.width = dims.innerWidth } }; var qtControllerHeight = 16; S.qt = function (obj, id) { this.obj = obj; this.id = id; this.height = obj.height ? parseInt(obj.height, 10) : 300; if (S.options.showMovieControls) { this.height += qtControllerHeight } this.width = obj.width ? parseInt(obj.width, 10) : 300 }; S.qt.ext = ["dv", "mov", "moov", "movie", "mp4", "avi", "mpg", "mpeg"]; S.qt.prototype = { append: function (body, dims) { var opt = S.options, autoplay = String(opt.autoplayMovies), controls = String(opt.showMovieControls); var html = "<object", movie = { id: this.id, name: this.id, height: this.height, width: this.width, kioskmode: "true" }; if (S.isIE) { movie.classid = "clsid:02BF25D5-8C17-4B23-BC80-D3488ABDDC6B"; movie.codebase = "http://www.apple.com/qtactivex/qtplugin.cab#version=6,0,2,0" } else { movie.type = "video/quicktime"; movie.data = this.obj.content } for (var m in movie) { html += " " + m + '="' + movie[m] + '"' } html += ">"; var params = { src: this.obj.content, scale: "aspect", controller: controls, autoplay: autoplay }; for (var p in params) { html += '<param name="' + p + '" value="' + params[p] + '">' } html += "</object>"; body.innerHTML = html }, remove: function () { try { document[this.id].Stop() } catch (e) { } var el = get(this.id); if (el) { remove(el) } } }; var wmpControllerHeight = (S.isIE ? 70 : 45); S.wmp = function (obj, id) { this.obj = obj; this.id = id; this.height = obj.height ? parseInt(obj.height, 10) : 300; if (S.options.showMovieControls) { this.height += wmpControllerHeight } this.width = obj.width ? parseInt(obj.width, 10) : 300 }; S.wmp.ext = ["asf", "avi", "mpg", "mpeg", "wm", "wmv"]; S.wmp.prototype = { append: function (body, dims) { var opt = S.options, autoplay = opt.autoplayMovies ? 1 : 0; var movie = '<object id="' + this.id + '" name="' + this.id + '" height="' + this.height + '" width="' + this.width + '"', params = { autostart: opt.autoplayMovies ? 1 : 0 }; if (S.isIE) { movie += ' classid="clsid:6BF52A52-394A-11d3-B153-00C04F79FAA6"'; params.url = this.obj.content; params.uimode = opt.showMovieControls ? "full" : "none" } else { movie += ' type="video/x-ms-wmv"'; movie += ' data="' + this.obj.content + '"'; params.showcontrols = opt.showMovieControls ? 1 : 0 } movie += ">"; for (var p in params) { movie += '<param name="' + p + '" value="' + params[p] + '">' } movie += "</object>"; body.innerHTML = movie }, remove: function () { if (S.isIE) { try { window[this.id].controls.stop(); window[this.id].URL = "movie" + now() + ".wmv"; window[this.id] = function () { } } catch (e) { } } var el = get(this.id); if (el) { setTimeout(function () { remove(el) }, 10) } } }; var overlayOn = false, visibilityCache = [], pngIds = ["sb-nav-close", "sb-nav-next", "sb-nav-play", "sb-nav-pause", "sb-nav-previous"], container, overlay, wrapper, doWindowResize = true; function animate(el, property, to, duration, callback) { var isOpacity = (property == "opacity"), anim = isOpacity ? S.setOpacity : function (el, value) { el.style[property] = "" + value + "px" }; if (duration == 0 || (!isOpacity && !S.options.animate) || (isOpacity && !S.options.animateFade)) { anim(el, to); if (callback) { callback() } return } var from = parseFloat(S.getStyle(el, property)) || 0; var delta = to - from; if (delta == 0) { if (callback) { callback() } return } duration *= 1000; var begin = now(), ease = S.ease, end = begin + duration, time; var interval = setInterval(function () { time = now(); if (time >= end) { clearInterval(interval); interval = null; anim(el, to); if (callback) { callback() } } else { anim(el, from + ease((time - begin) / duration) * delta) } }, 10) } function setSize() { container.style.height = S.getWindowSize("Height") + "px"; container.style.width = S.getWindowSize("Width") + "px" } function setPosition() { container.style.top = document.documentElement.scrollTop + "px"; container.style.left = document.documentElement.scrollLeft + "px" } function toggleTroubleElements(on) { if (on) { each(visibilityCache, function (i, el) { el[0].style.visibility = el[1] || "" }) } else { visibilityCache = []; each(S.options.troubleElements, function (i, tag) { each(document.getElementsByTagName(tag), function (j, el) { visibilityCache.push([el, el.style.visibility]); el.style.visibility = "hidden" }) }) } } function toggleNav(id, on) { var el = get("sb-nav-" + id); if (el) { el.style.display = on ? "" : "none" } } function toggleLoading(on, callback) { var loading = get("sb-loading"), playerName = S.getCurrent().player, anim = (playerName == "img" || playerName == "html"); if (on) { S.setOpacity(loading, 0); loading.style.display = "block"; var wrapped = function () { S.clearOpacity(loading); if (callback) { callback() } }; if (anim) { animate(loading, "opacity", 1, S.options.fadeDuration, wrapped) } else { wrapped() } } else { var wrapped = function () { loading.style.display = "none"; S.clearOpacity(loading); if (callback) { callback() } }; if (anim) { animate(loading, "opacity", 0, S.options.fadeDuration, wrapped) } else { wrapped() } } } function buildBars(callback) { var obj = S.getCurrent(); get("sb-title-inner").innerHTML = obj.title || ""; var close, next, play, pause, previous; if (S.options.displayNav) { close = true; var len = S.gallery.length; if (len > 1) { if (S.options.continuous) { next = previous = true } else { next = (len - 1) > S.current; previous = S.current > 0 } } if (S.options.slideshowDelay > 0 && S.hasNext()) { pause = !S.isPaused(); play = !pause } } else { close = next = play = pause = previous = false } toggleNav("close", close); toggleNav("next", next); toggleNav("play", play); toggleNav("pause", pause); toggleNav("previous", previous); var counter = ""; if (S.options.displayCounter && S.gallery.length > 1) { var len = S.gallery.length; if (S.options.counterType == "skip") { var i = 0, end = len, limit = parseInt(S.options.counterLimit) || 0; if (limit < len && limit > 2) { var h = Math.floor(limit / 2); i = S.current - h; if (i < 0) { i += len } end = S.current + (limit - h); if (end > len) { end -= len } } while (i != end) { if (i == len) { i = 0 } counter += '<a onclick="Shadowbox.change(' + i + ');"'; if (i == S.current) { counter += ' class="sb-counter-current"' } counter += ">" + (++i) + "</a>" } } else { counter = [S.current + 1, S.lang.of, len].join(" ") } } get("sb-counter").innerHTML = counter; callback() } function showBars(callback) { var titleInner = get("sb-title-inner"), infoInner = get("sb-info-inner"), duration = 0.35; titleInner.style.visibility = infoInner.style.visibility = ""; if (titleInner.innerHTML != "") { animate(titleInner, "marginTop", 0, duration) } animate(infoInner, "marginTop", 0, duration, callback) } function hideBars(anim, callback) { var title = get("sb-title"), info = get("sb-info"), titleHeight = title.offsetHeight, infoHeight = info.offsetHeight, titleInner = get("sb-title-inner"), infoInner = get("sb-info-inner"), duration = (anim ? 0.35 : 0); animate(titleInner, "marginTop", titleHeight, duration); animate(infoInner, "marginTop", infoHeight * -1, duration, function () { titleInner.style.visibility = infoInner.style.visibility = "hidden"; callback() }) } function adjustHeight(height, top, anim, callback) { var wrapperInner = get("sb-wrapper-inner"), duration = (anim ? S.options.resizeDuration : 0); animate(wrapper, "top", top, duration); animate(wrapperInner, "height", height, duration, callback) } function adjustWidth(width, left, anim, callback) { var duration = (anim ? S.options.resizeDuration : 0); animate(wrapper, "left", left, duration); animate(wrapper, "width", width, duration, callback) } function setDimensions(height, width) { var bodyInner = get("sb-body-inner"), height = parseInt(height), width = parseInt(width), topBottom = wrapper.offsetHeight - bodyInner.offsetHeight, leftRight = wrapper.offsetWidth - bodyInner.offsetWidth, maxHeight = overlay.offsetHeight, maxWidth = overlay.offsetWidth, padding = parseInt(S.options.viewportPadding) || 20, preserveAspect = (S.player && S.options.handleOversize != "drag"); return S.setDimensions(height, width, maxHeight, maxWidth, topBottom, leftRight, padding, preserveAspect) } var K = {}; K.markup = '<div id="sb-container"><div id="sb-overlay"></div><div id="sb-wrapper"><div id="sb-background"></div><div id="sb-wrapper-body"><div id="sb-title"><div id="sb-title-inner"></div></div><div id="sb-wrapper-inner"><div id="sb-body"><div id="sb-body-inner"></div><div id="sb-loading"><div id="sb-loading-inner"><span>{loading}</span></div></div></div></div><div id="sb-info"><div id="sb-info-inner"><div id="sb-counter"></div><div id="sb-nav"><a id="sb-nav-close" title="{close}" onclick="Shadowbox.close()"></a><a id="sb-nav-next" title="{next}" onclick="Shadowbox.next()"></a><a id="sb-nav-play" title="{play}" onclick="Shadowbox.play()"></a><a id="sb-nav-pause" title="{pause}" onclick="Shadowbox.pause()"></a><a id="sb-nav-previous" title="{previous}" onclick="Shadowbox.previous()"></a></div></div></div></div></div></div>'; K.options = { animSequence: "sync", counterLimit: 10, counterType: "default", displayCounter: true, displayNav: true, fadeDuration: 0.35, initialHeight: 160, initialWidth: 320, modal: false, overlayColor: "#000", overlayOpacity: 0.5, resizeDuration: 0.35, showOverlay: true, troubleElements: ["select", "object", "embed", "canvas"] }; K.init = function () { S.appendHTML(document.body, sprintf(K.markup, S.lang)); K.body = get("sb-body-inner"); container = get("sb-container"); overlay = get("sb-overlay"); wrapper = get("sb-wrapper"); if (!supportsFixed) { container.style.position = "absolute" } if (!supportsOpacity) { var el, m, re = /url\("(.*\.png)"\)/; each(pngIds, function (i, id) { el = get(id); if (el) { m = S.getStyle(el, "backgroundImage").match(re); if (m) { el.style.backgroundImage = "none"; el.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(enabled=true,src=" + m[1] + ",sizingMethod=scale);" } } }) } var timer; addEvent(window, "resize", function () { if (timer) { clearTimeout(timer); timer = null } if (open) { timer = setTimeout(K.onWindowResize, 10) } }) }; K.onOpen = function (obj, callback) { doWindowResize = false; container.style.display = "block"; setSize(); var dims = setDimensions(S.options.initialHeight, S.options.initialWidth); adjustHeight(dims.innerHeight, dims.top); adjustWidth(dims.width, dims.left); if (S.options.showOverlay) { overlay.style.backgroundColor = S.options.overlayColor; S.setOpacity(overlay, 0); if (!S.options.modal) { addEvent(overlay, "click", S.close) } overlayOn = true } if (!supportsFixed) { setPosition(); addEvent(window, "scroll", setPosition) } toggleTroubleElements(); container.style.visibility = "visible"; if (overlayOn) { animate(overlay, "opacity", S.options.overlayOpacity, S.options.fadeDuration, callback) } else { callback() } }; K.onLoad = function (changing, callback) { toggleLoading(true); while (K.body.firstChild) { remove(K.body.firstChild) } hideBars(changing, function () { if (!open) { return } if (!changing) { wrapper.style.visibility = "visible" } buildBars(callback) }) }; K.onReady = function (callback) { if (!open) { return } var player = S.player, dims = setDimensions(player.height, player.width); var wrapped = function () { showBars(callback) }; switch (S.options.animSequence) { case "hw": adjustHeight(dims.innerHeight, dims.top, true, function () { adjustWidth(dims.width, dims.left, true, wrapped) }); break; case "wh": adjustWidth(dims.width, dims.left, true, function () { adjustHeight(dims.innerHeight, dims.top, true, wrapped) }); break; default: adjustWidth(dims.width, dims.left, true); adjustHeight(dims.innerHeight, dims.top, true, wrapped) } }; K.onShow = function (callback) { toggleLoading(false, callback); doWindowResize = true }; K.onClose = function () { if (!supportsFixed) { removeEvent(window, "scroll", setPosition) } removeEvent(overlay, "click", S.close); wrapper.style.visibility = "hidden"; var callback = function () { container.style.visibility = "hidden"; container.style.display = "none"; toggleTroubleElements(true) }; if (overlayOn) { animate(overlay, "opacity", 0, S.options.fadeDuration, callback) } else { callback() } }; K.onPlay = function () { toggleNav("play", false); toggleNav("pause", true) }; K.onPause = function () { toggleNav("pause", false); toggleNav("play", true) }; K.onWindowResize = function () { if (!doWindowResize) { return } setSize(); var player = S.player, dims = setDimensions(player.height, player.width); adjustWidth(dims.width, dims.left); adjustHeight(dims.innerHeight, dims.top); if (player.onWindowResize) { player.onWindowResize() } }; S.skin = K; window.Shadowbox = S
})(window);
Event.observe(window, 'load', function () {
    Shadowbox.init({
        handleOversize: "resize", autoplayMovies: false
    });
});
var Reflector = {
    reflect: function (element) {
        element = $(element);
        if (element) {
            var _amount = 1 / 3;
            var _opacity = 1 / 3;
            var p = element.parentNode, n = element.nextSibling;
            var d = 1.0 / (element.height * _amount);
            (element.height * _amount).times(function (line) {
                var h = Builder.node('div', { className: 'ovLogoReflect' }, [Builder.node('img', { src: element.src, style: 'margin-top:-' + (element.height - line - 1) + 'px'
                })]);
                p.insertBefore(h, n);
                $(h).setOpacity((1 - d * line) * _opacity);
            });
        }
    }
}
function msieversion() {
    var ua = window.navigator.userAgent
    var msie = ua.indexOf("MSIE ")
    if (msie > 0)      // If Internet Explorer,return version number
        return parseInt(ua.substring(msie + 5, ua.indexOf(".", msie)))
    else                 // If another browser,return 0
        return 0
}
/**
* DatePicker widget using Prototype and Scriptaculous.
* (c) 2007-2008 Mathieu Jondet <mathieu@eulerian.com>
* Eulerian Technologies
* (c) 2009 Titi Ala'ilima <tigre@pobox.com>
*
* DatePicker is freely distributable under the same terms as Prototype.
*
* v1.0.0
*
* http://code.google.com/p/prototype-datepicker-widget/
*/
/***
* Some general things to keep in mind:
* - months,when passed around by themselves,typically go from 0 to 11
*/
/**
* DatePickerUtils object.  Not a class to be instantiated,just an object
* that holds commonly used values and methods
*/
var DatePickerUtils = {
    oneDayInMs: 24 * 3600 * 1000, _daysInMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], getMonthDays: function (year, month) {
        if (((0 == (year % 4)) &&
((0 != (year % 100)) || (0 == (year % 400)))) && (month == 1))
            return 29;
        return this._daysInMonth[month];
    }, parseDate: function (dateString) {
        var dateObj = DatePickerUtils.ansiDateToObject(dateString);
        if (!dateObj) {
            var relDate = parseFloat(dateString);
            dateObj = new Date();
            dateObj.setTime(dateObj.getTime() + dateString * this.oneDayInMs);
        }
        return dateObj;
    }, dateObjectToAnsi: function (dateObj) {
        if (!dateObj) return null;
        return dateObj.getFullYear().toPaddedString(4) + '-' +
(dateObj.getMonth() + 1).toPaddedString(2) + '-' +
dateObj.getDate().toPaddedString(2);
    }, ansiDateToObject: function (ansiDate) {
        var dateObj = null;
        var parsedDate = String(ansiDate).match(/^(\d+)-0*(\d+)-0*(\d+)$/);
        if (parsedDate)
            dateObj = new Date(parsedDate[1], parsedDate[2] - 1, parsedDate[3]);
        return dateObj;
    }, yearMonthToAnsiStub: function (year, month) {
        return year.toPaddedString(4) + '-' + (month + 1).toPaddedString(2) + '-';
    }, noDatesBefore: function (firstDate) {
        return new DatePickerFilter(
function (year, month) {
    /* Perform our date comparisons with ANSI/ISO date strings */
    var testDate = DatePickerUtils.dateObjectToAnsi(
DatePickerUtils.parseDate(firstDate));
    var dateFilter = new Array();
    var monthDays = DatePickerUtils.getMonthDays(year, month);
    var calDate = DatePickerUtils.yearMonthToAnsiStub(year, month);
    for (var i = 1; i <= monthDays; i++)
        dateFilter[i] = (testDate > (calDate + i.toPaddedString(2)));
    return dateFilter;
}, function (year, month) {
    /* Perform our date comparisons with ANSI/ISO date strings */
    var testDate =
DatePickerUtils.dateObjectToAnsi(DatePickerUtils.parseDate(firstDate));
    var calDate = DatePickerUtils.yearMonthToAnsiStub(year, month) +
DatePickerUtils.getMonthDays(year, month);
    return (testDate <= calDate);
}
);
    }, noDatesAfter: function (firstDate) {
        return new DatePickerFilter(
function (year, month) {
    /* Perform our date comparisons with ANSI/ISO date strings */
    var testDate = DatePickerUtils.dateObjectToAnsi(
DatePickerUtils.parseDate(firstDate));
    var dateFilter = new Array();
    var monthDays = DatePickerUtils.getMonthDays(year, month);
    var calDate = DatePickerUtils.yearMonthToAnsiStub(year, month);
    for (var i = 1; i <= monthDays; i++)
        dateFilter[i] = (testDate < (calDate + i.toPaddedString(2)));
    return dateFilter;
}, function (year, month) {
    /* Perform our date comparisons with ANSI/ISO date strings */
    var testDate =
DatePickerUtils.dateObjectToAnsi(DatePickerUtils.parseDate(firstDate));
    var calDate = DatePickerUtils.yearMonthToAnsiStub(year, month) + '01';
    return (testDate >= calDate);
}
);
    }, noWeekends: function () {
        return new DatePickerFilter(
function (year, month) {
    var dateFilter = new Array();
    var monthDays = DatePickerUtils.getMonthDays(year, month);
    var calDate = new Date(year, month, 1);
    for (var i = 1; i <= monthDays; calDate.setFullYear(year, month, ++i))
        dateFilter[i] = ((calDate.getDay() % 6) == 0); // 0 = Sun,6 = Sat
    return dateFilter;
}, null
);
    }
}
var DatePickerFormatter = Class.create();
DatePickerFormatter.prototype = {
    initialize: function (format, separator) {
        if (Object.isUndefined(format))
            format = ["yyyy", "mm", "dd"];
        if (Object.isUndefined(separator))
            separator = "-";
        this._format = format;
        this.separator = separator;
        this._formatYearIndex = format.indexOf("yyyy");
        this._formatMonthIndex = format.indexOf("mm");
        this._formatDayIndex = format.indexOf("dd");
        this._yearRegexp = /^\d{4}$/;
        this._monthRegexp = /^0\d|1[012]|\d$/;
        this._dayRegexp = /^0\d|[12]\d|3[01]|\d$/;
    }, match: function (str) {
        var d = str.split(this.separator);
        if (d.length < 3)
            return false;
        var year = d[this._formatYearIndex].match(this._yearRegexp);
        if (year) { year = year[0] } else { return false }
        var month = d[this._formatMonthIndex].match(this._monthRegexp);
        if (month) { month = month[0] } else { return false }
        var day = d[this._formatDayIndex].match(this._dayRegexp);
        if (day) { day = day[0] } else { return false }
        return [year, month, day];
    }, currentDate: function () {
        var d = new Date;
        return this.dateToString(
d.getFullYear(), d.getMonth() + 1, d.getDate()
);
    }, dateToString: function (year, month, day, separator) {
        if (Object.isUndefined(separator))
            separator = this.separator;
        var a = [0, 0, 0];
        a[this._formatYearIndex] = year;
        a[this._formatMonthIndex] = month.toPaddedString(2);
        a[this._formatDayIndex] = day.toPaddedString(2);
        return a.join(separator);
    }
};
var DatePickerFilter = Class.create();
DatePickerFilter.prototype = {
    initialize: function (dateFilterFunction, monthFilterFunction) {
        if (dateFilterFunction) this.badDates = dateFilterFunction;
        if (monthFilterFunction) this.validMonthP = monthFilterFunction;
    }, badDates: null, validMonthP: null, append: function (nextFilter) {
        if (!this.badDates)
            this.badDates = nextFilter.badDates;
        else if (nextFilter.badDates) {
            var firstBadDates = this.badDates;
            this.badDates = function (year, month) {
                var results1 = firstBadDates(year, month);
                var results2 = nextFilter.badDates(year, month);
                /* An element-wise "or",since if it's bad in one filter,it's
                bad for the aggregate. */
                for (var i = 0; i < results1.length; i++)
                    results1[i] = results1[i] || results2[i];
                return results1;
            };
        }
        if (!this.validMonthP)
            this.validMonthP = nextFilter.validMonthP;
        else if (nextFilter.validMonthP) {
            var firstValidMonthP = this.validMonthP;
            this.validMonthP = function (year, month) {
                return firstValidMonthP(year, month) && nextFilter.validMonthP(year, month);
            };
        }
        return this; // Just so we can chain filters inline
    }
};
var DatePicker = Class.create();
DatePicker.prototype = {
    Version: '1.0.0', _relative: null, _div: null, _zindex: 1, _keepFieldEmpty: false, _dateFormat: null, /* language */
    _language: 'en', _language_month: $H({
        'fr': ['Janvier', 'F&#233;vrier', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Aout', 'Septembre', 'Octobre', 'Novembre', 'D&#233;cembre'], 'en': ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'], 'sp': ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'], 'it': ['Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio', 'Giugno', 'Luglio', 'Agosto', 'Settembre', 'Ottobre', 'Novembre', 'Dicembre'], 'de': ['Januar', 'Februar', 'M&#228;rz', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember'], 'pt': ['Janeiro', 'Fevereiro', 'Mar&#231;o', 'Abril', 'Maio', 'Junho', 'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro'], 'hu': ['Janu&#225;r', 'Febru&#225;r', 'M&#225;rcius', '&#193;prilis', 'M&#225;jus', 'J&#250;nius', 'J&#250;lius', 'Augusztus', 'Szeptember', 'Okt&#243;ber', 'November', 'December'], 'lt': ['Sausis', 'Vasaris', 'Kovas', 'Balandis', 'Gegu&#382;&#279;', 'Bir&#382;elis', 'Liepa', 'Rugj&#363;tis', 'Rus&#279;jis', 'Spalis', 'Lapkritis', 'Gruodis'], 'nl': ['januari', 'februari', 'maart', 'april', 'mei', 'juni', 'juli', 'augustus', 'september', 'oktober', 'november', 'december'], 'dk': ['Januar', 'Februar', 'Marts', 'April', 'Maj', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'December'], 'no': ['Januar', 'Februar', 'Mars', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Desember'], 'lv': ['Janv&#257;ris', 'Febru&#257;ris', 'Marts', 'Apr&#299;lis', 'Maijs', 'J&#363;nijs', 'J&#363;lijs', 'Augusts', 'Septembris', 'Oktobris', 'Novembris', 'Decemberis'], 'ja': ['1&#26376;', '2&#26376;', '3&#26376;', '4&#26376;', '5&#26376;', '6&#26376;', '7&#26376;', '8&#26376;', '9&#26376;', '10&#26376;', '11&#26376;', '12&#26376;'], 'fi': ['Tammikuu', 'Helmikuu', 'Maaliskuu', 'Huhtikuu', 'Toukokuu', 'Kes&#228;kuu', 'Hein&#228;kuu', 'Elokuu', 'Syyskuu', 'Lokakuu', 'Marraskuu', 'Joulukuu'], 'ro': ['Ianuarie', 'Februarie', 'Martie', 'Aprilie', 'Mai', 'Junie', 'Julie', 'August', 'Septembrie', 'Octombrie', 'Noiembrie', 'Decembrie'], 'zh': ['1&#32;&#26376;', '2&#32;&#26376;', '3&#32;&#26376;', '4&#32;&#26376;', '5&#32;&#26376;', '6&#32;&#26376;', '7&#32;&#26376;', '8&#32;&#26376;', '9&#32;&#26376;', '10&#26376;', '11&#26376;', '12&#26376;'], 'sv': ['Januari', 'Februari', 'Mars', 'April', 'Maj', 'Juni', 'Juli', 'Augusti', 'September', 'Oktober', 'November', 'December'], 'pl': ['Stycze\u0144', 'Luty', 'Marzec', 'Kwiecie\u0144', 'Maj', 'Czerwiec', 'Lipiec', 'Sierpie\u0144', 'Wrzesie\u0144', 'Pa\u017adziernik', 'Listopad', 'Grudzie\u0144']
    }), _language_day: $H({
        'fr': ['Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam', 'Dim'], 'en': ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'], 'sp': ['Lun', 'Mar', 'Mie', 'Jue', 'Vie', 'S&#224;b', 'Dom'], 'it': ['Lun', 'Mar', 'Mer', 'Gio', 'Ven', 'Sab', 'Dom'], 'de': ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So'], 'pt': ['Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'S&#225;', 'Dom'], 'hu': ['H&#233;', 'Ke', 'Sze', 'Cs&#252;', 'P&#233;', 'Szo', 'Vas'], 'lt': ['Pir', 'Ant', 'Tre', 'Ket', 'Pen', '&Scaron;e&scaron;', 'Sek'], 'nl': ['ma', 'di', 'wo', 'do', 'vr', 'za', 'zo'], 'dk': ['Man', 'Tir', 'Ons', 'Tor', 'Fre', 'L&#248;r', 'S&#248;n'], 'no': ['Man', 'Tir', 'Ons', 'Tor', 'Fre', 'L&#248;r', 'Sun'], 'lv': ['P', 'O', 'T', 'C', 'Pk', 'S', 'Sv'], 'ja': ['&#26376;', '&#28779;', '&#27700;', '&#26408;', '&#37329;', '&#22303;', '&#26085;'], 'fi': ['Ma', 'Ti', 'Ke', 'To', 'Pe', 'La', 'Su'], 'ro': ['Lun', 'Mar', 'Mie', 'Joi', 'Vin', 'Sam', 'Dum'], 'zh': ['&#21608;&#19968;', '&#21608;&#20108;', '&#21608;&#19977;', '&#21608;&#22235;', '&#21608;&#20116;', '&#21608;&#20845;', '&#21608;&#26085;'], 'sv': ['M&#229;n', 'Tis', 'Ons', 'Tor', 'Fre', 'L&#246;r', 'S&#246;n'], 'pl': ['Pon', 'Wt', '\u015ar', 'Czw', 'Pt', 'Sob', 'Nie']
    }), _language_close: $H({
        'fr': 'fermer', 'en': 'close', 'sp': 'cierre', 'it': 'fine', 'de': 'schliessen', 'pt': 'fim', 'hu': 'bez&#225;r', 'lt': 'u&#382;daryti', 'nl': 'sluiten', 'dk': 'luk', 'no': 'lukk', 'lv': 'aizv&#275;rt', 'ja': '&#38281;&#12376;&#12427;', 'fi': 'sulje', 'ro': 'inchide', 'zh': '&#20851;&#32;&#38381', 'sv': 'st&#228;ng', 'pl': 'zamknij'
    }), _language_date_format: $H({
        'en': [["mm", "dd", "yyyy"], "/"], 'lt': [["yyyy", "mm", "dd"], "-"], 'fr': [["dd", "mm", "yyyy"], "/"], 'sp': [["dd", "mm", "yyyy"], "/"], 'it': [["dd", "mm", "yyyy"], "/"], 'de': [["dd", "mm", "yyyy"], "."], 'pt': [["dd", "mm", "yyyy"], "/"], 'hu': [["dd", "mm", "yyyy"], "/"], 'nl': [["dd", "mm", "yyyy"], "/"], 'dk': [["dd", "mm", "yyyy"], "/"], 'no': [["dd", "mm", "yyyy"], "/"], 'lv': [["dd", "mm", "yyyy"], "/"], 'ja': [["yyyy", "mm", "dd"], "-"], 'fi': [["dd", "mm", "yyyy"], "."], 'ro': [["dd", "mm", "yyyy"], "/"], 'zh': [["yyyy", "mm", "dd"], "-"], 'sv': [["dd", "mm", "yyyy"], "/"], 'pl': [["yyyy", "mm", "dd"], "-"]
    }), /* date manipulation */
    _todayDate: new Date(), _currentDate: null, _clickCallback: Prototype.emptyFunction, _cellCallback: Prototype.emptyFunction, _dateFilter: new DatePickerFilter(), _id_datepicker: null, /* positionning */
    _topOffset: 30, _leftOffset: 0, _isPositionned: false, _relativePosition: true, _setPositionTop: 0, _setPositionLeft: 0, _bodyAppend: false, /* Effects Adjustment */
    _showEffect: "appear", _showDuration: 0.2, _enableShowEffect: true, _closeEffect: "fade", _closeEffectDuration: 0.2, _enableCloseEffect: true, _closeTimer: null, _enableCloseOnBlur: false, /* afterClose : called when the close function is executed */
    _afterClose: Prototype.emptyFunction, /* return the name of current month in appropriate language */
    getMonthLocale: function (month) {
        return this._language_month.get(this._language)[month];
    }, getLocaleClose: function () {
        return this._language_close.get(this._language);
    }, _initCurrentDate: function () {
        /* Create the DateFormatter */
        if (!this._dateFormat)
            this._dateFormat = this._language_date_format.get(this._language);
        this._df = new DatePickerFormatter(this._dateFormat[0], this._dateFormat[1]);
        /* check if value in field is proper,if not set to today */
        this._currentDate = $F(this._relative);
        if (!this._df.match(this._currentDate)) {
            this._currentDate = this._df.currentDate();
            /* Modified by Netbiscuits - Start */
            /* set the field value ? */
            //            if (!this._keepFieldEmpty)
            //                $(this._relative).value = this._currentDate;
            /* Modified by Netbiscuits - End */
        }
        var a_date = this._df.match(this._currentDate);
        this._currentYear = Number(a_date[0]);
        this._currentMonth = Number(a_date[1]) - 1;
        this._currentDay = Number(a_date[2]);
    }, /* init */
    initialize: function (h_p) {
        /* arguments */
        this._relative = h_p["relative"];
        if (h_p["language"])
            this._language = h_p["language"];
        this._zindex = (h_p["zindex"]) ? parseInt(Number(h_p["zindex"])) : 1;
        if (!Object.isUndefined(h_p["keepFieldEmpty"]))
            this._keepFieldEmpty = h_p["keepFieldEmpty"];
        if (Object.isFunction(h_p["clickCallback"]))
            this._clickCallback = h_p["clickCallback"];
        if (!Object.isUndefined(h_p["leftOffset"]))
            this._leftOffset = parseInt(h_p["leftOffset"]);
        if (!Object.isUndefined(h_p["topOffset"]))
            this._topOffset = parseInt(h_p["topOffset"]);
        if (!Object.isUndefined(h_p["relativePosition"]))
            this._relativePosition = h_p["relativePosition"];
        if (!Object.isUndefined(h_p["showEffect"]))
            this._showEffect = h_p["showEffect"];
        if (!Object.isUndefined(h_p["enableShowEffect"]))
            this._enableShowEffect = h_p["enableShowEffect"];
        if (!Object.isUndefined(h_p["showDuration"]))
            this._showDuration = h_p["showDuration"];
        if (!Object.isUndefined(h_p["closeEffect"]))
            this._closeEffect = h_p["closeEffect"];
        if (!Object.isUndefined(h_p["enableCloseEffect"]))
            this._enableCloseEffect = h_p["enableCloseEffect"];
        if (!Object.isUndefined(h_p["closeEffectDuration"]))
            this._closeEffectDuration = h_p["closeEffectDuration"];
        if (Object.isFunction(h_p["afterClose"]))
            this._afterClose = h_p["afterClose"];
        if (!Object.isUndefined(h_p["externalControl"]))
            this._externalControl = h_p["externalControl"];
        if (!Object.isUndefined(h_p["dateFormat"]))
            this._dateFormat = h_p["dateFormat"];
        if (Object.isFunction(h_p["cellCallback"]))
            this._cellCallback = h_p["cellCallback"];
        this._setPositionTop = (h_p["setPositionTop"]) ?
parseInt(Number(h_p["setPositionTop"])) : 0;
        this._setPositionLeft = (h_p["setPositionLeft"]) ?
parseInt(Number(h_p["setPositionLeft"])) : 0;
        if (!Object.isUndefined(h_p["enableCloseOnBlur"]) && h_p["enableCloseOnBlur"])
            this._enableCloseOnBlur = true;
        if (!Object.isUndefined(h_p["dateFilter"]) && h_p["dateFilter"])
            this._dateFilter = h_p["dateFilter"];
        // Backwards compatibility
        if (!Object.isUndefined(h_p["disablePastDate"]) && h_p["disablePastDate"])
            this._dateFilter.append(DatePickerUtils.noDatesBefore(0));
        else if (!Object.isUndefined(h_p["disableFutureDate"]) && h_p["disableFutureDate"])
            this._dateFilter.append(DatePickerUtils.noDatesAfter(0));
        this._id_datepicker = 'datepicker-' + this._relative;
        this._id_datepicker_prev = this._id_datepicker + '-prev';
        this._id_datepicker_next = this._id_datepicker + '-next';
        this._id_datepicker_hdr = this._id_datepicker + '-header';
        this._id_datepicker_ftr = this._id_datepicker + '-footer';
        /* Modified by Netbiscuits - Start */
        /* build up calendar skel */
        //        this._div = new Element('div',{
        //            id: this._id_datepicker,//            className: 'datepicker',//            style: 'display: none; z-index:' + this._zindex
        //        });
        //        this._div.innerHTML = '<table><thead><tr><th width="10px" id="' + this._id_datepicker_prev + '" style="cursor: pointer;">&nbsp;&lt;&lt;&nbsp;</th><th id="' + this._id_datepicker_hdr + '" colspan="5"></th><th width="10px" id="' + this._id_datepicker_next + '" style="cursor: pointer;">&nbsp;&gt;&gt;&nbsp;</th></tr></thead><tbody id="' + this._id_datepicker + '-tbody"></tbody><tfoot><tr><td colspan="7" id="' + this._id_datepicker_ftr + '"></td></tr></tfoot></table>';
        this._div = new Element('div');
        this._div.className = 'datepicker';
        this._div.id = this._id_datepicker;
        this._div.style.display = 'none';
        this._div.style.zIndex = this._zindex;
        this._div.innerHTML = '<div class="datepicker-header"><table class="header" cellspacing="0"><tr><td id="' + this._id_datepicker_prev_year + '" class="prev_year"> << </td><td id="' + this._id_datepicker_prev + '" class="prev"> < </td><td id="' + this._id_datepicker_hdr + '" class="header"></td><td id="' + this._id_datepicker_next + '" class="next"> > </td><td id="' + this._id_datepicker_next_year + '" class="next_year"> >> </td></tr></table></div><div class="datepicker-calendar"><table class="body"><tbody id="' + this._id_datepicker + '-tbody"></tbody></table></div><div id="' + this._id_datepicker_ftr + '" class="datepicker-footer"></div>';
        /* Build the datepicker icon */
        var datepickeropener = Builder.node('table', { className: "datepicker-opener-table" });
        var con = Builder.node('tr', {}, [
Builder.node('td', { className: "datepicker-opener", id: "datepicker-opener-" + this._relative })
]);
        // insert into TBODY
        if (datepickeropener.childNodes[0] != undefined) {
            datepickeropener.childNodes[0].appendChild(con);
        } else {
            datepickeropener.appendChild(con);
        }
        Event.observe(datepickeropener, 'click', this.click.bindAsEventListener(this), false);
        this.insertAfter($(this._relative).parentNode, datepickeropener, $(this._relative));
        /* End Build the datepicker icon */
        /* Modified by Netbiscuits - End */
        /* finally declare the event listener on input field */
        Event.observe(this._relative, 'click', this.click.bindAsEventListener(this), false);
        /* need to append on body when doc is loaded for IE */
        document.observe('dom:loaded', this.load.bindAsEventListener(this), false);
        /* automatically close when blur event is triggered */
        if (this._enableCloseOnBlur) {
            Event.observe(this._relative, 'blur', function (e) {
                if (!this._closeTimer) this._closeTimer = this.close.bind(this).delay(1);
            } .bindAsEventListener(this));
            Event.observe(this._div, 'click', function (e) {
                Field.focus(this._relative);
                this.checkClose.bind(this).delay(0.1);
            } .bindAsEventListener(this));
        }
    }, insertAfter: function (parent, node, referenceNode) {
        parent.insertBefore(node, referenceNode.nextSibling);
    }, load: function () {
        /* if externalControl defined set the observer on it */
        if (this._externalControl)
            Event.observe(this._externalControl, 'click', this.click.bindAsEventListener(this), false);
        /* append to page */
        if (this._relativeAppend) {
            /* append to parent node */
            if ($(this._relative).parentNode) {
                this._div.innerHTML = this._wrap_in_iframe(this._div.innerHTML);
                $(this._relative).parentNode.appendChild(this._div);
            }
        } else {
            /* append to body */
            var body = document.getElementsByTagName("body").item(0);
            if (body) {
                this._div.innerHTML = this._wrap_in_iframe(this._div.innerHTML);
                body.appendChild(this._div);
            }
            if (this._relativePosition) {
                var a_pos = Element.cumulativeOffset($(this._relative));
                this.setPosition(a_pos[1], a_pos[0]);
            } else {
                if (this._setPositionTop || this._setPositionLeft)
                    this.setPosition(this._setPositionTop, this._setPositionLeft);
            }
        }
        /* init the date in field if needed */
        this._initCurrentDate();
        /* set the close locale content */
        $(this._id_datepicker_ftr).innerHTML = this.getLocaleClose();
        /* declare the observers for UI control */
        Event.observe($(this._id_datepicker_prev), 'click', this.prevMonth.bindAsEventListener(this), false);
        Event.observe($(this._id_datepicker_next), 'click', this.nextMonth.bindAsEventListener(this), false);
        Event.observe($(this._id_datepicker_ftr), 'click', this.close.bindAsEventListener(this), false);
        Event.observe($(document), 'click', this.documentClick.bindAsEventListener(this), false);
    }, /* hack for buggy form elements layering in IE */
    _wrap_in_iframe: function (content) {
        return (Prototype.Browser.IE && msieversion() < 8) ?
"<div style='height:184px;width:180px;background-color:white;align:left'><iframe width='100%' height='100%' marginwidth='0' marginheight='0' frameborder='0' src='about:blank' style='filter:alpha(Opacity=50);'></iframe><div style='position:absolute;top:0px;left:0px;background-color:white;width:180px'>" + content + "</div></div>" : content;
    }, visible: function () {
        return $(this._id_datepicker).visible();
    }, click: function () {
        /* init the datepicker if it doesn't exists */
        if ($(this._id_datepicker) == null) this.load();
        if (!this._isPositionned && this._relativePosition) {
            /* position the datepicker relatively to element */
            var a_lt = Element.cumulativeOffset($(this._relative));
            $(this._id_datepicker).setStyle({
                'left': Number(a_lt[0] + this._leftOffset) + 'px', 'top': Number(a_lt[1] + this._topOffset) + 'px'
            });
            this._isPositionned = true;
        }
        if (!this.visible()) {
            this._initCurrentDate();
            this._redrawCalendar();
        }
        /* eval the clickCallback function */
        eval(this._clickCallback());
        /* Effect toggle to fade-in / fade-out the datepicker */
        if (this._enableShowEffect) {
            new Effect.toggle(this._id_datepicker, this._showEffect, { duration: this._showDuration });
        } else {
            $(this._id_datepicker).show();
        }
    }, close: function () {
        // ignore requests to close if already closed:
        if (!this.visible())
            return;
        this.checkClose();
        if (this._enableCloseEffect) {
            switch (this._closeEffect) {
                case 'puff':
                    new Effect.Puff(this._id_datepicker, {
                        duration: this._closeEffectDuration
                    });
                    break;
                case 'blindUp':
                    new Effect.BlindUp(this._id_datepicker, {
                        duration: this._closeEffectDuration
                    });
                    break;
                case 'dropOut':
                    new Effect.DropOut(this._id_datepicker, {
                        duration: this._closeEffectDuration
                    });
                    break;
                case 'switchOff':
                    new Effect.SwitchOff(this._id_datepicker, {
                        duration: this._closeEffectDuration
                    });
                    break;
                case 'squish':
                    new Effect.Squish(this._id_datepicker, {
                        duration: this._closeEffectDuration
                    });
                    break;
                case 'fold':
                    new Effect.Fold(this._id_datepicker, {
                        duration: this._closeEffectDuration
                    });
                    break;
                case 'shrink':
                    new Effect.Shrink(this._id_datepicker, {
                        duration: this._closeEffectDuration
                    });
                    break;
                default:
                    new Effect.Fade(this._id_datepicker, {
                        duration: this._closeEffectDuration
                    });
                    break;
            };
        } else {
            $(this._id_datepicker).hide();
        }
        eval(this._afterClose());
    }, checkClose: function () {
        if (this._closeTimer) {
            window.clearTimeout(this._closeTimer);
            this._closeTimer = null;
        }
    }, documentClick: function (event) {
        var source = event.element();
        if (source != this._div && source != $(this._relative) && source != $(this._externalControl) &&
!source.descendantOf(this._div))
            this.close();
    }, setDateFormat: function (format, separator) {
        if (Object.isUndefined(format))
            format = this._dateFormat[0];
        if (Object.isUndefined(separator))
            separator = this._dateFormat[1];
        this._dateFormat = [format, separator];
    }, setPosition: function (t, l) {
        var h_pos = { 'top': '0px', 'left': '0px' };
        if (!Object.isUndefined(t))
            h_pos['top'] = Number(t) + this._topOffset + 'px';
        if (!Object.isUndefined(l))
            h_pos['left'] = Number(l) + this._leftOffset + 'px';
        $(this._id_datepicker).setStyle(h_pos);
        this._isPositionned = true;
    }, _buildCalendar: function () {
        var _self = this;
        var tbody = $(this._id_datepicker + '-tbody');
        try {
            while (tbody.hasChildNodes())
                tbody.removeChild(tbody.childNodes[0]);
        } catch (e) { };
        /* generate day headers */
        var trDay = new Element('tr');
        this._language_day.get(this._language).each(function (item) {
            var td = new Element('td');
            td.innerHTML = item;
            td.className = 'wday';
            trDay.appendChild(td);
        });
        tbody.appendChild(trDay);
        /* generate the content of days */
        /* build-up days matrix */
        var a_d = [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]
];
        var currentMonth = this._currentMonth;
        var currentYear = this._currentYear;
        /* set date at beginning of month to display */
        var d = new Date(currentYear, currentMonth, 1, 12);
        /* start the day list on monday */
        var startIndex = (d.getDay() + 6) % 7;
        var nbDaysInMonth = DatePickerUtils.getMonthDays(currentYear, currentMonth);
        var daysIndex = 1;
        var badDates = (this._dateFilter.badDates) ? this._dateFilter.badDates(currentYear, currentMonth) : [];
        /* The first week */
        for (var j = startIndex; j < 7; j++) {
            a_d[0][j] = {
                d: daysIndex, m: currentMonth, y: currentYear, b: badDates[daysIndex]
            };
            daysIndex++;
        }
        /* Fill in days before the current month starts */
        var a_prevMY = this._prevMonthYear();
        var nbDaysInMonthPrev = DatePickerUtils.getMonthDays(a_prevMY[1], a_prevMY[0]);
        for (var j = 0; j < startIndex; j++) {
            a_d[0][j] = {
                d: Number(nbDaysInMonthPrev - startIndex + j + 1), m: Number(a_prevMY[0]), y: a_prevMY[1], c: 'outbound', b: true
            };
        }
        /* Now the remaining weeks */
        var switchNextMonth = false;
        for (var i = 1; i < 6; i++) {
            for (var j = 0; j < 7; j++) {
                a_d[i][j] = {
                    d: daysIndex, m: currentMonth, y: currentYear, c: (switchNextMonth)
? 'outbound' :
(
((daysIndex == this._todayDate.getDate()) &&
(currentMonth == this._todayDate.getMonth()) &&
(currentYear == this._todayDate.getFullYear())) ? 'today' : null), b: switchNextMonth || badDates[daysIndex]
                };
                daysIndex++;
                /* if at the end of the month : reset counter */
                if (daysIndex > nbDaysInMonth) {
                    daysIndex = 1;
                    switchNextMonth = true;
                    if (this._currentMonth + 1 > 11) {
                        currentMonth = 0;
                        currentYear += 1;
                    } else {
                        currentMonth += 1;
                    }
                }
            }
        }
        /* now generate the table cells for the dates */
        for (var i = 0; i < 6; i++) {
            var tr = new Element('tr');
            for (var j = 0; j < 7; j++) {
                var h_ij = a_d[i][j];
                var td = new Element('td');
                /* id is : datepicker-day-mon-year or depending on language other way */
                /* don't forget to add 1 on month for proper formmatting */
                var id = $A([
this._relative, this._df.dateToString(h_ij["y"], h_ij["m"] + 1, h_ij["d"], '-')
]).join('-');
                /* set id and classname for cell if exists */
                td.setAttribute('id', id);
                if (h_ij["c"])
                    td.className = h_ij["c"];
                this._bindCellOnClick(td, h_ij["b"], h_ij["c"]);
                td.innerHTML = h_ij["d"];
                tr.appendChild(td);
            }
            tbody.appendChild(tr);
        }
        return tbody;
    }, _bindCellOnClick: function (td, badDateP, cellClass) {
        if (badDateP) {
            td.className = (cellClass) ? 'nclick_' + cellClass : 'nclick';
        } else {
            /* Create a closure so we have access to the DatePicker object */
            var _self = this;
            td.onclick = function () {
                $(_self._relative).value = String($(this).readAttribute('id')
).replace(_self._relative + '-', '').replace(/-/g, _self._df.separator);
                /* if we have a cellCallback defined call it and pass it the cell */
                if (_self._cellCallback)
                    _self._cellCallback(this);
                _self.close();
            };
        }
    }, _nextMonthYear: function () {
        var c_mon = this._currentMonth;
        var c_year = this._currentYear;
        if (c_mon + 1 > 11) {
            c_mon = 0;
            c_year += 1;
        } else {
            c_mon += 1;
        }
        return [c_mon, c_year];
    }, nextMonth: function () {
        this._maybeRedrawMonth(this._nextMonthYear());
    }, _prevMonthYear: function () {
        var c_mon = this._currentMonth;
        var c_year = this._currentYear;
        if (c_mon - 1 < 0) {
            c_mon = 11;
            c_year -= 1;
        } else {
            c_mon -= 1;
        }
        return [c_mon, c_year];
    }, prevMonth: function () {
        this._maybeRedrawMonth(this._prevMonthYear());
    }, _maybeRedrawMonth: function (a_new) {
        var _newMon = a_new[0];
        var _newYear = a_new[1];
        if (!this._dateFilter.validMonthP ||
this._dateFilter.validMonthP(_newYear, _newMon)) {
            this._currentMonth = _newMon;
            this._currentYear = _newYear;
            this._redrawCalendar();
        }
    }, _redrawCalendar: function () {
        this._setLocaleHdr(); this._buildCalendar();
    }, _setLocaleHdr: function () {
        /* next link */
        var a_next = this._nextMonthYear();
        $(this._id_datepicker_next).setAttribute('title', this.getMonthLocale(a_next[0]) + ' ' + a_next[1]);
        /* prev link */
        var a_prev = this._prevMonthYear();
        $(this._id_datepicker_prev).setAttribute('title', this.getMonthLocale(a_prev[0]) + ' ' + a_prev[1]);
        /* header */
        $(this._id_datepicker_hdr).update('&nbsp;&nbsp;&nbsp;' + this.getMonthLocale(this._currentMonth) + '&nbsp;' + this._currentYear + '&nbsp;&nbsp;&nbsp;');
    }
};
// ---------------------------------------------------------------------------
// Javascript:ovToolkit
// ---------------------------------------------------------------------------
function ovToolkitObject() {
    this.isLocal = document.URL.indexOf("localhost");
    this.isStage = document.URL.indexOf("stagekicker");
    this.isMSNStage = document.URL.indexOf("stagemsn");
    this.isMSNLive = document.URL.indexOf("sport.msn.de");
    this.rootURL = "http://www.kicker.de";
    this.player169URL = this.rootURL + "/flash/smallPlayerWide.swf";
    this.playerPopupURL = '/flash/kickerplayer_1-3-4_b88.swf';
    this.playerPlaylistURL = "" + "/videoplaylist";
    this.playerJuniorenPlaylistURL = "" + "/junioren/videoplaylist";
    this.playerVideoPath = 'http://video.kicker.de/flash/';
    this.defaultFontSize = 1.02;
    this.actFontSize = 1.02;
}
var ovToolkit = new ovToolkitObject();
///* Style Switcher */
function setActiveStyleSheet(title) {
    var i, a, main;
    for (i = 0; (a = document.getElementsByTagName("link")[i]); i++) {
        if (a.getAttribute("rel").indexOf("style") != -1 && a.getAttribute("title")) {
            a.disabled = true;
            if (a.getAttribute("title") == title) a.disabled = false;
        }
    }
}
ovToolkit.print = function (evt) {
    setActiveStyleSheet('ovprintcss');
    if (document.getElementById('tb_printtopa')) {
        document.getElementById('tb_printtopa').href = "javascript:ovToolkit.printback(this);";
        document.getElementById('tb_printtopa').style.width = "125px";
        document.getElementById('tb_printtopa').style.display = "block";
    }
    if (document.getElementById('tb_printtop')) {
        document.getElementById('tb_printtop').innerHTML = "Normalansicht";
        document.getElementById('tb_printtop').style.visibility = "visible";
        document.getElementById('tb_printtop').style.display = "block";
    }
    if (document.getElementById('tb_printbota')) {
        document.getElementById('tb_printbota').href = "javascript:ovToolkit.printback(this);";
        document.getElementById('tb_printbota').style.width = "125px";
    }
    if (document.getElementById('tb_printbot')) {
        document.getElementById('tb_printbot').innerHTML = "Normalansicht";
        document.getElementById('tb_printbot').style.visibility = "visible";
        document.getElementById('tb_printbot').style.display = "block";
    }
    if (document.getElementById('super_anz')) {
        document.getElementById('super_anz').style.display = "none";
        document.getElementById('super_anz').style.visibility = "hidden";
    }
    if (document.getElementById('tb_printart')) {
        document.getElementById('tb_printart').href = "javascript:ovToolkit.printback(this);";
    }
    var bName = navigator.appName;
    var bVer = navigator.appVersion;
    var br;
    if (((bName == "Netscape" && bVer > "3.0") && (bName == "Netscape" && bVer < "4.01")) || ((bName == "Netscape" && bVer >= "4.03")) || (bName == "Microsoft Internet Explorer" && bVer >= "4.0")) {
        br = "n3";
    } else {
        br = "n2";
    }
    if (br == "n3") {
        self.print();
    } else {
        alert("Ihr Browser unterstützt dieses Feature nicht. Bitte drucken Sie über Datei  >>  Drucken !");
    }
    ovToolkit.SetOmniturePrintPixel();
}
ovToolkit.SetOmniturePrintPixel = function () {
    try {
        var s = s_gi(ovs_account);
        s.linkTrackVars = "events";
        s.linkTrackEvents = "event14";
        s.events = "event14"
        s.tl(this, "o", "Print");
    } catch (e) { }
}
ovToolkit.printback = function () {
    setActiveStyleSheet('ov');
    if (document.getElementById('tb_printtopa')) {
        document.getElementById('tb_printtopa').href = "javascript:ovToolkit.print(this);";
        document.getElementById('tb_printtopa').style.width = "";
        document.getElementById('tb_printtopa').style.display = "";
    }
    if (document.getElementById('tb_printtop')) {
        document.getElementById('tb_printtop').innerHTML = "Druckansicht";
        document.getElementById('tb_printtop').style.visibility = "";
        document.getElementById('tb_printtop').style.display = "";
    }
    if (document.getElementById('tb_printbota')) {
        document.getElementById('tb_printbota').href = "javascript:ovToolkit.print(this);";
        document.getElementById('tb_printbota').style.width = "";
    }
    if (document.getElementById('tb_printbot')) {
        document.getElementById('tb_printbot').innerHTML = "Druckansicht";
        document.getElementById('tb_printbot').style.visibility = "";
        document.getElementById('tb_printbot').style.display = "";
    }
    if (document.getElementById('super_anz')) {
        document.getElementById('super_anz').style.display = "block";
        document.getElementById('super_anz').style.visibility = "visible";
    }
    if (document.getElementById('tb_printart')) {
        document.getElementById('tb_printart').href = "javascript:ovToolkit.print(this);";
    }
}
ovToolkit.changeTxtSize = function (mode) {
    if (mode == 1) {
        if (parseFloat(ovToolkit.defaultFontSize) + 0.3 >= parseFloat(ovToolkit.actFontSize))
            ovToolkit.actFontSize = parseFloat(ovToolkit.actFontSize) + 0.10;
    } else {
        if (parseFloat(ovToolkit.defaultFontSize) < parseFloat(ovToolkit.actFontSize))
            ovToolkit.actFontSize = parseFloat(ovToolkit.actFontSize) - 0.10;
    }
    document.getElementById('content').style.fontSize = ovToolkit.actFontSize + "em";
}
ovToolkit.CheckPagingImages = function () {
    var pagingLeft = $('paging-left');
    var pagingRight = $('paging-right');
    if (currSliderIndex > 5) {
        pagingLeft.src = 'http://mediadb.kicker.de/library/image/paging-left.png';
    }
    else {
        pagingLeft.src = 'http://mediadb.kicker.de/library/image/paging-left-inakt.png';
    }
    if (currSliderIndex < lastSliderIndex) {
        pagingRight.src = 'http://mediadb.kicker.de/library/image/paging-right.png';
    }
    else {
        pagingRight.src = 'http://mediadb.kicker.de/library/image/paging-right-inakt.png';
    }
}
ovToolkit.GetHashParams = function () {
    var loc = (document.location + "");
    var pos = loc.indexOf("#");
    if (pos == -1)
        return [];
    var hashQs = loc.substring(pos + 1, loc.length);
    return ovToolkit.SplitParams(hashQs);
}
ovToolkit.SplitParams = function (params) {
    var result = [];
    var pairs = params.split("&");
    for (var i = 0; i < pairs.length; i++) {
        var kv = pairs[i].split("=");
        if (kv.length == 2)
            result[kv[0]] = kv[1];
    }
    return result;
}
ovToolkit.ShowOASPos = function (pos) {
    return false;
}
function OAS_RICH(pos) {
    ovToolkit.ShowOASPos(pos);
}
ovToolkit.AlertIfIPhone = function () {
    if (document.URL.indexOf("www.kicker.de") > -1) {
        var Check = false;
        if (navigator.userAgent.toLowerCase().indexOf("iphone") > -1 && document.referrer.indexOf("kicker.de") == -1 && document.referrer.indexOf("localhost") == -1) {
            Check = confirm("kicker für Ihr iPhone. Zur iPhone - Applikation wechseln?");
            if (Check == true) { window.location.href = "http://iphone.kicker.mobi"; }
        } else {
            ovToolkit.ovRedirectIfMobileClient();
        }
    }
}
ovToolkit.ovShowHidePages = function (show, hidde) {
    ovAjax.ShowElem(show);
    ovAjax.HideElem(hidde);
}
var ovMobileClients = [
"midp", "240x320", "blackberry", "netfront", "nokia", "panasonic", "portalmmm", "sharp", "sie-", "sonyericsson", "symbian", "windows ce", "benq", "mda", "mot-", "opera mini", "philips", "pocket pc", "sagem", "samsung", "sda", "sgh-", "vodafone", "xda"
];
ovToolkit.ovIsMobileClient = function (userAgent) {
    try {
        userAgent = userAgent.toLowerCase();
        for (var i = 0; i < ovMobileClients.length; i++)
            if (userAgent.indexOf(ovMobileClients[i]) != -1)
                return true;
    }
    catch (e) {
    }
    return false;
}
ovToolkit.ovIsThisBrowserMobileClient = function () {
    return ovToolkit.ovIsMobileClient(navigator.userAgent);
}
ovToolkit.ovRedirectIfMobileClient = function () {
    try {
        if (ovToolkit.ovIsThisBrowserMobileClient()) {
            if (document.location.href.indexOf('nomobile') != -1) {
                var jetzt = new Date();
                var heute = jetzt.getTime();
                var dann = heute + (90 * 24 * 60 * 60 * 1000);
                jetzt.setTime(dann);
                document.cookie = "kickermobile=nomobile;Path=/;expires=" + jetzt.toString();
                return;
            }
            if (document.cookie && document.cookie.indexOf('nomobile') != -1) {
                return;
            }
            document.location.href = "http://www.kicker.mobi?redirect=1";
        }
    }
    catch (e) {
    }
}
ovToolkit.CheckNavi = function () {
    if (ovAuth.authExists()) {
        for (var i = 0; i < 30; i++) {
            var elm = document.getElementById("ovNavi" + i.toString());
            if (elm != null) {
                ovToolkit.ReplaceHref(elm)
            } else {
                break;
            }
        }
    }
}
ovToolkit.ReplaceHref = function (AObject) {
    var aHref = AObject.href;
    var manid = ovAuth.getCookieProp("teilnehmer", "userid");
    if (aHref.lastIndexOf("/") == aHref.length - 1) {
        AObject.href = aHref + "manid/" + manid;
    } else {
        AObject.href = aHref + "/manid/" + manid;
    }
}
// Gibt die aktuelle X-Position des Mauszeigers zurueck
ovToolkit.mouseX = function (evt) {
    if (evt.pageX)
        return evt.pageX;
    else if (evt.clientX)
        return evt.clientX + document.body.scrollLeft;
    else
        return null;
}
// Gibt die aktuelle Y-Position des Mauszeigers zurueck
ovToolkit.mouseY = function (evt) {
    if (evt.pageY)
        return evt.pageY;
    else if (evt.clientY) {
        var scrollPos = 0;
        if (typeof window.pageYOffset != 'undefined') {
            scrollPos = window.pageYOffset;
        } else if (typeof document.compatMode != 'undefined' && document.compatMode != 'BackCompat') {
            scrollPos = document.documentElement.scrollTop;
        } else if (typeof document.body != 'undefined') {
            scrollPos = document.body.scrollTop;
        }
        return evt.clientY + scrollPos;
    }
    else
        return null;
}
ovToolkit.formatUrl = function (url) {
    url = url.replace(/&amp;/g, "&");
    return url;
}
ovToolkit.clearSuchTextField = function () {
    var elm;
    elm = document.getElementById("inputsuche");
    if (elm.value == "Suche")
        elm.value = "";
}
ovToolkit.clearSucheVonTextField = function () {
    var elm;
    elm = document.getElementById("suchevon");
    if (elm.value == "24.08.1963")
        elm.value = "";
}
ovToolkit.makeRemote = function (url) {
    window.location.href = url;
}
ovToolkit.openNewWindow = function (url) {
    window.open(url, "kicker", "");
    return;
}
ovToolkit.OpenPage = function (url, ctrl) {
    nameParts = ctrl.name.split('$');
    window.location.href = url + '/' + nameParts[nameParts.length - 1] + '/' + ctrl.value;
}
ovToolkit.Startseite = function () {
    var Seite = "http://www.kicker.de";
    var browser = navigator.appName;
    var version = navigator.appVersion.substring(0, 1);
    var ie = ((browser == "Microsoft Internet Explorer") && (version >= 4));
    var strText;
    if (ie) {
        document.body.style.behavior = "url(#default#homepage)";
        document.body.sethomepage(Seite);
    }
    else {
        strText = "kicker.de kann nur im Internet Explorer ";
        strText += "automatisch eingestellt werden,bitte richten ";
        strText += "Sie kicker.de manuell als Startseite ein.";
        alert(strText);
    }
}
//Promitipp
ovToolkit.SubmitPromitippFormLigaChanged = function (form) {
    var name;
    var value;
    var nameParts;
    var strParams;
    var strActionOriginal;
    strAction = new String(form.action);
    strParams = '';
    for (i = 0; i < form.length; i++) {
        name = form[i].name;
        value = form[i].value;
        if (name.length > 0) {
            nameParts = name.split('$');
            if (nameParts.length < 2) {
                nameParts = name.split('%');
            }
            name = nameParts[nameParts.length - 1];
            if (value != null && value.length > 0 && name != 'promitippuser') {
                strParams += '/' + name + '/' + value;
            }
        }
    }
    window.location.href = strAction + strParams;
}
//F1Manager
ovToolkit.SubmitManagerligaFormLigaChanged = function (form) {
    var name;
    var value;
    var nameParts;
    var strParams;
    var strActionOriginal;
    strAction = new String(form.action);
    strParams = '';
    for (i = 0; i < form.length; i++) {
        name = form[i].name;
        value = form[i].value;
        if (name.length > 0) {
            nameParts = name.split('$');
            if (nameParts.length < 2) {
                nameParts = name.split('%');
            }
            name = nameParts[nameParts.length - 1];
            if (value != null && value.length > 0 && name != 'manid') {
                strParams += '/' + name + '/' + value;
            }
        }
    }
    window.location.href = strAction + strParams;
}
ovToolkit.SubmitRankingAuswahl = function (form) {
    var name;
    var value;
    var nameParts;
    var strParams;
    var strActionOriginal;
    strAction = new String(form.action);
    strParams = '';
    for (i = 0; i < form.length; i++) {
        name = form[i].name;
        value = form[i].value;
        if (name.length > 0) {
            nameParts = name.split('$');
            if (nameParts.length < 2) {
                nameParts = name.split('%');
            }
            name = nameParts[nameParts.length - 1];
        }
        if (value == null) {
            value = form[i].options[form[i].selectedIndex].value;
        }
        if (value != null && value.length > 0 && name != null && name.length > 0) {
            strParams += '/' + name + '/' + ovToolkit.encode_utf8(value);
        }
    }
    window.location.href = strAction + strParams;
}
ovToolkit.AppendPromitippParamsToActionString = function (form) {
    var name;
    var value;
    var nameParts;
    var strParams;
    var strActionOriginal;
    strAction = new String(form.action);
    strParams = '';
    for (i = 0; i < form.length; i++) {
        name = form[i].name;
        value = form[i].value;
        if (name.length > 0) {
            nameParts = name.split('$');
            if (nameParts.length < 2) {
                nameParts = name.split('%');
            }
            name = nameParts[nameParts.length - 1];
        }
        if (value != null && value.length > 0) {
            strParams += '/' + name + '/' + value;
        }
    }
    return strAction + strParams;
}
//RSS
ovToolkit.SubmitRSSNews = function (form, ctrlName, ctrlName2) {
    var name;
    var value;
    var nameParts;
    var rssDomain;
    var rssIdentifier;
    var strAction;
    strAction = new String(form.action);
    strParams = '';
    for (i = 0; i < form.length; i++) {
        name = form[i].name;
        value = form[i].value;
        if (name.length > 0) {
            nameParts = name.split('$');
            if (nameParts.length < 2) {
                nameParts = name.split('%');
            }
            name = nameParts[nameParts.length - 1];
            if (name == 'rsf_feed_type') {
                rssDomain = 'http://rss.kicker.de/' + value;
            }
            else if ((name == ctrlName || name == ctrlName2) && value != "0") {
                rssIdentifier = value;
                if (name == 'mobileNews') {
                    rssDomain = 'http://rss.kicker.de/mobile/news';
                }
                else if (name == 'mobileTeam') {
                    rssDomain = 'http://rss.kicker.de/mobile/team';
                }
            }
        }
    }
    if (rssDomain.length > 0 && rssIdentifier.length > 0) {
        window.location.href = rssDomain + '/' + rssIdentifier;
    }
    else {
        window.location.href = strAction;
    }
}
ovToolkit.RefreshRSSTooltip = function (kicker_url) {
    var ctrl_feed = document.getElementById('rsstooltip_auflistung_rssfeed');
    var ctrl_google = document.getElementById('rsstooltip_auflistung_google');
    var ctrl_yahoo = document.getElementById('rsstooltip_auflistung_yahoo');
    var ctrl_msn = document.getElementById('rsstooltip_auflistung_msn');
    var ctrl_newsgator = document.getElementById('rsstooltip_auflistung_newsgator');
    var ctrl_netvibes = document.getElementById('rsstooltip_auflistung_netvibes');
    var ctrl_pageflakes = document.getElementById('rsstooltip_auflistung_pageflakes');
    var ctrl_rojo = document.getElementById('rsstooltip_auflistung_rojo');
    ctrl_feed.href = kicker_url;
    ctrl_google.href = 'http://fusion.google.com/add?feedurl=' + kicker_url;
    ctrl_yahoo.href = 'http://add.my.yahoo.com/rss?url=' + kicker_url;
    ctrl_msn.href = 'http://my.msn.com/addtomymsn.armx?id=rss&amp;ut=' + kicker_url;
    ctrl_newsgator.href = 'http://www.newsgator.com/ngs/subscriber/subext.aspx?url=' + kicker_url;
    ctrl_netvibes.href = 'http://www.netvibes.com/subscribe.php?url=' + kicker_url;
    ctrl_pageflakes.href = 'http://www.pageflakes.com/subscribe.aspx?url=' + kicker_url;
    ctrl_rojo.href = 'http://www.rojo.com/add-subscription?resource=' + kicker_url;
}
//Statistik
ovToolkit.SubmitForm = function (form) {
    window.location.href = ovToolkit.AppendFormParamsToActionString(form, 0, 0, '');
}
ovToolkit.SubmitPromitipp = function (form) {
    window.location.href = ovToolkit.AppendPromitippParamsToActionString(form);
}
ovToolkit.AppendFormParamsToActionString = function (form, isspielplan, setturniergruppeZero, IgnoreName) {
    var name;
    var value;
    var nameParts;
    var strParams;
    var strActionOriginal;
    var turniergruppe;
    strAction = new String(form.action);
    strParams = '';
    for (i = 0; i < form.length; i++) {
        name = form[i].name;
        if (form[i].type != 'checkbox') {
            value = form[i].value;
        }
        else {
            value = form[i].checked;
        }
        if (name.length > 0) {
            if (form[i].type != 'radio' || form[i].checked) {
                nameParts = name.split('$');
                if (nameParts.length < 2) {
                    nameParts = name.split('%');
                }
                name = nameParts[nameParts.length - 1];
            }
        }
        if (name == 'tabelle') {
            if (value.length > 0 || value > 0) {
                if (strAction.indexOf("/spieltag", 0) >= 0) {
                    if (value == 4) {
                        strAction = strAction.substr(0, strAction.indexOf("/spieltag", 0) + 9) + "/ergebnisgrid";
                    }
                    else {
                        strAction = strAction.substr(0, strAction.indexOf("/spieltag", 0) + 9) + "/tabelle";
                    }
                }
            }
        }
        else if (name == 'liga') {
            if (value == "1") {
                strAction = strAction.replace("/2bundesliga", "/bundesliga");
            }
            else if (value == "2") {
                strAction = strAction.replace("/bundesliga", "/2bundesliga");
            }
        }
        else if (name == 'selliga') {
            name = 'liga';
            if (value == 1803 || value == 1805 || value == 1806) {
                //NHL,NFL,NBA
                strAction = strAction.replace("_spieltag", "_spielplan");
                strAction = strAction.replace("naviindex/0", "naviindex/1");
                strAction = strAction.replace("NaviIndex/0", "NaviIndex/1");
            }
            else {
                strAction = strAction.replace("_spielplan", "_spieltag");
                strAction = strAction.replace("naviindex/1", "naviindex/0");
                strAction = strAction.replace("NaviIndex/1", "NaviIndex/0");
            }
        }
        else if (name == 'turniergruppe' && value != null && value > 0) {
            strAction = strAction.replace("/plan", "/runde");
            if (strAction.toLowerCase().indexOf("naviindex") < 0) {
                strAction = strAction + "/naviindex/1";
            }
            turniergruppe = value;
        }
        else if (isspielplan == 1 && name == 'spieltag' && value != null && value > 0) {
            strAction = strAction.replace("/plan", "/runde");
            if (strAction.toLowerCase().indexOf("naviindex") < 0) {
                strAction = strAction + "/naviindex/1";
            }
        }
        if (value == null) {
            value = form[i].options[form[i].selectedIndex].value;
        }
        if (value != null && value.length > 0 && name != null && name.length > 0) {
            if ((IgnoreName == 'tennis_jahr' && (name == 'modus' || name == 'spieltag' || name == 'nationen' || name == 'turniergruppe')) ||
(IgnoreName == 'tennis_modus' && (name == 'spieltag' || name == 'turniergruppe')) ||
(IgnoreName == 'tennis_runde' && (name == 'nationen' || name == 'turniergruppe')) ||
(IgnoreName == 'tennis_geschlecht' && name == 'turnierart') ||
(IgnoreName == 'ligenligen' && (name == 'saison' || name == 'spieltag' || name == 'naviindex' || name == 'object'))) {
                //Ignore Parameter,don't add Parameter!
            }
            else {
                if (form[i].type != 'radio' || form[i].checked) {
                    strParams += '/' + name + '/' + value;
                }
            }
        }
    }
    var result;
    result = strAction + strParams;
    if (setturniergruppeZero) {
        result = result.replace("/turniergruppe/" + turniergruppe, "/turniergruppe/0");
    }
    return result;
}
//Suche
ovToolkit.checkSuche = function (myform) {
    myform.submit();
    return;
}
ovToolkit.checkSucheBtn = function () {
    var suchbegriff;
    suchbegriff = ovToolkit.encode_utf8(document.getElementById("inputsuche").value);
    window.open('http://de.ask.com/ar?q=' + suchbegriff + '&qsrc=999&siteid=3006&l=dis', 'askcom', 'menubar=1,location=1,toolbar=1,scrollbars=1,resizable=1');
    return;
}
ovToolkit.encode_utf8 = function (rohtext) {
    var utftext = "";
    rohtext = rohtext.replace(/\r\n/g, "\n");
    for (var n = 0; n < rohtext.length; n++) {
        if (rohtext.charAt(n) == "\u00E4") { //ae
            utftext += "%C3%A4";
        }
        else if (rohtext.charAt(n) == "\u00f6") { //oe
            utftext += "%C3%B6";
        }
        else if (rohtext.charAt(n) == "\u00fc") { //ue
            utftext += "%C3%BC";
        }
        else if (rohtext.charAt(n) == "\u00df") { //ss
            utftext += "%C3%9F";
        }
        else if (rohtext.charAt(n) == "\u00c4") { //Ae
            utftext += "%C3%84";
        }
        else if (rohtext.charAt(n) == "\u00d6") { //Oe
            utftext += "%C3%96";
        }
        else if (rohtext.charAt(n) == "\u00dc") { //Ue
            utftext += "%C3%9C";
        }
        else if (rohtext.charAt(n) == "\u00f3") { //o-apostroph
            utftext += "%C3%B3";
        }
        else {
            utftext += rohtext.charAt(n);
        }
    }
    return utftext;
}
ovToolkit.checkkickerSuche = function (form, suchwort, suchevon, suchebis, nurtitel) {
    var nurtitel;
    var maxtreffer;
    var params = "";
    for (i = 0; i < form.length; i++) {
        name = form[i].name;
        if (name.length > 0) {
            nameParts = name.split('$');
            if (nameParts.length < 2) {
                nameParts = name.split('%');
            }
            name = nameParts[nameParts.length - 1];
        }
        if (name == 'maxtreffer') {
            maxtreffer = form[i].value;
        }
        if (name == 'nurtitel')
            nurtitel = form[i].checked;
    }
    if (suchwort.value.length > 0) {
        params = '/q/' + suchwort.value;
    }
    if (suchevon.value.length > 0) {
        params = params + '/suchevon/' + suchevon.value;
    }
    if (suchebis.value.length > 0) {
        params = params + '/suchebis/' + suchebis.value;
    }
    if (nurtitel == true) {
        params = params + '/nurtitel/1';
    }
    else {
        params = params + '/nurtitel/0';
    }
    params = params + '/maxtreffer/' + maxtreffer;
    window.location.href = form.action + params;
    return;
}
ovToolkit.keyCheckEnter = function (eventObj, myform) {
    var keyCode;
    if (document.all) {
        keyCode = eventObj.keyCode;
    }
    else {
        keyCode = eventObj.which;
    }
    if (keyCode == 13) {
        ovToolkit.checkSuche(myform);
        return false;
    }
}
//Search
ovToolkit.searchOnEnter = function (eventObj, form) {
    var keyCode;
    if (document.all) {
        keyCode = eventObj.keyCode;
    }
    else {
        keyCode = eventObj.which;
    }
    if (keyCode == 13) {
        ovToolkit.RedirectSearch(form);
        return false;
    }
}
ovToolkit.searchChangeSuchevonColor = function () {
    var suchevon = $('suchevon');
    if (suchevon) {
        suchevon.style.color = "#595959";
    }
}
ovToolkit.searchRemoveDetails = function () {
    var rawurl = $('rawurl').value;
    if (rawurl.indexOf('details.html') > -1) {
        rawurl = rawurl.replace('/{suchobjecttype}/{suchobjectid}/{suchsaison}', '');
        rawurl = rawurl.replace('details.html', '.html');
        $('rawurl').value = rawurl;
    }
}
ovToolkit.RedirectSearch = function (form) {
    var rawurl = $('rawurl').value;
    var localprefixURL = $('localprefixURL').value;
    var suchbegriff = $('suchwort').value.replace(/ /g, '+');
    var suchobjecttype = $('suchobjecttype').value;
    var suchobjectid = $('suchobjectid').value;
    var suchsaison = $('suchsaison').value;
    var suchevon = $('suchevon').value.replace('.', '-').replace('.', '-');
    var suchebis = $('suchebis').value.replace('.', '-').replace('.', '-');
    var suchtype = $('suchtype').value;
    var maxtreffer = $('maxtreffer').value;
    var nurtitel = $('nurtitel').checked;
    var ctrlName;
    var suchRessorts = '0-';
    for (i = 0; i < form.length; i++) {
        ctrlName = form[i].name;
        if (ctrlName.length > 0 && ctrlName.indexOf('chkressorts') > -1) {
            if (form[i].checked) {
                suchRessorts += form[i].value + '-';
            }
        }
    }
    if (suchbegriff.length == 0)
        suchbegriff = '-';
    if (suchevon.length == 0)
        suchevon = '0';
    if (suchebis.length == 0)
        suchebis = '0';
    rawurl = rawurl.replace('{suchbegriff}', suchbegriff);
    rawurl = rawurl.replace('{suchevon}', suchevon);
    rawurl = rawurl.replace('{suchebis}', suchebis);
    rawurl = rawurl.replace('{sucheressort}', suchRessorts);
    rawurl = rawurl.replace('{maxtreffer}', maxtreffer);
    rawurl = rawurl.replace('{suchtype}', suchtype);
    rawurl = rawurl.replace('{suchobjecttype}', suchobjecttype);
    rawurl = rawurl.replace('{suchobjectid}', suchobjectid);
    rawurl = rawurl.replace('{suchsaison}', suchsaison);
    if (nurtitel == true)
        rawurl = rawurl.replace('{nurtitel}', '1');
    else
        rawurl = rawurl.replace('{nurtitel}', '0');
    window.location.href = localprefixURL + "/home" + rawurl;
}
//Community
ovToolkit.openCard = function (username) {
    window.location.href = "http://community.kicker.de/community/card/" + username + "/";
}
ovToolkit.openCommunityCard = function (username) {
    window.location.href = "http://community.kicker.de/community/card/" + username + "/";
}
ovToolkit.openPicFlyout = function (picZoomType, objectID, saison, virtualPath, verein) {
    ovToolkit.openPicFlyoutExt(picZoomType, objectID, saison, 0, virtualPath, verein);
}
ovToolkit.openPicFlyoutExt = function (picZoomType, objectID, saison, liga, virtualPath, verein) {
    var width;
    var height;
    if (picZoomType == 3) {
        //Stadion
        width = 488;
        height = 459;
    } else if (picZoomType == 5 || picZoomType == 6 || picZoomType == 7) {
        //F1-Strecke
        width = 620;
        height = 543;
    } else {
        width = 520;
        height = 675;
    }
    var winopts = "height=" + height + ",width=" + width + ",scrollbars=no,resizable=0,status=0,location=0,toolbar=0";
    var strLiga;
    var strVerein;
    if (liga > 0) {
        strLiga = '/liga/' + liga;
    } else {
        strLiga = '';
    }
    if (verein && verein > 0) {
        strVerein = '/verein/' + verein;
    } else {
        strVerein = '';
    }
    cardWin = window.open(virtualPath + 'piczoom/object/' + objectID + '/picZoomType/' + picZoomType + '/saison/' + saison + strLiga + strVerein, 'kicker', winopts);
}
ovToolkit.openSMSHelp = function (rootUrl, SpielID) {
    var url = rootUrl;
    url += "/spiel/" + SpielID;
    window.open(url, "popup", "menubar=0,toolbar=0,scrollbars=1,status=1,resizable=1,height=480,width=480");
    return;
}
ovToolkit.openZoom = function (artikelID, picID, picwidth) {
    var width;
    var height;
    var winopts;
    var Wert;
    if (parseInt(picwidth) < 401) {
        width = 430;
        height = 430;
    } else if (parseInt(picwidth) < 501) {
        width = 530;
        height = 510;
    } else if (parseInt(picwidth) < 601) {
        width = 630;
        height = 570;
    } else {
        width = parseInt(picwidth) + 30;
        height = parseInt(width * 570 / 630);
    }
    winopts = "height=" + height + ",width=" + width + ",scrollbars=no,resizable=0,status=0,location=0,toolbar=0";
    cardWin = window.open('/home/artikelzoom/object/' + artikelID + '/picid/' + picID, 'kicker', winopts);
}
ovToolkit.openVotingFlyOut = function (votingGUID, width, height) {
    var winopts;
    if (width == null) width = 440;
    if (height == null) height = 550;
    winopts = "height=" + height + ",width=" + width + ",scrollbars=yes,resizable=0,status=0,location=0,toolbar=0";
    window.open('/home/umfrage/votingguid/' + votingGUID, 'kicker', winopts);
    return;
}
ovToolkit.playCaptcha = function (uid, mediadburl) {
    var wavURL = mediadburl + "/special/Audio/Audio_Capture_Player.swf?uid=" + uid;
    var embedCode = '<EMBED SRC=' + wavURL + ' HIDDEN="true" AUTOSTART="true" >';
    document.getElementById("playAudio").innerHTML = "";
    document.getElementById("playAudio").innerHTML = embedCode;
    document.getElementById("newaccountcaptcha").value = "";
    document.getElementById("newaccountcaptcha").focus();
}
//Shirt-Promo
var maxShirtImg = 6;
var actShirtImg = 1;
var isFront = 1;
var imgShirtPath = "http://mediadb.kicker.de/special/managerspiel-shirts/";
function nextShirtImg(p) {
    if (parseInt(p) == 0) {
        if (actShirtImg > 1) {
            actShirtImg -= 1;
        }
        else {
            actShirtImg = maxShirtImg;
        }
    }
    else {
        if (actShirtImg < maxShirtImg) {
            actShirtImg += 1;
        }
        else {
            actShirtImg = 1;
        }
    }
    var newpath = imgShirtPath + actShirtImg + ".gif";
    var promoslideIMG = document.getElementById('shirtslide');
    promoslideIMG.src = newpath;
    setShirtURL()
}
function setShirtURL() {
    var shirtDefaultURL = document.getElementById('shirtdefaulturl');
    var shirtURL1 = document.getElementById('shirturl1');
    var shirtURL2 = document.getElementById('shirturl2');
    var url = shirtDefaultURL.value;
    if (isFront != 1)
        url += '&view=2'
    url += '&article_id=' + artikelidByPicIndex(actShirtImg);
    shirtURL1.href = url;
    shirtURL2.href = url;
}
function backsideShirtImg(isLiga) {
    var promoslideIMG = document.getElementById('shirtslide');
    var revCtrl = document.getElementById('fbmanager_rev');
    var ffwCtrl = document.getElementById('fbmanager_ffw');
    var backfrontLink = document.getElementById('backfront_link');
    var newpath = imgShirtPath;
    if (isFront == 1) {
        isFront = 0;
        if (isLiga == 1) {
            newpath += "backside-liga.gif";
        }
        else {
            newpath += "backside-cl-int.gif";
        }
        revCtrl.style.visibility = 'hidden';
        ffwCtrl.style.visibility = 'hidden';
        backfrontLink.innerHTML = 'Zur&uuml;ck zur Vorderseite';
    }
    else {
        isFront = 1;
        newpath += actShirtImg + ".gif";
        revCtrl.style.visibility = 'visible';
        ffwCtrl.style.visibility = 'visible';
        backfrontLink.innerHTML = 'Mit deiner Statistik auf der R&uuml;ckseite';
    }
    promoslideIMG.src = newpath;
    setShirtURL()
}
function artikelidByPicIndex(picIndex) {
    if (picIndex == 1)
        return '4872026';
    else if (picIndex == 2)
        return '4872066';
    else if (picIndex == 3)
        return '4872082';
    else if (picIndex == 4)
        return '4872106';
    else if (picIndex == 5)
        return '4872118';
    else if (picIndex == 6)
        return '4872123';
    else
        return '';
}
function ovShowVideoTeaserSmall(id, teaser) {
    $(id).style.border = "solid 1px red";
    $('teasersmall').style.visibility = "visible";
    $('teasersmall').innerHTML = teaser;
}
function ovHideVideoTeaserSmall(id) {
    $(id).style.border = "solid 1px #ffffff";
    $('teasersmall').style.visibility = "hidden";
}
//alte Funktionen fuer die Uebergangsphase
function checkHeftbestellung(myform) {
    ovToolkit.checkHeftbestellung(myform)
}
function openZoom(artikelID, picID, picwidth) {
    ovToolkit.openZoom(artikelID, picID, picwidth);
}
function openNewWindow(url) {
    ovToolkit.openNewWindow(url)
}
function openVotingFlyOut(votingGUID, width, height) {
    ovToolkit.openVotingFlyOut(votingGUID, width, height)
}
function makeRemote(url) {
    ovToolkit.makeRemote(url);
}
function openMedionBDF(dest) {
    win = window.open(dest, 'Medion', "'menubar=1,toolbar=0,scrollbars=0,status=0,resizable=0,height=400,width=400'");
    return;
}
// ---------------------------------------------------------------------------
// Javascript:Konvertierung
// ---------------------------------------------------------------------------
var ovUrl = {
    // public method for url encoding
    encode: function (string) {
        return escape(this._utf8_encode(string));
    }, // public method for url decoding
    decode: function (string) {
        return this._utf8_decode(unescape(string));
    }, // private method for UTF-8 encoding
    _utf8_encode: function (string) {
        string = string.replace(/\r\n/g, "\n");
        var utftext = "";
        for (var n = 0; n < string.length; n++) {
            var c = string.charCodeAt(n);
            if (c < 128) {
                utftext += String.fromCharCode(c);
            } else if ((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            } else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }
        }
        return utftext;
    }, // private method for UTF-8 decoding
    _utf8_decode: function (utftext) {
        var string = "";
        var i = 0;
        var c = c1 = c2 = 0;
        while (i < utftext.length) {
            c = utftext.charCodeAt(i);
            if (c < 128) {
                string += String.fromCharCode(c);
                i++;
            } else if ((c > 191) && (c < 224)) {
                c2 = utftext.charCodeAt(i + 1);
                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                i += 2;
            } else {
                c2 = utftext.charCodeAt(i + 1);
                c3 = utftext.charCodeAt(i + 2);
                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                i += 3;
            }
        }
        return string;
    }
}
var ovUtf8 = {
    // public method for url encoding
    encode: function (string) {
        string = string.replace(/\r\n/g, "\n");
        var utftext = "";
        for (var n = 0; n < string.length; n++) {
            var c = string.charCodeAt(n);
            if (c < 128) {
                utftext += String.fromCharCode(c);
            } else if ((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            } else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }
        }
        return utftext;
    }, // public method for url decoding
    decode: function (utftext) {
        var string = "";
        var i = 0;
        var c = c1 = c2 = 0;
        while (i < utftext.length) {
            c = utftext.charCodeAt(i);
            if (c < 128) {
                string += String.fromCharCode(c);
                i++;
            } else if ((c > 191) && (c < 224)) {
                c2 = utftext.charCodeAt(i + 1);
                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                i += 2;
            } else {
                c2 = utftext.charCodeAt(i + 1);
                c3 = utftext.charCodeAt(i + 2);
                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                i += 3;
            }
        }
        return string;
    }
}
// ---------------------------------------------------------------------------
// Javascript:ovAuthentication
// ---------------------------------------------------------------------------
function ovAuthentication() {
    this.pageurl = document.URL;
}
var ovAuth = new ovAuthentication();
ovAuth.initQuick = function () {
    if (this.authExists()) {
        ovAuth.showLoginContainer(true);
    } else {
        ovAuth.showLoginContainer(false);
    }
}
ovAuth.showLoginContainer = function (isLoggedIn, isFBLogIn) {
    if ($('ovUserisloggedin') && $('ovUserisloggedout')) {
        if (isLoggedIn) {
            $('ovUserisloggedin').style.display = 'block';
            $('ovUserisloggedout').style.display = 'none';
            if (isFBLogIn) {
                $('ovUserisfbloggedin').style.display = 'block';
                $('ovUserisloggedin').className = 'ovFbLogin';
            }
            else {
                $('ovUserisfbloggedin').style.display = 'none';
                $('ovUserisloggedin').className = '';
            }
            if ($('ovLoginnickname')) {
                $('ovLoginnickname').innerHTML = this.getAuthNickname();
            }
        }
        else {
            $('ovUserisloggedin').style.display = 'none';
            $('ovUserisloggedout').style.display = 'block';
            if ($('returnurl')) {
                $('returnurl').value = ovAuth.getReturnURL();
            }
        }
    }
}
ovAuth.CheckUser = function () {
    //alert('CheckUser start;');
    var teilnehmerCookie = ovAuth.getCookie("teilnehmer");
    if (teilnehmerCookie) {
        var accesscode = ovAuth.getCookieProp("teilnehmer", "accesscode");
        if (accesscode && accesscode.length > 0) {
            //alert('User has accesscode;');
            FB.getLoginStatus(function (response) {
                //alert('response: '+response +'  --  response.session: ' + response.session);
                if (response.session) {
                    //Überprüfung ob eingeloggter User der gleiche ist den kicker erwartet
                    var fbUserIDCookie = ovAuth.getCookieProp("teilnehmer", "fbuserid");
                    var fbUserIDApi = response.session.uid;
                    //alert('fbUserIDApi: '+fbUserIDApi +'  --  response.session.uid: ' + response.session.uid);
                    if (fbUserIDCookie == fbUserIDApi) {
                        //Richtiger User ist eingeloggt
                        //alert('alles ok!');
                        ovAuth.showLoginContainer(true, true);
                    }
                    else {
                        //Falscher User ist eingeloggt
                        //alert('nicht ok! Cookie wird gelöscht');
                        ovAuth.DeleteAuthCookies();
                        ovAuth.showLoginContainer(false);
                    }
                }
                else {
                    //Kein User ist über Facebook angemeldet
                    ovAuth.DeleteAuthCookies();
                    ovAuth.showLoginContainer(false);
                }
            }, true);
        }
        else {
            //User ist nicht über Facebook eingeloggt
            ovAuth.showLoginContainer(true);
        }
    }
    else {
        //User ist überhaupt nicht eingeloggt
        ovAuth.showLoginContainer(false);
    }
}
//---FACEBOOK START-------------------------------------------------------------------------------
function facebookPopup(url) {
    window.open(url, "facebookpopup", "width=620,height=400");
    return;
}
function fbChangeVariantenContainer(visibleContainerIndex) {
    if (visibleContainerIndex == 1) {
        $('fbVariantenReiterClassic').className = 'nav4tab';
        $('fbVariantenReiterPro').className = 'nav4tab';
        $('fbVariantenReiterInteractive').className = 'nav4tab-sel';
        $('fbInteractiveInfo').style.display = 'block';
        $('fbClassicInfo').style.display = 'none';
        $('fbProInfo').style.display = 'none';
    }
    else if (visibleContainerIndex == 2) {
        $('fbVariantenReiterClassic').className = 'nav4tab';
        $('fbVariantenReiterInteractive').className = 'nav4tab';
        $('fbVariantenReiterPro').className = 'nav4tab-sel';
        $('fbProInfo').style.display = 'block';
        $('fbInteractiveInfo').style.display = 'none';
        $('fbClassicInfo').style.display = 'none';
    }
    else {
        $('fbVariantenReiterPro').className = 'nav4tab';
        $('fbVariantenReiterInteractive').className = 'nav4tab';
        $('fbVariantenReiterClassic').className = 'nav4tab-sel';
        $('fbClassicInfo').style.display = 'block';
        $('fbInteractiveInfo').style.display = 'none';
        $('fbProInfo').style.display = 'none';
    }
}
function ShowFBConten(ctrlID) {
    if (ctrlID == 'fbverknuepfen') {
        $('fbreg').style.display = 'none';
        $('fbverknuepfen').style.display = 'block';
        $('fbadd').style.display = 'none';
    }
    else if (ctrlID == 'fbadd') {
        $('fbreg').style.display = 'none';
        $('fbverknuepfen').style.display = 'none';
        $('fbadd').style.display = 'block';
    }
    else {
        $('fbreg').style.display = 'block';
        $('fbverknuepfen').style.display = 'none';
        $('fbadd').style.display = 'none';
    }
}
function CloseAndRefresh() {
    try {
        if (window.opener) {
            if (window.opener.location.href == undefined) {
                window.location.href = 'http://manager.kicker.de/classic/facebookredirect';
            }
            else {
                window.opener.location.reload();
                window.close();
            }
        }
        else {
            window.close();
        }
    }
    catch (e) {
        window.location.href = 'http://manager.kicker.de/classic/facebookredirect';
    }
}
function ParentOpenURL(url) {
    if (window.opener) {
        window.opener.location.href = url;
    }
    else if (window.parent) {
        window.parent.location.href = url;
    }
    else {
        window.open(url, "kicker");
    }
}
//---FACEBOOK END-------------------------------------------------------------------------------
ovAuth.DeleteAuthCookies = function () {
    ovAuth.deleteCookie('teilnehmer');
    ovAuth.deleteCookie('kickermanagerspiel');
    window.location.reload();
}
ovAuth.clearUsernameTextField = function () {
    var elm = document.getElementById("nicknameLoginBox");
    if (elm.value == "Login")
        elm.value = "";
}
ovAuth.clearPasswordTextField = function () {
    var elm = document.getElementById("passwordLoginBox");
    if (elm.value == "pass")
        elm.value = "";
}
ovAuth.getRootURL = function () {
    var rootURL = "";
    var elm = document.getElementById("rootPath");
    if (elm != null)
        rootURL = elm.value;
    return rootURL;
}
ovAuth.getReturnURL = function () {
    var returnURL = ""; //document.URL;
    if (document.URL.toLowerCase().indexOf("returnurl") > -1) {
        returnURL = document.URL.substr(document.URL.toLowerCase().indexOf("returnurl") + 10);
        returnURL = ovUrl.decode(returnURL);
    }
    return returnURL;
}
ovAuth.logout = function () {
    window.location.href = ovAuth.getRootURL() + "/community/logout/";
}
ovAuth.createNothing = function () {
    document.writeln('<table width="100%"><tr><td>&nbsp;</td></tr>');
    document.writeln('</table>');
}
ovAuth.authExists = function () {
    var cookie = this.getCookie("teilnehmer");
    if (cookie != null) {
        if (this.getCookieProp("teilnehmer", "name") != null) {
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}
ovAuth.getAuthNickname = function () {
    if (this.authExists()) {
        return this.getCookieProp("teilnehmer", "nickname");
    }
    return "Registrierung";
}
ovAuth.getAuthFBCode = function () {
    if (this.authExists()) {
        return this.getCookieProp("teilnehmer", "accesscode");
    }
    return "";
}
ovAuth.getAuthName = function () {
    if (this.authExists()) {
        return this.getCookieProp("teilnehmer", "name");
    }
    return "Registrierung";
}
ovAuth.getCookieProp = function (cName, pName) {
    var cookie = this.getCookie(cName);
    var prefix = pName + "=";
    var propStart = cookie.indexOf("&" + prefix);
    var propEnd;
    var propValue;
    if (propStart == -1) {
        propStart = cookie.indexOf(prefix);
        if (propStart != 0) return null;
    }
    else propStart += 1;
    propEnd = cookie.indexOf("&", propStart);
    if (propEnd == -1) propEnd = cookie.length;
    propValue = cookie.substring(propStart + prefix.length, propEnd);
    while (propValue.indexOf("+") >= 0) {
        propValue = propValue.replace(/\++/, " ");
    }
    return unescape(propValue);
}
ovAuth.getCookie = function (name) {
    var dc = document.cookie;
    var prefix = name + "=";
    var begin = dc.indexOf("; " + prefix);
    if (begin == -1) {
        begin = dc.indexOf(prefix);
        if (begin != 0) return null;
    }
    else begin += 2;
    var end = document.cookie.indexOf(";", begin);
    if (end == -1) end = dc.length;
    return unescape(dc.substring(begin + prefix.length, end));
}
// this deletes the cookie when called
ovAuth.deleteCookie = function (name) {
    if (this.getCookie(name)) {
        if (document.URL.indexOf("localhost") > -1) {
            document.cookie = name + '=;path=/; expires=Thu,01-Jan-70 00:00:01 GMT;';
        }
        else {
            document.cookie = name + '=;path=/; expires=Thu,01-Jan-70 00:00:01 GMT;domain=.kicker.de';
        }
    }
}
ovAuth.setNewMail = function (messages) {
    var MCont = $('ovNewmailnav');
    var anzM = parseInt(messages);
    var postUrl = 'http://community.kicker.de/community/messages/Eingang/';
    if (MCont) {
        if (this.getCookieProp("teilnehmer", "accesscode") != null && this.getCookieProp("teilnehmer", "accesscode").length > 0) {
            MCont.innerHTML = '<a class="ovMail ovMailFb" href="' + postUrl + '"><span>' + anzM + '</span></a>';
        } else {
            if (anzM == 1) {
                MCont.innerHTML = '<a class="ovMail ovMailNew" href="' + postUrl + '"><span>' + anzM + '</span>&nbsp;neue&nbsp;Nachricht</a>';
            } else if (anzM > 0) {
                MCont.innerHTML = '<a class="ovMail ovMailNew" href="' + postUrl + '"><span>' + anzM + '</span>&nbsp;neue&nbsp;Nachrichten</a>';
            } else {
                MCont.innerHTML = '<a class="ovMail" href="' + postUrl + '"><span>0</span>&nbsp;neue&nbsp;Nachrichten</a>';
            }
        }
    }
}
// ---------------------------------------------------------------------------
// Javascript:FlashVideo
// ---------------------------------------------------------------------------
var myListener = {};
var kickerPlayer = {};
function updateHTML(elmId, value) {
    document.getElementById(elmId).innerHTML = value;
}
function setytplayerState(newState) {
    updateHTML("playerstate", newState);
}
function onKickerPlayerReady(playerId) {
    kickerPlayer = document.getElementById("flashVideoPlayer");
    kickerPlayer.addEventListener("onLoad", "myListener.onLoad");
    kickerPlayer.addEventListener("onPlay", "myListener.onPlay");
    kickerPlayer.addEventListener("onPause", "myListener.onPause");
    kickerPlayer.addEventListener("onComplete", "myListener.onComplete");
}
function play() {
    kickerPlayer.playVideo();
}
function pause() {
    kickerPlayer.pauseVideo();
}
myListener.onLoad = function (receivedParamsFromPlayerIfAny) {
    setytplayerState(receivedParamsFromPlayerIfAny);
}
myListener.onPlay = function (receivedParamsFromPlayerIfAny) {
    setytplayerState(receivedParamsFromPlayerIfAny);
}
myListener.onPause = function (receivedParamsFromPlayerIfAny) {
    setytplayerState(receivedParamsFromPlayerIfAny);
}
myListener.onComplete = function (receivedParamsFromPlayerIfAny) {
    setytplayerState(receivedParamsFromPlayerIfAny);
}
function ovCreateKickerPlayer(videoid, category, allowAds, thema, headline, credit, isJunioren, videoLevelId, videoStreamingUrl) {
    var flashvars = '';
    var videoPath = ovToolkit.playerVideoPath;
    var playlistURL;
    var videoPlayer = ovToolkit.playerPopupURL;
    var ewtest = (document.URL.indexOf("ewtest") > -1);
    if (isJunioren && isJunioren.toString() == "true") {
        playlistURL = ovToolkit.playerJuniorenPlaylistURL;
    } else {
        playlistURL = ovToolkit.playerPlaylistURL;
    }
    //initialClip -> if not defined the player will use the first clip out of the Playlist
    flashvars += 'FlashVars_videoid=' + videoid + '&';
    flashvars += 'FlashVars_category=' + category + '&';
    flashvars += 'FlashVars_allowInitialAds=' + allowAds + '&'; //only for the initial-clip'
    flashvars += 'FlashVars_thema=' + encodeURI(thema) + '&';
    flashvars += 'FlashVars_headline=' + encodeURI(headline) + '&';
    flashvars += 'FlashVars_credit=' + credit + '&';
    flashvars += 'FlashVars_videolevelid=' + videoLevelId + '&';
    flashvars += 'FlashVars_streamingurl=' + videoStreamingUrl + '&';
    flashvars += 'FlashVars_baseURL=http://www.kicker.de&';
    flashvars += 'FlashVars_loglevel=LEVEL_NONE&'; //allowed: LEVEL_NONE,LEVEL_DEBUG,LEVEL_INFO
    if (allowAds == false || allowAds.toLowerCase() == 'false') {
        flashvars += 'FlashVars_allowAds=false' + '&';
        flashvars += 'FlashVars_allowEWAds=false' + '&';
        flashvars += 'FlashVars_allowVASTAds=false' + '&';
    } else {
        flashvars += 'FlashVars_allowAds=true' + '&';
        if (ewtest) {
            flashvars += 'FlashVars_allowVASTAds=false' + '&';
        } else {
            flashvars += 'FlashVars_allowVASTAds=true' + '&';
        }
        flashvars += 'FlashVars_allowEWAds=true' + '&';
    }
    flashvars += 'FlashVars_urls=' + playlistURL + '?mode=newest;null;null&';
    flashvars += 'FlashVars_playlistUrl=' + playlistURL + '?&';
    // Statistik
    if (isJunioren && isJunioren.toString() == "true") {
        flashvars += 'FlashVars_countURL=' + escape(ovToolkit.rootURL + '/news/junioren/videocount?id=[ID]&format=[FORMAT]') + '&';
    } else {
        flashvars += 'FlashVars_countURL=' + escape(ovToolkit.rootURL + '/news/videocount?id=[ID]&format=[FORMAT]') + '&';
    }
    flashvars += 'FlashVars_countFrame=ad_count_frame&';
    if (isJunioren && isJunioren.toString() == "true") {
        flashvars += 'FlashVars_categories=Alle,Junioren&';
        //flashvars += 'FlashVars_showCategory=false&';
    } else {
        flashvars += 'FlashVars_categories=Alle,Dt. Fussball,Int. Fussball,Nationalelf,News,WM,EM,Formel 1,Mehr Sport' + '&';
        //flashvars += 'FlashVars_showCategory=true&';
    }
    flashvars += 'FlashVars_videoPath=' + videoPath + '&';
    flashvars += 'FlashVars_lc_networkId=106414' + '&';
    flashvars += 'FlashVars_lc_format=Video-Flash-400-400x300' + '&';
    flashvars += 'FlashVars_lc_levelId=Kicker_Portal%3AKicker_video' + '&';
    flashvars += 'FlashVars_lc_displayRegion=Standartbanner' + '&';
    if (ewtest) {
        //Test
        flashvars += 'FlashVars_ew_pre_url=http://ad.de.doubleclick.net/adx/kicker.smartclip/test;sz=400x320;dcmt=text/html;ord=[timestamp]?' + '&';
        flashvars += 'FlashVars_ew_overlay_url=http://ad.de.doubleclick.net/adx/kicker.smartclip/test;sz=300x50;dcmt=text/html;ord=[timestamp]?' + '&';
        flashvars += 'FlashVars_ew_mid_url=http://ad.de.doubleclick.net/adx/kicker.smartclip/test;sz=400x299;dcmt=text/html;ord=[timestamp]?' + '&';
        flashvars += 'FlashVars_ew_post_url=http://ad.de.doubleclick.net/adx/kicker.smartclip/test;sz=400x300;dcmt=text/html;ord=[timestamp]?' + '&';
        flashvars += 'FlashVars_vast_pre_url=http://im.banner.t-online.de/?advideo/3.0/784.1/2853455/0//cc=2;vidAS=pre_roll;vidRT=VAST;vidRTV=2.0.1;vidREG=companion_bottom:728x90:adiframe' + '&';
        flashvars += 'FlashVars_vast_overlay_url=http://im.banner.t-online.de/?advideo/3.0/784.1/2853456/0//cc=2;vidAS=overlay;vidRT=VAST;vidRTV=2.0.1;vidREG=companion_bottom:728x90:adiframe' + '&';
        flashvars += 'FlashVars_vast_mid_url=' + '&';
        flashvars += 'FlashVars_vast_post_url=http://im.banner.t-online.de/?advideo/3.0/784.1/2853457/0//cc=2;vidAS=post_roll;vidRT=VAST;vidRTV=2.0.1;vidREG=companion_bottom:728x90:adiframe' + '&';
    } else {
        //Live
        flashvars += 'FlashVars_ew_pre_url=http://ad.de.doubleclick.net/ad/kicker.smartclip/;sz=400x320;dcmt=text/html;ord=[timestamp]?' + '&';
        flashvars += 'FlashVars_ew_overlay_url=http://ad.de.doubleclick.net/ad/kicker.smartclip/;sz=300x50;dcmt=text/html;ord=[timestamp]?' + '&';
        flashvars += 'FlashVars_ew_mid_url=http://ad.de.doubleclick.net/ad/kicker.smartclip/;sz=400x299;dcmt=text/html;ord=[timestamp]?' + '&';
        flashvars += 'FlashVars_ew_post_url=http://ad.de.doubleclick.net/ad/kicker.smartclip/;sz=400x300;dcmt=text/html;ord=[timestamp]?' + '&';
        flashvars += 'FlashVars_vast_pre_url=http://im.banner.t-online.de/?advideo/3.0/784.1/2904355/0//cc=2;vidAS=pre_roll;vidRT=VAST;vidRTV=2.0.1;vidREG=companion_bottom:728x90:adiframe' + '&';
        flashvars += 'FlashVars_vast_overlay_url=http://im.banner.t-online.de/?advideo/3.0/784.1/2904356/0//cc=2;vidAS=overlay;vidRT=VAST;vidRTV=2.0.1;vidREG=companion_bottom:728x90:adiframe' + '&';
        flashvars += 'FlashVars_vast_mid_url=' + '&';
        flashvars += 'FlashVars_vast_post_url=http://im.banner.t-online.de/?advideo/3.0/784.1/2904359/0//cc=2;vidAS=post_roll;vidRT=VAST;vidRTV=2.0.1;vidREG=companion_bottom:728x90:adiframe' + '&';
    }
    //ew params
    flashvars += 'FlashVars_midroll_video_length=90' + '&';
    flashvars += 'FlashVars_overlayLoadDelay=3000';
    var params = {};
    params.allowfullscreen = "true";
    var attributes = { id: "kickerplayer" };
    if (navigator.userAgent.indexOf("iPad") >= 0) //|| navigator.userAgent.indexOf("Safari")>=0
    {
        var html5player = "<div class=\"ovVideoHTML5Wrapper\"><div class=\"ovVideoHTML5Headline\"><span>" + headline + "</span></div>";
        html5player += "<video src=\"http://podcast.kicker.de/videocenter/" + videoid + "_996x560_H264_1400.mp4\" width=\"640\" height=\"360\" autoplay=\"true\" controls=\"controls\" >";
        //html5player += "<source src=\"http://podcast.kicker.de/videocenter/"+videoid+"_iphone.mp4\" type=\"video/mp4\" />";
        html5player += "This browser is not compatible with HTML 5";
        html5player += "</video></div>";
        document.getElementById('ovPopupPlayer').innerHTML = html5player;
        var videoCountUrl = ovToolkit.rootURL + '/news/videocount?id=' + videoid + '&format=ipad';
        document.getElementById('ad_count_frame').src = videoCountUrl;
    }
    //	else if (navigator.userAgent.indexOf("MSIE 9")>=0) // && navigator.userAgent.indexOf("Win64")>=0
    //	{
    //	    var html5player = '<div class="ovVideoHTML5Wrapper"><div class="ovVideoHTML5Headline"><span>'+headline+'</span></div>';
    //	    html5player += '<video src="http://podcast.kicker.de/videocenter/'+videoid+'_996x560_H264_1400.mp4" width="640" height="360" controls autoplay />';
    //        //html5player += '<div>This browser is not compatible with HTML 5..</div>';
    //        html5player += '</video></div>';
    //
    //	    document.getElementById('ovPopupPlayer').innerHTML = html5player;
    //	    var videoCountUrl = ovToolkit.rootURL+'/news/videocount?id='+videoid+'&format=ie9x64';
    //	    document.getElementById('ad_count_frame').src = videoCountUrl;
    //
    //	}
    else if (navigator.userAgent.indexOf("IE") >= 0) {
        document.getElementById('ovPopupPlayer').innerHTML = '<embed src="' + videoPlayer + '" name="flashVideoPlayer" id="flashVideoPlayer" type="application/x-shockwave-flash" width="909" height="381" pluginspage="http://www.macromedia.com/go/getflashplayer" quality="high" bgcolor="#000000" menu="false" allowScriptAccess="always" allowFullScreen="true" FlashVars="' + flashvars + '" wmode="opaque"><\/embed>';
    } else {
        document.getElementById('ovPopupPlayer').innerHTML = '<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab" id="flashVideoPlayer" width="909" height="381">\n<param name="movie" value="' + videoPlayer + '" />\n<param name="quality" value="high" />\n<param name="bgcolor" value="#000000" />\n<param name="menu" value="false" />\n<param name="allowScriptAccess" value="always" />\n<param name="allowFullScreen" value="true" />\n<param name="wmode" value="opaque">\n<param name="FlashVars" value="' + flashvars + '" />\n<embed src="' + videoPlayer + '" name="flashVideoPlayer" type="application/x-shockwave-flash" width="909" height="381" pluginspage="http://www.macromedia.com/go/getflashplayer" quality="high" bgcolor="#000000" menu="false" allowScriptAccess="always" allowFullScreen="true" FlashVars="' + flashvars + '" wmode="opaque"><\/embed>\n<\/object>';
    }
}
//Deklaration CompanionAd
//Displayregion zu Div Id auf der Site Unbefüllt lassen wenn Displayregion nicht gebraucht wird.
companion_bottom = "companion_bottom";
companion_left = "companion_left";
companion_right = "companion_right";
companion_top = "companion_top";
im_site_status = "";
function im_site_load() {
    im_site_status = "ready";
}
function addEvent(obj, evType, fn) {
    if (obj.addEventListener) {
        obj.addEventListener(evType, fn, false);
        return true;
    } else if (obj.attachEvent) {
        var r = obj.attachEvent("on" + evType, fn);
        return r;
    } else {
        return false;
    }
}
addEvent(window, 'load', im_site_load);
function im_companionad_call(im_DisplayRegion, im_CompanionWidth, im_CompanionHeight, im_ResourceType, im_ResourceContent, im_creativeType, im_AltText, im_CompanionClickThrough, im_AdParameters) {
    //alert('im_DisplayRegion : ' + im_DisplayRegion + '\n' + 'im_CompanionWidth : ' + im_CompanionWidth + '\n' +	'im_CompanionHeight : ' + im_CompanionHeight + '\n' + 'im_ResourceType : ' + im_ResourceType + '\n' + 'im_ResourceContent : ' + im_ResourceContent + '\n' + 'im_creativeType : ' + im_creativeType + '\n' + 'im_AltText : ' + im_AltText + '\n' + 'im_CompanionClickThrough : ' + im_CompanionClickThrough + '\n' +	'im_AdParameters : ' + im_AdParameters);
    switch (im_ResourceType) {
        case "Static":
            if (im_creativeType == "image/jpeg" || im_creativeType == "image/gif" || im_creativeType == "image/png") {
                im_companion_ad_content = '<a href="' + im_CompanionClickThrough + '" target="_blank"><img src="' + im_ResourceContent + '" width="' + im_CompanionWidth + '" height="' + im_CompanionHeight + '" alt="' + im_AltText + '" border="0"></a>';
            }
            if (im_creativeType == "application/x-shockwave-flash") {
                im_companion_ad_content = '<OBJECT id="adcompanionobject" CLASSID="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" WIDTH="' + im_CompanionWidth + '" HEIGHT="' + im_CompanionHeight + '" CODEBASE="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab"><PARAM NAME="MOVIE" VALUE="' + im_ResourceContent + '"><PARAM NAME="WMODE" value="opaque"><PARAM NAME="QUALITY" VALUE="high"><PARAM NAME="SCALE" VALUE="exactscale"><PARAM NAME="AllowScriptAccess" VALUE="always"><PARAM NAME="MENU" VALUE="FALSE"><PARAM NAME="FLASHVARS" VALUE="' + im_AdParameters + '"><EMBED SRC="' + im_ResourceContent + '" quality="high" width="' + im_CompanionWidth + '" height="' + im_CompanionHeight + '" type="application/x-shockwave-flash" pluginspage="http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Version=ShockwaveFlash" wmode="opaque" play="true" loop="true" allowscriptaccess="always" scale="exactscale" menu="false" name="adcompanionobject" FLASHVARS="' + im_AdParameters + '"></EMBED></OBJECT>';
            }
            break;
        case "Iframe":
            im_companion_ad_content = '<iframe src="' + im_ResourceContent + '" width="' + im_CompanionWidth + '" height="' + im_CompanionHeight + '" scrolling="no" marginheight="0" marginwidth="0" frameborder="0"></iframe>';
            break
        case "HTML":
            var im_regexp_check = /script/i;
            if (im_regexp_check.test(im_ResourceContent)) {
                im_companion_ad_content = '<div style="visibility:hidden;">Fehlerhaftes CompanionAd,JS gefunden</div>';
            } else {
                im_companion_ad_content = im_ResourceContent;
            }
            break;
        default:
            break;
    }
    //alert('im_companion_ad_content: ' + im_companion_ad_content);
    im_intervall = "";
    im_intervall = window.setInterval("im_write_out()", 100);
    im_DisplayRegion_save = im_DisplayRegion;
}
function im_write_out() {
    im_write_status = "";
    if (im_site_status == "ready") {
        window.clearInterval(im_intervall);
        switch (im_DisplayRegion_save) {
            case "companion_bottom":
                im_Div_Id = companion_bottom;
                break;
            case "companion_top":
                im_Div_Id = companion_top;
                break;
            case "companion_left":
                im_Div_Id = companion_left;
                break;
            case "companion_right":
                im_Div_Id = companion_right;
                break;
            default:
                im_write_status = "stop";
                break;
        }
        if (document.getElementById(im_Div_Id) && im_write_status != "stop") { document.getElementById(im_Div_Id).innerHTML = im_companion_ad_content; }
    } 
}
// ---------------------------------------------------------------------------
// Javascript:Flash
// ---------------------------------------------------------------------------
var ShockMode = 0;
var plugin = (navigator.mimeTypes && navigator.mimeTypes["application/x-shockwave-flash"]) ? navigator.mimeTypes["application/x-shockwave-flash"].enabledPlugin : 0;
// flash version
if (plugin && parseInt(plugin.description.substring(plugin.description.indexOf(".") - 1)) >= 6) {
    ShockMode = 1;
}
//for the mac
if (navigator.userAgent.indexOf("Mac") >= 0 && navigator.userAgent.indexOf("MSIE") >= 0 && navigator.userAgent.indexOf("4.5") >= 0) {
    ShockMode = 1;
}
else if (navigator.userAgent && navigator.userAgent.indexOf("MSIE") >= 0 && navigator.userAgent.indexOf("Windows") >= 0) {
    document.write('\<SCRIPT LANGUAGE="VBScript" \>');
    document.write('on error resume next \n');
    document.write('ShockMode = (IsObject(CreateObject("ShockwaveFlash.ShockwaveFlash.6")))\n');
    document.write('<\/SCR' + 'IPT>');
}
function Browser() {
    this.isIE = false;
    this.isNS = false;
    this.isOpera = false;
    this.isMozilla = false;
    this.isWin = false;
    this.isMac = false;
    this.isLinux = false;
    this.version = 0;
    this.isFlashed = false;
    var requiredFlashVersion = 6;
    var maxFlashVersion = 10;
    var agent = navigator.userAgent.toLowerCase();
    this.isIE = agent.indexOf("msie") != -1 && agent.indexOf("opera") == -1;
    this.isNS = (agent.indexOf("netscape") != -1 || navigator.appName == "Netscape") && agent.indexOf("opera") == -1;
    //in netscape4 "netscape" doesn't appear in navigator.userAgent
    this.isOpera = agent.indexOf("opera") != -1;
    this.isMozilla = agent.indexOf("mozilla") != -1;
    this.isKonqueror = agent.indexOf("konqueror") != -1;
    this.isWin = agent.indexOf("win") != -1;
    this.isMac = agent.indexOf("mac") != -1;
    this.isLinux = agent.indexOf("linux") != -1;
    var minor = parseFloat(navigator.appVersion);
    if (this.isNS) {
        if (minor >= 6) {
            this.version = 6;
        } else {
            this.version = minor;
        }
    } else if (this.isKonqueror) {
        this.version = minor;
    } else if (this.isIE) {
        if (agent.indexOf("msie 5") != -1 && minor == 4) {
            this.version = 5;
        } else {
            this.version = minor;
        }
    } else if (this.isOpera) {
        if (agent.indexOf("opera 2") != -1 || agent.indexOf("opera/2") != -1) {
            this.version = 2;
        }
        if (agent.indexOf("opera 3") != -1 || agent.indexOf("opera/3") != -1) {
            this.version = 3;
        }
        if (agent.indexOf("opera 4") != -1 || agent.indexOf("opera/4") != -1) {
            this.version = 4;
        }
        if (agent.indexOf("opera 5") != -1 || agent.indexOf("opera/5") != -1) {
            this.version = 5;
        }
        if (agent.indexOf("opera 6") != -1 || agent.indexOf("opera/6") != -1) {
            this.version = 6;
        }
    }
    if (this.isIE && this.isWin) {
        document.write('<SCR' + 'IPT LANGUAGE="VBScript" \> \n');
        document.write('on error resume next \n');
        for (i = requiredFlashVersion; i < maxFlashVersion + 1; i++) {
            document.write('flash' + i + 'Installed = false \n');
            document.write('flash' + i + 'Installed = (IsObject(CreateObject("ShockwaveFlash.ShockwaveFlash.' + i + '"))) \n');
        }
        document.write('</SCR' + 'IPT\> \n');
        for (i = requiredFlashVersion; i < maxFlashVersion + 1; i++) {
            if (eval("flash" + i + "Installed")) {
                this.isFlashed = true;
                break;
            }
        }
    } else if (navigator.plugins && navigator.plugins["Shockwave Flash"]) {
        var plugin = navigator.plugins["Shockwave Flash"];
        var actualVersion = plugin.description.charAt(plugin.description.indexOf(".") - 1);
        if (actualVersion == 0) {
            actualVersion = plugin.description.charAt(plugin.description.indexOf(".") - 2) + actualVersion
        }
        this.isFlashed = (parseInt(actualVersion) >= requiredFlashVersion);
    }
}
var myBrowser = new Browser();
// ---------------------------------------------------------------------------
// Javascript:Anylink
// ---------------------------------------------------------------------------
var disappeardelay = 250  //menu disappear speed onMouseout (in miliseconds)
var enableanchorlink = 0 //Enable or disable the anchor link when clicked on? (1=e,0=d)
var hidemenu_onclick = 1 //hide menu when user clicks within menu? (1=yes,0=no)
var ie5 = document.all
var ns6 = document.getElementById && !document.all
function getposOffset(what, offsettype) {
    var totaloffset = (offsettype == "left") ? what.offsetLeft : what.offsetTop;
    var parentEl = what.offsetParent;
    while (parentEl != null) {
        totaloffset = (offsettype == "left") ? totaloffset + parentEl.offsetLeft : totaloffset + parentEl.offsetTop;
        parentEl = parentEl.offsetParent;
    }
    return totaloffset;
}
function showhide(obj, e, visible, hidden) {
    if (ie5 || ns6) {
        dropmenuobj.style.left = dropmenuobj.style.top = -500
    }
    if (e.type == "click" && obj.visibility == hidden || e.type == "mouseover") {
        obj.visibility = visible
        if (document.getElementById('mid') && ie5) {
            document.getElementById('mid').style.visibility = 'hidden';
            document.getElementById('mid2').style.visibility = 'hidden';
        }
    }
    else if (e.type == "click") {
        obj.visibility = hidden
        if (document.getElementById('mid') && ie5) {
            document.getElementById('mid').style.visibility = 'visible';
            document.getElementById('mid2').style.visibility = 'visible';
        }
    }
}
function iecompattest() {
    return (document.compatMode && document.compatMode != "BackCompat") ? document.documentElement : document.body
}
function clearbrowseredge(obj, whichedge) {
    var edgeoffset = 0
    if (whichedge == "rightedge") {
        var windowedge = ie5 && !window.opera ? iecompattest().scrollLeft + iecompattest().clientWidth - 15 : window.pageXOffset + window.innerWidth - 15
        dropmenuobj.contentmeasure = dropmenuobj.offsetWidth
        if (windowedge - dropmenuobj.x < dropmenuobj.contentmeasure)
            edgeoffset = dropmenuobj.contentmeasure - obj.offsetWidth
    }
    else {
        var windowedge = ie5 && !window.opera ? iecompattest().scrollTop + iecompattest().clientHeight - 15 : window.pageYOffset + window.innerHeight - 18
        dropmenuobj.contentmeasure = dropmenuobj.offsetHeight
        //if (windowedge-dropmenuobj.y < dropmenuobj.contentmeasure)
        //edgeoffset=dropmenuobj.contentmeasure+obj.offsetHeight
    }
    return edgeoffset
}
function dropdownmenu(obj, e, dropmenuID) {
    return dropdownmenu2(obj, e, dropmenuID, 0, 0);
}
function dropdownmenu2(obj, e, dropmenuID, newleft, newright) {
    if (window.event) event.cancelBubble = true
    else if (e.stopPropagation) e.stopPropagation()
    if (typeof dropmenuobj != "undefined") {
        dropmenuobj.style.visibility = "hidden"
    }
    clearhidemenu()
    if (ie5 || ns6) {
        obj.onmouseout = delayhidemenu
        dropmenuobj = document.getElementById(dropmenuID)
        if (hidemenu_onclick) dropmenuobj.onclick = function () { dropmenuobj.style.visibility = 'hidden' }
        dropmenuobj.onmouseover = clearhidemenu
        dropmenuobj.onmouseout = ie5 ? function () { dynamichide(event) } : function (event) { dynamichide(event) }
        showhide(dropmenuobj.style, e, "visible", "hidden");
        dropmenuobj.style.position = "absolute";
        dropmenuobj.x = getposOffset(obj, "left") - parseInt(newleft);
        dropmenuobj.y = getposOffset(obj, "top") - parseInt(newright);
        dropmenuobj.style.left = dropmenuobj.x - clearbrowseredge(obj, "rightedge") + "px";
        dropmenuobj.style.top = dropmenuobj.y - clearbrowseredge(obj, "bottomedge") + obj.offsetHeight + "px";
        dropmenuobj.style.zIndex = "100";
    }
    return clickreturnvalue()
}
function dropdownsppinfo(obj, e, dropmenuID, newleft, newtop) {
    if (window.event) event.cancelBubble = true
    else if (e.stopPropagation) e.stopPropagation()
    if (typeof dropmenuobj != "undefined") {
        //hide previous menu
        dropmenuobj.style.visibility = "hidden"
    }
    clearhidemenu()
    if (ie5 || ns6) {
        obj.onmouseout = delayhidemenu
        dropmenuobj = document.getElementById(dropmenuID)
        if (hidemenu_onclick) dropmenuobj.onclick = function () { dropmenuobj.style.visibility = 'hidden' }
        dropmenuobj.onmouseover = clearhidemenu
        dropmenuobj.onmouseout = ie5 ? function () { dynamichide(event) } : function (event) { dynamichide(event) }
        showhide(dropmenuobj.style, e, "visible", "hidden")
        dropmenuobj.style.left = parseInt(newleft) + "px"
        dropmenuobj.style.top = parseInt(newtop) + "px"
    }
    return clickreturnvalue()
}
function rightmenu(obj, e, dropmenuID) {
    if (window.event) event.cancelBubble = true
    else if (e.stopPropagation) e.stopPropagation()
    if (typeof dropmenuobj != "undefined") //hide previous menu
    //dropmenuobj.style.visibility="hidden"
        clearhidemenu()
    if (ie5 || ns6) {
        obj.onmouseout = delayhidemenu
        dropmenuobj = document.getElementById(dropmenuID)
        if (hidemenu_onclick) dropmenuobj.onclick = function () { dropmenuobj.style.visibility = 'hidden' }
        dropmenuobj.onmouseover = clearhidemenu
        dropmenuobj.onmouseout = ie5 ? function () { dynamichide(event) } : function (event) { dynamichide(event) }
        showhide(dropmenuobj.style, e, "visible", "hidden")
        dropmenuobj.x = getposOffset(obj, "left")
        dropmenuobj.y = getposOffset(obj, "top")
        dropmenuobj.style.left = "120px"
        dropmenuobj.style.top = "0px"
    }
    return clickreturnvalue()
}
function clickreturnvalue() {
    if ((ie5 || ns6) && !enableanchorlink) return false
    else return true
}
function contains_ns6(a, b) {
    if (b) {
        while (b.parentNode)
            if ((b = b.parentNode) == a)
                return true;
        return false;
    }
}
function dynamichide(e) {
    if (ie5 && !dropmenuobj.contains(e.toElement))
        delayhidemenu()
    else if (ns6 && e.currentTarget != e.relatedTarget && !contains_ns6(e.currentTarget, e.relatedTarget))
        delayhidemenu()
}
function delayhidemenu() {
    delayhide = setTimeout("dropmenuobj.style.visibility='hidden'", disappeardelay)
    if (document.getElementById('mid') && ie5) {
        delayhide2 = setTimeout("document.getElementById('mid').style.visibility='visible'", disappeardelay)
        delayhide3 = setTimeout("document.getElementById('mid2').style.visibility='visible'", disappeardelay)
    }
}
function clearhidemenu() {
    if (typeof delayhide != "undefined")
        clearTimeout(delayhide)
    if (typeof delayhide2 != "undefined")
        clearTimeout(delayhide2)
    if (typeof delayhide3 != "undefined")
        clearTimeout(delayhide3)
}
// ---------------------------------------------------------------------------
// Javascript:Podcast activeX start
// ---------------------------------------------------------------------------
function AC_AddExtension(src, ext) {
    if (src.indexOf('?') != -1)
        return src.replace(/\?/, ext + '?');
    else
        return src + ext;
}
function AC_Generateobj(objAttrs, params, embedAttrs) {
    var str = '<object ';
    for (var i in objAttrs)
        str += i + '="' + objAttrs[i] + '" ';
    str += '>';
    for (var i in params)
        str += '<param name="' + i + '" value="' + params[i] + '" /> ';
    str += '<embed ';
    for (var i in embedAttrs)
        str += i + '="' + embedAttrs[i] + '" ';
    str += ' ></embed></object>';
    document.write(str);
}
function AC_FL_RunContent() {
    var ret =
AC_GetArgs
(arguments, ".swf", "movie", "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000", "application/x-shockwave-flash"
);
    AC_Generateobj(ret.objAttrs, ret.params, ret.embedAttrs);
}
function AC_SW_RunContent() {
    var ret =
AC_GetArgs
(arguments, ".dcr", "src", "clsid:166B1BCA-3F9C-11CF-8075-444553540000", null
);
    AC_Generateobj(ret.objAttrs, ret.params, ret.embedAttrs);
}
function AC_GetArgs(args, ext, srcParamName, classid, mimeType) {
    var ret = new Object();
    ret.embedAttrs = new Object();
    ret.params = new Object();
    ret.objAttrs = new Object();
    for (var i = 0; i < args.length; i = i + 2) {
        var currArg = args[i].toLowerCase();
        switch (currArg) {
            case "classid":
                break;
            case "pluginspage":
                ret.embedAttrs[args[i]] = args[i + 1];
                break;
            case "src":
            case "movie":
                args[i + 1] = AC_AddExtension(args[i + 1], ext);
                ret.embedAttrs["src"] = args[i + 1];
                ret.params[srcParamName] = args[i + 1];
                break;
            case "onafterupdate":
            case "onbeforeupdate":
            case "onblur":
            case "oncellchange":
            case "onclick":
            case "ondblClick":
            case "ondrag":
            case "ondragend":
            case "ondragenter":
            case "ondragleave":
            case "ondragover":
            case "ondrop":
            case "onfinish":
            case "onfocus":
            case "onhelp":
            case "onmousedown":
            case "onmouseup":
            case "onmouseover":
            case "onmousemove":
            case "onmouseout":
            case "onkeypress":
            case "onkeydown":
            case "onkeyup":
            case "onload":
            case "onlosecapture":
            case "onpropertychange":
            case "onreadystatechange":
            case "onrowsdelete":
            case "onrowenter":
            case "onrowexit":
            case "onrowsinserted":
            case "onstart":
            case "onscroll":
            case "onbeforeeditfocus":
            case "onactivate":
            case "onbeforedeactivate":
            case "ondeactivate":
            case "type":
            case "codebase":
                ret.objAttrs[args[i]] = args[i + 1];
                break;
            case "width":
            case "height":
            case "align":
            case "vspace":
            case "hspace":
            case "class":
            case "title":
            case "accesskey":
            case "name":
            case "id":
            case "tabindex":
                ret.embedAttrs[args[i]] = ret.objAttrs[args[i]] = args[i + 1];
                break;
            default:
                ret.embedAttrs[args[i]] = ret.params[args[i]] = args[i + 1];
        }
    }
    ret.objAttrs["classid"] = classid;
    if (mimeType) ret.embedAttrs["type"] = mimeType;
    return ret;
}
// ---------------------------------------------------------------------------
// Javascript:Tooltip
// ---------------------------------------------------------------------------
/***********************************************
* Cool DHTML tooltip script II- &copy; Dynamic Drive DHTML code library (www.dynamicdrive.com)
* This notice MUST stay intact for legal use
* Visit Dynamic Drive at http://www.dynamicdrive.com/ for full source code
***********************************************/
var offsetfromcursorX = 12 //Customize x offset of tooltip
var offsetfromcursorY = 10 //Customize y offset of tooltip
var offsetdivfrompointerX = 10 //Customize x offset of tooltip DIV relative to pointer image
var offsetdivfrompointerY = 14 //Customize y offset of tooltip DIV relative to pointer image. Tip: Set it to (height_of_pointer_image-1).
var ie = document.all
var ns6 = document.getElementById && !document.all
var enabletip = false
function ietruebody() {
    return (document.compatMode && document.compatMode != "BackCompat") ? document.documentElement : document.body
}
function ddrivetip(thetext, thewidth, thecolor) {
    if (ie || ns6)
        var tipobj = document.all ? document.all["dhtmltooltip"] : document.getElementById ? document.getElementById("dhtmltooltip") : ""
    var pointerobj = document.all ? document.all["dhtmlpointer"] : document.getElementById ? document.getElementById("dhtmlpointer") : ""
    if (ns6 || ie) {
        if (typeof thewidth != "undefined") tipobj.style.width = thewidth + "px"
        if (typeof thecolor != "undefined" && thecolor != "") tipobj.style.backgroundColor = thecolor
        tipobj.innerHTML = thetext
        enabletip = true
        return false
    }
}
function positiontip(e) {
    if (enabletip) {
        if (ie || ns6)
            var tipobj = document.all ? document.all["dhtmltooltip"] : document.getElementById ? document.getElementById("dhtmltooltip") : ""
        var pointerobj = document.all ? document.all["dhtmlpointer"] : document.getElementById ? document.getElementById("dhtmlpointer") : ""
        var nondefaultpos = false
        var curX = (ns6) ? e.pageX : event.clientX + ietruebody().scrollLeft;
        var curY = (ns6) ? e.pageY : event.clientY + ietruebody().scrollTop;
        //Find out how close the mouse is to the corner of the window
        var winwidth = ie && !window.opera ? ietruebody().clientWidth : window.innerWidth - 20
        var winheight = ie && !window.opera ? ietruebody().clientHeight : window.innerHeight - 20
        var rightedge = ie && !window.opera ? winwidth - event.clientX - offsetfromcursorX : winwidth - e.clientX - offsetfromcursorX
        var bottomedge = ie && !window.opera ? winheight - event.clientY - offsetfromcursorY : winheight - e.clientY - offsetfromcursorY
        var leftedge = (offsetfromcursorX < 0) ? offsetfromcursorX * (-1) : -1000
        //if the horizontal distance isn't enough to accomodate the width of the context menu
        if (rightedge < tipobj.offsetWidth) {
            //move the horizontal position of the menu to the left by it's width
            tipobj.style.left = curX - tipobj.offsetWidth + "px"
            nondefaultpos = true
        }
        else if (curX < leftedge)
            tipobj.style.left = "5px"
        else {
            //position the horizontal position of the menu where the mouse is positioned
            tipobj.style.left = curX + offsetfromcursorX - offsetdivfrompointerX + "px"
            pointerobj.style.left = curX + offsetfromcursorX + "px"
        }
        //same concept with the vertical position
        if (bottomedge < tipobj.offsetHeight) {
            tipobj.style.top = curY - tipobj.offsetHeight - offsetfromcursorY + "px"
            nondefaultpos = true
        }
        else {
            tipobj.style.top = curY + offsetfromcursorY + offsetdivfrompointerY + "px"
            pointerobj.style.top = curY + offsetfromcursorY + "px"
        }
        tipobj.style.visibility = "visible"
        if (!nondefaultpos)
            pointerobj.style.visibility = "visible"
        else
            pointerobj.style.visibility = "hidden"
    }
}
function hideddrivetip() {
    if (ns6 || ie) {
        if (ie || ns6)
            var tipobj = document.all ? document.all["dhtmltooltip"] : document.getElementById ? document.getElementById("dhtmltooltip") : ""
        var pointerobj = document.all ? document.all["dhtmlpointer"] : document.getElementById ? document.getElementById("dhtmlpointer") : ""
        enabletip = false
        tipobj.style.visibility = "hidden"
        pointerobj.style.visibility = "hidden"
        tipobj.style.left = "-1000px"
        tipobj.style.backgroundColor = ''
        tipobj.style.width = ''
    }
}
document.onmousemove = positiontip
/** ----------------------------------------------------------------------------------------------------------------------------------
* SWFObject v1.5.1: Flash Player detection and embed
*
*
*
*
*/
if (typeof deconcept == "undefined") var deconcept = {};
if (typeof deconcept.util == "undefined") deconcept.util = {};
if (typeof deconcept.SWFObjectUtil == "undefined") deconcept.SWFObjectUtil = {};
deconcept.SWFObject = function (swf, id, w, h, ver, c, quality, xiRedirectUrl, redirectUrl, detectKey) {
    if (!document.getElementById) { return; }
    this.DETECT_KEY = detectKey ? detectKey : 'detectflash';
    this.skipDetect = deconcept.util.getRequestParameter(this.DETECT_KEY);
    this.params = {};
    this.variables = {};
    this.attributes = [];
    if (swf) { this.setAttribute('swf', swf); }
    if (id) { this.setAttribute('id', id); }
    if (w) { this.setAttribute('width', w); }
    if (h) { this.setAttribute('height', h); }
    if (ver) { this.setAttribute('version', new deconcept.PlayerVersion(ver.toString().split("."))); }
    this.installedVer = deconcept.SWFObjectUtil.getPlayerVersion();
    if (!window.opera && document.all && this.installedVer.major > 7) {
        // only add the onunload cleanup if the Flash Player version supports External Interface and we are in IE
        // fixes bug in some fp9 versions see http://blog.deconcept.com/2006/07/28/swfobject-143-released/
        if (!deconcept.unloadSet) {
            deconcept.SWFObjectUtil.prepUnload = function () {
                __flash_unloadHandler = function () { };
                __flash_savedUnloadHandler = function () { };
                window.attachEvent("onunload", deconcept.SWFObjectUtil.cleanupSWFs);
            }
            window.attachEvent("onbeforeunload", deconcept.SWFObjectUtil.prepUnload);
            deconcept.unloadSet = true;
        }
    }
    var q = quality ? quality : 'high';
    this.addParam('quality', q);
    this.setAttribute('useExpressInstall', false);
    this.setAttribute('doExpressInstall', false);
    var xir = (xiRedirectUrl) ? xiRedirectUrl : window.location;
    this.setAttribute('xiRedirectUrl', xir);
    this.setAttribute('redirectUrl', '');
    if (redirectUrl) { this.setAttribute('redirectUrl', redirectUrl); }
}
deconcept.SWFObject.prototype = {
    useExpressInstall: function (path) {
        this.xiSWFPath = !path ? "expressinstall.swf" : path;
        this.setAttribute('useExpressInstall', true);
    }, setAttribute: function (name, value) {
        this.attributes[name] = value;
    }, getAttribute: function (name) {
        return this.attributes[name] || "";
    }, addParam: function (name, value) {
        this.params[name] = value;
    }, getParams: function () {
        return this.params;
    }, addVariable: function (name, value) {
        this.variables[name] = value;
    }, getVariable: function (name) {
        return this.variables[name] || "";
    }, getVariables: function () {
        return this.variables;
    }, getVariablePairs: function () {
        var variablePairs = [];
        var key;
        var variables = this.getVariables();
        for (key in variables) {
            variablePairs[variablePairs.length] = key + "=" + variables[key];
        }
        return variablePairs;
    }, getSWFHTML: function () {
        var swfNode = "";
        if (navigator.plugins && navigator.mimeTypes && navigator.mimeTypes.length) { // netscape plugin architecture
            if (this.getAttribute("doExpressInstall")) {
                this.addVariable("MMplayerType", "PlugIn");
                this.setAttribute('swf', this.xiSWFPath);
            }
            swfNode = '<embed type="application/x-shockwave-flash" wmode="transparent" src="' + this.getAttribute('swf') + '" width="' + this.getAttribute('width') + '" height="' + this.getAttribute('height') + '" style="' + (this.getAttribute('style') || "") + '"';
            swfNode += ' id="' + this.getAttribute('id') + '" name="' + this.getAttribute('id') + '" ';
            var params = this.getParams();
            for (var key in params) { swfNode += [key] + '="' + params[key] + '" '; }
            var pairs = this.getVariablePairs().join("&");
            if (pairs.length > 0) { swfNode += 'flashvars="' + pairs + '"'; }
            swfNode += '/>';
        } else { // PC IE
            if (this.getAttribute("doExpressInstall")) {
                this.addVariable("MMplayerType", "ActiveX");
                this.setAttribute('swf', this.xiSWFPath);
            }
            swfNode = '<object id="' + this.getAttribute('id') + '" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="' + this.getAttribute('width') + '" height="' + this.getAttribute('height') + '" style="' + (this.getAttribute('style') || "") + '">';
            swfNode += '<param name="movie" value="' + this.getAttribute('swf') + '" /> <param name="wmode" value="transparent" />';
            var params = this.getParams();
            for (var key in params) {
                swfNode += '<param name="' + key + '" value="' + params[key] + '" /> <param name="wmode" value="transparent" />';
            }
            var pairs = this.getVariablePairs().join("&");
            if (pairs.length > 0) { swfNode += '<param name="flashvars" value="' + pairs + '" />'; }
            swfNode += "</object>";
        }
        return swfNode;
    }, write: function (elementId) {
        if (this.getAttribute('useExpressInstall')) {
            // check to see if we need to do an express install
            var expressInstallReqVer = new deconcept.PlayerVersion([6, 0, 65]);
            if (this.installedVer.versionIsValid(expressInstallReqVer) && !this.installedVer.versionIsValid(this.getAttribute('version'))) {
                this.setAttribute('doExpressInstall', true);
                this.addVariable("MMredirectURL", escape(this.getAttribute('xiRedirectUrl')));
                document.title = document.title.slice(0, 47) + " - Flash Player Installation";
                this.addVariable("MMdoctitle", document.title);
            }
        }
        if (this.skipDetect || this.getAttribute('doExpressInstall') || this.installedVer.versionIsValid(this.getAttribute('version'))) {
            var n = (typeof elementId == 'string') ? document.getElementById(elementId) : elementId;
            n.innerHTML = this.getSWFHTML();
            return true;
        } else {
            if (this.getAttribute('redirectUrl') != "") {
                document.location.replace(this.getAttribute('redirectUrl'));
            }
        }
        return false;
    }
}
/* ---- detection functions ---- */
deconcept.SWFObjectUtil.getPlayerVersion = function () {
    var PlayerVersion = new deconcept.PlayerVersion([0, 0, 0]);
    if (navigator.plugins && navigator.mimeTypes.length) {
        var x = navigator.plugins["Shockwave Flash"];
        if (x && x.description) {
            PlayerVersion = new deconcept.PlayerVersion(x.description.replace(/([a-zA-Z]|\s)+/, "").replace(/(\s+r|\s+b[0-9]+)/, ".").split("."));
        }
    } else if (navigator.userAgent && navigator.userAgent.indexOf("Windows CE") >= 0) { // if Windows CE
        var axo = 1;
        var counter = 3;
        while (axo) {
            try {
                counter++;
                axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash." + counter);
                //				document.write("player v: "+ counter);
                PlayerVersion = new deconcept.PlayerVersion([counter, 0, 0]);
            } catch (e) {
                axo = null;
            }
        }
    } else { // Win IE (non mobile)
        // do minor version lookup in IE,but avoid fp6 crashing issues
        // see http://blog.deconcept.com/2006/01/11/getvariable-setvariable-crash-internet-explorer-flash-6/
        try {
            var axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
        } catch (e) {
            try {
                var axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
                PlayerVersion = new deconcept.PlayerVersion([6, 0, 21]);
                axo.AllowScriptAccess = "always"; // error if player version < 6.0.47 (thanks to Michael Williams @ Adobe for this code)
            } catch (e) {
                if (PlayerVersion.major == 6) {
                    return PlayerVersion;
                }
            }
            try {
                axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
            } catch (e) { }
        }
        if (axo != null) {
            PlayerVersion = new deconcept.PlayerVersion(axo.GetVariable("$version").split(" ")[1].split(","));
        }
    }
    return PlayerVersion;
}
deconcept.PlayerVersion = function (arrVersion) {
    this.major = arrVersion[0] != null ? parseInt(arrVersion[0]) : 0;
    this.minor = arrVersion[1] != null ? parseInt(arrVersion[1]) : 0;
    this.rev = arrVersion[2] != null ? parseInt(arrVersion[2]) : 0;
}
deconcept.PlayerVersion.prototype.versionIsValid = function (fv) {
    if (this.major < fv.major) return false;
    if (this.major > fv.major) return true;
    if (this.minor < fv.minor) return false;
    if (this.minor > fv.minor) return true;
    if (this.rev < fv.rev) return false;
    return true;
}
/* ---- get value of query string param ---- */
deconcept.util = {
    getRequestParameter: function (param) {
        var q = document.location.search || document.location.hash;
        if (param == null) { return q; }
        if (q) {
            var pairs = q.substring(1).split("&");
            for (var i = 0; i < pairs.length; i++) {
                if (pairs[i].substring(0, pairs[i].indexOf("=")) == param) {
                    return pairs[i].substring((pairs[i].indexOf("=") + 1));
                }
            }
        }
        return "";
    }
}
/* fix for video streaming bug */
deconcept.SWFObjectUtil.cleanupSWFs = function () {
    var objects = document.getElementsByTagName("OBJECT");
    for (var i = objects.length - 1; i >= 0; i--) {
        objects[i].style.display = 'none';
        for (var x in objects[i]) {
            if (typeof objects[i][x] == 'function') {
                objects[i][x] = function () { };
            }
        }
    }
}
/* add document.getElementById if needed (mobile IE < 5) */
if (!document.getElementById && document.all) { document.getElementById = function (id) { return document.all[id]; } }
/* add some aliases for ease of use/backwards compatibility */
var getQueryParamValue = deconcept.util.getRequestParameter;
var FlashObject = deconcept.SWFObject; // for legacy support
var SWFObject = deconcept.SWFObject;
/*--------------------------------------------------------------------------------------------------*/
function now() {
    var Act = new Date();
    return Act;
}
function sleep(seconds, minutes, hours, days, month, years) {
    var DelaySeconds = seconds; /* 5 Sekunden Verzoegerung */
    var DelayMinutes = minutes; /* 0 Minuten  Verzoegerung */
    var DelayHours = hours; /* 0 Stunden  Verzoegerung */
    var DelayDays = days; /* 0 Tage     Verzoegerung */
    var DelayMonths = month; /* 0 Monate   Verzoegerung */
    var DelayYears = years; /* 0 Jahre    Verzoegerung */
    var ActTime = new Date();
    var Seconds = ActTime.getSeconds();
    var Minutes = ActTime.getMinutes();
    var Hours = ActTime.getHours();
    var Days = ActTime.getDate();
    var Months = ActTime.getMonth();
    var Years = ActTime.getYear();
    var FinalTime = ActTime;
    if ((60 - Seconds) < DelaySeconds) {
        Seconds = Seconds + DelaySeconds - 60;
        DelayMinutes = DelayMinutes + 1;
    }
    else {
        Seconds = Seconds + DelaySeconds;
    }
    if ((60 - Minutes) < DelayMinutes) {
        Minutes = Minutes + DelayMinutes - 60;
        DelayHours = DelayHours + 1;
    }
    else {
        DelayMinutes = Minutes + DelayMinutes;
    }
    if ((24 - Hours) < DelayHours) {
        Hours = Hours + DelayHours - 24;
        DelayDays = DelayDays + 1;
    }
    else {
        DelayHours = Hours + DelayHours;
    }
    switch (Months) {
        case 0, 2, 4, 6, 7, 9, 11:
            if ((31 - Days) < DelayDays) {
                Days = Days + DelayDays - 31;
                DelayMonths = DelayMonths + 1;
            }
            else {
                DelayDays = Days + DelayDays;
            }
            break;
        case 3, 5, 8, 10:
            if ((30 - Days) < DelayDays) {
                Days = Days + DelayDays - 30;
                DelayMonths = DelayMonths + 1;
            }
            else {
                DelayDays = Days + DelayDays;
            }
            break;
        case 1:
            if ((Year % 400) == 0) {
                if ((29 - Days) < DelayDays) {
                    Days = Days + DelayDays - 29;
                    DelayMonths = DelayMonths + 1;
                }
                else {
                    DelayDays = Days + DelayDays;
                }
            }
            else {
                if (((Year % 100) == 0)((Year % 4) != 0)) {
                    if ((28 - Days) < DelayDays) {
                        Days = Days + DelayDays - 28;
                        DelayMonths = DelayMonths + 1;
                    }
                    else {
                        DelayDays = Days + DelayDays;
                    }
                }
                else {
                    if ((29 - Days) < DelayDays) {
                        Days = Days + DelayDays - 29;
                        DelayMonths = DelayMonths + 1;
                    }
                    else {
                        DelayDays = Days + DelayDays;
                    }
                }
            }
            break;
    }
    if ((11 - Months) < DelayMonths) {
        Months = Months + DelayMonths - 24;
        DelayYears = DelayYears + 1;
    }
    else {
        DelayMonths = Months + DelayMonths;
    }
    Years = Years + DelayYears;
    FinalTime.setSeconds(Seconds);
    FinalTime.setMinutes(Minutes);
    FinalTime.setHours(Hours);
    FinalTime.setDate(Days);
    FinalTime.setMonth(Months);
    FinalTime.setYear(Years);
    while (now() < FinalTime) {
    }
}
function ovSlideDownCloseOpenItemsBefore(index, controlname, classPrefix) {
    ovSlideDown(index, controlname, classPrefix);
}
function ovSlideDownTable(index, controlname, container, urlres) {
    var link = $(controlname + index);
    var linkcontainer = $(container + index);
    var td = $('td_liga_' + index);
    var separator = $('sep_' + index);
    var img = $('directionimg_' + index);
    if (link) {
        Effect.toggle(container + index, 'blind', { duration: 0.5 });
        if (linkcontainer.style.display == 'none') {
            if (separator) {
                separator.style.borderBottomColor = "#000000";
            }
            img.src = urlres + "580-ic-swing-up.png";
        } else {
            if (separator) {
                separator.style.borderBottomColor = "#e7e7e7";
            }
            img.src = urlres + "580-ic-swing-down.png";
        }
    }
}
function ovSlideDown(index, controlname, classPrefix) {
    var link = $('a_' + controlname + index);
    if (link) {
        Effect.toggle(controlname + index, 'blind', { duration: 0.5 });
        if (link.className.toLowerCase().indexOf("div") > -1) {
            link = $('div_' + controlname + index);
            if (link) {
                if (link.className == 'auf' + classPrefix)
                    link.className = 'zu' + classPrefix;
                else
                    link.className = 'auf' + classPrefix;
            }
        }
        else {
            if (link.className == 'auf' + classPrefix)
                link.className = 'zu' + classPrefix;
            else
                link.className = 'auf' + classPrefix;
        }
    }
}
function ShowHideList(listID) {
    var list = $(listID);
    if (list) {
        if (list.style.display == 'none') {
            if (ovDLLastObject != null) { ovAjax.HideElem(ovDLLastObject); }
            ovDLLastObject = listID;
            ovAjax.ShowElem(listID);
            list.setAttribute('visible', "1");
            var dl = list.getElementsByTagName('DL')[0];
            if (dl != "undefined") {
                if (dl.offsetHeight > '285') {
                    dl.style.height = '285px';
                    if (navigator.userAgent.indexOf("MSIE 6.0") != -1) {
                        dl.style.width = '125px';
                    }
                }
            }
        }
        else {
            ovAjax.HideElem(listID);
            ovDLLastObject = null;
            list.setAttribute('visible', "0");
        }
    }
}
function ShowHideList2(elem, listID) {
    var list = $(listID);
    if (list) {
        list.style.left = getposOffset(elem, "left"); //(elem.offsetLeft;
        if (list.style.display == 'none') {
            ovAjax.ShowElem(listID);
        }
        else {
            ovAjax.HideElem(listID);
        }
    }
}
function HideList(listID) {
    var list = $(listID);
    if (list) {
        ovAjax.HideElem(listID);
    }
}
function debugddl(text) {
    //$('Anzsteuerung1').innerHTML += text + "<br>";
}
var selectTimer;
var selectedSelect;
function SelectOutList(listID) {
    return;
    if (navigator.userAgent.indexOf("MSIE 6.0") != -1) { return; }
    var select = $(listID);
    if (select.getAttribute('visible') == '1') {
        selectedSelect = select;
        selectTimer = setTimeout('CloseSelect()', 500);
    }
}
function CloseSelect() {
    return;
    if (navigator.userAgent.indexOf("MSIE 6.0") != -1) { return; }
    var select = selectedSelect;
    select.style.visibility = 'hidden';
    select.style.display = 'none';
    select.setAttribute('visible', "0");
    select.setAttribute('visible', "0");
}
function dontCloseSelect() {
    return;
    if (navigator.userAgent.indexOf("MSIE 6.0") != -1) { return; }
    clearTimeout(selectTimer);
}
//Globale Variabeln für die DL-Listenfunktion
var ovDLLastObject; //muss beim Öffnen der DL-Box gefüllt werden. Beim Schließen wieder auf null.
var ovDLCharCode = "";
var ovDLLastTime = new Date().getTime() / 1000;
var ovDLDelay = 2; //Verzögerung in Sek. für die Erfassung zweier Eingaben.
//keypress-Event registrieren
document.observe('keypress', function (e) {
    //Key-Prüfung nur durchführen,wenn eine DL-Box geöften ist und existiert.
    if (ovDLLastObject != null && $(ovDLLastObject)) {
        var dlList = ovDLLastObject;
        //KeyCode und Character ermitteln
        var keyCode;
        if (!e) var e = window.event;
        if (e.keyCode) { keyCode = e.keyCode; } else if (e.which) { keyCode = e.which; }
        var character = String.fromCharCode(keyCode);
        var timeNow = new Date().getTime() / 1000;
        if (timeNow - ovDLLastTime < ovDLDelay && ovDLCharCode.length == 1) { ovDLCharCode += character; } else { ovDLCharCode = character; }
        ovDLLastTime = timeNow;
        //DL-Element
        var dl = $(dlList).getElementsByTagName('DL')[0];
        if (dl != "undefined") {
            var dlItems = dl.childNodes;
            //Alle DT-Elemente durchlaufen und innerHTML des Kindelements auf Übereinstimmung prüfen und focus setzen.
            for (var i = 0; i < dlItems.length; i++) {
                if (dlItems[i].nodeName == 'DT') {
                    if (dlItems[i].childNodes[0].innerHTML.toLowerCase().indexOf(ovDLCharCode) == 0) {
                        dlItems[i].childNodes[0].focus();
                        break;
                    }
                }
            }
        }
    }
});
//------------------------------------------------------------------------------------------
//Slider Zusatzfunktionen
//------------------------------------------------------------------------------------------
function SetDefaultValues(boxLeft, sliderLeft) {
    if (parseInt(sliderLeft) > 461) {
        var mySlider = $('myslider');
        mySlider.style.left = 461 + 'px';
    }
    box.setStyle({ left: boxLeft + 'px' });
}
function MoveRight(moveThis) {
    var myBox = $('slidcont');
    var mySlider = $('myslider');
    var newleft = parseInt(myBox.style.left) - moveThis;
    if (newleft < -boxwidth) {
        newleft = -boxwidth;
    }
    var sliderPos = parseInt(parseInt(newleft) / parseInt(boxwidth) * -465);
    if (parseInt(sliderPos) > 461) {
        sliderPos = 461;
    }
    myBox.setStyle({ left: newleft + 'px' });
    mySlider.style.left = parseInt(sliderPos) + 'px';
}
function MoveLeft(moveThis) {
    var myBox = $('slidcont');
    var mySlider = $('myslider');
    var newleft = parseInt(myBox.style.left) + moveThis;
    if (newleft > 0) {
        newleft = 0;
    }
    myBox.setStyle({ left: newleft + 'px' });
    mySlider.style.left = parseInt(parseInt(newleft) / parseInt(boxwidth) * -465) + 'px';
}
function MoveLeft_Vereinsbilanz(moveThis) {
    MoveLeft(moveThis);
    saisonIndex++;
    ovSlideChangeVereinsBilanz(saisonIndex, vrnID);
}
function SlideshowMoveRight(moveThis) {
    var myBox = $('slidcont');
    var mySlider = $('myslider');
    var newleft = parseInt(myBox.style.left) - moveThis;
    if (newleft < -boxwidth) {
        newleft = -boxwidth;
    }
    var sliderPos = parseInt(parseInt(newleft) / parseInt(boxwidth) * -841);
    if (parseInt(sliderPos) > 806) {
        sliderPos = 806;
    }
    myBox.setStyle({ left: newleft + 'px' });
    mySlider.style.left = parseInt(sliderPos) + 'px';
}
function SlideshowMoveLeft(moveThis) {
    var myBox = $('slidcont');
    var mySlider = $('myslider');
    var newleft = parseInt(myBox.style.left) + moveThis;
    if (newleft > 0) {
        newleft = 0;
    }
    myBox.setStyle({ left: newleft + 'px' });
    mySlider.style.left = parseInt(parseInt(newleft) / parseInt(boxwidth) * -841) + 'px';
}
function SelAllRessorts(form) {
    var ctrl = $('allressorts');
    if (ctrl && ctrl.checked == true) {
        for (i = 0; i < form.length; i++) {
            if (form[i].name == 'chkressorts') {
                form[i].checked = true;
            }
        }
    }
}
//------------------------------------------------------------------------------------------
//Shadowbox-IVW-Aufruf
//------------------------------------------------------------------------------------------
Event.observe(window, 'load', function () {
    var url = document.URL;
    if (url.indexOf('startseite.html') == -1 && url.indexOf('matchkalender') == -1 && url.indexOf('livescores') == -1 &&
url.indexOf('livematch') == -1 && url.indexOf('livekonferenz') == -1 && document.URL.indexOf('.html') > -1 && $('ovContent')) {
        $('ovContent').select('[rel^=shadowbox]').each(function (element) {
            $(element).observe('click', function (event) {
                ovAjax.SetIVW('');
            });
        })
    }
});
//------------------------------------------------------------------------------------------
//DropDown-Navi
//------------------------------------------------------------------------------------------
Event.observe(window, 'load', function () {
    if ($('ovToolsNaviDD')) {
        $('ovToolsNaviDD').select('[id^=ovDDNav]').each(function (element) {
            $(element).observe('mouseover', function (event) {
                var element = event.element();
                Effect.Queues.get(element.id).invoke('cancel');
                new Effect.Morph(element.id, { style: 'height:79px;', duration: 0.3, queue: { scope: element.id} });
            });
            $(element).observe('mouseout', function (event) {
                var element = event.element();
                Effect.Queues.get(element.id).invoke('cancel');
                new Effect.Morph(element.id, { style: 'height:12px;', duration: 0.3, queue: { scope: element.id} });
            });
        })
    }
});
//------------------------------------------------------------------------------------------
//IE9 Features
//------------------------------------------------------------------------------------------
var ovLtGoalAlert = '';
var ovLtCheckAlert;
Event.observe(window, 'load', function () {
    try {
        if (window.external.msIsSiteMode() == false) {
            ovIE9ShowSiteModeBtn();
        } else {
        }
        ovIE9SetJumpList();
        ovCheckLiveTickerAlert();
    }
    catch (ex) {   //SiteMode ist not supported;
        return;
    }
});
Event.observe(window, 'mssitemodeinstalled', function () {
    ovIE9HideSiteModeBtn();
});
function ovIE9ShowSiteModeBtn() {
    $("ovBranding").innerHTML += '<style type="text/css">.ovSearch {width:400px;} #ovIE9SiteModeBtn{background:url("http://mediadb.kicker.de/library/image/bg-login.png") no-repeat scroll 0 0 transparent;height:43px;left:-20px;padding-top:4px;position:relative;text-align:center;top:28px;width:143px;} #ovIE9SiteModeBtn a {color:#FFFFFF;font-size:0.82em;}</style>';
    $("ovBranding").innerHTML += '<div id="ovIE9SiteModeBtn"><img src="http://mediadb.kicker.de/library/image/favicon/ie9-logo.png" alt="" />&nbsp;<a onclick="ovIE9AddtoSiteMode();" href="#">kicker.de Ihrem Startmenü hinzufügen!</a></div>';
}
function ovIE9HideSiteModeBtn() {
    $("ovIE9SiteModeBtn").hide();
}
function ovIE9AddtoSiteMode() {
    try {
        window.external.msAddSiteMode();
    } catch (ex) {
        // Site Mode not supported.
    }
}
function ovIE9SetJumpList() {
    //Custom JumpList
    window.external.msSiteModeCreateJumpList("Top Links");
    window.external.msSiteModeAddJumpListItem('Community', 'http://community.kicker.de/community/', 'http://mediadb.kicker.de/library/image/favicon/toolbar-community-s.ico');
    window.external.msSiteModeAddJumpListItem('Games', 'http://www.kicker.de/games/startseite/gamesstartseite.html', 'http://mediadb.kicker.de/library/image/favicon/toolbar-games-s.ico');
    window.external.msSiteModeAddJumpListItem('Video', 'http://www.kicker.de/news/video.html', 'http://mediadb.kicker.de/library/image/favicon/toolbar-video-s.ico');
    window.external.msSiteModeAddJumpListItem('Livescores', 'http://www.kicker.de/news/live-news/livescores/livescores_fussball.html', 'http://mediadb.kicker.de/library/image/favicon/toolbar-live-s.ico');
    window.external.msSiteModeAddJumpListItem('News', 'http://www.kicker.de/', 'http://mediadb.kicker.de/library/image/favicon/toolbar-news-s.ico');
    window.external.msSiteModeShowJumplist();
}
function ovCheckLiveTickerAlert() {
    //IconOverlay for LiveTicker
    var docUrl = document.URL.toLowerCase();
    if (docUrl.indexOf("livematch") > -1 || docUrl.indexOf("livekonferenz") > -1) {
        $('tb_printtopa').observe('mouseover', function (event) {
            window.external.msSiteModeSetIconOverlay('http://mediadb.kicker.de/library/image/favicon/tooor-alert2.ico', 'Tooor');
        });
        if (ovLtGoalAlert == '') {
            var jetzt = new Date();
            ovLtGoalAlert = jetzt;
            ovLtCheckAlert = setInterval(ovLtCheckGoals, 1 * 60 * 1000);
        }
    }
}
function ovLtCheckGoals() {
    new Ajax.Request(ovAjax.rootURL + "/rkajax/ajax.ashx?ajaxtype=livegoalalert&" + queryString, { method: 'get', onSuccess: ovLtGoalsRefresh });
}
function ovLtGoalsRefresh(transport) {
    var newResponse = transport.responseText;
    if (newResponse.length > 0) {
        var lastGoal = Date.parse(newResponse); //"March 10,1998 22:48:00");
        var lastUserGoal = Date.parse(ovLtGoalAlert);
        //alert("newResponse: "+newResponse + " ovLtGoalAlert: " + ovLtGoalAlert + " lastGoal: "+lastGoal + " lastUserGoal: "+lastUserGoal );
        if (lastGoal > lastUserGoal) {
            //Make an Alert and save the last goal.
            ovLtGoalAlert = newResponse;
            try {
                window.external.msSiteModeSetIconOverlay('http://mediadb.kicker.de/library/image/favicon/tooor-alert2.ico', 'Tooor');
            } catch (ex) {
                // Site Mode not supported.
            }
            //alert("tor");
        }
    }
}
//------------------------------------------------------------------------------------------
//Suche
//------------------------------------------------------------------------------------------
function createCookie(name, value, days) {
    if (days) {
        var date = new Date();
        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
        var expires = "; expires=" + date.toGMTString();
    }
    else expires = "";
    document.cookie = name + "=" + value + expires + "; path=/";
}
function SucheVerfeinernClick() {
    var detailCtrl = $('suchdetails');
    if (detailCtrl) {
        var suchhilfeCtrl = $('suchhilfeCtrl');
        if (detailCtrl.style.display == 'none') {
            suchhilfeCtrl.style.display = 'none';
            createCookie('erweitertesuche', '1');
            if ($('datepicker-opener-suchevon') == null) {
                var datepicker = new DatePicker({ relative: 'suchevon', language: 'de' });
                var datepicker2 = new DatePicker({ relative: 'suchebis', language: 'de' });
            }
        }
        else {
            suchhilfeCtrl.style.display = 'block';
            createCookie('erweitertesuche', '0');
        }
        detailCtrl.toggle();
    }
}
function SucheShowHiddeRessorts() {
    var detailCtrl = $('ressorthidde');
    var linkCtrl = $('ressorthiddeLink');
    if (detailCtrl) {
        if (detailCtrl.style.display == 'none') {
            linkCtrl.innerHTML = 'Top-3 Ressorts anzeigen';
        }
        else {
            linkCtrl.innerHTML = 'weitere Ressorts anzeigen';
        }
        detailCtrl.toggle();
    }
}
// ----------