function computedStyleXX(el, property) {
    var style = false;
    if (el) if (el.currentStyle) {
        style = el.currentStyle[property.replace(/-([a-z])/, function ($0, $1) {
            return $1.toUpperCase()
        })]
    } else if (window.getComputedStyleXX) style = document.defaultView.getComputedStyleXX(el, null).getPropertyValue(property);
    return style
};
var is = (function (o, u) {
    if ((o.ie = /*@cc_on !@*/ false)) {
        o.ieVersion = (function (v, p) {
            while (p.innerHTML = '<!--[if gt IE ' + (++v) + ']>1<![endif]-->', p.innerHTML > 0);
            if (v > 5) return v
        })(4, document.createElement('p'));
        if (o.ieVersion < 7) try {
            document.execCommand('BackgroundImageCache', false, true)
        } catch (e) {}
    } else {
        o = {
            opera: !! window.opera,
            khtml: u.indexOf('KHTML') > -1,
            gecko: u.indexOf('Gecko') > -1 && u.indexOf('KHTML') == -1,
            webkit: u.indexOf('AppleWebKit/') > -1,
            mac: u.indexOf('Macintosh') > -1
        };
        if (o.mac && o.webkit) window.focus = function () {}
    };
    o.handheld = computedStyleXX(document.documentElement, 'z-index') == 1;
    return o
})({}, navigator.userAgent),
    isEventSupported = (function () {
        var TAGNAMES = {
            select: 'input',
            change: 'input',
            submit: 'form',
            reset: 'form',
            error: 'img',
            load: 'img',
            abort: 'img'
        },
            cache = {};
        return function (eventName, element) {
            var canCache = arguments.length == 1,
                isSupported;
            if (canCache && eventName in cache) return cache[eventName];
            element = element || document.createElement(TAGNAMES[eventName] || 'div');
            eventName = 'on' + eventName;
            if (!(isSupported = eventName in element) && element.setAttribute) {
                element.setAttribute(eventName, 'return;');
                isSupported = typeof element[eventName] == 'function'
            };
            return canCache ? (cache[eventName] = isSupported) : isSupported
        }
    })()

    function imageHoverSwap(img, normalStateImg, hoverStateImg) {
        img.src = getPreloadImage(normalStateImg);
        if (!img.__hoverStateImg) {
            addEvent(img, 'mouseover', imgHoverOn);
            addEvent(img, 'mouseout', imgHoverOff)
        };
        img.__hoverStateImg = hoverStateImg;
        img.__normalStateImg = normalStateImg
    };
