//::: Prototype 00:00:00
var Prototype = {
    Version: '1.4.0',
    ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',
    emptyFunction: function() { },
    K: function(x) { return x } 
}
var Class = {
    create: function() {
        return function() {
            this.initialize.apply(this, arguments);
        } 
    } 
}
var Abstract = new Object();
Object.extend = function(destination, source) {
    for (property in source) {
        destination[property] = source[property];
    }
    return destination;
}
Object.inspect = function(object) {
    try {
        if (object == undefined) return 'undefined';
        if (object == null) return 'null';
        return object.inspect ? object.inspect() : object.toString();
    } catch (e) {
        if (e instanceof RangeError) return '...';
        throw e;
    } 
}
Function.prototype.bind = function() {
    var __method = this, args = $A(arguments), object = args.shift();
    return function() {
        return __method.apply(object, args.concat($A(arguments)));
    } 
}
Function.prototype.bindAsEventListener = function(object) {
    var __method = this;
    return function(event) {
        return __method.call(object, event || window.event);
    } 
}
Object.extend(Number.prototype, {
    toColorPart: function() {
        var digits = this.toString(16);
        if (this < 16) return '0' + digits;
        return digits;
    },
    succ: function() {
        return this + 1;
    },
    times: function(iterator) {
        $R(0, this, true).each(iterator);
        return this;
    } 
});
var Try = {
    these: function() {
        var returnValue;
        for (var i = 0; i < arguments.length; i++) {
            var lambda = arguments[i];
            try {
                returnValue = lambda();
                break;
            } catch (e) { } 
        }
        return returnValue;
    } 
}
var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype = {
    initialize: function(callback, frequency) {
        this.callback = callback;
        this.frequency = frequency;
        this.currentlyExecuting = false;
        this.registerCallback();
    },
    registerCallback: function() {
        setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
    },
    onTimerEvent: function() {
        if (!this.currentlyExecuting) {
            try {
                this.currentlyExecuting = true;
                this.callback();
            } finally {
                this.currentlyExecuting = false;
            } 
        } 
    } 
}
function $() {
    var elements = new Array();
    for (var i = 0; i < arguments.length; i++) {
        var element = arguments[i];
        if (typeof element == 'string')
            element = document.getElementById(element);
        if (arguments.length == 1)
            return element;
        elements.push(element);
    }
    return elements;
}
Object.extend(String.prototype, {
    stripTags: function() {
        return this.replace(/<\/?[^>]+>/gi, '');
    },
    stripScripts: function() {
        return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
    },
    extractScripts: function() {
        var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
        var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
        return (this.match(matchAll) || []).map(function(scriptTag) {
            return (scriptTag.match(matchOne) || ['', ''])[1];
        });
    },
    evalScripts: function() {
        return this.extractScripts().map(eval);
    },
    escapeHTML: function() {
        var div = document.createElement('div');
        var text = document.createTextNode(this);
        div.appendChild(text);
        return div.innerHTML;
    },
    unescapeHTML: function() {
        var div = document.createElement('div');
        div.innerHTML = this.stripTags();
        return div.childNodes[0] ? div.childNodes[0].nodeValue : '';
    },
    toQueryParams: function() {
        var pairs = this.match(/^\??(.*)$/)[1].split('&');
        return pairs.inject({}, function(params, pairString) {
            var pair = pairString.split('=');
            params[pair[0]] = pair[1];
            return params;
        });
    },
    toArray: function() {
        return this.split('');
    },
    camelize: function() {
        var oStringList = this.split('-');
        if (oStringList.length == 1) return oStringList[0];
        var camelizedString = this.indexOf('-') == 0 ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1) : oStringList[0];
        for (var i = 1, len = oStringList.length; i < len; i++) {
            var s = oStringList[i];
            camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
        }
        return camelizedString;
    },
    inspect: function() {
        return "'" + this.replace('\\', '\\\\').replace("'", '\\\'') + "'";
    } 
});
String.prototype.parseQuery = String.prototype.toQueryParams;
var $break = new Object();
var $continue = new Object();
var Enumerable = {
    each: function(iterator) {
        var index = 0;
        try {
            this._each(function(value) {
                try {
                    iterator(value, index++);
                } catch (e) {
                    if (e != $continue) throw e;
                } 
            });
        } catch (e) {
            if (e != $break) throw e;
        } 
    },
    all: function(iterator) {
        var result = true;
        this.each(function(value, index) {
            result = result && !!(iterator || Prototype.K)(value, index);
            if (!result) throw $break;
        });
        return result;
    },
    any: function(iterator) {
        var result = true;
        this.each(function(value, index) {
            if (result = !!(iterator || Prototype.K)(value, index))
                throw $break;
        });
        return result;
    },
    collect: function(iterator) {
        var results = [];
        this.each(function(value, index) {
            results.push(iterator(value, index));
        });
        return results;
    },
    detect: function(iterator) {
        var result;
        this.each(function(value, index) {
            if (iterator(value, index)) {
                result = value;
                throw $break;
            } 
        });
        return result;
    },
    findAll: function(iterator) {
        var results = [];
        this.each(function(value, index) {
            if (iterator(value, index))
                results.push(value);
        });
        return results;
    },
    grep: function(pattern, iterator) {
        var results = [];
        this.each(function(value, index) {
            var stringValue = value.toString();
            if (stringValue.match(pattern))
                results.push((iterator || Prototype.K)(value, index));
        })
        return results;
    },
    include: function(object) {
        var found = false;
        this.each(function(value) {
            if (value == object) {
                found = true;
                throw $break;
            } 
        });
        return found;
    },
    inject: function(memo, iterator) {
        this.each(function(value, index) {
            memo = iterator(memo, value, index);
        });
        return memo;
    },
    invoke: function(method) {
        var args = $A(arguments).slice(1);
        return this.collect(function(value) {
            return value[method].apply(value, args);
        });
    },
    max: function(iterator) {
        var result;
        this.each(function(value, index) {
            value = (iterator || Prototype.K)(value, index);
            if (value >= (result || value))
                result = value;
        });
        return result;
    },
    min: function(iterator) {
        var result;
        this.each(function(value, index) {
            value = (iterator || Prototype.K)(value, index);
            if (value <= (result || value))
                result = value;
        });
        return result;
    },
    partition: function(iterator) {
        var trues = [], falses = [];
        this.each(function(value, index) {
            ((iterator || Prototype.K)(value, index) ?
trues : falses).push(value);
        });
        return [trues, falses];
    },
    pluck: function(property) {
        var results = [];
        this.each(function(value, index) {
            results.push(value[property]);
        });
        return results;
    },
    reject: function(iterator) {
        var results = [];
        this.each(function(value, index) {
            if (!iterator(value, index))
                results.push(value);
        });
        return results;
    },
    sortBy: function(iterator) {
        return this.collect(function(value, index) {
            return { value: value, criteria: iterator(value, index) };
        }).sort(function(left, right) {
            var a = left.criteria, b = right.criteria;
            return a < b ? -1 : a > b ? 1 : 0;
        }).pluck('value');
    },
    toArray: function() {
        return this.collect(Prototype.K);
    },
    zip: function() {
        var iterator = Prototype.K, args = $A(arguments);
        if (typeof args.last() == 'function')
            iterator = args.pop();
        var collections = [this].concat(args).map($A);
        return this.map(function(value, index) {
            iterator(value = collections.pluck(index));
            return value;
        });
    },
    inspect: function() {
        return '#<Enumerable:' + this.toArray().inspect() + '>';
    } 
}
Object.extend(Enumerable, {
    map: Enumerable.collect,
    find: Enumerable.detect,
    select: Enumerable.findAll,
    member: Enumerable.include,
    entries: Enumerable.toArray
});
var $A = Array.from = function(iterable) {
    if (!iterable) return [];
    if (iterable.toArray) {
        return iterable.toArray();
    } else {
        var results = [];
        for (var i = 0; i < iterable.length; i++)
            results.push(iterable[i]);
        return results;
    } 
}
Object.extend(Array.prototype, Enumerable);
Array.prototype._reverse = Array.prototype.reverse;
Object.extend(Array.prototype, {
    _each: function(iterator) {
        for (var i = 0; i < this.length; i++)
            iterator(this[i]);
    },
    clear: function() {
        this.length = 0;
        return this;
    },
    first: function() {
        return this[0];
    },
    last: function() {
        return this[this.length - 1];
    },
    compact: function() {
        return this.select(function(value) {
            return value != undefined || value != null;
        });
    },
    flatten: function() {
        return this.inject([], function(array, value) {
            return array.concat(value.constructor == Array ?
value.flatten() : [value]);
        });
    },
    without: function() {
        var values = $A(arguments);
        return this.select(function(value) {
            return !values.include(value);
        });
    },
    indexOf: function(object) {
        for (var i = 0; i < this.length; i++)
            if (this[i] == object) return i;
        return -1;
    },
    reverse: function(inline) {
        return (inline !== false ? this : this.toArray())._reverse();
    },
    shift: function() {
        var result = this[0];
        for (var i = 0; i < this.length - 1; i++)
            this[i] = this[i + 1];
        this.length--;
        return result;
    },
    inspect: function() {
        return '[' + this.map(Object.inspect).join(', ') + ']';
    } 
});
var Hash = {
    _each: function(iterator) {
        for (key in this) {
            var value = this[key];
            if (typeof value == 'function') continue;
            var pair = [key, value];
            pair.key = key;
            pair.value = value;
            iterator(pair);
        } 
    },
    keys: function() {
        return this.pluck('key');
    },
    values: function() {
        return this.pluck('value');
    },
    merge: function(hash) {
        return $H(hash).inject($H(this), function(mergedHash, pair) {
            mergedHash[pair.key] = pair.value;
            return mergedHash;
        });
    },
    toQueryString: function() {
        return this.map(function(pair) {
            return pair.map(encodeURIComponent).join('=');
        }).join('&');
    },
    inspect: function() {
        return '#<Hash:{' + this.map(function(pair) {
            return pair.map(Object.inspect).join(': ');
        }).join(', ') + '}>';
    } 
}
function $H(object) {
    var hash = Object.extend({}, object || {});
    Object.extend(hash, Enumerable);
    Object.extend(hash, Hash);
    return hash;
}
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
    initialize: function(start, end, exclusive) {
        this.start = start;
        this.end = end;
        this.exclusive = exclusive;
    },
    _each: function(iterator) {
        var value = this.start;
        do {
            iterator(value);
            value = value.succ();
        } while (this.include(value));
    },
    include: function(value) {
        if (value < this.start)
            return false;
        if (this.exclusive)
            return value < this.end;
        return value <= this.end;
    } 
});
var $R = function(start, end, exclusive) {
    return new ObjectRange(start, end, exclusive);
}
var Ajax = {
    getTransport: function() {
        return Try.these(
function() { return new ActiveXObject('Msxml2.XMLHTTP') },
function() { return new ActiveXObject('Microsoft.XMLHTTP') },
function() { return new XMLHttpRequest() }) || false;
    },
    activeRequestCount: 0
}
Ajax.Responders = {
    responders: [],
    _each: function(iterator) {
        this.responders._each(iterator);
    },
    register: function(responderToAdd) {
        if (!this.include(responderToAdd))
            this.responders.push(responderToAdd);
    },
    unregister: function(responderToRemove) {
        this.responders = this.responders.without(responderToRemove);
    },
    dispatch: function(callback, request, transport, json) {
        this.each(function(responder) {
            if (responder[callback] && typeof responder[callback] == 'function') {
                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 = function() { };
Ajax.Base.prototype = {
    setOptions: function(options) {
        this.options = {
            method: 'post',
            asynchronous: true,
            parameters: ''
        }
        Object.extend(this.options, options || {});
    },
    responseIsSuccess: function() {
        return this.transport.status == undefined || this.transport.status == 0 || (this.transport.status >= 200 && this.transport.status < 300);
    },
    responseIsFailure: function() {
        return !this.responseIsSuccess();
    } 
}
Ajax.Request = Class.create();
Ajax.Request.Events = ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
    initialize: function(url, options) {
        this.transport = Ajax.getTransport();
        this.setOptions(options);
        this.request(url);
    },
    request: function(url) {
        var parameters = this.options.parameters || '';
        if (parameters.length > 0) parameters += '&_=';
        try {
            this.url = url;
            if (this.options.method == 'get' && parameters.length > 0)
                this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;
            Ajax.Responders.dispatch('onCreate', this, this.transport);
            this.transport.open(this.options.method, this.url,
this.options.asynchronous);
            if (this.options.asynchronous) {
                this.transport.onreadystatechange = this.onStateChange.bind(this);
                setTimeout((function() { this.respondToReadyState(1) }).bind(this), 10);
            }
            this.setRequestHeaders();
            var body = this.options.postBody ? this.options.postBody : parameters;
            this.transport.send(this.options.method == 'post' ? body : null);
        } catch (e) {
            this.dispatchException(e);
        } 
    },
    setRequestHeaders: function() {
        var requestHeaders = ['X-Requested-With', 'XMLHttpRequest',
'X-Prototype-Version', Prototype.Version];
        if (this.options.method == 'post') {
            requestHeaders.push('Content-type',
'application/x-www-form-urlencoded');
            if (this.transport.overrideMimeType)
                requestHeaders.push('Connection', 'close');
        }
        if (this.options.requestHeaders)
            requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);
        for (var i = 0; i < requestHeaders.length; i += 2)
            this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i + 1]);
    },
    onStateChange: function() {
        var readyState = this.transport.readyState;
        if (readyState != 1)
            this.respondToReadyState(this.transport.readyState);
    },
    header: function(name) {
        try {
            return this.transport.getResponseHeader(name);
        } catch (e) { } 
    },
    evalJSON: function() {
        try {
            return eval(this.header('X-JSON'));
        } catch (e) { } 
    },
    evalResponse: function() {
        try {
            return eval(this.transport.responseText);
        } catch (e) {
            this.dispatchException(e);
        } 
    },
    respondToReadyState: function(readyState) {
        var event = Ajax.Request.Events[readyState];
        var transport = this.transport, json = this.evalJSON();
        if (event == 'Complete') {
            try { (this.options['on' + this.transport.status] || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')] || Prototype.emptyFunction)(transport, json); } catch (e) {
                this.dispatchException(e);
            }
            if ((this.header('Content-type') || '').match(/^text\/javascript/i))
                this.evalResponse();
        }
        try {
            (this.options['on' + event] || Prototype.emptyFunction)(transport, json);
            Ajax.Responders.dispatch('on' + event, this, transport, json);
        } catch (e) {
            this.dispatchException(e);
        }
        if (event == 'Complete')
            this.transport.onreadystatechange = Prototype.emptyFunction;
    },
    dispatchException: function(exception) {
        (this.options.onException || Prototype.emptyFunction)(this, exception);
        Ajax.Responders.dispatch('onException', this, exception);
    } 
});
Ajax.Updater = Class.create();
Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
    initialize: function(container, url, options) {
        this.containers = {
            success: container.success ? $(container.success) : $(container),
            failure: container.failure ? $(container.failure) : (container.success ? null : $(container))
        }
        this.transport = Ajax.getTransport();
        this.setOptions(options);
        var onComplete = this.options.onComplete || Prototype.emptyFunction;
        this.options.onComplete = (function(transport, object) {
            this.updateContent();
            onComplete(transport, object);
        }).bind(this);
        this.request(url);
    },
    updateContent: function() {
        var receiver = this.responseIsSuccess() ?
this.containers.success : this.containers.failure;
        var response = this.transport.responseText;
        if (!this.options.evalScripts)
            response = response.stripScripts();
        if (receiver) {
            if (this.options.insertion) {
                new this.options.insertion(receiver, response);
            } else {
                Element.update(receiver, response);
            } 
        }
        if (this.responseIsSuccess()) {
            if (this.onComplete)
                setTimeout(this.onComplete.bind(this), 10);
        } 
    } 
});
Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
    initialize: function(container, url, options) {
        this.setOptions(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.onComplete = undefined;
        clearTimeout(this.timer); (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
    },
    updateComplete: function(request) {
        if (this.options.decay) {
            this.decay = (request.responseText == this.lastText ?
this.decay * this.options.decay : 1);
            this.lastText = request.responseText;
        }
        this.timer = setTimeout(this.onTimerEvent.bind(this),
this.decay * this.frequency * 1000);
    },
    onTimerEvent: function() {
        this.updater = new Ajax.Updater(this.container, this.url, this.options);
    } 
});
document.getElementsByClassName = function(className, parentElement) {
    var children = ($(parentElement) || $('body')).find('*');
    return $A(children).inject([], function(elements, child) {
        if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
            elements.push(child);
        return elements;
    });
}
if (!window.Element) {
    var Element = new Object();
}
Object.extend(Element, {
    visible: function(element) {
        return $(element).style.display != 'none';
    },
    toggle: function() {
        for (var i = 0; i < arguments.length; i++) {
            var element = $(arguments[i]);
            Element[Element.visible(element) ? 'hide' : 'show'](element);
        } 
    },
    hide: function() {
        for (var i = 0; i < arguments.length; i++) {
            var element = $(arguments[i]);
            element.style.display = 'none';
        } 
    },
    show: function() {
        for (var i = 0; i < arguments.length; i++) {
            var element = $(arguments[i]);
            element.style.display = '';
        } 
    },
    remove: function(element) {
        element = $(element);
        element.parentNode.removeChild(element);
    },
    update: function(element, html) {
        $(element).innerHTML = html.stripScripts();
        setTimeout(function() { html.evalScripts() }, 10);
    },
    getHeight: function(element) {
        element = $(element);
        return element.offsetHeight;
    },
    classNames: function(element) {
        return new Element.ClassNames(element);
    },
    hasClassName: function(element, className) {
        if (!(element = $(element))) return;
        return Element.classNames(element).include(className);
    },
    addClassName: function(element, className) {
        if (!(element = $(element))) return;
        return Element.classNames(element).add(className);
    },
    removeClassName: function(element, className) {
        if (!(element = $(element))) return;
        return Element.classNames(element).remove(className);
    },
    cleanWhitespace: function(element) {
        element = $(element);
        for (var i = 0; i < element.childNodes.length; i++) {
            var node = element.childNodes[i];
            if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
                Element.remove(node);
        } 
    },
    empty: function(element) {
        return $(element).innerHTML.match(/^\s*$/);
    },
    scrollTo: function(element) {
        element = $(element);
        var x = element.x ? element.x : element.offsetLeft,
y = element.y ? element.y : element.offsetTop;
        window.scrollTo(x, y);
    },
    getStyle: function(element, style) {
        element = $(element);
        var value = element.style[style.camelize()];
        if (!value) {
            if (document.defaultView && document.defaultView.getComputedStyle) {
                var css = document.defaultView.getComputedStyle(element, null);
                value = css ? css.getPropertyValue(style) : null;
            } else if (element.currentStyle) {
                value = element.currentStyle[style.camelize()];
            } 
        }
        if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
            if (Element.getStyle(element, 'position') == 'static') value = 'auto';
        return value == 'auto' ? null : value;
    },
    setStyle: function(element, style) {
        element = $(element);
        for (name in style)
            element.style[name.camelize()] = style[name];
    },
    getDimensions: function(element) {
        element = $(element);
        if (Element.getStyle(element, 'display') != 'none')
            return { width: element.offsetWidth, height: element.offsetHeight };
        var els = element.style;
        var originalVisibility = els.visibility;
        var originalPosition = els.position;
        els.visibility = 'hidden';
        els.position = 'absolute';
        els.display = '';
        var originalWidth = element.clientWidth;
        var originalHeight = element.clientHeight;
        els.display = 'none';
        els.position = originalPosition;
        els.visibility = originalVisibility;
        return { width: originalWidth, height: originalHeight };
    },
    makePositioned: function(element) {
        element = $(element);
        var pos = Element.getStyle(element, 'position');
        if (pos == 'static' || !pos) {
            element._madePositioned = true;
            element.style.position = 'relative';
            if (window.opera) {
                element.style.top = 0;
                element.style.left = 0;
            } 
        } 
    },
    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 = '';
        } 
    },
    makeClipping: function(element) {
        element = $(element);
        if (element._overflow) return;
        element._overflow = element.style.overflow;
        if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
            element.style.overflow = 'hidden';
    },
    undoClipping: function(element) {
        element = $(element);
        if (element._overflow) return;
        element.style.overflow = element._overflow;
        element._overflow = undefined;
    } 
});
var Toggle = new Object();
Toggle.display = Element.toggle;
Abstract.Insertion = function(adjacency) {
    this.adjacency = adjacency;
}
Abstract.Insertion.prototype = {
    initialize: function(element, content) {
        this.element = $(element);
        this.content = content.stripScripts();
        if (this.adjacency && this.element.insertAdjacentHTML) {
            try {
                this.element.insertAdjacentHTML(this.adjacency, this.content);
            } catch (e) {
                if (this.element.tagName.toLowerCase() == 'tbody') {
                    this.insertContent(this.contentFromAnonymousTable());
                } else {
                    throw e;
                } 
            } 
        } else {
            this.range = this.element.ownerDocument.createRange();
            if (this.initializeRange) this.initializeRange();
            this.insertContent([this.range.createContextualFragment(this.content)]);
        }
        setTimeout(function() { content.evalScripts() }, 10);
    },
    contentFromAnonymousTable: function() {
        var div = document.createElement('div');
        div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
        return $A(div.childNodes[0].childNodes[0].childNodes);
    } 
}
var Insertion = new Object();
Insertion.Before = Class.create();
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
    initializeRange: function() {
        this.range.setStartBefore(this.element);
    },
    insertContent: function(fragments) {
        fragments.each((function(fragment) {
            this.element.parentNode.insertBefore(fragment, this.element);
        }).bind(this));
    } 
});
Insertion.Top = Class.create();
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
    initializeRange: function() {
        this.range.selectNodeContents(this.element);
        this.range.collapse(true);
    },
    insertContent: function(fragments) {
        fragments.reverse(false).each((function(fragment) {
            this.element.insertBefore(fragment, this.element.firstChild);
        }).bind(this));
    } 
});
Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
    initializeRange: function() {
        this.range.selectNodeContents(this.element);
        this.range.collapse(this.element);
    },
    insertContent: function(fragments) {
        fragments.each((function(fragment) {
            this.element.appendChild(fragment);
        }).bind(this));
    } 
});
Insertion.After = Class.create();
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
    initializeRange: function() {
        this.range.setStartAfter(this.element);
    },
    insertContent: function(fragments) {
        fragments.each((function(fragment) {
            this.element.parentNode.insertBefore(fragment,
this.element.nextSibling);
        }).bind(this));
    } 
});
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(this.toArray().concat(classNameToAdd).join(' '));
    },
    remove: function(classNameToRemove) {
        if (!this.include(classNameToRemove)) return;
        this.set(this.select(function(className) {
            return className != classNameToRemove;
        }).join(' '));
    },
    toString: function() {
        return this.toArray().join(' ');
    } 
}
Object.extend(Element.ClassNames.prototype, Enumerable);
var Field = {
    clear: function() {
        for (var i = 0; i < arguments.length; i++)
            $(arguments[i]).value = '';
    },
    focus: function(element) {
        $(element).focus();
    },
    present: function() {
        for (var i = 0; i < arguments.length; i++)
            if ($(arguments[i]).value == '') return false;
        return true;
    },
    select: function(element) {
        $(element).select();
    },
    activate: function(element) {
        element = $(element);
        element.focus();
        if (element.select)
            element.select();
    } 
}
var Form = {
    serialize: function(form) {
        var elements = Form.getElements($(form));
        var queryComponents = new Array();
        for (var i = 0; i < elements.length; i++) {
            var queryComponent = Form.Element.serialize(elements[i]);
            if (queryComponent)
                queryComponents.push(queryComponent);
        }
        return queryComponents.join('&');
    },
    getElements: function(form) {
        form = $(form);
        var elements = new Array();
        for (tagName in Form.Element.Serializers) {
            var tagElements = form.getElementsByTagName(tagName);
            for (var j = 0; j < tagElements.length; j++)
                elements.push(tagElements[j]);
        }
        return elements;
    },
    getInputs: function(form, typeName, name) {
        form = $(form);
        var inputs = form.getElementsByTagName('input');
        if (!typeName && !name)
            return inputs;
        var matchingInputs = new Array();
        for (var i = 0; i < inputs.length; i++) {
            var input = inputs[i];
            if ((typeName && input.type != typeName) || (name && input.name != name))
                continue;
            matchingInputs.push(input);
        }
        return matchingInputs;
    },
    disable: function(form) {
        var elements = Form.getElements(form);
        for (var i = 0; i < elements.length; i++) {
            var element = elements[i];
            element.blur();
            element.disabled = 'true';
        } 
    },
    enable: function(form) {
        var elements = Form.getElements(form);
        for (var i = 0; i < elements.length; i++) {
            var element = elements[i];
            element.disabled = '';
        } 
    },
    findFirstElement: function(form) {
        return Form.getElements(form).find(function(element) {
            return element.type != 'hidden' && !element.disabled && ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
        });
    },
    focusFirstElement: function(form) {
        Field.activate(Form.findFirstElement(form));
    },
    reset: function(form) {
        $(form).reset();
    } 
}
Form.Element = {
    serialize: function(element) {
        element = $(element);
        var method = element.tagName.toLowerCase();
        var parameter = Form.Element.Serializers[method](element);
        if (parameter) {
            var key = encodeURIComponent(parameter);
            if (key.length == 0) return;
            if (parameter[1].constructor != Array)
                parameter[1] = [parameter[1]];
            return parameter[1].map(function(value) {
                return key + '=' + encodeURIComponent(value);
            }).join('&');
        } 
    },
    getValue: function(element) {
        element = $(element);
        var method = element.tagName.toLowerCase();
        var parameter = Form.Element.Serializers[method](element);
        if (parameter)
            return parameter[1];
    } 
}
Form.Element.Serializers = {
    input: function(element) {
        switch (element.type.toLowerCase()) {
            case 'submit':
            case 'hidden':
            case 'password':
            case 'text':
                return Form.Element.Serializers.textarea(element);
            case 'checkbox':
            case 'radio':
                return Form.Element.Serializers.inputSelector(element);
        }
        return false;
    },
    inputSelector: function(element) {
        if (element.checked)
            return [element.name, element.value];
    },
    textarea: function(element) {
        return [element.name, element.value];
    },
    select: function(element) {
        return Form.Element.Serializers[element.type == 'select-one' ?
'selectOne' : 'selectMany'](element);
    },
    selectOne: function(element) {
        var value = '', opt, index = element.selectedIndex;
        if (index >= 0) {
            opt = element.options[index];
            value = opt.value;
            if (!value && !('value' in opt))
                value = opt.text;
        }
        return [element.name, value];
    },
    selectMany: function(element) {
        var value = new Array();
        for (var i = 0; i < element.length; i++) {
            var opt = element.options[i];
            if (opt.selected) {
                var optValue = opt.value;
                if (!optValue && !('value' in opt))
                    optValue = opt.text;
                value.push(optValue);
            } 
        }
        return [element.name, value];
    } 
}
var $F = Form.Element.getValue;
Abstract.TimedObserver = function() { }
Abstract.TimedObserver.prototype = {
    initialize: function(element, frequency, callback) {
        this.frequency = frequency;
        this.element = $(element);
        this.callback = callback;
        this.lastValue = this.getValue();
        this.registerCallback();
    },
    registerCallback: function() {
        setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
    },
    onTimerEvent: function() {
        var value = this.getValue();
        if (this.lastValue != value) {
            this.callback(this.element, value);
            this.lastValue = value;
        } 
    } 
}
Form.Element.Observer = Class.create();
Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
    getValue: function() {
        return Form.Element.getValue(this.element);
    } 
});
Form.Observer = Class.create();
Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
    getValue: function() {
        return Form.serialize(this.element);
    } 
});
Abstract.EventObserver = function() { }
Abstract.EventObserver.prototype = {
    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() {
        var elements = Form.getElements(this.element);
        for (var i = 0; i < elements.length; i++)
            this.registerCallback(elements[i]);
    },
    registerCallback: function(element) {
        if (element.type) {
            switch (element.type.toLowerCase()) {
                case 'checkbox':
                case 'radio':
                    Event.observe(element, 'click', this.onElementEvent.bind(this));
                    break;
                case 'password':
                case 'text':
                case 'textarea':
                case 'select-one':
                case 'select-multiple':
                    Event.observe(element, 'change', this.onElementEvent.bind(this));
                    break;
            } 
        } 
    } 
}
Form.Element.EventObserver = Class.create();
Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
    getValue: function() {
        return Form.Element.getValue(this.element);
    } 
});
Form.EventObserver = Class.create();
Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
    getValue: function() {
        return Form.serialize(this.element);
    } 
});
if (!window.Event) {
    var Event = new Object();
}
Object.extend(Event, {
    KEY_BACKSPACE: 8,
    KEY_TAB: 9,
    KEY_RETURN: 13,
    KEY_ESC: 27,
    KEY_LEFT: 37,
    KEY_UP: 38,
    KEY_RIGHT: 39,
    KEY_DOWN: 40,
    KEY_DELETE: 46,
    element: function(event) {
        return event.target || event.srcElement;
    },
    isLeftClick: function(event) {
        return (((event.which) && (event.which == 1)) || ((event.button) && (event.button == 1)));
    },
    pointerX: function(event) {
        return event.pageX || (event.clientX + (document.documentElement.scrollLeft || document.body.scrollLeft));
    },
    pointerY: function(event) {
        return event.pageY || (event.clientY + (document.documentElement.scrollTop || document.body.scrollTop));
    },
    stop: function(event) {
        if (event.preventDefault) {
            event.preventDefault();
            event.stopPropagation();
        } else {
            event.returnValue = false;
            event.cancelBubble = true;
        } 
    },
    findElement: function(event, tagName) {
        var element = Event.element(event);
        while (element.parentNode && (!element.tagName || (element.tagName.toUpperCase() != tagName.toUpperCase())))
            element = element.parentNode;
        return element;
    },
    observers: false,
    _observeAndCache: function(element, name, observer, useCapture) {
        if (!this.observers) this.observers = [];
        if (element.addEventListener) {
            this.observers.push([element, name, observer, useCapture]);
            element.addEventListener(name, observer, useCapture);
        } else if (element.attachEvent) {
            this.observers.push([element, name, observer, useCapture]);
            element.attachEvent('on' + name, observer);
        } 
    },
    unloadCache: function() {
        if (!Event.observers) return;
        for (var i = 0; i < Event.observers.length; i++) {
            Event.stopObserving.apply(this, Event.observers[i]);
            Event.observers[i][0] = null;
        }
        Event.observers = false;
    },
    observe: function(element, name, observer, useCapture) {
        var element = $(element);
        useCapture = useCapture || false;
        if (name == 'keypress' && (navigator.appVersion.match(/Konqueror|Safari|KHTML/) || element.attachEvent))
            name = 'keydown';
        this._observeAndCache(element, name, observer, useCapture);
    },
    stopObserving: function(element, name, observer, useCapture) {
        var element = $(element);
        useCapture = useCapture || false;
        if (name == 'keypress' && (navigator.appVersion.match(/Konqueror|Safari|KHTML/) || element.detachEvent))
            name = 'keydown';
        if (element.removeEventListener) {
            element.removeEventListener(name, observer, useCapture);
        } else if (element.detachEvent) {
            element.detachEvent('on' + name, observer);
        } 
    } 
});
Event.observe(window, 'unload', Event.unloadCache, false);
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;
    },
    realOffset: function(element) {
        var valueT = 0, valueL = 0;
        do {
            valueT += element.scrollTop || 0;
            valueL += element.scrollLeft || 0;
            element = element.parentNode;
        } while (element);
        return [valueL, valueT];
    },
    cumulativeOffset: function(element) {
        var valueT = 0, valueL = 0;
        do {
            valueT += element.offsetTop || 0;
            valueL += element.offsetLeft || 0;
            element = element.offsetParent;
        } while (element);
        return [valueL, valueT];
    },
    positionedOffset: function(element) {
        var valueT = 0, valueL = 0;
        do {
            valueT += element.offsetTop || 0;
            valueL += element.offsetLeft || 0;
            element = element.offsetParent;
            if (element) {
                p = Element.getStyle(element, 'position');
                if (p == 'relative' || p == 'absolute') break;
            } 
        } while (element);
        return [valueL, valueT];
    },
    offsetParent: function(element) {
        if (element.offsetParent) return element.offsetParent;
        if (element == document.body) return element;
        while ((element = element.parentNode) && element != document.body)
            if (Element.getStyle(element, 'position') != 'static')
            return element;
        return document.body;
    },
    within: function(element, x, y) {
        if (this.includeScrollOffsets)
            return this.withinIncludingScrolloffsets(element, x, y);
        this.xcomp = x;
        this.ycomp = y;
        this.offset = this.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 = this.realOffset(element);
        this.xcomp = x + offsetcache[0] - this.deltaX;
        this.ycomp = y + offsetcache[1] - this.deltaY;
        this.offset = this.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;
    },
    clone: function(source, target) {
        source = $(source);
        target = $(target);
        target.style.position = 'absolute';
        var offsets = this.cumulativeOffset(source);
        target.style.top = offsets[1] + 'px';
        target.style.left = offsets[0] + 'px';
        target.style.width = source.offsetWidth + 'px';
        target.style.height = source.offsetHeight + 'px';
    },
    page: function(forElement) {
        var valueT = 0, valueL = 0;
        var element = forElement;
        do {
            valueT += element.offsetTop || 0;
            valueL += element.offsetLeft || 0;
            if (element.offsetParent == document.body)
                if (Element.getStyle(element, 'position') == 'absolute') break;
        } while (element = element.offsetParent);
        element = forElement;
        do {
            valueT -= element.scrollTop || 0;
            valueL -= element.scrollLeft || 0;
        } while (element = element.parentNode);
        return [valueL, valueT];
    },
    clone: function(source, target) {
        var options = Object.extend({
            setLeft: true,
            setTop: true,
            setWidth: true,
            setHeight: true,
            offsetTop: 0,
            offsetLeft: 0
        }, arguments[2] || {})
        source = $(source);
        var p = Position.page(source);
        target = $(target);
        var delta = [0, 0];
        var parent = null;
        if (Element.getStyle(target, 'position') == 'absolute') {
            parent = Position.offsetParent(target);
            delta = Position.page(parent);
        }
        if (parent == document.body) {
            delta[0] -= document.body.offsetLeft;
            delta[1] -= document.body.offsetTop;
        }
        if (options.setLeft) target.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
        if (options.setTop) target.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
        if (options.setWidth) target.style.width = source.offsetWidth + 'px';
        if (options.setHeight) target.style.height = source.offsetHeight + 'px';
    },
    absolutize: function(element) {
        element = $(element);
        if (element.style.position == 'absolute') return;
        Position.prepare();
        var offsets = Position.positionedOffset(element);
        var top = offsets[1];
        var left = offsets[0];
        var width = element.clientWidth;
        var height = element.clientHeight;
        element._originalLeft = left - parseFloat(element.style.left || 0);
        element._originalTop = top - parseFloat(element.style.top || 0);
        element._originalWidth = element.style.width;
        element._originalHeight = element.style.height;
        element.style.position = 'absolute';
        element.style.top = top + 'px'; ;
        element.style.left = left + 'px'; ;
        element.style.width = width + 'px'; ;
        element.style.height = height + 'px'; ;
    },
    relativize: function(element) {
        element = $(element);
        if (element.style.position == 'relative') return;
        Position.prepare();
        element.style.position = 'relative';
        var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);
        var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
        element.style.top = top + 'px';
        element.style.left = left + 'px';
        element.style.height = element._originalHeight;
        element.style.width = element._originalWidth;
    } 
}
if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
    Position.cumulativeOffset = function(element) {
        var valueT = 0, valueL = 0;
        do {
            valueT += element.offsetTop || 0;
            valueL += element.offsetLeft || 0;
            if (element.offsetParent == document.body)
                if (Element.getStyle(element, 'position') == 'absolute') break;
            element = element.offsetParent;
        } while (element);
        return [valueL, valueT];
    } 
}//::: Common 00:00:00.0156254

