var $getBounds = Sys.UI.DomElement.getBounds;
var $getLocation = Sys.UI.DomElement.getLocation;

function isUndefinedOrTrue(val)
{
	return (typeof(val) == 'undefined') || val;
}

function htmlEncode(s)
{
	return s.replace(/&(?!\w+([;\s]|$))/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
}


if (Sys.Browser.agent == Sys.Browser.Opera)
{
    Sys.UI.DomElement.getLocation = function Sys$UI$DomElement$getLocation(element) {
        /// <param name="element" domElement="true"></param>
        /// <returns type="Sys.UI.Point"></returns>
        var e = Function._validateParams(arguments, [
            {name: "element", domElement: true}
        ]);
        if (e) throw e;

        if ((element.window && (element.window === element)) || element.nodeType === 9) return new Sys.UI.Point(0,0);

        var offsetX = 0;
        var offsetY = 0;

        var previous = null;
        for (var parent = element; parent; previous = parent, parent = parent.offsetParent) {

            var tagName = parent.tagName;

            offsetX += parent.offsetLeft || 0;
            offsetY += parent.offsetTop || 0;
        }

        var elementPosition = element.style.position;
        var elementPositioned = !elementPosition || (elementPosition !== "static");

        for (var parent = element.parentNode; parent; parent = parent.parentNode) {
            tagName = parent.tagName;

            if ((tagName !== "BODY") && (tagName !== "HTML") && (parent.scrollLeft || parent.scrollTop) &&
                ((elementPositioned &&
                ((parent.style.overflow === "scroll") || (parent.style.overflow === "auto"))))) {
                                    
                offsetX -= (parent.scrollLeft || 0);
                offsetY -= (parent.scrollTop || 0);
            }
            var parentPosition = (parent && parent.style) ? parent.style.position : null;

            elementPositioned = elementPositioned || (!parentPosition || (parentPosition !== "static"));
        }

        return new Sys.UI.Point(offsetX, offsetY);
    }
}

if (Sys.Browser.agent == Sys.Browser.Firefox)
{
    document.recalc = function() {
        var tmp = { width: document.documentElement.style.width, height: document.documentElement.style.height };

        document.documentElement.style.width = 'auto';

        if (document.documentElement.clientHeight != document.documentElement.scrollHeight)
            document.documentElement.style.height = 'auto';

        window.setTimeout(function() {
            if (document.documentElement.clientHeight != document.documentElement.scrollHeight)
                document.documentElement.style.height = tmp.height;

            document.documentElement.style.width = tmp.width;
        }, 200);
    };
    
    /*
    window.HTMLElement.prototype.__defineGetter__('outerHTML', function() {
        return new XMLSerializer().serializeToString(this);
    });
    */
    
    window.HTMLElement.prototype.__defineGetter__('innerText', function() {
        return this.textContent;
    });
    
    window.HTMLElement.prototype.__defineSetter__('innerText', function(v) {
        if (v) 
            this.innerHTML = formatPlainTextAsHtml(v);
        else
            this.innerHTML = '';
    });

    function formatPlainTextAsHtml(str) 
    {
        var sb = new Sys.StringBuilder();

        var numChars = str.length;
        var prevCh;

        for (var i=0; i < numChars; i++) 
        {
            var ch = str.charAt(i);
            switch (ch) {
                case "<":
                    sb.append("&lt;");
                    break;
                case ">":
                    sb.append("&gt;");
                    break;
                case "\"":
                    sb.append("&quot;");
                    break;
                case "&":
                    sb.append("&amp;");
                    break;
                case " ":
                    if (prevCh == " ") {
                        sb.append("&nbsp;");
                    }
                    else {
                        sb.append(" ");
                    }
                    break;
                case "\r":
                                        break;
                case "\n":
                                        sb.appendLine();
                    sb.appendLine("<br />");
                    break;
                default:
                    sb.append(ch);
                    break;
            }

            prevCh = ch;
        }

        return sb.toString( );
    }

    function selectNodes(doc, path, contextNode) 
    {
        contextNode = contextNode ? contextNode : doc;
        var xpath = new XPathEvaluator();
        var result = xpath.evaluate(path, contextNode,
                                    doc.createNSResolver(doc.documentElement),
                                    XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);

        var nodeList = new Array(result.snapshotLength);
        for(var i = 0; i < result.snapshotLength; i++) {
            nodeList[i] = result.snapshotItem(i);
        }

        return nodeList;
    }

    function selectSingleNode(doc, path, contextNode) 
    {
        path += '[1]';
        var nodes = selectNodes(doc, path, contextNode);
        if (nodes.length != 0) {
            for (var i = 0; i < nodes.length; i++) 
            {
                if (nodes[i]) 
                    return nodes[i];
            }
        }
        return null;
    }

    window.XMLDocument.prototype.selectNodes = function window$XMLDocument$selectNodes(path, contextNode) 
    {
        return selectNodes(this, path, contextNode);
    }

    window.XMLDocument.prototype.selectSingleNode = function window$XMLDocument$selectSingleNode(path, contextNode) 
    {
        return selectSingleNode(this, path, contextNode);
    }

    window.XMLDocument.prototype.transformNode = function window$XMLDocument$transformNode(xsl) 
    {
        var xslProcessor = new XSLTProcessor();
        xslProcessor.importStylesheet(xsl);

        var ownerDocument = document.implementation.createDocument("", "", null);
        var transformedDoc = xslProcessor.transformToDocument(this);

        return transformedDoc.xml;
    }

    Node.prototype.selectNodes = function Node$selectNodes(path) 
    {
        var doc = this.ownerDocument;
        return doc.selectNodes(path, this);
    }

    Node.prototype.selectSingleNode = function Node$selectSingleNode(path) 
    {
        var doc = this.ownerDocument;
        return doc.selectSingleNode(path, this);
    }

    Node.prototype.__defineGetter__('baseName', function() {
        return this.localName;
    });

    Node.prototype.__defineGetter__('text', function() {
        return this.textContent;
    });
    Node.prototype.__defineSetter__('text', function(value) {
        this.textContent = value;
    });

    Node.prototype.__defineGetter__('xml', function() {
        return (new XMLSerializer()).serializeToString(this);
    });

    DocumentFragment.prototype.getElementById = function DocumentFragment$getElementById(id) 
    {
        var nodeQueue = [];
        var childNodes = this.childNodes;
        var node;
        var c;

        for (c = 0; c < childNodes.length; c++) 
        {
            node = childNodes[c];
            if (node.nodeType == 1)
                Array.enqueue(nodeQueue, node);
        }

        while (nodeQueue.length) 
        {
            node = Array.dequeue(nodeQueue);
            
            if (node.id == id)
                return node;
                
            childNodes = node.childNodes;
            if (childNodes.length != 0) {
                for (c = 0; c < childNodes.length; c++) 
                {
                    node = childNodes[c];
                    if (node.nodeType == 1)
                        Array.enqueue(nodeQueue, node);
                }
            }
        }

        return null;
    }

    DocumentFragment.prototype.createElement = function DocumentFragment$createElement(tagName) 
    {
        return document.createElement(tagName);
    }

}

var $clearTimeout = function(obj, timervar)
{
     var e = Function._validateParams(arguments, [
        {name: "obj" , mayBeNull: false},
        {name: "timervar", type: String}
    ]);
    
    if (e) throw e;
    
    if (obj[timervar])
    {
        window.clearTimeout(obj[timervar]);
        obj[timervar] = null;
    }
}


var $setTimeout = function(obj, timervar, func, timeout)
{
     var e = Function._validateParams(arguments, [
        {name: "obj" , mayBeNull: false},
        {name: "timervar", type: String},
        {name: "func", type: Function},
        {name: "timeout", type: Number, integer: true, optional: true}
    ]);
    
    if (e) throw e;
    
    if (arguments.length  == 3)
        timeout = 200;
    
    $clearTimeout(obj, timervar);
    
    obj[timervar] = window.setTimeout(Function.createDelegate(obj, func), timeout);
}


var $clearInterval = function(obj, timervar)
{
     var e = Function._validateParams(arguments, [
        {name: "obj" , mayBeNull: false},
        {name: "timervar", type: String}
    ]);
    
    if (e) throw e;
    
    if (obj[timervar])
    {
        window.clearInterval(obj[timervar]);
        obj[timervar] = null;
    }
}


var $setInterval = function(obj, timervar, func, timeout)
{
     var e = Function._validateParams(arguments, [
        {name: "obj" , mayBeNull: false},
        {name: "timervar", type: String},
        {name: "func", type: Function},
        {name: "timeout", type: Number, integer: true, optional: true}
    ]);
    
    if (e) throw e;
    
    if (arguments.length  == 3)
        timeout = 200;
    
    $clearInterval(obj, timervar);
    
    obj[timervar] = window.setInterval(Function.createDelegate(obj, func), timeout);
}


var $getComputedStyle = Sys.UI.DomElement.getComputedStyle = function getComputedStyle(e, p, i)
{
    var s, v = null;
    var dv = document.defaultView;

    function camelize(cssPropStr)
    {
        var i, c, a = cssPropStr.split('-');
        var s = a[0];

        for (i=1; i < a.length; ++i) 
        {
            c = a[i].charAt(0);
            s += a[i].replace(c, c.toUpperCase());
        }

        return s;
    }

    if(dv && dv.getComputedStyle)
    {
        if (s = dv.getComputedStyle(e,'')) 
            v = s.getPropertyValue(p);
    }
    else if(e.currentStyle)
    {
        v = e.currentStyle[camelize(p)];
    }
    else
    { 
        return null;
    }
    
    return i ? (parseInt(v) || 0) : v;
}

if (typeof(Function._validateParams) == 'undefined')
    Function._validateParams = new function() { return null };


Sys.EventHandlerList.prototype.clearHandler = function(id)
{
    var e = Function._validateParams(arguments, [
        {name: "id", type: String}
    ]);
    if (e) throw e;

    var evt = this._getEvent(id);
    if (!evt) return;
    Array.clear(evt);

}

Sys.Component.prototype.clearEvent = function Sys$Component$clearEvent(name)
{
    var e = Function._validateParams(arguments, [
        {name: "name" , type: String, mayBeNull: false}
    ]);
    
    if (e) throw e;
    
    this.get_events().clearHandler(name);
}


Sys.Component.prototype.raiseEvent = function Sys$Component$raiseEvent(name, eventArgs)
{
    var e = Function._validateParams(arguments, [
        {name: "name" , type: String, mayBeNull: false},
        {name: "eventArgs", type: Sys.EventArgs, optional: true}
    ]);
    
    if (e) throw e;
    
    var handler = this.get_events().getHandler(name);
    
    if (arguments.length == 1)
        eventArgs = Sys.EventArgs.Empty;
    
    if (handler) 
        handler(this, eventArgs);
}
Sys.Component.prototype.addProperty = function Sys$Component$addProperty(name , value) 
{
    var e = Function._validateParams(arguments, [
        {name: "name" , type: String, mayBeNull: false},
        {name: "value", mayBeNull: true}
    ]);
    if (e) throw e;

    this[name] = value;
    
    if (typeof(this['get_' + name]) !== 'function')
    {
        this['get_' + name] = function () 
        {
            if (arguments.length !== 0) throw Error.parameterCount();
            return this[name];
        }
    }
    
    if (typeof(this['set_' + name]) !== 'function')
    {
        this['set_' + name] = function (val) 
        {
            if (arguments.length !== 1) throw Error.parameterCount();
            this[name] = val;
        }
    }
}


Sys.Component.prototype.addEvent = function Sys$Component$addEvent(name) 
{
    var e = Function._validateParams(arguments, [
        {name: "name" , type: String, mayBeNull: false}
    ]);
    if (e) throw e;

    
    this['add_' + name] = function (handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this.get_events().addHandler(name, handler);
    }
    this['remove_' + name] = function (handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this.get_events().removeHandler(name, handler);
    }
}


String.isNullOrEmpty = function String$isNullOrEmpty(val) {
    var e = Function._validateParams(arguments, [
        {name: "val", type: String, mayBeNull: true}
    ]);
    if (e) throw e;

    return (val == null || val == '');
}

$removeFromParent = Sys.UI.DomElement.removeFromParent = function Sys$UI$DomElement$removeFromParent(elm) 
{
    var e = Function._validateParams(arguments, [
        {name: "elm", domElement: true, mayBeNull: true, optional: true}
    ]);
    
    if (e) throw e;
	
	if (!elm)
		return null;

    return elm.parentNode ? elm.parentNode.removeChild(elm) : elm;
}


$moveChildren = Sys.UI.DomElement.moveChildren = function Sys$UI$DomElement$moveChildren(src, dest) 
{
    var e = Function._validateParams(arguments, [
        {name: "src", domElement: true},
        {name: "dest", domElement: true}
    ]);
    
    if (e) throw e;


    var moveCount = 0;
    while (src.hasChildNodes()) 
    {
        var child = src.childNodes[0];
        child = src.removeChild(child);
        dest.appendChild(child);
        moveCount++;
    }
    return moveCount;
}

Sys.UI.DomElement.enableSelection = function Sys$UI$DomElement$enableSelection(element, enable) 
{
    var e = Function._validateParams(arguments, [
        {name: "element", domElement: true},
        {name: "enable", type: Boolean, mayBeNull: true, optional: true}
    ]);
    
    if (e) throw e;
    
    if (element == document && document.documentElement)
        element = document.documentElement;
    
    switch(Sys.Browser.agent)
    {
        case Sys.Browser.Opera:
        case Sys.Browser.InternetExplorer:
            {
                element.unselectable = enable ? '' : 'off' ; 
 		 
                var e, i = 0 ; 
                while ( e = element.all[ i++ ] ) 
                { 
                        switch ( e.tagName ) 
                        { 
                                case 'IFRAME' : 
                                case 'TEXTAREA' : 
                                case 'INPUT' : 
                                case 'SELECT' : 
                                        /* Ignore the above tags */ 
                                        break ; 
                                default : 
                                        e.unselectable = enable ? 'off' : 'on' ; 
                        } 
                } 
            }
            break;
        case Sys.Browser.Safari:
            element.style.KhtmlUserSelect = enable ? '' : 'none';
            break;
        case Sys.Browser.Firefox:
            element.style.MozUserSelect = enable ? '' : 'none';
            break;
        default:
            element.style.userSelect = enable ? '' : 'none'; //CSS3 not yet available
            break;
    }
}


Sys.UI.DomElement.setOpacity = function Sys$UI$DomElement$setOpacity(element, val) 
{
    var e = Function._validateParams(arguments, [
        {name: "element", domElement: true},
        {name: "val", type: Number}
    ]);
    
    if (e) throw e;
    
    if (element == document && document.documentElement)
        element = document.documentElement;
    
    switch(Sys.Browser.agent)
    {
        case Sys.Browser.InternetExplorer:
			element.style.filter = 'alpha(opacity=' + (100 * val) + ')';
            break;
        case Sys.Browser.Safari:
            element.style.KhtmlOpacity = val;
            break;
        case Sys.Browser.Firefox:
            element.style.MozOpacity = val;
            break;
        default:
            element.style.opacity = val;
            break;
    }
}

Math.sign = function Math$sign(num)
{
    if (typeof(num) == 'undefined' || isNaN(num))
        return;
    
    if (num > 0)
        return 1;
    else if (num < 0)
        return -1;
    else
        return 0;
}



function stopDragDropImg()
{
	var el = window.event.srcElement;
	
	if(el.tagName.toLowerCase() == "img" && (el.ondragstart == null))
		el.ondragstart = function(){ return false;}
}

if(document.attachEvent && !window.opera)
	document.attachEvent("ondragstart", stopDragDropImg);

var $addContextualHandlers = Sys.UI.DomEvent.addContextualHandlers = function Sys$UI$DomEvent$addContextualHandlers(element, events, handlerOwner, context) {
    /// <param name="element" domElement="true"></param>
    /// <param name="events" type="Object"></param>
    /// <param name="handlerOwner" optional="true"></param>
    /// <param name="context" optional="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "element", domElement: true},
        {name: "events", type: Object},
        {name: "handlerOwner", optional: true},
        {name: "context", optional: true}
    ]);
    if (e) throw e;

    for (var name in events) 
    {
        var handler = events[name];
        
        if (typeof(handler) !== 'function') 
            throw Error.invalidOperation(Sys.Res.cantAddNonFunctionhandler);
            
        if (handlerOwner) 
            handler = Function.createContextualDelegate(handlerOwner, handler, (context || null));
        
        $addHandler(element, name, handler);
    }
}