Object.extend = function (dest, source, allowOverwrite) {
    for (var prop in source) if (source.hasOwnProperty(prop) && (allowOverwrite || !dest.hasOwnProperty(prop))) dest[prop] = source[prop];
    return dest
};
Object.extend(Array.prototype, {
    indexOf: function (searchElement, fromIndex) {
        var lengthXX = this.length,
            i = 0;
        if (fromIndex) {
            i = fromIndex;
            if (i < 0) {
                i += lengthXX;
                if (i < 0) i = 0
            }
        };
        while (i < lengthXX) {
            if (this[i] === searchElement) return i;
            i++
        };
        return -1
    },
    forEach: function (func, obj) {
        for (var i = 0, lengthXX = this.length; i < lengthXX; i++) if (i in this) func.call(obj, this[i], i, this)
    },
    filter: function (func, obj) {
        var res = [],
            val;
        for (var i = 0, lengthXX = this.length; i < lengthXX; i++) if (i in this) {
            val = this[i];
            if (func.call(obj, val, i, this)) res.push(val)
        };
        return res
    }
});
['forEach', 'filter', 'slice'].forEach(function (func) {
    if (!(func in Array)) Array[func] = function (obj) {
        return this.prototype[func].apply(obj, Array.prototype.slice.call(arguments, 1))
    }
});
Object.extend(String.prototype, {
    trim: function () {
        return this.replace(/^\s\s*/, '').replace(/\s\s*$/, '')
    },
    ucFirst: function () {
        return this.charAt(0).toUpperCase() + this.substr(1)
    },
    escapeHtml: function () {
        var escapeChars = {
            '&': '&amp;',
            '<': '&lt;',
            '>': '&gt;',
            '"': '&quot;'
        };
        return this.replace(/[&<>"]/g, function (c) {
            return escapeChars[c]
        })
    },
    unescapeHtml: function () {
        var namedEntities = {
            amp: '&',
            lt: '<',
            gt: '>',
            quot: '"',
            euro: String.fromCharCode(8364)
        };
        return this.replace(/&(amp|lt|gt|quot|euro|#\d+);/g, function (c, n) {
            return namedEntities[n] || String.fromCharCode(n.substr(1))
        })
    },
    normalize: function () {
        var diacritics = {
            192: 'A',
            193: 'A',
            194: 'A',
            195: 'A',
            196: 'A',
            197: 'A',
            198: 'A',
            224: 'a',
            225: 'a',
            226: 'a',
            227: 'a',
            228: 'a',
            229: 'a',
            230: 'a',
            200: 'E',
            201: 'E',
            202: 'E',
            203: 'E',
            232: 'e',
            233: 'e',
            234: 'e',
            235: 'e',
            204: 'I',
            205: 'I',
            206: 'I',
            207: 'I',
            236: 'i',
            237: 'i',
            238: 'i',
            239: 'i',
            210: 'O',
            211: 'O',
            212: 'O',
            213: 'O',
            214: 'O',
            216: 'O',
            242: 'o',
            243: 'o',
            244: 'o',
            245: 'o',
            246: 'o',
            248: 'o',
            217: 'U',
            218: 'U',
            219: 'U',
            220: 'U',
            249: 'u',
            250: 'u',
            251: 'u',
            252: 'u',
            209: 'N',
            241: 'n',
            199: 'C',
            231: 'c',
            221: 'Y',
            253: 'y'
        };
        return this.replace(/[\300-\377]/g, function (c) {
            return diacritics[c.charCodeAt(0)] || c
        })
    },
    escapeJs: function () {
        return this.replace(/([\0\n\r\t\\'\/])/g, '\\$1')
    }
});
Object.extend(Function.prototype, {
    bind: function (obj) {
        var fn = this,
            args;
        if (arguments.length > 1) {
            args = Array.slice(arguments, 1);
            return function () {
                return arguments.length ? fn.apply(obj, args.concat(Array.slice(arguments))) : fn.apply(obj, args)
            }
        };
        return function () {
            return arguments.length ? fn.apply(obj, arguments) : fn.call(obj)
        }
    }
});
RegExp.escape = function (string) {
    return string.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1')
}

function Set() {
    var set = {},
        i = arguments.length;
    while (i--) set[arguments[i]] = 1;
    return set
};
var idCache = {}

function getById(id) {
    if (!(id in idCache)) idCache[id] = document.getElementById(id);
    return idCache[id]
};
var DomLoadedXX = {
    onload: [],
    loaded: function () {
        if (DomLoadedXX.done) return;
        DomLoadedXX.done = true;
        if (DomLoadedXX.timer) clearInterval(DomLoadedXX.timer);
        if (DomLoadedXX.onload.length) DomLoadedXX.execute()
    },
    load: function (fireThis) {
        DomLoadedXX.onload.push(fireThis);
        if (DomLoadedXX.onload.length == 1) {
            if (document.addEventListener) {
                document.addEventListener('DOMContentLoaded', DomLoadedXX.loaded, false);
                if (is.webkit || is.khtml) DomLoadedXX.timer = setInterval(function () {
                    if (/loaded|complete/.test(document.readyState)) DomLoadedXX.loaded()
                }, 10)
            } else DomLoadedXX.timer = setInterval(function () {
                if (document.getElementById('domLoaded')) DomLoadedXX.loaded()
            }, 10);
            addEvent(window, 'load', DomLoadedXX.loaded)
        }
    },
    execute: function () {
        var func = DomLoadedXX.onload.shift();
        if (typeof func == 'function') func();
        if (DomLoadedXX.onload.length) setTimeout(DomLoadedXX.execute, 10)
    }
},
    addEvent = function () {
        if (document.addEventListener) {
            function checkMouseLeaveOrEnter(element, handler) {
                return function (e) {
                    var target = e.relatedTarget || (e.type == 'mouseover' ? e.fromElement : e.toElement);
                    while (target) {
                        if (target == element) return;
                        try {
                            target = target.parentNode
                        } catch (e) {
                            return
                        }
                    };
                    return handler.call(this, e)
                }
            };
            return function (element, type, handler) {
                if (type == 'mouseenter') {
                    type = 'mouseover';
                    handler = checkMouseLeaveOrEnter(element, handler)
                } else if (type == 'mouseleave') {
                    type = 'mouseout';
                    handler = checkMouseLeaveOrEnter(element, handler)
                };
                element.addEventListener(type, handler, false)
            }
        } else {
            function handleEvent(event) {
                event = event || fixEvent(window.event);
                if (event.type == 'resize') {
                    var page = getPageDimensions(),
                        currentDimensions = page.innerWidth + 'x' + page.innerHeight;
                    if (this.__dimensions && this.__dimensions == currentDimensions) return true;
                    this.__dimensions = currentDimensions
                };
                var handlers = this.events[event.type],
                    returnValue;
                for (var i in handlers) if (handlers.hasOwnProperty(i) && handlers[i].call(this, event) === false) returnValue = false;
                return returnValue
            };

            function fixEvent(event) {
                event.preventDefaultXX = preventDefaultXX;
                event.stopPropagation = stopPropagation;
                event.target = event.srcElement;
                return event
            };

            function preventDefaultXX() {
                this.returnValue = false
            };

            function stopPropagation() {
                this.cancelBubble = true
            };

            function removeAllEvents() {
                while ((cachedEvent = eventCache.pop())) removeEvent(cachedEvent.element, cachedEvent.type, cachedEvent.handler);
                if (window.idCache) window.idCache = null
            };
            var guid = 1,
                eventCache = [];
            return function (element, type, handler) {
                if (!handler.$$guid) handler.$$guid = guid++;
                if (!element.events) element.events = {};
                if (!element.events[type]) {
                    element.events[type] = {};
                    if (element['on' + type]) element.events[type][0] = element['on' + type];
                    element['on' + type] = handleEvent
                };
                element.events[type][handler.$$guid] = handler;
                if (type != 'unload') {
                    if (!eventCache.length) addEvent(window, 'unload', removeAllEvents);
                    eventCache.push({
                        element: element,
                        type: type,
                        handler: handler
                    })
                }
            }
        }
    }(),
    removeEvent = function () {
        if (document.removeEventListener) {
            return function (element, type, handler) {
                element.removeEventListener(type, handler, false)
            }
        } else return function (element, type, handler) {
            if (element.events && element.events[type] && handler.$$guid) delete element.events[type][handler.$$guid]
        }
    }(),
    addCleanupHandler = function () {
        if (is.ie) {
            var cleanupItems = [];

            function cleanUp() {
                var iXX = cleanupItems.length,
                    j;
                while (iXX--) if (cleanupItems[iXX].obj) {
                    if (cleanupItems[iXX].func) try {
                        if (typeof cleanupItems[iXX].func == 'function') {
                            cleanupItems[iXX].func.call(obj)
                        } else cleanupItems[iXX].obj[cleanupItems[iXX].func]()
                    } catch (e) {};
                    j = cleanupItems[iXX].props.length;
                    while (j--) cleanupItems[iXX].obj[cleanupItems[iXX].props[j]] = null
                };
                cleanupItems = null
            };
            return function (obj, props, func) {
                var lengthXX = cleanupItems.length;
                cleanupItems[lengthXX] = {
                    obj: obj,
                    props: props,
                    func: func
                };
                if (lengthXX == 0) addEvent(window, 'unload', cleanUp)
            }
        };
        return function () {}
    }()

    function getHead() {
        if (is.ie) {
            var bases = document.getElementsByTagName('base');
            if (bases.length && bases[0].childNodes.length) return bases[0]
        };
        return document.getElementsByTagName('head')[0]
    }

    function first_child(par, nodeName) {
        if (par && par.nodeType == 1) {
            var res = par.firstChild;
            if (nodeName) {
                nodeName = nodeName.toLowerCase();
                do {
                    if (res.nodeName.toLowerCase() == nodeName) return res
                } while ((res = res.nextSibling))
            } else do {
                if (!is_ignorable(res)) return res
            } while ((res = res.nextSibling))
        };
        return null
    }

    function last_child(par, nodeName) {
        if (par && par.nodeType == 1) {
            var res = par.lastChild;
            if (nodeName) {
                nodeName = nodeName.toLowerCase();
                do {
                    if (res.nodeName.toLowerCase() == nodeName) return res
                } while ((res = res.previousSibling))
            } else do {
                if (!is_ignorable(res)) return res
            } while ((res = res.previousSibling))
        };
        return null
    }

    function node_after(sib, nodeName) {
        if (sib) if (nodeName) {
            nodeName = nodeName.toLowerCase();
            while ((sib = sib.nextSibling)) if (sib.nodeName.toLowerCase() == nodeName) return sib
        } else while ((sib = sib.nextSibling)) if (!is_ignorable(sib)) return sib;
        return null
    }

    function addClass(element, className) {
        if (element.className.length) {
            var classes = getClassList(element);
            if (classes.indexOf(className) == -1) {
                classes.push(className);
                setClassList(element, classes)
            }
        } else element.className = className
    }

    function removeClass(element, className) {
        var classes = getClassList(element),
            index;
        if ((index = classes.indexOf(className)) > -1) {
            delete classes[index];
            setClassList(element, classes)
        }
    }

    function replaceClass(element, oldclass, newclass) {
        var classes = getClassList(element),
            index;
        if ((index = classes.indexOf(oldclass)) > -1 && classes.indexOf(newclass) == -1) {
            classes[index] = newclass;
            setClassList(element, classes)
        }
    }

    function toggleClass(element, class1, class2) {
        if (hasClass(element, class1)) {
            replaceClass(element, class1, class2)
        } else replaceClass(element, class2, class1)
    }

    function getClassList(element) {
        return element.className.length ? element.className.split(/\s+/) : []
    }

    function setClassList(element, classes) {
        element.className = classes.join(' ')
    };
var regExpCache = {}

var resizeHandlers = []

function SiteMenu(activeMenu) {
    this.element = getById('siteMenu');
    this.menuItems = [];
    this.activeMenu = activeMenu;
    this.menuActive = false;
    this.menuItemTimeout = null;
    this.menuTimeout = null;
    this.init();
    SiteMenu.instance = this
};
Object.extend(SiteMenu.prototype, {
    init: function () {
        if (this.element) {
            var menuItems = this.element.getElementsByTagName('li'),
                menuItem, i = 0;
            while ((menuItem = menuItems[++i])) {
                addEvent(menuItem, 'click', this.onClick.bind(this, i));
                addEvent(menuItem, 'mouseover', this.onMouseover.bind(this, i));
                menuItem.subMenu = new SubMenu(i, menuItem.offsetLeft);
                this.menuItems[i] = menuItem
            };
            var header = getById('header');
            if (header) {
                addEvent(header, 'mouseover', this.cancelMouseout.bind(this));
                addEvent(header, 'mouseout', this.onMouseout.bind(this, this.activeMenu));
                addEvent(window, 'pageshow', this.reset.bind(this, this.activeMenu))
            };
            addCleanupHandler(this, ['element', 'menuItems', 'menuActive'])
        }
    },
    positionSubMenus: function () {
        var iXX = 0,
            menuItem;
        while ((menuItem = this.menuItems[++iXX])) if (menuItem.subMenu.element) menuItem.subMenu.position()
    },
    onClick: function (iXX) {
        clearTimeout(this.menuItemTimeout);
        this.menuActive = true;
        this.handleMouseover(iXX)
    },
    onMouseover: function (iXX, e) {
        clearTimeout(this.menuItemTimeout);
        if (iXX != this.activeMenu) {
            var timeOut = 0;
            if (this.menuActive) {
                timeOut = 0;
                if (e) {
                    var target = e.target || e.srcElement;
                    if (target.nodeType == 3) target = target.parentNode;
                    if (target.nodeName == 'A') timeOut = 0
                }
            };
            this.menuItemTimeout = setTimeout(this.onClick.bind(this, iXX), timeOut)
        }
    },
    onMouseout: function (iXX) {
        clearTimeout(this.menuTimeout);
        clearTimeout(this.menuItemTimeout);
        this.menuTimeout = setTimeout(this.handleMouseout.bind(this, iXX), 2e3)    },
    cancelMouseout: function () {
        clearTimeout(this.menuTimeout)
    },
    handleMouseover: function (iXX) {
        if (this.menuActive && this.menuItems && iXX != this.activeMenu) {
            this.hideSubMenu();
            this.showSubMenu(iXX)
        }
    },
    handleMouseout: function (iXX) {
        this.handleMouseover(iXX);
        this.menuActive = false
    },
    reset: function (iXX, e) {
        if (e && e.persisted && this.menuItems) {
            this.hideSubMenu();
            this.showSubMenu(iXX)
        }
    },
    showSubMenu: function (iXX) {
        this.activeMenu = iXX;
        var menu = this.menuItems[iXX];
        if (menu) {
            addClass(menu, 'active');
            if (menu.subMenu.element) addClass(menu.subMenu.element, 'active');
            if ((menu = this.menuItems[iXX + 1])) addClass(menu, 'activeNeighbor')
        }
    },
    hideSubMenu: function () {
        var iXX = this.activeMenu,
            menu = this.menuItems[iXX];
        if (menu) {
            removeClass(menu, 'active');
            if (menu.subMenu.element) {
                menu.subMenu.handleMouseout();
                removeClass(menu.subMenu.element, 'active')
            };
            if ((menu = this.menuItems[iXX + 1])) removeClass(menu, 'activeNeighbor')
        }
    }
})

function SubMenu(id, offset) {
    this.element = getById('groupNav' + id);
    this.menu = null;
    this.width = 0;
    this.menuItems = [];
    this.activeMenu = -1;
    this.menuActive = false;
    this.menuTimeout = null;
    this.menuItemTimeout = null;
    this.init()
};
Object.extend(SubMenu.prototype, {
    init: function () {
        if (this.element) {
            var lastitem, menuitem, menusubitem, iXX = 0;
            if ((this.menu = first_child(this.element, 'ul'))) {
                menuitem = first_child(this.menu, 'li');
                if (menuitem) {
                    do {
                        lastitem = menuitem;
                        if ((menusubitem = first_child(menuitem, 'div'))) {
                            menuitem.className += 'subitems';
                            addEvent(menuitem, 'click', this.onClick.bind(this, iXX));
                            addEvent(menuitem, 'mouseover', this.onMouseover.bind(this, iXX));
                            this.menuItems[iXX++] = menusubitem
                        } else addEvent(menuitem, 'mouseover', this.handleMouseover.bind(this, -1))
                    } while ((menuitem = node_after(menuitem, 'li')));
                    this.width = lastitem.offsetLeft;
                    this.position()
                }
            };
            addEvent(this.element, 'mouseover', this.cancelMouseout.bind(this));
            addEvent(this.element, 'mouseout', this.onMouseout.bind(this));
            menuitem = null, menusubitem = null;
            addCleanupHandler(this, ['element', 'menu', 'menuItems', 'menuActive'])
        }
    },
    position: function () {
        if (this.width) {
            var maxLeft = this.element.parentNode.offsetWidth - 10,
                searchbox = getById('searchbox');
            if (searchbox) maxLeft = searchbox.offsetLeft - 10;
            var offset = this.offset - Math.floor(this.width / 2);
            offset += 65;
            if (offset + this.width > maxLeft) offset = maxLeft - this.width;
            if (offset < 0) offset = 0;
//            this.element.style.left = offset + 'px'
        }
    },
    onClick: function (i) {
        clearTimeout(this.menuItemTimeout);
        this.menuActive = true;
        this.handleMouseover(i)
    },
    onMouseover: function (i) {
        clearTimeout(this.menuItemTimeout);
        if (this.menuActive) {
            this.handleMouseover(i)
        } else if (i != this.activeMenu) this.menuItemTimeout = setTimeout(this.onClick.bind(this, i), 140)
    },
    onMouseout: function (i) {
        clearTimeout(this.menuTimeout);
        clearTimeout(this.menuItemTimeout);
        this.menuTimeout = setTimeout(this.handleMouseout.bind(this), 1e3)
    },
    cancelMouseout: function () {
        clearTimeout(this.menuTimeout)
    },
    handleMouseover: function (i) {
        if (this.menuItems && i != this.activeMenu) {
            var menu = this.menuItems[this.activeMenu];
            if (menu) menu.style.display = 'none';
            this.activeMenu = i;
            if ((menu = this.menuItems[this.activeMenu])) {
                menu.style.left = menu.parentNode.offsetLeft + 'px';
                menu.style.display = 'block'
            }
        }
    },
    handleMouseout: function () {
        this.handleMouseover(-1);
        this.menuActive = false
    }
})