function $I(id){Claim.isString(id,"$I.id");var element=$(id);Claim.isObject(element,"Required HTML element id: "+id);return element;}
function $F(id){Claim.isString(id,"$F.id")
Claim.isObject($(id),"Required form element id: "+id)
return Form.Element.getValue(id)}
function $T(tagName){var element=document.getElementsByTagName(tagName).item(0)
Claim.isObject(element,"Required HTML element tag: "+tagName)
return element}
function $SO(id){return $I(id).options[$I(id).selectedIndex]}
Number.prototype.toText=function(base,width){Claim.isNumber(base,"Number.toText.base")
Claim.isTrue(base>0,"Number.toText.base")
Claim.isNumber(width,"Number.toText.width")
Claim.isTrue(width>=0,"Number.toText.width")
var text=this.toString(base||10)+""
while(text.length<width)
text="0"+text
return text}
Number.prototype.toDec=function(width){Claim.isNumber(width,"Number.toText.width")
Claim.isTrue(width>=0,"Number.toText.width")
return this.toText(10,width)}
Number.prototype.toHex=function(width){Claim.isNumber(width,"width","Number.toText.width")
Claim.isTrue(width>=0,"width","Number.toText.width")
return this.toText(16,width)}
Date.prototype.toText=function(){var year=this.getUTCFullYear().toDec(4)
var month=this.getUTCMonth().toDec(2)
var day=this.getUTCDate().toDec(2)
var hours=this.getUTCHours().toDec(2)
var minutes=this.getUTCMinutes().toDec(2)
var seconds=this.getUTCSeconds().toDec(2)
var milliseconds=this.getUTCMilliseconds().toDec(3)
return year+"-"+month+"-"+day+" "+hours+":"+minutes+":"+seconds+"."+milliseconds}
var PreLoad={}
PreLoad.preLoad=function(){PreLoad.log=new Log4Js.Logger("PreLoad")}
PreLoad.onLoad=function(){PreLoad.log.debug("Done pre-load")}
PreLoad.actions=[]
PreLoad.actions.push(PreLoad.preLoad)
Event.observe(window,"load",PreLoad.onLoad)
var Url={}
Url.parse=function(url){Claim.isString(url,"Url.parse.url")
var parsed={}
parsed.full=url
parsed.base=url.replace(/\?.*$/,'')
parsed.protocol=url.replace(/:.*$/,'')
parsed.domain=parsed.base.replace(/^[^:]*:\/[\/]/,'').replace(/[:\/].*$/,'')
parsed.path=parsed.base.replace(/^[^\/]*\/\/[^\/]*[\/]/,'/')
parsed.query=url.replace(/^[^?]*\??/,'')
parsed.params=parsed.query.split("&").inject({},function(params,paramValue){pair=paramValue.split("=")
params[pair[0]]=unescape(pair[1])
return params})
return parsed}
Url.trimAnchor=function(url){var i=url.lastIndexOf("#");var isHasSharpMark=i>-1
var isHasQMark=url.lastIndexOf("?")>-1
if(isHasSharpMark&&((isHasQMark&&i>url.lastIndexOf("="))||!isHasQMark)){url=url.substr(0,i);}
return url;}
Url.appendParams=function(url,params){Claim.isString(url,"Url.appendParams.url")
if(!params||params=="")
return url
if(typeof(params)=="string")
return url+(url.match(/\?/)?"&":"?")+params
return $A($H(params).keys().sort()).inject(url,function(url,param){return Url.appendParamValue(url,param,params[param])})}
Url.appendParamValue=function(url,param,value){Claim.isString(url,"Url.appendParamValue.url")
Claim.isString(param,"Url.appendParamValue.param")
Claim.isScalar(value,"Url.appendParamValue.value")
return url+(url.match(/\?/)?"&":"?")+escape(param)+"="+escape(value)}
Url.relativeUrl=function(options){Claim.isObject(options,"Url.relativeUrl.options")
var protocol=options.protocol||Url.here.protocol
Claim.isString(protocol,"Url.relativeUrl.options.protocol")
var domain=options.domain||Url.here.domain
Claim.isString(domain,"Url.relativeUrl.options.domain")
var path=options.path||Url.here.path
Claim.isString(path,"Url.relativeUrl.options.path")
if(!path.match(/^[\/]/)){var base=Url.here.path
path="../"+path
while(path.match(/^\.\.[\/]/)){path=path.replace(/^\.\.[\/]/,"")
base=base.replace(/\/[^\/]+$/,"")}
path=base+"/"+path}
var params={}
var withHereParams=options.withHereParams||false
Claim.isBoolean(withHereParams,"Url.relativeUrl.options.withHereParams")
if(withHereParams)
Object.extend(params,Url.here.params)
var withClearanceParams=options.withClearanceParams
if(withClearanceParams==undefined)
withClearanceParams=domain!=Url.here.domain
Claim.isBoolean(withClearanceParams,"Url.relativeUrl.options.withClearanceParams")
if(withClearanceParams){Object.extend(params,Clearance.getAllLevelParams())}
var optionsParams=options.params||{}
Claim.isObject(optionsParams,"Url.relativeUrl.options.params")
Object.extend(params,options.params||{})
return Url.appendParams(protocol+":/"+"/"+domain+path,params)}
Url.here=undefined
Url.preLoad=function(){Url.here=Url.parse(location.href)}
PreLoad.actions.push(Url.preLoad)
var Claim={}
Claim.check=function(condition,claim,comment){if(!comment)
comment=claim
else
comment=claim+": "+comment
var log=Claim.log
Claim.log=undefined
try{if(condition){if(log)
log.debug(comment)}
else{if(log)
log.error(comment)
else
alert(comment)
throw new Error(comment)}}
finally{Claim.log=log}}
Claim.valueType=function(object){if(object==undefined)
return"undefined"
if(object==null)
return"null"
return typeof(object)+"("+object+")"}
Claim.isTrue=function(condition,comment){Claim.check(condition,"isTrue("+Claim.valueType(condition)+")",comment)}
Claim.isFalse=function(condition,comment){Claim.check(!condition,"isFalse("+Claim.valueType(condition)+")",comment)}
Claim.isNull=function(object,comment){Claim.check(typeof(object)==null,"isNull("+Claim.valueType(object)+")",comment)}
Claim.isNotNull=function(object,comment){Claim.check(typeof(object)!=null,"isNotNull("+Claim.valueType(object)+")",comment)}
Claim.isUndefined=function(object,comment){Claim.check(typeof(object)=='undefined',"isUndefined("+Claim.valueType(object)+")",comment)}
Claim.isNotUndefined=function(object,comment){Claim.check(typeof(object)!='undefined',"isNotUndefined("+Claim.valueType(object)+")",comment)}
Claim.isObject=function(object,comment){Claim.check(!!object,"isObject("+Claim.valueType(object)+")",comment)}
Claim.isNumber=function(object,comment){Claim.check(typeof(object)=="number","isNumber("+Claim.valueType(object)+")",comment)}
Claim.isBoolean=function(object,comment){Claim.check(typeof(object)=="boolean","isBoolean("+Claim.valueType(object)+")",comment)}
Claim.isString=function(object,comment){Claim.check(typeof(object)=="string","isString("+Claim.valueType(object)+")",comment)}
Claim.isScalar=function(object,comment){Claim.check(typeof(object)=="string"||typeof(object)=="number"||typeof(object)=="boolean","isScalar("+Claim.valueType(object)+")",comment)}
Claim.isArray=function(object,comment){Claim.check(object&&object.length!=undefined,"isArray("+Claim.valueType(object)+")",comment)}
Claim.areEqual=function(object1,object2,comment){Claim.check(object1==object2,"areEqual("+Claim.valueType(object1)+" ? "+Claim.valueType(object2)+")",comment)}
Claim.isFunction=function(object,comment){Claim.check(typeof(object)=='function',"isFunction("+Claim.valueType(object)+")",comment)}
Claim.preLoad=function(){Claim.log=new Log4Js.Logger("Claim")}
PreLoad.actions.push(Claim.preLoad)
var Cookies={}
Cookies.defaultOptions={}
Cookies.rawByName={}
Cookies.valueByName={}
Cookies.set=function(name,value,options){Claim.isString(name,"Cookies.set.name")
Claim.isObject(value,"Cookies.set.value")
var fullOptions=Cookies.fullOptions(name,options)
var raw=Cookies.toJson(value)
Cookies.valueByName[name]=value
Cookies.rawByName[name]=raw
var cookie=Cookies.fullCookie(name,raw,fullOptions)
Cookies.log.info("Set cookie: "+cookie)
document.cookie=cookie}
Cookies.get=function(name){Claim.isString(name,"Cookies.get.name")
return Cookies.valueByName[name]}
Cookies.clear=function(name,options){Claim.isString(name,"Cookies.clear.name")
var fullOptions=Cookies.fullOptions(name,options)
fullOptions.expires=Cookies.expiration(-1)
var cookie=Cookies.fullCookie(name,"",fullOptions)
delete(Cookies.rawByName[name])
delete(Cookies.valueByName[name])
Cookies.log.info("Clear cookie: "+cookie)
document.cookie=cookie}
Cookies.fullOptions=function(name,options){Claim.isString(name,"Cookies.fullOptions.name")
var fullOptions=Object.extend({},Cookies.defaultOptions)
fullOptions=Object.extend(fullOptions,options||{})
if(!fullOptions.path){var error="Set cookie name: "+name+" without a path"
Cookies.log.error(error)
throw error}
if(fullOptions.path.charAt(0)!="/"){var error="Set cookie name: "+name+" invalid path: "+fullOptions.path
Cookies.log.error(error)
throw error}
if(!fullOptions.domain){var error="Set cookie name: "+name+" without a domain"
Cookies.log.error(error)
throw error}
if(fullOptions.domain.charAt(0)!="."){var error="Set cookie name: "+name+" invalid domain: "+fullOptions.domain
Cookies.log.error(error)
throw error}
return fullOptions}
Cookies.expiration=function(millis){Claim.isNumber(millis,"Cookies.expiration.millis")
var today=new Date()
var now=Date.parse(today)
today.setTime(now+1*millis)
return today.toUTCString()}
Cookies.fullCookie=function(name,raw,options){Claim.isString(name,"Cookies.fullCookie.name")
var cookie=name+"="+raw
$H(options).each(function(pair){if(pair[1]!=undefined)
cookie+=";"+pair[0]+"="+pair[1]})
return cookie}
Cookies.toJson=function(object){if(object==undefined)
return"undefined"
if(object==null)
return"null"
if(typeof(object)=="string")
return"\""+Cookies.jsonEscape(object.toString())+"\""
if(typeof(object)=="number"||typeof(object)=="boolean")
return object.toString()
if(object.toJson)
return object.toJson()
var json=""
var seperator=""
if(typeof object=='object'&&object.constructor.toString().match(/array/i)!=null){$A(object).each(function(value){json+=seperator+Cookies.toJson(value)
seperator=","})
return"["+json+"]"}
else{var json=""
$H(object).each(function(pair){json+=seperator+Cookies.toJson(pair[0])+":"+Cookies.toJson(pair[1])
seperator=","})
return"{"+json+"}"}}
Cookies.jsonEscape=function(text){Claim.isString(text,"Claim.jsonEscape.text")
var escaped=""
for(var i=0;i<text.length;i++){var code=text.charCodeAt(i)
if(code<32||code==59){escaped+="\\u"+code.toHex(4)}
else{var nextChar=text.charAt(i)
if(nextChar=="\""||nextChar=="\\")
escaped+="\\"
escaped+=nextChar}}
return escaped}
Cookies.preLoad=function(){Cookies.log=new Log4Js.Logger("Cookies")
Cookies.defaultOptions.path="/"
Cookies.defaultOptions.domain="."+Url.here.domain.replace(/^[a-zA-Z0-9\-]+./,'')
document.cookie.split(';').each(function(cookie){if(!cookie){if(Cookies.rawByName!=undefined){Cookies.rawByName={};Cookies.valueByName={};}
throw $break}
var name=cookie.replace(/^\s*([^=]+)=.*$/,'$1')
var raw=cookie.replace(/^[^=]*=/,'')
Cookies.rawByName[name]=raw
Cookies.log.info("Load cookie name: "+name+" value: "+raw)
try{var value=undefined
eval("value="+raw)
Cookies.valueByName[name]=value}
catch(error){Cookies.log.error("Invalid cookie name: "+name+" value: "+value+" error: "+error)
Cookies.valueByName[name]=null}})}
Cookies.pop=function(){var each,s=[];for(each in this.rawByName){s[s.length]=each
s[s.length]=":"
s[s.length]=this.rawByName[each]
s[s.length]="\n"}
alert(unescape(s.join("")));}
PreLoad.actions.push(Cookies.preLoad)
var Log4Js={}
Log4Js.levelNames=["All","Debug","Info","Warn","Error","Fatal","None"]
Log4Js.ALL=0
Log4Js.DEBUG=1
Log4Js.INFO=2
Log4Js.WARN=3
Log4Js.ERROR=4
Log4Js.FATAL=5
Log4Js.NONE=6
Log4Js.configVersion=0
Log4Js.targetsByName={"*":[]}
Log4Js.setTargets=function(name,targets){Claim.isString(name,"Log4Js.setTargets.name")
Claim.isArray(targets,"Log4Js.setTargets.targets")
Log4Js.targetsByName[name]=targets
Log4Js.configVersion++}
Log4Js.removeTargets=function(name){Claim.isString(name,"Log4Js.removeTargets.name")
if(name=="*")
Log4Js.targetsByName[name]=[]
else
delete(Log4Js.targetsByName[name])
Log4Js.configVersion++}
Log4Js.getTargets=function(name){Claim.isString(name,"Log4Js.getTargets.name")
return Log4Js.targetsByName[name]}
Log4Js.findPrefix=function(name){Claim.isString(name,"Log4Js.findPrefix.name")
while(true){if(name=="")
name="*"
var targets=Log4Js.targetsByName[name]
if(targets)
return name
var lastDot=name.lastIndexOf(".")
name=lastDot>0?name.substring(0,lastDot):""}}
Log4Js.findTargets=function(name){Claim.isString(name,"Log4Js.findTargets.name")
return this.getTargets(this.findPrefix(name))}
Log4Js.toConfig=function(){var anchorsByName={}
var targetAnchorByJson={}
var targetByAnchor={}
var nextAnchor=1
$H(Log4Js.targetsByName).each(function(pair){var name=pair[0]
var targets=pair[1]
anchorsByName[name]=targets.inject([],function(anchors,target){var json=target.toJson()
var anchor=targetAnchorByJson[json]
if(!anchor){anchor=targetAnchorByJson[json]="t"+nextAnchor++
targetByAnchor[anchor]=target}
anchors.push(anchor)
return anchors})})
return{targetByAnchor:targetByAnchor,anchorsByName:anchorsByName}}
Log4Js.fromConfig=function(config){Claim.isObject(config,"Log4Js.fromConfig.config")
Claim.isObject(config.anchorsByName,"Log4Js.fromConfig.config.anchorsByName")
Claim.isObject(config.targetByAnchor,"Log4Js.fromConfig.config.targetByAnchor")
var targetsByName=$H(config.anchorsByName).inject({},function(targetsByName,pair){var name=pair[0]
var anchors=pair[1]
targetsByName[name]=$A(anchors).inject([],function(targets,anchor){targets.push(config.targetByAnchor[anchor])
return targets})
return targetsByName})
Log4Js.targetsByName=targetsByName
Log4Js.configVersion++}
Log4Js.pop=function(conf){if(!conf||typeof(conf)!='object'){conf={anchorsByName:{"*":["t1"],Claim:["t2"]},targetByAnchor:{t1:new Log4Js.PopupTarget(Log4Js.ALL,"log4js-%U-%T",true),t2:new Log4Js.PopupTarget(Log4Js.FATAL,"log4js-%U-%T",true)}};}
Cookies.set("log4js.config",conf,{});this.fromConfig(conf);}
Log4Js.add=function(sClassName,enLEVEL){Claim.isString(sClassName,"Log4Js.add(sClassName, enLEVEL) - sClassName must be a string");Claim.isString(enLEVEL,"Log4Js.add(sClassName, enLEVEL) - enLEVEL must Log Level ALL, DEBUG, WARN, ...");var iLevel=this[enLEVEL.toUpperCase()];Claim.isNumber(iLevel,"Log4Js.add(sClassName, enLEVEL) - Log4Js."+enLEVEL+" is not a valid warn-level");Claim.check(iLevel>=0&&iLevel<=6,"0 <= iLevel <= 6","Log4Js.add(sClassName, enLEVEL) - Log4Js[enLEVEL must be between 0 to 6");var conf=this.toConfig();conf.targetByAnchor.newAnchor=new Log4Js.PopupTarget(iLevel,"log4js-%U-%T",true)
conf.anchorsByName[sClassName]=["newAnchor"];this.pop(conf);}
Log4Js.clear=function(sClassName){Claim.isString(sClassName,"Log4Js.clear(sClassName) - sClassName must be a string");var conf=this.toConfig();delete conf.anchorsByName[sClassName];this.pop(conf);}
Log4Js.stop=function(){var conf={anchorsByName:{"*":["t1"]},targetByAnchor:{t1:new Log4Js.PopupTarget(Log4Js.NONE,"log4js-%U-%T",true)}};Cookies.set("log4js.config",conf,{});this.fromConfig(conf);}
Log4Js.preLoad=function(){var config=Cookies.get("log4js.config")
if(config)
Log4Js.fromConfig(config)
PreLoad.log.debug("Start pre-load")}
PreLoad.actions.push(Log4Js.preLoad)
Log4Js.Logger=Class.create()
Log4Js.Logger.prototype={}
Log4Js.Logger.prototype.initialize=function(name){Claim.isString(name,"Log4Js.Logger.name")
this.name=name
this.configVersion=-1}
Log4Js.Logger.prototype.debug=function(text){this.emit(Log4Js.DEBUG,text)}
Log4Js.Logger.prototype.info=function(text){this.emit(Log4Js.INFO,text)}
Log4Js.Logger.prototype.warn=function(text){this.emit(Log4Js.WARN,text)}
Log4Js.Logger.prototype.error=function(text){this.emit(Log4Js.ERROR,text)}
Log4Js.Logger.prototype.fatal=function(text){this.emit(Log4Js.FATAL,text)}
Log4Js.Logger.prototype.emit=function(level,text){if(this.configVersion<Log4Js.configVersion){this.targets=Log4Js.findTargets(this.name)
this.configVersion=Log4Js.configVersion}
if(this.targets.length>0){Claim.isNumber(level,"Log4Js.Logger.emit.level")
Claim.isTrue(Log4Js.DEBUG<=level&&level<=Log4Js.FATAL)
Claim.isScalar(text,"text")
var event={time:new Date().toText(),level:level,name:this.name,text:text,url:location.href}
this.targets.each(function(target){target.emit(event)})}}
Log4Js.AbstractTarget=function(){}
Log4Js.AbstractTarget.prototype={}
Log4Js.AbstractTarget.prototype.emit=function(event){Claim.isObject(event,"Log4Js.AbstractTarget.emit.event")
Claim.isNumber(event.level,"Log4Js.AbstractTarget.emit.event.level")
if(event.level>=this.level)
this._emit(event)}
Log4Js.AlertTarget=Class.create()
Log4Js.AlertTarget.prototype=new Log4Js.AbstractTarget()
Log4Js.AlertTarget.prototype.initialize=function(level){Claim.isNumber(level,"Log4Js.AlertTarget.level")
Claim.isTrue(Log4Js.ALL<=level&&level<=Log4Js.NONE,"Log4Js.AlertTarget.level")
this.level=level}
Log4Js.AlertTarget.prototype._emit=function(event){Claim.isObject(event,"Log4Js.AlertTarget._emit.event")
alert(event.time+" "+event.url+" "+Log4Js.levelNames[event.level]+" "+event.name+":\n"+event.text)}
Log4Js.AlertTarget.prototype.toJson=function(){return"new Log4Js.AlertTarget(Log4Js."+Log4Js.levelNames[this.level].toUpperCase()+")"}
Log4Js.TableTarget=Class.create()
Log4Js.TableTarget.prototype=new Log4Js.AbstractTarget()
Log4Js.TableTarget.prototype.backLog=[]
Log4Js.TableTarget.prototype.initialize=function(level,table,isLastOnTop){Claim.isNumber(level,"Log4Js.TableTarget.level")
Claim.isTrue(Log4Js.ALL<=level&&level<=Log4Js.NONE,"Log4Js.TableTarget.level")
Claim.isObject(table,"Log4Js.TableTarget.table")
Claim.isBoolean(isLastOnTop,"Log4Js.TableTarget.isLastOnTop")
this.level=level
this.isLastOnTop=isLastOnTop
if(typeof(table)=="string"){this.name=table
this.table=$(table)}
else{this.name=table.id
this.table=table}}
Log4Js.TableTarget.prototype.initTable=function(event){Claim.isObject(event,"Log4Js.TableTarget.initTable.event")
this.table=this.table||$(this.name)
if(!this.table)
return false
if(this.table.rows.length>0)
return true
var row=this.table.insertRow(-1)
row.insertCell(-1).innerHTML="Time"
row.insertCell(-1).innerHTML="Level"
row.insertCell(-1).innerHTML="Name"
row.insertCell(-1).innerHTML="Text"
row=this.table.insertRow(-1)
row.insertCell(-1).innerHTML=event.time
row.insertCell(-1).innerHTML="<hr />"
row.insertCell(-1).innerHTML="LOG4JS"
row.insertCell(-1).innerHTML=event.url
row=this.table.insertRow(-1)
row.insertCell(-1).innerHTML=event.time
row.insertCell(-1).innerHTML="<hr />"
row.insertCell(-1).innerHTML="LOG4JS"
row.insertCell(-1).innerHTML=event.url
row=this.table.insertRow(-1)
row.insertCell(-1).innerHTML="Time"
row.insertCell(-1).innerHTML="Level"
row.insertCell(-1).innerHTML="Name"
row.insertCell(-1).innerHTML="Text"
return true}
Log4Js.TableTarget.prototype._emit=function(event){Claim.isObject(event,"Log4Js.TableTarget._emit.event")
this.backLog.push(event)
if(!this.initTable(event))
return
while(this.backLog.length>0){var event=this.backLog.shift()
var row=this.table.insertRow(this.isLastOnTop?2:-1)
row.insertCell(-1).innerHTML=event.time
row.insertCell(-1).innerHTML=Log4Js.levelNames[event.level]
row.insertCell(-1).innerHTML=event.name
row.insertCell(-1).innerHTML=event.text}}
Log4Js.TableTarget.prototype.toJson=function(){return"new Log4Js.TableTarget(Log4Js."+Log4Js.levelNames[this.level].toUpperCase()+","+Cookies.toJson(this.name)+","+Cookies.toJson(this.isLastOnTop)+")"}
Log4Js.PopupTarget=Class.create()
Log4Js.PopupTarget.prototype=new Log4Js.AbstractTarget()
Log4Js.PopupTarget.windows={}
Log4Js.PopupTarget.prototype.initialize=function(level,name,isLastOnTop){Claim.isNumber(level,"Log4Js.Prototype.level")
Claim.isTrue(Log4Js.ALL<=level&&level<=Log4Js.NONE,"Log4Js.Prototype.level")
Claim.isString(name,"Log4Js.Prototype.name")
Claim.isBoolean(isLastOnTop,"Log4Js.Prototype.isLastOnTop")
this.name=name
name=name.replace(/%T/,new Date().toText())
name=name.replace(/%U/,location.href)
name=name.replace(/\W+/g,'_')
name=name.replace(/[_]+/g,'_')
this.windowName=name
this.level=level
this.isLastOnTop=isLastOnTop}
Log4Js.PopupTarget.prototype._emit=function(event){Claim.isObject(event,"Log4Js.Prototype._emit.event")
if(!this.window||this.window.closed){this.window=Log4Js.PopupTarget.windows[name]
if(!this.window||this.window.closed){this.window=Log4Js.PopupTarget.windows[name]=window.open("",this.windowName,'width=640,height=480,'+'scrollbars=1,status=0,toolbars=0,resizable=1')
if(!this.window||this.window.closed){alert("A popup window manager is blocking the logger "+"popup display.\n"+"You need to allow popups to see the logged events.")
this.emit=function(event){}
return}
this.window.document.writeln("<table id='log-table'></table>")
this.window.document.close()}
this.table=this.window.document.getElementById("log-table")
this.target=new Log4Js.TableTarget(this.level,this.table,this.isLastOnTop)}
this.target._emit(event)}
Log4Js.PopupTarget.prototype.toJson=function(){return"new Log4Js.PopupTarget(Log4Js."+Log4Js.levelNames[this.level].toUpperCase()+","+Cookies.toJson(this.name)+","+Cookies.toJson(this.isLastOnTop)+")"}
var Clearance={}
Clearance.MEMBER=0;Clearance.GUEST=1;Clearance.levelNames=["Anonymnous","Unclassified","Restricted","Confidential"]
Clearance.ANONYMOUS=0
Clearance.UNCLASSIFIED=1
Clearance.RESTRICTED=2
Clearance.CONFIDENTIAL=3
Clearance.level=undefined
Clearance.userId=undefined
Clearance.isLevel=function(level){return Clearance.level==level}
Clearance.hasLevel=function(level){Claim.isNumber(level,"Clearance.hasLevel.level")
Claim.isTrue(0<=level&&level<=Clearance.CONFIDENTIAL,"Clearance.hasLevel.level")
if(Clearance.hasLoginType()==true){return Clearance.level>=level}return false;}
Clearance.requireLevel=function(requiredLevel,loginUrl,urlParam){Claim.isNumber(requiredLevel,"Clearance.requireLevel.requiredLevel")
var minLevel=Clearance.ANONYMOUS
var maxLevel=Url.here.protocol=="https"?Clearance.CONFIDENTIAL:Clearance.UNCLASSIFIED
Claim.isTrue(minLevel<=requiredLevel&&requiredLevel<=maxLevel,"Clearance.requireLevel.requiredLevel")
Claim.isString(loginUrl,"Clearance.requireLevel.loginUrl")
Claim.isString(urlParam,"Clearance.requireLevel.urlParam")
Clearance.log.debug("Required: "+requiredLevel+" level: "+Clearance.level)
if(Clearance.level<requiredLevel){var url=Url.appendParamValue(loginUrl,urlParam,location.href)
Clearance.log.info("Redirect to "+url)
location=url}}
Clearance.isUnclassified=function(){return Clearance.isLevel(Clearance.UNCLASSIFIED)}
Clearance.hasUnclassified=function(){return Clearance.hasLevel(Clearance.UNCLASSIFIED)}
Clearance.isGuest=function(){var currentLoginType=Clearance.loginType();if(currentLoginType){if(currentLoginType==Clearance.GUEST)
return true;return false;}}
Clearance.isMember=function(){var currentLoginType=Clearance.loginType();if(currentLoginType){if(currentLoginType==Clearance.MEMBER)
return true;return false;}}
Clearance.hasLoginType=function(){if(Clearance.loginType())
return true;return false;}
Clearance.loginType=function(){var unclCookie=Cookies.get(Clearance.cookieName(Clearance.UNCLASSIFIED,true));if(unclCookie){var cookieParams=unclCookie.en.toQueryParams()
if(cookieParams["LT"])
return cookieParams["LT"];}
return null}
Clearance.refresh=function(){Cookies.preLoad();Clearance.preLoad();}
Clearance.load=function(sessionToken){var sessionQuerystring=sessionToken.replace(/^[^?]*\??/,'');if(sessionQuerystring.length==0)
sessionQuerystring=sessionToken;Url.here.params=sessionQuerystring.split("&").inject({},function(params,paramValue){pair=paramValue.split("=")
params[pair[0]]=unescape(pair[1])
return params})
Clearance.refresh();}
Clearance.requireUnclassified=function(loginUrl,param){Clearance.requireLevel(Clearance.UNCLASSIFIED,loginUrl,param)}
Clearance.isRestricted=function(){return Clearance.isLevel(Clearance.RESTRICTED)}
Clearance.hasRestricted=function(){return Clearance.hasLevel(Clearance.RESTRICTED)},Clearance.requireRestricted=function(loginUrl,param){Clearance.requireLevel(Clearance.RESTRICTED,loginUrl,param)}
Clearance.isConfidential=function(){return Clearance.isLevel(Clearance.CONFIDENTIAL)}
Clearance.hasConfidential=function(){return Clearance.hasLevel(Clearance.CONFIDENTIAL)}
Clearance.requireConfidential=function(loginUrl,param){Clearance.requireLevel(Clearance.CONFIDENTIAL,loginUrl,param)}
Clearance.getExpiration=function(expiration){if(typeof(expiration)!="number")
return
var dateExpiration=new Date(expiration)
var dateNow=new Date()
shouldbeexpired=Number(dateExpiration.getTime())-Number(dateNow.getTime());if(shouldbeexpired>0)
return shouldbeexpired
else
return}
Clearance.getParams=function(level){Claim.isNumber(level,"Clearance.getEncrypted.level")
Claim.isTrue(level>=Clearance.UNCLASSIFIED&&level<=Clearance.CONFIDENTIAL,"Clearance.getEncrypted.level")
if(!Clearance.hasLevel(level))
return null
var params={}
params.ux=Clearance.getExpiration(Clearance.params.ux)
if(params.ux){params.un=Clearance.params.un
params.ui=Clearance.params.ui}else{Clearance.level=0;return null}
if(level>=Clearance.RESTRICTED){params.rx=Clearance.getExpiration(Clearance.params.rx)
if(params.rx)
params.rn=Clearance.params.rn}
if(level>=Clearance.CONFIDENTIAL){params.cx=Clearance.getExpiration(Clearance.params.cx)
if(params.cx)
params.cn=Clearance.params.cn}
return params}
Clearance.getAllLevelParams=function(){var params={}
for(level=1;level<=3;level=level+1){Object.extend(params,Clearance.getParams(level))}
return params;}
Clearance.getMagic=function(level){params=Clearance.getParams(level)
if(params)
return Url.appendParams("",params)
return null}
Clearance.prefix=["Oberon1.A.","Oberon1.U.","Oberon1.R.","Oberon1.C."],Clearance.cookieName=function(level,isTimed){Claim.isNumber(level,"Clearance.cookieName.level")
Claim.isTrue(level>=Clearance.ANONYMOUS&&level<=Clearance.CONFIDENTIAL,"Clearance.cookieName.level")
Claim.isBoolean(isTimed,"Clearance.cookieName.isTimed")
if(level>Clearance.UNCLASSIFIED)
return Clearance.prefix[level]+(isTimed?"T":"S")
else
return Clearance.prefix[level]}
Clearance.setCookies=function(level,userId,encrypted,expires){Claim.isNumber(level,"Clearance.setCookies.level")
Claim.isTrue(level>=Clearance.ANONYMOUS&&level<=Clearance.CONFIDENTIAL,"Clearance.setCookies.level")
if(level!=Clearance.ANONYMOUS)
Claim.isString(userId,"Clearance.setCookies.userId")
Claim.isString(encrypted,"Clearance.setCookies.encrypted")
var value={ui:userId,en:encrypted}
if(expires){value.ex=expires
var date=new Date()
date.setSeconds(date.getSeconds()+Math.round(expires/1000))
Cookies.set(Clearance.cookieName(level,true),value,{expires:date.toUTCString()})
if(level>Clearance.UNCLASSIFIED){Cookies.set(Clearance.cookieName(level,false),value,{expires:undefined})}}
else{Claim.isTrue(level==Clearance.UNCLASSIFIED||level==Clearance.ANONYMOUS,"Clearance.setCookies.level")
Cookies.set(Clearance.cookieName(level,true),value,{expires:undefined})}}
Clearance.clearCookies=function(level){Claim.isNumber(level,"Clearance.clearCookies.level")
Claim.isTrue(level>=Clearance.UNCLASSIFIED&&level<=Clearance.CONFIDENTIAL,"Clearance.clearCookies.level")
Cookies.clear(Clearance.cookieName(level,false),{})
Cookies.clear(Clearance.cookieName(level,true),{})}
Clearance.forget=function(url){Clearance.log.debug("Forget user")
Clearance.clearCookies(Clearance.UNCLASSIFIED)
Clearance.clearCookies(Clearance.RESTRICTED)
Clearance.clearCookies(Clearance.CONFIDENTIAL)
var url=Url.appendParamValue(url,"ui","none")
Clearance.log.info("Redirect to "+url)
location=url}
Clearance.params={},Clearance.preLoad=function(){Clearance.urlParamsToCookies()
Clearance.level=Clearance.ANONYMOUS
Clearance.log.debug("Achieved Anonymnous")
if(Clearance.processCookies(Clearance.UNCLASSIFIED,"un","ux"))
if(Clearance.processCookies(Clearance.RESTRICTED,"rn","rx"))
Clearance.processCookies(Clearance.CONFIDENTIAL,"cn","cx")}
Clearance.urlParamsToCookies=function(){Clearance.log=new Log4Js.Logger("Clearance")
Clearance.level=Clearance.ANONYMOUS
Clearance.log.debug("Try to access current URL clearance parameters")
if(Url.here.params.an){Clearance.setCookies(Clearance.ANONYMOUS,Url.here.params.ui,Url.here.params.an);}
if(Url.here.params.ui){if(Url.here.params.un&&Url.here.params.ux)
Clearance.setCookies(Clearance.UNCLASSIFIED,Url.here.params.ui,Url.here.params.un,((typeof(Url.here.params.ux)=="number")?(Url.here.params.ux*1000.0):Url.here.params.ux))
else if(Url.here.params.un)
Clearance.setCookies(Clearance.UNCLASSIFIED,Url.here.params.ui,Url.here.params.un,null)
else
Clearance.clearCookies(Clearance.UNCLASSIFIED)}
Clearance.log.debug("Strip clearance params from URL")
delete(Url.here.params["ui"])
delete(Url.here.params["un"])
delete(Url.here.params["ux"])
delete(Url.here.params["rn"])
delete(Url.here.params["rx"])
delete(Url.here.params["cn"])
delete(Url.here.params["cx"])
delete(Url.here.params["an"])}
Clearance.processCookies=function(level,en,ex){Claim.isNumber(level,"Clearance.processCookies.level")
Claim.isTrue(level>Clearance.level&&level<=Clearance.CONFIDENTIAL,"Clearance.processCookies.level")
Clearance.log.debug("Process "+Clearance.prefix[level]+" cookies")
var sessionName=Clearance.cookieName(level,false)
var timedName=Clearance.cookieName(level,true)
var session=Cookies.get(sessionName)
var timed=Cookies.get(timedName)
if(!session){Clearance.log.debug("No "+sessionName+" cookie => "+Clearance.levelNames[Clearance.level])
return false}
if(!timed){Clearance.log.debug("No "+timedName+" cookie => "+Clearance.levelNames[Clearance.level])
return false}
if(!session.ui){Clearance.log.debug("No "+sessionName+".ui => "+Clearance.levelNames[Clearance.level])
return false}
if(!timed.ui){Clearance.log.debug("No "+timedName+".ui => "+Clearance.levelNames[Clearance.level])
return false}
if(session.ui!=timed.ui){Clearance.log.debug("Mismatch {"+sessionName+","+timedName+"}.ui => "+Clearance.levelNames[Clearance.level])
return false}
if(!session.en){Clearance.log.debug("No "+sessionName+".en => "+Clearance.levelNames[Clearance.level])
return false}
if(!timed.en){Clearance.log.debug("No "+timedName+".en => "+Clearance.levelNames[Clearance.level])
return false}
if(session.en!=timed.en){Clearance.log.debug("Mismatch {"+sessionName+","+timedName+"}.en => "+Clearance.levelNames[Clearance.level])
return false}
if(level>Clearance.UNCLASSIFIED){if(session.ui!=Clearance.userId){Clearance.log.debug("Mismatch "+sessionName+".ui => "+Clearance.levelNames[Clearance.level])
return false}}
else{Clearance.params.ui=session.ui
Clearance.userId=session.ui}
Clearance.params[en]=session.en
var dateExpired=new Date()
var millExp=timed.ex?timed.ex:1
Clearance.params[ex]=Number(dateExpired.getTime())+Number(millExp)
Clearance.level=level
Clearance.log.debug("Achieved "+Clearance.levelNames[Clearance.level])
return true}
PreLoad.actions.push(Clearance.preLoad)
var Jast={}
Jast.timeout=20000
Jast.pendingRequestByUrl={}
Jast.pendingRequestById={}
Jast.isPreLoad=true
Jast.nextRequestId=0
Jast.activeRequestCount=0
Jast.response=function(id,isOk,result,caching){Claim.isNumber(id,"Jast.response.id")
Claim.isBoolean(isOk,"Jast.response.isOk")
request=Jast.pendingRequestById[id]
if(!request){Jast.Request.log.warn("Unknown load request id: "+id+" isOk: "+isOk)
return}
request.loaded(isOk,result,caching)}
Jast.clearCache=function(){$H(Cookies.valueByName).keys.each(function(name){if(name.substr(0,5)=="Jast.")
Cookies.clear(name)})}
Jast.Request=Class.create()
Jast.Request.prototype={}
Jast.Request.stateNames=["Uninitialized","Loading","Loaded","Interactive","Complete"]
Jast.Request.UNINITIALIZED=0
Jast.Request.LOADING=1
Jast.Request.LOADED=2
Jast.Request.INTERACTIVE=3
Jast.Request.COMPLETE=4
Jast.Request.statusNames=["Create","Success","Failure","Timeout"]
Jast.Request.CREATE=0
Jast.Request.SUCCESS=1
Jast.Request.FAILURE=2
Jast.Request.TIMEOUT=3
Jast.Request.preLoad=function(){Jast.Request.log=new Log4Js.Logger("Jast.Request")}
PreLoad.actions.push(Jast.Request.preLoad)
Jast.Request.onLoad=function(){Jast.isPreLoad=false
var length=Jast.nextRequestId
Jast.Request.log.debug("Complete "+length+" pre-load request(s)")
length.times(function(id){request=Jast.pendingRequestById[id]
if(request&&!request.uses)
if(request.result)
request.complete()
else{if(request.options.timeout>0){request.setTimeout=setTimeout(request.timedOut.bind(request),request.options.timeout)
Jast.Request.log.debug("Reset timeout for Preloaded Request. Request id: "+request.id+" setTimeout: "+request.setTimeout)}}})}
Event.observe(window,"load",Jast.Request.onLoad)
Jast.Request.prototype.initialize=function(url,options){Claim.isString(url,"Jast.Request.url")
this.url=url
this.options={timeout:Jast.timeout,toReuse:true,unimportant:[]}
Object.extend(this.options,options||{})
var parsed=Url.parse(url)
$A(this.options.unimportant).each(function(param){delete(parsed.params[param])})
$A(["un","ux","rn","rx","cn","cx"]).each(function(param){delete(parsed.params[param])})
this.cacheId=Url.appendParams(parsed.base,parsed.params)
this.cacheId="Just."+this.cacheId.replace(/[=;]/g,'_')
this.usedBy=[]
this.id=Jast.nextRequestId++
this.state=-1
this.status=Jast.Request.CREATE
Jast.Request.log.debug("Create request id: "+this.id+" url: "+this.url+" unimportant: "+Cookies.toJson(this.options.unimportant)+" cacheId: "+this.cacheId+" toReuse: "+this.options.toReuse+" timeout: "+this.options.timeout)
this.advanceTo(Jast.Request.UNINITIALIZED)
this.dispatch("onCreate")
var name
var cached=Cookies.get(name=this.cacheId+".T")||Cookies.get(name=this.cacheId+".S")
if(cached){Jast.Request.log.debug("Fetch request id: "+this.id+" from cookie name: "+name)
if(Jast.isPreLoad){Jast.pendingRequestByUrl[this.cacheId]=this
Jast.pendingRequestById[this.id]=this}
this.loaded(cached.isOk,cached.result,undefined)
return}
var request=Jast.pendingRequestByUrl[this.cacheId]
if(request&&this.options.toReuse&&request.options.toReuse&&request.state<=Jast.Request.LOADED){Jast.Request.log.debug("Merge request id: "+this.id+" with request id: "+request.id+" state: "+Jast.Request.stateNames[request.state]+" status: "+Jast.Request.statusNames[request.status])
this.uses=request
this.advanceTo(request.state)
this.result=request.result
this.status=request.status
request.usedBy.push(this)}
else{this.makeRequest()}}
Jast.Request.prototype.makeRequest=function(){this.fullUrl=Url.appendParamValue(this.url,"jastId",this.id)
Jast.Request.log.info("Make request id: "+this.id+" fullUrl: "+this.fullUrl)
this.scriptId="jast-script-"+this.id
Jast.pendingRequestByUrl[this.cacheId]=this
Jast.pendingRequestById[this.id]=this
var isHeadNotExists=(0==document.getElementsByTagName("HEAD").length);if(Jast.isPreLoad&&isHeadNotExists){Jast.Request.log.debug("Write script id: "+this.scriptId+" for request id: "+this.id)
document.write("<"+"script")
document.write(' id="'+this.scriptId+'"')
document.write(' type="text/javascript"')
document.write(' src="'+this.fullUrl+'"')
document.write("></"+"script"+">")}
else{Jast.Request.log.debug("Create script id: "+this.scriptId+" for request id: "+this.id)
script=document.createElement("script")
script.setAttribute("id",this.scriptId)
script.setAttribute("type","text/javascript")
script.setAttribute("src",this.fullUrl)
$T("head").appendChild(script)
if(this.options.timeout>0){this.setTimeout=setTimeout(this.timedOut.bind(this),this.options.timeout)
Jast.Request.log.debug("Request id: "+this.id+" setTimeout: "+this.setTimeout)}}
this.advanceTo(Jast.Request.LOADING)}
Jast.Request.prototype.loaded=function(isOk,result,caching){Claim.isBoolean(isOk,"Jast.Request.loaded.isOk")
if(this.state>=Jast.Request.LOADED){Jast.Request.log.warn("Reloaded request id: "+this.id+" isOk: "+isOk)
return}
Jast.Request.log.info("Loaded request id: "+this.id+" isOk: "+isOk)
if(this.setTimeout){clearTimeout(this.setTimeout)
Jast.Request.log.debug("Request id: "+this.id+" clearTimeout: "+this.setTimeout)
delete(this["setTimeout"])}
if(caching&&caching.expires||session){var value={isOk:isOk,result:result}
var session=caching.session
delete(caching["session"])
if(caching.expires){Jast.Request.log.debug("Cache in: "+this.cacheId+".T for "+caching.expires+"ms")
Cookies.set(this.cacheId+".T",value,caching)}
delete(caching["expires"])
if(session){Jast.Request.log.debug("Cache in: "+this.cacheId+".S for rest of session")
Cookies.set(this.cacheId+".S",value,caching)}}
this.advanceTo(Jast.Request.LOADED)
this.result=result
this.status=isOk?Jast.Request.SUCCESS:Jast.Request.FAILURE
var status=this.status
this.usedBy.each(function(request){request.result=result
request.status=status})
if(!Jast.isPreLoad)
this.complete()}
Jast.Request.prototype.timedOut=function(){if(this.state>=Jast.Request.LOADED){Jast.Request.log.warn("Retimedout request id: "+this.id)
return}
Jast.Request.log.info("Timedout request id: "+this.id)
this.advanceTo(Jast.Request.LOADED)
this.status=Jast.Request.TIMEOUT
this.usedBy.each(function(request){request.status=Jast.Request.TIMEOUT})
this.complete()}
Jast.Request.prototype.complete=function(){Jast.Request.log.debug("Complete request id: "+this.id)
this.advanceTo(Jast.Request.INTERACTIVE)
this.dispatchUsed("on"+Jast.Request.statusNames[this.status])
this.advanceTo(Jast.Request.COMPLETE)
delete(Jast.pendingRequestByUrl[this.cacheId])
delete(Jast.pendingRequestById[this.id])
this.usedBy.each(function(request){delete(Jast.pendingRequestById[request.id])})
if(this.scriptId){Jast.Request.log.debug("Remove script id: "+this.scriptId+" for request id: "+this.id)
var script=$I(this.scriptId)
script.parentNode.removeChild(script)}}
Jast.Request.prototype.advanceTo=function(state){Claim.isNumber(state,"Jast.Remove.advanceTo.state")
Claim.isTrue(0<=state&&state<=Jast.Request.COMPLETE,"Jast.Remove.advanceTo.state")
while(this.state<state){var nextState=this.state++
this.dispatch("on"+Jast.Request.stateNames[this.state])
this.usedBy.each(function(request){request.advanceTo(nextState)})}}
Jast.Request.prototype.dispatch=function(event){Claim.isString(event,"Jast.Request.dispatch.event")
Jast.Request.log.debug("Dispatch event: "+event+" for request id: "+this.id)
if(this.options[event]){try{this.options[event](this)}
catch(e){Jast.Request.log.warn("Exception in "+event+" for request id: "+request.id+" exception: "+e.message);}}
Jast.Responders.dispatch(event,this)}
Jast.Request.prototype.dispatchUsed=function(event){Claim.isString(event,"Jast.Responders.dispatchUsed.event")
Jast.Request.log.debug("DispatchUsed event: "+event+" for request id: "+this.id)
this.dispatch(event)
this.usedBy.each(function(request){request.dispatchUsed(event)})}
Jast.Responders={}
Jast.Responders.responders=[]
Jast.Responders._each=function(iterator){Claim.isObject(iterator,"Jast.Responders._each.iterator")
this.responders._each(iterator)}
Jast.Responders.register=function(responderToAdd){Claim.isObject(responderToAdd,"Jast.Request.register.responderToAdd")
if(!this.include(responderToAdd))
this.responders.push(responderToAdd)}
Jast.Responders.unregister=function(responderToRemove){Claim.isObject(responderToRemove,"Jast.Responders.unregister.responderToRemove")
this.responders=this.responders.without(responderToRemove)}
Jast.Responders.dispatch=function(event,request){Claim.isString(event,"Jast.Responders.dispatch.event")
Claim.isObject(request,"Jast.Responders.dispatch.request")
Claim.isNumber(request.id,"Jast.Responders.dispatch.request.id")
this.log.debug("Dispatch event "+event+" for request id: "+request.id)
this.each(function(responder){if(responder[event]){try{responder[event](request)}
catch(e){this.log.warn(" Exception in "+event+" for request id: "+request.id+" exception: "+e.message);}}})}
Jast.Responders.preLoad=function(){Jast.Responders.log=new Log4Js.Logger("Jast.Responders")}
Object.extend(Jast.Responders,Enumerable)
PreLoad.actions.push(Jast.Responders.preLoad)
Jast.Responders.register({onCreate:function(){Jast.activeRequestCount++
Jast.Responders.log.debug("Active requests up to "+Jast.activeRequestCount)
Claim.isTrue(Jast.activeRequestCount>=1,"Jast.Responders.activeRequestCount")},onComplete:function(){Jast.activeRequestCount--
Jast.Responders.log.debug("Active requests down to "+Jast.activeRequestCount)
Claim.isTrue(Jast.activeRequestCount>=0,"Jast.Responders.activeRequestCount")}})
$A(PreLoad.actions).each(function(action){action()})
//::: Omniture Web Analysis 00:00:00.0312508