Function.createContextualDelegate = function Function$createContextualDelegate(instance, method, context) {
    /// <param name="instance" mayBeNull="true"></param>
    /// <param name="method" type="Function"></param>
    /// <param name="context" mayBeNull="true"></param>    
    /// <returns type="Function"></returns>
    var e = Function._validateParams(arguments, [
        {name: "instance", mayBeNull: true},
        {name: "method", type: Function},
        {name: "context", mayBeNull: true}
    ]);
    if (e) throw e;

       
    return function() {
        var l = arguments.length;
        
        var args = [];
        
        for (var i = 0; i < l; i++) 
            args[i] = arguments[i];
        
        args[l] = context;

        return method.apply(instance, args);
    }
}


Sys.UI.DomElement.addPoints = function Sys$UI$DomElement$addPoints(p1, p2) {
    return { x: p1.x + p2.x, y: p1.y + p2.y };
}

Sys.UI.DomElement.subtractPoints = function Sys$UI$DomElement$subtractPoints(p1, p2) {
    return { x: p1.x - p2.x, y: p1.y - p2.y };
}

Sys.UI.DomElement.containsPoint = function Sys$UI$DomElement$containsPoint(r1, p1) {
    var xComplete = ((r1.x <= p1.x) && ((r1.x + r1.width) > p1.x));
    var yComplete = ((r1.y <= p1.y) && ((r1.y + r1.height) > p1.y));
    return (xComplete && yComplete) 
}