/************* DO NOT ALTER ANYTHING BELOW THIS LINE ! **************/
var s_objectID;function s_c2fe(f){var x='',s=0,e,a,b,c;while(1){e=
f.indexOf('"',s);b=f.indexOf('\\',s);c=f.indexOf("\n",s);if(e<0||(b>=
0&&b<e))e=b;if(e<0||(c>=0&&c<e))e=c;if(e>=0){x+=(e>s?f.substring(s,e):
'')+(e==c?'\\n':'\\'+f.substring(e,e+1));s=e+1}else return x
+f.substring(s)}return f}function s_c2fa(f){var s=f.indexOf('(')+1,e=
f.indexOf(')'),a='',c;while(s>=0&&s<e){c=f.substring(s,s+1);if(c==',')
a+='","';else if(("\n\r\t ").indexOf(c)<0)a+=c;s++}return a?'"'+a+'"':
a}function s_c2f(cc){cc=''+cc;var fc='var f=new Function(',s=
cc.indexOf(';',cc.indexOf('{')),e=cc.lastIndexOf('}'),o,a,d,q,c,f,h,x
fc+=s_c2fa(cc)+',"var s=new Object;';c=cc.substring(s+1,e);s=
c.indexOf('function');while(s>=0){d=1;q='';x=0;f=c.substring(s);a=
s_c2fa(f);e=o=c.indexOf('{',s);e++;while(d>0){h=c.substring(e,e+1);if(
q){if(h==q&&!x)q='';if(h=='\\')x=x?0:1;else x=0}else{if(h=='"'||h=="'"
)q=h;if(h=='{')d++;if(h=='}')d--}if(d>0)e++}c=c.substring(0,s)
+'new Function('+(a?a+',':'')+'"'+s_c2fe(c.substring(o+1,e))+'")'
+c.substring(e+1);s=c.indexOf('function')}fc+=s_c2fe(c)+';return s");'
eval(fc);return f}function s_gi(un,pg,ss){var c="function s_c(un,pg,s"
+"s){var s=this;s.wd=window;if(!s.wd.s_c_in){s.wd.s_c_il=new Array;s."
+"wd.s_c_in=0;}s._il=s.wd.s_c_il;s._in=s.wd.s_c_in;s._il[s._in]=s;s.w"
+"d.s_c_in++;s.m=function(m){return (''+m).indexOf('{')<0};s.fl=funct"
+"ion(x,l){return x?(''+x).substring(0,l):x};s.co=function(o){if(!o)r"
+"eturn o;var n=new Object,x;for(x in o)if(x.indexOf('select')<0&&x.i"
+"ndexOf('filter')<0)n[x]=o[x];return n};s.num=function(x){x=''+x;for"
+"(var p=0;p<x.length;p++)if(('0123456789').indexOf(x.substring(p,p+1"
+"))<0)return 0;return 1};s.rep=function(x,o,n){var i=x.indexOf(o);wh"
+"ile(x&&i>=0){x=x.substring(0,i)+n+x.substring(i+o.length);i=x.index"
+"Of(o,i+n.length)}return x};s.ape=function(x){var s=this,i;x=x?s.rep"
+"(escape(''+x),'+','%2B'):x;if(x&&s.charSet&&s.em==1&&x.indexOf('%u'"
+")<0&&x.indexOf('%U')<0){i=x.indexOf('%');while(i>=0){i++;if(('89ABC"
+"DEFabcdef').indexOf(x.substring(i,i+1))>=0)return x.substring(0,i)+"
+"'u00'+x.substring(i);i=x.indexOf('%',i)}}return x};s.epa=function(x"
+"){var s=this;return x?unescape(s.rep(''+x,'+',' ')):x};s.pt=functio"
+"n(x,d,f,a){var s=this,t=x,z=0,y,r;while(t){y=t.indexOf(d);y=y<0?t.l"
+"ength:y;t=t.substring(0,y);r=s.m(f)?s[f](t,a):f(t,a);if(r)return r;"
+"z+=y+d.length;t=x.substring(z,x.length);t=z<x.length?t:''}return ''"
+"};s.isf=function(t,a){var c=a.indexOf(':');if(c>=0)a=a.substring(0,"
+"c);if(t.substring(0,2)=='s_')t=t.substring(2);return (t!=''&&t==a)}"
+";s.fsf=function(t,a){var s=this;if(s.pt(a,',','isf',t))s.fsg+=(s.fs"
+"g!=''?',':'')+t;return 0};s.fs=function(x,f){var s=this;s.fsg='';s."
+"pt(x,',','fsf',f);return s.fsg};s.c_d='';s.c_gdf=function(t,a){var "
+"s=this;if(!s.num(t))return 1;return 0};s.c_gd=function(){var s=this"
+",d=s.wd.location.hostname,n=s.fpCookieDomainPeriods,p;if(!n)n=s.coo"
+"kieDomainPeriods;if(d&&!s.c_d){n=n?parseInt(n):2;n=n>2?n:2;p=d.last"
+"IndexOf('.');if(p>=0){while(p>=0&&n>1){p=d.lastIndexOf('.',p-1);n--"
+"}s.c_d=p>0&&s.pt(d,'.','c_gdf',0)?d.substring(p):d}}return s.c_d};s"
+".c_r=function(k){var s=this;k=s.ape(k);var c=' '+s.d.cookie,i=c.ind"
+"exOf(' '+k+'='),e=i<0?i:c.indexOf(';',i),v=i<0?'':s.epa(c.substring"
+"(i+2+k.length,e<0?c.length:e));return v!='[[B]]'?v:''};s.c_w=functi"
+"on(k,v,e){var s=this,d=s.c_gd(),l=s.cookieLifetime,t;v=''+v;l=l?(''"
+"+l).toUpperCase():'';if(e&&l!='SESSION'&&l!='NONE'){t=(v!=''?parseI"
+"nt(l?l:0):-60);if(t){e=new Date;e.setTime(e.getTime()+(t*1000))}}if"
+"(k&&l!='NONE'){s.d.cookie=k+'='+s.ape(v!=''?v:'[[B]]')+'; path=/;'+"
+"(e&&l!='SESSION'?' expires='+e.toGMTString()+';':'')+(d?' domain='+"
+"d+';':'');return s.c_r(k)==v}return 0};s.eh=function(o,e,r,f){var s"
+"=this,b='s_'+e+'_'+s._in,n=-1,l,i,x;if(!s.ehl)s.ehl=new Array;l=s.e"
+"hl;for(i=0;i<l.length&&n<0;i++){if(l[i].o==o&&l[i].e==e)n=i}if(n<0)"
+"{n=i;l[n]=new Object}x=l[n];x.o=o;x.e=e;f=r?x.b:f;if(r||f){x.b=r?0:"
+"o[e];x.o[e]=f}if(x.b){x.o[b]=x.b;return b}return 0};s.cet=function("
+"f,a,t,o,b){var s=this,r;if(s.apv>=5&&(!s.isopera||s.apv>=7))eval('t"
+"ry{r=s.m(f)?s[f](a):f(a)}catch(e){r=s.m(t)?s[t](e):t(e)}');else{if("
+"s.ismac&&s.u.indexOf('MSIE 4')>=0)r=s.m(b)?s[b](a):b(a);else{s.eh(s"
+".wd,'onerror',0,o);r=s.m(f)?s[f](a):f(a);s.eh(s.wd,'onerror',1)}}re"
+"turn r};s.gtfset=function(e){var s=this;return s.tfs};s.gtfsoe=new "
+"Function('e','var s=s_c_il['+s._in+'];s.eh(window,\"onerror\",1);s."
+"etfs=1;var c=s.t();if(c)s.d.write(c);s.etfs=0;return true');s.gtfsf"
+"b=function(a){return window};s.gtfsf=function(w){var s=this,p=w.par"
+"ent,l=w.location;s.tfs=w;if(p&&p.location!=l&&p.location.host==l.ho"
+"st){s.tfs=p;return s.gtfsf(s.tfs)}return s.tfs};s.gtfs=function(){v"
+"ar s=this;if(!s.tfs){s.tfs=s.wd;if(!s.etfs)s.tfs=s.cet('gtfsf',s.tf"
+"s,'gtfset',s.gtfsoe,'gtfsfb')}return s.tfs};s.ca=function(){var s=t"
+"his,imn='s_i_'+s.fun;if(s.d.images&&s.apv>=3&&(!s.isopera||s.apv>=7"
+")&&(s.ns6<0||s.apv>=6.1)){s.ios=1;if(!s.d.images[imn]&&(!s.isns||(s"
+".apv<4||s.apv>=5))){s.d.write('<im'+'g name=\"'+imn+'\" height=1 wi"
+"dth=1 border=0 alt=\"\">');if(!s.d.images[imn])s.ios=0}}};s.mr=func"
+"tion(sess,q,ta){var s=this,dc=s.dc,t1=s.trackingServer,t2=s.trackin"
+"gServerSecure,ns=s.visitorNamespace,unc=s.rep(s.fun,'_','-'),imn='s"
+"_i_'+s.fun,im,b,e,rs='http'+(s.ssl?'s':'')+'://'+(t1?(s.ssl&&t2?t2:"
+"t1):((ns?ns:(s.ssl?'102':unc))+'.'+(s.dc?s.dc:112)+'.2o7.net'))+'/b"
+"/ss/'+s.un+'/1/H.9-pdv-2/'+sess+'?[AQB]&ndh=1'+(q?q:'')+(s.q?s.q:''"
+")+'&[AQE]';if(s.isie&&!s.ismac){if(s.apv>5.5)rs=s.fl(rs,4095);else "
+"rs=s.fl(rs,2047)}if(s.ios||s.ss){if (!s.ss)s.ca();im=s.wd[imn]?s.wd"
+"[imn]:s.d.images[imn];if(!im)im=s.wd[imn]=new Image;im.src=rs;if(rs"
+".indexOf('&pe=')>=0&&(!ta||ta=='_self'||ta=='_top'||(s.wd.name&&ta="
+"=s.wd.name))){b=e=new Date;while(e.getTime()-b.getTime()<500)e=new "
+"Date}return ''}return '<im'+'g sr'+'c=\"'+rs+'\" width=1 height=1 b"
+"order=0 alt=\"\">'};s.gg=function(v){var s=this;return s.wd['s_'+v]"
+"};s.glf=function(t,a){if(t.substring(0,2)=='s_')t=t.substring(2);va"
+"r s=this,v=s.gg(t);if(v)s[t]=v};s.gl=function(v){var s=this;s.pt(v,"
+"',','glf',0)};s.gv=function(v){var s=this;return s['vpm_'+v]?s['vpv"
+"_'+v]:(s[v]?s[v]:'')};s.havf=function(t,a){var s=this,b=t.substring"
+"(0,4),x=t.substring(4),n=parseInt(x),k='g_'+t,m='vpm_'+t,q=t,v=s.li"
+"nkTrackVars,e=s.linkTrackEvents;s[k]=s.gv(t);if(s.lnk||s.eo){v=v?v+"
+"','+s.vl_l:'';if(v&&!s.pt(v,',','isf',t))s[k]='';if(t=='events'&&e)"
+"s[k]=s.fs(s[k],e)}s[m]=0;if(t=='visitorID')q='vid';else if(t=='page"
+"URL')q='g';else if(t=='referrer')q='r';else if(t=='vmk')q='vmt';els"
+"e if(t=='charSet'){q='ce';if(s[k]&&s.em==2)s[k]='UTF-8'}else if(t=="
+"'visitorNamespace')q='ns';else if(t=='cookieDomainPeriods')q='cdp';"
+"else if(t=='cookieLifetime')q='cl';else if(t=='variableProvider')q="
+"'vvp';else if(t=='currencyCode')q='cc';else if(t=='channel')q='ch';"
+"else if(t=='campaign')q='v0';else if(s.num(x)) {if(b=='prop')q='c'+"
+"n;else if(b=='eVar')q='v'+n;else if(b=='hier'){q='h'+n;s[k]=s.fl(s["
+"k],255)}}if(s[k]&&t!='linkName'&&t!='linkType')s.qav+='&'+q+'='+s.a"
+"pe(s[k]);return ''};s.hav=function(){var s=this;s.qav='';s.pt(s.vl_"
+"t,',','havf',0);return s.qav};s.lnf=function(t,h){t=t?t.toLowerCase"
+"():'';h=h?h.toLowerCase():'';var te=t.indexOf('=');if(t&&te>0&&h.in"
+"dexOf(t.substring(te+1))>=0)return t.substring(0,te);return ''};s.l"
+"n=function(h){var s=this,n=s.linkNames;if(n)return s.pt(n,',','lnf'"
+",h);return ''};s.ltdf=function(t,h){t=t?t.toLowerCase():'';h=h?h.to"
+"LowerCase():'';var qi=h.indexOf('?');h=qi>=0?h.substring(0,qi):h;if"
+"(t&&h.substring(h.length-(t.length+1))=='.'+t)return 1;return 0};s."
+"ltef=function(t,h){t=t?t.toLowerCase():'';h=h?h.toLowerCase():'';if"
+"(t&&h.indexOf(t)>=0)return 1;return 0};s.lt=function(h){var s=this,"
+"lft=s.linkDownloadFileTypes,lef=s.linkExternalFilters,lif=s.linkInt"
+"ernalFilters;lif=lif?lif:s.wd.location.hostname;h=h.toLowerCase();i"
+"f(s.trackDownloadLinks&&lft&&s.pt(lft,',','ltdf',h))return 'd';if(s"
+".trackExternalLinks&&(lef||lif)&&(!lef||s.pt(lef,',','ltef',h))&&(!"
+"lif||!s.pt(lif,',','ltef',h)))return 'e';return ''};s.lc=new Functi"
+"on('e','var s=s_c_il['+s._in+'],b=s.eh(this,\"onclick\");s.lnk=s.co"
+"(this);s.t();s.lnk=0;if(b)return this[b](e);return true');s.bc=new "
+"Function('e','var s=s_c_il['+s._in+'],f;if(s.d&&s.d.all&&s.d.all.cp"
+"pXYctnr)return;s.eo=e.srcElement?e.srcElement:e.target;eval(\"try{i"
+"f(s.eo&&(s.eo.tagName||s.eo.parentElement||s.eo.parentNode))s.t()}c"
+"atch(f){}\");s.eo=0');s.ot=function(o){var a=o.type,b=o.tagName;ret"
+"urn (a&&a.toUpperCase?a:b&&b.toUpperCase?b:o.href?'A':'').toUpperCa"
+"se()};s.oid=function(o){var s=this,t=s.ot(o),p=o.protocol,c=o.oncli"
+"ck,n='',x=0;if(!o.s_oid){if(o.href&&(t=='A'||t=='AREA')&&(!c||!p||p"
+".toLowerCase().indexOf('javascript')<0))n=o.href;else if(c){n=s.rep"
+"(s.rep(s.rep(s.rep(''+c,\"\\r\",''),\"\\n\",''),\"\\t\",''),' ','')"
+";x=2}else if(o.value&&(t=='INPUT'||t=='SUBMIT')){n=o.value;x=3}else"
+" if(o.src&&t=='IMAGE')n=o.src;if(n){o.s_oid=s.fl(n,100);o.s_oidt=x}"
+"}return o.s_oid};s.rqf=function(t,un){var s=this,e=t.indexOf('='),u"
+"=e>=0?','+t.substring(0,e)+',':'';return u&&u.indexOf(','+un+',')>="
+"0?s.epa(t.substring(e+1)):''};s.rq=function(un){var s=this,c=un.ind"
+"exOf(','),v=s.c_r('s_sq'),q='';if(c<0)return s.pt(v,'&','rqf',un);r"
+"eturn s.pt(un,',','rq',0)};s.sqp=function(t,a){var s=this,e=t.index"
+"Of('='),q=e<0?'':s.epa(t.substring(e+1));s.sqq[q]='';if(e>=0)s.pt(t"
+".substring(0,e),',','sqs',q);return 0};s.sqs=function(un,q){var s=t"
+"his;s.squ[un]=q;return 0};s.sq=function(q){var s=this,k='s_sq',v=s."
+"c_r(k),x,c=0;s.sqq=new Object;s.squ=new Object;s.sqq[q]='';s.pt(v,'"
+"&','sqp',0);s.pt(s.un,',','sqs',q);v='';for(x in s.squ)s.sqq[s.squ["
+"x]]+=(s.sqq[s.squ[x]]?',':'')+x;for(x in s.sqq)if(x&&s.sqq[x]&&(x=="
+"q||c<2)){v+=(v?'&':'')+s.sqq[x]+'='+s.ape(x);c++}return s.c_w(k,v,0"
+")};s.wdl=new Function('e','var s=s_c_il['+s._in+'],r=true,b=s.eh(s."
+"wd,\"onload\"),i,o,oc;if(b)r=this[b](e);for(i=0;i<s.d.links.length;"
+"i++){o=s.d.links[i];oc=o.onclick?\"\"+o.onclick:\"\";if((oc.indexOf"
+"(\"s_gs(\")<0||oc.indexOf(\".s_oc(\")>=0)&&oc.indexOf(\".tl(\")<0)s"
+".eh(o,\"onclick\",0,s.lc);}return r');s.wds=function(){var s=this;i"
+"f(s.apv>3&&(!s.isie||!s.ismac||s.apv>=5)){if(s.b&&s.b.attachEvent)s"
+".b.attachEvent('onclick',s.bc);else if(s.b&&s.b.addEventListener)s."
+"b.addEventListener('click',s.bc,false);else s.eh(s.wd,'onload',0,s."
+"wdl)}};s.vs=function(x){var s=this,v=s.visitorSampling,g=s.visitorS"
+"amplingGroup,k='s_vsn_'+s.un+(g?'_'+g:''),n=s.c_r(k),e=new Date,y=e"
+".getYear();e.setYear(y+10+(y<1900?1900:0));if(v){v*=100;if(!n){if(!"
+"s.c_w(k,x,e))return 0;n=x}if(n%10000>v)return 0}return 1};s.dyasmf="
+"function(t,m){if(t&&m&&m.indexOf(t)>=0)return 1;return 0};s.dyasf=f"
+"unction(t,m){var s=this,i=t?t.indexOf('='):-1,n,x;if(i>=0&&m){var n"
+"=t.substring(0,i),x=t.substring(i+1);if(s.pt(x,',','dyasmf',m))retu"
+"rn n}return 0};s.uns=function(){var s=this,x=s.dynamicAccountSelect"
+"ion,l=s.dynamicAccountList,m=s.dynamicAccountMatch,n,i;s.un.toLower"
+"Case();if(x&&l){if(!m)m=s.wd.location.host;if(!m.toLowerCase)m=''+m"
+";l=l.toLowerCase();m=m.toLowerCase();n=s.pt(l,';','dyasf',m);if(n)s"
+".un=n}i=s.un.indexOf(',');s.fun=i<0?s.un:s.un.substring(0,i)};s.sa="
+"function(un){s.un=un;if(!s.oun)s.oun=un;else if((','+s.oun+',').ind"
+"exOf(un)<0)s.oun+=','+un;s.uns()};s.t=function(){var s=this,trk=1,t"
+"m=new Date,sed=Math&&Math.random?Math.floor(Math.random()*100000000"
+"00000):tm.getTime(),sess='s'+Math.floor(tm.getTime()/10800000)%10+s"
+"ed,yr=tm.getYear(),vt=tm.getDate()+'/'+tm.getMonth()+'/'+(yr<1900?y"
+"r+1900:yr)+' '+tm.getHours()+':'+tm.getMinutes()+':'+tm.getSeconds("
+")+' '+tm.getDay()+' '+tm.getTimezoneOffset(),tfs=s.gtfs(),ta='',q='"
+"',qs='';s.uns();if(!s.q){var tl=tfs.location,x='',c='',v='',p='',bw"
+"='',bh='',j='1.0',k=s.c_w('s_cc','true',0)?'Y':'N',hp='',ct='',pn=0"
+",ps;if(s.apv>=4)x=screen.width+'x'+screen.height;if(s.isns||s.isope"
+"ra){if(s.apv>=3){j='1.1';v=s.n.javaEnabled()?'Y':'N';if(s.apv>=4){j"
+"='1.2';c=screen.pixelDepth;bw=s.wd.innerWidth;bh=s.wd.innerHeight;i"
+"f(s.apv>=4.06)j='1.3'}}s.pl=s.n.plugins}else if(s.isie){if(s.apv>=4"
+"){v=s.n.javaEnabled()?'Y':'N';j='1.2';c=screen.colorDepth;if(s.apv>"
+"=5){bw=s.d.documentElement.offsetWidth;bh=s.d.documentElement.offse"
+"tHeight;j='1.3';if(!s.ismac&&s.b){s.b.addBehavior('#default#homePag"
+"e');hp=s.b.isHomePage(tl)?\"Y\":\"N\";s.b.addBehavior('#default#cli"
+"entCaps');ct=s.b.connectionType}}}else r=''}if(s.pl)while(pn<s.pl.l"
+"ength&&pn<30){ps=s.fl(s.pl[pn].name,100)+';';if(p.indexOf(ps)<0)p+="
+"ps;pn++}s.q=(x?'&s='+s.ape(x):'')+(c?'&c='+s.ape(c):'')+(j?'&j='+j:"
+"'')+(v?'&v='+v:'')+(k?'&k='+k:'')+(bw?'&bw='+bw:'')+(bh?'&bh='+bh:'"
+"')+(ct?'&ct='+s.ape(ct):'')+(hp?'&hp='+hp:'')+(p?'&p='+s.ape(p):'')"
+"}if(s.usePlugins)s.doPlugins(s);var l=s.wd.location,r=tfs.document."
+"referrer;if(!s.pageURL)s.pageURL=s.fl(l?l:'',255);if(!s.referrer)s."
+"referrer=s.fl(r?r:'',255);if(s.lnk||s.eo){var o=s.eo?s.eo:s.lnk;if("
+"!o)return '';var p=s.gv('pageName'),w=1,t=s.ot(o),n=s.oid(o),x=o.s_"
+"oidt,h,l,i,oc;if(s.eo&&o==s.eo){while(o&&!n&&t!='BODY'){o=o.parentE"
+"lement?o.parentElement:o.parentNode;if(!o)return '';t=s.ot(o);n=s.o"
+"id(o);x=o.s_oidt}oc=o.onclick?''+o.onclick:'';if((oc.indexOf(\"s_gs"
+"(\")>=0&&oc.indexOf(\".s_oc(\")<0)||oc.indexOf(\".tl(\")>=0)return "
+"''}ta=n?o.target:1;h=o.href?o.href:'';i=h.indexOf('?');h=s.linkLeav"
+"eQueryString||i<0?h:h.substring(0,i);l=s.linkName?s.linkName:s.ln(h"
+");t=s.linkType?s.linkType.toLowerCase():s.lt(h);if(t&&(h||l))q+='&p"
+"e=lnk_'+(t=='d'||t=='e'?s.ape(t):'o')+(h?'&pev1='+s.ape(h):'')+(l?'"
+"&pev2='+s.ape(l):'');else trk=0;if(s.trackInlineStats){if(!p){p=s.g"
+"v('pageURL');w=0}t=s.ot(o);i=o.sourceIndex;if(s.gg('objectID')){n=s"
+".gg('objectID');x=1;i=1}if(p&&n&&t)qs='&pid='+s.ape(s.fl(p,255))+(w"
+"?'&pidt='+w:'')+'&oid='+s.ape(s.fl(n,100))+(x?'&oidt='+x:'')+'&ot='"
+"+s.ape(t)+(i?'&oi='+i:'')}}if(!trk&&!qs)return '';if(s.p_r)s.p_r();"
+"var code='';if(trk&&s.vs(sed))code=s.mr(sess,(vt?'&t='+s.ape(vt):''"
+")+s.hav()+q+(qs?qs:s.rq(s.un)),ta);s.sq(trk?'':qs);s.lnk=s.eo=s.lin"
+"kName=s.linkType=s.wd.s_objectID=s.ppu='';return code};s.tl=functio"
+"n(o,t,n){var s=this;s.lnk=s.co(o);s.linkType=t;s.linkName=n;s.t()};"
+"s.ssl=(s.wd.location.protocol.toLowerCase().indexOf('https')>=0);s."
+"d=document;s.b=s.d.body;s.n=navigator;s.u=s.n.userAgent;s.ns6=s.u.i"
+"ndexOf('Netscape6/');var apn=s.n.appName,v=s.n.appVersion,ie=v.inde"
+"xOf('MSIE '),o=s.u.indexOf('Opera '),i;if(v.indexOf('Opera')>=0||o>"
+"0)apn='Opera';s.isie=(apn=='Microsoft Internet Explorer');s.isns=(a"
+"pn=='Netscape');s.isopera=(apn=='Opera');s.ismac=(s.u.indexOf('Mac'"
+")>=0);if(o>0)s.apv=parseFloat(s.u.substring(o+6));else if(ie>0){s.a"
+"pv=parseInt(i=v.substring(ie+5));if(s.apv>3)s.apv=parseFloat(i)}els"
+"e if(s.ns6>0)s.apv=parseFloat(s.u.substring(s.ns6+10));else s.apv=p"
+"arseFloat(v);s.em=0;if(String.fromCharCode){i=escape(String.fromCha"
+"rCode(256)).toUpperCase();s.em=(i=='%C4%80'?2:(i=='%U0100'?1:0))}s."
+"sa(un);s.vl_l='visitorID,vmk,ppu,charSet,visitorNamespace,cookieDom"
+"ainPeriods,cookieLifetime,pageName,pageURL,referrer,currencyCode,pu"
+"rchaseID';s.vl_t=s.vl_l+',variableProvider,channel,server,pageType,"
+"campaign,state,zip,events,products,linkName,linkType';for(var n=1;n"
+"<51;n++)s.vl_t+=',prop'+n+',eVar'+n+',hier'+n;s.vl_g=s.vl_t+',track"
+"DownloadLinks,trackExternalLinks,trackInlineStats,linkLeaveQueryStr"
+"ing,linkDownloadFileTypes,linkExternalFilters,linkInternalFilters,l"
+"inkNames';if(pg)s.gl(s.vl_g);s.ss=ss;if(!ss){s.wds();s.ca()}}",
l=window.s_c_il,n=navigator,u=n.userAgent,v=n.appVersion,e=v.indexOf(
'MSIE '),m=u.indexOf('Netscape6/'),a,i,s;if(l)for(i=0;i<l.length;i++){
s=l[i];if(s.oun==un)return s;else if(s.fs(s.oun,un)){s.sa(un);return s
}}if(e>0){a=parseInt(i=v.substring(e+5));if(a>3)a=parseFloat(i)}
else if(m>0)a=parseFloat(u.substring(m+10));else a=parseFloat(v);if(a
>=5&&v.indexOf('Opera')<0&&u.indexOf('Opera')<0){eval(c);return new
s_c(un,pg,ss)}else s=s_c2f(c);return s(un,pg,ss)}