Sys.UI.DomElement.overlapsRect = function Sys$UI$DomElement$overlapsRect(r1, r2) {
    var xLeft = (r1.x >= r2.x && r1.x <= (r2.x + r2.width));
    var xRight = ((r1.x + r1.width) >= r2.x && (r1.x + r1.width) <= r2.x + r2.width);
    var xComplete = ((r1.x < r2.x) && ((r1.x + r1.width) > (r2.x + r2.width)));
    
    var yLeft = (r1.y >= r2.y && r1.y <= (r2.y + r2.height));
    var yRight = ((r1.y + r1.height) >= r2.y && (r1.y + r1.height) <= r2.y + r2.height);
    var yComplete = ((r1.y < r2.y) && ((r1.y + r1.height) > (r2.y + r2.height)));
    
    return ((xLeft || xRight || xComplete) && (yLeft || yRight || yComplete))
}


Sys.UI.DomElement.updateProperties = function Sys$UI$DomElement$updateProperties(obj, props, allowed)
{
     var e = Function._validateParams(arguments, [
        {name: "obj"},
        {name: "props", mayBeNull: true, optional: true},
        {name: "allowed", type: Array, mayBeNull: true, optional: true, elementMayBeNull: false}
    ]);
    
    if (e) throw e;

    if (!allowed)
    {
        allowed = new Array();
        for(aname in props)
        {
            Array.add(allowed, aname);
        }
    }

    var res = false;
    var i, j;
    
    for(i=0;i<allowed.length;i++)
    {
        var propval = props[allowed[i]];
        if (typeof(propval) == "undefined")
        {
            continue;
        }
        
        var anames = allowed[i].split('.');
        
        var aobj = obj;
        
        for(j = 0 ; j < anames.length - 1 ; j++)
        {
            aobj = aobj[anames[j]];
        }
           
        var namepart = anames[anames.length - 1]; 
        
        if (typeof(aobj['set_' + namepart]) == 'function')
        {
            if (typeof(aobj['get_' + namepart]) != 'function' || aobj['get_' + namepart]() != propval)
            {
                res = true;
                aobj['set_' + namepart](propval);
            }
        }
        else if (aobj[namepart] != propval)
        {
            res = true;
            aobj[namepart] = propval
        }
    }
    
    return res;
}