//::: Omniture Web Analysis 00:00:00.0312508

String.prototype.trim=function(){var spacesRegEx=/^[ \t\n]+|[ \t\n]+$/g;return this.replace(spacesRegEx,"");}
if(!window.GameCatalog)
GameCatalog={};if(!GameCatalog.WebAnalysis)
GameCatalog.WebAnalysis={};if(!GameCatalog.WebAnalysis.SiteTracking)
GameCatalog.WebAnalysis.SiteTracking={};GameCatalog.WebAnalysis.SiteTracking.GetInternalID=function()
{return Url.here.params.intID||'';}
GameCatalog.WebAnalysis.SiteTracking.Replacer=function(str)
{this.rep=function(a)
{var result=GameCatalog.WebAnalysis.SiteTracking.Replacer.symbols[a]();if(result==null||result==undefined)
return a;else
return result;}
if(str===undefined||str===null)
return'';return(str+'').replace(/(%%[^%]*%%)/g,this.rep).trim();}
GameCatalog.WebAnalysis.SiteTracking.hashCurrentSParams={};GameCatalog.WebAnalysis.SiteTracking.PreparePageParams=function(pageName,data)
{var pageData=GameCatalog.WebAnalysis.SiteTracking[pageName];if(pageData==null&&data!=null)
pageData=data;else if(pageData==null&&data==null)
return;GameCatalog.WebAnalysis.SiteTracking.ClearParams();for(p in pageData)
{if(typeof(pageData[p])=='function')
{try{s[p]=pageData[p]();}
catch(ex)
{s[p]="";}}
else
s[p]=pageData[p];GameCatalog.WebAnalysis.SiteTracking.hashCurrentSParams[p]="";}}
GameCatalog.WebAnalysis.SiteTracking.trackCustomLinkClicked=function(obj,linkName,data)
{if(obj==null||obj==undefined)
return;GameCatalog.WebAnalysis.SiteTracking.PreparePageParams("GameShellCustomLink",data);var lt=obj.href!=null?s.lt(obj.href):"";if(lt==""){s.tl(obj,'o',linkName);}}
GameCatalog.WebAnalysis.SiteTracking.submitEvent=function(pageName,data)
{GameCatalog.WebAnalysis.SiteTracking.PreparePageParams(pageName,data);s.t();}
GameCatalog.WebAnalysis.SiteTracking.ClearParams=function()
{for(p in GameCatalog.WebAnalysis.SiteTracking.hashCurrentSParams)
{delete s[p];}
GameCatalog.WebAnalysis.SiteTracking.hashCurrentSParams={};}
function GetScriptSrcQueryString()
{var src="";var pageName=GetPageName();src="pagefilename="+pageName;src+="&"+document.location.search.substr(1);return src;}
function GetPageName()
{var name=document.location.pathname.split("/")[document.location.pathname.split("/").length-1].split(".")[0];if(name)
name=name.toLowerCase();return name||"homepage";}
function getCookie(name){var index=document.cookie.indexOf(name+"=");if(index==-1)return null;index=document.cookie.indexOf("=",index)+1;var endstr=document.cookie.indexOf(";",index);if(endstr==-1)endstr=document.cookie.length;return unescape(document.cookie.substring(index,endstr));}
function setCookie(name,value,expiration){GameCatalog.WebAnalysis.SiteTracking.setCookie(name,value,expiration)}
GameCatalog.WebAnalysis.SiteTracking.setCookie=function(name,value,expiration)
{try{var strDate=new String();strDate=value.toString();while(strDate.indexOf(" ")!=-1){strDate=strDate.replace(" ","%20");}
while(strDate.indexOf(":")!=-1){strDate=strDate.replace(":","%3A");}
strDate=strDate.replace("+","%2B");strDate=strDate.replace("-","%2D");var today=new Date();var expiry=new Date(today.getTime()+expiration*24*60*60*1000);if(strDate!=null&&strDate!=""){document.cookie=name+"="+strDate+"; expires="+expiry.toGMTString();}}
catch(er){}}
function omnitureLogDownloadCover(gameCode,gameName)
{GameCatalog.WebAnalysis.SiteTracking.omnitureLogDownloadCover(gameCode,gameName);}
GameCatalog.WebAnalysis.SiteTracking.omnitureLogDownloadCover=function(gameCode,gameName)
{var expirationPeriod=180
var today=new Date();try{GameCatalog.WebAnalysis.SiteTracking.setCookie(gameCode,today,expirationPeriod);s.linkType="d";s.events="event1";s.eVar11=GameCatalog.WebAnalysis.SiteTracking.DownloadOmnitureFormattedDate();s.tl(this,"d",gameName);}
catch(er){}}
function DownloadOmnitureFormattedDate()
{return GameCatalog.WebAnalysis.SiteTracking.DownloadOmnitureFormattedDate();}
GameCatalog.WebAnalysis.SiteTracking.DownloadOmnitureFormattedDate=function()
{var date=new Date();hours=date.getUTCHours();minutes=date.getUTCMinutes();seconds=date.getUTCSeconds();var suffix="AM";if(hours>=12){suffix="PM";hours=hours-12;}
if(hours==0){hours=12;}
if(minutes<10)
minutes="0"+minutes
if(seconds<10)
seconds="0"+seconds
return(date.getUTCMonth()+1)+"/"+date.getUTCDate()+"/"+date.getUTCFullYear()+" "+hours+":"+minutes+":"+seconds+" "+suffix;}
function logDownload(gameCode,omnitureChannel){GameCatalog.WebAnalysis.SiteTracking.logDownload(gameCode,omnitureChannel);}
GameCatalog.WebAnalysis.SiteTracking.logDownload=function(gameCode,omnitureChannel)
{s.linkName=gameCode;s.products=";"+gameCode;GameCatalog.WebAnalysis.SiteTracking.omnitureLogDownloadCover(gameCode,gameCode);}
function omnitureLogDownload(gameCode,omnitureChannel,gameReportName){return GameCatalog.WebAnalysis.SiteTracking.omnitureLogDownload(gameCode,omnitureChannel,gameReportName);}
GameCatalog.WebAnalysis.SiteTracking.omnitureLogDownload=function(gameCode,omnitureChannel,gameReportName)
{try{s.linkName=gameReportName;s.products=";"+gameReportName;GameCatalog.WebAnalysis.SiteTracking.omnitureLogDownloadCover(gameCode,gameReportName);}
catch(er){}
return true;}
function omnitureLogDownload_Real(gameCode,omnitureChannel,gameName,catName,dlDateTime){return GameCatalog.WebAnalysis.SiteTracking.omnitureLogDownload_Real(gameCode,omnitureChannel,gameName,catName,dlDateTime);}
GameCatalog.WebAnalysis.SiteTracking.omnitureLogDownload_Real=function(gameCode,omnitureChannel,gameName,catName,dlDateTime)
{try{s.linkName=gameName;s.products=catName+";"+gameName;GameCatalog.WebAnalysis.SiteTracking.omnitureLogDownloadCover(gameCode,gameName);}
catch(e){}
return true;}
function getTimeBucket(oDate)
{try{var today=new Date();var downloadDate=new Date(oDate);var timeGap
timeGap=((today.getTime()-downloadDate.getTime())/(60*60*1000))
var timeBucket
if(downloadDate.getTime()==0||isNaN(timeGap)){timeBucket="Unknown";}else if(timeGap>=0&&timeGap<1){timeBucket="0-1 Hours";}else if(timeGap>=1&&timeGap<2){timeBucket="1-2 Hours";}else if(timeGap>=2&&timeGap<4){timeBucket="2-4 Hours";}else if(timeGap>=4&&timeGap<6){timeBucket="4-6 Hours";}else if(timeGap>=6&&timeGap<12){timeBucket="6-12 Hours";}else if(timeGap>=12&&timeGap<24){timeBucket="1 Day";}else if(timeGap>=1*24&&timeGap<2*24){timeBucket="2 Days";}else if(timeGap>=2*24&&timeGap<3*24){timeBucket="3 Days";}else if(timeGap>=3*24&&timeGap<4*24){timeBucket="4 Days";}else if(timeGap>=4*24&&timeGap<5*24){timeBucket="5 Days";}else if(timeGap>=5*24&&timeGap<6*24){timeBucket="6 Days";}else if(timeGap>=6*24&&timeGap<7*24){timeBucket="7 Days";}else if(timeGap>=1*24*7&&timeGap<2*24*7){timeBucket="1-2 Weeks";}else if(timeGap>=2*24*7&&timeGap<4*24*7){timeBucket="2-4 Weeks";}else if(timeGap>=1*24*7*4&&timeGap<2*24*7*4){timeBucket="1-2 Months";}else{timeBucket=" > 2 Months";}
return timeBucket;}
catch(er){return"Unknown";}}
//::: Omniture Web Analysis 00:00:00.0468762
GameCatalog.Mediator = {

 _pageStateChanged  : function(newStateData)
                         {
                         
//                            var params = {
//                                    pageName            : newStateData,
//                                    loginStatus         : UA.User.prototype.IsLoggedOn(),
//                                    userStatus          : FishhookCentral.InitResults.IsSubscribed,
//                                    oberonUserId        : FishhookCentral.InitResults.userGuid,
//                                    username            : FishhookCentral.InitResults.Nickname,
//                                    hasFreeTrial        : FishhookCentral.InitResults.HasFreeTrial
//                            };

                               GameCatalog.WebAnalysis.SiteTracking.submitEvent(newStateData);
                         }
                         
}