Sys.UI.DomElement.getSibling = function Sys$UI$DomElement$getSibling(element, prev)
{
     var e = Function._validateParams(arguments, [
        {name: "element", mayBeNull: true, domElement: true, optional: false},
        {name: "prev", type: Boolean, optional: true}
    ]);
    
    if (e) throw e;
    
    if (element == null)
        return null;
    
    
    for (element = (prev) ? element.previousSibling : element.nextSibling; element != null; element = (prev) ? element.previousSibling : element.nextSibling) 
    {
        if (element.innerHTML)
            return element;
    }
    return null;
}

Sys.UI.DomElement.getChildren = function Sys$UI$DomElement$getChildren(element)
{
     var e = Function._validateParams(arguments, [
        {name: "element", mayBeNull: true, domElement: true, optional: false}
    ]);
    
    if (e) throw e;
    
    var nodes = [];
    
    if (element != null)
	{
		for (element = element.firstChild; element != null; element = element.nextSibling) 
		{
			if (element.innerHTML)
				Array.add(nodes, element);
		}
    }
    return nodes;
}


Array.toggle = function Array$toggle(array, item) {
    /// <param name="array" type="Array" elementMayBeNull="true"></param>
    /// <param name="item" mayBeNull="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "array", type: Array, elementMayBeNull: true},
        {name: "item", mayBeNull: true}
    ]);
    if (e) throw e;

    var arrindex = Array.indexOf(array, item);
    
    if (arrindex != -1)
        Array.removeAt(array, arrindex);
    else
        Array.add(array, item);
}