Event.observe(window, "load", function(){GameCatalog.Mediator._pageStateChanged(GetPageName())}, false);


//::: WebAnalysisFunc 00:00:00.0468762

function GetPageName()
{return pageName;}
function GetScriptSrcQueryString()
{var src="";var pageName=GetPageName();src="pagefilename="+pageName;src+="&"+document.location.search.substr(1);return src;}
;
//::: Url
/* Url */var Url = new Object();

/*
** UrlParameter
** @param: paramName - name of query string parameter.
** @param: (optional) val - if its value is not null it will be added to the url URL as value of paramName.
** @return: Retrieves Query String Parameter value, or full URL with changed/added parameter value.
***/
Url.UrlParameter = function(paramName, val) 
{
    var found = false, subsequent = 0;
    var sep = function() { return (subsequent++ ? '&' : ''); };

    var keyValuePairs = window.location.href.split(/[&?]/g);
    if (val != null)
        var newHref = keyValuePairs[0] + '?';
    for (var p = 1; p < keyValuePairs.length; ++p) 
    {
        kv = keyValuePairs[p].split("=");
        if (decodeURIComponent(kv[0]) == paramName) 
        {
            if (val != null) 
            {
                newHref += sep() + kv[0] + '=' + encodeURIComponent(val);
                found = true;
            }
            else {
                val = keyValuePairs[p].substr(kv[0].length + 1);
                return decodeURIComponent(val.replace(/\+/g, ' '));
            }
        }
        else 
        {
            if (val != null)
                newHref += sep() + keyValuePairs[p];
        }
    }
    if (val == null)
        return null;

    if (!found)
        newHref += sep() + encodeURIComponent(paramName) + '=' + encodeURIComponent(val);
    return newHref;
}