Sys.UI.DomElement.getAttribute = function Sys$UI$DomElement$getAttribute(element, propname)
{
     var e = Function._validateParams(arguments, [
        {name: "element", mayBeNull: true, domElement: true, optional: false},
        {name: "propname", type: String, optional: false}
    ]);
    
    if (e) throw e;
    
    if (!element)
        return element;
    
    return element.getAttribute ? element.getAttribute(propname) || element[propname] : element[propname]
}


Sys.UI.DomElement.getAttribute = function Sys$UI$DomElement$getAttribute(element, propname)
{
     var e = Function._validateParams(arguments, [
        {name: "element", mayBeNull: true, domElement: true, optional: false},
        {name: "propname", type: String, optional: false}
    ]);
    
    if (e) throw e;
    
    if (!element)
        return element;
    
    return element.getAttribute ? element.getAttribute(propname) || element[propname] : element[propname]
}

Sys.UI.DomElement.setAttribute = function Sys$UI$DomElement$getAttribute(element, propname, value)
{
     var e = Function._validateParams(arguments, [
        {name: "element", mayBeNull: true, domElement: true, optional: false},
        {name: "propname", type: String, optional: false},
        {name: "value", optional: false}
    ]);
    
    if (e) throw e;
    
    if (!element)
        return;
    
    if (element.setAttribute)
		element.setAttribute(propname, value)
	else 
		element[propname] = value;
}

Sys.Application.add_init(function() 
{
	if (Sys.WebForms && Sys.WebForms.PageRequestManager)
	{
	    var prm = Sys.WebForms.PageRequestManager.getInstance();
	    
	    if (prm)
	    {
		    prm.add_endRequest(function(sender, arg) 
		    {
			    if (sender.LocationHref)    
			    {
				    var href = sender.LocationHref;
				    sender.LocationHref = null;
				    window.location.href = href;
			    }
		    });
		}
	}
	
	BIT.WebControls.SelectionType = function ()
	{
		if (arguments.length !== 0) throw Error.parameterCount();
		throw Error.notImplemented();
	}

	BIT.WebControls.SelectionType.prototype = 
	{
		singleItem: 0,
		addSingleItem: 1,
		rangeItem: 2,
		addRangeItem: 3
	}

	BIT.WebControls.SelectionType.registerEnum('BIT.WebControls.SelectionType');


});

$getDocInnerSize = Sys.UI.DomElement.getDocInnerSize = function Sys$UI$DomElement$getDocInnerSize()
{
	var b = document.body;
	var e = document.documentElement;
	var w = window;
	
	return new Sys.UI.Point((e || (b && (Sys.Browser.agent != Sys.Browser.Opera)) || { clientWidth : w.innerWidth }).clientWidth, 
							(e || (b && (Sys.Browser.agent != Sys.Browser.Opera)) || { clientHeight : w.innerHeight }).clientHeight);
}