/*
** GoToRoot
* Go to site root
*/
Url.GoToRoot = function()
{
    window.location.href = window.location.protocol
                                         + "//" + window.location.host + "/"+window.location.search;
}

Url.BrowserCode = function() {
    var browserCode = 'F';
    try {
        if (navigator.userAgent.indexOf('MSIE') != -1)
            browserCode = 'I';
    }
    catch (e) { }
    return browserCode;
}

Url.FillForm = function(form) {
    for (var i = 0; i < form.length; i++) {
        if (form[i].type != 'hidden')
            continue;

        if (form[i].value == '@') {
            var up = Url.UrlParameter(form[i].name);
            if (up)
                form[i].value = up;
            else
                form[i].disabled = true;
        }
        else {
            if (form[i].value.indexOf('@B@' >= 0))
                form[i].value.value = form[i].value.replace('@B@', Url.BrowserCode());
        }
    }
}

Url.onSubmitSearchForm = function(form) {
    if (form.q.value == '') {
        Url.GoToRoot();
        return false;
    }
    Url.FillForm(form);
    return true;
}

Url.onLoadValidate = function() {
    var q = Url.UrlParameter('q');
    if (q.length > 300)
        window.location = Url.UrlParameter('q', q.substr(0, 300));
}

//::: DynamicGizmos
var O = window.O || {};
O.Model = O.Model || {};