$getDocSize = Sys.UI.DomElement.getDocSize = function Sys$UI$DomElement$getDocSize()
{
	var b = document.body;
	var e = document.documentElement;
	
	var esw = 0, eow = 0, bsw = 0, bow = 0, esh=0, eoh=0, bsh=0, boh=0;
	
	if (e) 
	{
		esw = e.scrollWidth;
		esh = e.scrollHeight;
		
		if (Sys.Browser.agent !== Sys.Browser.InternetExplorer)
		{
			eow = e.offsetWidth;
			eoh = e.offsetHeight;
		}
		else
		{
			eow = e.clientWidth;
			eoh = e.clientHeight;
		}
	}
	if (b) 
	{
		bsw = b.scrollWidth;
		bow = b.offsetWidth;
		bsh = b.scrollHeight;
		boh = b.offsetHeight;
	}

	return new Sys.UI.Point(Math.max(esw,eow,bsw,bow), 
							Math.max(esh,eoh,bsh,boh));
}


$addIframe = Sys.UI.DomElement.addIframe = function Sys$UI$DomElement$addIframe(elm, noExpr, imgUrl) 
{
	var e = Function._validateParams(arguments, [
        {name: "elm", domElement: true},
        {name: "noExpr", mayBeNull: true, optional: true, type: Boolean},
        {name: "imgUrl", mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    
    elm.style.zIndex = $getComputedStyle(elm, 'z-index', true) || 2;
    
	var iframe = document.createElement('iframe');
	
	var bnds = $getBounds(elm);

	with(iframe.style)
	{
		position = 'absolute';
		padding = '0';
		margin = '0';
		width = bnds.width + 'px';
		height = bnds.height + 'px';
		left = bnds.x + 'px';
		top = bnds.y + 'px';		
		zIndex = elm.style.zIndex - 1;
		filter = 'alpha(opacity=0)';
		display = elm.style.display;
		border = '0';
	}
	
	if (!noExpr)
	{
		with(iframe.style)
		{
			setExpression('position', elm.uniqueID + '.style.position');
			setExpression('zIndex', elm.uniqueID + '.style.zIndex - 1');
			setExpression('width', elm.uniqueID + '.offsetWidth + \'px\'');
			setExpression('height', elm.uniqueID + '.offsetHeight + \'px\'');
	        
			setExpression('top', elm.uniqueID + '.style.top');
			setExpression('left', elm.uniqueID + '.style.left');
	        
			setExpression('display', elm.uniqueID + '.style.display');
		}
	}
	
	if (!imgUrl)
		imgUrl = 'WebResource.axd?d=t9VVFtHBqdP1tdTlZ-ZdNyOuXy2A9Yf3xn7NQ88nXNvIMa3UspTwlJV22qvELszYtGMKL4UMm35gK91hDV-NJw2&t=633912245744789735'
		
	if (!imgUrl || imgUrl == '')
		imgUrl = 'javascript: \'<HTML></HTML>\'';
		
	iframe.src = imgUrl;
    
	document.body.appendChild(iframe);
	
	return iframe;
}

Sys.UI.DomElement.swapNode = function (n1, n2) 
{
    var e = Function._validateParams(arguments, [
        {name: "n1", domElement: true},
        {name: "n2", domElement: true}
    ]);
    if (e) throw e;

	if (n1.swapNode)
	{
		n1.swapNode(n2);
	}
	else
	{
		var tr = document.createElement('tr');
		n1.parentNode.replaceChild(tr, n1);
		n2.parentNode.replaceChild(n1, n2);
		tr.parentNode.replaceChild(n2, tr);
		delete tr;
	}
}


$getMousePos = Sys.UI.DomElement.getMousePos = function Sys$UI$DomElement$getMousePos(evt) 
{
     var e = Function._validateParams(arguments, [
        {name: "evt", mayBeNull: false}
    ]);
    
    if (e) throw e;
    
    if (evt.rawEvent)
        evt = evt.rawEvent;
    
    var scrOfX = 0, scrOfY = 0;
    var posX = 0, posY = 0;
    
    if( evt.pageX || evt.pageY ) 
    {
        posX = evt.pageX;
        posY = evt.pageY;
    } 
    else
    {
        posX = evt.clientX;
        posY = evt.clientY;
        
        if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ) 
        {
            scrOfY = document.body.scrollTop;
            scrOfX = document.body.scrollLeft;
        } 
        else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) 
        {
            scrOfY = document.documentElement.scrollTop;
            scrOfX = document.documentElement.scrollLeft;
        }
    }

    return new Sys.UI.Point(posX + scrOfX, posY + scrOfY);
}


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

String.prototype.escapeHTML = function String$prototype$escapeHTML() 
{
	var div = document.createElement('div');
	var text = document.createTextNode(this);
	div.appendChild(text);
	return div.innerHTML;
}

String.prototype.unescapeHTML = function String$prototype$unescapeHTML() 
{
	var div = document.createElement('div');
	div.innerHTML = this.stripTags();
	return div.childNodes[0].nodeValue;
}


function resolveUrl(url, baseResUrl)
{
	if (!url || url.indexOf('~/') !== 0) 
		return url;

	if (!baseResUrl)
		baseResUrl = '/';
	else if (baseResUrl.lastIndexOf('/') <  baseResUrl.length - 1)
		baseResUrl += '/';
		
	return baseResUrl + url.substr(2);
}

function resolveImageUrl(url, baseResUrl, baseImageUrl)
{
	if (!url || !baseImageUrl || url.charAt(0) == '/' || url.charAt(0) == '~') 
		return resolveUrl(url, baseResUrl);

	if (baseImageUrl.lastIndexOf('/') <  baseImageUrl.length - 1)
		baseImageUrl += '/';
		
	return resolveUrl(baseImageUrl + url, baseResUrl);
}


if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();